chef-metal 0.10.2 → 0.11.beta

data/lib/chef/provider/machine_file.rb

@@ -1,10 +1,12 @@
 require 'chef/provider/lwrp_base'
-require 'cheffish/cheffish_server_api'
-require 'chef_metal/provider_action_handler'
+require 'chef_metal/chef_provider_action_handler'
+require 'chef_metal/machine'
 
 class Chef::Provider::MachineFile < Chef::Provider::LWRPBase
 
-  include ChefMetal::ProviderActionHandler
+  def action_handler
+    @action_handler ||= ChefMetal::ChefProviderActionHandler.new(self)
+  end
 
   use_inline_resources
 
@@ -17,18 +19,16 @@ class Chef::Provider::MachineFile < Chef::Provider::LWRPBase
       if new_resource.machine.kind_of?(ChefMetal::Machine)
         new_resource.machine
       else
-        # TODO this is inefficient, can we cache or something?
-        node = Cheffish::CheffishServerAPI.new(new_resource.chef_server).get("/nodes/#{new_resource.machine}")
-        new_resource.provisioner.connect_to_machine(node)
+        run_context.chef_metal.connect_to_machine(new_resource.machine, new_resource.chef_server)
       end
     end
   end
 
   action :upload do
     if new_resource.content
-      machine.write_file(self, new_resource.path, new_resource.content)
+      machine.write_file(action_handler, new_resource.path, new_resource.content)
     else
-      machine.upload_file(self, new_resource.local_path, new_resource.path)
+      machine.upload_file(action_handler, new_resource.local_path, new_resource.path)
     end
 
     attributes = {}
@@ -36,14 +36,14 @@ class Chef::Provider::MachineFile < Chef::Provider::LWRPBase
     attributes[:owner] = new_resource.owner if new_resource.owner
     attributes[:mode] = new_resource.mode if new_resource.mode
 
-    machine.set_attributes(self, new_resource.path, attributes)
+    machine.set_attributes(action_handler, new_resource.path, attributes)
   end
 
   action :download do
-    machine.download_file(self, new_resource.path, new_resource.local_path)
+    machine.download_file(action_handler, new_resource.path, new_resource.local_path)
   end
 
   action :delete do
-    machine.delete_file(self, new_resource.path)
+    machine.delete_file(action_handler, new_resource.path)
   end
 end

data/lib/chef/resource/machine.rb

@@ -9,31 +9,27 @@ class Chef::Resource::Machine < Chef::Resource::LWRPBase
     super
     @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
+    @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
 
-  def after_created
-    # Notify the provisioner of this machine's creation
-    @provisioner.resource_created(self)
-  end
-
-  actions :create, :delete, :stop, :converge, :nothing
-  default_action :create
+  actions :allocate, :ready, :setup, :converge, :converge_only, :destroy, :stop
+  default_action :converge
 
-  # Provisioner attributes
-  attribute :provisioner
-  attribute :provisioner_options
+  # Driver attributes
+  attribute :driver
+  attribute :machine_options
 
   # Node attributes
   Cheffish.node_attributes(self)
 
   # Client keys
   # Options to generate private key (size, type, etc.) when the server doesn't have it
-  attribute :private_key_options, :kind_of => String
+  attribute :private_key_options, :kind_of => Hash
+  attribute :allow_overwrite_keys, :kind_of => [TrueClass, FalseClass]
 
   # Optionally pull the public key out to a file
   attribute :public_key_path, :kind_of => String
@@ -88,8 +84,8 @@ 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)
+  def add_machine_options(options)
+    @machine_options = Chef::Mixin::DeepMerge.hash_only_merge(@machine_options, options)
   end
 
   # chef client version and omnibus

data/lib/chef/resource/machine_batch.rb

@@ -11,7 +11,7 @@ class Chef::Resource::MachineBatch < Chef::Resource::LWRPBase
 
   # 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
+  actions :acquire, :setup, :converge, :stop, :destroy
   default_action :converge
 
   attribute :machines, :kind_of => [ Array ]

data/lib/chef/resource/machine_execute.rb

@@ -1,7 +1,7 @@
 require 'chef/resource/lwrp_base'
 require 'chef_metal'
 require 'chef_metal/machine'
-require 'chef_metal/provisioner'
+require 'chef_metal/driver'
 
 class Chef::Resource::MachineExecute < Chef::Resource::LWRPBase
   self.resource_name = 'machine_execute'
@@ -9,15 +9,14 @@ class Chef::Resource::MachineExecute < Chef::Resource::LWRPBase
   def initialize(*args)
     super
     @chef_server = run_context.cheffish.current_chef_server
-    @provisioner = run_context.chef_metal.current_provisioner
   end
 
   actions :run
   default_action :run
 
   attribute :command, :kind_of => String, :name_attribute => true
