chef-provisioning 2.0.1 → 2.0.2

data/lib/chef/provider/machine_file.rb

@@ -1,55 +1,55 @@
-require 'chef/provider/lwrp_base'
-require 'chef/provisioning/chef_provider_action_handler'
-require 'chef/provisioning/machine'
-
-class Chef
-class Provider
-class MachineFile < Chef::Provider::LWRPBase
-  provides :machine_file
-
-  def action_handler
-    @action_handler ||= Chef::Provisioning::ChefProviderActionHandler.new(self)
-  end
-
-  use_inline_resources
-
-  def whyrun_supported?
-    true
-  end
-
-  def machine
-    @machine ||= begin
-      if new_resource.machine.kind_of?(Chef::Provisioning::Machine)
-        new_resource.machine
-      else
-        run_context.chef_provisioning.connect_to_machine(new_resource.machine, new_resource.chef_server)
-      end
-    end
-  end
-
-  action :upload do
-    if new_resource.content
-      machine.write_file(action_handler, new_resource.path, new_resource.content)
-    else
-      machine.upload_file(action_handler, new_resource.local_path, new_resource.path)
-    end
-
-    attributes = {}
-    attributes[:group] = new_resource.group if new_resource.group
-    attributes[:owner] = new_resource.owner if new_resource.owner
-    attributes[:mode] = new_resource.mode if new_resource.mode
-
-    machine.set_attributes(action_handler, new_resource.path, attributes)
-  end
-
-  action :download do
-    machine.download_file(action_handler, new_resource.path, new_resource.local_path)
-  end
-
-  action :delete do
-    machine.delete_file(action_handler, new_resource.path)
-  end
-
-end
-end
-end
+require 'chef/provider/lwrp_base'
+require 'chef/provisioning/chef_provider_action_handler'
+require 'chef/provisioning/machine'
+
+class Chef
+class Provider
+class MachineFile < Chef::Provider::LWRPBase
+  provides :machine_file
+
+  def action_handler
+    @action_handler ||= Chef::Provisioning::ChefProviderActionHandler.new(self)
+  end
+
+  use_inline_resources
+
+  def whyrun_supported?
+    true
+  end
+
+  def machine
+    @machine ||= begin
+      if new_resource.machine.kind_of?(Chef::Provisioning::Machine)
+        new_resource.machine
+      else
+        run_context.chef_provisioning.connect_to_machine(new_resource.machine, new_resource.chef_server)
+      end
+    end
+  end
+
+  action :upload do
+    if new_resource.content
+      machine.write_file(action_handler, new_resource.path, new_resource.content)
+    else
+      machine.upload_file(action_handler, new_resource.local_path, new_resource.path)
+    end
+
+    attributes = {}
+    attributes[:group] = new_resource.group if new_resource.group
+    attributes[:owner] = new_resource.owner if new_resource.owner
+    attributes[:mode] = new_resource.mode if new_resource.mode
+
+    machine.set_attributes(action_handler, new_resource.path, attributes)
+  end
+
+  action :download do
+    machine.download_file(action_handler, new_resource.path, new_resource.local_path)
+  end
+
+  action :delete do
+    machine.delete_file(action_handler, new_resource.path)
+  end
+
+end
+end
+end

data/lib/chef/provider/machine_image.rb

