chef-metal 0.8.2 → 0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 793510893dd7adb4e0d2bfd54f22adab49e0fc15
-  data.tar.gz: 23cc9b99b247524ffb35769b1f4c107a0f9414d3
+  metadata.gz: 07e0cfcc01b7e848ee6d6f179b128f5c4a09bd13
+  data.tar.gz: 81d09bd6ee53807461a1ca10811f1a128024352e
 SHA512:
-  metadata.gz: 6738450b250a9ec88c298d12166f7069fc79e4eea8bcab8c5a5d7a6f98ab77bfad43bc0ba85a57e8a8524f6a1bb26585c03dac2279d0d0d48a11f68b83f72aa0
-  data.tar.gz: 33f56df60eed263b8c49edbbeea700a551c219c11469eac9cb3c22405c004e6a1433a8793017a4b4381d313d15b15cd963c70c7e127ff9aaf84eeb682cd17187
+  metadata.gz: 8701093c85d54d2f5e0c1a2cc3d1b7662530f9254580e63f70e901d27b6c7f6398d6fe1d6ccc2ca7d134fabde917d83c4e6a031c00b748905e143f28864e1c68
+  data.tar.gz: b353d45dc362657b6c2e01d998516339d981e825dd807d6e25526ee9b7e510a625662c3e607f6024d39cf5ab0de615696af321d5338e6bb9bee76a35ece9d350

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Chef Metal Changelog
 
+## 0.9 (4/9/2014)
+
+- Add `files` and `file` attributes to the `machine` resource
+- Fix `machine_execute` resource (@irvingpop)
+- Fix `machine :converge` action (thanks @double-z)
+- Make chef-client timeout longer by default (2 hours)
+- Make chef_client_timeout a configurable option for all convergence strategies and provisioner_options
+- Add `metal cp` command
+
 ## 0.8.2 (4/9/2014)
 
 - Add timeout support to execute

data/bin/metal

@@ -2,7 +2,6 @@
 
 require 'rubygems'
 $:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-require 'chef'
 require 'chef_metal'
 require 'chef/rest'
 require 'chef/application'
@@ -57,6 +56,10 @@ class ChefMetal::Application < Chef::Application
     :description  => "Point chef-client at local repository",
     :boolean      => true
 
+  option :chef_repo_path,
+    :long         => '--chef-repo-path=PATH',
+    :description  => "Path to Chef repository"
+
   option :chef_zero_port,
     :long         => "--chef-zero-port PORT",
     :description  => "Port to start chef-zero on"
@@ -72,14 +75,16 @@ class ChefMetal::Application < Chef::Application
     :description  => "Whether to stream output from the machine (default: true)"
 
   option :timeout,
-    :long         => "--timeout",
+    :long         => "--timeout=TIMEOUT",
     :default      => 15*60,
     :description  => "Time to wait for program to execute, or 0 for no timeout (default: 15 minutes)"
 
   def reconfigure
     super
 
-    Chef::Config[:chef_server_url] = config[:chef_server_url] if config.has_key? :chef_server_url
+    Chef::Config.chef_server_url = config[:chef_server_url] if config.has_key? :chef_server_url
+
+    Chef::Config.chef_repo_path = config[:chef_repo_path] if config.has_key? :chef_repo_path
 
     Chef::Config.local_mode = config[:local_mode] if config.has_key?(:local_mode)
     if Chef::Config.local_mode && !Chef::Config.has_key?(:cookbook_path) && !Chef::Config.has_key?(:chef_repo_path)
@@ -121,15 +126,14 @@ class ChefMetal::Application < Chef::Application
     case command
     when 'execute'
       each_machine(cli_arguments.shift) do |machine, provisioner|
