chef-metal 0.4 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93940616771e3e091f441bce2587a1383f7859ef
-  data.tar.gz: 8e49d7a64afdc1fe06c82b99056accc1b4ae587c
+  metadata.gz: ae7198497aa5a5f38de02410732e0a1aab44e63a
+  data.tar.gz: bebf3d3226651b34c9bf334ac427c85d4ec6d6af
 SHA512:
-  metadata.gz: 1815d8c7b09c9fdb5fa68bcea2282abe2253bb71e4d3345c12b75774e545dea7532ddb45772f428b4c65b4361fb9006b45e633d12c80cdd780860f89b9b06886
-  data.tar.gz: 5bf3f00b97b72d98a9fcbf962c99bcb201afc696ae7ed25f9ef023234442e16cfab6e1a5e0d4256554a4ad3769f881b986be6593ebfb637624361708c2cd77e8
+  metadata.gz: b3f43cbc60deb6bf72f4aec3dabfcb16689896f74ab3b58abcd61cf6b97801402c903f75701837d015f7aa990f470c580367782f2ba9749d3cb69d7a931d5f69
+  data.tar.gz: 4cc81e32caf611a3f518b440ea8d2c4ef7a3b9be34f04993ab59f85f68750ede2e9cfc2f0220b2675a8aaf12e13f975b9801889d54a5a33c59cea681b33e11cf

data/lib/chef/provider/fog_key_pair.rb

@@ -1,7 +1,10 @@
 require 'chef/provider/lwrp_base'
+require 'chef_metal/provider_action_handler'
 
 class Chef::Provider::FogKeyPair < Chef::Provider::LWRPBase
 
+  include ChefMetal::ProviderActionHandler
+
   use_inline_resources
 
   def whyrun_supported?

data/lib/chef/provider/machine.rb

@@ -1,9 +1,12 @@
 require 'chef/provider/lwrp_base'
 require 'chef/provider/chef_node'
 require 'openssl'
+require 'chef_metal/provider_action_handler'
 
 class Chef::Provider::Machine < Chef::Provider::LWRPBase
 
+  include ChefMetal::ProviderActionHandler
+
   use_inline_resources
 
   def whyrun_supported?

data/lib/chef/provider/machine_file.rb

