chef-metal 0.10.2 → 0.11.beta

data/lib/chef_metal/chef_run_data.rb

@@ -1,19 +1,80 @@
-require 'cheffish/with_pattern'
 require 'chef/mixin/deep_merge'
+require 'cheffish/with_pattern'
+require 'cheffish/merged_config'
+require 'chef_metal/chef_machine_spec'
 
 module ChefMetal
   class ChefRunData
     extend Cheffish::WithPattern
-    with :provisioner
-    with :provisioner_options
+    def initialize(config)
+      @config = config
+      @drivers = {}
+    end
+
+    attr_reader :config
+    attr_reader :drivers
+
+    with :driver
+    with :machine_options
     with :machine_batch
 
-    def add_provisioner_options(options, &block)
-      if current_provisioner_options
-        with_provisioner_options(Chef::Mixin::DeepMerge.hash_only_merge(current_provisioner_options, options), &block)
+    def current_driver
+      @current_driver || config[:driver]
+    end
+
+    def current_machine_options
+      if @current_machine_options
+        @current_machine_options
+      elsif config[:drivers] && driver_for(current_driver) && config[:drivers][driver_for(current_driver).driver_url]
+        Cheffish::MergedConfig.new(config[:drivers][driver_for(current_driver).driver_url], config)[:machine_options] || {}
       else
-        with_provisioner_options(options)
+        config[:machine_options] || {}
+      end
+    end
+
+    def add_machine_options(options, &block)
+      with_machine_options(Chef::Mixin::DeepMerge.hash_only_merge(current_machine_options, options), &block)
+    end
+
+    def driver_for(driver)
+      driver.is_a?(String) ? driver_for_url(driver) : driver
+    end
+
+    def driver_config_for(driver)
+      ChefMetal.config_for_url(driver_for(driver).driver_url, config)
+    end
+
+    def driver_for_url(driver_url)
+      drivers[driver_url] ||= begin
+        driver = ChefMetal.driver_for_url(driver_url, config)
+        # Check the canonicalized driver_url from the driver
+        if driver.driver_url != driver_url
+          drivers[driver.driver_url] ||= driver
+        else
+          driver
+        end
+      end
+    end
+
+    def connect_to_machine(name, chef_server = nil)
+      if name.is_a?(MachineSpec)
+        machine_spec = name
+      else
+        machine_spec = ChefMetal::ChefMachineSpec.get(name, chef_server)
+      end
+      ChefMetal.connect_to_machine(machine_spec, config)
+    end
+
+    def keys
+      result = (config.keys || {}).dup
+      Array(config.key_path) do |key_path|
+        Dir.entries(key_path).each do |key|
+          if File.extname(key) == '.pem'
+            result[File.basename(key)[0..-5]] ||= key
+          end
+        end
       end
+      result
     end
   end
 end

data/lib/chef_metal/convergence_strategy.rb

@@ -1,14 +1,25 @@
 module ChefMetal
   class ConvergenceStrategy
-    def setup_convergence(action_handler, machine, machine_resource)
+    # convergence_options - a freeform hash of options to the converger.
+    # config - a Chef::Config-like object with global config like :log_level
+    def initialize(convergence_options, config)
+      @convergence_options = convergence_options || {}
+      @config = config
+    end
+
+    attr_reader :convergence_options
+    attr_reader :config
+
+    # Get the machine ready to converge, but do not converge.
+    def setup_convergence(action_handler, machine)
       raise "setup_convergence not overridden on #{self.class}"
     end
 
-    def converge(action_handler, machine, chef_server)
+    def converge(action_handler, machine)
       raise "converge not overridden on #{self.class}"
     end
 
-    def cleanup_convergence(action_handler, node)
+    def cleanup_convergence(action_handler, machine_spec)
       raise "cleanup_convergence not overridden on #{self.class}"
     end
   end

data/lib/chef_metal/convergence_strategy/install_cached.rb

@@ -7,20 +7,32 @@ require 'thread'
 module ChefMetal
   class ConvergenceStrategy
     class InstallCached < PrecreateChefObjects
