chef-metal 0.4 → 0.5

data/lib/chef_metal/machine.rb

@@ -9,16 +9,16 @@ module ChefMetal
     # Sets up everything necessary for convergence to happen on the machine.
     # The node MUST be saved as part of this procedure.  Other than that,
     # nothing is guaranteed except that converge() will work when this is done.
-    def setup_convergence(provider)
+    def setup_convergence(action_handler)
       raise "setup_convergence not overridden on #{self.class}"
     end
 
-    def converge(provider)
+    def converge(action_handler)
       raise "converge not overridden on #{self.class}"
     end
 
 
-    def execute(provider, command)
+    def execute(action_handler, command)
       raise "execute not overridden on #{self.class}"
     end
 
@@ -26,24 +26,24 @@ module ChefMetal
       raise "read_file not overridden on #{self.class}"
     end
 
-    def download_file(provider, path, local_path)
+    def download_file(action_handler, path, local_path)
       raise "read_file not overridden on #{self.class}"
     end
 
-    def write_file(provider, path, content)
+    def write_file(action_handler, path, content)
       raise "write_file not overridden on #{self.class}"
     end
 
-    def upload_file(provider, local_path, path)
+    def upload_file(action_handler, local_path, path)
       raise "write_file not overridden on #{self.class}"
     end
 
-    def create_dir(provider, path)
+    def create_dir(action_handler, path)
       raise "create_dir not overridden on #{self.class}"
     end
 
     # Delete file
-    def delete_file(provider, path)
+    def delete_file(action_handler, path)
       raise "delete_file not overridden on #{self.class}"
     end
 
@@ -58,7 +58,7 @@ module ChefMetal
     end
 
     # Set file attributes { mode, :owner, :group }
-    def set_attributes(provider, path, attributes)
+    def set_attributes(action_handler, path, attributes)
       raise "set_attributes not overridden on #{self.class}"
     end
 
@@ -76,13 +76,13 @@ module ChefMetal
       raise "disconnect not overridden on #{self.class}"
     end
 
-    # TODO get rid of the provider attribute, that is ridiculous
+    # TODO get rid of the action_handler attribute, that is ridiculous
     # Detect the OS on the machine (assumes the machine is up)
     # Returns a triplet:
-    #   platform, platform_version, machine_architecture = machine.detect_os(provider)
+    #   platform, platform_version, machine_architecture = machine.detect_os(action_handler)
     # This triplet is suitable for passing to the Chef metadata API:
     # https://www.opscode.com/chef/metadata?p=#{platform}&pv=#{platform_version}&m=#{machine_architecture}
-    def detect_os(provider)
+    def detect_os(action_handler)
       raise "detect_os not overridden on #{self.class}"
     end
   end

data/lib/chef_metal/machine/basic_machine.rb

@@ -15,16 +15,16 @@ module ChefMetal
       # Sets up everything necessary for convergence to happen on the machine.
       # The node MUST be saved as part of this procedure.  Other than that,
       # nothing is guaranteed except that converge() will work when this is done.
-      def setup_convergence(provider, machine_resource)
-        convergence_strategy.setup_convergence(provider, self, machine_resource)
+      def setup_convergence(action_handler, machine_resource)
+        convergence_strategy.setup_convergence(action_handler, self, machine_resource)
       end
 
-      def converge(provider)
-        convergence_strategy.converge(provider, self)
+      def converge(action_handler)
+        convergence_strategy.converge(action_handler, self)
       end
 
-      def execute(provider, command)
-        provider.converge_by "run '#{command}' on #{node['name']}" do
+      def execute(action_handler, command)
+        action_handler.converge_by "run '#{command}' on #{node['name']}" do
           transport.execute(command).error!
         end
       end
@@ -37,31 +37,31 @@ module ChefMetal
         transport.read_file(path)
       end
 
-      def download_file(provider, path, local_path)
+      def download_file(action_handler, path, local_path)
         if files_different?(path, local_path)