@@ -27,10 +27,17 @@ class Chef::Provider::MachineFile < Chef::Provider::LWRPBase
     else
       machine.upload_file(self, 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(self, new_resource.path, attributes)
   end
 
   action :download do
-    machine.download_file(provider, new_resource.path, new_resource.local_path)
+    machine.download_file(self, new_resource.path, new_resource.local_path)
   end
 
   action :delete do

data/lib/chef/provider/vagrant_cluster.rb

@@ -1,7 +1,10 @@
 require 'chef/provider/lwrp_base'
+require 'chef_metal/provider_action_handler'
 
 class Chef::Provider::VagrantCluster < Chef::Provider::LWRPBase
 
+  include ChefMetal::ProviderActionHandler
+
   use_inline_resources
 
   def whyrun_supported?

data/lib/chef/resource/machine_file.rb

@@ -20,6 +20,10 @@ class Chef::Resource::MachineFile < Chef::Resource::LWRPBase
   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 :provisioner, :kind_of => ChefMetal::Provisioner
 end

data/lib/chef_metal.rb

@@ -32,8 +32,8 @@ module ChefMetal
     end
   end
 
-  def self.inline_resource(provider, &block)
-    InlineResource.new(provider).instance_eval(&block)
+  def self.inline_resource(action_handler, &block)
+    InlineResource.new(action_handler).instance_eval(&block)
   end
 
   @@enclosing_provisioner = nil
@@ -48,7 +48,21 @@ module ChefMetal
   def self.enclosing_provisioner_options
     @@enclosing_provisioner_options
   end
+
   def self.enclosing_provisioner_options=(provisioner_options)
     @@enclosing_provisioner_options = provisioner_options
   end
+
+  @@registered_provisioner_classes = {}
+  def self.add_registered_provisioner_class(name, provisioner)
+    @@registered_provisioner_classes[name] = provisioner
+  end
+
+  def self.provisioner_for_node(node)
+    provisioner_url = node['normal']['provisioner_output']['provisioner_url']
+    cluster_type = provisioner_url.split(':', 2)[0]
+    require "chef_metal/provisioner_init/#{cluster_type}_init"
+    provisioner_class = @@registered_provisioner_classes[cluster_type]
+    provisioner_class.inflate(node)
+  end
 end

data/lib/chef_metal/action_handler.rb

@@ -0,0 +1,49 @@
+# -*- 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 the run context
+    def recipe_context
+      raise ActionFailed, "ActionHandler behavior requires a recipe_context"
+    end
+
+    # This should be repaced with whatever records the update; by default it
+    # essentially does nothing here.
+    def updated!
+      @updated = true
+    end
+
+    # This should perform the actual action (e.g., converge) if there is an
+    # action that needs to be done.
+    #
+    # By default, it will simply execute the block as so:
+    def perform_action(description, &block)
+      puts description
+      block.call
+    end
+
+    # This is the name that will show up in the output, so should be something
+    # like a cookbook or driver name
+    def debug_name
+      raise ActionFailed, "ActionHandler behavior requires a debug_name"
+    end
+  end
+end

data/lib/chef_metal/convergence_strategy.rb

@@ -1,15 +1,15 @@
 module ChefMetal
   class ConvergenceStrategy
-    def setup_convergence(provider, machine, machine_resource)
+    def setup_convergence(action_handler, machine, machine_resource)
       raise "setup_convergence not overridden on #{self.class}"
     end
 
-    def converge(provider, machine)
+    def converge(action_handler, machine)
       raise "converge not overridden on #{self.class}"
     end
 
-    def delete_chef_objects(provider, node)
-      raise "delete_chef_objects not overridden on #{self.class}"
+    def cleanup_convergence(action_handler, node)
+      raise "cleanup_convergence not overridden on #{self.class}"
     end
   end
-end
+end

data/lib/chef_metal/convergence_strategy/install_cached.rb

@@ -19,26 +19,26 @@ module ChefMetal
         @package_cache_lock = Mutex.new
       end
 
-      def setup_convergence(provider, machine, machine_resource)
+      def setup_convergence(action_handler, machine, machine_resource)
         super
 
         # Install chef-client.  TODO check and update version if not latest / not desired
         if machine.execute_always('chef-client -v').exitstatus != 0
-          platform, platform_version, machine_architecture = machine.detect_os(provider)
-          package_file = download_package_for_platform(provider, machine, platform, platform_version, machine_architecture)
+          platform, platform_version, machine_architecture = machine.detect_os(action_handler)
+          package_file = download_package_for_platform(action_handler, machine, platform, platform_version, machine_architecture)
           remote_package_file = "#{@tmp_dir}/#{File.basename(package_file)}"
-          machine.upload_file(provider, package_file, remote_package_file)
-          install_package(provider, machine, remote_package_file)
+          machine.upload_file(action_handler, package_file, remote_package_file)
+          install_package(action_handler, machine, remote_package_file)
         end
       end
 
-      def converge(provider, machine)
-        machine.execute(provider, 'chef-client')
+      def converge(action_handler, machine)
+        machine.execute(action_handler, 'chef-client')
       end
 
       private
 
-      def download_package_for_platform(provider, machine, platform, platform_version, machine_architecture)
+      def download_package_for_platform(action_handler, machine, platform, platform_version, machine_architecture)
         @package_cache_lock.synchronize do
           @package_cache ||= {}
           @package_cache[platform] ||= {}
@@ -55,7 +55,7 @@ module ChefMetal
             # Download actual package desired by metadata
             package_file = "#{@package_cache_path}/#{URI(metadata['url']).path.split('/')[-1]}"
 
-            ChefMetal.inline_resource(provider) do
+            ChefMetal.inline_resource(action_handler) do
               remote_file package_file do
                 source metadata['url']
                 checksum metadata['sha256']
@@ -75,9 +75,9 @@ module ChefMetal
         metadata_url="https://www.opscode.com/chef/metadata"
         metadata_url << "?v=#{@chef_version}"
         metadata_url << "&prerelease=#{@prerelease ? 'true' : 'false'}"
-        metadata_url << "&p=#{platform}"
-        metadata_url << "&pv=#{platform_version}"
-        metadata_url << "&m=#{machine_architecture}"
+        metadata_url << "&p=#{platform.strip}"
+        metadata_url << "&pv=#{platform_version.strip}"
+        metadata_url << "&m=#{machine_architecture.strip}"
         use_ssl = true
 
         # solaris 9 lacks openssl, solaris 10 lacks recent enough credentials - your base O/S is completely insecure, please upgrade
@@ -102,23 +102,23 @@ module ChefMetal
         metadata
       end
 
-      def install_package(provider, machine, remote_package_file)
+      def install_package(action_handler, machine, remote_package_file)
         extension = File.extname(remote_package_file)
         result = case extension
         when '.rpm'
-          machine.execute(provider, "rpm -Uvh --oldpackage --replacepkgs \"#{remote_package_file}\"")
+          machine.execute(action_handler, "rpm -Uvh --oldpackage --replacepkgs \"#{remote_package_file}\"")
         when '.deb'
-          machine.execute(provider, "dpkg -i \"#{remote_package_file}\"")
+          machine.execute(action_handler, "dpkg -i \"#{remote_package_file}\"")
         when '.solaris'
-          machine.write_file(provider, "#{@tmp_dir}/nocheck", <<EOM)
+          machine.write_file(action_handler, "#{@tmp_dir}/nocheck", <<EOM)
 conflict=nocheck
 action=nocheck
 mail=
 EOM
-          machine.execute(provider, "pkgrm -a \"#{@tmp_dir}/nocheck\" -n chef")
-          machine.execute(provider, "pkgadd -n -d \"#{remote_package_file}\" -a \"#{@tmp_dir}/nocheck\" chef")
+          machine.execute(action_handler, "pkgrm -a \"#{@tmp_dir}/nocheck\" -n chef")
+          machine.execute(action_handler, "pkgadd -n -d \"#{remote_package_file}\" -a \"#{@tmp_dir}/nocheck\" chef")
         when '.sh'
-          machine.execute(provider, "sh \"#{remote_package_file}\"")
+          machine.execute(action_handler, "sh \"#{remote_package_file}\"")
         else
           raise "Unknown package extension '#{extension}' for file #{remote_package_file}"
         end

data/lib/chef_metal/convergence_strategy/install_msi.rb

@@ -14,7 +14,7 @@ module ChefMetal
       attr_reader :install_msi_url
       attr_reader :install_msi_path
 
-      def setup_convergence(provider, machine, machine_resource)
+      def setup_convergence(action_handler, machine, machine_resource)
         system_drive = machine.execute_always('$env:SystemDrive').stdout.strip
         @client_rb_path ||= "#{system_drive}\\chef\\client.rb"
         @client_pem_path ||= "#{system_drive}\\chef\\client.pem"
@@ -27,12 +27,12 @@ module ChefMetal
           # TODO find a way to cache this on the host like with the Unix stuff.
           # Limiter is we don't know how to efficiently upload large files to
           # the remote machine with WMI.
-          machine.execute(provider, "(New-Object System.Net.WebClient).DownloadFile(#{machine.escape(install_msi_url)}, #{machine.escape(install_msi_path)})")
-          machine.execute(provider, "msiexec /qn /i #{machine.escape(install_msi_path)}")
+          machine.execute(action_handler, "(New-Object System.Net.WebClient).DownloadFile(#{machine.escape(install_msi_url)}, #{machine.escape(install_msi_path)})")
+          machine.execute(action_handler, "msiexec /qn /i #{machine.escape(install_msi_path)}")
         end
       end
 
-      def converge(provider, machine)
+      def converge(action_handler, machine)
         # TODO For some reason I get a 500 back if I don't do -l debug
         machine.transport.execute("chef-client -l debug")
       end

data/lib/chef_metal/convergence_strategy/install_sh.rb

@@ -16,20 +16,20 @@ module ChefMetal
       attr_reader :install_sh_url
       attr_reader :install_sh_path
 
-      def setup_convergence(provider, machine, machine_resource)
+      def setup_convergence(action_handler, machine, machine_resource)
         super
 
         # Install chef-client.  TODO check and update version if not latest / not desired
         if machine.execute_always('chef-client -v').exitstatus != 0
           # TODO ssh verification of install.sh before running arbtrary code would be nice?
           @@install_sh_cache[install_sh_url] ||= Net::HTTP.get(URI(install_sh_url))
-          machine.write_file(provider, install_sh_path, @@install_sh_cache[install_sh_url], :ensure_dir => true)
-          machine.execute(provider, "bash #{install_sh_path}")
+          machine.write_file(action_handler, install_sh_path, @@install_sh_cache[install_sh_url], :ensure_dir => true)
+          machine.execute(action_handler, "bash #{install_sh_path}")
         end
       end
 
-      def converge(provider, machine)
-        machine.execute(provider, 'chef-client')
+      def converge(action_handler, machine)
+        machine.execute(action_handler, 'chef-client')
       end
     end
   end

data/lib/chef_metal/convergence_strategy/no_converge.rb

@@ -0,0 +1,34 @@
+require 'chef_metal/convergence_strategy'
+require 'pathname'
+require 'cheffish'
+
+module ChefMetal
+  class ConvergenceStrategy
+    class NoConverge < ConvergenceStrategy
+      attr_reader :client_rb_path
+      attr_reader :client_pem_path
+
+      def setup_convergence(action_handler, machine, machine_resource)
+        # Save the node
+        ChefMetal.inline_resource(action_handler) do
+          # TODO strip automatic attributes first so we don't race with "current state"
+          chef_node machine.node['name'] do
+            chef_server machine_resource.chef_server
+            raw_json machine.node
+          end
+        end
+      end
+
+      def converge(action_handler, machine)
+      end
+
+      def cleanup_convergence(action_handler, node)
+        ChefMetal.inline_resource(action_handler) do
+          chef_node node['name'] do
+            action :delete
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef_metal/convergence_strategy/precreate_chef_objects.rb

@@ -1,5 +1,6 @@
 require 'chef_metal/convergence_strategy'
 require 'pathname'
+require 'cheffish'
 
 module ChefMetal
   class ConvergenceStrategy
@@ -13,11 +14,11 @@ module ChefMetal
       attr_reader :client_rb_path
       attr_reader :client_pem_path
 
-      def setup_convergence(provider, machine, machine_resource)
+      def setup_convergence(action_handler, machine, machine_resource)
         # Create keys on machine
-        public_key = create_keys(provider, machine, machine_resource)
+        public_key = create_keys(action_handler, machine, machine_resource)
         # Create node and client on chef server
-        create_chef_objects(provider, machine, machine_resource, public_key)
+        create_chef_objects(action_handler, machine, machine_resource, public_key)
 
         # If the chef server lives on localhost, tunnel the port through to the guest
         chef_server_url = machine_resource.chef_server[:chef_server_url]
@@ -29,11 +30,11 @@ module ChefMetal
 
         # Create client.rb and client.pem on machine
         content = client_rb_content(chef_server_url, machine.node['name'])
-        machine.write_file(provider, client_rb_path, content, :ensure_dir => true)
+        machine.write_file(action_handler, client_rb_path, content, :ensure_dir => true)
       end
 
-      def delete_chef_objects(provider, node)
-        ChefMetal.inline_resource(provider) do
+      def cleanup_convergence(action_handler, node)
+        ChefMetal.inline_resource(action_handler) do
           chef_node node['name'] do
             action :delete
           end
@@ -45,7 +46,7 @@ module ChefMetal
 
       protected
 
-      def create_keys(provider, machine, machine_resource)
+      def create_keys(action_handler, machine, machine_resource)
         server_private_key = machine.read_file(client_pem_path)
         if server_private_key
           begin
@@ -61,7 +62,7 @@ module ChefMetal
             # If the server private key does not match our source key, overwrite it
             server_private_key = source_key
             if machine_resource.allow_overwrite_keys
-              machine.write_file(provider, client_pem_path, server_private_key.to_pem, :ensure_dir => true)
+              machine.write_file(action_handler, client_pem_path, server_private_key.to_pem, :ensure_dir => true)
             else
               raise "Private key on machine #{machine_resource.name} does not match desired input key."
             end
@@ -70,7 +71,7 @@ module ChefMetal
         else
 
           # If the server does not already have keys, create them and upload
-          Cheffish.inline_resource(provider) do
+          Cheffish.inline_resource(action_handler) do
             private_key 'in_memory' do
               path :none
               if machine_resource.private_key_options
@@ -82,7 +83,7 @@ module ChefMetal
             end
           end
 
-          machine.write_file(provider, client_pem_path, server_private_key.to_pem, :ensure_dir => true)
+          machine.write_file(action_handler, client_pem_path, server_private_key.to_pem, :ensure_dir => true)
         end
 
         server_private_key.public_key
@@ -106,9 +107,9 @@ module ChefMetal
         end
       end
 
-      def create_chef_objects(provider, machine, machine_resource, public_key)
+      def create_chef_objects(action_handler, machine, machine_resource, public_key)
         # Save the node and create the client keys and client.
-        ChefMetal.inline_resource(provider) do
+        ChefMetal.inline_resource(action_handler) do
           # Create client
           chef_client machine.node['name'] do
             chef_server machine_resource.chef_server

data/lib/chef_metal/inline_resource.rb

@@ -1,13 +1,13 @@
 module ChefMetal
   class InlineResource
-    def initialize(provider)
-      @provider = provider
+    def initialize(action_handler)
+      @action_handler = action_handler
     end
 
-    attr_reader :provider
+    attr_reader :action_handler
 
-    def run_context
-      provider.run_context
+    def recipe_context
+      action_handler.recipe_context
     end
 
     def method_missing(method_symbol, *args, &block)
@@ -16,21 +16,24 @@ module ChefMetal
       # Checks the new platform => short_name => resource mapping initially
       # then fall back to the older approach (Chef::Resource.const_get) for
       # backward compatibility
-      resource_class = Chef::Resource.resource_for_node(method_symbol, provider.run_context.node)
+      resource_class = Chef::Resource.resource_for_node(method_symbol,
+        action_handler.recipe_context.node)
 
       super unless resource_class
       raise ArgumentError, "You must supply a name when declaring a #{method_symbol} resource" unless args.size > 0
 
       # If we have a resource like this one, we want to steal its state
-      args << run_context
+      args << recipe_context
       resource = resource_class.new(*args)
       resource.source_line = caller[0]
       resource.load_prior_resource
-      resource.cookbook_name = provider.cookbook_name
+      resource.cookbook_name = action_handler.debug_name
       resource.recipe_name = @recipe_name
       resource.params = @params
-      # Determine whether this resource is being created in the context of an enclosing Provider
-      resource.enclosing_provider = provider.is_a?(Chef::Provider) ? provider : nil
+      # Determine whether this resource is being created in the context of an
+      # enclosing Provider
+      resource.enclosing_provider =
+        action_handler.is_a?(Chef::Provider) ? action_handler : nil
       # Evaluate resource attribute DSL
       resource.instance_eval(&block) if block
 
@@ -38,13 +41,13 @@ module ChefMetal
       resource.after_created
 
       # Do NOT put this in the resource collection.
-      #run_context.resource_collection.insert(resource)
+      #recipe_context.resource_collection.insert(resource)
 
       # Instead, run the action directly.
       Array(resource.action).each do |action|
         resource.updated_by_last_action(false)
         run_provider_action(resource.provider_for_action(action))
-        provider.new_resource.updated_by_last_action(true) if resource.updated_by_last_action?
+        action_handler.updated! if resource.updated_by_last_action?
       end
       resource
     end
@@ -85,4 +88,4 @@ module ChefMetal
       inline_provider.cleanup_after_converge
     end
   end
-end
+end