chef-metal 0.14.2 → 0.15

data/lib/chef/provider/machine.rb

@@ -1,171 +0,0 @@
-require 'chef/provider/lwrp_base'
-require 'chef/provider/chef_node'
-require 'openssl'
-require 'chef_metal/chef_provider_action_handler'
-require 'chef_metal/chef_machine_spec'
-
-class Chef::Provider::Machine < Chef::Provider::LWRPBase
-
-  def action_handler
-    @action_handler ||= ChefMetal::ChefProviderActionHandler.new(self)
-  end
-
-  use_inline_resources
-
-  def whyrun_supported?
-    true
-  end
-
-  action :allocate do
-    if current_driver && current_driver.driver_url != new_driver.driver_url
-      raise "Cannot move '#{machine_spec.name}' from #{current_driver.driver_url} to #{new_driver.driver_url}: machine moving is not supported.  Destroy and recreate."
-    end
-    if !new_driver
-      raise "Driver not specified for machine #{machine_spec.name}"
-    end
-    new_driver.allocate_machine(action_handler, machine_spec, new_machine_options)
-    machine_spec.save(action_handler)
-  end
-
-  action :ready do
-    action_allocate
-    machine = current_driver.ready_machine(action_handler, machine_spec, current_machine_options)
-    machine_spec.save(action_handler)
-    machine
-  end
-
-  action :setup do
-    machine = action_ready
-    begin
-      machine.setup_convergence(action_handler)
-      machine_spec.save(action_handler)
-      upload_files(machine)
-    ensure
-      machine.disconnect
-    end
-  end
-
-  action :converge do
-    machine = action_ready
-    begin
-      machine.setup_convergence(action_handler)
-      machine_spec.save(action_handler)
-      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?) ||
-         !machine_spec.node['automatic'] || machine_spec.node['automatic'].size == 0
-        machine.converge(action_handler)
-      end
-    ensure
-      machine.disconnect
-    end
-  end
-
-  action :converge_only do
-    machine = run_context.chef_metal.connect_to_machine(machine_spec, current_machine_options)
-    begin
-      machine.converge(action_handler)
-    ensure
-      machine.disconnect
-    end
-  end
-
-  action :stop do
-    if current_driver
-      current_driver.stop_machine(action_handler, machine_spec, current_machine_options)
-    end
-  end
-
-  action :destroy do
-    if current_driver
-      current_driver.destroy_machine(action_handler, machine_spec, current_machine_options)
-    end
-  end
-
-  attr_reader :machine_spec
-
-  def new_driver
-    run_context.chef_metal.driver_for(new_resource.driver)
-  end
-
-  def current_driver
-    if machine_spec.driver_url
-      run_context.chef_metal.driver_for(machine_spec.driver_url)
-    end
-  end
-
-  def from_image_spec
-    @from_image_spec ||= begin
-      if new_resource.from_image
-        ChefMetal::ChefImageSpec.get(new_resource.from_image, new_resource.chef_server)
-      else
-        nil
-      end
-    end
-  end
-
-  def new_machine_options
-    machine_options(new_driver)
-  end
-
-  def current_machine_options
-    machine_options(current_driver)
-  end
-
-  def machine_options(driver)
-    configs = []
-
-    if from_image_spec && from_image_spec.machine_options
-      configs << from_image_spec.machine_options
-    end
-
-    configs << {
-      :convergence_options =>
-        [ :chef_server,
-          :allow_overwrite_keys,
-          :source_key, :source_key_path, :source_key_pass_phrase,
-          :private_key_options,
-          :ohai_hints,
-          :public_key_path, :public_key_format,
-          :admin, :validator
-        ].inject({}) do |result, key|
-          result[key] = new_resource.send(key)
-          result
-        end
-    }
-
-    configs << new_resource.machine_options if new_resource.machine_options
-    configs << driver.config[:machine_options] if driver.config[:machine_options]
-    Cheffish::MergedConfig.new(*configs)
-  end
-
-  def load_current_resource
-    node_driver = Chef::Provider::ChefNode.new(new_resource, run_context)
-    node_driver.load_current_resource
-    json = node_driver.new_json
-    json['normal']['metal'] = node_driver.current_json['normal']['metal']
-    @machine_spec = ChefMetal::ChefMachineSpec.new(json, new_resource.chef_server)
-  end
-
-  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(action_handler, local[:local_path], remote_file)
-          else
-            machine.write_file(action_handler, remote_file, local[:content])
-          end
-        else
-          machine.upload_file(action_handler, local, remote_file)
-        end
-      end
-    end
-  end
-
-  private
-
-  def upload_files(machine)
-    Machine.upload_files(action_handler, machine, new_resource.files)
-  end
-end

data/lib/chef/provider/machine_batch.rb

