test-kitchen 1.2.1 → 1.3.0

data/lib/kitchen/provisioner/chef/librarian.rb

@@ -16,8 +16,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'kitchen/errors'
-require 'kitchen/logging'
+require "kitchen/errors"
+require "kitchen/logging"
 
 module Kitchen
 
@@ -26,24 +26,36 @@ module Kitchen
     module Chef
 
       # Chef cookbook resolver that uses Librarian-Chef and a Cheffile to
-      # calculate # dependencies.
+      # calculate dependencies.
       #
       # @author Fletcher Nichol <fnichol@nichol.ca>
       class Librarian
 
         include Logging
 
-
+        # Creates a new cookbook resolver.
+        #
+        # @param cheffile [String] path to a Cheffile
+        # @param path [String] path in which to vendor the resulting
+        #   cookbooks
+        # @param logger [Kitchen::Logger] a logger to use for output, defaults
+        #   to `Kitchen.logger`
         def initialize(cheffile, path, logger = Kitchen.logger)
           @cheffile   = cheffile
           @path       = path
           @logger     = logger
         end
 
+        # Loads the library code required to use the resolver.
+        #
+        # @param logger [Kitchen::Logger] a logger to use for output, defaults
+        #   to `Kitchen.logger`
         def self.load!(logger = Kitchen.logger)
           load_librarian!(logger)
         end
 
+        # Performs the cookbook resolution and vendors the resulting cookbooks
+        # in the desired path.
         def resolve
           version = ::Librarian::Chef::VERSION
           info("Resolving cookbook dependencies with Librarian-Chef #{version}...")
@@ -56,12 +68,29 @@ module Kitchen
           ::Librarian::Action::Install.new(env).run
         end
 
-        attr_reader :cheffile, :path, :logger
+        private
+
+        # @return [String] path to a Cheffile
+        # @api private
+        attr_reader :cheffile
+
+        # @return [String] path in which to vendor the resulting cookbooks
+        # @api private
+        attr_reader :path
+
+        # @return [Kitchen::Logger] a logger to use for output
+        # @api private
+        attr_reader :logger
 
+        # Load the Librarian-specific libary code.
+        #
+        # @param logger [Kitchen::Logger] the logger to use
+        # @raise [UserError] if the library couldn't be loaded
+        # @api private
         def self.load_librarian!(logger)
-          first_load = require 'librarian/chef/environment'
-          require 'librarian/action/resolve'
-          require 'librarian/action/install'
+          first_load = require "librarian/chef/environment"
+          require "librarian/action/resolve"
+          require "librarian/action/install"
 
           version = ::Librarian::Chef::VERSION
           if first_load
@@ -70,9 +99,9 @@ module Kitchen
             logger.debug("Librarian-Chef #{version} previously loaded")
           end
         rescue LoadError => e
