chef-provisioning 0.19 → 0.20

data/lib/chef/provisioning.rb

@@ -3,6 +3,7 @@ require 'chef/provisioning/recipe_dsl'
 require 'chef/server_api'
 require 'cheffish/basic_chef_client'
 require 'cheffish/merged_config'
+require 'chef/provisioning/chef_managed_entry_store'
 
 class Chef
 module Provisioning
@@ -53,6 +54,9 @@ module Provisioning
       end
     end
     driver_class = @@registered_driver_classes[scheme]
+    if !driver_class
+      raise "chef/provisioning/driver_init/#{scheme} did not register a driver class for #{scheme.inspect}!  Perhaps you have the case (uppercase or lowercase) wrong?"
+    end
 
     #
     # Merge in any driver-specific config
@@ -82,7 +86,7 @@ module Provisioning
   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)
+      machine_spec = chef_managed_entry_store(chef_server).get(:machine, machine_spec)
     end
     driver = driver_for_url(machine_spec.driver_url, config)
     if driver
@@ -93,6 +97,10 @@ module Provisioning
       nil
     end
   end
+
+  def self.chef_managed_entry_store(chef_server = Cheffish.default_chef_server)
+    Provisioning::ChefManagedEntryStore.new(chef_server)
+  end
 end
 end
 

data/lib/chef/provisioning/chef_managed_entry_store.rb

@@ -0,0 +1,128 @@
+require 'chef/provisioning/managed_entry_store'
+require 'cheffish'
+
+class Chef
+  module Provisioning
+    class ChefManagedEntryStore < ManagedEntryStore
+      def initialize(chef_server = Cheffish.default_chef_server)
+        @chef_server = chef_server
+      end
+
+      attr_reader :chef_server
+
+      def chef_api
+        @chef_api ||= Cheffish.chef_server_api(chef_server)
+      end
+
+      #
+      # Get the given data
+      #
+      # @param resource_type [Symbol] The type of thing to retrieve (:machine, :machine_image, :load_balancer, :aws_vpc, :aws_subnet, ...)
+      # @param name [String] The unique identifier of the thing to retrieve
+      #
+      # @return [Hash,Array] The data, or `nil` if the data does not exist.  Will be JSON- and YAML-compatible (Hash, Array, String, Integer, Boolean, Nil)
+      #
+      def get_data(resource_type, name)
+        begin
+          if resource_type == :machine
+            chef_api.get("nodes/#{name}")
+          else
+            chef_api.get("data/#{resource_type}/#{name}")
+          end
+        rescue Net::HTTPServerException => e
+          if e.response.code == '404'
+            backcompat_type = ChefManagedEntryStore.type_names_for_backcompat[resource_type]
+            if backcompat_type && backcompat_type != resource_type
+              get_data(backcompat_type, name)
+            else
+              nil
+            end
+          else
+            raise
+          end
+        end
+      end
+
+      #
+      # Save the given data
+      #
+      # @param resource_type [Symbol] The type of thing to save (:machine, :machine_image, :load_balancer, :aws_vpc, :aws_subnet ...)
+      # @param name [String] The unique identifier of the thing to save
+      # @param data [Hash,Array] The data to save.  Must be JSON- and YAML-compatible (Hash, Array, String, Integer, Boolean, Nil)
+      #
+      def save_data(resource_type, name, data, action_handler)
+        _chef_server = self.chef_server
+        Chef::Provisioning.inline_resource(action_handler) do
+          if resource_type == :machine
+            chef_node name do
+              chef_server _chef_server
+              raw_json data
+            end
+          else
+            chef_data_bag resource_type.to_s do
+              chef_server _chef_server
+            end
+            chef_data_bag_item name do
+              chef_server _chef_server
+              data_bag resource_type.to_s
+              raw_data data
+            end
+          end
+        end
+
+        backcompat_type = ChefManagedEntryStore.type_names_for_backcompat[resource_type]
+        if backcompat_type && backcompat_type != resource_type
+          delete_data(backcompat_type, name, action_handler)
+        end
+      end
+
+      #
+      # Delete the given data
+      #
+      # @param resource_type [Symbol] The type of thing to delete (:machine, :machine_image, :load_balancer, :aws_vpc, :aws_subnet, ...)
+      # @param name [String] The unique identifier of the thing to delete
+      #
+      # @return [Boolean] Whether anything was deleted or not.
+      #
+      def delete_data(resource_type, name, action_handler)
+        _chef_server = self.chef_server
+        Chef::Provisioning.inline_resource(action_handler) do
+          if resource_type == :machine
+            chef_node name do
+              chef_server _chef_server
+              action :delete
+            end
+          else
+            chef_data_bag_item name do
+              chef_server _chef_server
+              data_bag resource_type.to_s
+              action :delete
+            end
+          end
+        end
+
+        backcompat_type = ChefManagedEntryStore.type_names_for_backcompat[resource_type]
+        if backcompat_type && backcompat_type != resource_type
+          delete_data(backcompat_type, name, action_handler)
+        end
+      end
+
+      def identifier(resource_type, name)
+        if resource_type == :machine
+          File.join(chef_server[:chef_server_url], "nodes", name)
+        else
+          File.join(chef_server[:chef_server_url], "data", resource_type.to_s, name)
+        end
+      end
+
+      #
+      # A list of the name that we used to use to store a given type before we
+      # standardized on "just use the resource name so we don't create collisions."
+      # Will be used to look up the old data.
+      #
+      def self.type_names_for_backcompat
+        @@type_names_for_backcompat ||= {}
+      end
+    end
+  end
+end

