cucumber-chef 2.1.0.rc.2 → 2.1.0.rc.3

data/bin/cc-knife

@@ -2,15 +2,14 @@
 require 'cucumber-chef'
 
 # if we have bundler binstubs use that; otherwise attempt to detect
-knife = (Cucumber::Chef.locate(:file, "bin", "knife") rescue nil)
-knife = "/usr/bin/env knife" unless knife
+knife = (Cucumber::Chef.locate(:file, "bin", "knife") rescue "/usr/bin/env knife")
 
 message = "cc-knife v#{Cucumber::Chef::VERSION}"
 puts(message)
 Cucumber::Chef.logger.info { message }
 
 Cucumber::Chef::Config.load
-if (test_lab = Cucumber::Chef::TestLab.new) && (test_lab.labs_running.count > 0)
+if (test_lab = Cucumber::Chef::TestLab.new) && test_lab.alive?
 
   knife_rb = Cucumber::Chef.knife_rb
   if File.exists?(knife_rb)

data/bin/cc-push

@@ -1,22 +1,12 @@
 #!/usr/bin/env ruby
 require 'cucumber-chef'
 
-def run_remote(command)
-  $logger.info { "cc-push(run_remote): '#{command}'" }
-  $test_lab.ssh.exec(command)
-end
-
-def run_local(command)
-  $logger.info { "cc-push(run_local): '#{command}'" }
-  %x(#{command})
-end
-
 tag = Cucumber::Chef.tag("cc-push")
 puts(tag)
 Cucumber::Chef.boot(tag)
 $logger = Cucumber::Chef.logger
 
-if ($test_lab = Cucumber::Chef::TestLab.new) && ($test_lab.labs_running.count > 0)
+if ($test_lab = Cucumber::Chef::TestLab.new) && $test_lab.alive?
   gem_name = "cucumber-chef-#{Cucumber::Chef::VERSION}.gem"
   gem_path = File.join(Cucumber::Chef.root_dir, gem_name)
 
@@ -37,21 +27,23 @@ if ($test_lab = Cucumber::Chef::TestLab.new) && ($test_lab.labs_running.count >
     $test_lab.ssh.upload(local_file, remote_file)
     FileUtils.rm_f(File.join(Cucumber::Chef.root_dir, "*.gem"))
 
-    run_remote(<<-EOH
+    $test_lab.ssh.exec(<<-EOH
 sudo /bin/bash -c '
+pkill -9 cc-server
 cd #{File.dirname(remote_file)}
 ls -la | grep 'cucumber-chef-'
-gem uninstall cucumber-chef --all --ignore-dependencies --executables --backtrace
+gem uninstall cucumber-chef ztk --all --ignore-dependencies --executables --backtrace
 rm -fv /usr/lib/ruby/gems/1.8/cache/#{gem_name}
 gem cleanup cucumber-chef --backtrace
 gem install #{remote_file} --backtrace
-rm -fv /home/#{$test_lab.ssh.config.user}/*.gem'
+rm -fv /home/#{$test_lab.ssh.config.user}/*.gem
+exit 0'
 EOH
     )
     File.exists?(gem_path) && File.delete(gem_path)
   end
 
 else
-  puts("No run_remotening cucumber-chef test labs to connect to!")
+  puts("No running cucumber-chef test labs to connect to!")
   exit(1)
 end

data/bin/cc-server

@@ -18,31 +18,62 @@ require 'drb/acl'
 require 'cucumber-chef'
 require 'cucumber/chef/helpers'
 
+tag = Cucumber::Chef.tag("cc-server")
+puts("  * #{tag}")
+Cucumber::Chef.boot(tag)
+$logger = Cucumber::Chef.logger
+Dir.chdir(File.join("/home", Cucumber::Chef.lab_user))
+
 class FrontObject
-  attr_accessor :servers
+  attr_accessor :containers
 
   include Cucumber::Chef
   include Cucumber::Chef::Helpers
 
+################################################################################
+
   def initialize
-    tag = Cucumber::Chef.tag("cc-server")
-    puts("  * #{tag}")
-    Cucumber::Chef.boot(tag)
-    $logger = Cucumber::Chef.logger
-    Dir.chdir(File.join("/home", Cucumber::Chef.lab_user))
+    logger.info { "DRB=#{DRb.config.inspect}" }
+
+    if ENV['PURGE']
+      Cucumber::Chef.logger.warn { "PURGING CONTAINERS!  Container attributes will be reset!" }
+      load_containers
+      containers.each do |name, value|
+        server_destroy(name)
+      end
+
+      File.exists?(Cucumber::Chef.containers_bin) && File.delete(Cucumber::Chef.containers_bin)
+      load_containers
+    else
+      Cucumber::Chef.logger.info { "Allowing existing containers to persist." }
+    end
   end
 
+################################################################################
+
   def shutdown
+    logger.fatal { "Shutting down." }
     DRb.stop_service
+    exit(0)
   end
 
+################################################################################
+
   def logger
     $logger
   end
 
+################################################################################
+
+  def ping
+    "pong"
+  end
+
+################################################################################
+
 end
 
-list = %w( deny all )
+list = %w(deny all)
 ARGV[0] and (list += [ 'allow', ARGV[0] ])
 acl = ACL.new(list)
 

data/bin/cucumber-chef

@@ -132,7 +132,6 @@ class CucumberChef < Thor
   def setup
     boot
 
-    puts
     if (test_lab = Cucumber::Chef::TestLab.new)
       if (provider = test_lab.create)
         if (provisioner = Cucumber::Chef::Provisioner.new(test_lab))
@@ -140,16 +139,11 @@ class CucumberChef < Thor
           provisioner.build
 
           puts
-          puts("Your cucumber-chef test lab has now been provisioned!")
+          puts("If you are using AWS, be sure to log into the chef-server webui and change the default admin password at least.")
           puts
-          puts("Be sure to log into the chef-server webui and change the default credentials.")
+          puts("Your test lab has now been provisioned!  Enjoy!")
           puts
-          puts("  Chef-Server WebUI:")
-          puts("    http://#{test_lab.ip}:4040/")
-          puts("  Username:")
-          puts("    admin")
-          puts("  Password:")
-          puts("    #{Cucumber::Chef::Provisioner::PASSWORD}")
+          test_lab.status
 
         else
           puts(set_color("Could not create the provisioner!", :red, true))
@@ -168,64 +162,70 @@ class CucumberChef < Thor
   end
 
 ################################################################################
-# TEARDOWN
+# DESTROY
 ################################################################################
 
-  desc "teardown [container]", "Teardown the cucumber-chef test lab in Amazon EC2 or a test lab [container] if specified."
+  desc "destroy [container]", "Destroy the cucumber-chef test lab in Amazon EC2 or a test lab [container] if specified."
   method_option :test, :type => :boolean, :desc => "INTERNAL USE ONLY"
-  def teardown(*args)
+  def destroy(*args)
     boot
 
-    puts
-    if (test_lab = Cucumber::Chef::TestLab.new)
+    if (test_lab = Cucumber::Chef::TestLab.new) && test_lab.exists?
       if args.count == 0
-        if yes?(set_color("Are you sure you want to teardown your cucumber-chef test lab?", :red, true))
-          count_down_colors = { 5 => :green, 4 => :yellow, 3 => :yellow, 2 => :red, 1 => :red }
+        test_lab.status
+
+        if yes?(set_color("Are you sure you want to destroy the test lab?", :red, true))
           puts
-          puts(set_color("You have 5 seconds to abort!", :green, true))
+          puts(set_color("You have 5 seconds to abort!", :red, true))
           puts
-          print(set_color("Self-destructing in", :green, true))
           5.downto(1) do |x|
-            print(set_color("...#{x}", count_down_colors[x], true))
+            print("#{x}...")
             sleep(1)
           end
-          puts(set_color("...BOOM!", :red, true))
+          puts("BOOM!")
           puts
-          test_lab.destroy
+
+          ZTK::Benchmark.bench(:message => "Destroy #{Cucumber::Chef::Config.provider.upcase} instance '#{test_lab.id}'", :mark => "completed in %0.4f seconds.") do
+            test_lab.destroy
+          end
         else
           puts
           puts(set_color("Whew! That was close!", :green, true))
         end
       else
-        container = args[0]
-        if yes?(set_color("Are you sure you want to teardown the test lab containter '#{container}'?", :red, true))
-          count_down_colors = { 5 => :green, 4 => :yellow, 3 => :yellow, 2 => :red, 1 => :red }
+        if yes?(set_color("Are you sure you want to destroy the container#{args.count > 1 ? 's' : nil} #{args.collect{|a| "'#{a}'"}.join(', ')}?", :red, true))
           puts
-          puts(set_color("You have 5 seconds to abort!", :green, true))
+          puts(set_color("You have 5 seconds to abort!", :red, true))
           puts
-          print(set_color("Self-destructing in", :green, true))
           5.downto(1) do |x|
-            print(set_color("...#{x}", count_down_colors[x], true))
+            print("#{x}...")
             sleep(1)
           end
-          puts(set_color("...BOOM!", :red, true))
+          puts("BOOM!")
           puts
 
-          test_lab.ssh.exec("nohup sudo pkill -9 -f cc-server")
-          test_lab.ssh.exec("nohup sudo BACKGROUND=yes cc-server #{Cucumber::Chef.external_ip}")
-          Cucumber::Chef.spinner do
-            ZTK::TCPSocketCheck.new(:host => test_lab.ip, :port => 8787, :data => "\n\n").wait
+          ZTK::Benchmark.bench(:message => "Start cc-server", :mark => "completed in %0.4f seconds.") do
+            cc_server = Cucumber::Chef::Server.new(test_lab)
+            cc_server.up(:silence => true)
+          end
+
+          args.each do |container|
+            ZTK::Benchmark.bench(:message => "Destroy container '#{container}'", :mark => "completed in %0.4f seconds.") do
+              test_lab.drb.load_containers
+              test_lab.drb.server_destroy(container)
+              test_lab.drb.server_delete(container)
+              test_lab.drb.save_containers
+            end
           end
-          test_lab.drb.servers = Hash.new(nil)
-          test_lab.drb.server_destroy(container)
         else
           puts
           puts(set_color("Whew! That was close!", :green, true))
         end
+
       end
 
     else
-      puts(set_color("Could not find a cucumber-chef test lab to teardown!", :red, true))
+      raise Cucumber::Chef::Error, "We could not find a running test lab."
     end
     puts
 
@@ -242,11 +242,12 @@ class CucumberChef < Thor
   def up
     boot
 
-    puts
-    if (test_lab = Cucumber::Chef::TestLab.new)
-      test_lab.up
+    if (test_lab = Cucumber::Chef::TestLab.new) && test_lab.dead?
+      ZTK::Benchmark.bench(:message => "Booting #{Cucumber::Chef::Config.provider.upcase} instance '#{test_lab.id}'", :mark => "completed in %0.4f seconds.") do
+        test_lab.up
+      end
     else
-      puts(set_color("Could not find a cucumber-chef test lab to startup!", :red, true))
+      raise Cucumber::Chef::Error, "We could not find a powered off test lab."
     end
     puts
 
@@ -256,18 +257,41 @@ class CucumberChef < Thor
   end
 
 ################################################################################
-# DOWN
+# HALT
 ################################################################################
 
-  desc "down", "Shutdown the cucumber-chef test lab"
-  def down
+  desc "halt", "Power off the cucumber-chef test lab"
+  def halt
     boot
 
+    if (test_lab = Cucumber::Chef::TestLab.new) && test_lab.alive?
+      ZTK::Benchmark.bench(:message => "Halting #{Cucumber::Chef::Config.provider.upcase} instance '#{test_lab.id}'", :mark => "completed in %0.4f seconds.") do
+        test_lab.halt
+      end
+    else
+      raise Cucumber::Chef::Error, "We could not find a running test lab."
+    end
     puts
-    if (test_lab = Cucumber::Chef::TestLab.new)
-      test_lab.down
+
+  rescue Cucumber::Chef::Error => e
+    $logger.fatal { e.backtrace.join("\n") }
+    fatal(e)
+  end
+
+################################################################################
+# RELOAD
+################################################################################
+
+  desc "reload", "Reload the cucumber-chef test lab"
+  def reload
+    boot
+
+    if (test_lab = Cucumber::Chef::TestLab.new) && test_lab.alive?
+      ZTK::Benchmark.bench(:message => "Reloading #{Cucumber::Chef::Config.provider.upcase} instance '#{test_lab.id}'", :mark => "completed in %0.4f seconds.") do
+        test_lab.reload
+      end
     else
-      puts(set_color("Could not find a cucumber-chef test lab to shutdown!", :red, true))
+      raise Cucumber::Chef::Error, "We could not find a running test lab."
     end
     puts
 
@@ -281,13 +305,60 @@ class CucumberChef < Thor
 ################################################################################
 
   desc "status", "Displays the current status of the test lab."
+  method_option :containers, :type => :boolean, :desc => "Display container status.", :default => false
+  method_option :attributes, :type => :boolean, :desc => "Display chef-client attributes for containers.", :default => false
   method_option :test, :type => :boolean, :desc => "INTERNAL USE ONLY"
   def status
     boot
 
-    puts
     if (test_lab = Cucumber::Chef::TestLab.new)
-      test_lab.status
+      if @options.containers?
+        if test_lab.alive?
+          ZTK::Benchmark.bench(:message => "Start cc-server", :mark => "completed in %0.4f seconds.") do
+            test_lab.cc_server.up(:silence => true)
+          end
+
+          test_lab.drb.load_containers
+
+          headers = [:name, :alive, :arch, :distro, :ip, :mac, :"chef version", :persist]
+          results = ZTK::Report.new.spreadsheet(test_lab.drb.containers, headers) do |name, detail|
+            chef_version = "N/A"
+            alive = (test_lab.drb.command_run_local(%Q{ping -n -c 1 -W 1 #{detail[:ip]}}, :ignore_exit_status => true).exit_code == 0)
+            if alive
+              chef_version = test_lab.drb.command_run_chroot(name, %Q{/usr/bin/env chef-client -v}, :ignore_exit_status => true).output.chomp
+            end
+
+            OpenStruct.new(
+              :name => name,
+              :ip => detail[:ip],
+              :mac => detail[:mac],
+              :distro => detail[:distro],
+              :arch => detail[:arch],
+              :alive => alive,
+              :"chef version" => chef_version,
+              :persist => detail[:persist],
+              :chef_attributes => detail[:chef_client]
+            )
+          end
+
+          if @options.attributes?
+            results.rows.each do |result|
+              puts
+              puts("-" * results.width)
+              puts("Chef-Client attributes for '#{result.name.to_s.downcase}':")
+              puts("-" * results.width)
+              puts(JSON.pretty_generate(result.chef_attributes))
+            end
+          end
+
+          test_lab.cc_server.down
+        else
+          raise Cucumber::Chef::Error, "We could not find a running test lab."
+        end
+
+      else
+        test_lab.status
+      end
     end
     puts
 
@@ -301,23 +372,48 @@ class CucumberChef < Thor
 ################################################################################
 
   desc "ssh [container]", "SSH to cucumber-chef test lab or [container] if specified."
-  method_option :test, :type => :boolean, :desc => "INTERNAL USE ONLY"
+  method_option :bootstrap, :type => :boolean, :desc => "Use the bootstrap settings.", :default => false
   def ssh(*args)
     boot
 
-    puts
-    if (test_lab = Cucumber::Chef::TestLab.new) && (test_lab.labs_running.count > 0)
-      if args.size == 0
-        puts([set_color("Attempting SSH connection to cucumber-chef '", :blue, true), set_color("test lab", :cyan, true), set_color("'...", :blue, true)].join)
+    if (test_lab = Cucumber::Chef::TestLab.new) && test_lab.alive?
+      if @options.bootstrap?
+        puts([set_color("Attempting bootstrap SSH connection to cucumber-chef '", :blue, true), set_color("test lab", :cyan, true), set_color("'...", :blue, true)].join)
+        test_lab.bootstrap_ssh.console
+      elsif args.size == 0
+        puts([set_color("Attempting SSH connection to the '", :blue, true), set_color("test lab", :cyan, true), set_color("'...", :blue, true)].join)
         test_lab.ssh.console
-      else
+      elsif args.size > 0
         container = args[0]
-        puts([set_color("Attempting SSH connection to cucumber-chef container '", :blue, true), set_color(container, :cyan, true), set_color("'...", :blue, true)].join)
+        puts([set_color("Attempting proxy SSH connection to the container '", :blue, true), set_color(container, :cyan, true), set_color("'...", :blue, true)].join)
         test_lab.proxy_ssh(container).console
+      else
+        raise Cucumber::Chef::Error, "You did not specify a valid combination of options."
       end
+    else
+      raise Cucumber::Chef::Error, "We could not find a running test lab."
+    end
+    puts
+
+  rescue Cucumber::Chef::Error => e
+    $logger.fatal { e.backtrace.join("\n") }
+    fatal(e)
+  end
 
+################################################################################
+# PS
+################################################################################
+
+  desc "ps [ps-options]", "Snapshot of the current cucumber-chef test lab container processes."
+  def ps(*args)
+    boot
+
+    if (test_lab = Cucumber::Chef::TestLab.new) && test_lab.alive?
+      puts("-" * 80)
+      test_lab.ssh.exec("lxc-ps --lxc -- #{args.join(" ")}")
+      puts("-" * 80)
     else
-      puts(set_color("No cucumber-chef test labs available to ssh to!", :red, true))
+      raise Cucumber::Chef::Error, "We could not find a running test lab."
     end
     puts
 
@@ -334,13 +430,9 @@ class CucumberChef < Thor
   def log
     boot
 
-    if ($test_lab = Cucumber::Chef::TestLab.new) && ($test_lab.labs_running.count > 0)
+    if ($test_lab = Cucumber::Chef::TestLab.new) && $test_lab.exists? && $test_lab.alive?
       $tail_thread_remote = Thread.new do
         $test_lab.ssh.exec("tail -n 0 -f /home/#{$test_lab.ssh.config.user}/.cucumber-chef/cucumber-chef.log")
-
-        Kernel.at_exit do
-          $test_lab.ssh.close
-        end
       end
 
       log_file = File.open(Cucumber::Chef.log_file, "r")
@@ -354,11 +446,13 @@ class CucumberChef < Thor
       end
 
       $tail_thread_remote.join
+    else
+      raise Cucumber::Chef::Error, "We could not find a running test lab."
     end
 
-    Kernel.at_exit do
-      $tail_thread_remote.kill
-    end
+  rescue Cucumber::Chef::Error => e
+    $logger.fatal { e.backtrace.join("\n") }
+    fatal(e)
   end
 
 ################################################################################
@@ -372,8 +466,7 @@ class CucumberChef < Thor
   def diagnose(container)
     boot
 
-    puts
-    if (test_lab = Cucumber::Chef::TestLab.new) && (test_lab.labs_running.count > 0)
+    if (test_lab = Cucumber::Chef::TestLab.new) && test_lab.alive?
       puts([set_color("Attempting to collect diagnostic information on cucumber-chef container '", :blue, true), set_color(container, :cyan, true), set_color("'...", :blue, true)].join)
       if @options.strace?
         puts
@@ -388,6 +481,8 @@ class CucumberChef < Thor
         puts(set_color("============================================================================", :bold))
         test_lab.proxy_ssh(container).exec("[[ -e /var/log/chef/client.log ]] && tail -n #{@options.lines} /var/log/chef/client.log")
       end
+    else
+      raise Cucumber::Chef::Error, "We could not find a running test lab."
     end
     puts
 
@@ -410,7 +505,7 @@ class CucumberChef < Thor
       "home_dir" => Cucumber::Chef.home_dir,
       "log_file" => Cucumber::Chef.log_file,
       "config_rb" => Cucumber::Chef.config_rb,
-      "servers_bin" => Cucumber::Chef.servers_bin,
+      "containers_bin" => Cucumber::Chef.containers_bin,
       "knife_rb" => Cucumber::Chef.knife_rb,
       "chef_repo" => Cucumber::Chef.chef_repo,
       "bootstrap_identity" => Cucumber::Chef.bootstrap_identity,
@@ -421,16 +516,15 @@ class CucumberChef < Thor
       "lxc_user_home_dir" => Cucumber::Chef.lxc_user_home_dir,
       "lxc_identity" => Cucumber::Chef.lxc_identity
     }
+    max_key_length = details.collect{ |k,v| k.to_s.length }.max
 
-    puts
-
+    puts("-" * 80)
     say(Cucumber::Chef::Config.configuration.to_yaml, :bold)
-
-    max_key_length = details.collect{ |k,v| k.to_s.length }.max
+    puts("-" * 80)
     details.each do |key,value|
       puts("%#{max_key_length}s = %s" % [key.downcase, value.inspect])
     end
-
+    puts("-" * 80)
     puts
 
   rescue Cucumber::Chef::Error => e
@@ -438,29 +532,6 @@ class CucumberChef < Thor
     fatal(e.message)
   end
 
-################################################################################
-# PS
-################################################################################
-
-  desc "ps [ps-options]", "Snapshot of the current cucumber-chef test lab container processes."
-  def ps(*args)
-    boot
-
-    puts
-    if (test_lab = Cucumber::Chef::TestLab.new) && (test_lab.labs_running.count > 0)
-      puts(set_color("Getting container processes from cucumber-chef test lab...", :blue, true))
-      puts
-      puts(set_color("============================================================================", :bold))
-      test_lab.ssh.exec("lxc-ps --lxc -- #{args.join(" ")}")
-      print("\n")
-    end
-    puts
-
-  rescue Cucumber::Chef::Error => e
-    $logger.fatal { e.backtrace.join("\n") }
-    fatal(e)
-  end
-
 ################################################################################
 # CREATE
 ################################################################################
@@ -485,34 +556,23 @@ class CucumberChef < Thor
   end
 
 ################################################################################
-# DEPRECIATED: INFO
-################################################################################
-
-  desc "info", "DEPRECIATED! - You should execute the 'status' task instead."
-  def info
-    puts
-    puts(set_color("The 'info' task is DEPRECIATED!  You should execute the 'status' task instead.", :red, true))
-    puts
-    status
-
-  rescue Cucumber::Chef::Error => e
-    $logger.fatal { e.backtrace.join("\n") }
-    fatal(e)
-  end
-
-################################################################################
-# DEPRECIATED: TEST
+# DEPRECIATED TASKS
 ################################################################################
 
-  desc "test", "DEPRECIATED! - You should execute 'cucumber' or 'rspec' directly."
-  def test
-    puts
-    puts(set_color("The test task is DEPRECIATED!  You should execute 'cucumber' or 'rspec' directly.", :red, true))
-    puts
+  depreciated_tasks = {
+    "teardown" => "You should execute the 'destroy' task instead.",
+    "info" => "You should execute the 'status' task instead.",
+    "test" => "You should execute 'cucumber' or 'rspec' directly.",
+    "down" => "You should execute the 'halt' task instead."
+  }
 
-  rescue Cucumber::Chef::Error => e
-    $logger.fatal { e.backtrace.join("\n") }
-    fatal(e)
+  depreciated_tasks.each do |old_task, message|
+    desc old_task, "*DEPRECIATED* - #{message}"
+    define_method(old_task) do
+      puts
+      puts(set_color("The '#{old_task}' task is *DEPRECIATED* - #{message}", :red, true))
+      puts
+    end
   end
 
 ################################################################################