ridley 0.12.4 → 1.0.0.rc1

data/lib/ridley/host_connector.rb

@@ -1,111 +1,73 @@
-require 'socket'
-require 'timeout'
-
 module Ridley
   # @author Kyle Allan <kallan@riotgames.com>
   module HostConnector
-    require_relative 'host_connector/response'
-    require_relative 'host_connector/response_set'
-    require_relative 'host_connector/ssh'
-    require_relative 'host_connector/winrm'
-
-    DEFAULT_SSH_PORT   = 22.freeze
-    DEFAULT_WINRM_PORT = 5985.freeze
+    class Base
+      include Celluloid
+      include Ridley::Logging
 
-    class << self
-      # Create a new connection worker for the given host. An SSH or WinRM connection will be returned
-      # depending on which ports are open on the target host.
+      # Execute a shell command on a node
       #
       # @param [String] host
-      #   host to create a connector for
+      #   the host to perform the action on
+      # @param [String] command
+      # @param [Hash] options
       #
-      # @option options [Hash] ssh
-      #   * :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 keys (or a single key) to authenticate the ssh user with instead of a password
-      #   * :timeout (Float) [5.0] timeout value for SSH bootstrap
-      # @option options [Hash] :winrm
-      #   * :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
-      #   * :port (Fixnum) the winrm port to connect on the node the bootstrap will be performed on
-      #
-      # @return [SSH::Worker, WinRM::Worker]
-      def new(host, options = {})
-        HostConnector.best_connector_for(host, options) do |host_connector|
-          host_connector::Worker.new(host, options)
-        end
+      # @return [HostConnector::Response]
+      def run(host, command, options = {})
+        raise RuntimeError, "abstract function: must be implemented on includer"
       end
 
-      # Finds and returns the best HostConnector for a given host
+      # Bootstrap a node
       #
-      # @param  host [String]
-      #   the host to attempt to connect to
-      # @option options [Hash] :ssh
-      #   * :port (Fixnum) the ssh port to connect on the node the bootstrap will be performed on (22)
-      #   * :timeout (Float) [5.0] timeout value for testing SSH connection
-      # @option options [Hash] :winrm
-      #   * :port (Fixnum) the winrm port to connect on the node the bootstrap will be performed on (5985)
-      # @param block [Proc]
-      #   an optional block that is yielded the best HostConnector
+      # @param [String] host
+      #   the host to perform the action on
+      # @param [Hash] options
       #
-      # @return [Ridley::HostConnector] a class under Ridley::HostConnector
-      def best_connector_for(host, options = {}, &block)
-        ssh_port, winrm_port = parse_port_options(options)
-        timeout = options[:ssh] && options[:ssh][:timeout]
-
-        if connector_port_open?(host, winrm_port)
-          host_connector = Ridley::HostConnector::WinRM
-        elsif connector_port_open?(host, ssh_port, timeout)
-          host_connector = Ridley::HostConnector::SSH
-        else
-          raise Ridley::Errors::HostConnectionError, "No available connection method available on #{host}."
-        end
-
-        if block_given?
-          yield host_connector
-        else
-          host_connector
-        end
+      # @return [HostConnector::Response]
+      def bootstrap(host, options = {})
+        raise RuntimeError, "abstract function: must be implemented on includer"
       end
 
-      # Checks to see if the given port is open for TCP connections
-      # on the given host.
+      # Perform a chef client run on a node
       #
-      # @param  host [String]
-      #   the host to attempt to connect to
-      # @param  port [Fixnum]
-      #   the port to attempt to connect on
-      # @param  timeout [Float]
-      #   the number of seconds to wait (default: 3)
+      # @param [String] host
+      #   the host to perform the action on
+      # @param [Hash] options
       #
-      # @return [Boolean]
-      def connector_port_open?(host, port, timeout = nil)
-        timeout ||= 3
-
-        Timeout::timeout(timeout) do
-          socket = TCPSocket.new(host, port)
-          socket.close
-        end
+      # @return [HostConnector::Response]
+      def chef_client(host, options = {})
+        raise RuntimeError, "abstract function: must be implemented on includer"
+      end
 
-        true
-      rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-        false
+      # Write your encrypted data bag secret on a node
+      #
+      # @param [String] host
+      #   the host to perform the action on
+      # @param [String] secret
+      #   your organization's encrypted data bag secret
+      # @param [Hash] options
+      #
+      # @return [HostConnector::Response]
+      def put_secret(host, secret, options = {})
+        raise RuntimeError, "abstract function: must be implemented on includer"
       end
 