-          logger.fatal("The `librarian-chef' gem is missing and must be installed" +
-            " or cannot be properly activated. Run" +
-            " `gem install librarian-chef` or add the following to your" +
+          logger.fatal("The `librarian-chef' gem is missing and must be installed" \
+            " or cannot be properly activated. Run" \
+            " `gem install librarian-chef` or add the following to your" \
             " Gemfile if you are using Bundler: `gem 'librarian-chef'`.")
           raise UserError,
             "Could not load or activate Librarian-Chef (#{e.message})"

data/lib/kitchen/provisioner/chef_base.rb

@@ -16,13 +16,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'fileutils'
-require 'pathname'
-require 'json'
+require "fileutils"
+require "pathname"
+require "json"
 
-require 'kitchen/provisioner/chef/berkshelf'
-require 'kitchen/provisioner/chef/librarian'
-require 'kitchen/util'
+require "kitchen/provisioner/chef/berkshelf"
+require "kitchen/provisioner/chef/librarian"
+require "kitchen/util"
 
 module Kitchen
 
@@ -34,12 +34,17 @@ module Kitchen
     class ChefBase < Base
 
       default_config :require_chef_omnibus, true
-      default_config :chef_omnibus_url, "https://www.getchef.com/chef/install.sh"
+      default_config :chef_omnibus_url, "https://www.chef.io/chef/install.sh"
+      default_config :chef_omnibus_root, "/opt/chef"
+      default_config :chef_omnibus_install_options, nil
       default_config :run_list, []
       default_config :attributes, {}
-      default_config :cookbook_files_glob, %w[README.* metadata.{json,rb}
+      default_config :log_file, nil
+      default_config :cookbook_files_glob, %w[
+        README.* metadata.{json,rb}
         attributes/**/* definitions/**/* files/**/* libraries/**/*
-        providers/**/* recipes/**/* resources/**/* templates/**/*].join(",")
+        providers/**/* recipes/**/* resources/**/* templates/**/*
+      ].join(",")
 
       default_config :data_path do |provisioner|
         provisioner.calculate_path("data")
@@ -72,79 +77,117 @@ module Kitchen
       expand_path_for :clients_path
 
       default_config :encrypted_data_bag_secret_key_path do |provisioner|
-        provisioner.calculate_path("encrypted_data_bag_secret_key", :file)
+        provisioner.calculate_path("encrypted_data_bag_secret_key", :type => :file)
       end
       expand_path_for :encrypted_data_bag_secret_key_path
 
+      # (see Base#install_command)
       def install_command
         return unless config[:require_chef_omnibus]
 
-        url = config[:chef_omnibus_url]
-        flag = config[:require_chef_omnibus]
-        version = if flag.is_a?(String) && flag != "latest"
-          "-v #{flag.downcase}"
-        else
-          ""
-        end
-
-        # use Bourne (/bin/sh) as Bash does not exist on all Unix flavors
-        <<-INSTALL.gsub(/^ {10}/, '')
-          sh -c '
-          #{Util.shell_helpers}
-
-          should_update_chef() {
-            case "#{flag}" in
-              true|`chef-solo -v | cut -d " " -f 2`) return 1 ;;
-              latest|*) return 0 ;;
-            esac
-          }
-
-          if [ ! -d "/opt/chef" ] || should_update_chef ; then
-            echo "-----> Installing Chef Omnibus (#{flag})"
-            do_download #{url} /tmp/install.sh
-            #{sudo('sh')} /tmp/install.sh #{version}
-          fi'
-        INSTALL
+        lines = [Util.shell_helpers, chef_shell_helpers, chef_install_function]
+        Util.wrap_command(lines.join("\n"))
       end
 
+      # (see Base#init_command)
       def init_command
-        dirs = %w{cookbooks data data_bags environments roles clients}.
+        dirs = %w[cookbooks data data_bags environments roles clients].
           map { |dir| File.join(config[:root_path], dir) }.join(" ")
-        "#{sudo('rm')} -rf #{dirs} ; mkdir -p #{config[:root_path]}"
+        lines = ["#{sudo("rm")} -rf #{dirs}", "mkdir -p #{config[:root_path]}"]
+
+        Util.wrap_command(lines.join("\n"))
       end
 
+      # (see Base#create_sandbox)
       def create_sandbox
         super
         prepare_json
         prepare_cache
         prepare_cookbooks
-        prepare_data
-        prepare_data_bags
-        prepare_environments
-        prepare_nodes
-        prepare_roles
-        prepare_clients
-        prepare_secret
-      end
-
-      protected
-
+        prepare(:data)
+        prepare(:data_bags)
+        prepare(:environments)
+        prepare(:nodes)
+        prepare(:roles)
+        prepare(:clients)
+        prepare(
+          :secret,
+          :type => :file,
+          :dest_name => "encrypted_data_bag_secret",
+          :key_name => :encrypted_data_bag_secret_key_path
+        )
+      end
+
+      private
+
+      # Load cookbook dependency resolver code, if required.
+      #
+      # (see Base#load_needed_dependencies!)
       def load_needed_dependencies!
-        if File.exists?(berksfile)
+        if File.exist?(berksfile)
           debug("Berksfile found at #{berksfile}, loading Berkshelf")
           Chef::Berkshelf.load!(logger)
-        elsif File.exists?(cheffile)
+        elsif File.exist?(cheffile)
           debug("Cheffile found at #{cheffile}, loading Librarian-Chef")
           Chef::Librarian.load!(logger)
         end
       end
 
