chef-provisioning 0.15

data/lib/chef/provider/machine_execute.rb

@@ -0,0 +1,35 @@
+require 'chef/provider/lwrp_base'
+require 'chef/provisioning/chef_provider_action_handler'
+require 'chef/provisioning/machine'
+
+class Chef
+class Provider
+class MachineExecute < Chef::Provider::LWRPBase
+
+  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 :run do
+    machine.execute(action_handler, new_resource.command)
+  end
+
+end
+end
+end

data/lib/chef/provider/machine_file.rb

@@ -0,0 +1,54 @@
+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
+
+  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

@@ -0,0 +1,60 @@
+require 'chef/provider/lwrp_base'
+require 'chef/provider/chef_node'
+require 'openssl'
+require 'chef/provisioning/chef_provider_action_handler'
+require 'chef/provisioning/chef_image_spec'
+
+class Chef
+class Provider
+class MachineImage < Chef::Provider::LWRPBase
+
+  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
+
+  action :create do
+    # Get the image mapping on the server (from name to image-id)
+    image_spec = Chef::Provisioning::ChefImageSpec.get(new_resource.name, new_resource.chef_server) ||
+                 Chef::Provisioning::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
+end
+end

data/lib/chef/provisioning.rb

@@ -0,0 +1,95 @@
+# 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'
+
+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 => e
+      require "chef_metal/driver_init/#{scheme}"
+    end
+    driver_class = @@registered_driver_classes[scheme]
+
+    #
+    # 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 = ChefMachineSpec.get(machine_spec, chef_server)
+    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
+end
+end
+
+ChefMetal = Chef::Provisioning

data/lib/chef/provisioning/action_handler.rb

@@ -0,0 +1,68 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Douglas Triggs (<doug@getchef.com>)
+#
+# Copyright (C) 2014, Chef, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This is the generic action handler
+class Chef
+module Provisioning
+  class ActionHandler
+
+    # This should be replaced with whatever records the update; by default it
+    # essentially does nothing here.
+    def updated!
+      @updated = true
+    end
+
+    def should_perform_actions
+      true
+    end
+
+    def report_progress(description)
+      Array(description).each { |d| puts d }
+    end
+
+    def performed_action(description)
+      Array(description).each { |d| puts d }
+    end
+
+    # This should perform the actual action (e.g., converge) if there is an
+    # action that needs to be done.
+    def perform_action(description)
+      if should_perform_actions
+        result = yield
+      else
+        result = nil
+      end
+      performed_action(description)
+      result
+    end
+
+    # Open a stream which can be printed to and closed
+    def open_stream(name)
+      if block_given?
+        yield STDOUT
+      else
+        STDOUT
+      end
+    end
+
+    # A URL identifying the host node. nil if no such node.
+    def host_node
+    end
+  end
+end
+end

data/lib/chef/provisioning/add_prefix_action_handler.rb

@@ -0,0 +1,31 @@
+require 'chef/provisioning/action_handler'
+
+class Chef
+module Provisioning
+  class AddPrefixActionHandler
+    extend Forwardable
+
+    def initialize(action_handler, prefix)
+      @action_handler = action_handler
+      @prefix = prefix
+    end
+
+    attr_reader :action_handler
+    attr_reader :prefix
+
+    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).flatten.map { |d| "#{prefix}#{d}" })
+    end
+
+    def perform_action(description, &block)
+      action_handler.perform_action(Array(description).flatten.map { |d| "#{prefix}#{d}" }, &block)
+    end
+  end
+end
+end

data/lib/chef/provisioning/chef_image_spec.rb

@@ -0,0 +1,108 @@
+require 'chef/provisioning'
+require 'cheffish'
+require 'chef/provisioning/image_spec'
+
+class Chef
+module Provisioning
+  #
+  # Specification for a image. Sufficient information to find and contact it
+  # after it has been set up.
+  #
+  class ChefImageSpec < ImageSpec
+    def initialize(node, chef_server)
+      super(node)
+      @chef_server = chef_server
+    end
+
+    #
+    # Get a ImageSpec from the chef server.  If the node does not exist on the
+    # server, it returns nil.
+    #
+    def self.get(name, chef_server = Cheffish.default_chef_server)
+      chef_api = Cheffish.chef_server_api(chef_server)
+      begin
+        data = chef_api.get("/data/images/#{name}")
+        data['machine_options'] = strings_to_symbols(data['machine_options'])
+        ChefImageSpec.new(data, chef_server)
+      rescue Net::HTTPServerException => e
+        if e.response.code == '404'
+          nil
+        else
+          raise
+        end
+      end
+    end
+
+    # Creates a new empty ImageSpec with the given name.
+    def self.empty(id, chef_server = Cheffish.default_chef_server)
+      ChefImageSpec.new({ 'id' => id }, chef_server)
+    end
+
+    #
+    # Globally unique identifier for this image. Does not depend on the image's
+    # location or existence.
+    #
+    def id
+      ChefImageSpec.id_from(chef_server, name)
+    end
+
+    def self.id_from(chef_server, name)
+      "#{chef_server[:chef_server_url]}/data/images/#{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_image and ready_image.
+    #
+    def save(action_handler)
+      # Save the node to the server.
+      _self = self
+      _chef_server = _self.chef_server
+      Chef::Provisioning.inline_resource(action_handler) do
+        chef_data_bag_item _self.name do
+          data_bag 'images'
+          chef_server _chef_server
+          raw_data _self.image_data
+        end
+      end
+    end
+
+    def delete(action_handler)
+      # Save the node to the server.
+      _self = self
+      _chef_server = _self.chef_server
+      Chef::Provisioning.inline_resource(action_handler) do
+        chef_data_bag_item _self.name do
+          data_bag 'images'
+          chef_server _chef_server
+          action :destroy
+        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
+
+    def self.strings_to_symbols(data)
+      if data.is_a?(Hash)
+        result = {}
+        data.each_pair do |key, value|
+          result[key.to_sym] = strings_to_symbols(value)
+        end
+        result
+      else
+        data
+      end
+    end
+  end
+end
+end