-        puts "[#{machine.node['name']}] running '#{cli_arguments.join(' ')}'"
-        result = machine.execute(action_handler, cli_arguments.join(' '), :read_only => config[:read_only], :stream => config[:stream], :timeout => config[:timeout])
+        result = machine.execute(action_handler, cli_arguments.join(' '), :read_only => config[:read_only], :stream => config[:stream], :timeout => config[:timeout].to_f)
         puts result.stdout if result.stdout != '' && !config[:stream] && Chef::Config.log_level != :debug
         STDERR.puts result.stderr if result.stderr != '' && !config[:stream] && Chef::Config.log_level != :debug
         exit_code = result.exitstatus if result.exitstatus != 0
       end
     when 'converge'
       each_machine(cli_arguments.shift) do |machine, provisioner|
-        machine.converge(action_handler)
+        machine.converge(action_handler, chef_server)
       end
     when 'delete'
       each_machine(cli_arguments.shift) do |machine, provisioner|
@@ -138,8 +142,9 @@ class ChefMetal::Application < Chef::Application
     when 'update'
       each_machine(cli_arguments.shift) do |machine, provisioner|
         machine = provisioner.acquire_machine(action_handler, machine.node)
+        # TODO find out what files were uploaded so we can do it again
         machine.setup_convergence(action_handler)
-        machine.converge(action_handler)
+        machine.converge(action_handler, chef_server)
       end
     when 'stop'
       each_machine(cli_arguments.shift) do |machine, provisioner|
@@ -151,6 +156,47 @@ class ChefMetal::Application < Chef::Application
           puts machine.read_file(remote_path)
         end
       end
+    when 'cp'
+      machines = {}
+      to = cli_arguments.pop
+      if to =~ /^([^\/:]+):(.+)$/
+        to_server = $1
+        machines[to_server] ||= ChefMetal.connect_to_machine(to_server)
+        to_path = $2
+        to_is_directory = machines[to_server].is_directory?(to_path)
+      else
+        to_server = nil
+        to_path = File.absolute_path(to)
+      end
+
+      cli_arguments.each do |from|
+        if from =~ /^([^\/:]+):(.+)$/
+          from_server = $1
+          from_path = $2
+          if to_server
+            raise "Cannot copy from one server to another, or intraserver (from=#{from}, to=#{to})"
+          end
+
+          machines[from_server] ||= ChefMetal.connect_to_machine(from_server)
+          if File.directory?(to_path)
+            machines[from_server].download_file(action_handler, from_path, "#{to_path}/#{File.basename(from_path)}")
+          else
+            machines[from_server].download_file(action_handler, from_path, to_path)
+          end
+        else
+          from_server = nil
+          from_path = File.absolute_path(from)
+          if !to_server
+            raise "Cannot copy two local files.  One of the arguments must be MACHINE:PATH.  (from=#{from}, to=#{to})"
+          end
+
+          if to_is_directory
+            machines[to_server].upload_file(action_handler, from_path, "#{to_path}/#{File.basename(from_path)}")
+          else
+            machines[to_server].upload_file(action_handler, from_path, to_path)
+          end
+        end
+      end
     else
       Chef::Log.error("Command '#{command}' unrecognized")
     end
@@ -175,6 +221,16 @@ class ChefMetal::Application < Chef::Application
     @action_handler ||= ActionHandler.new
   end
 
+  def chef_server
+    {
+      :chef_server_url => Chef::Config[:chef_server_url],
+      :options => {
+        :client_name => Chef::Config[:node_name],
+        :signing_key_filename => Chef::Config[:client_key]
+      }
+    }
+  end
+
   class ActionHandler < ChefMetal::ActionHandler
     def recipe_context
       # TODO: somehow remove this code; should context really always be needed?

data/lib/chef/provider/machine.rb

@@ -19,10 +19,11 @@ class Chef::Provider::Machine < Chef::Provider::LWRPBase
     machine = new_resource.provisioner.acquire_machine(self, node_json)
     begin
       machine.setup_convergence(self, new_resource)
