chef-metal 0.9.4 → 0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 00a282ef18ac2646f17721192ffadb941fdcb633
-  data.tar.gz: 5661ed9e46d23ca6d8a58a7b7ea83e2004dea534
+  metadata.gz: 91ee1320eb59919be2805020ac09ec0b05661f7a
+  data.tar.gz: 60dd728cdbb222d29baf94fa0c8b142a84f986c5
 SHA512:
-  metadata.gz: 14715c670bde674c517bf4239b558e0cd435e0a9b9bcfee580c71653fc10699b792461563c818f004519c089272365fc38bf47c0c818eb094a451177dd68991a
-  data.tar.gz: f11ccb2cea40c9afab0ad34eddd177c297a8ba169a9f34f757048866f36af6ceffea92bc9e5852ad27e78928c536218698c9b62e40b2f45dbc27df71b4eba93c
+  metadata.gz: 29ee96e2d9905ede692ab859a084065027b3645a523e1a9705cde2e73c9c39b1169096b16d977da12ad6641c92d91ffaf25fc8143196c3023f2f1561b181cd7f
+  data.tar.gz: 5a2acc8d69b8031a83c404306251c1738900c08322bc2d5fff68d24c74d24e570cbc9e2961e91264f5175b881f848dfe14c109f741cbe573b0b0fa590b10d7db

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Chef Metal Changelog
 
