cucumber-chef 2.0.7 → 2.1.0.rc.0

data/lib/cucumber/chef/bootstrap.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");
@@ -41,33 +41,33 @@ module Cucumber
 ################################################################################
 
       def run
-        $logger.debug { "config(#{@config.inspect})" }
+        Cucumber::Chef.logger.debug { "config(#{@config.inspect})" }
 
         if !@config[:template_file]
           message = "You must supply a 'template_file' option."
-          $logger.fatal { message }
+          Cucumber::Chef.logger.fatal { message }
           raise BootstrapError, message
         end
 
         if !@config[:host]
           message = "You must supply a 'host' option."
-          $logger.fatal { message }
+          Cucumber::Chef.logger.fatal { message }
           raise BootstrapError, message
         end
 
         if !@config[:ssh_user]
           message = "You must supply a 'ssh_user' option."
-          $logger.fatal { message }
+          Cucumber::Chef.logger.fatal { message }
           raise BootstrapError, message
         end
 
         if (!@config[:ssh_password] && !@config[:identity_file])
           message = "You must supply a 'ssh_password' or 'identity_file' option."
-          $logger.fatal { message }
+          Cucumber::Chef.logger.fatal { message }
           raise BootstrapError, message
         end
 
-        $logger.debug { "prepare(#{@config[:host]})" }
+        Cucumber::Chef.logger.debug { "prepare(#{@config[:host]})" }
 
         @ssh.config.host_name = @config[:host]
         @ssh.config.user = @config[:ssh_user]
@@ -75,13 +75,13 @@ module Cucumber
         @ssh.config.keys = @config[:identity_file]
         @ssh.config.timeout = 5
 
-        $logger.debug { "template_file(#{@config[:template_file]})" }
+        Cucumber::Chef.logger.debug { "template_file(#{@config[:template_file]})" }
         command = ZTK::Template.render(@config[:template_file], @config[:context])
         command = "sudo #{command}" if @config[:use_sudo]
 
-        $logger.debug { "begin(#{@config[:host]})" }
+        Cucumber::Chef.logger.debug { "begin(#{@config[:host]})" }
         @ssh.exec(command, :silence => true)
-        $logger.debug { "end(#{@config[:host]})" }
+        Cucumber::Chef.logger.debug { "end(#{@config[:host]})" }
       end
 
 ################################################################################

data/lib/cucumber/chef/config.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");
@@ -51,14 +51,14 @@ module Cucumber
 
       def self.load
         config_rb = Cucumber::Chef.locate(:file, ".cucumber-chef", "config.rb")
-        $logger.info { "Attempting to load cucumber-chef configuration from '%s'." % config_rb }
+        Cucumber::Chef.logger.debug { "Attempting to load cucumber-chef configuration from '%s'." % config_rb }
         self.from_file(config_rb)
         self.verify
-        $logger.info { "Successfully loaded cucumber-chef configuration from '%s'." % config_rb }
+        Cucumber::Chef.logger.debug { "Successfully loaded cucumber-chef configuration from '%s'." % config_rb }
 
         log_dump = self.duplicate(self.configuration)
         log_dump[:aws].merge!(:aws_access_key_id => "[REDACTED]", :aws_secret_access_key => "[REDACTED]")
-        $logger.debug { log_dump.inspect }
+        Cucumber::Chef.logger.debug { log_dump.inspect }
 
         self
       rescue Errno::ENOENT, UtilityError
@@ -77,25 +77,25 @@ module Cucumber
         self.verify_keys
         self.verify_provider_keys
         eval("self.verify_provider_#{self[:provider].to_s.downcase}")
-        $logger.debug { "Configuration verified successfully" }
+        Cucumber::Chef.logger.debug { "Configuration verified successfully" }
       end
 
 ################################################################################
 
       def self.verify_keys
-        $logger.debug { "Checking for missing configuration keys" }
+        Cucumber::Chef.logger.debug { "Checking for missing configuration keys" }
         missing_keys = KEYS.select{ |key| !self[key.to_sym] }
         if missing_keys.count > 0
           message = "Configuration incomplete, missing configuration keys: #{missing_keys.join(", ")}"
-          $logger.fatal { message }
+          Cucumber::Chef.logger.fatal { message }
           raise ConfigError, message
         end
 
-        $logger.debug { "Checking for invalid configuration keys" }
+        Cucumber::Chef.logger.debug { "Checking for invalid configuration keys" }
         invalid_keys = KEYS.select{ |key| !eval("#{key.to_s.upcase}S").include?(self[key]) }
         if invalid_keys.count > 0
           message = "Configuration incomplete, invalid configuration keys: #{invalid_keys.join(", ")}"
