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

data/lib/chef_metal/chef_provider_action_handler.rb

@@ -0,0 +1,72 @@
+# -*- 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_metal/action_handler'
+
+# This is included in the metal drivers to proxy from generic requests needed
+# to specific driver actions
+module ChefMetal
+  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

data/lib/chef_metal/chef_run_data.rb

@@ -0,0 +1,80 @@
+require 'chef/mixin/deep_merge'
+require 'cheffish/with_pattern'
+require 'cheffish/merged_config'
+require 'chef_metal/chef_machine_spec'
+
+module ChefMetal
+  class ChefRunData
+    extend Cheffish::WithPattern
+    def initialize(config)
+      @config = config
+      @drivers = {}
+    end
+
+    attr_reader :config
+    attr_reader :drivers
+
+    with :driver
+    with :machine_options
+    with :machine_batch
+
+    def current_driver
+      @current_driver || config[:driver]
+    end
+
+    def current_machine_options
+      if @current_machine_options
+        @current_machine_options
+      elsif config[:drivers] && driver_for(current_driver) && config[:drivers][driver_for(current_driver).driver_url]
+        Cheffish::MergedConfig.new(config[:drivers][driver_for(current_driver).driver_url], config)[:machine_options] || {}
+      else
+        config[:machine_options] || {}
+      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 driver_config_for(driver)
+      ChefMetal.config_for_url(driver_for(driver).driver_url, config)
+    end
+
+    def driver_for_url(driver_url)
+      drivers[driver_url] ||= begin
+        driver = ChefMetal.driver_for_url(driver_url, config)
+        # Check the canonicalized driver_url from the driver
+        if driver.driver_url != driver_url
+          drivers[driver.driver_url] ||= driver
+        else
+          driver
+        end
+      end
+    end
+
+    def connect_to_machine(name, chef_server = nil)
+      if name.is_a?(MachineSpec)
+        machine_spec = name
+      else
+        machine_spec = ChefMetal::ChefMachineSpec.get(name, chef_server)
+      end
+      ChefMetal.connect_to_machine(machine_spec, config)
+    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

data/lib/chef_metal/convergence_strategy.rb

@@ -0,0 +1,26 @@
+module ChefMetal
+  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

data/lib/chef_metal/convergence_strategy/install_cached.rb

@@ -0,0 +1,157 @@
+require 'chef_metal/convergence_strategy/precreate_chef_objects'
+require 'pathname'
+require 'fileutils'
+require 'digest/md5'
+require 'thread'
+
+module ChefMetal
+  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]}"
+
+            ChefMetal.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)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = use_ssl
+        request = Net::HTTP::Get.new(uri.request_uri)
+        response = http.request(request)
+        metadata_str = response.body
+        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

data/lib/chef_metal/convergence_strategy/install_msi.rb

@@ -0,0 +1,56 @@
+require 'chef_metal/convergence_strategy/precreate_chef_objects'
+require 'pathname'
+
+module ChefMetal
+  class ConvergenceStrategy
+    class InstallMsi < PrecreateChefObjects
+      @@install_msi_cache = {}
+
+      def initialize(convergence_options, config)
+        super
+        @install_msi_url = convergence_options[:install_msi_url] || 'http://www.opscode.com/chef/install.msi'
+        @install_msi_path = convergence_options[:install_msi_path] || "%TEMP%\\#{File.basename(@install_msi_url)}"
+        @chef_client_timeout = convergence_options.has_key?(:chef_client_timeout) ? convergence_options[:chef_client_timeout] : 120*60 # Default: 2 hours
+      end
+
+      attr_reader :install_msi_url
+      attr_reader :install_msi_path
+
+      def setup_convergence(action_handler, machine)
+        if !convergence_options.has_key?(:client_rb_path) || !convergence_options.has_key?(:client_pem_path)
+          system_drive = machine.execute_always('$env:SystemDrive').stdout.strip
+          @convergence_options = Cheffish::MergedConfig.new(convergence_options, {
+            :client_rb_path => "#{system_drive}\\chef\\client.rb",
+            :client_pem_path => "#{system_drive}\\chef\\client.pem"
+          })
+        end
+
+        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)}")
+        end
+      end
+
+      def converge(action_handler, machine)
+        super
+
+        # TODO For some reason I get a 500 back if I don't do -l debug
+        action_handler.open_stream(machine.node['name']) do |stdout|
+          action_handler.open_stream(machine.node['name']) do |stderr|
+            machine.execute(action_handler, "chef-client -l debug",
+              :stream_stdout => stdout,
+              :stream_stderr => stderr,
+              :timeout => @chef_client_timeout)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef_metal/convergence_strategy/install_sh.rb

@@ -0,0 +1,51 @@
+require 'chef_metal/convergence_strategy/precreate_chef_objects'
+require 'pathname'
+
+module ChefMetal
+  class ConvergenceStrategy
+    class InstallSh < PrecreateChefObjects
+      @@install_sh_cache = {}
+
+      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)
+        @install_sh_url = convergence_options[:install_sh_url] || 'http://www.opscode.com/chef/install.sh'
+        @install_sh_path = convergence_options[:install_sh_path] || '/tmp/chef-install.sh'
+        @chef_client_timeout = convergence_options.has_key?(:chef_client_timeout) ? convergence_options[:chef_client_timeout] : 120*60 # Default: 2 hours
+      end
+
+      attr_reader :install_sh_url
+      attr_reader :install_sh_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
+          # 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, "bash #{install_sh_path}")
+        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
+    end
+  end
+end