@@ -1,105 +1,105 @@
-require 'chef/provider/lwrp_base'
-require 'openssl'
-require 'chef/provisioning/chef_provider_action_handler'
-
-class Chef
-class Provider
-class MachineImage < Chef::Provider::LWRPBase
-  provides :machine_image
-
-  def action_handler
-    @action_handler ||= Chef::Provisioning::ChefProviderActionHandler.new(self)
-  end
-
-  def load_current_resource
-  end
-
-  # Get the driver specified in the resource
-  def new_driver
-    @new_driver ||= run_context.chef_provisioning.driver_for(new_resource.driver)
-  end
-
-  def chef_managed_entry_store
-    @chef_managed_entry_store ||= Provisioning.chef_managed_entry_store(new_resource.chef_server)
-  end
-
-  action :create do
-    # Get the image mapping on the server (from name to image-id)
-    image_spec = chef_managed_entry_store.get_or_new(:machine_image, new_resource.name)
-    if image_spec.reference
-      # TODO check for real existence and maybe update
-      new_driver.ready_image(action_handler, image_spec, new_image_options)
-    else
-      #
-      # Create a new image
-      #
-      create_image(image_spec, new_resource.machine_options || {})
-    end
-  end
-
-  action :destroy do
-    # Destroy the exemplar machine if it exists
-    machine_provider = Chef::Provider::Machine.new(new_resource, run_context)
-    machine_provider.action_handler = action_handler
-    machine_provider.load_current_resource
-    machine_provider.action_destroy
-
-    # Get the image mapping on the server (from name to image-id)
-    image_spec = chef_managed_entry_store.get(:machine_image, new_resource.name)
-
-    if image_spec && image_spec.reference
-      new_driver.destroy_image(action_handler, image_spec, new_resource.image_options)
-      image_spec.delete(action_handler)
-    end
-  end
-
-  def create_image(image_spec, machine_options)
-    # 1. Create the exemplar machine
-    machine_provider = Chef::Provider::Machine.new(new_resource, run_context)
-    machine_provider.action_handler = action_handler
-    machine_provider.load_current_resource
-    machine_provider.action_converge
-
-    # 2. Create the image
-    machine_options = new_machine_options
-    new_driver.allocate_image(action_handler, image_spec, new_image_options,
-                              machine_provider.machine_spec, machine_options)
-    image_spec.driver_url ||= new_driver.driver_url
-    image_spec.from_image ||= new_resource.from_image if new_resource.from_image
-    image_spec.run_list   ||= machine_provider.machine_spec.node['run_list']
-
-    # 3. Save the linkage from name -> image id
-    image_spec.save(action_handler)
-
-    # 4. Wait for image to be ready
-    new_driver.ready_image(action_handler, image_spec, new_image_options)
-
-    machine_provider.action_destroy
-  end
-
-  def new_image_options
-    @new_image_options ||= begin
-      configs = []
-      configs << new_resource.image_options if new_resource.image_options
-      # See documentation in machine.rb provider
-      (self.class.additional_image_option_keys || []).each do |k|
-        configs << { k => new_resource.send(k)} if new_resource.send(k)
-      end
-      Cheffish::MergedConfig.new(*configs)
-    end
-  end
-
-  def new_machine_options
-    @new_machine_options ||= new_resource.machine_options
-  end
-
-  def self.additional_image_option_keys
-    @@additional_image_option_keys ||= []
-  end
-
-end
-end
-end
-
-require 'chef/provisioning/chef_managed_entry_store'
-Chef::Provisioning::ChefManagedEntryStore.type_names_for_backcompat[:machine_image] = "images"
+require 'chef/provider/lwrp_base'
+require 'openssl'
+require 'chef/provisioning/chef_provider_action_handler'
+
+class Chef
+class Provider
+class MachineImage < Chef::Provider::LWRPBase
+  provides :machine_image
+
+  def action_handler
+    @action_handler ||= Chef::Provisioning::ChefProviderActionHandler.new(self)
+  end
+
+  def load_current_resource
+  end
+
+  # Get the driver specified in the resource
+  def new_driver
+    @new_driver ||= run_context.chef_provisioning.driver_for(new_resource.driver)
+  end
+
+  def chef_managed_entry_store
+    @chef_managed_entry_store ||= Provisioning.chef_managed_entry_store(new_resource.chef_server)
+  end
+
+  action :create do
+    # Get the image mapping on the server (from name to image-id)
+    image_spec = chef_managed_entry_store.get_or_new(:machine_image, new_resource.name)
+    if image_spec.reference
+      # TODO check for real existence and maybe update
+      new_driver.ready_image(action_handler, image_spec, new_image_options)
+    else
+      #
+      # Create a new image
+      #
+      create_image(image_spec, new_resource.machine_options || {})
+    end
+  end
+
+  action :destroy do
+    # Destroy the exemplar machine if it exists
+    machine_provider = Chef::Provider::Machine.new(new_resource, run_context)
+    machine_provider.action_handler = action_handler
+    machine_provider.load_current_resource
+    machine_provider.action_destroy
+
+    # Get the image mapping on the server (from name to image-id)
+    image_spec = chef_managed_entry_store.get(:machine_image, new_resource.name)
+
+    if image_spec && image_spec.reference
+      new_driver.destroy_image(action_handler, image_spec, new_resource.image_options)
+      image_spec.delete(action_handler)
+    end
+  end
+
+  def create_image(image_spec, machine_options)
+    # 1. Create the exemplar machine
+    machine_provider = Chef::Provider::Machine.new(new_resource, run_context)
+    machine_provider.action_handler = action_handler
+    machine_provider.load_current_resource
+    machine_provider.action_converge
+
+    # 2. Create the image
+    machine_options = new_machine_options
+    new_driver.allocate_image(action_handler, image_spec, new_image_options,
+                              machine_provider.machine_spec, machine_options)
+    image_spec.driver_url ||= new_driver.driver_url
+    image_spec.from_image ||= new_resource.from_image if new_resource.from_image
+    image_spec.run_list   ||= machine_provider.machine_spec.node['run_list']
+
+    # 3. Save the linkage from name -> image id
+    image_spec.save(action_handler)
+
+    # 4. Wait for image to be ready
+    new_driver.ready_image(action_handler, image_spec, new_image_options)
+
+    machine_provider.action_destroy
+  end
+
+  def new_image_options
+    @new_image_options ||= begin
+      configs = []
+      configs << new_resource.image_options if new_resource.image_options
+      # See documentation in machine.rb provider
+      (self.class.additional_image_option_keys || []).each do |k|
+        configs << { k => new_resource.send(k)} if new_resource.send(k)
+      end
+      Cheffish::MergedConfig.new(*configs)
+    end
+  end
+
+  def new_machine_options
+    @new_machine_options ||= new_resource.machine_options
+  end
+
+  def self.additional_image_option_keys
+    @@additional_image_option_keys ||= []
+  end
+
+end
+end
+end
+
+require 'chef/provisioning/chef_managed_entry_store'
+Chef::Provisioning::ChefManagedEntryStore.type_names_for_backcompat[:machine_image] = "images"