-          $logger.fatal { message }
+          Cucumber::Chef.logger.fatal { message }
           raise ConfigError, message
         end
       end
@@ -103,11 +103,11 @@ module Cucumber
 ################################################################################
 
       def self.verify_provider_keys
-        $logger.debug { "Checking for missing provider keys" }
+        Cucumber::Chef.logger.debug { "Checking for missing provider keys" }
         missing_keys = eval("PROVIDER_#{self[:provider].to_s.upcase}_KEYS").select{ |key| !self[self[:provider]].key?(key) }
         if missing_keys.count > 0
           message = "Configuration incomplete, missing provider configuration keys: #{missing_keys.join(", ")}"
-          $logger.fatal { message }
+          Cucumber::Chef.logger.fatal { message }
           raise ConfigError, message
         end
       end
@@ -122,14 +122,14 @@ module Cucumber
           compute.describe_availability_zones
         end
       rescue Fog::Service::Error => err
-        message = "Invalid AWS credentials.  Please check your configuration."
-        $logger.fatal { message }
+        message = "Invalid AWS credentials.  Please check your configuration. #{err.inspect}"
+        Cucumber::Chef.logger.fatal { message }
         raise ConfigError, message
       end
 
       def self.verify_provider_vagrant
         message = "Not yet implemented."
-        $logger.fatal { message }
+        Cucumber::Chef.logger.fatal { message }
         raise ConfigError, message
       end
 
@@ -147,7 +147,7 @@ module Cucumber
           return ami.name if ami
         end
         message = "Could not find a valid AMI image ID.  Please check your configuration."
-        $logger.fatal { message }
+        Cucumber::Chef.logger.fatal { message }
         raise ConfigError, message
       end
 

data/lib/cucumber/chef/helpers/chef_client.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,26 +26,45 @@ module Cucumber::Chef::Helpers::ChefClient
   # call this in a Before hook
   def chef_set_client_config(config={})
     @chef_client_config = (@chef_client_config || {
-      :log_level => :debug,
+      :log_level => :info,
       :log_location => "/var/log/chef/client.log",
       :chef_server_url => "https://api.opscode.com/organizations/#{config[:orgname]}",
-      :validation_client_name => "#{config[:orgname]}-validator"
+      :validation_client_name => "#{config[:orgname]}-validator",
+      :ssl_verify_mode => :verify_none,
+      :environment => nil # use default; i.e. set no value
     }).merge(config)
+    log("setting chef client config $#{@chef_client_config.inspect}$")
+
+    true
   end
 
 ################################################################################
 
   # call this before chef_run_client
   def chef_set_client_attributes(name, attributes={})
-    @chef_client_attributes = (@chef_client_attributes || {}).merge(attributes) { |k,o,n| (k = (o + n)) }
+    @servers[name] ||= Hash.new
+    @servers[name][:chef_client] = (@servers[name][:chef_client] || {}).merge(attributes) { |k,o,n| (k = (o + n).uniq) }
+    log("setting chef client attributes to $#{@servers[name][:chef_client].inspect}$ for container $#{name}$")
+
+    true
   end
 
 ################################################################################
 
   def chef_run_client(name,*args)
     chef_config_client(name)
