chef-metal 0.10.1 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75907d8e5aa3714df11b2d37090fb42babe16499
-  data.tar.gz: 61cadff437fe83b341b74da8d41d9d0164c670c7
+  metadata.gz: af79447510d93b295a7d77a3223d670bdc569415
+  data.tar.gz: ac28faf8d8afa3026960b9997de94d9c4fc77369
 SHA512:
-  metadata.gz: 6b46ef77e100475dd856861eb9db77202919dd28150b7606b9deddd8658c7594c2922755aaae0b2c9af71f71905f8b33b9a31dcb15e79dc9fffaba338d5981a2
-  data.tar.gz: 4fd6d879cb7d174f5ef65b7af723f4079e017f04975f42e4c6f9346e2888485aec7b3b3b70a1ca56d74e6678ee0a3b6483c54ef05f5b3c80c57ffb4f6d76bbde
+  metadata.gz: 49762ba3a7f0f71677b85d6f9657cdb05174c1d389ba96825bb218f9af7dd557f35ab515dd391865caba7dc20a6a3ddfbd12b1a3c566219bab1e6cda7d8248fa
+  data.tar.gz: 5412dfb1f503aa30259bf37c16a7f8e46dffc98c7434375fefaf208a3745af25208052d60a4982a6a809444eaaeb82211e6490fa5a9c52cced6a7347cf70c0a0

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Chef Metal Changelog
 
+## 0.10.2 (5/2/2014)
+
+- Fix crash with add_provisioner_options when provisioner_options is not yet set
+
 ## 0.10.1 (5/2/2014)
 
 - Fix a crash when uploading files in a machine batch

data/lib/chef_metal/chef_run_data.rb

@@ -9,7 +9,11 @@ module ChefMetal
     with :machine_batch
 
     def add_provisioner_options(options, &block)
-      with_provisioner_options(Chef::Mixin::DeepMerge.hash_only_merge(current_provisioner_options, options), &block)
+      if current_provisioner_options
+        with_provisioner_options(Chef::Mixin::DeepMerge.hash_only_merge(current_provisioner_options, options), &block)
+      else
+        with_provisioner_options(options)
+      end
     end
   end
 end

data/lib/chef_metal/machine_spec.rb

@@ -0,0 +1,81 @@
+require 'cheffish'
+require 'cheffish/cheffish_server_api'
+
+module ChefMetal
+  #
+  # Specification for a machine. Sufficient information to find and contact it
+  # after it has been set up.
+  #
+  class MachineSpec
+    def initialize(node, chef_server)
+      @node = node
+      @chef_server = chef_server
+    end
+
+    def self.get(name, chef_server)
+      rest = Cheffish::CheffishServerAPI.new(chef_server || Cheffish.current_chef_server)
+      MachineSpec.new(rest.get("/nodes/#{name}"), chef_server)
+    end
+
+    #
+    # Globally unique identifier for this machine. Does not depend on the machine's
+    # location or existence.
+    #
+    def id
+      "#{@chef_server[:chef_server_url]}/nodes/#{name}"
+    end
+
+    #
+    # Name of the machine. Corresponds to the name in "machine 'name' do" ...
+    #
+    def name
+      @node['name']
+    end
+
+    #
+    # Location of this machine. This should be a freeform hash, with enough
+    # information for the provider to look it up and create a Machine object to
+    # access it.
+    #
+    # This MUST include a 'provider_url' attribute with the provider's URL in it.
+    #
+    # chef-metal will do its darnedest to not lose this information.
+    #
+    def location
+      metal_attr('location')
+    end
+
+    #
+    # Set the location for this machine.
+    #
+    def location=(value)
+      @node['normal']['metal'] ||= {}
+      @node['normal']['metal']['spec'] = value
+    end
+
+    #
+    # Save this node to the server.  If you have significant information that
+    # could be lost, you should do this as quickly as possible.  Data will be
+    # saved automatically for you after allocate_machine and ready_machine.
+    #
+    def save(action_handler)
+      # Save the node to the server.
+      ChefMetal.inline_resource(action_handler) do
+        chef_node node['name'] do
+          chef_server @chef_server
+          raw_json node
+        end
+      end
+    end
+
+    private
+
+    def metal_attr(attr)
+      if @node['normal'] && @node['normal']['metal']
+        @node['normal']['metal'][attr]
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/chef_metal/provider.rb

