chef-provisioning 0.15

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler'
+require 'bundler/gem_tasks'
+
+task :spec do
+  require File.expand_path('spec/run')
+end

data/lib/chef/provider/load_balancer.rb

@@ -0,0 +1,77 @@
+require 'chef/provider/lwrp_base'
+require 'chef/provider/chef_node'
+require 'openssl'
+require 'chef/provisioning/chef_provider_action_handler'
+require 'chef/provisioning/chef_load_balancer_spec'
+
+class Chef
+  class Provider
+    class LoadBalancer < Chef::Provider::LWRPBase
+
+      def action_handler
+        @action_handler ||= Chef::Provisioning::ChefProviderActionHandler.new(self)
+      end
+
+      def whyrun_supported?
+        true
+      end
+
+      def new_driver
+        @new_driver ||= run_context.chef_provisioning.driver_for(new_resource.driver)
+      end
+
+      action :create do
+        lb_spec = Chef::Provisioning::ChefLoadBalancerSpec.get(new_resource.name, new_resource.chef_server) ||
+                  Chef::Provisioning::ChefLoadBalancerSpec.empty(new_resource.name, new_resource.chef_server)
+
+        if lb_spec.location
+          # Updating
+          update_loadbalancer(lb_spec)
+        else
+          lb_spec.load_balancer_options = new_resource.load_balancer_options
+          lb_spec.machines = new_resource.machines
+          create_loadbalancer(lb_spec)
+        end
+      end
+
+      action :destroy do
+        lb_spec = Chef::Provisioning::ChefLoadBalancerSpec.get(new_resource.name, new_resource.chef_server)
+        new_driver.destroy_load_balancer(@action_handler, lb_spec, lb_options)
+      end
+
+      attr_reader :lb_spec
+
+
+      def update_loadbalancer(lb_spec)
+        machines = Hash[
+            *(new_resource.machines).collect {
+                |machine_name| [machine_name, get_machine_spec(machine_name)]
+            }.flatten
+        ]
+        new_driver.update_load_balancer(action_handler, lb_spec, lb_options, {
+                  :machines => machines
+                }
+            )
+        lb_spec.load_balancer_options = new_resource.load_balancer_options
+        lb_spec.machines = new_resource.machines
+        lb_spec.save(action_handler)
+      end
+
+      def create_loadbalancer(lb_spec)
+        new_driver.allocate_load_balancer(action_handler, lb_spec, lb_options)
+        lb_spec.save(action_handler)
+        new_driver.ready_load_balancer(action_handler, lb_spec, lb_options)
+      end
+
+      private
+      def get_machine_spec(machine_name)
+        Chef::Provisioning::ChefMachineSpec.get(machine_name, new_resource.chef_server)
+      end
+
+      def lb_options
+        new_resource.load_balancer_options
+      end
+
+    end
+  end
+end

data/lib/chef/provider/machine.rb

@@ -0,0 +1,176 @@
+require 'chef/provider/lwrp_base'
+require 'chef/provider/chef_node'
+require 'openssl'
+require 'chef/provisioning/chef_provider_action_handler'
+require 'chef/provisioning/chef_machine_spec'
+
+class Chef
+class Provider
+class Machine < Chef::Provider::LWRPBase
+
+  def action_handler
+    @action_handler ||= Chef::Provisioning::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_provisioning.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_provisioning.driver_for(new_resource.driver)
+  end
+
+  def current_driver
+    if machine_spec.driver_url
+      run_context.chef_provisioning.driver_for(machine_spec.driver_url)
+    end
+  end
+
+  def from_image_spec
+    @from_image_spec ||= begin
+      if new_resource.from_image
+        Chef::Provisioning::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']['chef_provisioning'] = node_driver.current_json['normal']['chef_provisioning']
+    @machine_spec = Chef::Provisioning::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
+end
+end

data/lib/chef/provider/machine_batch.rb

@@ -0,0 +1,191 @@
+require 'chef/chef_fs/parallelizer'
+require 'chef/provider/lwrp_base'
+require 'chef/provider/machine'
+require 'chef/provisioning/chef_provider_action_handler'
+require 'chef/provisioning/add_prefix_action_handler'
+require 'chef/provisioning/machine_spec'
+require 'chef/provisioning/chef_machine_spec'
+
+class Chef
+class Provider
+class MachineBatch < Chef::Provider::LWRPBase
+
+  def action_handler
+    @action_handler ||= Chef::Provisioning::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 = Chef::Provisioning::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 = Chef::Provisioning::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 = Chef::Provisioning::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 = Chef::Provisioning::AddPrefixActionHandler.new(action_handler, "[#{m[:spec].name}] ")
+      machine = run_context.chef_provisioning.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_provisioning.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_provisioning.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_provisioning.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?(Chef::Provisioning::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 = Chef::Provisioning::ChefMachineSpec.get(name, new_resource.chef_server) ||
+                       Chef::Provisioning::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_provisioning.config[:machine_options]) if run_context.chef_provisioning.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
+end
+end