ridley 0.9.1 → 0.10.0.rc1

data/lib/ridley/{ssh → host_connector}/response.rb

@@ -1,5 +1,5 @@
 module Ridley
-  class SSH
+  module HostConnector
     # @author Jamie Winsor <reset@riotgames.com>
     class Response
       attr_reader :host

data/lib/ridley/{ssh → host_connector}/response_set.rb

@@ -1,15 +1,15 @@
 module Ridley
-  class SSH
+  module HostConnector
     # @author Jamie Winsor <reset@riotgames.com>
     class ResponseSet
       class << self
         # Merges the responses of the other ResponseSet with the target ResponseSet
         # and returns the mutated target
         #
-        # @param [SSH::ResponseSet] target
-        # @param [SSH::ResponseSet] other
+        # @param [HostConnector::ResponseSet] target
+        # @param [HostConnector::ResponseSet] other
         #
-        # @return [SSH::ResponseSet]
+        # @return [HostConnector::ResponseSet]
         def merge!(target, other)
           if other.is_a?(self)
             target.add_response(other.responses)
@@ -34,9 +34,9 @@ module Ridley
         add_response Array(responses)
       end
 
-      # @param [SSH::Response, Array<SSH::Response>] response
+      # @param [HostConnector::Response, Array<HostConnector::Response>] response
       #
-      # @return [Array<SSH::Response>]
+      # @return [Array<HostConnector::Response>]
       def add_response(response)
         if response.is_a?(Array)
           until response.empty?
@@ -64,9 +64,9 @@ module Ridley
       # Merges the responses of another ResponseSet with self and returns
       # a new instance of ResponseSet
       #
-      # @param [Ridley::SSH::ResponseSet] other
+      # @param [Ridley::HostConnector::ResponseSet] other
       #
-      # @return [Ridley::SSH::ResponseSet]
+      # @return [Ridley::HostConnector::ResponseSet]
       def merge(other)
         target = self.class.new(self.responses) # Why the fuck can't I use #dup here?
         self.class.merge!(target, other)
@@ -75,7 +75,7 @@ module Ridley
       # Merges the respones of another ResponseSet with self and returns
       # mutated self
       #
-      # @param [Ridley::SSH::ResponseSet] other
+      # @param [Ridley::HostConnector::ResponseSet] other
       #
       # @return [self]
       def merge!(other)
@@ -84,12 +84,12 @@ module Ridley
 
       private
 
-        # @param [SSH::Response] response
+        # @param [HostConnector::Response] response
         def add_failure(response)
           self.failures << response
         end
 
-        # @param [SSH::Response] response
+        # @param [HostConnector::Response] response
         def add_success(response)
           self.successes << response
         end

data/lib/ridley/host_connector/ssh.rb

@@ -0,0 +1,58 @@
+require 'net/ssh'
+
+module Ridley
+  module HostConnector
+    # @author Jamie Winsor <reset@riotgames.com>
+    class SSH
+      autoload :Worker, 'ridley/host_connector/ssh/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?          
+        end
+      end
+
+      include Celluloid
+      include Celluloid::Logger
+
+      attr_reader :nodes
+      attr_reader :options
+
+      # @param [Ridley::NodeResource, Array<Ridley::NodeResource>] nodes
+      # @param [Hash] options
+      #   @see Net::SSH
+      def initialize(nodes, options = {})
+        @nodes   = Array(nodes)
+        @options = options
+      end
+
+      # @param [String] command
+      #
+      # @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
+
+        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)
+      end
+    end
+  end
+end

data/lib/ridley/host_connector/ssh/worker.rb

