cucumber-chef 3.0.0.rc.0 → 3.0.0.rc.1

data/bin/cucumber-chef

@@ -128,7 +128,7 @@ class CucumberChef < Thor
 # SETUP
 ################################################################################
 
-  desc "setup", "Setup cucumber-chef test lab in Amazon EC2"
+  desc "setup", "Setup the cucumber-chef test lab"
   method_option :test, :type => :boolean, :desc => "INTERNAL USE ONLY"
   def setup
     boot
@@ -166,7 +166,7 @@ class CucumberChef < Thor
 # DESTROY
 ################################################################################
 
-  desc "destroy [container]", "Destroy the cucumber-chef test lab in Amazon EC2 or a test lab [container] if specified."
+  desc "destroy [container] [...]", "Destroy the cucumber-chef test lab or a single or multiple containers if specified"
   method_option :test, :type => :boolean, :desc => "INTERNAL USE ONLY"
   def destroy(*args)
     boot
@@ -207,9 +207,7 @@ class CucumberChef < Thor
 
           args.each do |container|
             ZTK::Benchmark.bench(:message => "Destroy container '#{container}'", :mark => "completed in %0.4f seconds.") do
-              test_lab.containers.load
               test_lab.containers.destroy(container)
-              test_lab.containers.save
             end
           end
 
@@ -234,7 +232,7 @@ class CucumberChef < Thor
 # UP
 ################################################################################
 
-  desc "up", "Startup the cucumber-chef test lab"
+  desc "up", "Power up the cucumber-chef test lab"
   def up
     boot
 
@@ -253,16 +251,16 @@ class CucumberChef < Thor
   end
 
 ################################################################################
-# HALT
+# DOWN
 ################################################################################
 
-  desc "halt", "Power off the cucumber-chef test lab"
-  def halt
+  desc "down", "Power off the cucumber-chef test lab"
+  def down
     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
+      ZTK::Benchmark.bench(:message => "Downing #{Cucumber::Chef::Config.provider.upcase} instance '#{test_lab.id}'", :mark => "completed in %0.4f seconds.") do
+        test_lab.down
       end
     else
       raise Cucumber::Chef::Error, "We could not find a running test lab."
@@ -296,14 +294,14 @@ class CucumberChef < Thor
     fatal(e)
   end
 
-  desc "genmac", "Generate a private MAC address"
+  desc "genmac", "Generate an RFC compliant private MAC address"
   def genmac
     boot
 
     puts Cucumber::Chef::Containers.generate_mac
   end
 
-  desc "genip", "Generate a private IP address"
+  desc "genip", "Generate an RFC compliant private IP address"
   def genip
     boot
 
@@ -329,13 +327,13 @@ class CucumberChef < Thor
             headers = [:name, :alive, :distro, :ip, :mac, :"chef version", :persist]
             results = ZTK::Report.new.spreadsheet(Cucumber::Chef::Container.all, headers) do |container|
               chef_version = "N/A"