-      # Parses the options Hash and returns an array of
-      # [SSH_PORT, WINRM_PORT] used to attempt to connect to.
+      # Execute line(s) of Ruby code on a node using Chef's embedded Ruby
       #
-      # @option options [Hash] :ssh
-      #   * :port (Fixnum) the ssh port to connect on the node the bootstrap will be performed on (22)
-      # @option options [Hash] :winrm
-      #   * :port (Fixnum) the winrm port to connect on the node the bootstrap will be performed on (5985)
+      # @param [String] host
+      #   the host to perform the action on
+      # @param [Array<String>] command_lines
+      #   An Array of lines of the command to be executed
+      # @param [Hash] options
       #
-      # @return [Array]
-      def parse_port_options(options)
-        ssh_port = options[:ssh][:port] if options[:ssh]
-        winrm_port = options[:winrm][:port] if options[:winrm]
-        [ssh_port || DEFAULT_SSH_PORT, winrm_port || DEFAULT_WINRM_PORT]
+      # @return [HostConnector::Response]
+      def ruby_script(host, command_lines, options = {})
+        raise RuntimeError, "abstract function: must be implemented on includer"
       end
     end
+
+    require_relative 'host_connector/response'
+    require_relative 'host_connector/ssh'
+    require_relative 'host_connector/winrm'
   end
 end

data/lib/ridley/host_connector/ssh.rb

@@ -3,56 +3,170 @@ require 'net/ssh'
 module Ridley
   module HostConnector
     # @author Jamie Winsor <reset@riotgames.com>
-    class SSH
-      require_relative 'ssh/worker'
-
-      class << self
-        # @param [Ridley::NodeObject, Array<Ridley::NodeObject>] nodes
-        # @param [Hash] options
-        def start(nodes, options = {}, &block)
-          runner = new(nodes, options)
-          result = yield runner
-          runner.terminate
-
-          result
-        ensure
-          runner.terminate if runner && runner.alive?
+    class SSH < HostConnector::Base
+      DEFAULT_PORT       = 22
+      EMBEDDED_RUBY_PATH = '/opt/chef/embedded/bin/ruby'.freeze
+
+      # Execute a shell command on a node
+      #
+      # @param [String] host
+      #   the host to perform the action on
+      # @param [String] command
+      #
+      # @option options [Hash] :ssh
+      #   * :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
+      #
+      # @return [HostConnector::Response]
+      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 #{command}" if options[:sudo]
+
+        Ridley::HostConnector::Response.new(host).tap do |response|
+          begin
+            log.info "Running SSH command: '#{command}' on: '#{host}' as: '#{options[:ssh][:user]}'"
+
+            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::Exception => ex
+            response.exit_code = -1
+            response.stderr    = ex.message
+            return response
+          end
+
+          case response.exit_code
+          when 0
+            log.info "Successfully ran 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
 
-      include Celluloid
-      include Celluloid::Logger
+      # Bootstrap a node
+      #
+      # @param [String] host
+      #   the host to perform the action on
+      #
+      # @option options [Hash] :ssh
+      #   * :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
+      #
+      # @return [HostConnector::Response]
+      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)
 
-      attr_reader :nodes
-      attr_reader :options
+        log.info "Bootstrapping host: #{host}"
+        run(host, context.boot_command, options)
+      end
 
-      # @param [Ridley::NodeObject, Array<Ridley::NodeObject>] nodes
-      # @param [Hash] options
-      #   @see Net::SSH
-      def initialize(nodes, options = {})
-        @nodes   = Array(nodes)
-        @options = options
+      # Perform a chef client run on a node
+      #
+      # @param [String] host
+      #   the host to perform the action on
+      #
+      # @option options [Hash] :ssh
+      #   * :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
+      #
+      # @return [HostConnector::Response]
+      def chef_client(host, options = {})
+        run(host, "chef-client", options)
       end
 
-      # @param [String] command
+      # Write your encrypted data bag secret on a node
       #
