Class: Ridley::HostConnector::SSH

Inherits:
Base
  • Object
show all
Defined in:
lib/ridley-connectors/host_connector/ssh.rb

Constant Summary collapse

DEFAULT_PORT = 
22
EMBEDDED_RUBY_PATH = 
'/opt/chef/embedded/bin/ruby'.freeze

Instance Method Summary collapse

Instance Method Details

#bootstrap(host, options = {}) ⇒ HostConnector::Response

Bootstrap a node

Parameters:

  • host (String) —

    the host to perform the action on

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :ssh (Hash) —

    • :user (String) a shell user that will login to each node and perform the bootstrap command on

    • :password (String) the password for the shell user that will perform the bootstrap

    • :keys (Array, String) an array of key(s) to authenticate the ssh user with instead of a password

    • :timeout (Float) timeout value for SSH bootstrap (5.0)

    • :sudo (Boolean) run as sudo

Returns:



95
96
97
98
99
100
101
102
103
 
# File 'lib/ridley-connectors/host_connector/ssh.rb', line 95

def bootstrap(host, options = {})
  options = options.reverse_merge(ssh: Hash.new)
  options[:ssh].reverse_merge!(sudo: true, timeout: 5.0)
  context = BootstrapContext::Unix.new(options)

  log.info "Bootstrapping host: #{host}"
  log.filter_param(context.boot_command)
  run(host, context.boot_command, options)
end

#chef_client(host, options = {}) ⇒ HostConnector::Response

Perform a chef client run on a node

Parameters:

  • host (String) —

    the host to perform the action on

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :ssh (Hash) —

    • :user (String) a shell user that will login to each node and perform the bootstrap command on

    • :password (String) the password for the shell user that will perform the bootstrap

    • :keys (Array, String) an array of key(s) to authenticate the ssh user with instead of a password

    • :timeout (Float) timeout value for SSH bootstrap (5.0)

    • :sudo (Boolean) run as sudo

Returns:



118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/ridley-connectors/host_connector/ssh.rb', line 118

def chef_client(host, options = {})
  log_level = case log.level
    when 0
      "debug"
    when 1
      "info"
    when 2
      "warn"
    else
      "info"
    end
  run(host, "chef-client -l #{log_level}", options)
end

#put_secret(host, secret, options = {}) ⇒ HostConnector::Response

Write your encrypted data bag secret on a node

Parameters:

  • host (String) —

    the host to perform the action on

  • secret (String) —

    your organization’s encrypted data bag secret

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :ssh (Hash) —

    • :user (String) a shell user that will login to each node and perform the bootstrap command on

    • :password (String) the password for the shell user that will perform the bootstrap

    • :keys (Array, String) an array of key(s) to authenticate the ssh user with instead of a password

    • :timeout (Float) timeout value for SSH bootstrap (5.0)

    • :sudo (Boolean) run as sudo

Returns:



147
148
149
150
151
 
# File 'lib/ridley-connectors/host_connector/ssh.rb', line 147

def put_secret(host, secret, options = {})
  log.filter_param(secret)
  cmd = "echo '#{secret}' > /etc/chef/encrypted_data_bag_secret; chmod 0600 /etc/chef/encrypted_data_bag_secret"
  run(host, cmd, options)
end

#ruby_script(host, command_lines, options = {}) ⇒ HostConnector::Response

Execute line(s) of Ruby code on a node using Chef’s embedded Ruby

Parameters:

  • host (String) —

    the host to perform the action on

  • command_lines (Array<String>) —

    An Array of lines of the command to be executed

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :ssh (Hash) —

    • :user (String) a shell user that will login to each node and perform the bootstrap command on

    • :password (String) the password for the shell user that will perform the bootstrap

    • :keys (Array, String) an array of key(s) to authenticate the ssh user with instead of a password

    • :timeout (Float) timeout value for SSH bootstrap (5.0)

    • :sudo (Boolean) run as sudo

Returns:



168
169
170
 
# File 'lib/ridley-connectors/host_connector/ssh.rb', line 168

def ruby_script(host, command_lines, options = {})
  run(host, "#{EMBEDDED_RUBY_PATH} -e \"#{command_lines.join(';')}\"", options)
end

#run(host, command, options = {}) ⇒ HostConnector::Response

Execute a shell command on a node

Parameters:

  • host (String) —

    the host to perform the action on

  • command (String)
  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :ssh (Hash) —

    • :user (String) a shell user that will login to each node and perform the bootstrap command on

    • :password (String) the password for the shell user that will perform the bootstrap

    • :keys (Array, String) an array of key(s) to authenticate the ssh user with instead of a password

    • :timeout (Float) timeout value for SSH bootstrap (5.0)

    • :sudo (Boolean) run as sudo

Returns:



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/ridley-connectors/host_connector/ssh.rb', line 23