+      # Returns shell code with chef-related functions.
+      #
+      # @return [String] shell code
+      # @api private
+      def chef_shell_helpers
+        IO.read(File.join(
+          File.dirname(__FILE__), %w[.. .. .. support chef_helpers.sh]
+        ))
+      end
+
+      # Generates the shell code to conditionally install a Chef Omnibus
+      # package onto an instance.
+      #
+      # @return [String] shell code
+      # @api private
+      def chef_install_function
+        version = config[:require_chef_omnibus].to_s.downcase
+        pretty_version = case version
+                         when "true" then "install only if missing"
+                         when "latest" then "always install latest version"
+                         else version
+                         end
+        install_flags = %w[latest true].include?(version) ? "" : "-v #{version}"
+        if config[:chef_omnibus_install_options]
+          install_flags += config[:chef_omnibus_install_options]
+        end
+
+        <<-INSTALL.gsub(/^ {10}/, "")
+          if should_update_chef "#{config[:chef_omnibus_root]}" "#{version}" ; then
+            echo "-----> Installing Chef Omnibus (#{pretty_version})"
+            do_download #{config[:chef_omnibus_url]} /tmp/install.sh
+            #{sudo("sh")} /tmp/install.sh #{install_flags}
+          else
+            echo "-----> Chef Omnibus installation detected (#{pretty_version})"
+          fi
+        INSTALL
+      end
+
+      # Generates a rendered client.rb/solo.rb/knife.rb formatted file as a
+      # String.
+      #
+      # @param data [Hash] a key/value pair hash of configuration
+      # @return [String] a rendered Chef config file as a String
+      # @api private
       def format_config_file(data)
         data.each.map { |attr, value|
-          [attr, (value.is_a?(Array) ? value.to_s : %{"#{value}"})].join(" ")
+          [attr, value.inspect].join(" ")
         }.join("\n")
       end
 
+      # Generates a Hash with default values for a solo.rb or client.rb Chef
+      # configuration file.
+      #
+      # @return [Hash] a configuration hash
+      # @api private
       def default_config_rb
         root = config[:root_path]
 
@@ -163,105 +206,78 @@ module Kitchen
           :validation_key   => "#{root}/validation.pem",
           :client_key       => "#{root}/client.pem",
           :chef_server_url  => "http://127.0.0.1:8889",
-          :encrypted_data_bag_secret => "#{root}/encrypted_data_bag_secret",
+          :encrypted_data_bag_secret => "#{root}/encrypted_data_bag_secret"
         }
       end
 
-      def prepare_json
-        dna = config[:attributes].merge({ :run_list => config[:run_list] })
-
-        File.open(File.join(sandbox_path, "dna.json"), "wb") do |file|
-          file.write(dna.to_json)
+      # Prepares a generic Chef component source directory or file for
+      # inclusion in the sandbox path. These components might includes nodes,
+      # roles, etc.
+      #
+      # @param component [Symbol,String] a component name such as `:node`
+      # @param opts [Hash] optional configuration
+      # @option opts [Symbol] :type whether the component is a directory or
+      #   file (default: `:directory`)
+      # @option opts [Symbol] :key_name the key name in the config hash from
+      #   which to pull the source path (default: `"#{component}_path"`)
+      # @option opts [String] :dest_name the destination file or directory
+      #   basename in the sandbox path (default: `component.to_s`)
+      # @api private
+      def prepare(component, opts = {})
+        opts = { :type => :directory }.merge(opts)
+        key_name = opts.fetch(:key_name, "#{component}_path")
+        src = config[key_name.to_sym]
+        return if src.nil?
+
+        info("Preparing #{component}")
+        debug("Using #{component} from #{src}")
+
+        dest = File.join(sandbox_path, opts.fetch(:dest_name, component.to_s))
+
+        case opts[:type]
+        when :directory
+          FileUtils.mkdir_p(dest)
+          FileUtils.cp_r(Dir.glob("#{src}/*"), dest)
+        when :file
+          FileUtils.mkdir_p(File.dirname(dest))
+          FileUtils.cp_r(src, dest)
         end
       end
 