-      # @return [Array]
-      def run(command)
-        workers = Array.new
-        futures = self.nodes.collect do |node|
-          workers << worker = Worker.new(node.public_hostname, self.options.freeze)
-          worker.future.run(command)
-        end
+      # @param [String] host
+      #   the host to perform the action on
+      # @param [String] secret
+      #   your organization's encrypted data bag secret
+      #
+      # @option options [Hash] :ssh
+      #   * :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
+      #
+      # @return [HostConnector::Response]
+      def put_secret(host, secret, options = {})
+        cmd = "echo '#{secret}' > /etc/chef/encrypted_data_bag_secret; chmod 0600 /etc/chef/encrypted_data_bag_secret"
+        run(host, cmd, options)
+      end
 
-        ResponseSet.new.tap do |response_set|
-          futures.each do |future|
-            status, response = future.value
-            response_set.add_response(response)
+      # Execute line(s) of Ruby code on a node using Chef's embedded Ruby
+      #
+      # @param [String] host
+      #   the host to perform the action on
+      # @param [Array<String>] command_lines
+      #   An Array of lines of the command to be executed
+      #
+      # @option options [Hash] :ssh
+      #   * :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
+      #
+      # @return [HostConnector::Response]
+      def ruby_script(host, command_lines, options = {})
+        run(host, "#{EMBEDDED_RUBY_PATH} -e \"#{command_lines.join(';')}\"", options)
+      end
+
+      private
+
+        def channel_exec(channel, command, host, response)
+          channel.exec(command) do |ch, success|
+            unless success
+              raise "Channel execution failed while executing command #{command}"
+            end
+
+            channel.on_data do |ch, data|
+              response.stdout += data
+              log.info "[#{host}](SSH) #{data}" if data.present? and data != "\r\n"
+            end
+
+            channel.on_extended_data do |ch, type, data|
+              response.stderr += data
+              log.info "[#{host}](SSH) #{data}" if data.present? and data != "\r\n"
+            end
+
+            channel.on_request("exit-status") do |ch, data|
+              response.exit_code = data.read_long
+            end
+
+            channel.on_request("exit-signal") do |ch, data|
+              response.exit_signal = data.read_string
+            end
           end
         end
-      ensure
-        workers.map(&:terminate)
-      end
     end
   end
 end

data/lib/ridley/host_connector/winrm.rb

@@ -1,56 +1,181 @@
+require 'active_support/core_ext/kernel/reporting'
+# Silencing warnings because not all versions of GSSAPI support all of the GSSAPI methods
+# the gssapi gem attempts to attach to and these warnings are dumped to STDERR.
+silence_warnings do
+  require 'winrm'
+end
+
 module Ridley
   module HostConnector
     # @author Kyle Allan <kallan@riotgames.com>
-    class WinRM
+    class WinRM < HostConnector::Base
       require_relative 'winrm/command_uploader'
-      require_relative 'winrm/worker'
-
-      class << self
-        # @param [Ridley::NodeResource, Array<Ridley::NodeResource>] nodes
-        # @param [Hash] options
-        def start(nodes, options = {}, &block)
-          runner = new(nodes, options)
-          result = yield runner
-          runner.terminate
-
-          result
-        ensure
-          runner.terminate if runner && runner.alive?
+
+      DEFAULT_PORT       = 5985
+      EMBEDDED_RUBY_PATH = 'C:\opscode\chef\embedded\bin\ruby'.freeze
+
+      # Execute a shell command on a node
+      #
+      # @param [String] host
+      #   the host to perform the action on
+      # @param [String] command
+      #
+      # @option options [Hash] :winrm
+      #   * :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)
+      #
+      # @return [HostConnector::Response]
+      def run(host, command, options = {})
+        options = options.reverse_merge(winrm: Hash.new)
+        options[:winrm].reverse_merge!(port: DEFAULT_PORT)
+
+        command_uploaders = Array.new
+        user              = options[:winrm][:user]
+        password          = options[:winrm][:password]
+        port              = options[:winrm][:port]
+        connection        = winrm(host, port, options[:winrm].slice(:user, :password))
+
+        HostConnector::Response.new(host).tap do |response|
+          command_uploaders << command_uploader = CommandUploader.new(connection)
+          command = get_command(command, command_uploader)
+
+          begin
+            log.info "Running WinRM Command: '#{command}' on: '#{host}' as: '#{user}'"
+
+            output = connection.run_cmd(command) do |stdout, stderr|
+              if stdout
+                response.stdout += stdout
+                log.info "[#{host}](WinRM) #{stdout}"
+              end
+
+              if stderr
+                response.stderr += stderr unless stderr.nil?
+                log.info "[#{host}](WinRM) #{stdout}"
+              end
+            end
+
+            response.exit_code = output[:exitcode]
+          rescue ::WinRM::WinRMHTTPTransportError => ex
+            response.exit_code = -1
+            response.stderr    = ex.message
+            return response
+          end
+
+          case response.exit_code
+          when 0
+            log.info "Successfully ran WinRM command on: '#{host}' as: '#{user}'"
+          else
+            log.info "Successfully ran WinRM command on: '#{host}' as: '#{user}', but it failed"
+          end
+        end
+      ensure
+        command_uploaders.map(&:cleanup)
+      end
+
+      # Returns the command if it does not break the WinRM command length
+      # limit. Otherwise, we return an execution of the command as a batch file.
+      #
+      # @param  command [String]
+      #
+      # @return [String]
+      def get_command(command, command_uploader)
+        if command.length < CommandUploader::CHUNK_LIMIT
+          command
+        else
+          log.debug "Detected a command that was longer than #{CommandUploader::CHUNK_LIMIT} characters. " +
+            "Uploading command as a file to the host."
+          command_uploader.upload(command)
+          command_uploader.command
         end
       end
 