+## Unreleased
+
+- Parallelism!
+  - All machines by default will be created in parallel just before the first "machine" definition. They will attempt to run all the way to converge.  If they fail, add "with_machine_batch 'mybatch', :setup"
+  - Use "with_machine_batch 'mybatch'" before any machines if you want tighter control. Actions include :delete, :acquire, :setup, and :converge.
+- Parallelizableness: chef-metal now stores data in the run_context instead of globally, so that it can be run multiple times in parallel. This capability is not yet being used.
+
 ## 0.9.4 (4/23/2014)
 
 - Preserve provisioner_output in machine resource (don't destroy it!!)

data/lib/chef/provider/machine.rb

@@ -64,15 +64,13 @@ class Chef::Provider::Machine < Chef::Provider::LWRPBase
   attr_reader :node_provider
 
   def load_current_resource
-    @node_provider = Chef::Provider::ChefNode.new(new_resource, nil)
+    @node_provider = Chef::Provider::ChefNode.new(new_resource, run_context)
     @node_provider.load_current_resource
   end
 
-  private
-
-  def upload_files(machine)
-    if new_resource.files
-      new_resource.files.each_pair do |remote_file, local|
+  def self.upload_files(action_handler, machine, files)
+    if files
+      files.each_pair do |remote_file, local|
         if local.is_a?(Hash)
           if local[:local_path]
             machine.upload_file(self, local[:local_path], remote_file)
@@ -85,4 +83,10 @@ class Chef::Provider::Machine < Chef::Provider::LWRPBase
       end
     end
   end
+
+  private
+
+  def upload_files(machine)
+    Machine.upload_files(self, machine, new_resource.files)
+  end
 end

data/lib/chef/provider/machine_batch.rb

@@ -1,6 +1,8 @@
+require 'chef/chef_fs/parallelizer'
 require 'chef/provider/lwrp_base'
+require 'chef/provider/machine'
 require 'chef_metal/provider_action_handler'
-require 'chef/chef_fs/parallelizer'
+require 'chef_metal/add_prefix_action_handler'
 
 class Chef::Provider::MachineBatch < Chef::Provider::LWRPBase
 
@@ -12,37 +14,102 @@ class Chef::Provider::MachineBatch < Chef::Provider::LWRPBase
     true
   end
 
-  action :create do
-    # Collect nodes by provisioner
+  def parallelizer
+    @parallelizer ||= Chef::ChefFS::Parallelizer.new(new_resource.max_simultaneous || 100)
+  end
+
+  action :boot do
+    with_booted_machines
+  end
+
+  action :setup do
+    with_booted_machines do |machine|
+      prefixed_handler = ChefMetal::AddPrefixActionHandler.new(self, "[#{machine[:resource].name}] ")
+      machine[:machine].setup_convergence(prefixed_handler, machine[:resource])
+      Chef::Provider::Machine.upload_files(prefixed_handler, machine[:machine], machine[:resource].files)
+    end
+  end
+
+  action :converge do
+    with_booted_machines do |machine|
+      prefixed_handler = ChefMetal::AddPrefixActionHandler.new(self, "[#{machine[:resource].name}] ")
+      machine[:machine].setup_convergence(prefixed_handler, machine[:resource])
+      Chef::Provider::Machine.upload_files(prefixed_handler, machine[:machine], machine[:resource].files)
+      machine[:machine].converge(prefixed_handler, machine[:resource].chef_server)
+    end
+  end
+
+  action :stop do
+    parallel_do(@by_provisioner) do |provisioner, node_urls|
+      provisioner.stop_machines(self, node_urls.map { |n| @by_node[n][:provider].node_provider.current_json }, parallelizer)
+    end
+  end
+
+  action :delete do
+    parallel_do(@by_provisioner) do |provisioner, node_urls|
+      provisioner.delete_machines(self, node_urls.map { |n| @by_node[n][:provider].node_provider.current_json }, parallelizer)
+    end
+  end
 
-    by_provisioner = new_resource.machines.group_by { |machine| machine.provisioner }
-    # Talk to each provisioner in parallel
-    Chef::ChefFS::Parallelizer.parallelize(by_provisioner) do |provisioner, machines|
-      nodes_json = machines.map do |machine|
-        node_json = node_providers[machine].node_json
-        node_json['normal']['provisioner_options'] = machine.provisioner_options
-        node_json
+  def with_booted_machines
+    parallel_do(@by_provisioner) do |provisioner, node_urls|
+      machines = node_urls.map do |node_url|
+        # Fill in the provisioner options and output in case they got overwritten
+        machine = @by_node[node_url]
+        machine[:node] = machine[:provider].node_provider.new_json
+        machine[:node]['normal']['provisioner_options'] = machine[:resource].provisioner_options
+        machine[:node]['normal']['provisioner_output'] = machine[:provider].node_provider.current_json['normal']['provisioner_output']
+        machine
       end
-      if provisioner.respond_to?(:acquire_machines)
-        provisioner.acquire_machines(self, nodes_json)
-      else
-        Chef::ChefFS::Parallelizer.parallelize(nodes_json) do |node_json|
-          provisioner.acquire_machine(self, node_json)
+
+      # TODO I don't understand why the object_id hack was necessary.  Using the
+      # node as a key didn't work. If we could pass node_urls through acquire_machines,
+      # that would solve the problem in a bestest way (nodes themselves are not
+      # necessarily unique without knowing the chef_server with which they are
+      # associated)
+      by_node_json = machines.inject({}) { |result, machine| result[machine[:node].object_id] = machine; result }
+      provisioner.acquire_machines(self, by_node_json.values.map { |m| m[:node] }, parallelizer) do |node_json, machine_obj|
+        machine = by_node_json[node_json.object_id]
+
+        machine[:machine] = machine_obj
+        begin
+          yield machine if block_given?
+        ensure
+          machine_obj.disconnect
         end
       end
     end
   end
 
-  attr_reader :node_providers
+  # TODO in many of these cases, the order of the results only matters because you
+  # want to match it up with the input.  Make a parallelize method that doesn't
+  # care about order and spits back results as quickly as possible.
+  def parallel_do(enum, options = {}, &block)
+    parallelizer.parallelize(enum, options, &block).to_a
+  end
+
+  def node_url(machine_resource)
+    "#{machine_resource.chef_server[:chef_server_url]}/nodes/#{machine_resource.name}"
+  end
 
   def load_current_resource
-    @node_providers = {}
-    new_resource.machines.each do |machine|
-      @node_providers[machine] = Chef::Provider.ChefNode.new(machine, nil)
+    # Figure out which machines are in the batch, remove duplicates, and retrieve
+    # the nodes from the Chef server if they exist.
+    @by_provisioner = {}
+    @by_node = {}
+    new_resource.machines.each do |machine_resource|
+      next if @by_node.has_key?(node_url(machine_resource))
+      next unless Array(machine_resource.action).include?(:create)
+      @by_node[node_url(machine_resource)] = {
+        :resource => machine_resource,
+        :provider => Chef::Provider::Machine.new(machine_resource, run_context)
+      }
+      @by_provisioner[machine_resource.provisioner] ||= []
+      @by_provisioner[machine_resource.provisioner] << node_url(machine_resource)
     end
     # Load nodes in parallel
-    Chef::ChefFS::Parallelizer.parallelize(@node_providers.values) do |node_provider|
-      node_provider.load_current_resource
+    parallel_do(@by_node.values) do |machine|
+      machine[:provider].load_current_resource
     end
   end
 

data/lib/chef/provider/machine_execute.rb

@@ -1,5 +1,6 @@
 require 'chef/provider/lwrp_base'
 require 'cheffish/cheffish_server_api'
+require 'chef_metal/provider_action_handler'
 
 class Chef::Provider::MachineExecute < Chef::Provider::LWRPBase
 

data/lib/chef/provider/machine_file.rb

@@ -1,5 +1,6 @@
 require 'chef/provider/lwrp_base'
 require 'cheffish/cheffish_server_api'
+require 'chef_metal/provider_action_handler'
 
 class Chef::Provider::MachineFile < Chef::Provider::LWRPBase
 

data/lib/chef/resource/machine.rb

@@ -7,10 +7,13 @@ class Chef::Resource::Machine < Chef::Resource::LWRPBase
 
   def initialize(*args)
     super
-    @chef_environment = Cheffish.enclosing_environment
-    @chef_server = Cheffish.enclosing_chef_server
-    @provisioner = ChefMetal.enclosing_provisioner
-    @provisioner_options = ChefMetal.enclosing_provisioner_options
+    @chef_environment = run_context.cheffish.current_environment
+    @chef_server = run_context.cheffish.current_chef_server
+    @provisioner = run_context.chef_metal.current_provisioner
+    @provisioner_options = run_context.chef_metal.current_provisioner_options
+    if run_context.chef_metal.current_machine_batch
+      run_context.chef_metal.current_machine_batch.machines << self
+    end
   end
 
   def after_created
@@ -85,6 +88,10 @@ class Chef::Resource::Machine < Chef::Resource::LWRPBase
     end
   end
 
+  def add_provisioner_options(options)
+    @provisioner_options = Chef::Mixin::DeepMerge.hash_only_merge(@provisioner_options, options)
+  end
+
   # chef client version and omnibus
   # chef-zero boot method?
   # chef-client -z boot method?

data/lib/chef/resource/machine_batch.rb

@@ -1,13 +1,20 @@
 require 'chef/resource/lwrp_base'
 
 class Chef::Resource::MachineBatch < Chef::Resource::LWRPBase
+  self.resource_name = 'machine_batch'
+
   def initialize(*args)
     super
     @machines = []
+    @chef_server = run_context.cheffish.current_chef_server
   end
 
-  actions :create, :setup, :converge, :stop
-  default_action :create
+  # 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, :delete
+  default_action :converge
 
   attribute :machines, :kind_of => [ Array ]
+  attribute :max_simultaneous, :kind_of => [ Integer ]
+  attribute :chef_server
 end

data/lib/chef/resource/machine_execute.rb

@@ -8,8 +8,8 @@ class Chef::Resource::MachineExecute < Chef::Resource::LWRPBase
 
   def initialize(*args)
     super
-    @chef_server = Cheffish.enclosing_chef_server
-    @provisioner = ChefMetal.enclosing_provisioner
+    @chef_server = run_context.cheffish.current_chef_server
+    @provisioner = run_context.chef_metal.current_provisioner
   end
 
   actions :run

data/lib/chef/resource/machine_file.rb

@@ -8,8 +8,8 @@ class Chef::Resource::MachineFile < Chef::Resource::LWRPBase
 
   def initialize(*args)
     super
-    @chef_server = Cheffish.enclosing_chef_server
-    @provisioner = ChefMetal.enclosing_provisioner
+    @chef_server = run_context.cheffish.current_chef_server
+    @provisioner = run_context.chef_metal.current_provisioner
   end
 
   actions :upload, :download, :delete, :nothing

data/lib/chef_metal.rb

@@ -2,59 +2,37 @@
 require 'chef_metal/recipe_dsl'
 require 'chef/resource/machine'
 require 'chef/provider/machine'
+require 'chef/resource/machine_batch'
+require 'chef/provider/machine_batch'
 require 'chef/resource/machine_file'
 require 'chef/provider/machine_file'
 require 'chef/resource/machine_execute'
 require 'chef/provider/machine_execute'
-
-require 'chef_metal/inline_resource'
+require 'chef/server_api'
+require 'cheffish/basic_chef_client'
 
 module ChefMetal
-  def self.with_provisioner(provisioner)
-    old_provisioner = ChefMetal.enclosing_provisioner
-    ChefMetal.enclosing_provisioner = provisioner
-    if block_given?
-      begin
-        yield
-      ensure
-        ChefMetal.enclosing_provisioner = old_provisioner
-      end
-    end
+  def self.inline_resource(action_handler, &block)
+    events = ActionHandlerForward.new(action_handler)
+    Cheffish::BasicChefClient.converge_block(nil, events, &block)
   end
 
-  def self.with_provisioner_options(provisioner_options)
-    old_provisioner_options = ChefMetal.enclosing_provisioner_options
-    ChefMetal.enclosing_provisioner_options = provisioner_options
-    if block_given?
-      begin
-        yield
-      ensure
-        ChefMetal.enclosing_provisioner_options = old_provisioner_options
-      end
+  class ActionHandlerForward < Chef::EventDispatch::Base
+    def initialize(action_handler)
+      @action_handler = action_handler
     end
-  end
 
-  def self.inline_resource(action_handler, &block)
-    InlineResource.new(action_handler).instance_eval(&block)
-  end
+    attr_reader :action_handler
 
-  @@enclosing_provisioner = nil
-  def self.enclosing_provisioner
-    @@enclosing_provisioner
-  end
-  def self.enclosing_provisioner=(provisioner)
-    @@enclosing_provisioner = provisioner
-  end
-
-  @@enclosing_provisioner_options = nil
-  def self.enclosing_provisioner_options
-    @@enclosing_provisioner_options
+    def resource_update_applied(resource, action, update)
+      prefix = action_handler.should_perform_actions ? "" : "Would "
+      update = Array(update).map { |u| "#{prefix}#{u}"}
+      action_handler.performed_action(update)
+    end
   end
 
-  def self.enclosing_provisioner_options=(provisioner_options)
-    @@enclosing_provisioner_options = provisioner_options
-  end
 
+  # Helpers for provisioner inflation
   @@registered_provisioner_classes = {}
   def self.add_registered_provisioner_class(name, provisioner)
     @@registered_provisioner_classes[name] = provisioner

data/lib/chef_metal/action_handler.rb

@@ -20,24 +20,27 @@
 module ChefMetal
   class ActionHandler
 
-    # This should be the run context
-    def recipe_context
-      raise ActionFailed, "ActionHandler behavior requires a recipe_context"
-    end
-
-    # This should be repaced with whatever records the update; by default it
+    # This should be replaced with whatever records the update; by default it
     # essentially does nothing here.
     def updated!
       @updated = true
     end
 
+    def should_perform_actions
+      true
+    end
+
+    def performed_action(description)
+      puts description
+    end
+
     # This should perform the actual action (e.g., converge) if there is an
     # action that needs to be done.
-    #
-    # By default, it will simply execute the block as so:
-    def perform_action(description, &block)
-      puts description
-      block.call
+    def perform_action(description)
+      if should_perform_actions
+        yield
+      end
+      performed_action(description)
     end
 
     # This is the name that will show up in the output, so should be something
@@ -45,5 +48,14 @@ module ChefMetal
     def debug_name
       raise ActionFailed, "ActionHandler behavior requires a debug_name"
     end
+
+    # Open a stream which can be printed to and closed
+    def open_stream(name)
+      if block_given?
+        yield STDOUT
+      else
+        STDOUT
+      end
+    end
   end
 end

data/lib/chef_metal/add_prefix_action_handler.rb

@@ -0,0 +1,27 @@
+require 'chef_metal/action_handler'
+
+module ChefMetal
+  class AddPrefixActionHandler
+    extend Forwardable
+
+    def initialize(action_handler, prefix)
+      @action_handler = action_handler
+      @prefix = prefix
+    end
+
+    attr_reader :action_handler
+    attr_reader :prefix
+
+    def_delegators :@action_handler, :should_perform_actions, :updated!, :debug_name, :open_stream
+    # TODO remove this as soon as HUMANLY POSSIBLE (looking at you, chef-metal-fog)
+    def_delegators :@action_handler, :new_resource
+
+    def performed_action(description)
+      action_handler.performed_action(Array(description).map { |d| "#{prefix}#{d}" })
+    end
+
+    def perform_action(description, &block)
+      action_handler.perform_action(Array(description).map { |d| "#{prefix}#{d}" }, &block)
+    end
+  end
+end

data/lib/chef_metal/chef_run_data.rb

@@ -0,0 +1,15 @@
+require 'cheffish/with_pattern'
+require 'chef/mixin/deep_merge'
+
+module ChefMetal
+  class ChefRunData
+    extend Cheffish::WithPattern
+    with :provisioner
+    with :provisioner_options
+    with :machine_batch
+
+    def add_provisioner_options(options, &block)
+      with_provisioner_options(Chef::Mixin::DeepMerge.hash_only_merge(current_provisioner_options, options), &block)
+    end
+  end
+end

data/lib/chef_metal/convergence_strategy/install_cached.rb

@@ -35,8 +35,15 @@ module ChefMetal
 
       def converge(action_handler, machine, chef_server)
         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|
+            machine.execute(action_handler, "chef-client -l #{Chef::Config.log_level.to_s}",
+              :stream_stdout => stdout,
+              :stream_stderr => stderr,
+              :timeout => @chef_client_timeout)
+          end
+        end
       end
 
       private

data/lib/chef_metal/convergence_strategy/precreate_chef_objects.rb

@@ -75,7 +75,7 @@ module ChefMetal
         else
 
           # If the server does not already have keys, create them and upload
-          Cheffish.inline_resource(action_handler) do
+          ChefMetal.inline_resource(action_handler) do
             private_key 'in_memory' do
               path :none
               if machine_resource.private_key_options

data/lib/chef_metal/provider_action_handler.rb

@@ -22,14 +22,20 @@ module ChefMetal
   module ProviderActionHandler
     # Implementation of ActionHandler interface
 
-    def recipe_context
-      self.run_context
-    end
-
     def updated!
       self.new_resource.updated_by_last_action(true)
     end
 
+    def should_perform_actions
+      !Chef::Config.why_run
+    end
+
+    def performed_action(description)
+      self.converge_by description do
+        # We already did the action, but we trust whoever told us that they did it.
+      end
+    end
+
     def perform_action(description, &block)
       self.converge_by(description, &block)
     end
@@ -37,5 +43,17 @@ module ChefMetal
     def debug_name
       self.cookbook_name
     end
+
+    def open_stream(name, &block)
+      if self.run_context.respond_to?(:open_stream)
+        self.run_context.open_stream({ :name => name }, &block)
+      else
+        if block_given?
+          yield STDOUT
+        else
+          STDOUT
+        end
+      end
+    end
   end
 end

data/lib/chef_metal/provisioner.rb

@@ -1,3 +1,5 @@
+require 'chef_metal/add_prefix_action_handler'
+
 module ChefMetal
   class Provisioner
     # Inflate a provisioner from node information; we don't want to force the
@@ -71,6 +73,35 @@ module ChefMetal
     def resource_created(machine)
     end
 
+    #
+    # Batch methods
+    #
+
+    # Acquire machines in batch, in parallel if possible.
+    def acquire_machines(action_handler, nodes_json, parallelizer)
+      parallelizer.parallelize(nodes_json) do |node_json|
+        machine = acquire_machine(add_prefix(node_json, action_handler), node_json)
+        yield node_json, machine if block_given?
+        machine
+      end.to_a
+    end
+
+    # Stop machines in batch, in parallel if possible.
+    def stop_machines(action_handler, nodes_json, parallelizer)
+      parallelizer.parallelize(nodes_json) do |node_json|
+        stop_machine(add_prefix(node_json, action_handler), node_json)
+        yield node_json if block_given?
+      end.to_a
+    end
+
+    # Delete machines in batch, in parallel if possible.
+    def delete_machines(action_handler, nodes_json, parallelizer)
+      parallelizer.parallelize(nodes_json) do |node_json|
+        delete_machine(add_prefix(node_json, action_handler), node_json)
+        yield node_json if block_given?
+      end.to_a
+    end
+
     protected
 
     def save_node(provider, node, chef_server)
@@ -82,5 +113,9 @@ module ChefMetal
         end
       end
     end
+
+    def add_prefix(node_json, action_handler)
+      AddPrefixActionHandler.new(action_handler, "[#{node_json['name']}] ")
+    end
   end
 end

data/lib/chef_metal/recipe_dsl.rb

@@ -1,13 +1,53 @@
-require 'chef_metal'
+require 'chef_metal/chef_run_data'
+require 'chef/resource_collection'
 
 class Chef
-  class Recipe
-    def with_provisioner(provisioner, &block)
-      ChefMetal.with_provisioner(provisioner, &block)
+  module DSL
+    module Recipe
+      def with_provisioner(provisioner, &block)
+        run_context.chef_metal.with_provisioner(provisioner, &block)
+      end
+
+      def with_provisioner_options(provisioner_options, &block)
+        run_context.chef_metal.with_provisioner_options(provisioner_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_provisioner_options
+        run_context.chef_metal.current_provisioner_options
+      end
+
+      def add_provisioner_options(options, &block)
+        run_context.chef_metal.add_provisioner_options(options, &block)
+      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])
+        end
+        declare_resource(:machine, name, caller[0], &block)
+      end
     end