@@ -0,0 +1,99 @@
+module Ridley
+  module HostConnector
+    class SSH
+      # @author Jamie Winsor <reset@riotgames.com>
+      # @api private
+      class Worker
+        include Celluloid
+        include Celluloid::Logger
+
+        attr_reader :sudo
+        attr_reader :user
+        attr_reader :host
+        # @return [Hashie::Mash]
+        attr_reader :options
+        
+        # @param [Hash] options
+        def initialize(host, options = {})
+          @options = options.deep_symbolize_keys
+          @options = options[:ssh] if options[:ssh]
+          @host    = host
+          @sudo    = @options[:sudo]
+          @user    = @options[:user]
+
+          @options[:paranoid] = false
+        end
+
+        # @param [String] command
+        #
+        # @return [Array]
+        def run(command)
+          response = Ridley::HostConnector::Response.new(host)
+          debug "Running SSH command: '#{command}' on: '#{host}' as: '#{user}'"
+
+          channel_exec = ->(channel, command) do
+            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
+                info "NODE[#{host}] #{data}" if data.present? and data != "\r\n"
+              end
+
+              channel.on_extended_data do |ch, type, data|
+                response.stderr += data
+                info "NODE[#{host}] #{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
+
+          Net::SSH.start(host, user, options.slice(*Net::SSH::VALID_OPTIONS)) do |ssh|
+            ssh.open_channel do |channel|
+              if self.sudo
+                channel.request_pty do |channel, success|
+                  raise "Could not aquire pty: A pty is required for running sudo commands." unless success
+
+                  channel_exec.call(channel, command)
+                end
+              else
+                channel_exec.call(channel, command)
+              end
+            end
+
+            ssh.loop
+          end
+
+          case response.exit_code
+          when 0
+            debug "Successfully ran SSH command on: '#{host}' as: '#{user}'"
+            [ :ok, response ]
+          else
+            error "Successfully ran SSH command on: '#{host}' as: '#{user}', but it failed"
+            error response.stdout
+            [ :error, response ]
+          end
+        rescue => e
+          error "Failed to run SSH command on: '#{host}' as: '#{user}'"
+          error "#{e.class}: #{e.message}"
+          response.exit_code = -1
+          response.stderr = e.message
+          [ :error, response ]
+        end
+
+        private
+
+          attr_reader :runner
+      end
+    end
+  end
+end

data/lib/ridley/host_connector/winrm.rb

@@ -0,0 +1,55 @@
+module Ridley
+  module HostConnector
+    # @author Kyle Allan <kallan@riotgames.com>
+    class WinRM
+      autoload :Worker, 'ridley/host_connector/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?
+        end
+      end
+
+      include Celluloid
+      include Celluloid::Logger
+
+      attr_reader :nodes
+      attr_reader :options
+
+      # @param [Ridley::NodeResource, Array<Ridley::NodeResource>] nodes
+      # @param [Hash] options
+      def initialize(nodes, options = {})
+        @nodes = Array(nodes)
+        @options = options
+      end
+
+      # @param [String] command
+      #
+      # @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
+
+        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)
+      end
+    end
+  end
+end

data/lib/ridley/host_connector/winrm/worker.rb

