ridley 0.12.4 → 1.0.0.rc1

data/lib/ridley/bootstrap_bindings/windows_template_binding.rb

@@ -1,163 +0,0 @@
-module Ridley
-  # Represents a binding that will be evaluated as an ERB template. When bootstrapping
-  # nodes, an instance of this class represents the customizable and necessary configurations
-  # needed by the Host in order to install and connect to Chef. By default, this class will be used
-  # when WinRM is the best way to connect to the node.
-  #
-  # @author Kyle Allan <kallan@riotgames.com>
-  #
-  # Windows Specific code written by Seth Chisamore (<schisamo@opscode.com>) in knife-windows
-  # https://github.com/opscode/knife-windows/blob/3b8886ddcfb928ca0958cd05b22f8c3d78bee86e/lib/chef/knife/bootstrap/windows-chef-client-msi.erb
-  # https://github.com/opscode/knife-windows/blob/78d38bbed358ac20107fc2b5b427f4b5e52e5cb2/lib/chef/knife/core/windows_bootstrap_context.rb
-  class WindowsTemplateBinding
-    include Ridley::BootstrapBinding
-
-    attr_reader :template_file
-
-    # @option options [String] :validator_client
-    # @option options [String] :validator_path
-    #   filepath to the validator used to bootstrap the node (required)
-    # @option options [String] :bootstrap_proxy (nil)
-    #   URL to a proxy server to bootstrap through
-    # @option options [String] :encrypted_data_bag_secret
-    #   your organizations encrypted data bag secret
-    # @option options [Hash] :hints (Hash.new)
-    #   a hash of Ohai hints to place on the bootstrapped node
-    # @option options [Hash] :attributes (Hash.new)
-    #   a hash of attributes to use in the first Chef run
-    # @option options [Array] :run_list (Array.new)
-    #   an initial run list to bootstrap with
-    # @option options [String] :chef_version (nil)
-    #   version of Chef to install on the node
-    # @option options [String] :environment ('_default')
-    #   environment to join the node to
-    # @option options [Boolean] :sudo (true)
-    #   bootstrap with sudo (default: true)
-    # @option options [String] :template ('windows_omnibus')
-    #   bootstrap template to use
-    def initialize(options)
-      options = self.class.default_options.merge(options)
-      options[:template] ||= default_template
-      self.class.validate_options(options)
-
-      @template_file             = options[:template]
-      @bootstrap_proxy           = options[:bootstrap_proxy]
-      @chef_version              = options[:chef_version] ? options[:chef_version] : "latest"
-      @validator_path            = options[:validator_path]
-      @encrypted_data_bag_secret = options[:encrypted_data_bag_secret]
-      @server_url                = options[:server_url]
-      @validator_client          = options[:validator_client]
-      @node_name                 = options[:node_name]
-      @attributes                = options[:attributes]
-      @run_list                  = options[:run_list]
-      @environment               = options[:environment]
-    end
-
-    # @return [String]
-    def boot_command
-      template.evaluate(self)
-    end
-
-    # @return [String]
-    def chef_config
-      body = <<-CONFIG
-log_level        :info
-log_location     STDOUT
-chef_server_url  "#{server_url}"
-validation_client_name "#{validator_client}"
-CONFIG
-
-      if node_name.present?
-        body << %Q{node_name "#{node_name}"\n}
-      else
-        body << "# Using default node name (fqdn)\n"
-      end
-
-      if bootstrap_proxy.present?
-        body << %Q{http_proxy        "#{bootstrap_proxy}"\n}
-        body << %Q{https_proxy       "#{bootstrap_proxy}"\n}
-      end
-
-      if encrypted_data_bag_secret.present?
-        body << %Q{encrypted_data_bag_secret '#{bootstrap_directory}\\encrypted_data_bag_secret'\n}
-      end
-
-      escape_and_echo(body)
-    end
-
-    # @return [String]
-    def bootstrap_directory
-      "C:\\chef"
-    end
-
-    # @return [String]
-    def validation_key
-      escape_and_echo(IO.read(File.expand_path(validator_path)).chomp)
-    rescue Errno::ENOENT
-      raise Errors::ValidatorNotFound, "Error bootstrapping: Validator not found at '#{validator_path}'"
-    end
-
-    # @return [String]
-    def chef_run
-      "chef-client -j #{bootstrap_directory}\\first-boot.json -E #{environment}"
-    end
-
-    # @return [String]
-    def default_template
-      templates_path.join('windows_omnibus.erb').to_s
-    end
-
-    # @return [String]
-    def encrypted_data_bag_secret
-      return unless @encrypted_data_bag_secret
-
-      escape_and_echo(@encrypted_data_bag_secret)
-    end
-
-    # Implements a Powershell script that attempts a simple
-    # 'wget' to download the Chef msi
-    #
-    # @return [String]
-    def windows_wget_powershell
-      win_wget_ps = <<-WGET_PS
-param(
- [String] $remoteUrl,
- [String] $localPath
-)
-
-$webClient = new-object System.Net.WebClient;
-
-$webClient.DownloadFile($remoteUrl, $localPath);
-WGET_PS
-
-      escape_and_echo(win_wget_ps)
-    end
-
-    # @return [String]
-    def install_chef
-      'msiexec /qb /i "%LOCAL_DESTINATION_MSI_PATH%"'
-    end
-
-    # @return [String]
-    def first_boot
-      escape_and_echo(JSON.fast_generate(attributes.merge(run_list: run_list)))
-    end
-
-    # @return [String]
-    def set_path
-      "SET \"PATH=%PATH%;C:\\ruby\\bin;C:\\opscode\\chef\\bin;C:\\opscode\\chef\\embedded\\bin\"\n"
-    end
-
-    # @return [String]
-    def local_download_path
-      "%TEMP%\\chef-client-#{chef_version}.msi"
-    end
-
-    # escape WIN BATCH special chars
-    # and prefixes each line with an
-    # echo
-    def escape_and_echo(file_contents)
-      file_contents.gsub(/^(.*)$/, 'echo.\1').gsub(/([(<|>)^])/, '^\1')
-    end
-  end
-end

