test-kitchen 0.7.0 → 1.0.0.alpha.0

data/lib/kitchen/chef_data_uploader.rb

@@ -0,0 +1,156 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, 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 'fileutils'
+require 'json'
+require 'net/scp'
+require 'stringio'
+
+module Kitchen
+
+  # Uploads Chef asset files such as dna.json, data bags, and cookbooks to an
+  # instance over SSH.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class ChefDataUploader
+
+    include ShellOut
+    include Logging
+
+    def initialize(instance, ssh_args, kitchen_root, chef_home)
+      @instance = instance
+      @ssh_args = ssh_args
+      @kitchen_root = kitchen_root
+      @chef_home = chef_home
+    end
+
+    def upload
+      Net::SCP.start(*ssh_args) do |scp|
+        upload_json       scp
+        upload_solo_rb    scp
+        upload_cookbooks  scp
+        upload_data_bags  scp if instance.suite.data_bags_path
+        upload_roles      scp if instance.suite.roles_path
+      end
+    end
+
+    private
+
+    attr_reader :instance, :ssh_args, :kitchen_root, :chef_home
+
+    def logger
+      instance.logger
+    end
+
+    def upload_json(scp)
+      json_file = StringIO.new(instance.dna.to_json)
+      scp.upload!(json_file, "#{chef_home}/dna.json")
+    end
+
+    def upload_solo_rb(scp)
+      solo_rb_file = StringIO.new(solo_rb_contents)
+      scp.upload!(solo_rb_file, "#{chef_home}/solo.rb")
+    end
+
+    def upload_cookbooks(scp)
+      cookbooks_dir = local_cookbooks
+      upload_path(scp, cookbooks_dir, "cookbooks")
+    ensure
+      FileUtils.rmtree(cookbooks_dir)
+    end
+
+    def upload_data_bags(scp)
+      upload_path(scp, instance.suite.data_bags_path)
+    end
+
+    def upload_roles(scp)
+      upload_path(scp, instance.suite.roles_path)
+    end
+
+    def upload_path(scp, path, dir = File.basename(path))
+      dest = "#{chef_home}/#{dir}"
+
+      scp.upload!(path, dest, :recursive => true) do |ch, name, sent, total|
+        if sent == total
+          info("Uploaded #{name.sub(%r{^#{path}/}, '')} (#{total} bytes)")
+        end
+      end
+    end
+
+    def solo_rb_contents
+      solo = []
+      solo << %{node_name "#{instance.name}"}
+      solo << %{file_cache_path "#{chef_home}/cache"}
+      solo << %{cookbook_path "#{chef_home}/cookbooks"}
+      solo << %{role_path "#{chef_home}/roles"}
+      if instance.suite.data_bags_path
+        solo << %{data_bag_path "#{chef_home}/data_bags"}
+      end
+      solo.join("\n")
+    end
+
+    def local_cookbooks
+      tmpdir = Dir.mktmpdir("#{instance.name}-cookbooks")
+      prepare_tmpdir(tmpdir)
+      tmpdir
+    end
+
+    def prepare_tmpdir(tmpdir)
+      if File.exists?(File.join(kitchen_root, "Berksfile"))
+        run_resolver("Berkshelf", "berks", tmpdir)
+      elsif File.exists?(File.join(kitchen_root, "Cheffile"))
+        run_resolver("Librarian", "librarian-chef", tmpdir)
+      elsif File.directory?(File.join(kitchen_root, "cookbooks"))
+        cp_cookbooks(tmpdir)
+      else
+        FileUtils.rmtree(tmpdir)
+        fatal("Berksfile, Cheffile or cookbooks/ must exist in #{kitchen_root}")
+        raise UserError, "Cookbooks could not be found"
+      end
+    end
+
+    def run_resolver(name, bin, tmpdir)
+      begin
+        run_command "if ! command -v #{bin} >/dev/null; then exit 1; fi"
+      rescue Kitchen::ShellOut::ShellCommandFailed
+        fatal("#{name} must be installed, add it to your Gemfile.")
+        raise UserError, "#{bin} command not found"
+      end
+
+      Kitchen.mutex.synchronize do
+        run_command "#{bin} install --path #{tmpdir}"
+      end
+    end
+
+    def cp_cookbooks(tmpdir)
+      FileUtils.cp_r(File.join(kitchen_root, "cookbooks", "."), tmpdir)
+      cp_this_cookbook(tmpdir) if File.exists?(File.expand_path('metadata.rb'))
+    end
+
+    def cp_this_cookbook(tmpdir)
+      metadata_rb = File.join(kitchen_root, "metadata.rb")
+      cb_name = MetadataChopper.extract(metadata_rb).first
+      cb_path = File.join(tmpdir, cb_name)
+      glob = Dir.glob("#{kitchen_root}/{metadata.rb,README.*," +
+        "attributes,files,libraries,providers,recipes,resources,templates}")
+
+      FileUtils.mkdir_p(cb_path)
+      FileUtils.cp_r(glob, cb_path)
+    end
+  end
+end

