ridley 0.9.1 → 0.10.0.rc1

data/lib/ridley/bootstrapper.rb

@@ -3,22 +3,10 @@ module Ridley
   class Bootstrapper
     autoload :Context, 'ridley/bootstrapper/context'
 
-    class << self
-      # @return [Pathname]
-      def templates_path
-        Ridley.root.join('bootstrappers')
-      end
-
-      # @return [String]
-      def default_template
-        templates_path.join('omnibus.erb').to_s
-      end
-    end
-
     include Celluloid
     include Celluloid::Logger
-
-    # @return [Array<String>]
+    
+    # @return  [Array<String>]
     attr_reader :hosts
 
     # @return [Array<Bootstrapper::Context>]
@@ -33,6 +21,10 @@ module Ridley
     #   * :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)
@@ -46,13 +38,13 @@ module Ridley
     #   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 (Ridley::CHEF_VERSION)
+    # @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')
+    # @option options [String] :template
     #   bootstrap template to use
     def initialize(hosts, options = {})
       @hosts         = Array(hosts).collect(&:to_s).uniq
@@ -64,23 +56,23 @@ module Ridley
       }.merge(@options[:ssh])
 
       @options[:sudo] = @options[:ssh][:sudo]
-
       @contexts = @hosts.collect do |host|
-        Context.new(host, options)
+        Context.create(host, options)
       end
     end
 
-    # @return [SSH::ResponseSet]
+    # @return [HostConnector::ResponseSet]
     def run
       workers = Array.new
       futures = contexts.collect do |context|
         info "Running bootstrap command on #{context.host}"
 
-        workers << worker = SSH::Worker.new_link(self.options[:ssh].freeze)
-        worker.future.run(context.host, context.boot_command)
+        workers << worker = context.host_connector::Worker.new(context.host, self.options.freeze)
+
+        worker.future.run(context.template_binding.boot_command)
       end
 
-      SSH::ResponseSet.new.tap do |response_set|
+      HostConnector::ResponseSet.new.tap do |response_set|
         futures.each do |future|
           status, response = future.value
           response_set.add_response(response)

data/lib/ridley/bootstrapper/context.rb

@@ -5,185 +5,76 @@ module Ridley
     # @author Jamie Winsor <reset@riotgames.com>
     class Context
       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"
+        # @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_path (nil)
+        #   filepath on your host machine to 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
+        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
-        end
-
-        # A hash of default options to be used in the Context initializer
-        #
-        # @return [Hash]
-        def default_options
-          @default_options ||= {
-            validator_client: "chef-validator",
-            hints: Hash.new,
-            attributes: Hash.new,
-            run_list: Array.new,
-            chef_version: Ridley::CHEF_VERSION,
-            environment: "_default",
-            sudo: true,
-            template: Bootstrapper.default_template
-          }
+          new(host, host_connector, template_binding)
         end
       end
 
       # @return [String]
       attr_reader :host