-      include Celluloid
-      include Celluloid::Logger
+      # Bootstrap a node
+      #
+      # @param [String] host
+      #   the host to perform the action on
+      #
+      # @option options [Hash] :winrm
+      #   * :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)
+      #
+      # @return [HostConnector::Response]
+      def bootstrap(host, options = {})
+        context = BootstrapContext::Windows.new(options)
 
-      attr_reader :nodes
-      attr_reader :options
+        log.info "Bootstrapping host: #{host}"
+        run(host, context.boot_command, options)
+      end
 
-      # @param [Ridley::NodeResource, Array<Ridley::NodeResource>] nodes
-      # @param [Hash] options
-      def initialize(nodes, options = {})
-        @nodes = Array(nodes)
-        @options = options
+      # Perform a chef client run on a node
+      #
+      # @param [String] host
+      #   the host to perform the action on
+      #
+      # @option options [Hash] :winrm
+      #   * :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)
+      #
+      # @return [HostConnector::Response]
+      def chef_client(host, options = {})
+        run(host, "chef-client", options)
       end
 
-      # @param [String] command
+      # Write your encrypted data bag secret on a node
       #
-      # @return [Array]
-      def run(command)
-        workers = Array.new
-        futures = self.nodes.collect do |node|
-          workers << worker = Worker.new(node.public_hostname, self.options.freeze)
-          worker.future.run(command)
-        end
+      # @param [String] host
+      #   the host to perform the action on
+      # @param [String] secret
+      #   your organization's encrypted data bag secret
+      #
+      # @option options [Hash] :winrm
+      #   * :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)
+      #
+      # @return [HostConnector::Response]
+      def put_secret(host, secret, options = {})
+        command = "echo #{secret} > C:\\chef\\encrypted_data_bag_secret"
+        run(host, command, options)
+      end
 
-        Ridley::HostConnector::ResponseSet.new.tap do |response_set|
-          futures.each do |future|
-            status, response = future.value
-            response_set.add_response(response)
-          end
-        end
-      ensure
-        workers.map(&:terminate)
+      # Execute line(s) of Ruby code on a node using Chef's embedded Ruby
+      #
+      # @param [String] host
+      #   the host to perform the action on
+      # @param [Array<String>] command_lines
+      #   An Array of lines of the command to be executed
+      #
+      # @option options [Hash] :winrm
+      #   * :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)
+      #
+      # @return [HostConnector::Response]
+      def ruby_script(host, command_lines, options = {})
+        command = "#{EMBEDDED_RUBY_PATH} -e \"#{command_lines.join(';')}\""
+        run(host, command, options)
       end
+
+      private
+
+        # @param [String] host
+        # @param [Integer] port
+        #
+        # @option options [String] :user
+        # @option options [String] :password
+        #
+        # @return [WinRM::WinRMWebService]
+        def winrm(host, port, options = {})
+          winrm_opts = { disable_sspi: true, basic_auth_only: true }
+          winrm_opts[:user] = options[:user]
+          winrm_opts[:pass] = options[:password]
+          client = ::WinRM::WinRMWebService.new("http://#{host}:#{port}/wsman", :plaintext, winrm_opts)
+          client.set_timeout(6000)
+          client
+        end
     end
   end
 end