+      upload_files(machine)
       # If we were asked to converge, or anything changed, or if a converge has never succeeded, converge.
       if new_resource.converge || (new_resource.converge.nil? && resource_updated?) ||
          !node_json['automatic'] || node_json['automatic'].size == 0
-        machine.converge(self)
+        machine.converge(self, new_resource.chef_server)
       end
     ensure
       machine.disconnect
@@ -34,7 +35,7 @@ class Chef::Provider::Machine < Chef::Provider::LWRPBase
     node_json['normal']['provisioner_options'] = new_resource.provisioner_options
     machine = new_resource.provisioner.connect_to_machine(node_json)
     begin
-      machine.converge(self)
+      machine.converge(self, new_resource.chef_server)
     ensure
       machine.disconnect
     end
@@ -60,4 +61,22 @@ class Chef::Provider::Machine < Chef::Provider::LWRPBase
     @node_provider = Chef::Provider::ChefNode.new(new_resource, nil)
     @node_provider.load_current_resource
   end
+
+  private
+
+  def upload_files(machine)
+    if new_resource.files
+      new_resource.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)
+          else
+            machine.write_file(self, remote_file, local[:content])
+          end
+        else
+          machine.upload_file(self, local, remote_file)
+        end
+      end
+    end
+  end
 end

data/lib/chef/provider/machine_execute.rb

@@ -3,6 +3,8 @@ require 'cheffish/cheffish_server_api'
 
 class Chef::Provider::MachineExecute < Chef::Provider::LWRPBase
 
+  include ChefMetal::ProviderActionHandler
+
   use_inline_resources
 
   def whyrun_supported?

data/lib/chef/resource/machine.rb

@@ -53,6 +53,38 @@ class Chef::Resource::Machine < Chef::Resource::LWRPBase
   # or force it with "true"
   attribute :converge, :kind_of => [TrueClass, FalseClass]
 
+  # A list of files to upload, in the format REMOTE_PATH => LOCAL_PATH|HASH.
+  # == Examples
+  # files '/remote/path.txt' => '/local/path.txt'
+  # files '/remote/path.txt' => { :local_path => '/local/path.txt' }
+  # files '/remote/path.txt' => { :content => 'woo' }
+  attribute :files, :kind_of => Hash
+
+  # A single file to upload, in the format REMOTE_PATH, LOCAL_PATH|HASH.
+  # This directive may be passed multiple times, and multiple files will be uploaded.
+  # == Examples
+  # file '/remote/path.txt', '/local/path.txt'
+  # file '/remote/path.txt', { :local_path => '/local/path.txt' }
+  # file '/remote/path.txt', { :content => 'woo' }
+  def file(remote_path, local = nil)
+    @files ||= {}
+    if remote_path.is_a?(Hash)
+      if local
+        raise "file(Hash, something) does not make sense.  Either pass a hash, or pass a pair, please."
+      end
+      remote_path.each_pair do |remote, local|
+        @files[remote] = local
+      end
+    elsif remote_path.is_a?(String)
+      if !local
+        raise "Must pass both a remote path and a local path to file directive"
+      end
+      @files[remote_path] = local
+    else
+      raise "file remote_path must be a String, but is a #{remote_path.class}"
+    end
+  end
+
   # chef client version and omnibus
   # chef-zero boot method?
   # chef-client -z boot method?

data/lib/chef_metal.rb

@@ -76,6 +76,7 @@ module ChefMetal
       raise "Node #{name} was not provisioned with Metal."
     end
     provisioner = provisioner_for_node(node)
-    provisioner.connect_to_machine(node)
+    machine = provisioner.connect_to_machine(node)
+    [ machine, provisioner ]
   end
 end

data/lib/chef_metal/convergence_strategy.rb

@@ -4,7 +4,7 @@ module ChefMetal
       raise "setup_convergence not overridden on #{self.class}"
     end
 