-          provider.converge_by "download file #{path} on #{node['name']} to #{local_path}" do
+          action_handler.converge_by "download file #{path} on #{node['name']} to #{local_path}" do
             transport.download_file(path, local_path)
           end
         end
       end
 
-      def write_file(provider, path, content, options = {})
+      def write_file(action_handler, path, content, options = {})
         if files_different?(path, nil, content)
           if options[:ensure_dir]
-            create_dir(provider, dirname_on_machine(path))
+            create_dir(action_handler, dirname_on_machine(path))
           end
-          provider.converge_by "write file #{path} on #{node['name']}" do
+          action_handler.converge_by "write file #{path} on #{node['name']}" do
             transport.write_file(path, content)
           end
         end
       end
 
-      def upload_file(provider, local_path, path, options = {})
+      def upload_file(action_handler, local_path, path, options = {})
         if files_different?(path, local_path)
           if options[:ensure_dir]
-            create_dir(provider, dirname_on_machine(path))
+            create_dir(action_handler, dirname_on_machine(path))
           end
-          provider.converge_by "upload file #{local_path} to #{path} on #{node['name']}" do
+          action_handler.converge_by "upload file #{local_path} to #{path} on #{node['name']}" do
             transport.upload_file(local_path, path)
           end
         end

data/lib/chef_metal/machine/unix_machine.rb

@@ -16,9 +16,9 @@ module ChefMetal
       attr_reader :options
 
       # Delete file
-      def delete_file(provider, path)
+      def delete_file(action_handler, path)
         if file_exists?(path)
-          provider.converge_by "delete file #{path} on #{node['name']}" do
+          action_handler.converge_by "delete file #{path} on #{node['name']}" do
             transport.execute("rm -f #{path}").error!
           end
         end
@@ -53,30 +53,30 @@ module ChefMetal
         remote_sum != digest.hexdigest
       end
 
-      def create_dir(provider, path)
+      def create_dir(action_handler, path)
         if !file_exists?(path)
-          provider.converge_by "create directory #{path} on #{node['name']}" do
+          action_handler.converge_by "create directory #{path} on #{node['name']}" do
             transport.execute("mkdir #{path}").error!
           end
         end
       end
 
       # Set file attributes { mode, :owner, :group }
-      def set_attributes(provider, path, attributes)
+      def set_attributes(action_handler, path, attributes)
         if attributes[:mode] || attributes[:owner] || attributes[:group]
-          current_attributes = get_file_attributes(path)
-          if attributes[:mode] && current_attributes[:mode] != attributes[:mode]
-            provider.converge_by "change mode of #{path} on #{node['name']} from #{current_attributes[:mode].to_i(8)} to #{attributes[:mode].to_i(8)}" do
-              transport.execute("chmod #{attributes[:mode].to_i(8)} #{path}").error!
+          current_attributes = get_attributes(path)
+          if attributes[:mode] && current_attributes[:mode].to_i != attributes[:mode].to_i
+            action_handler.converge_by "change mode of #{path} on #{node['name']} from #{current_attributes[:mode].to_i} to #{attributes[:mode].to_i}" do
+              transport.execute("chmod #{attributes[:mode].to_i} #{path}").error!
             end
           end
           if attributes[:owner] && current_attributes[:owner] != attributes[:owner]
-            provider.converge_by "change group of #{path} on #{node['name']} from #{current_attributes[:owner]} to #{attributes[:owner]}" do
+            action_handler.converge_by "change group of #{path} on #{node['name']} from #{current_attributes[:owner]} to #{attributes[:owner]}" do
               transport.execute("chown #{attributes[:owner]} #{path}").error!
             end
           end
           if attributes[:group] && current_attributes[:group] != attributes[:group]
-            provider.converge_by "change group of #{path} on #{node['name']} from #{current_attributes[:group]} to #{attributes[:group]}" do
+            action_handler.converge_by "change group of #{path} on #{node['name']} from #{current_attributes[:group]} to #{attributes[:group]}" do
               transport.execute("chgrp #{attributes[:group]} #{path}").error!
             end
           end
