test-kitchen 1.0.0.beta.4 → 1.0.0.rc.1

data/lib/kitchen/provisioner/base.rb

@@ -16,6 +16,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'kitchen/lazy_hash'
+
 module Kitchen
 
   module Provisioner
@@ -27,10 +29,35 @@ module Kitchen
 
       include Logging
 
-      def initialize(instance, config)
-        @instance = instance
-        @config = config
-        @logger = instance.logger
+      attr_accessor :instance
+
+      def initialize(config = {})
+        @config = LazyHash.new(config, self)
+        self.class.defaults.each do |attr, value|
+          @config[attr] = value unless @config.has_key?(attr)
+        end
+      end
+
+      # Returns the name of this driver, suitable for display in a CLI.
+      #
+      # @return [String] name of this driver
+      def name
+        self.class.name.split('::').last
+      end
+
+      # Provides hash-like access to configuration keys.
+      #
+      # @param attr [Object] configuration key
+      # @return [Object] value at configuration key
+      def [](attr)
+        config[attr]
+      end
+
+      # Returns an array of configuration keys.
+      #
+      # @return [Array] array of configuration keys
+      def config_keys
+        config.keys
       end
 
       def install_command ; end
@@ -45,19 +72,38 @@ module Kitchen
 
       def cleanup_sandbox ; end
 
-      def home_path ; end
-
       protected
 
-      attr_reader :instance, :logger, :config, :tmpdir
+      attr_reader :config
+
+      def logger
+        instance ? instance.logger : Kitchen.logger
+      end
 
       def sudo(script)
         config[:sudo] ? "sudo -E #{script}" : script
       end
 
-      def kitchen_root
-        config[:kitchen_root]
+      def self.defaults
+        @defaults ||= Hash.new.merge(super_defaults)
+      end
+
+      def self.super_defaults
+        klass = self.superclass
+
+        if klass.respond_to?(:defaults)
+          klass.defaults
+        else
+          Hash.new
+        end
+      end
+
+      def self.default_config(attr, value = nil, &block)
+        defaults[attr] = block_given? ? block : value
       end
+
+      default_config :root_path, "/tmp/kitchen"
+      default_config :sudo, true
     end
   end
 end

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

@@ -0,0 +1,76 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2013, Fletcher Nichol
+#
+# 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 'kitchen/errors'
+require 'kitchen/logging'
+
+module Kitchen
+
+  module Provisioner
+
+    module Chef
+
+      # Chef cookbook resolver that uses Berkshelf and a Berksfile to calculate
+      # dependencies.
+      #
+      # @author Fletcher Nichol <fnichol@nichol.ca>
+      class Berkshelf
+
+        include Logging
+
+        def initialize(berksfile, path, logger = Kitchen.logger)
+          @berksfile  = berksfile
+          @path       = path
+          @logger     = logger
+        end
+
+        def resolve
+          info("Resolving cookbook dependencies with Berkshelf...")
+          debug("Using Berksfile from #{berksfile}")
+
+          load_berkshelf!
+
+          ::Berkshelf.ui.mute do
+            if ::Berkshelf::Berksfile.method_defined?(:vendor)
+              # Berkshelf 3.0 requires the directory to not exist
+              FileUtils.rm_rf(path)
+              ::Berkshelf::Berksfile.from_file(berksfile).vendor(path)
+            else
+              ::Berkshelf::Berksfile.from_file(berksfile).install(path: path)
+            end
+          end
+        end
+
+        private
+
+        attr_reader :berksfile, :path, :logger
+
+        def load_berkshelf!
+          require 'berkshelf'
+        rescue LoadError => e
+          fatal("The `berkshelf' gem is missing and must be installed" +
+            " or cannot be properly activated. Run" +
+            " `gem install berkshelf` or add the following to your" +
+            " Gemfile if you are using Bundler: `gem 'berkshelf'`.")
+          raise UserError,
+            "Could not load or activate Berkshelf (#{e.message})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2013, Fletcher Nichol
+#
+# 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 'kitchen/errors'
+require 'kitchen/logging'
+
+module Kitchen
+
+  module Provisioner
+
+    module Chef
+
+      # Chef cookbook resolver that uses Librarian-Chef and a Cheffile to
+      # calculate # dependencies.
+      #
+      # @author Fletcher Nichol <fnichol@nichol.ca>
+      class Librarian
+
+        include Logging
+
+        def initialize(cheffile, path, logger = Kitchen.logger)
+          @cheffile   = cheffile
+          @path       = path
+          @logger     = logger
+        end
+
+        def resolve
+          info("Resolving cookbook dependencies with Librarian-Chef")
+          debug("Using Cheffile from #{cheffile}")
+
+          load_librarian!
+
+          env = ::Librarian::Chef::Environment.new(
+            :project_path => File.dirname(cheffile))
+          env.config_db.local["path"] = path
+          ::Librarian::Action::Resolve.new(env).run
+          ::Librarian::Action::Install.new(env).run
+        end
+
+        attr_reader :cheffile, :path, :logger
+
+        def load_librarian!
+          require 'librarian/chef/environment'
+          require 'librarian/action/resolve'
+          require 'librarian/action/install'
+        rescue LoadError => e
+          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})"
+        end
+      end
+    end
+  end
+end

