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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c229a92cb5e105e2be9320f683c3d1acbddd051f
-  data.tar.gz: aeed9e2cf4740182b8091ff446a9cb0bbbc56ea3
+  metadata.gz: ef0925df69f5f0d7cf6f51b0b849f155d4c2b6ee
+  data.tar.gz: dfc2e5acb07a424fac4d9041dff233c631aaf111
 SHA512:
-  metadata.gz: a11e30995c1f7e74914cf875fef68ca58a86b3953473bd77fd0e7efb56defb1d40cbec52d5a79ac12dba4673bc44fb153cd7b4ed122b85c36e7851c8364fb33e
-  data.tar.gz: 36496bc2ac754cad82abfa77e7386a107fa2ff7ad982c6ac14beecf54f53f132280ebcce9e0ff982cb432855549264b448f7a308c1e9bb8bbc211d588d8b0c4c
+  metadata.gz: cbbc0262f139ba2883711e183cb192f895b3accd2389c56a8b68619b21c85fcbcecbd6cbf134b1b45352729334f6bc5e7a34ff759430fc1eadf6e8fe81dfcd04
+  data.tar.gz: 7b3e07b27e49b7962d1f20a7ef6e7823d70d78b5606022fcac731f53a1c8f6808f9b017a975ed4bd811cfe70fabda92f423b7158aa67099bb0da2f3f3332d2bf

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

@@ -14,33 +14,13 @@ class Chef
   module DSL
     module Recipe
       def with_driver(driver, &block)
-        if driver.is_a?(String)
-          run_context.chef_metal.with_driver(driver, &block)
-        elsif driver.is_a?(ChefMetal::Driver)
-          run_context.chef_metal.with_driver(run_context.chef_metal.driver_for_url(driver), &block)
-        else
-          raise "with_driver accepts either a driver URL string or a ChefMetal::Driver instance. You tried passing a #{driver.class}."
-        end
+        run_context.chef_metal.with_driver(driver, &block)
       end
 
       def with_machine_options(machine_options, &block)
         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
@@ -49,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
@@ -81,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/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: clc-fork-chef-metal
 version: !ruby/object:Gem::Version
-  version: 0.11.beta.5
+  version: 0.11.beta.6
 platform: ruby
 authors:
 - Matt Wrock
 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