@@ -0,0 +1,239 @@
+module ChefMetal
+  #
+  # A Provider instance represents a place where machines can be created and found,
+  # and contains methods to create, delete, start, stop, and find them.
+  #
+  # For AWS, a Provider instance corresponds to a single account.
+  # For Vagrant, it is a directory where VM files are found.
+  #
+  # == How to Make a Provider
+  #
+  # To implement a Provider, you must implement the following methods:
+  #
+  # - initialize(driver_url) - create a new driver with the given URL
+  # - driver_url - a URL representing everything unique about your provider.
+  #                But NOT credentials.
+  # - allocate_machine - ask the driver to allocate a machine to you.
+  # - ready_machine - get the machine "ready" - wait for it to be booted and
+  #                   accessible (for example, accessible via SSH transport).
+  # - stop_machine - stop the machine.
+  # - delete_machine - delete the machine.
+  # - connect_to_machine - connect to the given machine.
+  #
+  # Optionally, you can also implement:
+  # - allocate_machines - allocate an entire group of machines.
+  # - resource_created - a hook to tell you when a resource associated with your
+  #                      provider has been created.
+  #
+  # Additionally, you must create a file named `chef_metal/provider_init/<scheme>.rb`,
+  # where <scheme> is the name of the scheme you chose for your driver_url. This
+  # file, when required, must call
+  #
+  # All of these methods must be idempotent - if the work is already done, they
+  # just don't do anything.
+  #
+  class Provider
+    #
+    # Inflate a driver from node information; we don't want to force the
+    # driver to figure out what the driver really needs, since it varies
+    # from driver to driver.
+    #
+    # ## Parameters
+    # driver_url - the URL to inflate the driver
+    #
+    # ## Returns
+    # A Provider representing the given driver_url.
+    def initialize(driver_url)
+      # We do not save it ... it's up to the driver to extract whatever information
+      # it wants.
+    end
+
+    #
+    # A URL representing the driver and the place where machines come from.
+    # This will be stuffed in attributes in the node so that the node can be
+    # reinflated.  URLs must have a unique scheme identifying the driver
+    # class, and enough information to identify the place where created machines
+    # can be found.  For AWS, this is the account number; for lxc and vagrant,
+    # it is the directory in which VMs and containers are.
+    #
+    # For example:
+    # - fog:AWS:123456789012
+    # - vagrant:/var/vms
+    # - lxc:
+    # - docker:
+    #
+    def driver_url
+      raise "#{self.class} does not implement driver_url"
+    end
+
+    #
+    # Allocate a machine from the PXE/cloud/VM/container provider.  This method
+    # does not need to wait for the machine to boot or have an IP, but it must
+    # store enough information in node['normal']['driver_output'] to find
+    # the machine later in ready_machine.
+    #
+    # If a machine is powered off or otherwise unusable, this method may start
+    # it, but does not need to wait until it is started.  The idea is to get the
+    # gears moving, but the job doesn't need to be done :)
+    #
+    # ## 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).
+    #
+    # existing_machine - a MachineSpec representing the existing machine (if any).
+    #
+    # machine_options - a set of options representing the desired provisioning
+    #                   state of the machine (image name, bootstrap ssh credentials,
+    #                   etc.). This will NOT be stored in the node, and is
+    #                   ephemeral.
+    #
+    # ## Returns
+    #
+    # Modifies the passed-in machine_spec.  Anything in here will be saved
+    # back to the node.
+    #
+    def allocate_machine(action_handler, machine_spec, machine_options)
+      raise "#{self.class} does not implement allocate_machine"
+    end
+
+    #
+    # Ready a machine, to the point where it is running and accessible via a
+    # transport. This will NOT allocate a machine, but may kick it if it is down.
+    # This method waits for the machine to be usable, returning a Machine object
+    # pointing at the machine, allowing useful actions like setup, converge,
+    # execute, file and directory.
+    #
+    # ## 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).
+    # machine_spec - MachineSpec representing this machine.
+    #
+    # ## Returns
+    #
+    # Machine object pointing at the machine, allowing useful actions like setup,
+    # converge, execute, file and directory.
+    #
+    def ready_machine(action_handler, machine_spec)
+      raise "#{self.class} does not implement ready_machine"
+    end
+
+    #
+    # Connect to a machine without allocating or readying it.  This method will
+    # NOT make any changes to anything, or attempt to wait.
+    #
+    # ## Parameters
+    # machine_spec - MachineSpec representing this machine.
+    #
+    # ## Returns
+    #
+    # Machine object pointing at the machine, allowing useful actions like setup,
+    # converge, execute, file and directory.
+    #
+    def connect_to_machine(machine_spec)
+      raise "#{self.class} does not implement connect_to_machine"
+    end
+
+    #
+    # Delete the given machine (idempotent).  Should destroy the machine,
+    # returning things to the state before allocate_machine was called.
+    #
+    def delete_machine(action_handler, machine_spec)
+      raise "#{self.class} does not implement delete_machine"
+    end
+
+    #
+    # Stop the given machine.
+    #
+    def stop_machine(action_handler, machine_spec)
+      raise "#{self.class} does not implement stop_machine"
+    end
+
+    #
+    # Optional interface methods
+    #
+
+    #
+    # Allocate a set of machines.  This should have the same effect as running
+    # allocate_machine on all nodes.
+    #
+    # Providers do not need to implement this; the default implementation
+    # calls acquire_machine in parallel.
+    #
+    # ## Parameter
+    # 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).
+    # nodes - a list of nodes representing the nodes to acquire.
+    # parallelizer - an object with a parallelize() method that works like this:
+    #
+    #   parallelizer.parallelize(nodes) do |node|
+    #     allocate_machine(action_handler, node)
+    #   end.to_a
+    #   # The to_a at the end causes you to wait until the parallelization is done
+    #
+    # This object is shared among other chef-metal actions, ensuring that you do
+    # not go over parallelization limits set by the user.  Use of the parallelizer
+    # to parallelizer machines is not required.
+    #
+    def allocate_machines(action_handler, machine_specs, parallelizer)
+      parallelizer.parallelize(machine_specs) do |machine_spec|
+        allocate_machine(add_prefix(machine_spec, action_handler), machine_spec)
+        yield machine_spec if block_given?
+        machine
+      end.to_a
+    end
+
+    # Acquire machines in batch, in parallel if possible.
+    def acquire_machines(action_handler, machine_specs, parallelizer)
+      parallelizer.parallelize(machine_specs) do |machine_spec|
+        machine = acquire_machine(add_prefix(machine_spec, action_handler), machine_spec)
+        yield machine_spec, 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(machine_specs) do |machine_spec|
+        stop_machine(add_prefix(machine_spec, action_handler), machine_spec)
+        yield machine_spec if block_given?
+      end.to_a
+    end
+
+    # Delete machines in batch, in parallel if possible.
+    def delete_machines(action_handler, machine_specs, parallelizer)
+      parallelizer.parallelize(machine_specs) do |machine_spec|
+        delete_machine(add_prefix(machine_spec, action_handler), machine_spec)
+        yield machine_spec if block_given?
+      end.to_a
+    end
+
+    #
+    # Provider notification that happens at the point a machine 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
+
+    def add_prefix(node_json, action_handler)
+      AddPrefixActionHandler.new(action_handler, "[#{node_json['name']}] ")
+    end
+  end
+end

data/lib/chef_metal/version.rb

@@ -1,3 +1,3 @@
 module ChefMetal
-  VERSION = '0.10.1'
+  VERSION = '0.10.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.10.2
 platform: ruby
 authors:
 - John Keiser
@@ -172,7 +172,9 @@ files:
 - lib/chef_metal/machine/unix_machine.rb
 - lib/chef_metal/machine/windows_machine.rb
 - lib/chef_metal/machine.rb
+- lib/chef_metal/machine_spec.rb
 - lib/chef_metal/openstack_credentials.rb
+- lib/chef_metal/provider.rb
 - lib/chef_metal/provider_action_handler.rb
 - lib/chef_metal/provisioner.rb
 - lib/chef_metal/recipe_dsl.rb