@@ -1,186 +0,0 @@
-require 'chef/chef_fs/parallelizer'
-require 'chef/provider/lwrp_base'
-require 'chef/provider/machine'
-require 'chef_metal/chef_provider_action_handler'
-require 'chef_metal/add_prefix_action_handler'
-require 'chef_metal/machine_spec'
-require 'chef_metal/chef_machine_spec'
-
-class Chef::Provider::MachineBatch < Chef::Provider::LWRPBase
-
-  def action_handler
-    @action_handler ||= ChefMetal::ChefProviderActionHandler.new(self)
-  end
-
-  use_inline_resources
-
-  def whyrun_supported?
-    true
-  end
-
-  def parallelizer
-    @parallelizer ||= Chef::ChefFS::Parallelizer.new(new_resource.max_simultaneous || 100)
-  end
-
-  action :allocate do
-    by_new_driver.each do |driver, specs_and_options|
-      driver.allocate_machines(action_handler, specs_and_options, parallelizer) do |machine_spec|
-        prefixed_handler = ChefMetal::AddPrefixActionHandler.new(action_handler, "[#{machine_spec.name}] ")
-        machine_spec.save(prefixed_handler)
-      end
-    end
-  end
-
-  action :ready do
-    with_ready_machines
-  end
-
-  action :setup do
-    with_ready_machines do |m|
-      prefixed_handler = ChefMetal::AddPrefixActionHandler.new(action_handler, "[#{m[:spec].name}] ")
-      m[:machine].setup_convergence(prefixed_handler)
-      m[:spec].save(prefixed_handler)
-      Chef::Provider::Machine.upload_files(prefixed_handler, m[:machine], m[:files])
-    end
-  end
-
-  action :converge do
-    with_ready_machines do |m|
-      prefixed_handler = ChefMetal::AddPrefixActionHandler.new(action_handler, "[#{m[:spec].name}] ")
-      m[:machine].setup_convergence(prefixed_handler)
-      m[:spec].save(action_handler)
-      Chef::Provider::Machine.upload_files(prefixed_handler, m[:machine], m[:files])
-      # TODO only converge if machine was modified
-      m[:machine].converge(prefixed_handler)
-      m[:spec].save(prefixed_handler)
-    end
-  end
-
-  action :converge_only do
-    parallel_do(@machines) do |m|
-      prefixed_handler = ChefMetal::AddPrefixActionHandler.new(action_handler, "[#{m[:spec].name}] ")
-      machine = run_context.chef_metal.connect_to_machine(m[:spec])
-      machine.converge(prefixed_handler)
-    end
-  end
-
-  action :destroy do
-    parallel_do(by_current_driver) do |driver, specs_and_options|
-      driver.destroy_machines(action_handler, specs_and_options, parallelizer)
-    end
-  end
-
-  action :stop do
-    parallel_do(by_current_driver) do |driver, specs_and_options|
-      driver.stop_machines(action_handler, specs_and_options, parallelizer)
-    end
-  end
-
-  def with_ready_machines
-    action_allocate
-    by_id = @machines.inject({}) { |hash,m| hash[m[:spec].id] = m; hash }
-    parallel_do(by_new_driver) do |driver, specs_and_options|
-      driver.ready_machines(action_handler, specs_and_options, parallelizer) do |machine|
-        machine.machine_spec.save(action_handler)
-
-        m = by_id[machine.machine_spec.id]
-
-        m[:machine] = machine
-        begin
-          yield m if block_given?
-        ensure
-          machine.disconnect
-        end
-      end
-    end
-  end
-
-  # 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 by_new_driver
-    result = {}
-    drivers = {}
-    @machines.each do |m|
-      if m[:desired_driver]
-        drivers[m[:desired_driver]] ||= run_context.chef_metal.driver_for(m[:desired_driver])
-        driver = drivers[m[:desired_driver]]
-        # Check whether the current driver is same or different; we disallow
-        # moving a machine from one place to another.
-        if m[:spec].driver_url
-          drivers[m[:spec].driver_url] ||= run_context.chef_metal.driver_for(m[:spec].driver_url)
-          current_driver = drivers[m[:spec].driver_url]
-          if driver.driver_url != current_driver.driver_url
-            raise "Cannot move '#{m[:spec].name}' from #{current_driver.driver_url} to #{driver.driver_url}: machine moving is not supported.  Destroy and recreate."
-          end
-        end
-        result[driver] ||= {}
-        result[driver][m[:spec]] = m[:machine_options].call(driver)
-      else
-        raise "No driver specified for #{m[:spec].name}"
-      end
-    end
-    result
-  end
-
-  def by_current_driver
-    result = {}
-    drivers = {}
-    @machines.each do |m|
-      if m[:spec].driver_url
-        drivers[m[:spec].driver_url] ||= run_context.chef_metal.driver_for(m[:spec].driver_url)
-        driver = drivers[m[:spec].driver_url]
-        result[driver] ||= {}
-        result[driver][m[:spec]] = m[:machine_options].call(driver)
-      end
-    end
-    result
-  end
-
-  def load_current_resource
-    # Load nodes in parallel
-    @machines = parallel_do(new_resource.machines) do |machine|
-      if machine.is_a?(Chef::Resource::Machine)
-        machine_resource = machine
-        provider = Chef::Provider::Machine.new(machine_resource, machine_resource.run_context)
-        provider.load_current_resource
-        {
-          :spec => provider.machine_spec,
-          :desired_driver => machine_resource.driver,
-          :files => machine_resource.files,
-          :machine_options => proc { |driver| provider.machine_options(driver) }
-        }
-      elsif machine.is_a?(ChefMetal::MachineSpec)
-        machine_spec = machine
-        {
-          :spec => machine_spec,
-          :desired_driver => new_resource.driver,
-          :files => new_resource.files,
-          :machine_options => proc { |driver| machine_options(driver) }
-        }
-      else
-        name = machine
-        machine_spec = ChefMetal::ChefMachineSpec.get(name, new_resource.chef_server) ||
-                       ChefMetal::ChefMachineSpec.empty(name, new_resource.chef_server)
-        {
-          :spec => machine_spec,
-          :desired_driver => new_resource.driver,
-          :files => new_resource.files,
-          :machine_options => proc { |driver| machine_options(driver) }
-        }
-      end
-    end.to_a
-  end
-
-  def machine_options(driver)
-    result = { :convergence_options => { :chef_server => new_resource.chef_server } }
-    result = Chef::Mixin::DeepMerge.hash_only_merge(result, run_context.chef_metal.config[:machine_options]) if run_context.chef_metal.config[:machine_options]
-    result = Chef::Mixin::DeepMerge.hash_only_merge(result, driver.config[:machine_options]) if driver.config && driver.config[:machine_options]
-    result = Chef::Mixin::DeepMerge.hash_only_merge(result, new_resource.machine_options)
-    result
-  end
-end

