clc-fork-chef-metal 0.11.beta.5

data/lib/chef/provider/machine_execute.rb

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

@@ -0,0 +1,49 @@
+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/resource/machine.rb

@@ -0,0 +1,95 @@
+require 'chef/resource/lwrp_base'
+require 'cheffish'
+require 'chef_metal'
+
+class Chef::Resource::Machine < Chef::Resource::LWRPBase
+  self.resource_name = 'machine'
+
+  def initialize(*args)
+    super
+    @chef_environment = run_context.cheffish.current_environment
+    @chef_server = run_context.cheffish.current_chef_server
+    @driver = run_context.chef_metal.current_driver
+    @machine_options = run_context.chef_metal.current_machine_options
+    if run_context.chef_metal.current_machine_batch
+      run_context.chef_metal.current_machine_batch.machines << self
+    end
+  end
+
+  actions :allocate, :ready, :setup, :converge, :converge_only, :destroy, :stop
+  default_action :converge
+
+  # Driver attributes
+  attribute :driver
+  attribute :machine_options
+
+  # Node attributes
+  Cheffish.node_attributes(self)
+
+  # Client keys
+  # Options to generate private key (size, type, etc.) when the server doesn't have it
+  attribute :private_key_options, :kind_of => Hash
+  attribute :allow_overwrite_keys, :kind_of => [TrueClass, FalseClass]
+
+  # Optionally pull the public key out to a file
+  attribute :public_key_path, :kind_of => String
+  attribute :public_key_format, :kind_of => String
+
+  # If you really want to force the private key to be a certain key, pass these
+  attribute :source_key
+  attribute :source_key_path, :kind_of => String
+  attribute :source_key_pass_phrase
+
+  # Client attributes
+  attribute :admin, :kind_of => [TrueClass, FalseClass]
+  attribute :validator, :kind_of => [TrueClass, FalseClass]
+
+  # Client Ohai hints, allows machine to enable hints
+  # e.g. ohai_hint 'ec2' => { 'a' => 'b' } creates file ec2.json with json contents { 'a': 'b' }
+  attribute :ohai_hints, :kind_of => Hash
+
+  # Allows you to turn convergence off in the :create action by writing "converge false"
+  # or force it with "true"
+  attribute :converge, :kind_of => [TrueClass, FalseClass]
+
+  # A list of files to upload, in the format REMOTE_PATH => LOCAL_PATH|HASH.
+  # == Examples
+  # files '/remote/path.txt' => '/local/path.txt'
+  # files '/remote/path.txt' => { :local_path => '/local/path.txt' }
+  # files '/remote/path.txt' => { :content => 'woo' }
+  attribute :files, :kind_of => Hash
+
+  # A single file to upload, in the format REMOTE_PATH, LOCAL_PATH|HASH.
+  # This directive may be passed multiple times, and multiple files will be uploaded.
+  # == Examples
+  # file '/remote/path.txt', '/local/path.txt'
+  # file '/remote/path.txt', { :local_path => '/local/path.txt' }
+  # file '/remote/path.txt', { :content => 'woo' }
+  def file(remote_path, local = nil)
+    @files ||= {}
+    if remote_path.is_a?(Hash)
+      if local
+        raise "file(Hash, something) does not make sense.  Either pass a hash, or pass a pair, please."
+      end
+      remote_path.each_pair do |remote, local|
+        @files[remote] = local
+      end
+    elsif remote_path.is_a?(String)
+      if !local
+        raise "Must pass both a remote path and a local path to file directive"
+      end
+      @files[remote_path] = local
+    else
+      raise "file remote_path must be a String, but is a #{remote_path.class}"
+    end
+  end
+
+  def add_machine_options(options)
+    @machine_options = Chef::Mixin::DeepMerge.hash_only_merge(@machine_options, options)
+  end
+
+  # chef client version and omnibus
+  # chef-zero boot method?
+  # chef-client -z boot method?
+  # pushy boot method?
+end

data/lib/chef/resource/machine_batch.rb