data/lib/ridley/bootstrapper.rb

@@ -1,89 +0,0 @@
-require_relative 'bootstrapper/context'
-require_relative 'logging'
-
-module Ridley
-  # @author Jamie Winsor <reset@riotgames.com>
-  class Bootstrapper
-    include Celluloid
-    include Ridley::Logging
-
-    # @return  [Array<String>]
-    attr_reader :hosts
-
-    # @return [Hash]
-    attr_reader :options
-
-    # @param [Array<#to_s>] hosts
-    # @option options [Hash] :ssh
-    #   * :user (String) a shell user that will login to each node and perform the bootstrap command on (required)
-    #   * :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 (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)
-    # @option options [String] :validator_client
-    # @option options [String] :validator_path
-    #   filepath to the validator used to bootstrap the node (required)
-    # @option options [String] :bootstrap_proxy (nil)
-    #   URL to a proxy server to bootstrap through
-    # @option options [String] :encrypted_data_bag_secret
-    #   your organizations encrypted data bag secret
-    # @option options [Hash] :hints (Hash.new)
-    #   a hash of Ohai hints to place on the bootstrapped node
-    # @option options [Hash] :attributes (Hash.new)
-    #   a hash of attributes to use in the first Chef run
-    # @option options [Array] :run_list (Array.new)
-    #   an initial run list to bootstrap with
-    # @option options [String] :chef_version (nil)
-    #   version of Chef to install on the node
-    # @option options [String] :environment ('_default')
-    #   environment to join the node to
-    # @option options [Boolean] :sudo (true)
-    #   bootstrap with sudo (default: true)
-    # @option options [String] :template
-    #   bootstrap template to use
-    def initialize(hosts, options = {})
-      @hosts         = Array(hosts).flatten.collect(&:to_s).uniq
-      @options       = options.dup
-      @options[:ssh] ||= Hash.new
-      @options[:ssh] = {
-        timeout: 5.0,
-        sudo: true
-      }.merge(@options[:ssh])
-
-      @options[:sudo] = @options[:ssh][:sudo]
-    end
-
-    # @raise [Errors::HostConnectionError] if a node is unreachable
-    #
-    # @return [Array<Bootstrapper::Context>]
-    def contexts
-      @contexts ||= @hosts.collect { |host| Context.create(host, options) }
-    end
-
-    # @raise [Errors::HostConnectionError] if a node is unreachable
-    #
-    # @return [HostConnector::ResponseSet]
-    def run
-      workers = Array.new
-      futures = contexts.collect do |context|
-        log.info { "Running bootstrap command on #{context.host}" }
-
-        workers << worker = context.host_connector::Worker.new(context.host, self.options.freeze)
-
-        worker.future.run(context.template_binding.boot_command)
-      end
-
-      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