-      def initialize(options = {})
-        @client_rb_path ||= '/etc/chef/client.rb'
-        @client_pem_path ||= '/etc/chef/client.pem'
-        @chef_version ||= options[:chef_version]
-        @prerelease ||= options[:prerelease]
-        @package_cache_path ||= options[:package_cache_path] || "#{ENV['HOME']}/.chef/package_cache"
+      # convergence_options is a hash of setup convergence_options, including:
+      # - :chef_server
+      # - :allow_overwrite_keys
+      # - :source_key, :source_key_path, :source_key_pass_phrase
+      # - :private_key_options
+      # - :ohai_hints
+      # - :public_key_path, :public_key_format
+      # - :admin, :validator
+      # - :chef_client_timeout
+      # - :client_rb_path, :client_pem_path
+      # - :chef_version, :prerelease, :package_cache_path
+      def initialize(convergence_options, config)
+        super
+        @convergence_options[:client_rb_path] ||= '/etc/chef/client.rb'
+        @convergence_options[:client_pem_path] ||= '/etc/chef/client.pem'
+        @chef_version ||= convergence_options[:chef_version]
+        @prerelease ||= convergence_options[:prerelease]
+        @package_cache_path ||= convergence_options[:package_cache_path] || "#{ENV['HOME']}/.chef/package_cache"
         @package_cache = {}
         @tmp_dir = '/tmp'
-        @chef_client_timeout = options.has_key?(:chef_client_timeout) ? options[:chef_client_timeout] : 120*60 # Default: 2 hours
+        @chef_client_timeout = convergence_options.has_key?(:chef_client_timeout) ? convergence_options[:chef_client_timeout] : 120*60 # Default: 2 hours
         FileUtils.mkdir_p(@package_cache_path)
         @package_cache_lock = Mutex.new
       end
 
-      def setup_convergence(action_handler, machine, machine_resource)
+      def setup_convergence(action_handler, machine)
         super
 
         # Install chef-client.  TODO check and update version if not latest / not desired
@@ -33,12 +45,14 @@ module ChefMetal
         end
       end
 
-      def converge(action_handler, machine, chef_server)
+      def converge(action_handler, machine)
         super
 
         action_handler.open_stream(machine.node['name']) do |stdout|
           action_handler.open_stream(machine.node['name']) do |stderr|