data/lib/chef/provisioning/chef_run_data.rb

@@ -1,6 +1,5 @@
 require 'chef/mixin/deep_merge'
 require 'cheffish/merged_config'
-require 'chef/provisioning/chef_machine_spec'
 
 class Chef
 module Provisioning
@@ -17,7 +16,6 @@ module Provisioning
     attr_accessor :current_machine_options
     attr_accessor :current_load_balancer_options
     attr_accessor :current_image_options
-    attr_accessor :current_data_center
 
     def with_machine_options(value)
       old_value = self.current_machine_options
@@ -43,26 +41,21 @@ module Provisioning
       end
     end
 
-    def with_data_center(value)
-      old_value = self.current_data_center
-      self.current_data_center = value
+    def with_driver(driver, options = nil, &block)
+      if drivers[driver] && options
+        raise "Driver #{driver} has already been created, options #{options} would be ignored!"
+      end
+      old_driver, old_options = @current_driver, @current_driver_options
+      @current_driver, @current_driver_options = driver, options
       if block_given?
         begin
           yield
         ensure
-          self.current_data_center = old_value
+          @current_driver, @current_driver_options = old_driver, old_options
         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
@@ -92,10 +85,10 @@ module Provisioning
     end
 
     def connect_to_machine(name, chef_server = nil)
-      if name.is_a?(MachineSpec)
+      if name.is_a?(ManagedEntry)
         machine_spec = name
       else
-        machine_spec = Chef::Provisioning::ChefMachineSpec.get(name, chef_server)
+        machine_spec = Provisioning.chef_managed_entry_store(chef_server).get(:machine, name)
       end
       Chef::Provisioning.connect_to_machine(machine_spec, config)
     end

data/lib/chef/provisioning/convergence_strategy/install_cached.rb

@@ -42,14 +42,32 @@ module Provisioning
       def setup_convergence(action_handler, machine)
         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(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(action_handler, package_file, remote_package_file)
-          install_package(action_handler, machine, remote_package_file)
+        # Check for existing chef client.
+        version = machine.execute_always('chef-client -v')
+
+        # Don't do install/upgrade if a chef client exists and
+        # no chef version is defined by user configs or
+        # the chef client's version already matches user config
+        if version.exitstatus == 0
+          version = version.stdout.strip
+          if !chef_version
+            return
+          elsif version =~ /Chef: #{chef_version}$/
+            Chef::Log.debug "Already installed chef version #{version}"
+            return
+          elsif version.include?(chef_version)
+            Chef::Log.warn "Installed chef version #{version} contains desired version #{chef_version}.  " +
+              "If you see this message on consecutive chef runs tighten your desired version constraint to prevent " +
+              "multiple convergence."
+          end
         end
+
+        # Install chef client
+        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(action_handler, package_file, remote_package_file)
+        install_package(action_handler, machine, remote_package_file)
       end
 
       def converge(action_handler, machine)

data/lib/chef/provisioning/convergence_strategy/install_msi.rb

@@ -28,15 +28,33 @@ module Provisioning
 
         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.msi before running arbtrary code would be nice?
-          # 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(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)}")
+        # Check for existing chef client.
+        version = machine.execute_always('chef-client -v')
+
+        # Don't do install/upgrade if a chef client exists and
+        # no chef version is defined by user configs or
+        # the chef client's version already matches user config
+        if version.exitstatus == 0
+          version = version.stdout.strip
+          if !chef_version
+            return
+          elsif version =~ /Chef: #{chef_version}$/
+            Chef::Log.debug "Already installed chef version #{version}"
+            return
+          elsif version.include?(chef_version)
+            Chef::Log.warn "Installed chef version #{version} contains desired version #{chef_version}.  " +
+              "If you see this message on consecutive chef runs tighten your desired version constraint to prevent " +
+              "multiple convergence."
+          end
         end
+
+        # Install chef client
+        # TODO ssh verification of install.msi before running arbtrary code would be nice?
+        # 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(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
 
       def converge(action_handler, machine)

data/lib/chef/provisioning/convergence_strategy/install_sh.rb

@@ -39,13 +39,35 @@ module Provisioning
       def setup_convergence(action_handler, machine)
         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(action_handler, install_sh_path, @@install_sh_cache[install_sh_url], :ensure_dir => true)
-          machine.execute(action_handler, install_sh_command_line)
+        # Check for existing chef client.
+        version = machine.execute_always('chef-client -v')
+
+        # Don't do install/upgrade if a chef client exists and
+        # no chef version is defined by user configs or
+        # the chef client's version already matches user config
+        if version.exitstatus == 0
+          version = version.stdout.strip
+          if !chef_version
+            return
+          # This logic doesn't cover the case for a client with 12.0.1.dev.0 => 12.0.1
+          # so we decided to just use exact version for the time being (see comments in PR 303)
+          #elsif version.stdout.strip =~ /Chef: #{chef_version}([^0-9]|$)/
+          elsif version =~ /Chef: #{chef_version}$/
+            Chef::Log.debug "Already installed chef version #{version}"
+            return
+          elsif version.include?(chef_version)
+            Chef::Log.warn "Installed chef version #{version} contains desired version #{chef_version}.  " +
+              "If you see this message on consecutive chef runs tighten your desired version constraint to prevent " +
+              "multiple convergence."
+          end
         end
+
+        # Install chef client
+        # 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(action_handler, install_sh_path, @@install_sh_cache[install_sh_url], :ensure_dir => true)
+        # TODO handle bad version case better
+        machine.execute(action_handler, install_sh_command_line)
       end
 
       def converge(action_handler, machine)

data/lib/chef/provisioning/driver.rb

@@ -59,7 +59,7 @@ module Provisioning
 
     #
     # A URL representing the driver and the place where machines come from.
-    # This will be stuffed in machine_spec.location['driver_url'] so that the
+    # This will be stuffed in machine_spec.reference['driver_url'] so that the
     # machine can be re-inflated.  URLs must have a unique scheme identifying the
     # driver class, and enough information to identify the place where created
     # machines can be found.  For AWS, this is the account number; for lxc and
@@ -94,7 +94,7 @@ module Provisioning
 
     # Allocate a machine from the underlying service.  This method
     # does not need to wait for the machine to boot or have an IP, but it must
-    # store enough information in machine_spec.location to find the machine
+    # store enough information in machine_spec.reference to find the machine
     # later in ready_machine.
     #
     # If a machine is powered off or otherwise unusable, this method may start
@@ -102,11 +102,11 @@ module Provisioning
     # gears moving, but the job doesn't need to be done :)
     #
     # @param [Chef::Provisioning::ActionHandler] action_handler The action_handler object that is calling this method
-    # @param [Chef::Provisioning::MachineSpec] machine_spec A machine specification representing this machine.
+    # @param [Chef::Provisioning::ManagedEntry] machine_spec A machine specification representing this machine.
     # @param [Hash] machine_options A set of options representing the desired options when
     # constructing the machine
     #
-    # @return [Chef::Provisioning::MachineSpec] Modifies the passed-in machine_spec.  Anything in here will be saved
+    # @return [Chef::Provisioning::ManagedEntry] Modifies the passed-in machine_spec.  Anything in here will be saved
     # back after allocate_machine completes.
     #
     def allocate_machine(action_handler, machine_spec, machine_options)
@@ -121,7 +121,7 @@ module Provisioning
     #
     #
     # @param [Chef::Provisioning::ActionHandler] action_handler The action_handler object that is calling this method
-    # @param [Chef::Provisioning::MachineSpec] machine_spec A machine specification representing this machine.
+    # @param [Chef::Provisioning::ManagedEntry] machine_spec A machine specification representing this machine.
     # @param [Hash] machine_options A set of options representing the desired state of the machine
     #
     # @return [Machine] A machine object pointing at the machine, allowing useful actions like setup,
@@ -134,7 +134,7 @@ module Provisioning
     # Connect to a machine without allocating or readying it.  This method will
     # NOT make any changes to anything, or attempt to wait.
     #
-    # @param [Chef::Provisioning::MachineSpec] machine_spec MachineSpec representing this machine.
+    # @param [Chef::Provisioning::ManagedEntry] machine_spec ManagedEntry representing this machine.
     # @param [Hash] machine_options
     # @return [Machine] A machine object pointing at the machine, allowing useful actions like setup,
     # converge, execute, file and directory.
@@ -148,7 +148,7 @@ module Provisioning
     # returning things to the state before allocate_machine was called.
     #
     # @param [Chef::Provisioning::ActionHandler] action_handler The action_handler object that is calling this method
-    # @param [Chef::Provisioning::MachineSpec] machine_spec A machine specification representing this machine.
+    # @param [Chef::Provisioning::ManagedEntry] machine_spec A machine specification representing this machine.
     # @param [Hash] machine_options A set of options representing the desired state of the machine
     def destroy_machine(action_handler, machine_spec, machine_options)
       raise "#{self.class} does not implement destroy_machine"
@@ -157,7 +157,7 @@ module Provisioning
     # Stop the given machine.
     #
     # @param [Chef::Provisioning::ActionHandler] action_handler The action_handler object that is calling this method
-    # @param [Chef::Provisioning::MachineSpec] machine_spec A machine specification representing this machine.
+    # @param [Chef::Provisioning::ManagedEntry] machine_spec A machine specification representing this machine.
     # @param [Hash] machine_options A set of options representing the desired state of the machine
     def stop_machine(action_handler, machine_spec, machine_options)
       raise "#{self.class} does not implement stop_machine"
@@ -166,17 +166,19 @@ module Provisioning
     # Allocate an image. Returns quickly with an ID that tracks the image.
     #
     # @param [Chef::Provisioning::ActionHandler] action_handler The action_handler object that is calling this method
-    # @param [Chef::Provisioning::ImageSpec] image_spec A machine specification representing this machine.
-    # @param [Hash] image_options A set of options representing the desired state of the machine
-    def allocate_image(action_handler, image_spec, image_options, machine_spec)
+    # @param [Chef::Provisioning::ManagedEntry] image_spec An image specification representing this image.
+    # @param [Hash] image_options A set of options representing the desired state of the image
+    # @param [Chef::Provisioning::ManagedEntry] machine_spec A machine specification representing this machine.
+    # @param [Hash] machine_options A set of options representing the desired state of the machine used to create the image
+    def allocate_image(action_handler, image_spec, image_options, machine_spec, machine_options)
       raise "#{self.class} does not implement create_image"
     end
 
     # Ready an image, waiting till the point where it is ready to be used.
     #
     # @param [Chef::Provisioning::ActionHandler] action_handler The action_handler object that is calling this method
-    # @param [Chef::Provisioning::ImageSpec] image_spec A machine specification representing this machine.
-    # @param [Hash] image_options A set of options representing the desired state of the machine
+    # @param [Chef::Provisioning::ManagedEntry] image_spec An image specification representing this image.
+    # @param [Hash] image_options A set of options representing the desired state of the image
     def ready_image(action_handler, image_spec, image_options)
       raise "#{self.class} does not implement ready_image"
     end
@@ -184,9 +186,10 @@ module Provisioning
     # Destroy an image using this service.
     #
     # @param [Chef::Provisioning::ActionHandler] action_handler The action_handler object that is calling this method
-    # @param [Chef::Provisioning::ImageSpec] image_spec A machine specification representing this machine.
-    # @param [Hash] image_options A set of options representing the desired state of the machine
-    def destroy_image(action_handler, image_spec, image_options)
+    # @param [Chef::Provisioning::ManagedEntry] image_spec An image specification representing this image.
+    # @param [Hash] image_options A set of options representing the desired state of the image
+    # @param [Hash] machine_options A set of options representing the desired state of the machine used to create the image
+    def destroy_image(action_handler, image_spec, image_options, machine_options)
       raise "#{self.class} does not implement destroy_image"
     end
 
@@ -267,18 +270,22 @@ module Provisioning
     end
 
     # Allocate a load balancer
-    # @param [ChefMetal::ActionHandler] action_handler The action handler
-    # @param [ChefMetal::LoadBalancerSpec] lb_spec Frozen LB specification
+    # @param [Chef::Provisioning::ActionHandler] action_handler The action handler
+    # @param [Chef::Provisioning::ManagedEntry] lb_spec Frozen LB specification
     # @param [Hash] lb_options A hash of options to pass the LB
     # @param [Array[ChefMetal::MachineSpec]] machine_specs An array of machine specs
-    #        the load balancer should have
+    #        the load balancer should have.  `nil` indicates "leave the set of machines
+    #        alone," or for new LBs, it means "no machines."
     def allocate_load_balancer(action_handler, lb_spec, lb_options, machine_specs)
     end
 
     # Make the load balancer ready
-    # @param [ChefMetal::ActionHandler] action_handler The action handler
-    # @param [ChefMetal::LoadBalancerSpec] lb_spec Frozen LB specification
+    # @param [Chef::Provisioning::ActionHandler] action_handler The action handler
+    # @param [Chef::Provisioning::ManagedEntry] lb_spec Frozen LB specification
     # @param [Hash] lb_options A hash of options to pass the LB
+    # @param [Array[ChefMetal::MachineSpec]] machine_specs An array of machine specs
+    #        the load balancer should have.  `nil` indicates "leave the set of machines
+    #        alone," or for new LBs, it means "no machines."
     def ready_load_balancer(action_handler, lb_spec, lb_options, machine_specs)
     end