data/lib/ridley/bootstrapper/context.rb

@@ -1,81 +0,0 @@
-require 'erubis'
-
-module Ridley
-  class Bootstrapper
-    # @author Jamie Winsor <reset@riotgames.com>
-    class Context
-      class << self
-        # @param [String] host
-        # @option options [Hash] :ssh
-        #   * :user (String) a shell user that will login to each node and perform the bootstrap command on (required)
-        #   * :password (String) the password for the shell user that will perform the bootstrap
-        #   * :port (Fixnum) the ssh port to connect on the node the bootstrap will be performed on (22)
-        #   * :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 (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)
-        # @option options [String] :validator_client
-        # @option options [String] :validator_path
-        #   filepath to the validator used to bootstrap the node (required)
-        # @option options [String] :bootstrap_proxy (nil)
-        #   URL to a proxy server to bootstrap through
-        # @option options [String] :encrypted_data_bag_secret
-        #   your organizations encrypted data bag secret
-        # @option options [Hash] :hints (Hash.new)
-        #   a hash of Ohai hints to place on the bootstrapped node
-        # @option options [Hash] :attributes (Hash.new)
-        #   a hash of attributes to use in the first Chef run
-        # @option options [Array] :run_list (Array.new)
-        #   an initial run list to bootstrap with
-        # @option options [String] :chef_version (nil)
-        #   version of Chef to install on the node
-        # @option options [String] :environment ('_default')
-        #   environment to join the node to
-        # @option options [Boolean] :sudo (true)
-        #   bootstrap with sudo (default: true)
-        # @option options [String] :template ('omnibus')
-        #   bootstrap template to use
-        #
-        # @raise [Errors::HostConnectionError] if a node is unreachable
-        def create(host, options = {})
-          host_connector = HostConnector.best_connector_for(host, options)
-          template_binding = case host_connector.to_s
-          when Ridley::HostConnector::SSH.to_s
-            Ridley::UnixTemplateBinding.new(options)
-          when Ridley::HostConnector::WinRM.to_s
-            Ridley::WindowsTemplateBinding.new(options)
-          else
-            raise Ridley::Errors::HostConnectionError, "Cannot find an appropriate Template Binding for an unknown connector."
-          end
-          new(host, host_connector, template_binding)
-        end
-      end
-
-      # @return [String]
-      attr_reader :host
-      # @return [Ridley::HostConnector]
-      attr_reader :host_connector
-      # @return [Ridley::Binding]
-      attr_reader :template_binding
-
-      # @param [String] host
-      #   name of the node as identified in Chef
-      # @param [Ridley::HostConnector] host_connector
-      #   either the SSH or WinRM Connector class
-      # @param [Ridley::Binding] template_binding
-      #   an instance of either the UnixTemplateBinding or WindowsTemplateBinding class
-      def initialize(host, host_connector, template_binding)
-        @host             = host
-        @host_connector   = host_connector
-        @template_binding = template_binding
-      end
-
-      # @return [String]
-      def clean_command
-        "rm /etc/chef/first-boot.json; rm /etc/chef/validation.pem"
-      end
-    end
-  end
-end

