cucumber-chef 2.0.7 → 2.1.0.rc.0

data/lib/cucumber/chef/helpers/server.rb

@@ -2,7 +2,7 @@
 #
 #      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
 #      Author: Zachary Patten <zachary@jovelabs.com>
-#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#   Copyright: Copyright (c) 2011-2013 Atalanta Systems Ltd
 #     License: Apache License, Version 2.0
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
@@ -23,20 +23,14 @@ module Cucumber::Chef::Helpers::Server
 
 ################################################################################
 
-  def detect_arch(distro)
-    case distro.downcase
-    when "ubuntu" then
-      ((RUBY_PLATFORM =~ /x86_64/) ? "amd64" : "i386")
-    when "fedora" then
-      ((RUBY_PLATFORM =~ /x86_64/) ? "amd64" : "i686")
-    end
-  end
-
   def server_create(name, attributes={})
     if ((attributes[:persist] && @servers[name]) || (@servers[name] && @servers[name][:persist]))
       attributes = @servers[name]
+      log("using existing attributes for container $#{name} #{server_tag(name)}$")
     else
-      server_destroy(name) if (container_exists?(name) && (ENV['DESTROY'] == "1"))
+      if (container_exists?(name) && (ENV['DESTROY'] == "1"))
+        server_destroy(name)
+      end
       attributes = { :ip => generate_ip,
                      :mac => generate_mac,
                      :persist => true,
@@ -47,18 +41,26 @@ module Cucumber::Chef::Helpers::Server
     @servers = (@servers || Hash.new(nil)).merge(name => attributes)
     $current_server = @servers[name][:ip]
     if !server_running?(name)
-      log(name, "is being provisioned") if @servers[name]
+      log("please wait, creating container $#{name} #{server_tag(name)}$")
+      bm = ::Benchmark.realtime do
+        test_lab_config_dhcpd
+        container_config_network(name)
+        container_create(name, @servers[name][:distro], @servers[name][:release], @servers[name][:arch])
+      end
+      log("container $#{name}$ creation took %0.4f seconds" % bm)
 
-      test_lab_config_dhcpd
-      container_config_network(name)
-      container_create(name, @servers[name][:distro], @servers[name][:release], @servers[name][:arch])
-      ZTK::TCPSocketCheck.new(:host => @servers[name][:ip], :port => 22).wait
+      bm = ::Benchmark.realtime do
+        ZTK::TCPSocketCheck.new(:host => @servers[name][:ip], :port => 22).wait
+      end
+      log("container $#{name}$ SSHD responded after %0.4f seconds" % bm)
+    else
+      log("container $#{name}$ is already running")
     end
   end
 
-  def server_destroy(name)
-    log(name, "is being destroyed") if @servers[name]
+################################################################################
 
+  def server_destroy(name)
     container_destroy(name)
   end
 
@@ -74,6 +76,23 @@ module Cucumber::Chef::Helpers::Server
     containers
   end
 
+################################################################################
+
+  def server_tag(name)
+    @servers[name].inspect.to_s
+  end
+
+################################################################################
+
+  def detect_arch(distro)
+    case distro.downcase
+    when "ubuntu" then
+      ((RUBY_PLATFORM =~ /x86_64/) ? "amd64" : "i386")
+    when "fedora" then
+      ((RUBY_PLATFORM =~ /x86_64/) ? "amd64" : "i686")
+    end
+  end
+
 ################################################################################
 
 end

data/lib/cucumber/chef/helpers/test_lab.rb

@@ -2,7 +2,7 @@
 #
 #      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
 #      Author: Zachary Patten <zachary@jovelabs.com>
-#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#   Copyright: Copyright (c) 2011-2013 Atalanta Systems Ltd
 #     License: Apache License, Version 2.0
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");

data/lib/cucumber/chef/helpers/utility.rb

@@ -2,7 +2,7 @@
 #
 #      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
 #      Author: Zachary Patten <zachary@jovelabs.com>
-#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#   Copyright: Copyright (c) 2011-2013 Atalanta Systems Ltd
 #     License: Apache License, Version 2.0
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
@@ -23,9 +23,29 @@ module Cucumber::Chef::Helpers::Utility
 
 ################################################################################
 
-  def log(name, message)
-    STDOUT.puts("\033[34m  >>> \033[1m#{name}\033[0m\033[34m #{message}\033[0m")
+  def log(message)
+    Cucumber::Chef.logger.info { message.gsub("$", "'") }
+    return if !(ENV['VERBOSE'] == "1")
+
+    pattern = [ "\033[0m\033[36m", "\033[1m" ]
+
+    result = [ " \033[0m\033[34m[\033[1mCC\033[0m\033[34m] \033[36m" ]
+    result << pattern.first
+
+    sanity = message.split('').count{ |z| (z == "$") }
+    raise "You have a log message with an odd number of highlight markup characters! '#{message}' -> (sanity=#{sanity.inspect}) " if (sanity.modulo(2) != 0)
+
+    chunks = message.split("$")
+    chunks.each_with_index do |chunk, index|
+      result << pattern[index.modulo(pattern.length)]
+      result << chunk
+    end
+    result << "\033[0m"
+
+    STDOUT.puts(result.join)
     STDOUT.flush if STDOUT.respond_to?(:flush)
+
+    true
   end
 
 ################################################################################

data/lib/cucumber/chef/helpers.rb

@@ -2,7 +2,7 @@
 #
 #      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
 #      Author: Zachary Patten <zachary@jovelabs.com>
-#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#   Copyright: Copyright (c) 2011-2013 Atalanta Systems Ltd
 #     License: Apache License, Version 2.0
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,6 +26,8 @@ module Cucumber
     # definitions.
     module Helpers
 
+      require 'benchmark'
+
       require 'cucumber/chef/helpers/chef_client'
       require 'cucumber/chef/helpers/chef_server'
       require 'cucumber/chef/helpers/command'
@@ -35,13 +37,13 @@ module Cucumber
       require 'cucumber/chef/helpers/utility'
 
       def self.included(base)
-        base.send(:include, Cucumber::Chef::Helpers::ChefClient)
-        base.send(:include, Cucumber::Chef::Helpers::ChefServer)
-        base.send(:include, Cucumber::Chef::Helpers::Command)
-        base.send(:include, Cucumber::Chef::Helpers::Container)
-        base.send(:include, Cucumber::Chef::Helpers::Server)
-        base.send(:include, Cucumber::Chef::Helpers::TestLab)
-        base.send(:include, Cucumber::Chef::Helpers::Utility)
+        base.send(:include, ::Cucumber::Chef::Helpers::ChefClient)
+        base.send(:include, ::Cucumber::Chef::Helpers::ChefServer)
+        base.send(:include, ::Cucumber::Chef::Helpers::Command)
+        base.send(:include, ::Cucumber::Chef::Helpers::Container)
+        base.send(:include, ::Cucumber::Chef::Helpers::Server)
+        base.send(:include, ::Cucumber::Chef::Helpers::TestLab)
+        base.send(:include, ::Cucumber::Chef::Helpers::Utility)
       end
 
     end

data/lib/cucumber/chef/provisioner.rb

@@ -2,7 +2,7 @@
 #
 #      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
 #      Author: Zachary Patten <zachary@jovelabs.com>
-#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#   Copyright: Copyright (c) 2011-2013 Atalanta Systems Ltd
 #     License: Apache License, Version 2.0
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
@@ -39,7 +39,7 @@ module Cucumber
 
         @ssh = ZTK::SSH.new(:stdout => @stdout, :stderr => @stderr, :stdin => @stdin)
         @ssh.config.host_name = @server.public_ip_address
-        @ssh.config.user = "ubuntu"
+        @ssh.config.user = Cucumber::Chef::Config[:lab_user]
         @ssh.config.keys = Cucumber::Chef::Config[:aws][:identity_file]
 
         # @command = Cucumber::Chef::Command.new(@stdout, @stderr, @stdin)
@@ -91,7 +91,7 @@ module Cucumber
 
           bootstrap = Cucumber::Chef::Bootstrap.new(@stdout, @stderr, @stdin)
           bootstrap.config[:host] = @server.public_ip_address
-          bootstrap.config[:ssh_user] = "ubuntu"
+          bootstrap.config[:ssh_user] = Cucumber::Chef::Config[:lab_user]
           bootstrap.config[:use_sudo] = true
           bootstrap.config[:identity_file] = Cucumber::Chef::Config[:aws][:identity_file]
           bootstrap.config[:template_file] = template_file
@@ -130,9 +130,10 @@ module Cucumber
           local_path = Cucumber::Chef.locate(:directory, ".cucumber-chef")
           remote_path = File.join("/", "home", @ssh.config.user, ".ssh")
 
-          files = { "id_rsa" => "id_rsa-ubuntu" }
+          files = { "id_rsa" => "id_rsa-#{Cucumber::Chef::Config[:lab_user]}" }
           files.each do |remote_file, local_file|
             local = File.join(local_path, local_file)
+            File.exists?(local) and File.delete(local)
             @ssh.download(File.join(remote_path, remote_file), local)
             File.chmod(0600, local)
           end
@@ -164,32 +165,32 @@ module Cucumber
 ################################################################################
 
       def upload_cookbook
-        $logger.debug { "Uploading cucumber-chef cookbooks..." }
+        Cucumber::Chef.logger.debug { "Uploading cucumber-chef cookbooks..." }
         @stdout.print("Uploading cucumber-chef cookbooks...")
 
         Cucumber::Chef.spinner do
-          Cucumber::Chef.load_knife_config
+          Cucumber::Chef.load_knife
           cookbook_repo = ::Chef::CookbookLoader.new(@cookbooks_path)
           cookbook_repo.each do |name, cookbook|
-            $logger.debug { "::Chef::CookbookUploader(#{name}) ATTEMPT" }
+            Cucumber::Chef.logger.debug { "::Chef::CookbookUploader(#{name}) ATTEMPT" }
             ::Chef::CookbookUploader.new(cookbook, @cookbooks_path, :force => true).upload_cookbooks
-            $logger.debug { "::Chef::CookbookUploader(#{name}) UPLOADED" }
+            Cucumber::Chef.logger.debug { "::Chef::CookbookUploader(#{name}) UPLOADED" }
           end
           #@command.knife([ "cookbook upload cucumber-chef", "-o", @cookbooks_path ], :silence => true)
         end
 
         @stdout.print("done.\n")
-        $logger.debug { "Successfully uploaded cucumber-chef test lab cookbooks." }
+        Cucumber::Chef.logger.debug { "Successfully uploaded cucumber-chef test lab cookbooks." }
       end
 
 ################################################################################
 
       def upload_role
-        $logger.debug { "Uploading cucumber-chef test lab role..." }
+        Cucumber::Chef.logger.debug { "Uploading cucumber-chef test lab role..." }
         @stdout.print("Uploading cucumber-chef test lab role...")
 
         Cucumber::Chef.spinner do
-          Cucumber::Chef.load_knife_config
+          Cucumber::Chef.load_knife
           ::Chef::Config[:role_path] = @roles_path
           [ "test_lab" ].each do |name|
             role = ::Chef::Role.from_disk(name)
@@ -199,17 +200,17 @@ module Cucumber
         end
 
         @stdout.print("done.\n")
-        $logger.debug { "Successfully uploaded cucumber-chef test lab roles."}
+        Cucumber::Chef.logger.debug { "Successfully uploaded cucumber-chef test lab roles."}
       end
 
 ################################################################################
 
       def tag_node
-        $logger.debug { "Tagging cucumber-chef test lab node..." }
+        Cucumber::Chef.logger.debug { "Tagging cucumber-chef test lab node..." }
         @stdout.print("Tagging cucumber-chef test lab node...")
 
         Cucumber::Chef.spinner do
-          Cucumber::Chef.load_knife_config
+          Cucumber::Chef.load_knife
           node = ::Chef::Node.load(HOSTNAME)
           [ Cucumber::Chef::Config[:mode].to_s, Cucumber::Chef::Config[:user].to_s ].each do |tag|
             node.tags << tag
@@ -219,17 +220,17 @@ module Cucumber
         end
 
         @stdout.print("done.\n")
-        $logger.debug { "Successfully tagged cucumber-chef test lab node."}
+        Cucumber::Chef.logger.debug { "Successfully tagged cucumber-chef test lab node."}
       end
 
 ################################################################################
 
       def add_node_role
-        $logger.debug { "Setting up cucumber-chef test lab run list..." }
+        Cucumber::Chef.logger.debug { "Setting up cucumber-chef test lab run list..." }
         @stdout.print("Setting up cucumber-chef test lab run list...")
 
         Cucumber::Chef.spinner do
-          Cucumber::Chef.load_knife_config
+          Cucumber::Chef.load_knife
           node = ::Chef::Node.load(HOSTNAME)
           [ "role[test_lab]" ].each do |entry|
             node.run_list << entry
@@ -238,7 +239,7 @@ module Cucumber
           #@command.knife([ "node run_list add", HOSTNAME, "\"role[test_lab]\"" ], :silence => true)
         end
 
-        $logger.debug { "Successfully added roles to cucumber-chef test lab."}
+        Cucumber::Chef.logger.debug { "Successfully added roles to cucumber-chef test lab."}
         @stdout.print("done.\n")
       end
 
@@ -259,13 +260,13 @@ module Cucumber
       def wait_for_chef_server
         @stdout.print("Waiting for Chef-Server...")
         Cucumber::Chef.spinner do
-          ZTK::TCPSocketCheck.new(:host => @server.public_ip_address, :port => 4000, :data => "GET").wait
+          ZTK::TCPSocketCheck.new(:host => @server.public_ip_address, :port => 4000, :data => "GET", :wait => 120).wait
         end
         @stdout.puts("done.\n")
 
         @stdout.print("Waiting for Chef-WebUI...")
         Cucumber::Chef.spinner do
-          ZTK::TCPSocketCheck.new(:host => @server.public_ip_address, :port => 4040, :data => "GET").wait
+          ZTK::TCPSocketCheck.new(:host => @server.public_ip_address, :port => 4040, :data => "GET", :wait => 120).wait
         end
         @stdout.puts("done.\n")
       end
@@ -283,7 +284,7 @@ module Cucumber
 
         @stdout.print("Waiting for SSHD...")
         Cucumber::Chef.spinner do
-          ZTK::TCPSocketCheck.new(:host => @server.public_ip_address, :port => 22).wait
+          ZTK::TCPSocketCheck.new(:host => @server.public_ip_address, :port => 22, :wait => 120).wait
         end
         @stdout.puts("done.\n")
 

data/lib/cucumber/chef/steps/chef_steps.rb

@@ -2,7 +2,7 @@
 #
 #      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
 #      Author: Zachary Patten <zachary@jovelabs.com>
-#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#   Copyright: Copyright (c) 2011-2013 Atalanta Systems Ltd
 #     License: Apache License, Version 2.0
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");

data/lib/cucumber/chef/steps/minitest_steps.rb

@@ -2,7 +2,7 @@
 #
 #      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
 #      Author: Zachary Patten <zachary@jovelabs.com>
-#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#   Copyright: Copyright (c) 2011-2013 Atalanta Systems Ltd
 #     License: Apache License, Version 2.0
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,10 +20,10 @@
 ################################################################################
 
 When /^I enable the running of MiniTest suites for "(.*?)"$/ do |name|
-  $drb_test_lab.enable_minitest(name)
+  $test_lab.drb.enable_minitest(name)
 end
 
 Then /^the tests should run and pass on "(.*?)"$/ do |name|
-  results = $drb_test_lab.run_minitests(name)
+  results = $test_lab.drb.run_minitests(name)
   results.last.scan(/assertions.*(\d).*failures.*(\d).*errors.*(\d).*skips/).flatten.map { |v| v.to_i }.should == [0,0,0]
 end

data/lib/cucumber/chef/steps/provision_steps.rb

@@ -2,7 +2,7 @@
 #
 #      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
 #      Author: Zachary Patten <zachary@jovelabs.com>
-#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#   Copyright: Copyright (c) 2011-2013 Atalanta Systems Ltd
 #     License: Apache License, Version 2.0
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
@@ -44,21 +44,22 @@ And /^"([^\"]*)" has a MAC address of "([^\"]*)"$/ do |name, mac|
 end
 
 And /^"([^\"]*)" has been provisioned$/ do |name|
-  $drb_test_lab.server_create(name, @servers[name])
+  $test_lab.drb.server_create(name, @servers[name])
 end
 
 And /^the "([^\"]*)" role has been added to the "([^\"]*)" run list$/ do |role, name|
-  $drb_test_lab.chef_set_client_attributes(@servers[name], :run_list => ["role[#{role}]"])
+  $test_lab.drb.chef_set_client_attributes(name, :run_list => ["role[#{role}]"])
 end
 
 And /^the "([^\"]*)" recipe has been added to the "([^\"]*)" run list$/ do |recipe, name|
-  $drb_test_lab.chef_set_client_attributes(@servers[name], :run_list => ["recipe[#{recipe}]"])
+  $test_lab.drb.chef_set_client_attributes(name, :run_list => ["recipe[#{recipe}]"])
 end
 
 And /^"([^\"]*)" is in the "([^\"]*)" environment$/ do |name, environment|
-  $drb_test_lab.chef_set_client_config(:environment => environment)
+  $test_lab.drb.chef_set_client_config(:environment => environment)
 end
 
 And /^the chef-client has been run on "([^\"]*)"$/ do |name|
-  $drb_test_lab.chef_run_client(name)
+  $test_lab.drb.chef_run_client(name)
+  chef_client_artifacts(name)
 end

data/lib/cucumber/chef/steps/ssh_steps.rb

@@ -1,7 +1,35 @@
+################################################################################
+
+# | id | hostname | username | keyfile |
+# | root | chef-client | root | keyfile |
+
+When /^I have the following SSH sessions:$/ do |table|
+  lambda {
+    @ssh_sessions ||= Hash.new
+    table.hashes.each do |hash|
+      id = hash["id"]
+      @ssh_sessions[id] and !@ssh_sessions[id].closed? and @ssh_sessions[id].close
+      @ssh_sessions[id] = ZTK::SSH.new
+
+      @ssh_sessions[id].config.proxy_host_name = $test_lab.labs_running.first.public_ip_address
+      @ssh_sessions[id].config.proxy_user = "ubuntu"
+      @ssh_sessions[id].config.proxy_keys = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{@ssh_sessions[id].config.proxy_user}")
+
+      hash['hostname'] and (@ssh_sessions[id].config.host_name = hash['hostname'])
+      hash['username'] and (@ssh_sessions[id].config.user = hash['username'])
+      hash['password'] and (@ssh_sessions[id].config.password = hash['password'])
+      hash['keyfile'] and (@ssh_sessions[id].config.keys = hash['keyfile'])
+    end
+  }.should_not raise_error
+end
+
+################################################################################
+
 When /^I ssh to "([^\"]*)" with the following credentials:$/ do |hostname, table|
   session = table.hashes.first
   lambda {
 
+    @connection and !@connection.ssh.closed? and @connection.ssh.close
     @connection = ZTK::SSH.new
 
     @connection.config.proxy_host_name = $test_lab.labs_running.first.public_ip_address
@@ -18,6 +46,7 @@ end
 
 And /^I run "([^\"]*)"$/ do |command|
   @output = @connection.exec(command, :silence => true).output
+  Cucumber::Chef.logger.info { @output.chomp }
 end
 
 Then /^I should( not)? see "([^\"]*)" in the output$/ do |boolean, string|
@@ -30,9 +59,9 @@ end
 
 Then /^I should( not)? see the "([^\"]*)" of "([^\"]*)" in the output$/ do |boolean, key, name|
   if (!boolean)
-    @output.should =~ /#{$drb_test_lab.servers[name][key.downcase.to_sym]}/i
+    @output.should =~ /#{$test_lab.drb.servers[name][key.downcase.to_sym]}/i
   else
-    @output.should_not =~ /#{$drb_test_lab.servers[name][key.downcase.to_sym]}/i
+    @output.should_not =~ /#{$test_lab.drb.servers[name][key.downcase.to_sym]}/i
   end
 end
 

data/lib/cucumber/chef/steps.rb

@@ -2,7 +2,7 @@
 #
 #      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
 #      Author: Zachary Patten <zachary@jovelabs.com>
-#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#   Copyright: Copyright (c) 2011-2013 Atalanta Systems Ltd
 #     License: Apache License, Version 2.0
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");

data/lib/cucumber/chef/templates/cucumber/cc-hooks.rb

@@ -0,0 +1,111 @@
+################################################################################
+#
+#      Author: Zachary Patten <zachary@jovelabs.com>
+#   Copyright: Copyright (c) 2011-2013 Atalanta Systems Ltd
+#     License: Apache License, Version 2.0
+#
+#   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.
+#
+################################################################################
+
+tag = Cucumber::Chef.tag("cucumber-chef")
+puts("  * #{tag}")
+Cucumber::Chef.load_config(tag)
+
+if ($test_lab = Cucumber::Chef::TestLab.new) && ($test_lab.labs_running.count > 0)
+  $test_lab.ssh.exec("sudo mkdir -p /home/#{$test_lab.ssh.config.user}/.cucumber-chef")
+  $test_lab.ssh.exec("sudo cp -f /home/#{$test_lab.ssh.config.user}/.chef/knife.rb /home/#{$test_lab.ssh.config.user}/.cucumber-chef/knife.rb")
+  $test_lab.ssh.exec("sudo chown -R #{$test_lab.ssh.config.user}:#{$test_lab.ssh.config.user} /home/#{$test_lab.ssh.config.user}/.cucumber-chef")
+
+  local_file = Cucumber::Chef.config_rb
+  remote_file = File.join("/", "home", $test_lab.ssh.config.user, ".cucumber-chef", "config.rb")
+  $test_lab.ssh.upload(local_file, remote_file)
+
+  $cc_server_thread = Thread.new do
+    $test_lab.ssh.exec("sudo pkill -9 -f cc-server")
+
+    destroy = (ENV['DESTROY'] == '1' ? 'DESTROY="1"' : nil)
+    verbose = (ENV['VERBOSE'] == '1' ? 'VERBOSE="1"' : nil)
+    command = ["sudo", destroy, verbose, "cc-server", Cucumber::Chef.external_ip].compact.join(" ")
+    $test_lab.ssh.exec(command, :silence => false)
+
+    Kernel.at_exit do
+      $test_lab.ssh.close
+    end
+  end
+
+  ZTK::TCPSocketCheck.new(:host => $test_lab.labs_running.first.public_ip_address, :port => 8787, :data => "\n\n").wait
+
+  FileUtils.rm_rf(File.join(Cucumber::Chef.locate(:directory, ".cucumber-chef"), "artifacts"))
+else
+  message = "No running cucumber-chef test labs to connect to!"
+  Cucumber::Chef.logger.fatal { message }
+  raise message
+end
+
+
+################################################################################
+# BEFORE HOOK
+################################################################################
+
+Before do |scenario|
+  # store the current scenario here; espcially since I don't know a better way to get at this information
+  # we use various aspects of the scenario to name our artifacts
+  $scenario = scenario
+
+  # cleanup previous lxc containers if asked
+  if ENV['DESTROY']
+    log("$containers$ are being destroyed")
+    $test_lab.drb.servers.each do |name, value|
+      $test_lab.drb.server_destroy(name)
+    end
+    File.exists?(Cucumber::Chef.servers_bin) && File.delete(Cucumber::Chef.servers_bin)
+  else
+    log("$containers$ are being persisted")
+  end
+
+  if File.exists?(Cucumber::Chef.servers_bin)
+    $test_lab.drb.servers = (Marshal.load(IO.read(Cucumber::Chef.servers_bin)) rescue Hash.new(nil))
+  end
+
+  $test_lab.drb.chef_set_client_config(:chef_server_url => "http://192.168.255.254:4000",
+                                       :validation_client_name => "chef-validator")
+end
+
+
+################################################################################
+# AFTER HOOK
+################################################################################
+
+After do |scenario|
+  File.open(Cucumber::Chef.servers_bin, 'w') do |f|
+    f.puts(Marshal.dump($test_lab.drb.servers))
+  end
+
+  # cleanup non-persistent lxc containers between tests
+  $test_lab.drb.servers.select{ |name, attributes| !attributes[:persist] }.each do |name, attributes|
+    $test_lab.drb.server_destroy(name)
+  end
+end
+
+
+################################################################################
+# EXIT HOOK
+################################################################################
+
+Kernel.at_exit do
+  $test_lab.drb.shutdown
+  $cc_server_thread.kill
+end
+
+################################################################################

data/lib/cucumber/chef/templates/cucumber/env.rb

@@ -11,90 +11,3 @@ end
 World do
   CustomWorld.new
 end
-
-################################################################################
-
-$logger = ZTK::Logger.new(Cucumber::Chef.log_file)
-Cucumber::Chef.is_rc? and ($logger.level = ZTK::Logger::DEBUG)
-
-message = "cucumber-chef v#{Cucumber::Chef::VERSION}"
-print("  * #{message}")
-$logger.info { message }
-
-Cucumber::Chef::Config.load
-if ($test_lab = Cucumber::Chef::TestLab.new) && ($test_lab.labs_running.count > 0)
-
-  # fire up our drb server
-  ssh = ZTK::SSH.new
-  ssh.config.host_name = $test_lab.labs_running.first.public_ip_address
-  ssh.config.user = "ubuntu"
-  ssh.config.keys = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config.user}")
-  ssh.exec("nohup sudo pkill -9 -f cc-server")
-  ssh.exec("nohup sudo BACKGROUND=yes cc-server #{Cucumber::Chef.external_ip}")
-  Cucumber::Chef.spinner do
-    ZTK::TCPSocketCheck.new(:host => $test_lab.labs_running.first.public_ip_address, :port => 8787, :data => "\n\n").wait
-  end
-
-  # load our test lab knife config
-  knife_rb = Cucumber::Chef.locate(:file, ".cucumber-chef", "knife.rb")
-  Chef::Config.from_file(knife_rb)
-
-  # initialize our drb object
-  $drb_test_lab ||= DRbObject.new_with_uri("druby://#{$test_lab.labs_running.first.public_ip_address}:8787")
-  $drb_test_lab and DRb.start_service
-  $drb_test_lab.servers = Hash.new(nil)
-
-else
-  puts("No running cucumber-chef test labs to connect to!")
-  exit(1)
-end
-
-puts(" - connected to test lab")
-
-################################################################################
-
-Before do
-  $servers_bin ||= (File.join(Cucumber::Chef.locate(:directory, ".cucumber-chef"), "servers.bin") rescue File.expand_path(File.join(ENV['HOME'], "servers.bin")))
-
-  # cleanup previous lxc containers if asked
-  if ENV['DESTROY']
-    log("servers", "are being destroyed")
-    $drb_test_lab.servers.each do |name|
-      $drb_test_lab.server_destroy(name)
-    end
-    File.exists?($servers_bin) && File.delete($servers_bin)
-  else
-    log("servers", "are being preserved")
-  end
-
-  if File.exists?($servers_bin)
-    $drb_test_lab.servers = (Marshal.load(IO.read($servers_bin)) rescue Hash.new(nil))
-  end
-
-  $drb_test_lab.chef_set_client_config(:chef_server_url => "http://192.168.255.254:4000",
-                                   :validation_client_name => "chef-validator")
-end
-
-################################################################################
-
-After do |scenario|
-  File.open($servers_bin, 'w') do |f|
-    f.puts(Marshal.dump($drb_test_lab.servers))
-  end
-
-  Kernel.exit if scenario.failed?
-
-  # cleanup non-persistent lxc containers between tests
-  $drb_test_lab.servers.select{ |name, attributes| !attributes[:persist] }.each do |name, attributes|
-    $drb_test_lab.server_destroy(name)
-  end
-
-end
-
-################################################################################
-
-Kernel.at_exit do
-  $drb_test_lab.shutdown
-end
-
-################################################################################