def run(host, command, options = {})
  options = options.reverse_merge(ssh: Hash.new)
  options[:ssh].reverse_merge!(port: DEFAULT_PORT, paranoid: false, sudo: false)

  command = "sudo -E #{command}" if options[:ssh][:sudo]

  Ridley::HostConnector::Response.new(host).tap do |response|
    begin
      log.info "Running SSH command: '#{command}' on: '#{host}' as: '#{options[:ssh][:user]}'"

      defer {
        Net::SSH.start(host, options[:ssh][:user], options[:ssh].slice(*Net::SSH::VALID_OPTIONS)) do |ssh|
          ssh.open_channel do |channel|
            if options[:sudo]
              channel.request_pty do |channel, success|
                unless success
                  raise "Could not aquire pty: A pty is required for running sudo commands."
                end

                channel_exec(channel, command, host, response)
              end
            else
              channel_exec(channel, command, host, response)
            end
          end
          ssh.loop
        end
      }
    rescue Net::SSH::AuthenticationFailed => ex
      response.exit_code = -1
      response.stderr    = "Authentication failure for user #{ex}"
    rescue Net::SSH::ConnectionTimeout, Timeout::Error
      response.exit_code = -1
      response.stderr    = "Connection timed out"
    rescue SocketError, Errno::EHOSTUNREACH
      response.exit_code = -1
      response.stderr    = "Host unreachable"
    rescue Errno::ECONNREFUSED
      response.exit_code = -1
      response.stderr    = "Connection refused"
    rescue Net::SSH::Exception => ex
      response.exit_code = -1
      response.stderr    = ex.inspect
    rescue => ex
      response.exit_code = -1
      response.stderr    = "An unknown error occurred: #{ex.class} - #{ex.message}"
    end

    case response.exit_code
    when 0
      log.info "Successfully ran SSH command on: '#{host}' as: '#{options[:ssh][:user]}'"
    when -1
      log.info "Failed to run SSH command on: '#{host}' as: '#{options[:ssh][:user]}'"
    else
      log.info "Successfully ran SSH command on: '#{host}' as: '#{options[:ssh][:user]}' but it failed"
    end
  end
end

#uninstall_chef(host, options = {}) ⇒ HostConnector::Response

Uninstall Chef from a node

Parameters:

  • host (String) —

    the host to perform the action on

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :skip_chef (Boolena) — default: false —

    skip removal of the Chef package and the contents of the installation directory. Setting this to true will only remove any data and configurations generated by running Chef client.

  • :ssh (Hash) —

    • :user (String) a shell user that will login to each node and perform the bootstrap command on

    • :password (String) the password for the shell user that will perform the bootstrap

    • :keys (Array, String) an array of key(s) to authenticate the ssh user with instead of a password

    • :timeout (Float) timeout value for SSH bootstrap (5.0)

    • :sudo (Boolean) run as sudo (true)

Returns:



189
190
191
192
193
194
195
 
# File 'lib/ridley-connectors/host_connector/ssh.rb', line 189

def uninstall_chef(host, options = {})
  options = options.reverse_merge(ssh: Hash.new)
  options[:ssh].reverse_merge!(sudo: true, timeout: 5.0)

  log.info "Uninstalling Chef from host: #{host}"
  run(host, CommandContext::UnixUninstall.command(options), options)
end

#update_omnibus(host, options = {}) ⇒ HostConnector::Response

Update a node’s Omnibus installation of Chef

Parameters:

  • host (String) —

    the host to perform the action on

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :chef_version (String) —

    the version of Chef to install on the node

  • :prerelease (Boolean) —

    install a prerelease version of Chef

  • :direct_url (String) —

    a url pointing directly to a Chef package to install

  • :ssh (Hash) —

    • :user (String) a shell user that will login to each node and perform the bootstrap command on

    • :password (String) the password for the shell user that will perform the bootstrap

    • :keys (Array, String) an array of key(s) to authenticate the ssh user with instead of a password

    • :timeout (Float) timeout value for SSH bootstrap (5.0)

    • :sudo (Boolean) run as sudo (true)

  • :winrm (Hash) —

    • :user (String) a user that will login to each node and perform the bootstrap command on

    • :password (String) the password for the user that will perform the bootstrap (required)

    • :port (Fixnum) the winrm port to connect on the node the bootstrap will be performed on (5985)

Returns:



220
221
222
223
224
225
226
 
# File 'lib/ridley-connectors/host_connector/ssh.rb', line 220

def update_omnibus(host, options = {})
  options = options.reverse_merge(ssh: Hash.new)
  options[:ssh].reverse_merge!(sudo: true, timeout: 5.0)

  log.info "Updating Omnibus installation on host: #{host}"
  run(host, CommandContext::UnixUpdateOmnibus.command(options), options)
end