@@ -85,21 +85,15 @@ module ChefMetal
 
       # Get file attributes { :mode, :owner, :group }
       def get_attributes(path)
-        file_info = transport.execute("ls -ld #{path}").stdout.split(/\s+/)
+        file_info = transport.execute("stat -c '%a %U %G %n' #{path}").stdout.split(/\s+/)
         if file_info.size <= 1
           raise "#{path} does not exist in set_attributes()"
         end
         result = {
-          :mode => 0,
-          :owner => file_info[2],
-          :group => file_info[3]
+          :mode => file_info[0],
+          :owner => file_info[1],
+          :group => file_info[2]
         }
-        attribute_string = file_info[0]
-        0.upto(attribute_string.length-1).each do |i|
-          result[:mode] <<= 1
-          result[:mode] += (attribute_string[i] == '-' ? 0 : 1)
-        end
-        result
       end
 
       def dirname_on_machine(path)
@@ -107,12 +101,12 @@ module ChefMetal
       end
     end
 
-    def detect_os(provider)
+    def detect_os(action_handler)
       #
       # Use detect.sh to detect the operating system of the remote machine
       #
       # TODO do this in terms of commands rather than writing a shell script
-      self.write_file(provider, "#{@tmp_dir}/detect.sh", detect_sh)
+      self.write_file(action_handler, "#{@tmp_dir}/detect.sh", detect_sh)
       detected = self.execute_always("sh #{@tmp_dir}/detect.sh")
       if detected.exitstatus != 0
         raise "detect.sh exited with nonzero exit status: #{detected.exitstatus}"

data/lib/chef_metal/machine/windows_machine.rb

@@ -13,9 +13,9 @@ module ChefMetal
       attr_reader :options
 
       # Delete file
-      def delete_file(provider, path)
+      def delete_file(action_handler, path)
         if file_exists?(path)
-          provider.converge_by "delete file #{escape(path)} on #{node['name']}" do
+          action_handler.converge_by "delete file #{escape(path)} on #{node['name']}" do
             transport.execute("Remove-Item #{escape(path)}").error!
           end
         end
@@ -58,16 +58,16 @@ EOM
         remote_sum != digest.hexdigest
       end
 
-      def create_dir(provider, path)
+      def create_dir(action_handler, path)
         if !file_exists?(path)
-          provider.converge_by "create directory #{path} on #{node['name']}" do
+          action_handler.converge_by "create directory #{path} on #{node['name']}" do
             transport.execute("New-Item #{escape(path)} -Type directory")
           end
         end
       end
 
       # Set file attributes { :owner, :group, :rights }
-#      def set_attributes(provider, path, attributes)
+#      def set_attributes(action_handler, path, attributes)
 #      end
 
       # Get file attributes { :owner, :group, :rights }
@@ -91,4 +91,4 @@ EOM
       end
     end
   end
-end
+end

data/lib/chef_metal/provider_action_handler.rb

@@ -0,0 +1,41 @@
+# -*- 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 included in the metal provisioners to proxy from generic requests needed
+# to specific provider actions
+module ChefMetal
+  module ProviderActionHandler
+    # Implementation of ActionHandler interface
+
+    def recipe_context
+      self.run_context
+    end
+
+    def updated!
+      self.new_resource.updated_by_last_action(true)
+    end
+
+    def perform_action(description, &block)
+      self.converge_by(description, &block)
+    end
+
+    def debug_name
+      self.cookbook_name
+    end
+  end
+end

data/lib/chef_metal/provisioner.rb

@@ -1,5 +1,17 @@
 module ChefMetal
   class Provisioner
+    # Inflate a provisioner from node information; we don't want to force the
+    # driver to figure out what the provisioner really needs, since it varies
+    # from provisioner to provisioner.
+    #
+    # ## Parameters
+    # node - node to inflate the provisioner for
+    #
+    # returns a should return a Privisoner from the information provided
+    def self.inflate(node)
+      raise "#{self.class} does not override self.inflate"
+    end
+
     # Acquire a machine, generally by provisioning it.  Returns a Machine
     # object pointing at the machine, allowing useful actions like setup,
     # converge, execute, file and directory.  The Machine object will have a