+  end
 
-    def with_provisioner_options(provisioner_options, &block)
-      ChefMetal.with_provisioner_options(provisioner_options, &block)
+  class RunContext
+    def chef_metal
+      @chef_metal ||= ChefMetal::ChefRunData.new
     end
   end
-end
+end

data/lib/chef_metal/transport/ssh.rb

@@ -154,17 +154,15 @@ module ChefMetal
         channel = Net::SCP.new(session).download(path, local_path)
         begin
           channel.wait
-        rescue Net::SCP::Error
+        rescue Net::SCP::Error => e
+          # TODO we need a way to distinguish between "directory of file does not exist" and "SCP did not finish successfully"
           nil
-        rescue
-          # This works around https://github.com/net-ssh/net-scp/pull/10 until a new net-scp is merged.
-          begin
-            channel.close
-            channel.wait
-          rescue Net::SCP::Error
-            nil
-          end
+        # ensure the channel is closed when a rescue happens above
+        ensure
+          channel.close
+          channel.wait
         end
+        nil
       end
 
       class SSHResult

data/lib/chef_metal/version.rb

@@ -1,3 +1,3 @@
 module ChefMetal
-  VERSION = '0.9.4'
+  VERSION = '0.10'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: '0.10'
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-24 00:00:00.000000000 Z
+date: 2014-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -24,20 +24,6 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: cheffish
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: net-ssh
   requirement: !ruby/object:Gem::Requirement