@@ -0,0 +1,20 @@
+require 'chef/resource/lwrp_base'
+
+class Chef::Resource::MachineBatch < Chef::Resource::LWRPBase
+  self.resource_name = 'machine_batch'
+
+  def initialize(*args)
+    super
+    @machines = []
+    @chef_server = run_context.cheffish.current_chef_server
+  end
+
+  # TODO there is a useful action sequence where one does an ohai on all machines,
+  # waits for that to complete, save the nodes, and THEN converges.
+  actions :acquire, :setup, :converge, :stop, :destroy
+  default_action :converge
+
+  attribute :machines, :kind_of => [ Array ]
+  attribute :max_simultaneous, :kind_of => [ Integer ]
+  attribute :chef_server
+end

data/lib/chef/resource/machine_execute.rb

@@ -0,0 +1,22 @@
+require 'chef/resource/lwrp_base'
+require 'chef_metal'
+require 'chef_metal/machine'
+require 'chef_metal/driver'
+
+class Chef::Resource::MachineExecute < Chef::Resource::LWRPBase
+  self.resource_name = 'machine_execute'
+
+  def initialize(*args)
+    super
+    @chef_server = run_context.cheffish.current_chef_server
+  end
+
+  actions :run
+  default_action :run
+
+  attribute :command, :kind_of => String, :name_attribute => true
+  attribute :machine, :kind_of => String
+
+  attribute :chef_server, :kind_of => Hash
+  attribute :driver, :kind_of => ChefMetal::Driver
+end

data/lib/chef/resource/machine_file.rb

@@ -0,0 +1,28 @@
+require 'chef/resource/lwrp_base'
+require 'chef_metal'
+require 'chef_metal/machine'
+require 'chef_metal/driver'
+
+class Chef::Resource::MachineFile < Chef::Resource::LWRPBase
+  self.resource_name = 'machine_file'
+
+  def initialize(*args)
+    super
+    @chef_server = run_context.cheffish.current_chef_server
+  end
+
+  actions :upload, :download, :delete, :nothing
+  default_action :upload
+
+  attribute :path, :kind_of => String, :name_attribute => true
+  attribute :machine, :kind_of => String
+  attribute :local_path, :kind_of => String
+  attribute :content
+
+  attribute :owner, :kind_of => String
+  attribute :group, :kind_of => String
+  attribute :mode, :kind_of => String
+
+  attribute :chef_server, :kind_of => Hash
+  attribute :driver, :kind_of => ChefMetal::Driver
+end

data/lib/chef_metal.rb

@@ -0,0 +1,62 @@
+# Include recipe basics so require 'chef_metal' will load everything
+require 'chef_metal/recipe_dsl'
+require 'chef/server_api'
+require 'cheffish/basic_chef_client'
+require 'cheffish/merged_config'
+
+module ChefMetal
+  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.config_for_url(driver_url, config = Cheffish.profiled_config)
+    if config && config[:drivers] && config[:drivers][driver_url]
+      config = Cheffish::MergedConfig.new(config[:drivers][driver_url], config)
+    end
+    config || {}
+  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)
+    cluster_type = driver_url.split(':', 2)[0]
+    require "chef_metal/driver_init/#{cluster_type}"
+    driver_class = @@registered_driver_classes[cluster_type]
+    config = config_for_url(driver_url, config)
+    driver_class.from_url(driver_url, config || {})
+  end
+
+  def self.connect_to_machine(machine_spec, config = Cheffish.profiled_config)
+    driver = driver_for_url(machine_spec.driver_url, config)
+    if driver
+      machine_options = { :convergence_options => { :chef_server => Cheffish.default_chef_server(config) } }
+      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

data/lib/chef_metal/action_handler.rb

@@ -0,0 +1,63 @@
+# -*- 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
+module ChefMetal
+  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
+        yield
+      end
+      performed_action(description)
+    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

data/lib/chef_metal/add_prefix_action_handler.rb

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

data/lib/chef_metal/chef_machine_spec.rb

@@ -0,0 +1,64 @@
+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.
+    #
+    def self.get(name, chef_server = Cheffish.default_chef_server)
+      chef_api = Cheffish.chef_server_api(chef_server)
+      ChefMachineSpec.new(chef_api.get("/nodes/#{name}"), 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)
+      # 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