@@ -0,0 +1,126 @@
+module Ridley
+  module HostConnector
+    class WinRM
+      # @author Kyle Allan <kallan@riotgames.com>
+      # @api private
+      class Worker
+        include Celluloid
+        include Celluloid::Logger
+
+        # @return [String]
+        attr_reader :user
+        # @return [String]
+        attr_reader :password
+        # @return [String]
+        attr_reader :host
+        # @return [Hash]
+        attr_reader :options
+        # @return [String]
+        attr_reader :winrm_endpoint
+
+        # @param  host [String]
+        #   the host the worker is going to work on
+        # @option options [Hash] :winrm
+        #   * :user (String) a user that will login to each node and perform the bootstrap command on (required)
+        #   * :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 (5985)
+        def initialize(host, options = {})
+          @options        = options.deep_symbolize_keys
+          @options        = options[:winrm] if options[:winrm]
+          @host           = host
+          @user           = @options[:user]
+          @password       = @options[:password]
+          @winrm_endpoint = "http://#{host}:#{winrm_port}/wsman"
+        end
+
+        def run(command)
+          command = get_command(command)
+
+          response = Ridley::HostConnector::Response.new(host)
+          debug "Running WinRM Command: '#{command}' on: '#{host}' as: '#{user}'"
+
+          output = winrm.run_cmd(command) do |stdout, stderr|
+            response.stdout += stdout unless stdout.nil?
+            response.stderr += stderr unless stderr.nil?
+          end
+          response.exit_code = output[:exitcode]
+
+          case response.exit_code
+          when 0
+            debug "Successfully ran WinRM command on: '#{host}' as: '#{user}'"
+            [ :ok, response ]
+          else
+            error "Successfully ran WinRM command on: '#{host}' as: '#{user}', but it failed"
+            error response.stdout
+            [ :error, response ]
+          end
+        rescue => e
+          error "Failed to run WinRM command on: '#{host}' as: '#{user}'"
+          error "#{e.class}: #{e.message}"
+          response.exit_code = -1
+          response.stderr = e.message
+          [ :error, response ]
+        end
+
+        # @return [::WinRM::WinRMWebService]
+        def winrm
+          ::WinRM::WinRMWebService.new(winrm_endpoint, :plaintext, user: user, pass: password, disable_sspi: true, basic_auth_only: true)
+        end
+
+        # @return [Fixnum]
+        def winrm_port
+          options[:port] || Ridley::HostConnector::DEFAULT_WINRM_PORT
+        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)
+          if command.length < 2047
+            command
+          else
+            debug "Detected a command that was longer than 2047 characters, uploading command as a file to the host."
+            upload_command_to_host(command)
+          end
+        end
+
+        private
+
+          # Uploads the command encoded as base64 to a file on the host
+          # and then uses Powershell to transform the base64 file into the
+          # command that was originally passed through.
+          #
+          # @param  command [String]
+          #
+          # @return [String] the command to execute the uploaded file
+          def upload_command_to_host(command)
+            base64_file = "winrm-upload-base64-#{Process.pid}-#{Time.now.to_i}"
+            base64_file_name = get_file_path(base64_file)
+
+            Base64.encode64(command).gsub("\n", '').chars.to_a.each_slice(8000 - base64_file_name.size) do |chunk|
+              out = winrm.run_cmd( "echo #{chunk.join} >> \"#{base64_file_name}\"" )
+            end
+
+            command_file = "winrm-upload-#{Process.pid}-#{Time.now.to_i}.bat"
+            command_file_name = get_file_path(command_file)
+            winrm.powershell <<-POWERSHELL
+              $base64_string = Get-Content \"#{base64_file_name}\"
+              $bytes  = [System.Convert]::FromBase64String($base64_string) 
+              $new_file = [System.IO.Path]::GetFullPath(\"#{command_file_name}\")
+              [System.IO.File]::WriteAllBytes($new_file,$bytes)
+            POWERSHELL
+
+            "cmd.exe /C #{command_file_name}"
+          end
+
+          # @return [String]
+          def get_file_path(file)
+            (winrm.run_cmd("echo %TEMP%\\#{file}"))[:data][0][:stdout].chomp
+          end
+      end
+    end
+  end
+end

data/lib/ridley/mixin/bootstrap_binding.rb

@@ -0,0 +1,88 @@
+require 'erubis'
+
+module Ridley
+  module BootstrapBinding
+    module ClassMethods
+      def validate_options(options = {})
+        if options[:server_url].nil?
+          raise Errors::ArgumentError, "A server_url is required for bootstrapping"
+        end
+
+        if options[:validator_path].nil?
+          raise Errors::ArgumentError, "A path to a validator is required for bootstrapping"
+        end
+      end
+
+      # A hash of default options to be used in the Context initializer
+      #
+      # @return [Hash]
+      def default_options
+        @default_options ||= {
+          validator_client: "chef-validator",
+          attributes: Hash.new,
+          run_list: Array.new,
+          environment: "_default",
+          sudo: true,
+          hints: Hash.new
+        }
+      end
+    end
+
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+
+    attr_reader :template_file
+    attr_reader :bootstrap_proxy
+    attr_reader :chef_version
+    attr_reader :default_options
+    attr_reader :validator_path
+    attr_reader :encrypted_data_bag_secret_path
+    attr_reader :server_url
+    attr_reader :validator_client
+    attr_reader :node_name
+    attr_reader :attributes
+    attr_reader :run_list
+    attr_reader :environment
+
+    # @return [Pathname]
+    def templates_path
+      Ridley.root.join('bootstrappers')
+    end
+
+    # @return [String]
+    def first_boot
+      MultiJson.encode attributes.merge(run_list: run_list)
+    end
+
+    # @raise [Ridley::Errors::EncryptedDataBagSecretNotFound]
+    #
+    # @return [String, nil]
+    def encrypted_data_bag_secret
+      return unless encrypted_data_bag_secret_path
+
+      IO.read(encrypted_data_bag_secret_path).chomp
+    rescue Errno::ENOENT
+      raise Errors::EncryptedDataBagSecretNotFound, "Error bootstrapping: Encrypted data bag secret provided but not found at '#{encrypted_data_bag_secret_path}'"
+    end
+
+    # The validation key to create a new client for the node
+    #
+    # @raise [Ridley::Errors::ValidatorNotFound]
+    #
+    # @return [String]
+    def validation_key
+      IO.read(File.expand_path(validator_path)).chomp
+    rescue Errno::ENOENT
+      raise Errors::ValidatorNotFound, "Error bootstrapping: Validator not found at '#{validator_path}'"
+    end
+
+    # @return [Erubis::Eruby]
+    def template
+      Erubis::Eruby.new(IO.read(template_file).chomp)
+    end
+
+  end
+end