-  attribute :machine, :kind_of => [String, ChefMetal::Machine]
+  attribute :machine, :kind_of => String
 
   attribute :chef_server, :kind_of => Hash
-  attribute :provisioner, :kind_of => ChefMetal::Provisioner
+  attribute :driver, :kind_of => ChefMetal::Driver
 end

data/lib/chef/resource/machine_file.rb

@@ -1,7 +1,7 @@
 require 'chef/resource/lwrp_base'
 require 'chef_metal'
 require 'chef_metal/machine'
-require 'chef_metal/provisioner'
+require 'chef_metal/driver'
 
 class Chef::Resource::MachineFile < Chef::Resource::LWRPBase
   self.resource_name = 'machine_file'
@@ -9,14 +9,13 @@ class Chef::Resource::MachineFile < Chef::Resource::LWRPBase
   def initialize(*args)
     super
     @chef_server = run_context.cheffish.current_chef_server
-    @provisioner = run_context.chef_metal.current_provisioner
   end
 
   actions :upload, :download, :delete, :nothing
   default_action :upload
 
   attribute :path, :kind_of => String, :name_attribute => true
-  attribute :machine, :kind_of => [String, ChefMetal::Machine]
+  attribute :machine, :kind_of => String
   attribute :local_path, :kind_of => String
   attribute :content
 
@@ -25,5 +24,5 @@ class Chef::Resource::MachineFile < Chef::Resource::LWRPBase
   attribute :mode, :kind_of => String
 
   attribute :chef_server, :kind_of => Hash
-  attribute :provisioner, :kind_of => ChefMetal::Provisioner
+  attribute :driver, :kind_of => ChefMetal::Driver
 end

data/lib/chef_metal.rb

@@ -1,15 +1,8 @@
 # Include recipe basics so require 'chef_metal' will load everything
 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/server_api'
 require 'cheffish/basic_chef_client'
+require 'cheffish/merged_config'
 
 module ChefMetal
   def self.inline_resource(action_handler, &block)
@@ -26,35 +19,40 @@ module ChefMetal
 
     def resource_update_applied(resource, action, update)
       prefix = action_handler.should_perform_actions ? "" : "Would "
-      update = Array(update).map { |u| "#{prefix}#{u}"}
+      update = Array(update).flatten.map { |u| "#{prefix}#{u}"}
       action_handler.performed_action(update)
     end
   end
 
+  # Helpers for driver inflation
+  @@registered_driver_classes = {}
+  def self.register_driver_class(name, driver)
+    @@registered_driver_classes[name] = driver
+  end
 
-  # Helpers for provisioner inflation
-  @@registered_provisioner_classes = {}
-  def self.add_registered_provisioner_class(name, provisioner)
-    @@registered_provisioner_classes[name] = provisioner
+  def self.config_for_url(driver_url, config = Chef::Config)
+    if config && config[:drivers] && config[:drivers][driver_url]
+      config = Cheffish::MergedConfig.new(config[:drivers][driver_url], config)
+    end
+    config || {}
   end
 
-  def self.provisioner_for_node(node)
-    provisioner_url = node['normal']['provisioner_output']['provisioner_url']
-    cluster_type = provisioner_url.split(':', 2)[0]
-    require "chef_metal/provisioner_init/#{cluster_type}_init"
-    provisioner_class = @@registered_provisioner_classes[cluster_type]
-    provisioner_class.inflate(node)
+  def self.driver_for_url(driver_url, config = Chef::Config)
+    cluster_type = driver_url.split(':', 2)[0]
+    require "chef_metal/driver_init/#{cluster_type}"
+    driver_class = @@registered_driver_classes[cluster_type]
+    config = config_for_url(driver_url, config)
+    driver_class.from_url(driver_url, config || {})
   end
 
-  def self.connect_to_machine(name)
-    rest = Chef::ServerAPI.new()
-    node = rest.get("/nodes/#{name}")
-    provisioner_output = node['normal']['provisioner_output']
-    if !provisioner_output
-      raise "Node #{name} was not provisioned with Metal."
+  def self.connect_to_machine(machine_spec, config = Chef::Config)
+    driver = driver_for_url(machine_spec.driver_url, config)
+    if driver
+      machine_options = { :convergence_options => { :chef_server => Cheffish.default_chef_server(config) } }
+      machine_options = Cheffish::MergedConfig.new(config[:machine_options], machine_options) if config[:machine_options]
+      driver.connect_to_machine(machine_spec, machine_options)
+    else
+      nil
     end
-    provisioner = provisioner_for_node(node)
-    machine = provisioner.connect_to_machine(node)
-    [ machine, provisioner ]
   end
 end

data/lib/chef_metal/action_handler.rb