-    def converge(action_handler, machine)
+    def converge(action_handler, machine, chef_server)
       raise "converge not overridden on #{self.class}"
     end
 

data/lib/chef_metal/convergence_strategy/install_cached.rb

@@ -15,6 +15,7 @@ module ChefMetal
         @package_cache_path ||= 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
         FileUtils.mkdir_p(@package_cache_path)
         @package_cache_lock = Mutex.new
       end
@@ -32,8 +33,10 @@ module ChefMetal
         end
       end
 
-      def converge(action_handler, machine)
-        machine.execute(action_handler, "chef-client -l #{Chef::Config.log_level.to_s}", :stream => true)
+      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)
       end
 
       private

data/lib/chef_metal/convergence_strategy/install_msi.rb

@@ -9,6 +9,7 @@ module ChefMetal
       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
       end
 
       attr_reader :install_msi_url
@@ -32,9 +33,11 @@ module ChefMetal
         end
       end
 
-      def converge(action_handler, machine)
+      def converge(action_handler, machine, chef_server)
+        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")
+        machine.execute(action_handler, "chef-client -l debug", :stream => true, :timeout => @chef_client_timeout)
       end
     end
   end

data/lib/chef_metal/convergence_strategy/install_sh.rb

@@ -11,6 +11,7 @@ module ChefMetal
         @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
       end
 
       attr_reader :install_sh_url
@@ -28,8 +29,10 @@ module ChefMetal
         end
       end
 
-      def converge(action_handler, machine)
-        machine.execute(action_handler, "chef-client -l #{Chef::Config.log_level.to_s}", :stream => true)
+      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)
       end
     end
   end

data/lib/chef_metal/convergence_strategy/no_converge.rb

@@ -19,9 +19,6 @@ module ChefMetal
         end
       end
 
-      def converge(action_handler, machine)
-      end
-
       def cleanup_convergence(action_handler, node)
         ChefMetal.inline_resource(action_handler) do
           chef_node node['name'] do

data/lib/chef_metal/convergence_strategy/precreate_chef_objects.rb

