chef-metal 0.14.2 → 0.15

data/lib/chef_metal/add_prefix_action_handler.rb

@@ -1,29 +1 @@
-require 'chef_metal/action_handler'
-
-module ChefMetal
-  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
+require "chef/provisioning/add_prefix_action_handler"

data/lib/chef_metal/chef_image_spec.rb

@@ -1,106 +1 @@
-require 'chef_metal'
-require 'cheffish'
-require 'chef_metal/image_spec'
-
-module ChefMetal
-  #
-  # 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
-      ChefMetal.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
-      ChefMetal.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
+require "chef/provisioning/chef_image_spec"

data/lib/chef_metal/chef_machine_spec.rb

@@ -1,82 +1 @@
-require 'pry'
-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.  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
-        ChefMachineSpec.new(chef_api.get("/nodes/#{name}"), chef_server)
-      rescue Net::HTTPServerException => e
-        if e.response.code == '404'
-          nil
-        else
-          raise
-        end
-      end
-    end
-
-    # Creates a new empty MachineSpec with the given name.
-    def self.empty(name, chef_server = Cheffish.default_chef_server)
-      ChefMachineSpec.new({ 'name' => name, 'normal' => {} }, 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)
-      if location && (!location.is_a?(Hash) || !location['driver_url'])
-        raise "Drivers must specify a canonical driver_url in machine_spec.location.  Contact your driver's author."
-      end
-      # 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
+require "chef/provisioning/chef_machine_spec"

data/lib/chef_metal/chef_provider_action_handler.rb

@@ -1,72 +1 @@
-# -*- 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.
-
-require 'chef_metal/action_handler'
-
-# This is included in the metal drivers to proxy from generic requests needed
-# to specific driver actions
-module ChefMetal
-  class ChefProviderActionHandler < ActionHandler
-    def initialize(provider)
-      @provider = provider
-    end
-
-    attr_reader :provider
-
-    def updated!
-      provider.new_resource.updated_by_last_action(true)
-    end
-
-    def should_perform_actions
-      !provider.run_context.config.why_run
-    end
-
-    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 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 perform_action(description, &block)
-      provider.converge_by(description, &block)
-    end
-
-    def open_stream(name, &block)
-      if provider.run_context.respond_to?(:open_stream)
-        provider.run_context.open_stream({ :name => name }, &block)
-      else
-        if block_given?
-          yield STDOUT
-        else
-          STDOUT
-        end
-      end
-    end
-
-    def host_node
-      "#{provider.run_context.config[:chef_server_url]}/nodes/#{provider.run_context.node['name']}"
-    end
-  end
-end
+require "chef/provisioning/chef_provider_action_handler"

data/lib/chef_metal/chef_run_data.rb

@@ -1,125 +1 @@
-require 'chef/mixin/deep_merge'
-require 'cheffish/merged_config'
-require 'chef_metal/chef_machine_spec'
-
-module ChefMetal
-  class ChefRunData
-
-    def initialize(config)
-      @config = config
-      @drivers = {}
-    end
-
-    attr_reader :config
-    attr_reader :drivers
-    attr_reader :current_driver
-    attr_accessor :current_machine_options
-    attr_accessor :current_image_options
-
-
-    def with_machine_options(value)
-      old_value = self.current_machine_options
-      self.current_machine_options = value
-      if block_given?
-        begin
-          yield
-        ensure
-          self.current_machine_options = old_value
-        end
-      end
-    end
-
-    def with_image_options(value)
-      old_value = self.current_image_options
-      self.current_image_options = value
-      if block_given?
-        begin
-          yield
-        ensure
-          self.current_image_options = old_value
-        end
-      end
-    end
-
-
-    def with_driver(driver, options = nil, &block)
-      if drivers[driver] && options
-        raise "Driver #{driver} has already been created, options #{options} would be ignored!"
-      end
-      @current_driver = driver
-      @current_driver_options = options
-    end
-
-    def current_driver
-      @current_driver || config[:driver]
-    end
-
-    def current_machine_options
-      if @current_machine_options
-        @current_machine_options
-      else
-        {}
-      end
-    end
-
-    def current_image_options
-      if @current_image_options
-        @current_image_options
-      else
-        {}
-      end
-    end
-
-    def add_machine_options(options, &block)
-      with_machine_options(Chef::Mixin::DeepMerge.hash_only_merge(current_machine_options, options), &block)
-    end
-
-    def driver_for(driver)
-      driver.is_a?(String) ? driver_for_url(driver) : driver
-    end
-
-    def connect_to_machine(name, chef_server = nil)
-      if name.is_a?(MachineSpec)
-        machine_spec = name
-      else
-        machine_spec = ChefMetal::ChefMachineSpec.get(name, chef_server)
-      end
-      ChefMetal.connect_to_machine(machine_spec, config)
-    end
-
-    private
-
-    def driver_for_url(driver_url)
-      drivers[driver_url] ||= begin
-        if driver_url == @current_driver && @current_driver_options
-          # Use the driver options if available
-          merged_config = Cheffish::MergedConfig.new({ :driver_options => @current_driver_options }, config)
-          driver = ChefMetal.driver_for_url(driver_url, merged_config)
-        else
-          driver = ChefMetal.driver_for_url(driver_url, config)
-        end
-        # Check the canonicalized driver_url from the driver
-        if driver.driver_url != driver_url
-          if drivers[driver.driver_url] && @current_driver_options
-            raise "Canonical driver #{driver.driver_url} for #{driver_url} has already been created!  Current options #{@current_driver_options} would be ignored."
-          end
-          drivers[driver.driver_url] ||= driver
-        else
-          driver
-        end
-      end
-    end
-
-    def keys
-      result = (config.keys || {}).dup
-      Array(config.key_path) do |key_path|
-        Dir.entries(key_path).each do |key|
-          if File.extname(key) == '.pem'
-            result[File.basename(key)[0..-5]] ||= key
-          end
-        end
-      end
-      result
-    end
-  end
-end
+require "chef/provisioning/chef_run_data"

data/lib/chef_metal/convergence_strategy.rb

@@ -1,26 +1 @@
-module ChefMetal
-  class ConvergenceStrategy
-    # convergence_options - a freeform hash of options to the converger.
-    # config - a Chef::Config-like object with global config like :log_level
-    def initialize(convergence_options, config)
-      @convergence_options = convergence_options || {}
-      @config = config
-    end
-
-    attr_reader :convergence_options
-    attr_reader :config
-
-    # Get the machine ready to converge, but do not converge.
-    def setup_convergence(action_handler, machine)
-      raise "setup_convergence not overridden on #{self.class}"
-    end
-
-    def converge(action_handler, machine)
-      raise "converge not overridden on #{self.class}"
-    end
-
-    def cleanup_convergence(action_handler, machine_spec)
-      raise "cleanup_convergence not overridden on #{self.class}"
-    end
-  end
-end
+require "chef/provisioning/convergence_strategy"