data/lib/kitchen/cli.rb

@@ -0,0 +1,540 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, 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 'benchmark'
+require 'erb'
+require 'ostruct'
+require 'thor'
+
+require 'kitchen'
+
+module Kitchen
+
+  # The command line runner for Kitchen.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class CLI < Thor
+
+    include Thor::Actions
+    include Logging
+
+    # Constructs a new instance.
+    def initialize(*args)
+      super
+      $stdout.sync = true
+      @config = Kitchen::Config.new(
+        :loader     => Kitchen::Loader::YAML.new(ENV['KITCHEN_YAML']),
+        :log_level  => ENV['KITCHEN_LOG'] && ENV['KITCHEN_LOG'].downcase.to_sym,
+        :supervised => false
+      )
+      Kitchen.logger = Kitchen.default_file_logger
+    end
+
+    desc "list [(all|<REGEX>)]", "List all instances"
+    method_option :bare, :aliases => "-b", :type => :boolean,
+      :desc => "List the name of each instance only, one per line"
+    def list(*args)
+      result = parse_subcommand(args.first)
+      if options[:bare]
+        say Array(result).map { |i| i.name }.join("\n")
+      else
+        table = [
+          [set_color("Instance", :green), set_color("Last Action", :green)]
+        ]
+        table += Array(result).map { |i| display_instance(i) }
+        print_table(table)
+      end
+    end
+
+    [:create, :converge, :setup, :verify, :destroy].each do |action|
+      desc(
+        "#{action} [(all|<REGEX>)] [opts]",
+        "#{action.capitalize} one or more instances"
+      )
+      method_option :parallel, :aliases => "-p", :type => :boolean,
+        :desc => "Perform action against all matching instances in parallel"
+      define_method(action) { |*args| exec_action(action) }
+    end
+
+    desc "test [all|<REGEX>)] [opts]", "Test one or more instances"
+    long_desc <<-DESC
+      Test one or more instances
+
+      There are 3 post-verify modes for instance cleanup, triggered with
+      the `--destroy' flag:
+
+      * passing: instances passing verify will be destroyed afterwards.\n
+      * always: instances will always be destroyed afterwards.\n
+      * never: instances will never be destroyed afterwards.
+    DESC
+    method_option :parallel, :aliases => "-p", :type => :boolean,
+      :desc => "Perform action against all matching instances in parallel"
+    method_option :destroy, :aliases => "-d", :default => "passing",
+      :desc => "Destroy strategy to use after testing (passing, always, never)."
+    def test(*args)
+      if ! %w{passing always never}.include?(options[:destroy])
+        raise ArgumentError, "Destroy mode must be passing, always, or never."
+      end
+
+      banner "Starting Kitchen"
+      elapsed = Benchmark.measure do
+        destroy_mode = options[:destroy].to_sym
+        @task = :test
+        results = parse_subcommand(args.first)
+
+        if options[:parallel]
+          run_parallel(results, destroy_mode)
+        else
+          run_serial(results, destroy_mode)
+        end
+      end
+      banner "Kitchen is finished. #{Util.duration(elapsed.real)}"
+    end
+
+    desc "login (['REGEX']|[INSTANCE])", "Log in to one instance"
+    def login(regexp)
+      results = get_filtered_instances(regexp)
+      if results.size > 1
+        die task, "Argument `#{regexp}' returned multiple results:\n" +
+          results.map { |i| "  * #{i.name}" }.join("\n")
+      end
+      instance = results.pop
+
+      instance.login
+    end
+
+    desc "version", "Print Kitchen's version information"
+    def version
+      say "Kitchen version #{Kitchen::VERSION}"
+    end
+    map %w(-v --version) => :version
+
+    desc "console", "Kitchen Console!"
+    def console
+      require 'pry'
+      Pry.start(@config, :prompt => pry_prompts)
+    rescue LoadError => e
+      warn %{Make sure you have the pry gem installed. You can install it with:}
+      warn %{`gem install pry` or including 'gem "pry"' in your Gemfile.}
+      exit 1
+    end
+
+    desc "init", "Adds some configuration to your cookbook so Kitchen can rock"
+    def init
+      InitGenerator.new.init
+    end
+
+    desc "new_plugin [NAME]", "Generate a new Kitchen Driver plugin gem project"
+    method_option :license, :aliases => "-l", :default => "apachev2",
+      :desc => "Type of license for gem (apachev2, mit, gplv3, gplv2, reserved)"
+    def new_plugin(name)
+      g = NewPluginGenerator.new
+      g.options = options
+      g.new_plugin(name)
+    end
+
+    private
+
+    attr_reader :task
+
+    def logger
+      Kitchen.logger
+    end
+
+    def exec_action(action)
+      banner "Starting Kitchen"
+      elapsed = Benchmark.measure do
+        @task = action
+        results = parse_subcommand(args.first)
+        options[:parallel] ? run_parallel(results) : run_serial(results)
+      end
+      banner "Kitchen is finished. #{Util.duration(elapsed.real)}"
+    end
+
+    def run_serial(instances, *args)
+      Array(instances).map { |i| i.public_send(task, *args) }
+    end
+
+    def run_parallel(instances, *args)
+      futures = Array(instances).map { |i| i.future.public_send(task) }
+      futures.map { |i| i.value }
+    end
+
+    def parse_subcommand(arg = nil)
+      arg == "all" ? get_all_instances : get_filtered_instances(arg)
+    end
+
+    def get_all_instances
+      result = @config.instances
+      if result.empty?
+        die task, "No instances defined"
+      else
+        result
+      end
+    end
+
+    def get_filtered_instances(regexp)
+      result = if options[:parallel]
+        @config.instance_actors(/#{regexp}/)
+      else
+        @config.instances.get_all(/#{regexp}/)
+      end
+
+      if result.empty?
+        die task, "No instances for regex `#{regexp}', try running `kitchen list'"
+      else
+        result
+      end
+    end
+
+    def display_instance(instance)
+      action = case instance.last_action
+      when 'create' then set_color("Created", :cyan)
+      when 'converge' then set_color("Converged", :magenta)
+      when 'setup' then set_color("Set Up", :blue)
+      when 'verify' then set_color("Verified", :yellow)
+      when nil then set_color("<Not Created>", :red)
+      else set_color("<Unknown>", :white)
+      end
+      [set_color(instance.name, :white), action]
+    end
+
+    def die(task, msg)
+      error "\n#{msg}\n\n"
+      help(task)
+      exit 1
+    end
+
+    def pry_prompts
+      [
+        proc { |target_self, nest_level, pry|
+          ["[#{pry.input_array.size}] ",
+            "jc(#{Pry.view_clip(target_self.class)})",
+            "#{":#{nest_level}" unless nest_level.zero?}> "
+          ].join
+        },
+        proc { |target_self, nest_level, pry|
+          ["[#{pry.input_array.size}] ",
+            "jc(#{Pry.view_clip(target_self.class)})",
+            "#{":#{nest_level}" unless nest_level.zero?}* "
+          ].join
+        },
+      ]
+    end
+  end
+
+  # A project initialization generator, to help prepare a cookbook project for
+  # testing with Kitchen.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class InitGenerator < Thor
+
+    include Thor::Actions
+
+    desc "init", "Adds some configuration to your cookbook so Kitchen can rock"
+    def init
+      create_file ".kitchen.yml", default_yaml
+
+      rakedoc = <<-RAKE.gsub(/^ {8}/, '')
+
+        begin
+          require 'kitchen/rake_tasks'
+          Kitchen::RakeTasks.new
+        rescue LoadError
+          puts ">>>>> Kitchen gem not loaded, omitting tasks" unless ENV['CI']
+        end
+      RAKE
+      append_to_file("Rakefile", rakedoc) if init_rakefile?
+
+      thordoc = <<-THOR.gsub(/^ {8}/, '')
+
+        begin
+          require 'kitchen/thor_tasks'
+          Kitchen::ThorTasks.new
+        rescue LoadError
+          puts ">>>>> Kitchen gem not loaded, omitting tasks" unless ENV['CI']
+        end
+      THOR
+      append_to_file("Thorfile", thordoc) if init_thorfile?
+
+      empty_directory "test/integration/default" if init_test_dir?
+      append_to_gitignore(".kitchen/")
+      append_to_gitignore(".kitchen.local.yml")
+      add_plugins
+    end
+
+    private
+
+    def default_yaml
+      url_base = "https://opscode-vm.s3.amazonaws.com/vagrant/boxes"
+      platforms = [
+        { :n => 'ubuntu', :vers => %w(12.04 10.04), :rl => "recipe[apt]" },
+        { :n => 'centos', :vers => %w(6.3 5.8), :rl => "recipe[yum::epel]" },
+      ]
+      platforms = platforms.map do |p|
+        p[:vers].map do |v|
+          { 'name' => "#{p[:n]}-#{v}",
+            'driver_config' => {
+              'box' => "opscode-#{p[:n]}-#{v}",
+              'box_url' => "#{url_base}/opscode-#{p[:n]}-#{v}.box"
+            },
+            'run_list' => Array(p[:rl])
+          }
+        end
+      end.flatten
+      cookbook_name = if File.exists?(File.expand_path('metadata.rb'))
+        MetadataChopper.extract('metadata.rb').first
+      else
+        nil
+      end
+      run_list = cookbook_name ? "recipe[#{cookbook_name}]" : nil
+
+      { 'driver_plugin' => 'vagrant',
+        'platforms' => platforms,
+        'suites' => [
+          { 'name' => 'default',
+            'run_list' => Array(run_list),
+            'attributes' => Hash.new
+          },
+        ]
+      }.to_yaml
+    end
+
+    def init_rakefile?
+      File.exists?("Rakefile") &&
+        IO.readlines("Rakefile").grep(%r{require 'kitchen/rake_tasks'}).empty?
+    end
+
+    def init_thorfile?
+      File.exists?("Thorfile") &&
+        IO.readlines("Thorfile").grep(%r{require 'kitchen/thor_tasks'}).empty?
+    end
+
+    def init_test_dir?
+      Dir.glob("test/integration/*").select { |d| File.directory?(d) }.empty?
+    end
+
+    def append_to_gitignore(line)
+      create_file(".gitignore") unless File.exists?(".gitignore")
+
+      if IO.readlines(".gitignore").grep(%r{^#{line}}).empty?
+        append_to_file(".gitignore", "#{line}\n")
+      end
+    end
+
+    def add_plugins
+      prompt_add  = "Add a Driver plugin to your Gemfile? (y/n)>"
+      prompt_name = "Enter gem name, `list', or `skip'>"
+
+      if yes?(prompt_add, :green)
+        list_plugins while (plugin = ask(prompt_name, :green)) == "list"
+        return if plugin == "skip"
+        begin
+          append_to_file(
+            "Gemfile", %{gem '#{plugin}', :group => :integration\n}
+          )
+          say "You must run `bundle install' to fetch any new gems.", :red
+        rescue Errno::ENOENT
+          warn %{You do not have an existing Gemfile}
+          warn %{Exiting...}
+          exit 1
+        end
+      end
+    end
+
+    def list_plugins
+      specs = fetch_gem_specs.map { |t| t.first }.map { |t| t[0, 2] }.
+        sort { |x, y| x[0] <=> y[0] }
+      specs = specs[0, 49].push(["...", "..."]) if specs.size > 49
+      specs = specs.unshift(["Gem Name", "Latest Stable Release"])
+      print_table(specs, :indent => 4)
+    end
+
+    def fetch_gem_specs
+      require 'rubygems/spec_fetcher'
+      req = Gem::Requirement.default
+      dep = Gem::Deprecate.skip_during { Gem::Dependency.new(/kitchen-/i, req) }
+      fetcher = Gem::SpecFetcher.fetcher
+
+      specs = fetcher.find_matching(dep, false, false, false)
+    end
+  end
+
+  # A generator to create a new Kitchen driver plugin.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class NewPluginGenerator < Thor
+
+    include Thor::Actions
+
+    desc "new_plugin [NAME]", "Generate a new Kitchen Driver plugin gem project"
+    method_option :license, :aliases => "-l", :default => "apachev2",
+      :desc => "Type of license for gem (apachev2, mit, gplv3, gplv2, reserved)"
+    def new_plugin(plugin_name)
+      if ! run("command -v bundle", :verbose => false)
+        die "Bundler must be installed and on your PATH: `gem install bundler'"
+      end
+
+      @plugin_name = plugin_name
+      @gem_name = "kitchen-#{plugin_name}"
+      @gemspec = "#{gem_name}.gemspec"
+      @klass_name = Util.to_camel_case(plugin_name)
+      @constant = Util.to_snake_case(plugin_name).upcase
+      @license = options[:license]
+      @author = %x{git config user.name}.chomp
+      @email = %x{git config user.email}.chomp
+      @year = Time.now.year
+
+      create_plugin
+    end
+
+    private
+
+    attr_reader :plugin_name, :gem_name, :gemspec, :klass_name,
+      :constant, :license, :author, :email, :year
+
+    def create_plugin
+      run("bundle gem #{gem_name}") unless File.directory?(gem_name)
+
+      inside(gem_name) do
+        update_gemspec
+        update_gemfile
+        update_rakefile
+        create_src_files
+        cleanup
+        create_license
+        add_git_files
+      end
+    end
+
+    def update_gemspec
+      gsub_file(gemspec, %r{require '#{gem_name}/version'},
+        %{require 'kitchen/driver/#{plugin_name}_version.rb'})
+      gsub_file(gemspec, %r{Kitchen::#{klass_name}::VERSION},
+        %{Kitchen::Driver::#{constant}_VERSION})
+      gsub_file(gemspec, %r{(gem\.executables\s*) =.*$},
+        '\1 = []')
+      gsub_file(gemspec, %r{(gem\.description\s*) =.*$},
+        '\1 = "' + "Kitchen::Driver::#{klass_name} - " +
+          "A Kitchen Driver for #{klass_name}\"")
+      gsub_file(gemspec, %r{(gem\.summary\s*) =.*$},
+        '\1 = gem.description')
+      gsub_file(gemspec, %r{(gem\.homepage\s*) =.*$},
+        '\1 = "https://github.com/opscode/' +
+          "#{gem_name}/\"")
+      insert_into_file(gemspec,
+        "\n  gem.add_dependency 'test-kitchen'\n", :before => "end\n")
+      insert_into_file(gemspec,
+        "\n  gem.add_development_dependency 'cane'\n", :before => "end\n")
+      insert_into_file(gemspec,
+        "  gem.add_development_dependency 'tailor'\n", :before => "end\n")
+    end
+
+    def update_gemfile
+      append_to_file("Gemfile", "\ngroup :test do\n  gem 'rake'\nend\n")
+    end
+
+    def update_rakefile
+      append_to_file("Rakefile", <<-RAKEFILE.gsub(/^ {8}/, ''))
+        require 'cane/rake_task'
+        require 'tailor/rake_task'
+
+        desc "Run cane to check quality metrics"
+        Cane::RakeTask.new
+
+        Tailor::RakeTask.new
+
+        task :default => [ :cane, :tailor ]
+      RAKEFILE
+    end
+
+    def create_src_files
+      license_comments = rendered_license.gsub(/^/, '# ').gsub(/\s+$/, '')
+
+      empty_directory("lib/kitchen/driver")
+      create_template("plugin/version.rb",
+        "lib/kitchen/driver/#{plugin_name}_version.rb",
+        :klass_name => klass_name, :constant => constant,
+        :license => license_comments)
+      create_template("plugin/driver.rb",
+        "lib/kitchen/driver/#{plugin_name}.rb",
+        :klass_name => klass_name, :license => license_comments,
+        :author => author, :email => email)
+    end
+
+    def rendered_license
+      TemplateRenderer.render("plugin/license_#{license}",
+        :author => author, :email => email, :year => year)
+    end
+
+    def create_license
+      dest_file = case license
+      when "mit" then "LICENSE.txt"
+      when "apachev2", "reserved" then "LICENSE"
+      when "gplv2", "gplv3" then "COPYING"
+      else
+        raise ArgumentError, "No such license #{license}"
+      end
+
+      create_file(dest_file, rendered_license)
+    end
+
+    def cleanup
+      %W(LICENSE.txt lib/#{gem_name}/version.rb lib/#{gem_name}.rb).each do |f|
+        run("git rm -f #{f}") if File.exists?(f)
+      end
+      remove_dir("lib/#{gem_name}")
+    end
+
+    def add_git_files
+      run("git add .")
+    end
+
+    def create_template(template, destination, data = {})
+      create_file(destination, TemplateRenderer.render(template, data))
+    end
+
+    # Renders an ERB template with a hash of template variables.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class TemplateRenderer < OpenStruct
+
+      def self.render(template, data = {})
+        renderer = new(template, data)
+        yield renderer if block_given?
+        renderer.render
+      end
+
+      def initialize(template, data = {})
+        super()
+        data[:template] = template
+        data.each { |key, value| send("#{key}=", value) }
+      end
+
+      def render
+        ERB.new(IO.read(template_file)).result(binding)
+      end
+
+      private
+
+      def template_file
+        Kitchen.source_root.join("templates", "#{template}.erb").to_s
+      end
+    end
+  end
+end