ridley 0.12.4 → 1.0.0.rc1

data/Gemfile

@@ -45,5 +45,5 @@ group :test do
   gem 'fuubar'
   gem 'json_spec'
   gem 'webmock'
-  gem 'chef-zero', '~> 1.1.1'
+  gem 'chef-zero', '~> 1.1.3'
 end

data/lib/ridley.rb

@@ -16,15 +16,15 @@ module Ridley
   CHEF_VERSION = '11.4.0'.freeze
 
   require_relative 'ridley/mixin'
-  require_relative 'ridley/bootstrap_bindings'
-  require_relative 'ridley/bootstrapper'
+  require_relative 'ridley/logging'
+  require_relative 'ridley/bootstrap_context'
   require_relative 'ridley/chef_object'
   require_relative 'ridley/chef_objects'
   require_relative 'ridley/client'
   require_relative 'ridley/connection'
   require_relative 'ridley/chef'
+  require_relative 'ridley/host_commander'
   require_relative 'ridley/host_connector'
-  require_relative 'ridley/logging'
   require_relative 'ridley/middleware'
   require_relative 'ridley/resource'
   require_relative 'ridley/resources'

data/lib/ridley/bootstrap_context.rb

@@ -0,0 +1,100 @@
+require 'erubis'
+
+module Ridley
+  module BootstrapContext
+    class Base
+      class << self
+        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
+      end
+
+      attr_reader :template_file
+      attr_reader :bootstrap_proxy
+      attr_reader :chef_version
+      attr_reader :validator_path
+      attr_reader :encrypted_data_bag_secret
+      attr_reader :server_url
+      attr_reader :validator_client
+      attr_reader :node_name
+      attr_reader :attributes
+      attr_reader :run_list
+      attr_reader :environment
+      attr_reader :hints
+
+      def initialize(options = {})
+        options = options.reverse_merge(
+          validator_client: "chef-validator",
+          attributes: Hash.new,
+          run_list: Array.new,
+          environment: "_default",
+          sudo: true,
+          hints: Hash.new,
+          chef_version: "latest"
+        )
+        options[:template] ||= default_template
+        self.class.validate_options(options)
+
+        @template_file             = options[:template]
+        @bootstrap_proxy           = options[:bootstrap_proxy]
+        @chef_version              = options[:chef_version]
+        @sudo                      = options[:sudo]
+        @validator_path            = options[:validator_path]
+        @encrypted_data_bag_secret = options[:encrypted_data_bag_secret]
+        @hints                     = options[:hints]
+        @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 bootstrap_command
+        raise RuntimeError, "abstract function: must be implemented on includer"
+      end
+
+      # @return [String]
+      def default_template
+        raise RuntimeError, "abstract function: must be implemented on includer"
+      end
+
+      # @return [Pathname]
+      def templates_path
+        Ridley.root.join('bootstrappers')
+      end
+
+      # @return [String]
+      def first_boot
+        JSON.fast_generate(attributes.merge(run_list: run_list))
+      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
+end
+
+Dir["#{File.dirname(__FILE__)}/bootstrap_context/*.rb"].sort.each do |path|
+  require_relative "bootstrap_context/#{File.basename(path, '.rb')}"
+end

data/lib/ridley/bootstrap_context/unix.rb

@@ -0,0 +1,74 @@
+module Ridley
+  module BootstrapContext
+    # 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 SSH is the best way to connect to the node.
+    #
+    # @author Kyle Allan <kallan@riotgames.com>
+    class Unix < BootstrapContext::Base
+      attr_reader :sudo
+
+      # @option options [Boolean] :sudo (true)
+      #   bootstrap with sudo (default: true)
+      def initialize(options = {})
+        options = options.reverse_merge(sudo: true)
+        @sudo   = options[:sudo]
+        super(options)
+      end
+
+      # @return [String]
+      def boot_command
+        cmd = template.evaluate(self)
+
+        if sudo
+          cmd = "sudo #{cmd}"
+        end
+
+        cmd
+      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
+
+        body
+      end
+
+      # @return [String]
+      def bootstrap_directory
+        "/etc/chef"
+      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('unix_omnibus.erb').to_s
+      end
+    end
+  end
+end

data/lib/ridley/bootstrap_context/windows.rb