data/lib/chef/provider/machine_execute.rb

@@ -1,30 +0,0 @@
-require 'chef/provider/lwrp_base'
-require 'chef_metal/chef_provider_action_handler'
-require 'chef_metal/machine'
-
-class Chef::Provider::MachineExecute < Chef::Provider::LWRPBase
-
-  def action_handler
-    @action_handler ||= ChefMetal::ChefProviderActionHandler.new(self)
-  end
-
-  use_inline_resources
-
-  def whyrun_supported?
-    true
-  end
-
-  def machine
-    @machine ||= begin
-      if new_resource.machine.kind_of?(ChefMetal::Machine)
-        new_resource.machine
-      else
-        run_context.chef_metal.connect_to_machine(new_resource.machine, new_resource.chef_server)
-      end
-    end
-  end
-
-  action :run do
-    machine.execute(action_handler, new_resource.command)
-  end
-end

data/lib/chef/provider/machine_file.rb

@@ -1,49 +0,0 @@
-require 'chef/provider/lwrp_base'
-require 'chef_metal/chef_provider_action_handler'
-require 'chef_metal/machine'
-
-class Chef::Provider::MachineFile < Chef::Provider::LWRPBase
-
-  def action_handler
-    @action_handler ||= ChefMetal::ChefProviderActionHandler.new(self)
-  end
-
-  use_inline_resources
-
-  def whyrun_supported?
-    true
-  end
-
-  def machine
-    @machine ||= begin
-      if new_resource.machine.kind_of?(ChefMetal::Machine)
-        new_resource.machine
-      else
-        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(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

data/lib/chef/provider/machine_image.rb

@@ -1,54 +0,0 @@
-require 'chef/provider/lwrp_base'
-require 'chef/provider/chef_node'
-require 'openssl'
-require 'chef_metal/chef_provider_action_handler'
-require 'chef_metal/chef_image_spec'
-
-class Chef::Provider::MachineImage < Chef::Provider::LWRPBase
-  def action_handler
-    @action_handler ||= ChefMetal::ChefProviderActionHandler.new(self)
-  end
-
-  def load_current_resource
-  end
-
-  # Get the driver specified in the resource
-  def new_driver
-    @new_driver ||= run_context.chef_metal.driver_for(new_resource.driver)
-  end
-
-  action :create do
-    # Get the image mapping on the server (from name to image-id)
-    image_spec = ChefMetal::ChefImageSpec.get(new_resource.name, new_resource.chef_server) ||
-                 ChefMetal::ChefImageSpec.empty(new_resource.name, new_resource.chef_server)
-    if image_spec.location
-      # TODO check for real existence and maybe update
-    else
-      #
-      # Create a new image
-      #
-      image_spec.machine_options = new_resource.machine_options
-      create_image(image_spec)
-    end
-  end
-
-  action :destroy do
-  end
-
-  def create_image(image_spec)
-    # 1. Create the exemplar machine
-    machine_provider = Chef::Provider::Machine.new(new_resource, run_context)
-    machine_provider.load_current_resource
-    machine_provider.action_converge
-
-    # 2. Create the image
-    new_driver.allocate_image(action_handler, image_spec, new_resource.image_options,
-                              machine_provider.machine_spec)
-
-    # 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_resource.image_options)
-  end
-end