-              alive = (test_lab.bootstrap_ssh(:ignore_exit_status => true).exec(%Q{ping -n -c 1 -W 1 #{container.ip}}, :silence => true).exit_code == 0)
+              alive = (test_lab.bootstrap_ssh(:ignore_exit_status => true).exec(%(ping -n -c 1 -W 1 #{container.ip}), :silence => true).exit_code == 0)
               if alive
-                chef_version = test_lab.proxy_ssh(container.name, :ignore_exit_status => true).exec(%Q{/usr/bin/env chef-client -v}, :silence => true).output.chomp
+                chef_version = test_lab.proxy_ssh(container.id, :ignore_exit_status => true).exec(%(/usr/bin/env chef-client -v), :silence => true).output.chomp
               end
 
               OpenStruct.new(
-                :name => container.name,
+                :name => container.id,
                 :ip => container.ip,
                 :mac => container.mac,
                 :distro => container.distro,
@@ -378,8 +376,8 @@ class CucumberChef < Thor
 # SSH
 ################################################################################
 
-  desc "ssh [container]", "SSH to cucumber-chef test lab or [container] if specified."
-  method_option :bootstrap, :type => :boolean, :desc => "Use the bootstrap settings.", :default => false
+  desc "ssh [container]", "SSH to cucumber-chef test lab or [container] if specified"
+  method_option :bootstrap, :type => :boolean, :desc => "Use the bootstrap settings", :default => false
   def ssh(*args)
     boot
 
@@ -571,8 +569,7 @@ class CucumberChef < Thor
   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."
+    "test" => "You should execute 'cucumber' or 'rspec' directly."
   }
 
   depreciated_tasks.each do |old_task, message|

data/cucumber-chef.gemspec

@@ -46,7 +46,7 @@ Gem::Specification.new do |s|
   s.add_dependency("rake", ">= 0.9.2")
   s.add_dependency("thor", ">= 0.15.2")
   s.add_dependency("ubuntu_ami", ">= 0.4.0")
-  s.add_dependency("ztk", ">= 1.0.3")
+  s.add_dependency("ztk", ">= 1.0.8")
 
   s.add_development_dependency("simplecov", ">= 0.6.4")
   s.add_development_dependency("pry", ">= 0")

data/lib/cucumber/chef/client.rb

@@ -28,78 +28,94 @@ module Cucumber
 
 ################################################################################
 
-      def initialize(test_lab, ui=ZTK::UI.new)
-        @test_lab = test_lab
-        @ui = ui
-      end
+      def initialize
+        tag = Cucumber::Chef.tag("cucumber-chef")
+        puts(">>> #{tag}")
+        Cucumber::Chef.boot(tag)
 
-################################################################################
+        @ui = ZTK::UI.new(:logger => Cucumber::Chef.logger)
 
-      def up(options={})
-        # user = Cucumber::Chef.lab_user
-        # home_dir = Cucumber::Chef.lab_user_home_dir
-        # provider = Cucumber::Chef::Config.provider.to_s
-        # @test_lab.ssh.exec("sudo mkdir -p #{File.join(home_dir, ".cucumber-chef", provider)}")
-        # @test_lab.ssh.exec("sudo cp -f #{File.join(home_dir, ".chef", "knife.rb")} #{File.join(home_dir, ".cucumber-chef", provider, "knife.rb")}")
-        # @test_lab.ssh.exec("sudo chown -R #{user}:#{user} #{File.join(home_dir, ".cucumber-chef")}")
-
-        # local_file = Cucumber::Chef.config_rb
-        # remote_file = File.join(home_dir, ".cucumber-chef", "config.rb")
-        # @test_lab.ssh.upload(local_file, remote_file)
-
-        # begin
-        #   self.ping
-        # rescue
-        #   @background = ZTK::Background.new
-        #   @background.process do
-        #     self.down
-
-        #     environment = Array.new
-        #     %w(PURGE VERBOSE LOG_LEVEL).each do |env_var|
-        #       environment << "#{env_var}=#{ENV[env_var].inspect}" if (!ENV[env_var].nil? && !ENV[env_var].empty?)
-        #     end
-        #     environment = environment.join(" ")
-        #     external_ip = Cucumber::Chef.external_ip
-
-        #     command = %Q{nohup sudo #{environment} /usr/bin/env cc-server #{external_ip} &}
-
-        #     @test_lab.ssh.exec(command, options)
-        #   end
-
-        #   Kernel.at_exit do
-        #     self.at_exit
-        #   end
-        # end
-
-        # ZTK::RescueRetry.try(:tries => 30) do
-        #   self.drb.ping
-        # end
+        if !((@test_lab = Cucumber::Chef::TestLab.new(@ui)) && @test_lab.alive?)
+          message = "No running cucumber-chef test labs to connect to!"
+          @ui.logger.fatal { message }
+          raise message
+        end
 
-        true
       end
 
 ################################################################################
 
-      def down
-        # (@test_lab.drb.shutdown rescue nil)
-      end
+      def up(options={})
 
-################################################################################
+        # PUSH CHEF-REPO
+        #################
+        if environment_variable_set?("PUSH")
+          # Upload all of the chef-repo environments
+          ZTK::Benchmark.bench(:message => ">>> Pushing chef-repo environments to the test lab", :mark => "completed in %0.4f seconds.") do
+            @test_lab.knife_cli(%(environment from file ./environments/*.rb), :silence => true)
+          end
+
+          # Upload all of the chef-repo cookbooks
+          ZTK::Benchmark.bench(:message => ">>> Pushing chef-repo cookbooks to the test lab", :mark => "completed in %0.4f seconds.") do
+            cookbook_paths = ["./cookbooks"]
+            cookbook_paths << "./site-cookbooks" if Cucumber::Chef::Config.librarian_chef
+            @test_lab.knife_cli(%(cookbook upload --all --cookbook-path #{cookbook_paths.join(':')} --force), :silence => true)
+          end
+
+          # Upload all of the chef-repo roles
+          ZTK::Benchmark.bench(:message => ">>> Pushing chef-repo roles to the test lab", :mark => "completed in %0.4f seconds.") do
+            @test_lab.knife_cli(%(role from file ./roles/*.rb), :silence => true)
+          end
+
+          # Upload all of our chef-repo data bags
+          Dir.glob("./data_bags/*").each do |data_bag_path|
+            next if !File.directory?(data_bag_path)
+            ZTK::Benchmark.bench(:message => ">>> Pushing chef-repo data bag '#{File.basename(data_bag_path)}' to the test lab", :mark => "completed in %0.4f seconds.") do
+              data_bag = File.basename(data_bag_path)
+              @test_lab.knife_cli(%(data bag create "#{data_bag}"), :silence => true)
+              @test_lab.knife_cli(%(data bag from file "#{data_bag}" "#{data_bag_path}"), :silence => true)
+            end
+          end
+        end
+
+        # PURGE CONTAINERS
+        ###################
+        if environment_variable_set?("PURGE")
+          @ui.logger.warn { "PURGING CONTAINERS!  Container attributes will be reset!" }
+          @test_lab.containers.list.each do |name|
+            ZTK::Benchmark.bench(:message => ">>> Destroying container '#{name}'", :mark => "completed in %0.4f seconds.") do
+              @test_lab.containers.destroy(name)
+            end
+          end
+        else
+          @ui.logger.info { "Allowing existing containers to persist." }
+        end
+
+        # CREATE CONTAINERS
+        ####################
+        Cucumber::Chef::Container.all.each do |container|
+          ZTK::Benchmark.bench(:message => ">>> Creating container '#{container.id}'", :mark => "completed in %0.4f seconds.") do
+            @test_lab.containers.create(container)
+          end
+        end
+
+        # PROVISION CONTAINERS
+        #######################
+        @test_lab.containers.chef_set_client_config(:chef_server_url => "http://192.168.255.254:4000",
+                                                    :validation_client_name => "chef-validator")
+        Cucumber::Chef::Container.all.each do |container|
+          ZTK::Benchmark.bench(:message => ">>> Provisioning container '#{container.id}'", :mark => "completed in %0.4f seconds.") do
+            @test_lab.containers.provision(container)
+          end
+        end
 
-      # def drb
-      #   @drb and DRb.stop_service
-      #   @drb = DRbObject.new_with_uri("druby://#{@test_lab.ip}:8787")
-      #   @drb and DRb.start_service
-      #   @drb
-      # end
+        true
+      end
 
 ################################################################################
 
       def before(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
-
       end
 
 ################################################################################
@@ -109,13 +125,20 @@ module Cucumber
 
 ################################################################################
 
-      # def at_exit
-      #   @ui.logger.fatal { "Waiting for cc-server to shutdown." }
-      #   self.down
-      #   @background.wait
-      # end
+      def at_exit
+      end
 
 ################################################################################
+    private
+################################################################################
+
+      def environment_variable_set?(variable_name)
+        raise "You must supply an environment variable name!" if variable_name.nil?
+
+        variable_name = variable_name.strip.upcase
+
+        (!ENV[variable_name].nil? && ((ENV[variable_name] == '1') || (ENV[variable_name].strip.upcase == 'YES')))
+      end
 
     end
 

data/lib/cucumber/chef/containers.rb

@@ -43,7 +43,7 @@ module Cucumber
 
       def create(container)
         # if this is a new or non-persistent container destroy it
-        destroy(container.name) if !container.persist
+        destroy(container.id) if !container.persist
 
         container.ip ||= self.generate_ip
         container.mac ||= self.generate_mac
@@ -52,26 +52,26 @@ module Cucumber
         container.release ||= "lucid"
         container.arch = detect_arch(container.distro || "ubuntu")
 
-        if running?(container.name)
-          @ui.logger.info { "Container '#{container.name}' is already running." }
+        if running?(container.id)
+          @ui.logger.info { "Container '#{container.id}' is already running." }
         else
           @ui.logger.info { "Please wait, creating container #{container.inspect}." }
           bm = ::Benchmark.realtime do
             test_lab_config_dhcpd
             config_network(container)
-            _create(container.name, container.distro, container.release, container.arch)
+            _create(container.id, container.distro, container.release, container.arch)
           end
-          @ui.logger.info { "Container '#{container.name}' creation took %0.4f seconds." % bm }
+          @ui.logger.info { "Container '#{container.id}' creation took %0.4f seconds." % bm }
 
           bm = ::Benchmark.realtime do
             ZTK::RescueRetry.try(:tries => 32) do
-              @test_lab.ssh.exec("host #{container.name}", :silence => true)
+              @test_lab.ssh.exec("host #{container.id}", :silence => true)
             end
             ZTK::RescueRetry.try(:tries => 32) do
-              @test_lab.proxy_ssh(container.name).exec("uptime", :silence => true)
+              @test_lab.proxy_ssh(container.id).exec("uptime", :silence => true)
             end
           end
-          @ui.logger.info { "Container '#{container.name}' SSHD responded after %0.4f seconds." % bm }
+          @ui.logger.info { "Container '#{container.id}' SSHD responded after %0.4f seconds." % bm }
         end
       end
 
@@ -89,11 +89,17 @@ module Cucumber
         end
       end
 
+################################################################################
+
+      def provision(container, *args)
+        @test_lab.containers.chef_run_client(container, *args)
+      end
+
 ################################################################################
 
       def chef_set_client_config(config={})
         @chef_client_config = (@chef_client_config || {
-          :log_level => :info,
+          :log_level => :debug,
           :log_location => "/var/log/chef/client.log",
           :chef_server_url => "https://api.opscode.com/organizations/#{config[:orgname]}",
           :validation_client_name => "#{config[:orgname]}-validator",
@@ -112,12 +118,12 @@ module Cucumber
         chef_config_client(container)
 
         @ui.logger.info { "Removing artifacts #{Cucumber::Chef::Config[:artifacts].values.collect{|z| "'#{z}'" }.join(' ')}." }
-        (@test_lab.proxy_ssh(container.name).exec("/bin/rm -fv #{Cucumber::Chef::Config[:artifacts].values.join(' ')}", :silence => true) rescue nil)
+        (@test_lab.proxy_ssh(container.id).exec("/bin/rm -fv #{Cucumber::Chef::Config[:artifacts].values.join(' ')}", :silence => true) rescue nil)
 
-        @ui.logger.info { "Running chef client on container '#{container.name}'." }
+        @ui.logger.info { "Running chef client on container '#{container.id}'." }
 
         arguments = {
-          "--node-name" => container.name,
+          "--node-name" => container.id,
           "--json-attributes" => File.join("/etc", "chef", "attributes.json").to_s,
           "--log_level" => @chef_client_config[:log_level],
           "--logfile" => @chef_client_config[:log_location],
@@ -127,9 +133,9 @@ module Cucumber
 
         output = nil
         bm = ::Benchmark.realtime do
-          output = @test_lab.proxy_ssh(container.name).exec(["/usr/bin/chef-client", arguments, args, "--once"].flatten.join(" "), :silence => true)
+          output = @test_lab.proxy_ssh(container.id).exec(["/usr/bin/chef-client", arguments, args, "--once"].flatten.join(" "), :silence => true, :ignore_exit_status => true)
         end
-        @ui.logger.info { "Chef client run on container '#{container.name}' took %0.4f seconds." % bm }
+        @ui.logger.info { "Chef client run on container '#{container.id}' took %0.4f seconds." % bm }
 
         chef_client_artifacts(container)
 
@@ -190,7 +196,7 @@ module Cucumber
 ################################################################################
 
       def list
-        @test_lab.bootstrap_ssh.exec("sudo lxc-ls 2>&1", :silence => true).output.split("\n").uniq
+        @test_lab.bootstrap_ssh.exec("sudo lxc-ls 2>&1", :silence => true).output.strip.split(" ").uniq
       end
 
 ################################################################################
@@ -213,37 +219,37 @@ module Cucumber
           omnibus_chef_client = File.join("/", "opt", "chef", "bin", "chef-client")
           omnibus_cache = File.join(cache_rootfs, omnibus_chef_client)
           @ui.logger.info { "looking for omnibus cache in #{omnibus_cache}" }
-          if @test_lab.bootstrap_ssh.exec(%Q{sudo /bin/bash -c '[[ -f #{omnibus_cache} ]] ; echo $? ; true'}, :silence => true).output.chomp =~ /1/
+          if @test_lab.bootstrap_ssh.exec(%(sudo /bin/bash -c '[[ -f #{omnibus_cache} ]]'), :silence => true, :ignore_exit_status => true).exit_code == 1
             case distro.downcase
             when "ubuntu" then
-              @test_lab.bootstrap_ssh.exec(%Q{sudo chroot #{cache_rootfs} /bin/bash -c 'DEBIAN_FRONTEND=noninteractive apt-get -y --force-yes install wget'}, :silence => true)
+              @test_lab.bootstrap_ssh.exec(%(sudo chroot #{cache_rootfs} /bin/bash -c 'DEBIAN_FRONTEND=noninteractive apt-get -y --force-yes install wget'), :silence => true)
             when "fedora" then
-              @test_lab.bootstrap_ssh.exec(%Q{sudo yum --nogpgcheck --installroot=#{cache_rootfs} -y install wget openssh-server}, :silence => true)
+              @test_lab.bootstrap_ssh.exec(%(sudo yum --nogpgcheck --installroot=#{cache_rootfs} -y install wget openssh-server), :silence => true)
             end
-            @test_lab.bootstrap_ssh.exec(%Q{sudo chroot #{cache_rootfs} /bin/bash -c 'locale-gen'}, :silence => true)
-            @test_lab.bootstrap_ssh.exec(%Q{sudo chroot #{cache_rootfs} /bin/bash -c 'locale-gen en_US'}, :silence => true)
-            @test_lab.bootstrap_ssh.exec(%Q{sudo chroot #{cache_rootfs} /bin/bash -c 'wget http://www.opscode.com/chef/install.sh'}, :silence => true)
-            @test_lab.bootstrap_ssh.exec(%Q{sudo chroot #{cache_rootfs} /bin/bash -c 'bash install.sh -v #{Cucumber::Chef::Config.chef[:version]}'}, :silence => true)
+            @test_lab.bootstrap_ssh.exec(%(sudo chroot #{cache_rootfs} /bin/bash -c 'locale-gen'), :silence => true)
+            @test_lab.bootstrap_ssh.exec(%(sudo chroot #{cache_rootfs} /bin/bash -c 'locale-gen en_US'), :silence => true)
+            @test_lab.bootstrap_ssh.exec(%(sudo chroot #{cache_rootfs} /bin/bash -c 'wget http://www.opscode.com/chef/install.sh'), :silence => true)
+            @test_lab.bootstrap_ssh.exec(%(sudo chroot #{cache_rootfs} /bin/bash -c 'bash install.sh -v #{Cucumber::Chef::Config.chef[:version]}'), :silence => true)
             if distro.downcase == "fedora"
-              @test_lab.bootstrap_ssh.exec(%Q{sudo chroot #{cache_rootfs} /bin/bash -c 'rpm -Uvh --nodeps /tmp/*rpm'}, :silence => true)
+              @test_lab.bootstrap_ssh.exec(%(sudo chroot #{cache_rootfs} /bin/bash -c 'rpm -Uvh --nodeps /tmp/*rpm'), :silence => true)
             end
-            @test_lab.bootstrap_ssh.exec(%Q{sudo lxc-destroy -n #{name}}, :silence => true)
-            @test_lab.bootstrap_ssh.exec(%Q{sudo #{create_command(name, distro, release, arch)}}, :silence => true)
+            @test_lab.bootstrap_ssh.exec(%(sudo lxc-destroy -n #{name}), :silence => true)
+            @test_lab.bootstrap_ssh.exec(%(sudo #{create_command(name, distro, release, arch)}), :silence => true)
           end
 
           lab_ssh_path = File.join(Cucumber::Chef.lab_user_home_dir, ".ssh")
           ssh_path = File.join(root(name), Cucumber::Chef.lxc_user_home_dir, ".ssh")
           motd_path = File.join(root(name), "etc", "motd")
 
-          @test_lab.bootstrap_ssh.exec(%Q{sudo mkdir -vp #{ssh_path}}, :silence => true)
-          @test_lab.bootstrap_ssh.exec(%Q{sudo chmod 0700 #{ssh_path}}, :silence => true)
-          @test_lab.bootstrap_ssh.exec(%Q{sudo cat #{File.join(lab_ssh_path, "id_rsa.pub")} | sudo tee -a #{File.join(ssh_path, "authorized_keys")}}, :silence => true)
+          @test_lab.bootstrap_ssh.exec(%(sudo mkdir -vp #{ssh_path}), :silence => true)
+          @test_lab.bootstrap_ssh.exec(%(sudo chmod 0700 #{ssh_path}), :silence => true)
+          @test_lab.bootstrap_ssh.exec(%(sudo cat #{File.join(lab_ssh_path, "id_rsa.pub")} | sudo tee -a #{File.join(ssh_path, "authorized_keys")}), :silence => true)
 
-          @test_lab.bootstrap_ssh.exec(%Q{sudo rm -vf #{motd_path}}, :silence => true)
-          @test_lab.bootstrap_ssh.exec(%Q{sudo cp -v /etc/motd #{motd_path}}, :silence => true)
-          @test_lab.bootstrap_ssh.exec(%Q{echo "    You are now logged in to the "#{name}" container!\n" | sudo tee -a #{motd_path}}, :silence => true)
-          @test_lab.bootstrap_ssh.exec(%Q{echo "127.0.0.1 #{name}.#{Cucumber::Chef::Config.test_lab[:tld]} #{name}" | sudo tee -a #{File.join(root(name), "etc", "hosts")}}, :silence => true)
-          @test_lab.bootstrap_ssh.exec(%Q{echo "#{name}.test-lab" | sudo tee #{File.join(root(name), "etc", "hostname")}}, :silence => true)
+          @test_lab.bootstrap_ssh.exec(%(sudo rm -vf #{motd_path}), :silence => true)
+          @test_lab.bootstrap_ssh.exec(%(sudo cp -v /etc/motd #{motd_path}), :silence => true)
+          @test_lab.bootstrap_ssh.exec(%(echo "    You are now logged in to the "#{name}" container!\n" | sudo tee -a #{motd_path}), :silence => true)
+          @test_lab.bootstrap_ssh.exec(%(echo "127.0.0.1 #{name}.#{Cucumber::Chef::Config.test_lab[:tld]} #{name}" | sudo tee -a #{File.join(root(name), "etc", "hosts")}), :silence => true)
+          @test_lab.bootstrap_ssh.exec(%(echo "#{name}.test-lab" | sudo tee #{File.join(root(name), "etc", "hostname")}), :silence => true)
         end
         start(name)
       end
@@ -251,26 +257,26 @@ module Cucumber
 ################################################################################
 
       def start(name)
-        status = @test_lab.bootstrap_ssh.exec("sudo lxc-info -n #{name}", :silence => true).output
+        status = @test_lab.bootstrap_ssh.exec(%(sudo lxc-info -n #{name}), :silence => true).output
         if status.include?("STOPPED")
-          @test_lab.bootstrap_ssh.exec("sudo lxc-start -d -n #{name}", :silence => true)
+          @test_lab.bootstrap_ssh.exec(%(sudo lxc-start -d -n #{name}), :silence => true)
         end
       end
 
       def stop(name)
-        status = @test_lab.bootstrap_ssh.exec("sudo lxc-info -n #{name}", :silence => true).output
+        status = @test_lab.bootstrap_ssh.exec(%(sudo lxc-info -n #{name}), :silence => true).output
         if status.include?("RUNNING")
-          @test_lab.bootstrap_ssh.exec("sudo lxc-stop -n #{name}", :silence => true)
+          @test_lab.bootstrap_ssh.exec(%(sudo lxc-stop -n #{name}), :silence => true)
         end
       end
 
 ################################################################################
 
       def chef_config_client(container)
-        tempfile = Tempfile.new(container.name)
-        client_rb = File.join("/", root(container.name), "etc/chef/client.rb")
+        tempfile = Tempfile.new(container.id)
+        client_rb = File.join("/", root(container.id), "etc/chef/client.rb")
 
-        @test_lab.bootstrap_ssh.exec(%Q{sudo mkdir -pv #{File.dirname(client_rb)}}, :silence => true)
+        @test_lab.bootstrap_ssh.exec(%(sudo mkdir -pv #{File.dirname(client_rb)}), :silence => true)
 
         if Cucumber::Chef::Config.chef[:render_client_rb]
           max_key_size = @chef_client_config.keys.collect{ |z| z.to_s.size }.max
@@ -278,7 +284,7 @@ module Cucumber
           File.open(tempfile, 'w') do |f|
             f.puts(Cucumber::Chef.generate_do_not_edit_warning("Chef Client Configuration"))
             f.puts
-            @chef_client_config.merge(:node_name => container.name).each do |(key,value)|
+            @chef_client_config.merge(:node_name => container.id).each do |(key,value)|
               next if value.nil?
               f.puts("%-#{max_key_size}s  %s" % [key, value.inspect])
             end
@@ -286,25 +292,25 @@ module Cucumber
             f.puts("Mixlib::Log::Formatter.show_time = true")
           end
           @test_lab.bootstrap_ssh.upload(tempfile.path, File.basename(tempfile.path))
-          @test_lab.bootstrap_ssh.exec(%Q{sudo mv -v #{File.basename(tempfile.path)} #{client_rb}}, :silence => true)
+          @test_lab.bootstrap_ssh.exec(%(sudo mv -v #{File.basename(tempfile.path)} #{client_rb}), :silence => true)
         else
-          @test_lab.bootstrap_ssh.exec(%Q{sudo /bin/bash -c '[[ -f #{client_rb} ]] && rm -fv #{client_rb}'}, :silence => true, :ignore_exit_status => true)
+          @test_lab.bootstrap_ssh.exec(%(sudo /bin/bash -c '[[ -f #{client_rb} ]] && rm -fv #{client_rb}'), :silence => true, :ignore_exit_status => true)
         end
 
-        tempfile = Tempfile.new(container.name)
-        attributes_json = File.join("/", root(container.name), "etc", "chef", "attributes.json")
-        @test_lab.bootstrap_ssh.exec(%Q{sudo mkdir -pv #{File.dirname(attributes_json)}}, :silence => true)
+        tempfile = Tempfile.new(container.id)
+        attributes_json = File.join("/", root(container.id), "etc", "chef", "attributes.json")
+        @test_lab.bootstrap_ssh.exec(%(sudo mkdir -pv #{File.dirname(attributes_json)}), :silence => true)
         File.open(tempfile, 'w') do |f|
           f.puts((container.chef_client || {}).to_json)
         end
         @test_lab.bootstrap_ssh.upload(tempfile.path, File.basename(tempfile.path))
-        @test_lab.bootstrap_ssh.exec(%Q{sudo mv -v #{File.basename(tempfile.path)} #{attributes_json}}, :silence => true)
+        @test_lab.bootstrap_ssh.exec(%(sudo mv -v #{File.basename(tempfile.path)} #{attributes_json}), :silence => true)
 
         # make sure our log location is there
-        log_location = File.join("/", root(container.name), @chef_client_config[:log_location])
-        @test_lab.bootstrap_ssh.exec(%Q{sudo mkdir -pv #{File.dirname(log_location)}}, :silence => true)
+        log_location = File.join("/", root(container.id), @chef_client_config[:log_location])
+        @test_lab.bootstrap_ssh.exec(%(sudo mkdir -pv #{File.dirname(log_location)}), :silence => true)
 
-        @test_lab.bootstrap_ssh.exec(%Q{sudo cp /etc/chef/validation.pem #{root(container.name)}/etc/chef/}, :silence => true)
+        @test_lab.bootstrap_ssh.exec(%(sudo cp /etc/chef/validation.pem #{root(container.id)}/etc/chef/), :silence => true)
 
         true
       end
@@ -312,14 +318,14 @@ module Cucumber
 ################################################################################
 
       def chef_client_artifacts(container)
-        ssh = @test_lab.proxy_ssh(container.name)
+        ssh = @test_lab.proxy_ssh(container.id)
 
         Cucumber::Chef::Config[:artifacts].each do |label, remote_path|
-          result = ssh.exec("sudo /bin/bash -c '[[ -f #{remote_path} ]] ; echo $? ; true'", :silence => true)
+          result = ssh.exec(%(sudo /bin/bash -c '[[ -f #{remote_path} ]] ; echo $? ; true'), :silence => true)
           if (result.output =~ /0/)
-            @ui.logger.info { "Retrieving artifact '#{remote_path}' from container '#{container.name}'." }
+            @ui.logger.info { "Retrieving artifact '#{remote_path}' from container '#{container.id}'." }
 
-            local_path = File.join(Cucumber::Chef.artifacts_dir, "#{container.name}.log")
+            local_path = File.join(Cucumber::Chef.artifacts_dir, "#{container.id}-#{File.basename(remote_path)}")
             tmp_path = File.join("/tmp", label)
 
             FileUtils.mkdir_p(File.dirname(local_path))
@@ -339,8 +345,8 @@ module Cucumber
 ################################################################################
 
       def config_network(container)
-        tempfile = Tempfile.new(container.name)
-        lxc_network_config = File.join("/etc/lxc", container.name)
+        tempfile = Tempfile.new(container.id)
+        lxc_network_config = File.join("/etc/lxc", container.id)
         File.open(tempfile, 'w') do |f|
           f.puts(Cucumber::Chef.generate_do_not_edit_warning("LXC Container Configuration"))
           f.puts("")
@@ -352,7 +358,7 @@ module Cucumber
           f.puts("lxc.network.ipv4 = 0.0.0.0")
         end
         @test_lab.bootstrap_ssh.upload(tempfile.path, File.basename(tempfile.path))
-        @test_lab.bootstrap_ssh.exec(%Q{sudo mv -v #{File.basename(tempfile.path)} #{lxc_network_config}}, :silence => true)
+        @test_lab.bootstrap_ssh.exec(%(sudo mv -v #{File.basename(tempfile.path)} #{lxc_network_config}), :silence => true)
       end
 
 ################################################################################
@@ -366,17 +372,17 @@ module Cucumber
             next if [container.mac, container.ip].any?{ |z| z.nil? }
 
             f.puts
-            f.puts("host #{container.name} {")
+            f.puts("host #{container.id} {")
             f.puts("  hardware ethernet #{container.mac};")
             f.puts("  fixed-address #{container.ip};")
-            f.puts("  ddns-hostname \"#{container.name}\";")
+            f.puts("  ddns-hostname \"#{container.id}\";")
             f.puts("}")
           end
           f.flush
           f.close
         end
         @test_lab.bootstrap_ssh.upload(tempfile.path, File.basename(tempfile.path))
-        @test_lab.bootstrap_ssh.exec(%Q{sudo mv -v #{File.basename(tempfile.path)} #{dhcpd_config}}, :silence => true)
+        @test_lab.bootstrap_ssh.exec(%(sudo mv -v #{File.basename(tempfile.path)} #{dhcpd_config}), :silence => true)
 
         @test_lab.bootstrap_ssh.exec("sudo service isc-dhcp-server restart", :silence => true)
         @test_lab.bootstrap_ssh.exec("sudo service bind9 restart", :silence => true)
@@ -397,14 +403,14 @@ module Cucumber
 ################################################################################
 
       def running?(name)
-        status = @test_lab.bootstrap_ssh.exec("sudo lxc-info -n #{name}", :silence => true).output.chomp
+        status = @test_lab.bootstrap_ssh.exec(%(sudo lxc-info -n #{name}), :silence => true).output.chomp
         status.include?("RUNNING")
       end
 
 ################################################################################
 
       def exists?(name)
-        (@test_lab.bootstrap_ssh.exec("sudo /bin/bash -c '[[ -d #{root(name)} ]] ; echo $? ; true'", :silence => true).output.chomp =~ /0/)
+        (@test_lab.bootstrap_ssh.exec(%(sudo /bin/bash -c '[[ -d #{root(name)} ]] ; echo $? ; true'), :silence => true).output.chomp =~ /0/)
       end
 
 ################################################################################
@@ -429,9 +435,9 @@ module Cucumber
       def create_command(name, distro, release, arch)
         case distro.downcase
         when "ubuntu" then
-          "sudo DEBIAN_FRONTEND=noninteractive lxc-create -n #{name} -f /etc/lxc/#{name} -t #{distro} -- --release #{release} --arch #{arch}"
+          %(sudo DEBIAN_FRONTEND=noninteractive lxc-create -n #{name} -f /etc/lxc/#{name} -t #{distro} -- --release #{release} --arch #{arch})
         when "fedora" then
-          "sudo lxc-create -n #{name} -f /etc/lxc/#{name} -t #{distro} -- --release #{release}"
+          %(sudo lxc-create -n #{name} -f /etc/lxc/#{name} -t #{distro} -- --release #{release})
         end
       end