data/lib/kitchen/provisioner/chef_base.rb

@@ -16,10 +16,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'buff/ignore'
 require 'fileutils'
 require 'pathname'
 require 'json'
+
+require 'kitchen/provisioner/chef/berkshelf'
+require 'kitchen/provisioner/chef/librarian'
 require 'kitchen/util'
 
 module Kitchen
@@ -31,10 +33,47 @@ module Kitchen
     # @author Fletcher Nichol <fnichol@nichol.ca>
     class ChefBase < Base
 
+      default_config :require_chef_omnibus, true
+      default_config :chef_omnibus_url, "https://www.opscode.com/chef/install.sh"
+      default_config :run_list, []
+      default_config :attributes, {}
+      default_config :cookbook_files_glob, %w[README.* metadata.{json,rb}
+        attributes/**/* definitions/**/* files/**/* libraries/**/*
+        providers/**/* recipes/**/* resources/**/* templates/**/*].join(",")
+
+      default_config :data_path do |provisioner|
+        provisioner.calculate_path("data")
+      end
+
+      default_config :data_bags_path do |provisioner|
+        provisioner.calculate_path("data_bags")
+      end
+
+      default_config :environments_path do |provisioner|
+        provisioner.calculate_path("environments")
+      end
+
+      default_config :nodes_path do |provisioner|
+        provisioner.calculate_path("nodes")
+      end
+
+      default_config :roles_path do |provisioner|
+        provisioner.calculate_path("roles")
+      end
+
+      default_config :encrypted_data_bag_secret_key_path do |provisioner|
+        provisioner.calculate_path("encrypted_data_bag_secret", :file)
+      end
+
+      def instance=(instance)
+        @instance = instance
+        expand_paths!
+      end
+
       def install_command
-        return nil unless config[:require_chef_omnibus]
+        return unless config[:require_chef_omnibus]
 
-        url = config[:chef_omnibus_url] || "https://www.opscode.com/chef/install.sh"
+        url = config[:chef_omnibus_url]
         flag = config[:require_chef_omnibus]
         version = if flag.is_a?(String) && flag != "latest"
           "-v #{flag.downcase}"
@@ -63,7 +102,9 @@ module Kitchen
       end
 
       def init_command
-        "#{sudo('rm')} -rf #{home_path}"
+        dirs = %w{cookbooks data data_bags environments roles}.
+          map { |dir| File.join(config[:root_path], dir) }.join(" ")
+        "#{sudo('rm')} -rf #{dirs} ; mkdir -p #{config[:root_path]}"
       end
 
       def cleanup_sandbox
@@ -73,8 +114,59 @@ module Kitchen
         FileUtils.rmtree(tmpdir)
       end
 