@@ -7,7 +19,10 @@ module ChefMetal
     # different from the original node object).
     #
     # ## Parameters
-    # provider - the provider object that is calling this method.
+    # action_handler - the action_handler object that is calling this method; this
+    #        is generally a provider, but could be anything that can support the
+    #        interface (i.e., in the case of the test kitchen metal driver for
+    #        acquiring and destroying VMs).
     # node - node object (deserialized json) representing this machine.  If
     #        the node has a provisioner_options hash in it, these will be used
     #        instead of options provided by the provisioner.  TODO compare and
@@ -23,7 +38,7 @@ module ChefMetal
     #
     #           -- provisioner_url: <provisioner url>
     #
-    def acquire_machine(provider, node)
+    def acquire_machine(action_handler, node)
       raise "#{self.class} does not override acquire_machine"
     end
 
@@ -42,12 +57,12 @@ module ChefMetal
 
     # Delete the given machine (idempotent).  Should destroy the machine,
     # returning things to the state before acquire_machine was called.
-    def delete_machine(provider, node)
+    def delete_machine(action_handler, node)
       raise "#{self.class} does not override delete_machine"
     end
 
     # Stop the given machine.
-    def stop_machine(provider, node)
+    def stop_machine(action_handler, node)
       raise "#{self.class} does not override stop_machine"
     end
 

data/lib/chef_metal/provisioner/fog_provisioner.rb

@@ -2,6 +2,8 @@ require 'chef_metal/provisioner'
 require 'chef_metal/aws_credentials'
 require 'chef_metal/openstack_credentials'
 require 'chef_metal/version'
+require 'fog/compute'
+require 'fog'
 
 module ChefMetal
   class Provisioner
@@ -17,7 +19,13 @@ module ChefMetal
         :ssh_timeout => 20
       }
 
-      # Create a new vagrant provisioner.
+      def self.inflate(node)
+        url = node['normal']['provisioner_output']['provisioner_url']
+        scheme, provider, id = url.split(':', 3)
+        FogProvisioner.new({ :provider => provider }, id)
+      end
+
+      # Create a new fog provisioner.
       #
       # ## Parameters
       # compute_options - hash of options to be passed to Fog::Compute.new
@@ -32,7 +40,9 @@ module ChefMetal
       #   - :create_timeout - the time to wait for the instance to boot to ssh (defaults to 600)
       #   - :start_timeout - the time to wait for the instance to start (defaults to 600)
       #   - :ssh_timeout - the time to wait for ssh to be available if the instance is detected as up (defaults to 20)
-      def initialize(compute_options)
+      # id - the ID in the provisioner_url (fog:PROVIDER:ID)
+      def initialize(compute_options, id=nil)
+        @compute_options = compute_options
         @base_bootstrap_options = compute_options.delete(:base_bootstrap_options) || {}
 
         case compute_options[:provider]
@@ -46,6 +56,11 @@ module ChefMetal
           end
           compute_options[:aws_access_key_id] ||= @aws_credentials.default[:access_key_id]
           compute_options[:aws_secret_access_key] ||= @aws_credentials.default[:secret_access_key]
+          # TODO actually find a key with the proper id
+          # TODO let the user specify credentials and provider profiles that we can use
+          if id && aws_login_info[0] != id
+            raise "Default AWS credentials point at AWS account #{aws_login_info[0]}, but inflating from URL #{id}"
+          end
         when 'OpenStack'
           openstack_credentials = compute_options.delete(:openstack_credentials)
           if openstack_credentials
@@ -61,7 +76,6 @@ module ChefMetal
           compute_options[:openstack_tenant] ||= @openstack_credentials.default[:openstack_tenant]
         end
         @key_pairs = {}
-        @compute_options = compute_options
         @base_bootstrap_options_for = {}
       end
 
@@ -82,6 +96,17 @@ module ChefMetal
         result
       end
 