-    output = command_run_remote(name, ["/usr/bin/chef-client -j /etc/chef/attributes.json -N #{name}", args].join(" "))
-    log("chef-client", "ran on node '#{name}'")
+    artifacts =
+    log("removing artifacts #{Cucumber::Chef::Config[:artifacts].values.collect{|z| "$#{z}$" }.join(' ')}")
+    (command_run_remote(name, "/bin/rm -fv #{Cucumber::Chef::Config[:artifacts].values.join(' ')}") rescue nil)
+
+    log("running chef client on container $#{name}$")
+
+    output = nil
+    bm = ::Benchmark.realtime do
+      output = command_run_remote(name, ["/usr/bin/chef-client --json-attributes /etc/chef/attributes.json --node-name #{name}", args].flatten.join(" "))
+    end
+    log("chef client run on container $#{name}$ took %0.4f seconds" % bm)
+
     output
   end
 
@@ -56,16 +75,15 @@ module Cucumber::Chef::Helpers::ChefClient
     client_rb = File.join("/", container_root(name), "etc/chef/client.rb")
     FileUtils.mkdir_p(File.dirname(client_rb))
 
+    max_key_size = @chef_client_config.keys.collect{ |z| z.to_s.size }.max
+
     File.open(client_rb, 'w') do |f|
       f.puts(Cucumber::Chef.generate_do_not_edit_warning("Chef Client Configuration"))
       f.puts
-      f.puts("log_level               :#{@chef_client_config[:log_level]}")
-      f.puts("log_location            \"#{@chef_client_config[:log_location]}\"")
-      f.puts("chef_server_url         \"#{@chef_client_config[:chef_server_url]}\"")
-      f.puts("ssl_verify_mode         :verify_none")
-      f.puts("validation_client_name  \"#{@chef_client_config[:validation_client_name]}\"")
-      f.puts("node_name               \"#{name}\"")
-      f.puts("environment             \"#{@chef_client_config[:environment]}\"") if @chef_client_config[:environment]
+      @chef_client_config.merge(:node_name => name).each do |(key,value)|
+        next if value.nil?
+        f.puts("%-#{max_key_size}s  %s" % [key, value.inspect])
+      end
       f.puts
       f.puts("Mixlib::Log::Formatter.show_time = true")
     end
@@ -73,7 +91,7 @@ module Cucumber::Chef::Helpers::ChefClient
     attributes_json = File.join("/", container_root(name), "etc", "chef", "attributes.json")
     FileUtils.mkdir_p(File.dirname(attributes_json))
     File.open(attributes_json, 'w') do |f|
-      f.puts((@chef_client_attributes || {}).to_json)
+      f.puts((@servers[name][:chef_client] || {}).to_json)
     end
 
     # make sure our log location is there
@@ -81,6 +99,62 @@ module Cucumber::Chef::Helpers::ChefClient
     FileUtils.mkdir_p(File.dirname(log_location))
 
     command_run_local("cp /etc/chef/validation.pem #{container_root(name)}/etc/chef/ 2>&1")
+
+    true
+  end
+
+################################################################################
+
+  def chef_client_artifacts(name)
+    # this is messy and needs to be refactored into a more configurable
+    # solution; but for now this should do the trick
+
+    ssh_private_key_file = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{Cucumber::Chef::Config[:lab_user]}")
+    File.chmod(0400, ssh_private_key_file)
+
+    ssh = ZTK::SSH.new
+
+    ssh.config.proxy_host_name = $test_lab.labs_running.first.public_ip_address
+    ssh.config.proxy_user = Cucumber::Chef::Config[:lab_user]
+    ssh.config.proxy_keys = ssh_private_key_file
+
+    ssh.config.host_name = name
+    ssh.config.user = Cucumber::Chef::Config[:lxc_user]
+    ssh.config.keys = ssh_private_key_file
+
+    feature_file = $scenario.file_colon_line.split(":").first
+    feature_line = $scenario.file_colon_line.split(":").last
+    scenario_tag = $scenario.name.gsub(" ", "_")
+
+    feature_name = File.basename(feature_file, ".feature")
+    feature_dir = feature_file.split("/")[-2]
+
+    Cucumber::Chef::Config[:artifacts].each do |label, remote_path|
+      result = ssh.exec("/bin/bash -c '[[ -f #{remote_path} ]] ; echo $?'", :silence => true)
+      if (result.output =~ /0/)
+        log("retrieving artifact $#{remote_path}$ from container $#{name}$")
+
+        local_path = File.join(Cucumber::Chef.locate(:directory, ".cucumber-chef"), "artifacts", feature_dir, "#{feature_name}.txt")
+        tmp_path = File.join("/tmp", label)
+
+        FileUtils.mkdir_p(File.dirname(local_path))
+        ssh.download(remote_path, tmp_path)
+        data = IO.read(tmp_path).chomp
+
+        message = "#{$scenario.name} (#{File.basename(feature_file)}:#{feature_line}:#{label})"
+        header = ("-" * message.length)
+
+        f = File.open(local_path, "a")
+        f.write("#{header}\n")
+        f.write("#{message}\n")
+        f.write("#{header}\n")
+        f.write("#{data}\n")
+
+        File.chmod(0644, local_path)
+      end
+    end
+
+    true
   end
 
 ################################################################################

data/lib/cucumber/chef/helpers/chef_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");
@@ -25,14 +25,14 @@ module Cucumber::Chef::Helpers::ChefServer
 
   def chef_server_node_destroy(name)
     (::Chef::Node.load(name).destroy rescue nil)
-    log("chef-server", "destroyed node '#{name}'")
+    log("destroyed chef node $#{name}$")
   end
 
 ################################################################################
 
   def chef_server_client_destroy(name)
     (::Chef::ApiClient.load(name).destroy rescue nil)
-    log("chef-server", "destroyed client '#{name}'")
+    log("destroyed chef client $#{name}$")
   end
 
 ################################################################################
@@ -45,20 +45,37 @@ module Cucumber::Chef::Helpers::ChefServer
     cookbook_repo.each do |name, cbook|
       next if name != cookbook
       ::Chef::CookbookUploader.new(cbook, cookbook_path, :force => true).upload_cookbooks
-      log("chef-server", "uploaded cookbook '#{cookbook}' from path '#{cookbook_path}'")
+      log("uploaded chef cookbook $#{cookbook}$ from $#{cookbook_path}$")
     end
   end
 
 ################################################################################
 
   def load_role(role, role_path)
-    if !File.exists?(File.expand_path(role_path))
-      raise "Role path does not exist!"
+    expanded_role_path = File.expand_path(role_path)
+    if !File.exists?(expanded_role_path)
+      raise "Role path, '#{expanded_role_path}', does not exist!"
     end
-    ::Chef::Config[:role_path] = role_path
+    ::Chef::Config[:role_path] = expanded_role_path
     role = ::Chef::Role.from_disk(role)
     role.save
-    log("chef-server", "updated role '#{role}' from file '#{role_path}'")
+    log("updated chef role $#{role}$ from $#{role_path}$")
+  end
+
+################################################################################
+
+  def get_databag(databag)
+    @rest ||= ::Chef::REST.new(Chef::Config[:chef_server_url])
+    @rest.get_rest("data/#{databag}")
+  rescue Net::HTTPServerException => e
+    raise unless e.to_s =~ /^404/
+  end
+
+  def destroy_databag(databag)
+    @rest ||= ::Chef::REST.new(Chef::Config[:chef_server_url])
+    @rest.delete_rest("data/#{databag}")
+  rescue Net::HTTPServerException => e
+    raise unless e.to_s =~ /^404/
   end
 
 ################################################################################
@@ -77,24 +94,30 @@ module Cucumber::Chef::Helpers::ChefServer
   def load_databag(databag, databag_path)
     create_databag(databag)
     items = Dir.glob(File.expand_path(File.join(databag_path, "*.{json,rb}")))
+    if (items.size == 0)
+      raise "Could not find any of the data bags you defined!"
+    end
     items.each do |item|
       next if File.directory?(item)
 
+      item_name = %w( json rb ).collect{ |ext| (item =~ /#{ext}/ ? File.basename(item, ".#{ext}") : nil) }.compact.first
       item_path = File.basename(item)
       databag_item_path = File.expand_path(File.join(databag_path, item_path))
 
       data_bag_item = ::Chef::DataBagItem.new
       data_bag_item.data_bag(databag)
-      data_bag_item.raw_data = load_databag_item(databag_item_path)
+      raw_data = load_databag_item(databag_item_path)
+      data_bag_item.raw_data = raw_data.dup
       data_bag_item.save
-      log("chef-server", "updated data bag item '#{databag}/#{item_path}' from file '#{databag_path}'")
-    end
 
-    # TODO fix ghetto sleep
-    # databags don't always update right away; ghetto fix with a sleep
-    # for now.  likely needs to loop reading the databag back until it updates
-    # then return
-    sleep(3)
+      loop do
+        chef_data = ::Chef::DataBagItem.load(databag, item_name).raw_data
+        break if chef_data == raw_data
+        log("waiting on chef data bag to update")
+        sleep(1)
+      end
+      log("updated chef data bag item $#{databag}/#{item_path}$ from $#{databag_path}$")
+    end
   end
 
 ################################################################################

data/lib/cucumber/chef/helpers/command.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");
@@ -24,29 +24,45 @@ module Cucumber::Chef::Helpers::Command
 ################################################################################
 
   def command_run_remote(name, command, expected_exit_code=0)
-    output = %x(ssh #{name} '#{command}' 2>&1)
-    raise "command_run_remote(#{command}) failed (#{$?})" if ($? != expected_exit_code)
+    command = %Q(ssh #{name} #{command} 2>&1)
+    logger.info { "command_run_remote(#{command})" }
+    output = %x(#{command})
+    if !expected_exit_code.nil? && ($? != expected_exit_code)
+      message = "command_run_remote(#{command}) failed (code=#{$?},output='#{output.chomp}')"
+      logger.fatal { message }
+      logger.fatal { "output(#{output.chomp})" }
+      raise message
+    end
     output
-#  rescue RuntimeError => e
-#    if $? == 65280
-#      puts "Exit Code #{$?}: Retrying..."
-#      retry
-#    end
   end
 
 ################################################################################
 
   def command_run_chroot(name, command, expected_exit_code=0)
-    output = %x(chroot #{container_root(name)} /bin/bash -c '#{command}' 2>&1)
-    raise "command_run_chroot(#{command}) failed (#{$?})" if ($? != expected_exit_code)
+    command = %Q(chroot #{container_root(name)} /bin/bash -c '#{command.gsub("'", '"')}' 2>&1)
+    logger.info { "command_run_chroot(#{command})" }
+    output = %x(#{command})
+    if !expected_exit_code.nil? && ($? != expected_exit_code)
+      message = "command_run_chroot(#{command}) failed (#{$?})"
+      logger.fatal { message }
+      logger.fatal { "output(#{output.chomp})" }
+      raise message
+    end
     output
   end
 
 ################################################################################
 
   def command_run_local(command, expected_exit_code=0)
-    output = %x(#{command} 2>&1)
-    raise "command_run_local(#{command}) failed (#{$?})" if ($? != expected_exit_code)
+    command = %Q(/bin/bash -c '#{command.gsub("'", '"')}' 2>&1)
+    logger.info { "command_run_local(#{command})" }
+    output = %x(#{command})
+    if !expected_exit_code.nil? && ($? != expected_exit_code)
+      message = "command_run_local(#{command}) failed (#{$?})"
+      logger.fatal { message }
+      logger.fatal { "output(#{output.chomp})" }
+      raise message
+    end
     output
   end
 

data/lib/cucumber/chef/helpers/container.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");
@@ -25,71 +25,74 @@ module Cucumber::Chef::Helpers::Container
 
   def container_create(name, distro, release, arch)
     unless container_exists?(name)
-      chef_server_node_destroy(name)
-      chef_server_client_destroy(name)
-
       cache_rootfs = container_cache_root(name, distro, release, arch)
-      log(name, "has triggered first time lxc distro cache build; this will take a while") if !File.exists?(cache_rootfs)
+      if !File.exists?(cache_rootfs)
+        log("$#{name}$ has triggered building the lxc file cache for $#{distro}$")
+        log("this one time process per distro can take up to 10 minutes or longer depending on the test lab hardware")
+      end
 
       command_run_local(container_create_command(name, distro, release, arch))
 
       # install omnibus into the distro/release file cache if it's not already there
-      omnibus_chef_client = File.join("/", "opt", "opscode", "bin", "chef-client")
-      if !File.exists?(File.join(cache_rootfs, omnibus_chef_client))
+      omnibus_chef_client = File.join("/", "opt", "chef", "bin", "chef-client")
+      omnibus_cache = File.join(cache_rootfs, omnibus_chef_client)
+      logger.info { "looking for omnibus cache in #{omnibus_cache}" }
+      if !File.exists?(omnibus_cache)
         case distro.downcase
         when "ubuntu" then
-          %x( chroot #{cache_rootfs} /bin/bash -c 'apt-get -y --force-yes install wget' 2>&1 )
+          command_run_local("chroot #{cache_rootfs} /bin/bash -c 'apt-get -y --force-yes install wget'")
         when "fedora" then
-          %x( yum --nogpgcheck --installroot=#{cache_rootfs} -y install wget openssh-server )
+          command_run_local("yum --nogpgcheck --installroot=#{cache_rootfs} -y install wget openssh-server")
         end
-        %x( chroot #{cache_rootfs} /bin/bash -c 'wget http://www.opscode.com/chef/install.sh -O - | bash' 2>&1 )
+        command_run_local("chroot #{cache_rootfs} /bin/bash -c 'wget http://www.opscode.com/chef/install.sh -O - | bash'")
         if distro.downcase == "fedora"
-          %x( chroot #{cache_rootfs} /bin/bash -c 'rpm -Uvh --nodeps /tmp/*rpm' 2>&1 )
+          command_run_local("chroot #{cache_rootfs} /bin/bash -c 'rpm -Uvh --nodeps /tmp/*rpm'")
         end
-        command_run_local("lxc-destroy -n #{name} 2>&1")
+        command_run_local("lxc-destroy -n #{name}")
         command_run_local(container_create_command(name, distro, release, arch))
       end
 
       command_run_local("mkdir -p #{container_root(name)}/root/.ssh")
       command_run_local("chmod 0755 #{container_root(name)}/root/.ssh")
       command_run_local("cat /root/.ssh/id_rsa.pub | tee -a #{container_root(name)}/root/.ssh/authorized_keys")
-      command_run_local("cat /home/ubuntu/.ssh/id_rsa.pub | tee -a #{container_root(name)}/root/.ssh/authorized_keys")
+      command_run_local("cat /home/#{Cucumber::Chef::Config[:lab_user]}/.ssh/id_rsa.pub | tee -a #{container_root(name)}/root/.ssh/authorized_keys")
 
-      command_run_local("mkdir -p #{container_root(name)}/home/ubuntu/.ssh")
-      command_run_local("chmod 0755 #{container_root(name)}/home/ubuntu/.ssh")
-      command_run_local("cat /root/.ssh/id_rsa.pub | tee -a #{container_root(name)}/home/ubuntu/.ssh/authorized_keys")
-      command_run_local("cat /home/ubuntu/.ssh/id_rsa.pub | tee -a #{container_root(name)}/home/ubuntu/.ssh/authorized_keys")
-      command_run_local("chown -R ubuntu:ubuntu #{container_root(name)}/home/ubuntu/.ssh")
+      command_run_local("mkdir -p #{container_root(name)}/home/#{Cucumber::Chef::Config[:lab_user]}/.ssh")
+      command_run_local("chmod 0755 #{container_root(name)}/home/#{Cucumber::Chef::Config[:lab_user]}/.ssh")
+      command_run_local("cat /root/.ssh/id_rsa.pub | tee -a #{container_root(name)}/home/#{Cucumber::Chef::Config[:lab_user]}/.ssh/authorized_keys")
+      command_run_local("cat /home/#{Cucumber::Chef::Config[:lab_user]}/.ssh/id_rsa.pub | tee -a #{container_root(name)}/home/#{Cucumber::Chef::Config[:lab_user]}/.ssh/authorized_keys")
+      command_run_local("chown -R #{Cucumber::Chef::Config[:lab_user]}:#{Cucumber::Chef::Config[:lab_user]} #{container_root(name)}/home/#{Cucumber::Chef::Config[:lab_user]}/.ssh")
 
       command_run_local("rm #{container_root(name)}/etc/motd")
       command_run_local("cp /etc/motd #{container_root(name)}/etc/motd")
-      command_run_local("echo \"    You are now logged in to the LXC '#{name}'\\n\" >> #{container_root(name)}/etc/motd")
-      command_run_local("sed -i \"s/localhost #{name}/#{name}.test-lab #{name} localhost/\" #{container_root(name)}/etc/hosts")
-      command_run_local("echo \"#{name}.test-lab\" | tee #{container_root(name)}/etc/hostname")
+      command_run_local("echo '    You are now logged in to the #{name} container!\n' >> #{container_root(name)}/etc/motd")
+      command_run_local("sed -i 's/localhost #{name}/#{name}.test-lab #{name} localhost/' #{container_root(name)}/etc/hosts")
+      command_run_local("echo '#{name}.test-lab' | tee #{container_root(name)}/etc/hostname")
     end
     container_start(name)
   end
 
   def container_destroy(name)
     if container_exists?(name)
-      container_stop(name)
-      command_run_local("lxc-destroy -n #{name} 2>&1")
       chef_server_node_destroy(name)
       chef_server_client_destroy(name)
+      container_stop(name)
+      command_run_local("lxc-destroy -n #{name}")
+      log("destroyed container $#{name}$")
     end
   end
 
 ################################################################################
 
   def container_start(name)
-    status = command_run_local("lxc-info -n #{name} 2>&1")
+    status = command_run_local("lxc-info -n #{name}")
     if status.include?("STOPPED")
       command_run_local("lxc-start -d -n #{name}")
     end
   end
 
   def container_stop(name)
-    status = command_run_local("lxc-info -n #{name} 2>&1")
+    status = command_run_local("lxc-info -n #{name}")
     if status.include?("RUNNING")
       command_run_local("lxc-stop -n #{name}")
     end
@@ -98,7 +101,7 @@ module Cucumber::Chef::Helpers::Container
 ################################################################################
 
   def container_running?(name)
-    status = command_run_local("lxc-info -n #{name} 2>&1")
+    status = command_run_local("lxc-info -n #{name}")
     status.include?("RUNNING")
   end
 

data/lib/cucumber/chef/helpers/minitest.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");