+      def calculate_path(path, type = :directory)
+        base = config[:test_base_path]
+        candidates = []
+        candidates << File.join(base, instance.suite.name, path)
+        candidates << File.join(base, path)
+        candidates << File.join(Dir.pwd, path)
+
+        candidates.find do |c|
+          type == :directory ? File.directory?(c) : File.file?(c)
+        end
+      end
+
       protected
 
+      attr_reader :tmpdir
+
+      def expand_paths!
+        paths = %w{test_base data data_bags environments nodes roles}
+        paths.map{ |p| "#{p}_path".to_sym }.each do |key|
+          unless config[key].nil?
+            config[key] = File.expand_path(config[key], config[:kitchen_root])
+          end
+        end
+      end
+
+      def format_config_file(data)
+        data.each.map { |attr, value|
+          [attr, (value.is_a?(Array) ? value.to_s : %{"#{value}"})].join(" ")
+        }.join("\n")
+      end
+
+      def default_config_rb
+        root = config[:root_path]
+
+        {
+          :node_name        => instance.name,
+          :checksum_path    => "#{root}/checksums",
+          :file_cache_path  => "#{root}/cache",
+          :file_backup_path => "#{root}/backup",
+          :cookbook_path    => ["#{root}/cookbooks", "#{root}/site-cookbooks"],
+          :data_bag_path    => "#{root}/data_bags",
+          :environment_path => "#{root}/environments",
+          :node_path        => "#{root}/nodes",
+          :role_path        => "#{root}/roles",
+          :client_path      => "#{root}/clients",
+          :user_path        => "#{root}/users",
+          :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",
+        }
+      end
+
       def create_chef_sandbox
         @tmpdir = Dir.mktmpdir("#{instance.name}-sandbox-")
         File.chmod(0755, @tmpdir)
@@ -82,22 +174,36 @@ module Kitchen
 
         yield if block_given?
         prepare_json
+        prepare_cache
+        prepare_cookbooks
+        prepare_data
         prepare_data_bags
-        prepare_roles
-        prepare_nodes
         prepare_environments
+        prepare_nodes
+        prepare_roles
         prepare_secret
-        prepare_cache
-        prepare_cookbooks
         tmpdir
       end
 
       def prepare_json
+        dna = config[:attributes].merge({ :run_list => config[:run_list] })
+
         File.open(File.join(tmpdir, "dna.json"), "wb") do |file|
-          file.write(instance.dna.to_json)
+          file.write(dna.to_json)
         end
       end
 
+      def prepare_data
+        return unless data
+
+        info("Preparing data")
+        debug("Using data from #{data}")
+
+        tmpdata_dir = File.join(tmpdir, "data")
+        FileUtils.mkdir_p(tmpdata_dir)
+        FileUtils.cp_r(Dir.glob("#{data}/*"), tmpdata_dir)
+      end
+
       def prepare_data_bags
         return unless data_bags
 
@@ -165,65 +271,71 @@ module Kitchen
         elsif File.exists?(metadata_rb)
           cp_this_cookbook
         else
-          FileUtils.rmtree(tmpdir)
-          fatal("Berksfile, Cheffile, cookbooks/, or metadata.rb" +
-            " must exist in #{kitchen_root}")
-          raise UserError, "Cookbooks could not be found"
+          make_fake_cookbook
         end
 
-        remove_ignored_files
+        filter_only_cookbook_files
       end
 
-      def remove_ignored_files
-        cookbooks_in_tmpdir do |cookbook_path|
-          chefignore = File.join(cookbook_path, "chefignore")
-          if File.exist? chefignore
-            ignores = Buff::Ignore::IgnoreFile.new(chefignore)
-            cookbook_files = Dir.glob(File.join(cookbook_path, "**/*"), File::FNM_DOTMATCH).
-              select { |fn| File.file?(fn) && fn != '.' && fn != '..' }
-            cookbook_files.each { |file| FileUtils.rm(file) if ignores.ignored?(file) }
-          end
-        end
+      def filter_only_cookbook_files
+        info("Removing non-cookbook files in sandbox")
+        FileUtils.rm(all_files_in_cookbooks - only_cookbook_files)
+      end
+
+      def all_files_in_cookbooks
+        Dir.glob(File.join(tmpbooks_dir, "**/*"), File::FNM_DOTMATCH).
+          select { |fn| File.file?(fn) && ! %w{. ..}.include?(fn) }
+      end
+
+      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) }
       end
 
       def berksfile