-      # @return [String]
-      attr_reader :node_name
-      # @return [String]
-      attr_reader :server_url
-      # @return [String]
-      attr_reader :validator_client
-      # @return [String]
-      attr_reader :validator_path
-      # @return [String]
-      attr_reader :bootstrap_proxy
-      # @return [Hash]
-      attr_reader :hints
-      # @return [String]
-      attr_reader :chef_version
-      # @return [String]
-      attr_reader :environment
+      # @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
-      # @option options [String] :validator_path
-      #   filepath to the validator used to bootstrap the node (required)
-      # @option options [String] :node_name
-      # @option options [String] :server_url
-      # @option options [String] :validator_client
-      # @option options [String] :bootstrap_proxy
-      #   URL to a proxy server to bootstrap through (default: nil)
-      # @option options [String] :encrypted_data_bag_secret_path
-      #   filepath on your host machine to your organizations encrypted data bag secret (default: nil)
-      # @option options [Hash] :hints
-      #   a hash of Ohai hints to place on the bootstrapped node (default: Hash.new)
-      # @option options [Hash] :attributes
-      #   a hash of attributes to use in the first Chef run (default: Hash.new)
-      # @option options [Array] :run_list
-      #   an initial run list to bootstrap with (default: Array.new)
-      # @option options [String] :chef_version
-      #   version of Chef to install on the node (default: {Ridley::CHEF_VERSION})
-      # @option options [String] :environment
-      #   environment to join the node to (default: '_default')
-      # @option options [Boolean] :sudo
-      #   bootstrap with sudo (default: true)
-      # @option options [String] :template
-      #   bootstrap template to use (default: omnibus)
-      def initialize(host, options = {})
-        options = self.class.default_options.merge(options)
-        self.class.validate_options(options)
-
+      # @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
-        @server_url                     = options[:server_url]
-        @validator_path                 = options[:validator_path]
-        @node_name                      = options[:node_name]
-        @validator_client               = options[:validator_client]
-        @bootstrap_proxy                = options[:bootstrap_proxy]
-        @encrypted_data_bag_secret_path = options[:encrypted_data_bag_secret_path]
-        @hints                          = options[:hints]
-        @attributes                     = options[:attributes]
-        @run_list                       = options[:run_list]
-        @chef_version                   = options[:chef_version]
-        @environment                    = options[:environment]
-        @sudo                           = options[:sudo]
-        @template_file                  = options[:template]
-      end
-
-      # @return [String]
-      def boot_command
-        cmd = template.evaluate(self)
-
-        if sudo
-          cmd = "sudo #{cmd}"
-        end
-
-        cmd
+        @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
-
-      # @return [String]
-      def chef_run
-        "chef-client -j /etc/chef/first-boot.json -E #{environment}"
-      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 "/etc/chef/encrypted_data_bag_secret"\n}
-        end
-
-        body
-      end
-
-      # @return [String]
-      def first_boot
-        MultiJson.encode 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
-
-      # @raise [Ridley::Errors::EncryptedDataBagSecretNotFound]
-      #
-      # @return [String, nil]
-      def encrypted_data_bag_secret
-        return nil if encrypted_data_bag_secret_path.nil?
-
-        IO.read(encrypted_data_bag_secret_path).chomp
-      rescue Errno::ENOENT => encrypted_data_bag_secret
-        raise Errors::EncryptedDataBagSecretNotFound, "Error bootstrapping: Encrypted data bag secret provided but not found at '#{encrypted_data_bag_secret_path}'"
-      end
-
-      private
-
-        attr_reader :sudo
-        attr_reader :template_file
-        attr_reader :encrypted_data_bag_secret_path
-        attr_reader :validator_path
-        attr_reader :run_list
-        attr_reader :attributes
-
-        # @return [Erubis::Eruby]
-        def template
-          Erubis::Eruby.new(IO.read(template_file).chomp)
-        end
     end
   end
 end

data/lib/ridley/chef.rb

@@ -5,7 +5,6 @@ module Ridley
   # site, and Chef Cookbooks
   module Chef
     autoload :Cookbook, 'ridley/chef/cookbook'
-    autoload :Chefignore, 'ridley/chef/chefignore'
     autoload :Digester, 'ridley/chef/digester'
   end
 end

data/lib/ridley/chef/cookbook.rb

@@ -96,7 +96,6 @@ module Ridley::Chef
         root_files: Array.new
       )
       @frozen        = false
-      @chefignore    = Ridley::Chef::Chefignore.new(@path)
 
       load_files
     end
@@ -208,12 +207,7 @@ module Ridley::Chef
 
     private
 
-      # @return [Array]
       attr_reader :files
-      # @return [Ridley::Chef::Chefignore]
-      attr_reader :chefignore
-
-      def_delegator :chefignore, :ignored?
 
       def load_files
         load_shallow(:recipes, 'recipes', '*.rb')
@@ -231,7 +225,6 @@ module Ridley::Chef
         [].tap do |files|
           Dir.glob(path.join('*'), File::FNM_DOTMATCH).each do |file|
             next if File.directory?(file)
-            next if ignored?(file)
             @files << file
             @manifest[:root_files] << file_metadata(:root_files, file)
           end
@@ -243,7 +236,6 @@ module Ridley::Chef
           file_spec = path.join(category_dir, '**', glob)
           Dir.glob(file_spec, File::FNM_DOTMATCH).each do |file|
             next if File.directory?(file)
-            next if ignored?(file)
             @files << file
             @manifest[category] << file_metadata(category, file)
           end
