chef-metal 0.11.beta.5 → 0.11.beta.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64ea86f29c6071ee79f33641c14a1f789cfcd332
-  data.tar.gz: 26b76360f2199924897ce4e86e68be5fd21dff0e
+  metadata.gz: 57e203c5e2a58d054e8d303906e5b40d2478ed37
+  data.tar.gz: 0b8b3b991467d7d834f546f5f43deea6d2082698
 SHA512:
-  metadata.gz: 6fc3b908d5393e2729fee78d50a9edf1f561748c93a4336b871fafa22f17898b50b3248dee66a7350399631c95de2c9431562352d67fc8267d47a68271196501
-  data.tar.gz: b6e096f975a6807a2ecb313ba8de45c4611aea368ebf84004ed3ba14257025f75f5ce4b302317a98ac2c7275aa032295d74983e5786cb563bbab8eb502c64b56
+  metadata.gz: 6e53205b1f8a91b810aac8f45f830194d2a9b6012351d64f7cb51d2da219f71d5aa1cb5a534d710bbaf7a7a2a98041d38dd843149eebd3927e97366a61e70440
+  data.tar.gz: bfc2fbef95fc8c9692d48621fe4aefb353422742350c79e49a5386af627dfc7aba41140d589f250916abf7c6fd6a290b3fc92b9da56fdce620ab5bf8c0301234

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Chef Metal Changelog
 