-        File.join(kitchen_root, "Berksfile")
+        File.join(config[:kitchen_root], "Berksfile")
       end
 
       def cheffile
-        File.join(kitchen_root, "Cheffile")
+        File.join(config[:kitchen_root], "Cheffile")
       end
 
       def metadata_rb
-        File.join(kitchen_root, "metadata.rb")
+        File.join(config[:kitchen_root], "metadata.rb")
       end
 
       def cookbooks_dir
-        File.join(kitchen_root, "cookbooks")
+        File.join(config[:kitchen_root], "cookbooks")
       end
 
       def site_cookbooks_dir
-        File.join(kitchen_root, "site-cookbooks")
+        File.join(config[:kitchen_root], "site-cookbooks")
       end
 
       def data_bags
-        instance.suite.data_bags_path
+        config[:data_bags_path]
       end
 
       def roles
-        instance.suite.roles_path
+        config[:roles_path]
       end
 
       def nodes
-        instance.suite.nodes_path
+        config[:nodes_path]
+      end
+
+      def data
+        config[:data_path]
       end
 
       def environments
-        instance.suite.environments_path
+        config[:environments_path]
       end
 
       def secret
-        instance.suite.encrypted_data_bag_secret_key_path
+        config[:encrypted_data_bag_secret_key_path]
       end
 
       def tmpbooks_dir
@@ -260,63 +372,32 @@ module Kitchen
 
         cb_path = File.join(tmpbooks_dir, cb_name)
 
-        glob = Dir.glob("#{kitchen_root}/**")
+        glob = Dir.glob("#{config[:kitchen_root]}/**")
 
         FileUtils.mkdir_p(cb_path)
         FileUtils.cp_r(glob, cb_path)
       end
 
-      def resolve_with_berkshelf
-        info("Resolving cookbook dependencies with Berkshelf")
-        debug("Using Berksfile from #{berksfile}")
-
-        begin
-          require 'berkshelf'
-        rescue LoadError => e
-          fatal("The `berkshelf' gem is missing and must be installed" +
-            " or cannot be properly activated. Run" +
-            " `gem install berkshelf` or add the following to your" +
-            " Gemfile if you are using Bundler: `gem 'berkshelf'`.")
-          raise UserError,
-            "Could not load or activate Berkshelf (#{e.message})"
+      def make_fake_cookbook
+        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"})
         end
+      end
 
+      def resolve_with_berkshelf
         Kitchen.mutex.synchronize do
-          Berkshelf::Berksfile.from_file(berksfile).
-            install(:path => tmpbooks_dir)
+          Chef::Berkshelf.new(berksfile, tmpbooks_dir, logger).resolve
         end
       end
 
       def resolve_with_librarian
-        info("Resolving cookbook dependencies with Librarian-Chef")
-        debug("Using Cheffile from #{cheffile}")
-
-        begin
-          require 'librarian/chef/environment'
-          require 'librarian/action/resolve'
-          require 'librarian/action/install'
-        rescue LoadError => e
-          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})"
-        end
-
         Kitchen.mutex.synchronize do
-          env = Librarian::Chef::Environment.new(:project_path => kitchen_root)
-          env.config_db.local["path"] = tmpbooks_dir
-          Librarian::Action::Resolve.new(env).run
-          Librarian::Action::Install.new(env).run
-        end
-      end
-
-      private
-
-      def cookbooks_in_tmpdir
-        Dir.glob(File.join(tmpbooks_dir, "*/")).each do |cookbook_path|
-          yield cookbook_path if block_given?
+          Chef::Librarian.new(cheffile, tmpbooks_dir, logger).resolve
         end
       end
     end