-            machine.execute(action_handler, "chef-client -l #{Chef::Config.log_level.to_s}",
+            command_line = "chef-client"
+            command_line << "-l #{config[:log_level].to_s}" if config[:log_level]
+            machine.execute(action_handler, "chef-client",
               :stream_stdout => stdout,
               :stream_stderr => stderr,
               :timeout => @chef_client_timeout)

data/lib/chef_metal/convergence_strategy/install_msi.rb

@@ -6,19 +6,19 @@ module ChefMetal
     class InstallMsi < PrecreateChefObjects
       @@install_msi_cache = {}
 
-      def initialize(options = {})
-        @install_msi_url = options[:install_msi_url] || 'http://www.opscode.com/chef/install.msi'
-        @install_msi_path = options[:install_msi_path] || "%TEMP%\\#{File.basename(@install_msi_url)}"
-        @chef_client_timeout = options.has_key?(:chef_client_timeout) ? options[:chef_client_timeout] : 120*60 # Default: 2 hours
+      def initialize(convergence_options, config)
+        @install_msi_url = convergence_options[:install_msi_url] || 'http://www.opscode.com/chef/install.msi'
+        @install_msi_path = convergence_options[:install_msi_path] || "%TEMP%\\#{File.basename(@install_msi_url)}"
+        @chef_client_timeout = convergence_options.has_key?(:chef_client_timeout) ? convergence_options[:chef_client_timeout] : 120*60 # Default: 2 hours
       end
 
       attr_reader :install_msi_url
       attr_reader :install_msi_path
 
-      def setup_convergence(action_handler, machine, machine_resource)
+      def setup_convergence(action_handler, machine)
         system_drive = machine.execute_always('$env:SystemDrive').stdout.strip
-        @client_rb_path ||= "#{system_drive}\\chef\\client.rb"
-        @client_pem_path ||= "#{system_drive}\\chef\\client.pem"
+        convergence_options[:client_rb_path] ||= "#{system_drive}\\chef\\client.rb"
+        convergence_options[:client_pem_path] ||= "#{system_drive}\\chef\\client.pem"
 
         super
 
@@ -33,11 +33,18 @@ module ChefMetal
         end
       end
 
-      def converge(action_handler, machine, chef_server)
+      def converge(action_handler, machine)
         super
-        
+
         # TODO For some reason I get a 500 back if I don't do -l debug
-        machine.execute(action_handler, "chef-client -l debug", :stream => true, :timeout => @chef_client_timeout)
+        action_handler.open_stream(machine.node['name']) do |stdout|
+          action_handler.open_stream(machine.node['name']) do |stderr|
+            machine.execute(action_handler, "chef-client -l debug",
+              :stream_stdout => stdout,
+              :stream_stderr => stderr,
+              :timeout => @chef_client_timeout)
+          end
+        end
       end
     end
   end

data/lib/chef_metal/convergence_strategy/install_sh.rb

@@ -6,18 +6,19 @@ module ChefMetal
     class InstallSh < PrecreateChefObjects
       @@install_sh_cache = {}
 
-      def initialize(options = {})
-        @install_sh_url = options[:install_sh_url] || 'http://www.opscode.com/chef/install.sh'
-        @install_sh_path = options[:install_sh_path] || '/tmp/chef-install.sh'
-        @client_rb_path ||= '/etc/chef/client.rb'
-        @client_pem_path ||= '/etc/chef/client.pem'
-        @chef_client_timeout = options.has_key?(:chef_client_timeout) ? options[:chef_client_timeout] : 120*60 # Default: 2 hours
+      def initialize(convergence_options, config)
+        super
+        @install_sh_url = convergence_options[:install_sh_url] || 'http://www.opscode.com/chef/install.sh'
+        @install_sh_path = convergence_options[:install_sh_path] || '/tmp/chef-install.sh'
+        @convergence_options[:client_rb_path] ||= '/etc/chef/client.rb'
+        @convergence_options[:client_pem_path] ||= '/etc/chef/client.pem'
+        @chef_client_timeout = convergence_options.has_key?(:chef_client_timeout) ? convergence_options[:chef_client_timeout] : 120*60 # Default: 2 hours
       end
 
       attr_reader :install_sh_url
       attr_reader :install_sh_path
 
-      def setup_convergence(action_handler, machine, machine_resource)
+      def setup_convergence(action_handler, machine)
         super
 
         # Install chef-client.  TODO check and update version if not latest / not desired
@@ -29,10 +30,19 @@ module ChefMetal
         end
       end
 
-      def converge(action_handler, machine, chef_server)
+      def converge(action_handler, machine)
         super
-        
-        machine.execute(action_handler, "chef-client -l #{Chef::Config.log_level.to_s}", :stream => true, :timeout => @chef_client_timeout)
+
+        action_handler.open_stream(machine.node['name']) do |stdout|
+          action_handler.open_stream(machine.node['name']) do |stderr|
+            command_line = "chef-client"
+            command_line << "-l #{config[:log_level].to_s}" if config[:log_level]
+            machine.execute(action_handler, command_line,
+              :stream_stdout => stdout,
+              :stream_stderr => stderr,
+              :timeout => @chef_client_timeout)
+          end
+        end
       end
     end
   end

data/lib/chef_metal/convergence_strategy/no_converge.rb

@@ -5,23 +5,30 @@ require 'cheffish'
 module ChefMetal
   class ConvergenceStrategy
     class NoConverge < ConvergenceStrategy
-      attr_reader :client_rb_path
-      attr_reader :client_pem_path
+      def initialize(convergence_options, config)
+        super
+      end
 
-      def setup_convergence(action_handler, machine, machine_resource)
-        # Save the node
-        ChefMetal.inline_resource(action_handler) do
-          # TODO strip automatic attributes first so we don't race with "current state"
-          chef_node machine.node['name'] do
-            chef_server machine_resource.chef_server
-            raw_json machine.node
-          end
-        end
+      def chef_server
+        @chef_server ||= convergence_options[:chef_server] || Cheffish.default_chef_server(config)
+      end
+
+      def setup_convergence(action_handler, machine)
+        machine_spec.save(action_handler)
+      end
+
+      def converge(action_handler, machine)
       end
 
-      def cleanup_convergence(action_handler, node)
+      def cleanup_convergence(action_handler, machine_spec)
+        _self = self
         ChefMetal.inline_resource(action_handler) do
-          chef_node node['name'] do
+          chef_node machine_spec.name do
+            chef_server _self.chef_server
+            action :delete
+          end
+          chef_client machine_spec.name do
+            chef_server _self.chef_server
             action :delete
           end
         end

data/lib/chef_metal/convergence_strategy/precreate_chef_objects.rb

@@ -5,44 +5,46 @@ require 'cheffish'
 module ChefMetal
   class ConvergenceStrategy
     class PrecreateChefObjects < ConvergenceStrategy
-      def initialize(options = {})
+      def initialize(convergence_options, config)
         super
-        @client_rb_path = options[:client_rb_path]
-        @client_pem_path = options[:client_pem_path]
       end
 
-      attr_reader :client_rb_path
-      attr_reader :client_pem_path
+      def chef_server
+        @chef_server ||= convergence_options[:chef_server] || Cheffish.default_chef_server(config)
+      end
 
-      def setup_convergence(action_handler, machine, machine_resource)
+      def setup_convergence(action_handler, machine)
         # Create keys on machine
-        public_key = create_keys(action_handler, machine, machine_resource)
+        public_key = create_keys(action_handler, machine)
         # Create node and client on chef server
-        create_chef_objects(action_handler, machine, machine_resource, public_key)
+        create_chef_objects(action_handler, machine, public_key)
 
         # If the chef server lives on localhost, tunnel the port through to the guest
         # (we need to know what got tunneled!)
-        chef_server_url = machine_resource.chef_server[:chef_server_url]
+        chef_server_url = chef_server[:chef_server_url]
         chef_server_url = machine.make_url_available_to_remote(chef_server_url)
 
-        #Support for multiple ohai hints, required on some platforms
-        create_ohai_files(action_handler, machine, machine_resource)
+        # Support for multiple ohai hints, required on some platforms
+        create_ohai_files(action_handler, machine)
 
         # Create client.rb and client.pem on machine
         content = client_rb_content(chef_server_url, machine.node['name'])
-        machine.write_file(action_handler, client_rb_path, content, :ensure_dir => true)
+        machine.write_file(action_handler, convergence_options[:client_rb_path], content, :ensure_dir => true)
       end
 
-      def converge(action_handler, machine, chef_server)
+      def converge(action_handler, machine)
         machine.make_url_available_to_remote(chef_server[:chef_server_url])
       end
 
-      def cleanup_convergence(action_handler, node)
+      def cleanup_convergence(action_handler, machine_spec)
+        _self = self
         ChefMetal.inline_resource(action_handler) do
-          chef_node node['name'] do
+          chef_node machine_spec.name do
+            chef_server _self.chef_server
             action :delete
           end
-          chef_client node['name'] do
+          chef_client machine_spec.name do
+            chef_server _self.chef_server
             action :delete
           end
         end
@@ -50,8 +52,8 @@ module ChefMetal
 
       protected
 
-      def create_keys(action_handler, machine, machine_resource)
-        server_private_key = machine.read_file(client_pem_path)
+      def create_keys(action_handler, machine)
+        server_private_key = machine.read_file(convergence_options[:client_pem_path])
         if server_private_key
           begin
             server_private_key, format = Cheffish::KeyFormatter.decode(server_private_key)
@@ -61,25 +63,25 @@ module ChefMetal
         end
 
         if server_private_key
-          source_key = source_key_for(machine_resource)
           if source_key && server_private_key.to_pem != source_key.to_pem
             # If the server private key does not match our source key, overwrite it
             server_private_key = source_key
-            if machine_resource.allow_overwrite_keys
-              machine.write_file(action_handler, client_pem_path, server_private_key.to_pem, :ensure_dir => true)
+            if convergence_options[:allow_overwrite_keys]
+              machine.write_file(action_handler, convergence_options[:client_pem_path], server_private_key.to_pem, :ensure_dir => true)
             else
-              raise "Private key on machine #{machine_resource.name} does not match desired input key."
+              raise "Private key on machine #{machine.name} does not match desired input key."
             end
           end
 
         else
 
           # If the server does not already have keys, create them and upload
+          _convergence_options = convergence_options
           ChefMetal.inline_resource(action_handler) do
             private_key 'in_memory' do
               path :none
-              if machine_resource.private_key_options
-                machine_resource.private_key_options.each_pair do |key,value|
+              if _convergence_options[:private_key_options]
+                _convergence_options[:private_key_options].each_pair do |key,value|
                   send(key, value)
                 end
               end
@@ -87,7 +89,7 @@ module ChefMetal
             end
           end
 
-          machine.write_file(action_handler, client_pem_path, server_private_key.to_pem, :ensure_dir => true)
+          machine.write_file(action_handler, convergence_options[:client_pem_path], server_private_key.to_pem, :ensure_dir => true)
         end
 
         server_private_key.public_key
@@ -97,14 +99,14 @@ module ChefMetal
         host == '127.0.0.1' || host == 'localhost' || host == '[::1]'
       end
 
-      def source_key_for(machine_resource)
-        if machine_resource.source_key.is_a?(String)
-          key, format = Cheffish::KeyFormatter.decode(machine_resource.source_key, machine_resource.source_key_pass_phrase)
+      def source_key
+        if convergence_options[:source_key].is_a?(String)
+          key, format = Cheffish::KeyFormatter.decode(convergence_options[:source_key], convergence_options[:source_key_pass_phrase])
           key
-        elsif machine_resource.source_key
-          machine_resource.source_key
-        elsif machine_resource.source_key_path
-          key, format = Cheffish::KeyFormatter.decode(IO.read(machine_resource.source_key_path), machine_resource.source_key_pass_phrase, machine_resource.source_key_path)
+        elsif convergence_options[:source_key]
+          convergence_options[:source_key]
+        elsif convergence_options[:source_key_path]
+          key, format = Cheffish::KeyFormatter.decode(IO.read(convergence_options[:source_key_path]), convergence_options[:source_key_pass_phrase], convergence_options[:source_key_path])
           key
         else
           nil
@@ -112,9 +114,9 @@ module ChefMetal
       end
 
       # Create the ohai file(s)
-      def create_ohai_files(action_handler, machine, machine_resource)
-        if machine_resource.ohai_hints
-          machine_resource.ohai_hints.each_pair do |hint, data|
+      def create_ohai_files(action_handler, machine)
+        if convergence_options[:ohai_hints]
+          convergence_options[:ohai_hints].each_pair do |hint, data|
             # The location of the ohai hint
             ohai_hint = "/etc/chef/ohai/hints/#{hint}.json"
             machine.write_file(action_handler, ohai_hint, data.to_json, :ensure_dir => true)
@@ -122,30 +124,32 @@ module ChefMetal
         end
       end
 
-      def create_chef_objects(action_handler, machine, machine_resource, public_key)
+      def create_chef_objects(action_handler, machine, public_key)
+        _convergence_options = convergence_options
+        _chef_server = chef_server
         # Save the node and create the client keys and client.
         ChefMetal.inline_resource(action_handler) do
           # Create client
-          chef_client machine.node['name'] do
-            chef_server machine_resource.chef_server
+          chef_client machine.name do
+            chef_server _chef_server
             source_key public_key
-            output_key_path machine_resource.public_key_path
-            output_key_format machine_resource.public_key_format
-            admin machine_resource.admin
-            validator machine_resource.validator
+            output_key_path _convergence_options[:public_key_path]
+            output_key_format _convergence_options[:public_key_format]
+            admin _convergence_options[:admin]
+            validator _convergence_options[:validator]
           end
 
           # Create node
           # TODO strip automatic attributes first so we don't race with "current state"
-          chef_node machine.node['name'] do
-            chef_server machine_resource.chef_server
+          chef_node machine.name do
+            chef_server _chef_server
             raw_json machine.node
           end
         end
 
         # If using enterprise/hosted chef, fix acls
-        if machine_resource.chef_server[:chef_server_url] =~ /\/+organizations\/.+/
-          grant_client_node_permissions(machine_resource.chef_server, machine.node['name'], ["read", "update"])
+        if chef_server[:chef_server_url] =~ /\/+organizations\/.+/
+          grant_client_node_permissions(chef_server, machine.name, ["read", "update"])
         end
       end
 
@@ -164,7 +168,7 @@ module ChefMetal
         <<EOM
 chef_server_url #{chef_server_url.inspect}
 node_name #{node_name.inspect}
-client_key #{client_pem_path.inspect}
+client_key #{convergence_options[:client_pem_path].inspect}
 EOM
       end
     end