-      def prepare_data
-        return unless data
-
-        info("Preparing data")
-        debug("Using data from #{data}")
-
-        tmpdata_dir = File.join(sandbox_path, "data")
-        FileUtils.mkdir_p(tmpdata_dir)
-        FileUtils.cp_r(Dir.glob("#{data}/*"), tmpdata_dir)
-      end
-
-      def prepare_data_bags
-        return unless data_bags
-
-        info("Preparing data bags")
-        debug("Using data bags from #{data_bags}")
-
-        tmpbags_dir = File.join(sandbox_path, "data_bags")
-        FileUtils.mkdir_p(tmpbags_dir)
-        FileUtils.cp_r(Dir.glob("#{data_bags}/*"), tmpbags_dir)
-      end
-
-      def prepare_roles
-        return unless roles
-
-        info("Preparing roles")
-        debug("Using roles from #{roles}")
-
-        tmproles_dir = File.join(sandbox_path, "roles")
-        FileUtils.mkdir_p(tmproles_dir)
-        FileUtils.cp_r(Dir.glob("#{roles}/*"), tmproles_dir)
-      end
-
-      def prepare_clients
-        return unless clients
-
-        info("Preparing clients")
-        debug("Using roles from #{clients}")
-
-        tmpclients_dir = File.join(sandbox_path, "clients")
-        FileUtils.mkdir_p(tmpclients_dir)
-        FileUtils.cp_r(Dir.glob("#{clients}/*"), tmpclients_dir)
-      end
-
-      def prepare_nodes
-        return unless nodes
-
-        info("Preparing nodes")
-        debug("Using nodes from #{nodes}")
-
-        tmpnodes_dir = File.join(sandbox_path, "nodes")
-        FileUtils.mkdir_p(tmpnodes_dir)
-        FileUtils.cp_r(Dir.glob("#{nodes}/*"), tmpnodes_dir)
-      end
-
-      def prepare_environments
-        return unless environments
-
-        info("Preparing environments")
-        debug("Using environments from #{environments}")
-
-        tmpenvs_dir = File.join(sandbox_path, "environments")
-        FileUtils.mkdir_p(tmpenvs_dir)
-        FileUtils.cp_r(Dir.glob("#{environments}/*"), tmpenvs_dir)
-      end
-
-      def prepare_secret
-        return unless secret
+      # Prepares a Chef JSON file, sometimes called a dna.json or
+      # first-boot.json, for inclusion in the sandbox path.
+      #
+      # @api private
+      def prepare_json
+        dna = config[:attributes].merge(:run_list => config[:run_list])
 
-        info("Preparing encrypted data bag secret")
-        debug("Using secret from #{secret}")
+        info("Preparing dna.json")
+        debug("Creating dna.json from #{dna.inspect}")
 
-        FileUtils.cp_r(secret, File.join(sandbox_path, "encrypted_data_bag_secret"))
+        File.open(File.join(sandbox_path, "dna.json"), "wb") do |file|
+          file.write(dna.to_json)
+        end
       end
 
+      # Prepares a cache directory for inclusion in the sandbox path.
+      #
+      # @api private
       def prepare_cache
         FileUtils.mkdir_p(File.join(sandbox_path, "cache"))
       end
 
+      # Prepares Chef cookbooks for inclusion in the sandbox path.
+      #
+      # @api private
       def prepare_cookbooks
-        if File.exists?(berksfile)
+        if File.exist?(berksfile)
           resolve_with_berkshelf
-        elsif File.exists?(cheffile)
+        elsif File.exist?(cheffile)
           resolve_with_librarian
+          cp_site_cookbooks if File.directory?(site_cookbooks_dir)
         elsif File.directory?(cookbooks_dir)
           cp_cookbooks
-        elsif File.exists?(metadata_rb)
+        elsif File.exist?(metadata_rb)
           cp_this_cookbook
         else
           make_fake_cookbook
@@ -270,79 +286,86 @@ module Kitchen
         filter_only_cookbook_files
       end
 
+      # Removes all non-cookbook files in the sandbox path.
+      #
+      # @api private
       def filter_only_cookbook_files
         info("Removing non-cookbook files before transfer")
         FileUtils.rm(all_files_in_cookbooks - only_cookbook_files)
       end
 
+      # Generates a list of all files in the cookbooks directory in the
+      # sandbox path.
+      #
+      # @return [Array<String>] an array of absolute paths to files
+      # @api private
       def all_files_in_cookbooks
         Dir.glob(File.join(tmpbooks_dir, "**/*"), File::FNM_DOTMATCH).
-          select { |fn| File.file?(fn) && ! %w{. ..}.include?(fn) }
+          select { |fn| File.file?(fn) && ! %w[. ..].include?(fn) }
       end
 
+      # Generates a list of all typical cookbook files needed in a Chef run,
+      # located in the cookbooks directory in the sandbox path.
+      #
+      # @return [Array<String>] an array of absolute paths to files
+      # @api private
       def only_cookbook_files
         glob = File.join(tmpbooks_dir, "*", "{#{config[:cookbook_files_glob]}}")
 
         Dir.glob(glob, File::FNM_DOTMATCH).
-          select { |fn| File.file?(fn) && ! %w{. ..}.include?(fn) }
+          select { |fn| File.file?(fn) && ! %w[. ..].include?(fn) }
       end
 
+      # @return [String] an absolute path to a Berksfile, relative to the
+      #   kitchen root
+      # @api private
       def berksfile
         File.join(config[:kitchen_root], "Berksfile")
       end
 
+      # @return [String] an absolute path to a Cheffile, relative to the
+      #   kitchen root
+      # @api private
       def cheffile
         File.join(config[:kitchen_root], "Cheffile")
       end
 