data/lib/ridley/host_connector/response_set.rb

@@ -1,98 +0,0 @@
-module Ridley
-  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 [HostConnector::ResponseSet] target
-        # @param [HostConnector::ResponseSet] other
-        #
-        # @return [HostConnector::ResponseSet]
-        def merge!(target, other)
-          if other.is_a?(self)
-            target.add_response(other.responses)
-          end
-
-          target
-        end
-      end
-
-      extend Forwardable
-      include Enumerable
-
-      attr_reader :failures
-      attr_reader :successes
-
-      def_delegator :responses, :each
-
-      def initialize(responses = Array.new)
-        @failures  = Array.new
-        @successes = Array.new
-
-        add_response Array(responses)
-      end
-
-      # @param [HostConnector::Response, Array<HostConnector::Response>] response
-      #
-      # @return [Array<HostConnector::Response>]
-      def add_response(response)
-        if response.is_a?(Array)
-          until response.empty?
-            add_response(response.pop)
-          end
-          return responses
-        end
-
-        response.error? ? add_failure(response) : add_success(response)
-        responses
-      end
-      alias_method :<<, :add_response
-
-      def responses
-        successes + failures
-      end
-
-      # Return true if the response set contains any errors
-      #
-      # @return [Boolean]
-      def has_errors?
-        self.failures.any?
-      end
-
-      # Merges the responses of another ResponseSet with self and returns
-      # a new instance of ResponseSet
-      #
-      # @param [Ridley::HostConnector::ResponseSet] other
-      #
-      # @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)
-      end
-
-      # Merges the respones of another ResponseSet with self and returns
-      # mutated self
-      #
-      # @param [Ridley::HostConnector::ResponseSet] other
-      #
-      # @return [self]
-      def merge!(other)
-        self.class.merge!(self, other)
-      end
-
-      private
-
-        # @param [HostConnector::Response] response
-        def add_failure(response)
-          self.failures << response
-        end
-
-        # @param [HostConnector::Response] response
-        def add_success(response)
-          self.successes << response
-        end
-    end
-  end
-end

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

@@ -1,135 +0,0 @@
-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
-
-        EMBEDDED_RUBY_PATH = '/opt/chef/embedded/bin/ruby'.freeze
-
-        # @param [Hash] options
-        def initialize(host, options = {})
-          options = options.deep_symbolize_keys
-          @options = options[:ssh] || Hash.new
-          @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
-
-        # Executes a chef-client command on the nodes
-        #
-        # @return [#run]
-        def chef_client
-          command = "chef-client"
-          if sudo
-            command = "sudo #{command}"
-          end
-
-          run(command)
-        end
-
-        # Writes the given encrypted data bag secret to the node
-        #
-        # @param [String] secret
-        #   your organization's encrypted data bag secret
-        #
-        # @return [#run]
-        def put_secret(secret)
-          command = "echo '#{secret}' > /etc/chef/encrypted_data_bag_secret; chmod 0600 /etc/chef/encrypted_data_bag_secret"
-          run(command)
-        end
-
-        # Executes a provided Ruby script in the embedded Ruby installation
-        #
-        # @param [Array<String>] command_lines
-        #   An Array of lines of the command to be executed
-        #
-        # @return [#run]
-        def ruby_script(command_lines)
-          command = "#{EMBEDDED_RUBY_PATH} -e \"#{command_lines.join(';')}\""
-          run(command)
-        end
-
-        private
-
-          attr_reader :runner
-      end
-    end
-  end
-end