@@ -80,34 +66,48 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: cheffish
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: chef-metal-fog
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: chef-metal-vagrant
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -159,14 +159,15 @@ files:
 - lib/chef/resource/machine_execute.rb
 - lib/chef/resource/machine_file.rb
 - lib/chef_metal/action_handler.rb
+- lib/chef_metal/add_prefix_action_handler.rb
 - lib/chef_metal/aws_credentials.rb
+- lib/chef_metal/chef_run_data.rb
 - lib/chef_metal/convergence_strategy/install_cached.rb
 - lib/chef_metal/convergence_strategy/install_msi.rb
 - lib/chef_metal/convergence_strategy/install_sh.rb
 - lib/chef_metal/convergence_strategy/no_converge.rb
 - lib/chef_metal/convergence_strategy/precreate_chef_objects.rb
 - lib/chef_metal/convergence_strategy.rb
-- lib/chef_metal/inline_resource.rb
 - lib/chef_metal/machine/basic_machine.rb
 - lib/chef_metal/machine/unix_machine.rb
 - lib/chef_metal/machine/windows_machine.rb

data/lib/chef_metal/inline_resource.rb

@@ -1,91 +0,0 @@
-module ChefMetal
-  class InlineResource
-    def initialize(action_handler)
-      @action_handler = action_handler
-    end
-
-    attr_reader :action_handler
-
-    def recipe_context
-      action_handler.recipe_context
-    end
-
-    def method_missing(method_symbol, *args, &block)
-      # Stolen ruthlessly from Chef's chef/dsl/recipe.rb
-
-      # Checks the new platform => short_name => resource mapping initially
-      # then fall back to the older approach (Chef::Resource.const_get) for
-      # backward compatibility
-      resource_class = Chef::Resource.resource_for_node(method_symbol,
-        action_handler.recipe_context.node)
-
-      super unless resource_class
-      raise ArgumentError, "You must supply a name when declaring a #{method_symbol} resource" unless args.size > 0
-
-      # If we have a resource like this one, we want to steal its state
-      args << recipe_context
-      resource = resource_class.new(*args)
-      resource.source_line = caller[0]
-      resource.load_prior_resource
-      resource.cookbook_name = action_handler.debug_name
-      resource.recipe_name = @recipe_name
-      resource.params = @params
-      # Determine whether this resource is being created in the context of an
-      # enclosing Provider
-      resource.enclosing_provider =
-        action_handler.is_a?(Chef::Provider) ? action_handler : nil
-      # Evaluate resource attribute DSL
-      resource.instance_eval(&block) if block
-
-      # Run optional resource hook
-      resource.after_created
-
-      # Do NOT put this in the resource collection.
-      #recipe_context.resource_collection.insert(resource)
-
-      # Instead, run the action directly.
-      Array(resource.action).each do |action|
-        resource.updated_by_last_action(false)
-        run_provider_action(resource.provider_for_action(action))
-        action_handler.updated! if resource.updated_by_last_action?
-      end
-      resource
-    end
-
-    # Do Chef::Provider.run_action, but without events
-    def run_provider_action(inline_provider)
-      if !inline_provider.whyrun_supported?
-        raise "#{inline_provider} is not why-run-safe.  Only why-run-safe resources are supported in inline_resource."
-      end
-
-      # Blatantly ripped off from chef/provider run_action
-
-      # TODO: it would be preferable to get the action to be executed in the
-      # constructor...
-
-      # user-defined LWRPs may include unsafe load_current_resource methods that cannot be run in whyrun mode
-      inline_provider.load_current_resource
-      inline_provider.define_resource_requirements
-      inline_provider.process_resource_requirements
-
-      # user-defined providers including LWRPs may
-      # not include whyrun support - if they don't support it
-      # we can't execute any actions while we're running in
-      # whyrun mode. Instead we 'fake' whyrun by documenting that
-      # we can't execute the action.
-      # in non-whyrun mode, this will still cause the action to be
-      # executed normally.
-      if inline_provider.whyrun_supported? && !inline_provider.requirements.action_blocked?(@action)
-        inline_provider.send("action_#{inline_provider.action}")
-      elsif !inline_provider.whyrun_mode?
-        inline_provider.send("action_#{inline_provider.action}")
-      end
-
-      if inline_provider.resource_updated?
-        inline_provider.new_resource.updated_by_last_action(true)
-      end
-
-      inline_provider.cleanup_after_converge
-    end
-  end
-end