+## 0.11.beta.6 (5/28/2014)
+
+- Fix machine_batch defaults to be significantly less stupid
+- Remove with_machine_batch
+- Allow this:
+  ```ruby
+  machine_batch do
+    machine 'a'
+    machine 'b'
+  end
+  ```
+- Allow this:
+  ```ruby
+  machine_batch do
+    machines 'a', 'b', 'c'
+    action :destroy
+  end
+- fix SSH gateway code to honor any options given (@marcusn)
+
 ## 0.11.beta.5 (5/28/2014)
 
 - fix issue setting Hosted Chef ACLs on nodes

data/lib/chef/provider/machine_batch.rb

@@ -3,6 +3,8 @@ require 'chef/provider/lwrp_base'
 require 'chef/provider/machine'
 require 'chef_metal/chef_provider_action_handler'
 require 'chef_metal/add_prefix_action_handler'
+require 'chef_metal/machine_spec'
+require 'chef_metal/chef_machine_spec'
 
 class Chef::Provider::MachineBatch < Chef::Provider::LWRPBase
 
@@ -34,27 +36,28 @@ class Chef::Provider::MachineBatch < Chef::Provider::LWRPBase
 
   action :setup do
     with_ready_machines do |m|
-      prefixed_handler = ChefMetal::AddPrefixActionHandler.new(action_handler, "[#{m[:resource].name}] ")
+      prefixed_handler = ChefMetal::AddPrefixActionHandler.new(action_handler, "[#{m[:spec].name}] ")
       machine[:machine].setup_convergence(prefixed_handler)
       m[:spec].save(action_handler)
-      Chef::Provider::Machine.upload_files(prefixed_handler, m[:machine], m[:resource].files)
+      Chef::Provider::Machine.upload_files(prefixed_handler, m[:machine], m[:files])
     end
   end
 
   action :converge do
     with_ready_machines do |m|
-      prefixed_handler = ChefMetal::AddPrefixActionHandler.new(action_handler, "[#{m[:resource].name}] ")
+      prefixed_handler = ChefMetal::AddPrefixActionHandler.new(action_handler, "[#{m[:spec].name}] ")
       m[:machine].setup_convergence(prefixed_handler)
       m[:spec].save(action_handler)
-      Chef::Provider::Machine.upload_files(prefixed_handler, m[:machine], m[:resource].files)
+      Chef::Provider::Machine.upload_files(prefixed_handler, m[:machine], m[:files])
       m[:machine].converge(prefixed_handler)
       m[:spec].save(action_handler)
     end
   end
 
-  action :stop do
-    parallel_do(by_current_driver) do |driver, specs_and_options|
-      driver.stop_machines(action_handler, specs_and_options, parallelizer)
+  action :converge_only do
+    parallel_do(@machines) do |m|
+      machine = run_context.chef_metal.connect_to_machine(m[:spec])
+      machine.converge(action_handler)
     end
   end
 
@@ -64,6 +67,12 @@ class Chef::Provider::MachineBatch < Chef::Provider::LWRPBase
     end
   end
 
+  action :stop do
+    parallel_do(by_current_driver) do |driver, specs_and_options|
+      driver.stop_machines(action_handler, specs_and_options, parallelizer)
+    end
+  end
+
   def with_ready_machines
     action_allocate
     by_id = @machines.inject({}) { |hash,m| hash[m[:spec].id] = m; hash }
@@ -93,8 +102,8 @@ class Chef::Provider::MachineBatch < Chef::Provider::LWRPBase
   def by_new_driver
     result = {}
     @machines.each do |m|
-      if m[:resource].driver
-        driver = run_context.chef_metal.driver_for(m[:resource].driver)
+      if m[:desired_driver]
+        driver = run_context.chef_metal.driver_for(m[:desired_driver])
         result[driver] ||= {}
         result[driver][m[:spec]] = m[:options]
       end
@@ -116,15 +125,50 @@ class Chef::Provider::MachineBatch < Chef::Provider::LWRPBase
 
   def load_current_resource
     # Load nodes in parallel
-    @machines = parallel_do(new_resource.machines) do |machine_resource|
-      provider = Chef::Provider::Machine.new(machine_resource, machine_resource.run_context)
-      provider.load_current_resource
-      {
-        :resource => machine_resource,
-        :spec => provider.machine_spec,
-        :options => provider.machine_options
-      }
-    end.to_a
+    @machines = parallel_do(new_resource.machines) do |machine|
+      if machine.is_a?(Chef::Resource::Machine)
+        machine_resource = machine
+        provider = Chef::Provider::Machine.new(machine_resource, machine_resource.run_context)
+        provider.load_current_resource
+        {
+          :spec => provider.machine_spec,
+          :desired_driver => machine_resource.driver,
+          :files => machine_resource.files,
+          :options => provider.machine_options
+        }
+      elsif machine.is_a?(ChefMetal::MachineSpec)
+        machine_spec = machine
+        {
+          :spec => machine_spec,
+          :desired_driver => new_resource.driver,
+          :files => new_resource.files,
+          :options => new_machine_options
+        }
+      else
+        name = machine
+        machine_spec = ChefMetal::ChefMachineSpec.get(name, new_resource.chef_server) ||
+                       ChefMetal::ChefMachineSpec.empty(name, new_resource.chef_server)
+        {
+          :spec => machine_spec,
+          :desired_driver => new_resource.driver,
+          :files => new_resource.files,
+          :options => new_machine_options
+        }
+      end
+    end.select { |m| !m.nil? }.to_a
+  end
+
+  def new_machine_options
+    @new_machine_options ||= begin
+      result = { :convergence_options => { :chef_server => new_resource.chef_server } }
+      result = Chef::Mixin::DeepMerge.hash_only_merge(result, new_config[:machine_options]) if new_config[:machine_options]
+      result = Chef::Mixin::DeepMerge.hash_only_merge(result, new_resource.machine_options)
+      result
+    end
+  end
+
+  def new_config
+    @new_config ||= run_context.chef_metal.driver_config_for(new_resource.driver)
   end
 
 end

data/lib/chef/resource/machine.rb

@@ -1,6 +1,7 @@
 require 'chef/resource/lwrp_base'
 require 'cheffish'
 require 'chef_metal'
+require 'cheffish/merged_config'
 
 class Chef::Resource::Machine < Chef::Resource::LWRPBase
   self.resource_name = 'machine'
@@ -11,9 +12,6 @@ class Chef::Resource::Machine < Chef::Resource::LWRPBase
     @chef_server = run_context.cheffish.current_chef_server
     @driver = run_context.chef_metal.current_driver
     @machine_options = run_context.chef_metal.current_machine_options
-    if run_context.chef_metal.current_machine_batch
-      run_context.chef_metal.current_machine_batch.machines << self
-    end
   end
 
   actions :allocate, :ready, :setup, :converge, :converge_only, :destroy, :stop
@@ -85,7 +83,7 @@ class Chef::Resource::Machine < Chef::Resource::LWRPBase
   end
 
   def add_machine_options(options)
-    @machine_options = Chef::Mixin::DeepMerge.hash_only_merge(@machine_options, options)
+    @machine_options = Cheffish::MergedConfig.new(options, @machine_options)
   end
 
   # chef client version and omnibus

data/lib/chef/resource/machine_batch.rb

@@ -1,4 +1,5 @@
 require 'chef/resource/lwrp_base'
+require 'chef/mixin/deep_merge'
 
 class Chef::Resource::MachineBatch < Chef::Resource::LWRPBase
   self.resource_name = 'machine_batch'
@@ -6,15 +7,38 @@ class Chef::Resource::MachineBatch < Chef::Resource::LWRPBase
   def initialize(*args)
     super
     @machines = []
+    @driver = run_context.chef_metal.current_driver
     @chef_server = run_context.cheffish.current_chef_server
+    @machine_options = run_context.chef_metal.current_machine_options
   end
 
-  # TODO there is a useful action sequence where one does an ohai on all machines,
-  # waits for that to complete, save the nodes, and THEN converges.
-  actions :acquire, :setup, :converge, :stop, :destroy
+  actions :allocate, :ready, :setup, :converge, :converge_only, :destroy, :stop
   default_action :converge
 
   attribute :machines, :kind_of => [ Array ]
   attribute :max_simultaneous, :kind_of => [ Integer ]
+  attribute :from_recipe
+
+  # These four attributes are for when you pass names or MachineSpecs to
+  # "machines".  Not used for auto-batch or explicit inline machine declarations.
+  attribute :driver
   attribute :chef_server
+  attribute :machine_options
+  attribute :files, :kind_of => [ Array ]
+
+  def machines(*values)
+    if values.size == 0
+      @machines
+    else
+      @machines += values.flatten
+    end
+  end
+
+  def machine(name, &block)
+    machines << from_recipe.build_resource(:machine, name, caller[0], &block)
+  end
+
+  def add_machine_options(options)
+    @machine_options = Chef::Mixin::DeepMerge.hash_only_merge(@machine_options, options)
+  end
 end

data/lib/chef_metal/chef_machine_spec.rb

@@ -14,11 +14,25 @@ module ChefMetal
     end
 
     #
-    # Get a MachineSpec from the chef server.
+    # Get a MachineSpec from the chef server.  If the node does not exist on the
+    # server, it returns nil.
     #
     def self.get(name, chef_server = Cheffish.default_chef_server)
       chef_api = Cheffish.chef_server_api(chef_server)
-      ChefMachineSpec.new(chef_api.get("/nodes/#{name}"), chef_server)
+      begin
+        ChefMachineSpec.new(chef_api.get("/nodes/#{name}"), chef_server)
+      rescue Net::HTTPServerException => e
+        if e.response.code == '404'
+          nil
+        else
+          raise
+        end
+      end
+    end
+
+    # Creates a new empty MachineSpec with the given name.
+    def self.empty(name, chef_server = Cheffish.default_chef_server)
+      ChefMachineSpec.new({ 'name' => name, 'normal' => {} }, chef_server)
     end
 
     #

data/lib/chef_metal/chef_run_data.rb

@@ -16,7 +16,18 @@ module ChefMetal
 
     with :driver
     with :machine_options
-    with :machine_batch
+
+    def auto_batch_machines
+      if !@auto_batch_machines.nil?
+        @auto_batch_machines
+      else
+        config[:auto_batch_machines]
+      end
+    end
+
+    def auto_batch_machines=(value)
+      @auto_batch_machines = value
+    end
 
     def current_driver
       @current_driver || config[:driver]
@@ -25,10 +36,8 @@ module ChefMetal
     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
-        config[:machine_options] || {}
+        driver_config_for(current_driver)[:machine_options] || {}
       end
     end
 

data/lib/chef_metal/recipe_dsl.rb

@@ -21,20 +21,6 @@ class Chef
         run_context.chef_metal.with_machine_options(machine_options, &block)
       end
 
-      def with_machine_batch(the_machine_batch, options = {}, &block)
-        if the_machine_batch.is_a?(String)
-          the_machine_batch = machine_batch the_machine_batch do
-            if options[:action]
-              action options[:action]
-            end
-            if options[:max_simultaneous]
-              max_simultaneous options[:max_simultaneous]
-            end
-          end
-        end
-        run_context.chef_metal.with_machine_batch(the_machine_batch, &block)
-      end
-
       def current_machine_options
         run_context.chef_metal.current_machine_options
       end
@@ -43,19 +29,76 @@ class Chef
         run_context.chef_metal.add_machine_options(options, &block)
       end
 
+      NOT_PASSED = Object.new
+
+      def auto_batch_machines(value = NOT_PASSED)
+        if value == NOT_PASSED
+          run_context.chef_metal.auto_batch_machines
+        else
+          run_context.chef_metal.auto_batch_machines = value
+        end
+      end
+
+      def machine_batch_default_name
+        if @machine_batch_index
+          @machine_batch_index += 1
+          "default#{@machine_batch_index}"
+        else
+          @machine_batch_index = 0
+          "default"
+        end
+      end
+
+      def machine_batch(name = nil, &block)
+        name ||= machine_batch_default_name
+        recipe = self
+        declare_resource(:machine_batch, name, caller[0]) do
+          from_recipe recipe
+          instance_eval(&block)
+        end
+      end
+
       # When the machine resource is first declared, create a machine_batch (if there
       # isn't one already)
       def machine(name, &block)
-        if !run_context.chef_metal.current_machine_batch
-          run_context.chef_metal.with_machine_batch declare_resource(:machine_batch, 'default', caller[0])
+        resource = build_resource(:machine, name, caller[0], &block)
+
+        # Grab the previous resource so we can decide whether to batch this or make it its own resource.
+        previous_index = run_context.resource_collection.previous_index
+        previous = previous_index >= 0 ? run_context.resource_collection[previous_index] : nil
+        if run_context.chef_metal.auto_batch_machines &&
+           previous &&
+           Array(resource.action).size == 1 &&
+           Array(previous.action) == Array(resource.action)
+
+          # Handle batching similar machines (with similar actions)
+          if previous.is_a?(Chef::Resource::MachineBatch)
+            # If we see a machine declared after a previous machine_batch with the same action, add it to the batch.
+            previous.machines << resource
+          elsif previous.is_a?(Chef::Resource::Machine)
+            # If we see two machines in a row with the same action, batch them.
+            _self = self
+            batch = build_resource(:machine_batch, machine_batch_default_name) do
+              action resource.action
+              machines [ previous, resource ]
+            end
+            batch.from_recipe self
+            run_context.resource_collection[previous_index] = batch
+          else
+            run_context.resource_collection.insert(resource)
+          end
+
+        else
+          run_context.resource_collection.insert(resource)
         end
-        declare_resource(:machine, name, caller[0], &block)
+        resource
       end
     end
   end
 
   class Config
     default(:driver) { ENV['CHEF_DRIVER'] }
+    default(:auto_batch_machines) { true }
   #   config_context :drivers do
   #     # each key is a driver_url, and each value can have driver, driver_options and machine_options
   #     config_strict_mode false
@@ -75,4 +118,10 @@ class Chef
       @chef_metal ||= ChefMetal::ChefRunData.new(config)
     end
   end
+
+  class ResourceCollection
+    def previous_index
+      @insert_after_idx ? @insert_after_idx : @resources.length - 1
+    end
+  end
 end

data/lib/chef_metal/transport/ssh.rb

@@ -159,7 +159,7 @@ module ChefMetal
 
           Chef::Log.debug("Opening SSH gateway to #{gw_user}@#{gw_host} with options #{ssh_start_opts.inspect}")
           begin
-            Net::SSH::Gateway.new(gw_host, gw_user)
+            Net::SSH::Gateway.new(gw_host, gw_user, ssh_start_opts)
           rescue Errno::ETIMEDOUT
             Chef::Log.debug("Timed out connecting to gateway: #{$!}")
             raise InitialConnectTimeout.new($!)

data/lib/chef_metal/version.rb

@@ -1,3 +1,3 @@
 module ChefMetal
-  VERSION = '0.11.beta.5'
+  VERSION = '0.11.beta.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal
 version: !ruby/object:Gem::Version
-  version: 0.11.beta.5
+  version: 0.11.beta.6
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-28 00:00:00.000000000 Z
+date: 2014-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef