chef-provisioning 0.15

data/lib/chef/provisioning/chef_load_balancer_spec.rb

@@ -0,0 +1,108 @@
+require 'chef/provisioning'
+require 'cheffish'
+require 'chef/provisioning/load_balancer_spec'
+
+class Chef
+module Provisioning
+  #
+  # Specification for a image. Sufficient information to find and contact it
+  # after it has been set up.
+  #
+  class ChefLoadBalancerSpec < LoadBalancerSpec
+    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/loadbalancers/#{name}")
+        data['load_balancer_options'] = strings_to_symbols(data['load_balancer_options'])
+        ChefLoadBalancerSpec.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)
+      ChefLoadBalancerSpec.new({ 'id' => id }, chef_server)
+    end
+
+    #
+    # Globally unique identifier for this image. Does not depend on the image's
+    # location or existence.
+    #
+    def id
+      ChefLoadBalancerSpec.id_from(chef_server, name)
+    end
+
+    def self.id_from(chef_server, name)
+      "#{chef_server[:chef_server_url]}/data/loadbalancers/#{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
+      Chef::Provisioning.inline_resource(action_handler) do
+        chef_data_bag_item _self.name do
+          data_bag 'loadbalancers'
+          chef_server _chef_server
+          raw_data _self.load_balancer_data
+        end
+      end
+    end
+
+    def delete(action_handler)
+      # Save the node to the server.
+      _self = self
+      _chef_server = _self.chef_server
+      Chef::Provisioning.inline_resource(action_handler) do
+        chef_data_bag_item _self.name do
+          data_bag 'loadbalancers'
+          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
+end

data/lib/chef/provisioning/chef_machine_spec.rb

@@ -0,0 +1,84 @@
+require 'pry'
+require 'chef/provisioning'
+require 'cheffish'
+require 'chef/provisioning/machine_spec'
+
+class Chef
+module Provisioning
+  #
+  # 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
+      Chef::Provisioning.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
+end

data/lib/chef/provisioning/chef_provider_action_handler.rb

@@ -0,0 +1,74 @@
+# -*- 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/provisioning/action_handler'
+
+# This is included in provisioning drivers to proxy from generic requests needed
+# to specific driver actions
+class Chef
+module Provisioning
+  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
+end

data/lib/chef/provisioning/chef_run_data.rb

@@ -0,0 +1,139 @@
+require 'chef/mixin/deep_merge'
+require 'cheffish/merged_config'
+require 'chef/provisioning/chef_machine_spec'
+
+class Chef
+module Provisioning
+  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_load_balancer_options
+    attr_accessor :current_image_options
+    attr_accessor :current_data_center
+
+    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_data_center(value)
+      old_value = self.current_data_center
+      self.current_data_center = value
+      if block_given?
+        begin
+          yield
+        ensure
+          self.current_data_center = 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 = Chef::Provisioning::ChefMachineSpec.get(name, chef_server)
+      end
+      Chef::Provisioning.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 = Chef::Provisioning.driver_for_url(driver_url, merged_config)
+        else
+          driver = Chef::Provisioning.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
+end

data/lib/chef/provisioning/convergence_strategy.rb

@@ -0,0 +1,28 @@
+class Chef
+module Provisioning
+  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
+end

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

@@ -0,0 +1,156 @@
+require 'chef/provisioning/convergence_strategy/precreate_chef_objects'
+require 'pathname'
+require 'fileutils'
+require 'digest/md5'
+require 'thread'
+require 'chef/http/simple'
+
+class Chef
+module Provisioning
+  class ConvergenceStrategy
+    class InstallCached < PrecreateChefObjects
+      # convergence_options is a hash of setup convergence_options, including:
+      # - :chef_server
+      # - :allow_overwrite_keys
+      # - :source_key, :source_key_path, :source_key_pass_phrase
+      # - :private_key_options
+      # - :ohai_hints
+      # - :public_key_path, :public_key_format
+      # - :admin, :validator
+      # - :chef_client_timeout
+      # - :client_rb_path, :client_pem_path
+      # - :chef_version, :prerelease, :package_cache_path
+      def initialize(convergence_options, config)
+        convergence_options = Cheffish::MergedConfig.new(convergence_options, {
+          :client_rb_path => '/etc/chef/client.rb',
+          :client_pem_path => '/etc/chef/client.pem'
+        })
+        super(convergence_options, config)
+        @chef_version ||= convergence_options[:chef_version]
+        @prerelease ||= convergence_options[:prerelease]
+        @package_cache_path ||= convergence_options[:package_cache_path] || "#{ENV['HOME']}/.chef/package_cache"
+        @package_cache = {}
+        @tmp_dir = '/tmp'
+        @chef_client_timeout = convergence_options.has_key?(:chef_client_timeout) ? convergence_options[:chef_client_timeout] : 120*60 # Default: 2 hours
+        FileUtils.mkdir_p(@package_cache_path)
+        @package_cache_lock = Mutex.new
+      end
+
+      attr_reader :client_rb_path
+      attr_reader :client_pem_path
+
+      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)
+        end
+      end
+
+      def converge(action_handler, machine)
+        super
+
+        action_handler.open_stream(machine.node['name']) do |stdout|
+          action_handler.open_stream(machine.node['name']) do |stderr|
+            command_line = "chef-client"
+            command_line << " -l #{config[:log_level].to_s}" if config[:log_level]
+            machine.execute(action_handler, command_line,
+              :stream_stdout => stdout,
+              :stream_stderr => stderr,
+              :timeout => @chef_client_timeout)
+          end
+        end
+      end
+
+      private
+
+      def download_package_for_platform(action_handler, machine, platform, platform_version, machine_architecture)
+        @package_cache_lock.synchronize do
+          @package_cache ||= {}
+          @package_cache[platform] ||= {}
+          @package_cache[platform][platform_version] ||= {}
+          @package_cache[platform][platform_version][machine_architecture] ||= { :lock => Mutex.new }
+        end
+        @package_cache[platform][platform_version][machine_architecture][:lock].synchronize do
+          if !@package_cache[platform][platform_version][machine_architecture][:file]
+            #
+            # Grab metadata
+            #
+            metadata = download_metadata_for_platform(machine, platform, platform_version, machine_architecture)
+
+            # Download actual package desired by metadata
+            package_file = "#{@package_cache_path}/#{URI(metadata['url']).path.split('/')[-1]}"
+
+            Chef::Provisioning.inline_resource(action_handler) do
+              remote_file package_file do
+                source metadata['url']
+                checksum metadata['sha256']
+              end
+            end
+
+            @package_cache[platform][platform_version][machine_architecture][:file] = package_file
+          end
+        end
+        @package_cache[platform][platform_version][machine_architecture][:file]
+      end
+
+      def download_metadata_for_platform(machine, platform, platform_version, machine_architecture)
+        #
+        # Figure out the URL to the metadata
+        #
+        metadata_url="https://www.opscode.com/chef/metadata"
+        metadata_url << "?v=#{@chef_version}"
+        metadata_url << "&prerelease=#{@prerelease ? 'true' : 'false'}"
+        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
+        if platform == 'solaris2' && (platform_version == '5.9' || platform_version == '5.10')
+          metadata_url.sub(/^https/, 'http')
+          use_ssl = false
+        end
+
+        # Download and parse the metadata
+        Chef::Log.debug("Getting metadata for machine #{machine.node['name']}: #{metadata_url}")
+        uri = URI(metadata_url)
+        metadata_str = Chef::HTTP::Simple.new(uri).get(uri)
+        metadata = {}
+        metadata_str.each_line do |line|
+          key, value = line.split("\t", 2)
+          metadata[key] = value
+        end
+        metadata
+      end
+
+      def install_package(action_handler, machine, remote_package_file)
+        extension = File.extname(remote_package_file)
+        result = case extension
+        when '.rpm'
+          machine.execute(action_handler, "rpm -Uvh --oldpackage --replacepkgs \"#{remote_package_file}\"")
+        when '.deb'
+          machine.execute(action_handler, "dpkg -i \"#{remote_package_file}\"")
+        when '.solaris'
+          machine.write_file(action_handler, "#{@tmp_dir}/nocheck", <<EOM)
+conflict=nocheck
+action=nocheck
+mail=
+EOM
+          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(action_handler, "sh \"#{remote_package_file}\"")
+        else
+          raise "Unknown package extension '#{extension}' for file #{remote_package_file}"
+        end
+      end
+    end
+  end
+end
+end