+      # Inflate a provisioner from node information; we don't want to force the
+      # driver to figure out what the provisioner really needs, since it varies
+      # from provisioner to provisioner.
+      #
+      # ## Parameters
+      # node - node to inflate the provisioner for
+      #
+      # returns a FogProvisioner
+      # TODO: def self.inflate(node)
+      # right now, not implemented, will raise error from base class until overridden
+
       # Acquire a machine, generally by provisioning it.  Returns a Machine
       # object pointing at the machine, allowing useful actions like setup,
       # converge, execute, file and directory.  The Machine object will have a
@@ -89,7 +114,11 @@ module ChefMetal
       # different from the original node object).
       #
       # ## Parameters
-      # provider - the provider object that is calling this method.
+      # action_handler - the action_handler object that is calling this method; this
+      #        is generally a action_handler, but could be anything that can support the
+      #        ChefMetal::ActionHandler interface (i.e., in the case of the test
+      #        kitchen metal driver for acquiring and destroying VMs; see the base
+      #        class for what needs providing).
       # node - node object (deserialized json) representing this machine.  If
       #        the node has a provisioner_options hash in it, these will be used
       #        instead of options provided by the provisioner.  TODO compare and
@@ -116,7 +145,7 @@ module ChefMetal
       #           -- provisioner_url: fog:<relevant_fog_options>
       #           -- server_id: the ID of the server so it can be found again
       #