data/lib/chef/provisioning.rb

@@ -1,110 +1,110 @@
-# Include recipe basics so require 'chef/provisioning' will load everything
-require 'chef/provisioning/recipe_dsl'
-require 'chef/server_api'
-require 'cheffish/basic_chef_client'
-require 'cheffish/merged_config'
-require 'chef/provisioning/chef_managed_entry_store'
-
-class Chef
-module Provisioning
-  def self.inline_resource(action_handler, &block)
-    events = ActionHandlerForward.new(action_handler)
-    Cheffish::BasicChefClient.converge_block(nil, events, &block)
-  end
-
-  class ActionHandlerForward < Chef::EventDispatch::Base
-    def initialize(action_handler)
-      @action_handler = action_handler
-    end
-
-    attr_reader :action_handler
-
-    def resource_update_applied(resource, action, update)
-      prefix = action_handler.should_perform_actions ? "" : "Would "
-      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
-
-  def self.default_driver(config = Cheffish.profiled_config)
-    driver_for_url(config[:driver], config)
-  end
-
-  def self.driver_for_url(driver_url, config = Cheffish.profiled_config, allow_different_config = false)
-    #
-    # Create and cache the driver
-    #
-    #
-    # Figure out the driver class
-    #
-    scheme = driver_url.split(':', 2)[0]
-    begin
-      require "chef/provisioning/driver_init/#{scheme}"
-    rescue LoadError
-      begin
-        require "chef_metal/driver_init/#{scheme}"
-      rescue LoadError
-        # try the doomed require again so the stack trace shows the first LoadError and not the second (which
-        # would throw a confusing "chef_metal" into the error output of what is now chef-provisioning). one
-        # could also experiment with saving the first LoadError and re-raising it.
-        require "chef/provisioning/driver_init/#{scheme}"
-      end
-    end
-    driver_class = @@registered_driver_classes[scheme]
-    if !driver_class
-      raise "chef/provisioning/driver_init/#{scheme} did not register a driver class for #{scheme.inspect}!  Perhaps you have the case (uppercase or lowercase) wrong?"
-    end
-
-    #
-    # Merge in any driver-specific config
-    #
-    if config[:drivers] && config[:drivers][driver_url]
-      config = Cheffish::MergedConfig.new(config[:drivers][driver_url], config)
-    end
-
-    #
-    # Canonicalize the URL
-    #
-    canonicalized_url, canonicalized_config = driver_class.canonicalize_url(driver_url, config)
-    config = canonicalized_config if canonicalized_config
-
-    #
-    # Merge in config from the canonicalized URL if it is different
-    #
-    if canonicalized_url != driver_url
-      if config[:drivers] && config[:drivers][canonicalized_url]
-        config = Cheffish::MergedConfig.new(config[:drivers][canonicalized_url], config)
-      end
-    end
-
-    driver_class.from_url(canonicalized_url, config)
-  end
-
-  def self.connect_to_machine(machine_spec, config = Cheffish.profiled_config)
-    chef_server = Cheffish.default_chef_server(config)
-    if machine_spec.is_a?(String)
-      machine_spec = chef_managed_entry_store(chef_server).get(:machine, machine_spec)
-    end
-    driver = driver_for_url(machine_spec.driver_url, config)
-    if driver
-      machine_options = { :convergence_options => { :chef_server => chef_server } }
-      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
-  end
-
-  def self.chef_managed_entry_store(chef_server = Cheffish.default_chef_server)
-    Provisioning::ChefManagedEntryStore.new(chef_server)
-  end
-end
-end
-
-ChefMetal = Chef::Provisioning
+# Include recipe basics so require 'chef/provisioning' will load everything
+require 'chef/provisioning/recipe_dsl'
+require 'chef/server_api'
+require 'cheffish/basic_chef_client'
+require 'cheffish/merged_config'
+require 'chef/provisioning/chef_managed_entry_store'
+
+class Chef
+module Provisioning
+  def self.inline_resource(action_handler, &block)
+    events = ActionHandlerForward.new(action_handler)
+    Cheffish::BasicChefClient.converge_block(nil, events, &block)
+  end
+
+  class ActionHandlerForward < Chef::EventDispatch::Base
+    def initialize(action_handler)
+      @action_handler = action_handler
+    end
+
+    attr_reader :action_handler
+
+    def resource_update_applied(resource, action, update)
+      prefix = action_handler.should_perform_actions ? "" : "Would "
+      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
+
+  def self.default_driver(config = Cheffish.profiled_config)
+    driver_for_url(config[:driver], config)
+  end
+
+  def self.driver_for_url(driver_url, config = Cheffish.profiled_config, allow_different_config = false)
+    #
+    # Create and cache the driver
+    #
+    #
+    # Figure out the driver class
+    #
+    scheme = driver_url.split(':', 2)[0]
+    begin
+      require "chef/provisioning/driver_init/#{scheme}"
+    rescue LoadError
+      begin
+        require "chef_metal/driver_init/#{scheme}"
+      rescue LoadError
+        # try the doomed require again so the stack trace shows the first LoadError and not the second (which
+        # would throw a confusing "chef_metal" into the error output of what is now chef-provisioning). one
+        # could also experiment with saving the first LoadError and re-raising it.
+        require "chef/provisioning/driver_init/#{scheme}"
+      end
+    end
+    driver_class = @@registered_driver_classes[scheme]
+    if !driver_class
+      raise "chef/provisioning/driver_init/#{scheme} did not register a driver class for #{scheme.inspect}!  Perhaps you have the case (uppercase or lowercase) wrong?"
+    end
+
+    #
+    # Merge in any driver-specific config
+    #
+    if config[:drivers] && config[:drivers][driver_url]
+      config = Cheffish::MergedConfig.new(config[:drivers][driver_url], config)
+    end
+
+    #
+    # Canonicalize the URL
+    #
+    canonicalized_url, canonicalized_config = driver_class.canonicalize_url(driver_url, config)
+    config = canonicalized_config if canonicalized_config
+
+    #
+    # Merge in config from the canonicalized URL if it is different
+    #
+    if canonicalized_url != driver_url
+      if config[:drivers] && config[:drivers][canonicalized_url]
+        config = Cheffish::MergedConfig.new(config[:drivers][canonicalized_url], config)
+      end
+    end
+
+    driver_class.from_url(canonicalized_url, config)
+  end
+
+  def self.connect_to_machine(machine_spec, config = Cheffish.profiled_config)
+    chef_server = Cheffish.default_chef_server(config)
+    if machine_spec.is_a?(String)
+      machine_spec = chef_managed_entry_store(chef_server).get(:machine, machine_spec)
+    end
+    driver = driver_for_url(machine_spec.driver_url, config)
+    if driver
+      machine_options = { :convergence_options => { :chef_server => chef_server } }
+      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
+  end
+
+  def self.chef_managed_entry_store(chef_server = Cheffish.default_chef_server)
+    Provisioning::ChefManagedEntryStore.new(chef_server)
+  end
+end
+end
+
+ChefMetal = Chef::Provisioning