@@ -0,0 +1,120 @@
+module Ridley
+  module BootstrapContext
+    # 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 Windows < BootstrapContext::Base
+      # @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(super)
+      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(super)
+      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
+end

data/lib/ridley/chef_objects/node_object.rb

@@ -144,14 +144,17 @@ module Ridley
     # @option options [Hash] :attributes
     #   attributes of normal precedence to merge
     #
-    # @return [Ridley::NodeResource]
+    # @return [Ridley::NodeObject]
     def merge_data(options = {})
-      unless options[:run_list].nil?
-        self.run_list = (self.run_list + Array(options[:run_list])).uniq
+      new_run_list   = Array(options[:run_list])
+      new_attributes = options[:attributes]
+
+      unless new_run_list.empty?
+        self.run_list = self.run_list | new_run_list
       end
 
-      unless options[:attributes].nil?
-        self.normal = self.normal.deep_merge(options[:attributes])
+      unless new_attributes.nil?
+        self.normal = self.normal.deep_merge(new_attributes)
       end
 
       self

data/lib/ridley/host_commander.rb

@@ -0,0 +1,207 @@
+require 'socket'
+require 'timeout'
+
+module Ridley
+  class ConnectorSupervisor < ::Celluloid::SupervisionGroup
+    # @param [Celluloid::Registry] registry
+    def initialize(registry)
+      super(registry)
+      supervise_as :ssh, HostConnector::SSH
+      supervise_as :winrm, HostConnector::WinRM
+    end
+  end
+
+  class HostCommander
+    class << self
+      # Checks to see if the given port is open for TCP connections
+      # on the given host.
+      #
+      # @param [String] host
+      #   the host to attempt to connect to
+      # @param [Fixnum] port
+      #   the port to attempt to connect on
+      # @param [Float] timeout
+      #   the number of seconds to wait (default: {PORT_CHECK_TIMEOUT})
+      #
+      # @return [Boolean]
+      def connector_port_open?(host, port, timeout = nil)
+        Timeout.timeout(timeout || PORT_CHECK_TIMEOUT) { TCPSocket.new(host, port).close; true }
+      rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::EADDRNOTAVAIL => ex
+        false
+      end
+    end
+
+    include Celluloid
+    include Ridley::Logging
+
+    PORT_CHECK_TIMEOUT = 3
+
+    finalizer :finalize_callback
+
+    def initialize
+      @connector_registry   = Celluloid::Registry.new
+      @connector_supervisor = ConnectorSupervisor.new_link(@connector_registry)
+    end
+
+    # 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
+    # @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 = {})
+      execute(__method__, host, command, options)
+    end
+
+    # 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
+    # @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 = {})
+      execute(__method__, host, options)
+    end
+
+    # 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
+    # @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 = {})
+      execute(__method__, host, options)
+    end
+
+    # 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
+    #
+    # @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
+    # @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 = {})
+      execute(__method__, host, secret, options)
+    end
+
+    # 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
+    # @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 = {})
+      execute(__method__, host, command_lines, options)
+    end
+
+    private
+
+      def execute(method, host, *args)
+        options = args.last.is_a?(Hash) ? args.pop : Hash.new
+
+        connector_for(host, options).send(method, host, *args, options)
+      rescue Errors::HostConnectionError => ex
+        abort(ex)
+      end
+
+      # Finds and returns the best HostConnector for a given host
+      #
+      # @param [String] host
+      #   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
+      #
+      # @return [Symbol]
+      def connector_for(host, options = {})
+        options = options.reverse_merge(ssh: Hash.new, winrm: Hash.new)
+        options[:ssh][:port]   ||= HostConnector::SSH::DEFAULT_PORT
+        options[:winrm][:port] ||= HostConnector::WinRM::DEFAULT_PORT
+
+        if self.class.connector_port_open?(host, options[:winrm][:port])
+          options.delete(:ssh)
+          winrm
+        elsif self.class.connector_port_open?(host, options[:ssh][:port], options[:ssh][:timeout])
+          options.delete(:winrm)
+          ssh
+        else
+          raise Errors::HostConnectionError, "No connector ports open on '#{host}'"
+        end
+      end
+
+      def finalize_callback
+        @connector_supervisor.terminate if @connector_supervisor && @connector_supervisor.alive?
+      end
+
+      def ssh
+        @connector_registry[:ssh]
+      end
+
+      def winrm
+        @connector_registry[:winrm]
+      end
+  end
+end