-      def acquire_machine(provider, node)
+      def acquire_machine(action_handler, node)
         # Set up the modified node data
         provisioner_output = node['normal']['provisioner_output'] || {
           'provisioner_url' => provisioner_url,
@@ -131,7 +160,7 @@ module ChefMetal
             provisioner_output['provisioner_version'] ||= ChefMetal::VERSION
             provisioner_output['creator'] ||= aws_login_info[1]
           else
-            raise "Switching providers for a machine is not currently supported!  Use machine :destroy and then re-create the machine on the new provider."
+            raise "Switching providers for a machine is not currently supported!  Use machine :destroy and then re-create the machine on the new action_handler."
           end
         end
 
@@ -152,10 +181,10 @@ module ChefMetal
           else
             need_to_create = false
             if !server.ready?
-              provider.converge_by "start machine #{node['name']} (#{server.id} on #{provisioner_url})" do
+              action_handler.perform_action "start machine #{node['name']} (#{server.id} on #{provisioner_url})" do
                 server.start
               end
-              provider.converge_by "wait for machine #{node['name']} (#{server.id} on #{provisioner_url}) to be ready" do
+              action_handler.perform_action "wait for machine #{node['name']} (#{server.id} on #{provisioner_url}) to be ready" do
                 wait_until_ready(server, option_for(node, :start_timeout))
               end
             else
@@ -168,8 +197,8 @@ module ChefMetal
 
         if need_to_create
           # If the server does not exist, create it
-          bootstrap_options = bootstrap_options_for(provider.new_resource, node)
-          bootstrap_options.merge(:name => provider.new_resource.name)
+          bootstrap_options = bootstrap_options_for(action_handler.new_resource, node)
+          bootstrap_options.merge(:name => action_handler.new_resource.name)
 
           start_time = Time.now
           timeout = option_for(node, :create_timeout)
@@ -177,11 +206,11 @@ module ChefMetal
           description = [ "create machine #{node['name']} on #{provisioner_url}" ]
           bootstrap_options.each_pair { |key,value| description << "    #{key}: #{value.inspect}" }
           server = nil
-          provider.converge_by description do
+          action_handler.perform_action description do
             server = compute.servers.create(bootstrap_options)
             provisioner_output['server_id'] = server.id
             # Save quickly in case something goes wrong
-            save_node(provider, node, provider.new_resource.chef_server)
+            save_node(action_handler, node, action_handler.new_resource.chef_server)
           end
 
           if server
@@ -191,22 +220,22 @@ module ChefMetal
             if bootstrap_options[:floating_ip_pool]
               Chef::Log.info 'Attaching IP from pool'
               server.wait_for { ready? }
-              provider.converge_by "attach floating IP from #{bootstrap_options[:floating_ip_pool]} pool" do
+              action_handler.perform_action "attach floating IP from #{bootstrap_options[:floating_ip_pool]} pool" do
                 attach_ip_from_pool(server, bootstrap_options[:floating_ip_pool])
               end
             elsif bootstrap_options[:floating_ip]
               Chef::Log.info 'Attaching given IP'
               server.wait_for { ready? }
-              provider.converge_by "attach floating IP #{bootstrap_options[:floating_ip]}" do
+              action_handler.perform_action "attach floating IP #{bootstrap_options[:floating_ip]}" do
                 attach_ip(server, bootstrap_options[:floating_ip])
               end
             end
-            provider.converge_by "machine #{node['name']} created as #{server.id} on #{provisioner_url}" do
+            action_handler.perform_action "machine #{node['name']} created as #{server.id} on #{provisioner_url}" do
             end
             # Wait for the machine to come up and for ssh to start listening
             transport = nil
             _self = self
-            provider.converge_by "wait for machine #{node['name']} to boot" do
+            action_handler.perform_action "wait for machine #{node['name']} to boot" do
               server.wait_for(timeout - (Time.now - start_time)) do
                 if ready?
                   transport ||= _self.transport_for(server)
@@ -232,10 +261,10 @@ module ChefMetal
               # some other problem.  If this is the case, we restart the server
               # to unstick it.  Reboot covers a multitude of sins.
               Chef::Log.warn "Machine #{node['name']} (#{server.id} on #{provisioner_url}) was started but SSH did not come up.  Rebooting machine in an attempt to unstick it ..."
-              provider.converge_by "reboot machine #{node['name']} to try to unstick it" do
+              action_handler.perform_action "reboot machine #{node['name']} to try to unstick it" do
                 server.reboot
               end
-              provider.converge_by "wait for machine #{node['name']} to be ready after reboot" do
+              action_handler.perform_action "wait for machine #{node['name']} to be ready after reboot" do
                 wait_until_ready(server, option_for(node, :start_timeout))
               end
             end
@@ -276,21 +305,21 @@ module ChefMetal
         machine_for(node)
       end
 
-      def delete_machine(provider, node)
+      def delete_machine(action_handler, node)
         if node['normal']['provisioner_output'] && node['normal']['provisioner_output']['server_id']
           server = compute.servers.get(node['normal']['provisioner_output']['server_id'])
-          provider.converge_by "destroy machine #{node['name']} (#{node['normal']['provisioner_output']['server_id']} at #{provisioner_url})" do
+          action_handler.perform_action "destroy machine #{node['name']} (#{node['normal']['provisioner_output']['server_id']} at #{provisioner_url})" do
             server.destroy
           end
-          convergence_strategy_for(node).delete_chef_objects(provider, node)
+          convergence_strategy_for(node).cleanup_convergence(action_handler, node)
         end
       end
 
-      def stop_machine(provider, node)
+      def stop_machine(action_handler, node)
         # If the machine doesn't exist, we silently do nothing
         if node['normal']['provisioner_output'] && node['normal']['provisioner_output']['server_id']
           server = compute.servers.get(node['normal']['provisioner_output']['server_id'])
-          provider.converge_by "stop machine #{node['name']} (#{server.id} at #{provisioner_url})" do
+          action_handler.perform_action "stop machine #{node['name']} (#{server.id} at #{provisioner_url})" do
             server.stop
           end
         end
@@ -302,11 +331,7 @@ module ChefMetal
 
 
       def compute
-        @compute ||= begin
-          require 'fog/compute'
-          require 'fog'
-          Fog::Compute.new(compute_options)
-        end
+        @compute ||= Fog::Compute.new(compute_options)
       end
 
       def provisioner_url
@@ -499,6 +524,9 @@ module ChefMetal
           raise "Server #{server.id} has no private or public IP address!"
         end
 
+        #Enable pty by default
+        options[:ssh_pty_enable] = true
+
         ChefMetal::Transport::SSH.new(remote_host, username, ssh_options, options)
       end