@@ -253,7 +245,6 @@ module Ridley::Chef
       def load_shallow(category, *path_glob)
         [].tap do |files|
           Dir[path.join(*path_glob)].each do |file|
-            next if ignored?(file)
             @files << file
             @manifest[category] << file_metadata(category, file)
           end

data/lib/ridley/client.rb

@@ -77,6 +77,8 @@ module Ridley
     attr_accessor :validator_path
     attr_accessor :encrypted_data_bag_secret_path
     attr_accessor :ssh
+    attr_accessor :winrm
+    attr_accessor :chef_version
 
     # @option options [String] :server_url
     #   URL to the Chef API
@@ -93,6 +95,12 @@ module Ridley
     #   * :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
     #   * :sudo (Boolean) [true] bootstrap with sudo
+    # @option options [Hash] :winrm (Hash.new)
+    #   * :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] :chef_version
+    #   the version of Chef to use when bootstrapping
     # @option options [Hash] :params
     #   URI query unencoded key/value pairs
     # @option options [Hash] :headers
@@ -111,11 +119,14 @@ module Ridley
       super()
 
       @options = options.reverse_merge(
-        ssh: Hash.new
+        ssh: Hash.new,
+        winrm: Hash.new
       ).deep_symbolize_keys
       self.class.validate_options(@options)
 
       @ssh              = @options[:ssh]
+      @winrm            = @options[:winrm]
+      @chef_version     = @options[:chef_version]
       @validator_client = @options[:validator_client]
 
       @options[:client_key] = File.expand_path(@options[:client_key])

data/lib/ridley/errors.rb

@@ -38,6 +38,7 @@ module Ridley
     class BootstrapError < RidleyError; end
     class ClientKeyFileNotFound < BootstrapError; end
     class EncryptedDataBagSecretNotFound < BootstrapError; end
+    class HostConnectionError < BootstrapError; end
 
     # Exception thrown when the maximum amount of requests is exceeded.
     class RedirectLimitReached < RidleyError

data/lib/ridley/host_connector.rb

@@ -0,0 +1,76 @@
+require 'socket'
+require 'timeout'
+
+module Ridley
+  # @author Kyle Allan <kallan@riotgames.com>
+  module HostConnector
+    autoload :Response, 'ridley/host_connector/response'
+    autoload :ResponseSet, 'ridley/host_connector/response_set'
+    autoload :SSH, 'ridley/host_connector/ssh'
+    autoload :WinRM, 'ridley/host_connector/winrm'
+
+    DEFAULT_SSH_PORT   = 22.freeze
+    DEFAULT_WINRM_PORT = 5985.freeze
+
+    class << self
+      # Finds and returns the best HostConnector for a given host
+      # 
+      # @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)
+      # @option options [Hash] :winrm
+      #   * :port (Fixnum) the winrm port to connect on the node the bootstrap will be performed on (5985)
+      # 
+      # @return [Ridley::HostConnector] a class under Ridley::HostConnector
+      def best_connector_for(host, options = {})
+        ssh_port, winrm_port = parse_port_options(options)
+        if connector_port_open?(host, ssh_port)
+          Ridley::HostConnector::SSH
+        elsif connector_port_open?(host, winrm_port)
+          Ridley::HostConnector::WinRM
+        else
+          raise Ridley::Errors::HostConnectionError, "No available connection method available on #{host}."
+        end
+      end
+
+      # Checks to see if the given port is open for TCP connections
+      # on the given host.
+      #
+      # @param  host [String]
+      #   the host to attempt to connect to
+      # @param  port [Fixnum]
+      #   the port to attempt to connect on
+      # 
+      # @return [Boolean]
+      def connector_port_open?(host, port)
+        Timeout::timeout(1) do
+          begin
+            socket = TCPSocket.new(host, port)
+            socket.close
+            true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            false
+          end
+        end
+      rescue Timeout::Error
+        false
+      end
+
+      # Parses the options Hash and returns an array of
+      # [SSH_PORT, WINRM_PORT] used 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)
+      # @option options [Hash] :winrm
+      #   * :port (Fixnum) the winrm port to connect on the node the bootstrap will be performed on (5985)
+      # 
+      # @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]
+      end
+    end
+  end
+end