+      # @return [String] an absolute path to a metadata.rb, relative to the
+      #   kitchen root
+      # @api private
       def metadata_rb
         File.join(config[:kitchen_root], "metadata.rb")
       end
 
+      # @return [String] an absolute path to a cookbooks/ directory, relative
+      #   to the kitchen root
+      # @api private
       def cookbooks_dir
         File.join(config[:kitchen_root], "cookbooks")
       end
 
+      # @return [String] an absolute path to a site-cookbooks/ directory,
+      #   relative to the kitchen root
+      # @api private
       def site_cookbooks_dir
         File.join(config[:kitchen_root], "site-cookbooks")
       end
 
-      def data_bags
-        config[:data_bags_path]
-      end
-
-      def roles
-        config[:roles_path]
-      end
-
-      def clients
-        config[:clients_path]
-      end
-
-      def nodes
-        config[:nodes_path]
-      end
-
-      def data
-        config[:data_path]
-      end
-
-      def environments
-        config[:environments_path]
-      end
-
-      def secret
-        config[:encrypted_data_bag_secret_key_path]
-      end
-
+      # @return [String] an absolute path to a cookbooks/ directory in the
+      #   sandbox path
+      # @api private
       def tmpbooks_dir
         File.join(sandbox_path, "cookbooks")
       end
 
+      # @return [String] an absolute path to a site cookbooks directory in the
+      #   sandbox path
+      # @api private
       def tmpsitebooks_dir
         File.join(sandbox_path, "cookbooks")
       end
 
+      # Copies a cookbooks/ directory into the sandbox path.
       def cp_cookbooks
         info("Preparing cookbooks from project directory")
         debug("Using cookbooks from #{cookbooks_dir}")
@@ -351,9 +374,12 @@ module Kitchen
         FileUtils.cp_r(File.join(cookbooks_dir, "."), tmpbooks_dir)
 
         cp_site_cookbooks if File.directory?(site_cookbooks_dir)
-        cp_this_cookbook if File.exists?(metadata_rb)
+        cp_this_cookbook if File.exist?(metadata_rb)
       end
 
+      # Copies a site-cookbooks/ directory into the sandbox path.
+      #
+      # @api private
       def cp_site_cookbooks
         info("Preparing site-cookbooks from project directory")
         debug("Using cookbooks from #{site_cookbooks_dir}")
@@ -362,12 +388,16 @@ module Kitchen
         FileUtils.cp_r(File.join(site_cookbooks_dir, "."), tmpsitebooks_dir)
       end
 
+      # Copies the current project, assumed to be a Chef cookbook into the
+      # sandbox path.
+      #
+      # @api private
       def cp_this_cookbook
         info("Preparing current project directory as a cookbook")
         debug("Using metadata.rb from #{metadata_rb}")
 
-        cb_name = MetadataChopper.extract(metadata_rb).first or raise(UserError,
-          "The metadata.rb does not define the 'name' key." +
+        cb_name = MetadataChopper.extract(metadata_rb).first || raise(UserError,
+          "The metadata.rb does not define the 'name' key." \
             " Please add: `name '<cookbook_name>'` to metadata.rb and retry")
 
         cb_path = File.join(tmpbooks_dir, cb_name)
@@ -378,23 +408,32 @@ module Kitchen
         FileUtils.cp_r(glob, cb_path)
       end
 
+      # Creates a minimal, no-op cookbook in the sandbox path.
+      #
+      # @api private
       def make_fake_cookbook
-        info("Berksfile, Cheffile, cookbooks/, or metadata.rb not found " +
+        info("Berksfile, Cheffile, cookbooks/, or metadata.rb not found " \
           "so Chef will run with effectively no cookbooks. Is this intended?")
         name = File.basename(config[:kitchen_root])
         fake_cb = File.join(tmpbooks_dir, name)
         FileUtils.mkdir_p(fake_cb)
         File.open(File.join(fake_cb, "metadata.rb"), "wb") do |file|
-          file.write(%{name "#{name}\n"})
+          file.write(%{name "#{name}"\n})
         end
       end
 
+      # Performs a Berkshelf cookbook resolution inside a common mutex.
+      #
+      # @api private
       def resolve_with_berkshelf
         Kitchen.mutex.synchronize do
           Chef::Berkshelf.new(berksfile, tmpbooks_dir, logger).resolve
         end
       end
 
+      # Performs a Librarin-Chef cookbook resolution inside a common mutex.
+      #
+      # @api private
       def resolve_with_librarian
         Kitchen.mutex.synchronize do
           Chef::Librarian.new(cheffile, tmpbooks_dir, logger).resolve