@@ -21,6 +21,7 @@ module ChefMetal
         create_chef_objects(action_handler, machine, machine_resource, 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 = machine.make_url_available_to_remote(chef_server_url)
 
@@ -32,6 +33,10 @@ module ChefMetal
         machine.write_file(action_handler, client_rb_path, content, :ensure_dir => true)
       end
 
+      def converge(action_handler, machine, chef_server)
+        machine.make_url_available_to_remote(chef_server[:chef_server_url])
+      end
+
       def cleanup_convergence(action_handler, node)
         ChefMetal.inline_resource(action_handler) do
           chef_node node['name'] do

data/lib/chef_metal/machine.rb

@@ -9,11 +9,11 @@ module ChefMetal
     # Sets up everything necessary for convergence to happen on the machine.
     # The node MUST be saved as part of this procedure.  Other than that,
     # nothing is guaranteed except that converge() will work when this is done.
-    def setup_convergence(action_handler)
+    def setup_convergence(action_handler, machine_resource)
       raise "setup_convergence not overridden on #{self.class}"
     end
 
-    def converge(action_handler)
+    def converge(action_handler, chef_server)
       raise "converge not overridden on #{self.class}"
     end
 
@@ -50,6 +50,11 @@ module ChefMetal
       raise "delete_file not overridden on #{self.class}"
     end
 
+    # Return true if directory, false/nil if not
+    def is_directory?(path)
+      raise "is_directory? not overridden on #{self.class}"
+    end
+
     # Return true or false depending on whether file exists
     def file_exists?(path)
       raise "file_exists? not overridden on #{self.class}"

data/lib/chef_metal/machine/basic_machine.rb

@@ -19,8 +19,8 @@ module ChefMetal
         convergence_strategy.setup_convergence(action_handler, self, machine_resource)
       end
 
-      def converge(action_handler)
-        convergence_strategy.converge(action_handler, self)
+      def converge(action_handler, chef_server)
+        convergence_strategy.converge(action_handler, self, chef_server)
       end
 
       def execute(action_handler, command, options = {})

data/lib/chef_metal/machine/unix_machine.rb

@@ -24,6 +24,12 @@ module ChefMetal
         end
       end
 
+      def is_directory?(path)
+        result = transport.execute("stat -c '%F' #{path}", :read_only => true)
+        return nil if result.exitstatus != 0
+        result.stdout.chomp == 'directory'
+      end
+
       # Return true or false depending on whether file exists
       def file_exists?(path)
         result = transport.execute("ls -d #{path}", :read_only => true)
@@ -31,7 +37,7 @@ module ChefMetal
       end
 
       def files_different?(path, local_path, content=nil)
-        if !file_exists?(path)
+        if !file_exists?(path) || (local_path && !File.exists?(local_path))
           return true
         end
 
@@ -85,7 +91,9 @@ module ChefMetal
 
       # Get file attributes { :mode, :owner, :group }
       def get_attributes(path)
-        file_info = transport.execute("stat -c '%a %U %G %n' #{path}", :read_only => true).stdout.split(/\s+/)
+        result = transport.execute("stat -c '%a %U %G %n' #{path}", :read_only => true)
+        return nil if result.exitstatus != 0
+        file_info = result.stdout.split(/\s+/)
         if file_info.size <= 1
           raise "#{path} does not exist in set_attributes()"
         end

data/lib/chef_metal/machine/windows_machine.rb

@@ -21,12 +21,20 @@ module ChefMetal
         end
       end
 
+      def is_directory?(path)
+        parse_boolean(transport.execute("Test-Path #{escape(path)} -pathtype container", :read_only => true).stdout)
+      end
+
       # Return true or false depending on whether file exists
       def file_exists?(path)
         parse_boolean(transport.execute("Test-Path #{escape(path)}", :read_only => true).stdout)
       end
 
       def files_different?(path, local_path, content=nil)
+        if !file_exists?(path) || (local_path && !File.exists?(local_path))
+          return true
+        end
+
         # Get remote checksum of file (from http://stackoverflow.com/a/13926809)
         result = transport.execute(<<-EOM, :read_only => true)
 $md5 = [System.Security.Cryptography.MD5]::Create("MD5")

data/lib/chef_metal/transport/ssh.rb

@@ -104,9 +104,11 @@ module ChefMetal
         uri = URI(local_url)
         host = Socket.getaddrinfo(uri.host, uri.scheme, nil, :STREAM)[0][3]
         if host == '127.0.0.1' || host == '[::1]'
-          # TODO IPv6
-          Chef::Log.debug("Forwarding local server 127.0.0.1:#{uri.port} to port #{uri.port} on #{username}@#{host}")
-          session.forward.remote(uri.port, "127.0.0.1", uri.port)
+          unless session.forward.active_remotes.any? { |port, bind| port == uri.port && bind == '127.0.0.1' }
+            # TODO IPv6
+            Chef::Log.debug("Forwarding local server 127.0.0.1:#{uri.port} to port #{uri.port} on #{username}@#{host}")
+            session.forward.remote(uri.port, '127.0.0.1', uri.port)
+          end
         end
         local_url
       end

data/lib/chef_metal/version.rb

@@ -1,3 +1,3 @@
 module ChefMetal
-  VERSION = '0.8.2'
+  VERSION = '0.9'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: '0.9'
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-09 00:00:00.000000000 Z
+date: 2014-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -164,9 +164,7 @@ files:
 - 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/driver.rb
 - lib/chef_metal/inline_resource.rb
-- lib/chef_metal/instance.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/driver.rb

@@ -1,86 +0,0 @@
-module ChefMetal
-  class Provisioner
-    # Inflate a provisioner from node information; we don't want to force the
-    # driver to figure out what the provisioner really needs, since it varies
-    # from provisioner to provisioner.
-    #
-    # ## Parameters
-    # node - node to inflate the provisioner for
-    #
-    # returns a should return a Privisoner from the information provided
-    def self.inflate(node)
-      raise "#{self.class} does not override self.inflate"
-    end
-
-    # Acquire a machine, generally by provisioning it.  Returns a Machine
-    # object pointing at the machine, allowing useful actions like setup,
-    # converge, execute, file and directory.  The Machine object will have a
-    # "node" property which must be saved to the server (if it is any
-    # different from the original node object).
-    #
-    # ## Parameters
-    # action_handler - the action_handler object that is calling this method; this
-    #        is generally a provider, but could be anything that can support the
-    #        interface (i.e., in the case of the test kitchen metal driver for
-    #        acquiring and destroying VMs).
-    # node - node object (deserialized json) representing this machine.  If
-    #        the node has a provisioner_options hash in it, these will be used
-    #        instead of options provided by the provisioner.  TODO compare and
-    #        fail if different?
-    #        node will have node['normal']['provisioner_options'] in it with any
-    #        options. It is a hash with at least these options:
-    #
-    #           -- provisioner_url: <provisioner url>
-    #
-    #        node['normal']['provisioner_output'] will be populated with
-    #        information about the created machine.  For vagrant, it is a hash
-    #        with at least these options:
-    #
-    #           -- provisioner_url: <provisioner url>
-    #
-    def acquire_machine(action_handler, node)
-      raise "#{self.class} does not override acquire_machine"
-    end
-
-    # Connect to a machine without acquiring it.  This method will NOT make any
-    # changes to anything.
-    #
-    # ## Parameters
-    # node - node object (deserialized json) representing this machine.  The
-    #        node may have normal attributes "provisioner_options" and
-    #        "provisioner_output" in it, representing the input and output of
-    #        any prior "acquire_machine" process (if any).
-    #
-    def connect_to_machine(node)
-      raise "#{self.class} does not override connect_to_machine"
-    end
-
-    # Delete the given machine (idempotent).  Should destroy the machine,
-    # returning things to the state before acquire_machine was called.
-    def delete_machine(action_handler, node)
-      raise "#{self.class} does not override delete_machine"
-    end
-
-    # Stop the given machine.
-    def stop_machine(action_handler, node)
-      raise "#{self.class} does not override stop_machine"
-    end
-
-    # Provider notification that happens at the point a resource is declared
-    # (after all properties have been set on it)
-    def resource_created(machine)
-    end
-
-    protected
-
-    def save_node(provider, node, chef_server)
-      # Save the node and create the client.  TODO strip automatic attributes first so we don't race with "current state"
-      ChefMetal.inline_resource(provider) do
-        chef_node node['name'] do
-          chef_server chef_server
-          raw_json node
-        end
-      end
-    end
-  end
-end

data/lib/chef_metal/instance.rb

@@ -1,54 +0,0 @@
-module ChefMetal
-  class Provisioner
-    def create_machine(instance)
-    end
-    def delete_machine(instance)
-    end
-    def stop_machine(instance)
-    end
-  end
-end
-
-module ChefMetal
-  class Instance
-    def create
-    end
-    def delete
-    end
-    def stop
-    end
-    def converge
-    end
-    def
-
-  end
-end
-
-
-- MachineList (physical)
-  - Driver (lists, creates, deletes associated machines)
-    EC2
-    LXC
-    Docker
-    BareMetal
-  - Machine (physical)
-    - Transport
-      SSH (+Rsync)
-      WinRM
-      LXC IPC
-      Docker API
-    - Provisioner
-      Chef Client
-      Puppet
-
-- Cluster (logical)
-  Chef server
-  Puppet master
-  - Instance (logical)
-    create
-    delete
-    exists?
-    provision
-    verify
-    execute
-    upload/download