@@ -30,8 +30,12 @@ module ChefMetal
       true
     end
 
+    def report_progress(description)
+      Array(description).each { |d| puts d }
+    end
+
     def performed_action(description)
-      puts description
+      Array(description).each { |d| puts d }
     end
 
     # This should perform the actual action (e.g., converge) if there is an
@@ -43,12 +47,6 @@ module ChefMetal
       performed_action(description)
     end
 
-    # This is the name that will show up in the output, so should be something
-    # like a cookbook or driver name
-    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?
@@ -57,5 +55,9 @@ module ChefMetal
         STDOUT
       end
     end
+
+    # A URL identifying the host node. nil if no such node.
+    def host_node
+    end
   end
 end

data/lib/chef_metal/add_prefix_action_handler.rb

@@ -12,16 +12,18 @@ module ChefMetal
     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_delegators :@action_handler, :should_perform_actions, :updated!, :open_stream, :host_node
+
+    def report_progress(description)
+      action_handler.report_progress(Array(description).flatten.map { |d| "#{prefix}#{d}" })
+    end
 
     def performed_action(description)
-      action_handler.performed_action(Array(description).map { |d| "#{prefix}#{d}" })
+      action_handler.performed_action(Array(description).flatten.map { |d| "#{prefix}#{d}" })
     end
 
     def perform_action(description, &block)
-      action_handler.perform_action(Array(description).map { |d| "#{prefix}#{d}" }, &block)
+      action_handler.perform_action(Array(description).flatten.map { |d| "#{prefix}#{d}" }, &block)
     end
   end
 end

data/lib/chef_metal/chef_machine_spec.rb

@@ -0,0 +1,64 @@
+require 'chef_metal'
+require 'cheffish'
+require 'chef_metal/machine_spec'
+
+module ChefMetal
+  #
+  # Specification for a machine. Sufficient information to find and contact it
+  # after it has been set up.
+  #
+  class ChefMachineSpec < MachineSpec
+    def initialize(node, chef_server)
+      super(node)
+      @chef_server = chef_server
+    end
+
+    #
+    # Get a MachineSpec from the chef server.
+    #
+    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)
+    end
+
+    #
+    # Globally unique identifier for this machine. Does not depend on the machine's
+    # location or existence.
+    #
+    def id
+      ChefMachineSpec.id_from(chef_server, name)
+    end
+
+    def self.id_from(chef_server, name)
+      "#{chef_server[:chef_server_url]}/nodes/#{name}"
+    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.
+      _self = self
+      _chef_server = _self.chef_server
+      ChefMetal.inline_resource(action_handler) do
+        chef_node _self.name do
+          chef_server _chef_server
+          raw_json _self.node
+        end
+      end
+    end
+
+    protected
+
+    attr_reader :chef_server
+
+    #
+    # Chef API object for the given Chef server
+    #
+    def chef_api
+      Cheffish.server_api_for(chef_server)
+    end
+  end
+end

data/lib/chef_metal/{provider_action_handler.rb → chef_provider_action_handler.rb}

@@ -16,37 +16,46 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# This is included in the metal provisioners to proxy from generic requests needed
-# to specific provider actions
+require 'chef_metal/action_handler'
+
+# This is included in the metal drivers to proxy from generic requests needed
+# to specific driver actions
 module ChefMetal
-  module ProviderActionHandler
-    # Implementation of ActionHandler interface
+  class ChefProviderActionHandler < ActionHandler
+    def initialize(provider)
+      @provider = provider
+    end
+
+    attr_reader :provider
 
     def updated!
-      self.new_resource.updated_by_last_action(true)
+      provider.new_resource.updated_by_last_action(true)
     end
 
     def should_perform_actions
-      !Chef::Config.why_run
+      !provider.run_context.config.why_run
     end
 
-    def performed_action(description)
-      self.converge_by description do
+    def report_progress(description)
+      # TODO this seems wrong but Chef doesn't have another thing
+      provider.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)
+    def performed_action(description)
+      provider.converge_by description do
+        # We already did the action, but we trust whoever told us that they did it.
+      end
     end
 
-    def debug_name
-      self.cookbook_name
+    def perform_action(description, &block)
+      provider.converge_by(description, &block)
     end
 
     def open_stream(name, &block)
-      if self.run_context.respond_to?(:open_stream)
-        self.run_context.open_stream({ :name => name }, &block)
+      if provider.run_context.respond_to?(:open_stream)
+        provider.run_context.open_stream({ :name => name }, &block)
       else
         if block_given?
           yield STDOUT
@@ -55,5 +64,9 @@ module ChefMetal
         end
       end
     end
+
+    def host_node
+      "#{provider.run_context.config[:chef_server_url]}/nodes/#{provider.run_context.node['name']}"
+    end
   end
 end