cucumber-chef 2.1.0.rc.15 → 3.0.0.rc.0

data/bin/cc-knife

@@ -10,15 +10,7 @@ Cucumber::Chef.boot(tag)
 
 ui = ZTK::UI.new(:logger => Cucumber::Chef.logger)
 if (test_lab = Cucumber::Chef::TestLab.new(ui)) && test_lab.alive?
-
-  knife_rb = Cucumber::Chef.knife_rb
-  if File.exists?(knife_rb)
-    test_lab.knife_cli([ARGV], :replace_current_process => true)
-  else
-    puts("Could not find your Cucumber-Chef 'knife.rb'.  Did you setup your test lab?")
-    exit(2)
-  end
-
+  test_lab.knife_cli([ARGV], :replace_current_process => true)
 else
   puts("No running cucumber-chef test labs to connect to!")
   exit(1)

data/bin/cucumber-chef

@@ -296,6 +296,20 @@ class CucumberChef < Thor
     fatal(e)
   end
 
+  desc "genmac", "Generate a private MAC address"
+  def genmac
+    boot
+
+    puts Cucumber::Chef::Containers.generate_mac
+  end
+
+  desc "genip", "Generate a private IP address"
+  def genip
+    boot
+
+    puts Cucumber::Chef::Containers.generate_ip
+  end
+
 ################################################################################
 # STATUS
 ################################################################################
@@ -311,27 +325,24 @@ class CucumberChef < Thor
       if @options.containers?
         if test_lab.alive?
 
-          test_lab.containers.load
-
           if test_lab.containers.count > 0
-            headers = [:name, :alive, :arch, :distro, :ip, :mac, :"chef version", :persist]
-            results = ZTK::Report.new.spreadsheet(test_lab.containers.to_a, headers) do |name, detail|
+            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 #{detail[:ip]}}, :silence => true).exit_code == 0)
+              alive = (test_lab.bootstrap_ssh(:ignore_exit_status => true).exec(%Q{ping -n -c 1 -W 1 #{container.ip}}, :silence => true).exit_code == 0)
               if alive
-                chef_version = test_lab.proxy_ssh(name, :ignore_exit_status => true).exec(%Q{/usr/bin/env chef-client -v}, :silence => true).output.chomp
+                chef_version = test_lab.proxy_ssh(container.name, :ignore_exit_status => true).exec(%Q{/usr/bin/env chef-client -v}, :silence => true).output.chomp
               end
 
               OpenStruct.new(
-                :name => name,
-                :ip => detail[:ip],
-                :mac => detail[:mac],
-                :distro => detail[:distro],
-                :arch => detail[:arch],
+                :name => container.name,
+                :ip => container.ip,
+                :mac => container.mac,
+                :distro => container.distro,
                 :alive => alive,
                 :"chef version" => chef_version,
-                :persist => detail[:persist],
-                :chef_attributes => detail[:chef_client]
+                :persist => container.persist,
+                :chef_attributes => container.chef_client
               )
             end
 
@@ -502,10 +513,11 @@ class CucumberChef < Thor
       "log_file" => Cucumber::Chef.log_file,
       "artifacts_dir" => Cucumber::Chef.artifacts_dir,
       "config_rb" => Cucumber::Chef.config_rb,
-      "containers_bin" => Cucumber::Chef.containers_bin,
-      "knife_rb" => Cucumber::Chef.knife_rb,
+      "labfile" => Cucumber::Chef.labfile,
       "chef_repo" => Cucumber::Chef.chef_repo,
       "bootstrap_identity" => Cucumber::Chef.bootstrap_identity,
+      "chef_user" => Cucumber::Chef.chef_user,
+      "chef_identity" => Cucumber::Chef.chef_identity,
       "lab_user" => Cucumber::Chef.lab_user,
       "lab_user_home_dir" => Cucumber::Chef.lab_user_home_dir,
       "lab_identity" => Cucumber::Chef.lab_identity,

data/chef_repo/cookbooks/cucumber-chef/recipes/test_lab.rb

@@ -117,10 +117,10 @@ end
 # CHEF-SOLR / APACHE SOLR
 ################################################################################
 
-template "install custom solr config" do
-  path "/var/lib/chef/solr/conf/solrconfig.xml"
-  source "solrconfig.erb"
-  owner "chef"
-  group "chef"
-  mode "0644"
-end
+# template "install custom solr config" do
+#   path "/var/lib/chef/solr/conf/solrconfig.xml"
+#   source "solrconfig.erb"
+#   owner "chef"
+#   group "chef"
+#   mode "0644"
+# end

data/cucumber-chef.gemspec

@@ -34,9 +34,6 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = ">= 1.3.6"
   s.licenses = ["Apache 2.0"]
 
-  # Chef
-  s.add_dependency("chef", ">= 0.10.0")
-
   # Providers
   s.add_dependency("fog", ">= 1.3.1")
 
@@ -49,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.2")
+  s.add_dependency("ztk", ">= 1.0.3")
 
   s.add_development_dependency("simplecov", ">= 0.6.4")
   s.add_development_dependency("pry", ">= 0")

data/lib/cucumber-chef/rake/task.rb

@@ -6,54 +6,73 @@ namespace :cc do
 
   desc "Run features in a style suitable for Continuous Integration"
   task :ci do |t|
-    pushed = false
-    exit_codes = Array.new
 
-    puts("Cleaning up...")
-    system(%Q{rm -rfv artifacts})
-    system(%Q{rm -rfv public})
-    system(%Q{mkdir -v public})
-    system(%Q{echo "<html><head><title>Cucumber-Chef Report</title></head><body>" | tee public/index.html})
-    system(%Q{echo "<h2>Cucumber-Chef Report</h2><ul>" | tee -a public/index.html})
+    def feature_dir(dir, &block)
+      puts("=" * 80)
+      puts("feature_dir(#{dir.inspect})")
+      puts("=" * 80)
 
-    puts("Generating Cucumber-Chef html reports...")
-    Dir.glob("features/*").each do |feature_dir|
-      found_features = false
-      Dir.glob("#{feature_dir}/*.feature") do |feature|
-        if found_features == false
-          found_features = true
-          system(%Q{echo "<li /><p>#{File.basename(feature_dir)}<ul>" | tee -a public/index.html})
-        end
-        filename = feature.gsub(/(\w*).feature/, '\1.html')
-        puts("#{feature} -> public/#{filename}")
+      system(%Q{echo "<li /><p>#{File.basename(dir)}<ul>" | tee -a #{@index_html}})
+      block.call
+      system(%Q{echo "</p></ul>" | tee -a #{@index_html}})
+    end
 
-        system(%Q{mkdir -pv #{File.dirname("public/#{filename}")}})
+    def run_feature(feature_file)
+      puts("=" * 80)
+      puts("run_feature(#{feature_file.inspect})")
+      puts("=" * 80)
 
-        push = (pushed ? nil : %Q{PUSH="YES"})
-        command = [push, "bundle exec cucumber", "features/support", feature, ENV['EXTRA_CUCUMBER_ARGS'], "--format html", "--out public/#{filename}"].flatten.compact.join(" ")
-        pushed = true if !pushed
-        puts("command=#{command.inspect}")
-        system(command)
-        exit_codes << $?.exitstatus
+      filename = feature_file.gsub(/(\w*).feature/, '\1.html')
+      puts("#{feature_file} -> public/#{filename}")
 
-        passed = "<font style='font-weight: bold; color: green;'>PASSED</font>"
-        failed = "<font style='font-weight: bold; color: red;'>FAILED</font>"
-        status = ((exit_codes[-1] == 0) ? passed : failed)
+      system(%Q{mkdir -pv #{File.dirname("public/#{filename}")}})
 
-        system(%Q{echo "<li /><a href='#{filename}'>#{File.basename(filename.gsub('.html', ''))}</a> (#{status})" | tee -a public/index.html})
-      end
+      push = (@pushed ? nil : %Q{SETUP="YES"})
+      output_file = File.join(@output_dir, filename)
+      command = [push, "bundle exec cucumber", "features/support", feature_file, ENV['EXTRA_CUCUMBER_ARGS'], "--format html", "--out", output_file].flatten.compact.join(" ")
+      @pushed = true if !@pushed
+      puts("command=#{command.inspect}")
+      system(command)
+      @exit_codes << $?.exitstatus
 
-      if found_features
-        system(%Q{echo "</p></ul>" | tee -a public/index.html})
-      end
+      passed = "<font style='font-weight: bold; color: green;'>PASSED</font>"
+      failed = "<font style='font-weight: bold; color: red;'>FAILED</font>"
+      status = ((@exit_codes[-1] == 0) ? passed : failed)
+
+      system(%Q{echo "<li /><a href='#{filename}'>#{File.basename(filename.gsub('.html', ''))}</a> (#{status})" | tee -a #{@index_html}})
     end
 
-    system(%Q{echo "</ul></body></html>" | tee -a public/index.html})
+    @output_dir = File.join(Dir.pwd, "public")
+    @index_html = File.join(@output_dir, "index.html")
+    @pushed = false
+    @exit_codes = Array.new
 
-    system(%Q{/bin/bash -c '[[ -d $CUCUMBER_CHEF_HOME/aws/artifacts ]] && mv -v $CUCUMBER_CHEF_HOME/aws/artifacts .'})
+    puts("Cleaning up...")
+    system(%Q{rm -rfv .cucumber-chef/aws/artifacts})
+    system(%Q{rm -rfv public})
+    system(%Q{mkdir -v public})
+
+    puts("Generating Cucumber-Chef html reports...")
+
+    system(%Q{echo "<html><head><title>Cucumber-Chef Report</title></head><body>" | tee public/index.html})
+    system(%Q{echo "<h2>Cucumber-Chef Report</h2><ul>" | tee -a public/index.html})
+    Dir.glob("features/*").each do |fdir|
+      if File.directory?(fdir)
+        if (ffiles = Dir.glob("#{fdir}/*.feature")).count > 0
+          feature_dir(fdir) do
+            ffiles.each do |ffile|
+              run_feature(ffile)
+            end
+          end
+        end
+      else
+        run_feature(fdir)
+      end
+    end
+    system(%Q{echo "</ul></body></html>" | tee -a public/index.html})
 
     # If we had a failure be sure to surface it
-    exit_code = (exit_codes.any?{ |ec| ec != 0 } ? 1 : 0)
+    exit_code = (@exit_codes.any?{ |ec| ec != 0 } ? 1 : 0)
     exit(exit_code)
   end
 

data/lib/cucumber/chef.rb

@@ -23,9 +23,6 @@ require 'benchmark'
 
 ################################################################################
 
-require 'chef'
-require 'chef/cookbook_uploader'
-
 require 'fog'
 
 require 'json'
@@ -44,7 +41,10 @@ module Cucumber
 
     autoload :Client, 'cucumber/chef/client'
     autoload :Config, 'cucumber/chef/config'
+    autoload :Container, 'cucumber/chef/container'
     autoload :Containers, 'cucumber/chef/containers'
+    autoload :Ecosystem, 'cucumber/chef/ecosystem'
+    autoload :Labfile, 'cucumber/chef/labfile'
     autoload :Provider, 'cucumber/chef/provider'
     autoload :Provisioner, 'cucumber/chef/provisioner'
     autoload :TestLab, 'cucumber/chef/test_lab'

data/lib/cucumber/chef/container.rb

@@ -0,0 +1,44 @@
+################################################################################
+#
+#      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
+#      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.
+#
+################################################################################
+
+module Cucumber
+  module Chef
+
+    class ContainerError < Error; end
+
+    class Container < ZTK::DSL::Base
+      belongs_to :ecosystem, :class_name => "Cucumber::Chef:Ecosystem"
+
+      attribute :name
+      attribute :ip
+      attribute :mac
+      attribute :persist
+      attribute :distro
+      attribute :release
+      attribute :arch
+      attribute :roles
+      attribute :chef_client
+    end
+
+  end
+end
+
+################################################################################

data/lib/cucumber/chef/containers.rb

@@ -18,6 +18,7 @@
 #   limitations under the License.
 #
 ################################################################################
+require 'tempfile'
 
 module Cucumber
   module Chef
@@ -25,6 +26,7 @@ module Cucumber
     class ContainersError < Error; end
 
     class Containers
+
 ################################################################################
 
       def initialize(ui=ZTK::UI.new, test_lab=nil)
@@ -34,104 +36,59 @@ module Cucumber
 ################################################################################
 
       def count
-        @containers.count
-      end
-
-      def to_a
-        @containers
-      end
-
-################################################################################
-
-      def load
-        @ui.logger.debug { "Reading '#{Cucumber::Chef.containers_bin}'." }
-        @containers = ((Marshal.load(IO.read(Cucumber::Chef.containers_bin)) rescue Hash.new) || Hash.new)
-
-        @ui.logger.info { "-" * 8 }
-        @containers.each do |key, value|
-          @ui.logger.info { "LOAD CONTAINER: #{key.inspect} => #{value.inspect}" }
-        end
+        Container.count
       end
 
 ################################################################################
 
-      def save
-        @ui.logger.debug { "Writing '#{Cucumber::Chef.containers_bin}'." }
-        @ui.logger.info { "-" * 8 }
-        @containers.each do |key, value|
-          @ui.logger.info { "SAVE CONTAINER: #{key.inspect} => #{value.inspect}" }
-        end
-
-        File.open(Cucumber::Chef.containers_bin, 'w') do |f|
-          f.puts(Marshal.dump(@containers))
-        end
-      end
-
-################################################################################
-
-      def init(name)
-        @containers[name] ||= Hash.new
-        @containers[name][:chef_client] = nil
-      end
-
-################################################################################
+      def create(container)
+        # if this is a new or non-persistent container destroy it
+        destroy(container.name) if !container.persist
 
-      def create(name)
-        init(name)
+        container.ip ||= self.generate_ip
+        container.mac ||= self.generate_mac
+        container.persist ||= false
+        container.distro ||= "ubuntu"
+        container.release ||= "lucid"
+        container.arch = detect_arch(container.distro || "ubuntu")
 
-        # if this is a new or non-persistent container destroy it
-        destroy(name) if !@containers[name][:persist]
-
-        attributes = @containers[name]
-        @containers[name] = {
-          :ip => generate_ip,
-          :mac => generate_mac,
-          :persist => true,
-          :distro => "ubuntu",
-          :release => "lucid",
-        }.merge(attributes).merge(:arch => detect_arch(attributes[:distro] || "ubuntu"))
-
-        if running?(name)
-          @ui.logger.info { "Container '#{name}' is already running." }
+        if running?(container.name)
+          @ui.logger.info { "Container '#{container.name}' is already running." }
         else
-          @ui.logger.info { "Please wait, creating container {#{name.inspect} => #{tag(name)}}." }
+          @ui.logger.info { "Please wait, creating container #{container.inspect}." }
           bm = ::Benchmark.realtime do
             test_lab_config_dhcpd
-            config_network(name)
-            _create(name, @containers[name][:distro], @containers[name][:release], @containers[name][:arch])
+            config_network(container)
+            _create(container.name, container.distro, container.release, container.arch)
           end
-          @ui.logger.info { "Container '#{name}' creation took %0.4f seconds." % bm }
+          @ui.logger.info { "Container '#{container.name}' creation took %0.4f seconds." % bm }
 
-          # bm = ::Benchmark.realtime do
-          #   ZTK::TCPSocketCheck.new(:host => @containers[name][:ip], :port => 22).wait
-          # end
-          # @ui.logger.info { "Container '#{name}' SSHD responded after %0.4f seconds." % bm }
+          bm = ::Benchmark.realtime do
+            ZTK::RescueRetry.try(:tries => 32) do
+              @test_lab.ssh.exec("host #{container.name}", :silence => true)
+            end
+            ZTK::RescueRetry.try(:tries => 32) do
+              @test_lab.proxy_ssh(container.name).exec("uptime", :silence => true)
+            end
+          end
+          @ui.logger.info { "Container '#{container.name}' SSHD responded after %0.4f seconds." % bm }
         end
-
-        save
       end
 
 ################################################################################
 
       def destroy(name)
+        @test_lab.knife_cli("node delete #{name}", :ignore_exit_status => true)
+        @test_lab.knife_cli("client delete #{name}", :ignore_exit_status => true)
+
         if exists?(name)
-          @test_lab.knife_cli("node delete #{name} --yes", :ignore_exit_status => true)
-          @test_lab.knife_cli("client delete #{name} --yes", :ignore_exit_status => true)
           stop(name)
           @test_lab.bootstrap_ssh.exec("sudo lxc-destroy -n #{name}", :silence => true)
           @ui.logger.info { "Destroyed container '#{name}'." }
           test_lab_config_dhcpd
-          @containers.delete(name)
-          save
         end
       end
 
-################################################################################
-
-      def set_attributes(name, attributes={})
-        @containers[name].merge!(attributes)
-      end
-
 ################################################################################
 
       def chef_set_client_config(config={})
@@ -151,41 +108,30 @@ module Cucumber
 
 ################################################################################
 
-      def chef_set_client_attributes(name, attributes={})
-        @containers[name] ||= Hash.new
-        @containers[name][:chef_client] = (@containers[name][:chef_client] || {}).merge(attributes) { |k,o,n| (k = (o + n).uniq) }
-
-        @ui.logger.info { "Setting chef client attributes to '#{@containers[name][:chef_client].inspect}' for container '#{name}'." }
-
-        true
-      end
-
-################################################################################
-
-      def chef_run_client(name, *args)
-        chef_config_client(name)
+      def chef_run_client(container, *args)
+        chef_config_client(container)
 
         @ui.logger.info { "Removing artifacts #{Cucumber::Chef::Config[:artifacts].values.collect{|z| "'#{z}'" }.join(' ')}." }
-        (@test_lab.proxy_ssh(name).exec("/bin/rm -fv #{Cucumber::Chef::Config[:artifacts].values.join(' ')}", :silence => true) rescue nil)
+        (@test_lab.proxy_ssh(container.name).exec("/bin/rm -fv #{Cucumber::Chef::Config[:artifacts].values.join(' ')}", :silence => true) rescue nil)
 
-        @ui.logger.info { "Running chef client on container '#{name}'." }
+        @ui.logger.info { "Running chef client on container '#{container.name}'." }
 
         arguments = {
-          "--node-name" => name,
+          "--node-name" => container.name,
           "--json-attributes" => File.join("/etc", "chef", "attributes.json").to_s,
           "--log_level" => @chef_client_config[:log_level],
           "--logfile" => @chef_client_config[:log_location],
           "--server" => @chef_client_config[:chef_server_url],
-          "--environment" => @chef_client_config[:environment]
+          "--environment" => (container.chef_client[:environment] || @chef_client_config[:environment])
         }.reject{ |k,v| v.nil? }.sort
 
         output = nil
         bm = ::Benchmark.realtime do
-          output = @test_lab.proxy_ssh(name).exec(["/usr/bin/chef-client", arguments, args, "--once"].flatten.join(" "), :silence => true)
+          output = @test_lab.proxy_ssh(container.name).exec(["/usr/bin/chef-client", arguments, args, "--once"].flatten.join(" "), :silence => true)
         end
-        @ui.logger.info { "Chef client run on container '#{name}' took %0.4f seconds." % bm }
+        @ui.logger.info { "Chef client run on container '#{container.name}' took %0.4f seconds." % bm }
 
-        chef_client_artifacts(name)
+        chef_client_artifacts(container)
 
         output
       end
@@ -203,6 +149,50 @@ module Cucumber
         test_result
       end
 
+################################################################################
+      class << self
+
+        def generate_ip
+          octets = [ 192..192,
+                     168..168,
+                     0..254,
+                     1..254 ]
+          ip = Array.new
+          for x in 1..4 do
+            ip << octets[x-1].to_a[rand(octets[x-1].count)].to_s
+          end
+          ip.join(".")
+        end
+
+        def generate_mac
+          digits = [ %w(0),
+                     %w(0),
+                     %w(0),
+                     %w(0),
+                     %w(5),
+                     %w(e),
+                     %w(0 1 2 3 4 5 6 7 8 9 a b c d e f),
+                     %w(0 1 2 3 4 5 6 7 8 9 a b c d e f),
+                     %w(5 6 7 8 9 a b c d e f),
+                     %w(3 4 5 6 7 8 9 a b c d e f),
+                     %w(0 1 2 3 4 5 6 7 8 9 a b c d e f),
+                     %w(0 1 2 3 4 5 6 7 8 9 a b c d e f) ]
+          mac = ""
+          for x in 1..12 do
+            mac += digits[x-1][rand(digits[x-1].count)]
+            mac += ":" if (x.modulo(2) == 0) && (x != 12)
+          end
+          mac
+        end
+
+      end
+
+################################################################################
+
+      def list
+        @test_lab.bootstrap_ssh.exec("sudo lxc-ls 2>&1", :silence => true).output.split("\n").uniq
+      end
+
 ################################################################################
     private
 ################################################################################
@@ -276,9 +266,9 @@ module Cucumber
 
 ################################################################################
 
-      def chef_config_client(name)
-        tempfile = Tempfile.new(name)
-        client_rb = File.join("/", root(name), "etc/chef/client.rb")
+      def chef_config_client(container)
+        tempfile = Tempfile.new(container.name)
+        client_rb = File.join("/", root(container.name), "etc/chef/client.rb")
 
         @test_lab.bootstrap_ssh.exec(%Q{sudo mkdir -pv #{File.dirname(client_rb)}}, :silence => true)
 
@@ -288,7 +278,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 => name).each do |(key,value)|
+            @chef_client_config.merge(:node_name => container.name).each do |(key,value)|
               next if value.nil?
               f.puts("%-#{max_key_size}s  %s" % [key, value.inspect])
             end
@@ -301,59 +291,43 @@ module Cucumber
           @test_lab.bootstrap_ssh.exec(%Q{sudo /bin/bash -c '[[ -f #{client_rb} ]] && rm -fv #{client_rb}'}, :silence => true, :ignore_exit_status => true)
         end
 
-        tempfile = Tempfile.new(name)
-        attributes_json = File.join("/", root(name), "etc", "chef", "attributes.json")
+        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)
         File.open(tempfile, 'w') do |f|
-          f.puts((@containers[name][:chef_client] || {}).to_json)
+          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)
 
         # make sure our log location is there
-        log_location = File.join("/", root(name), @chef_client_config[:log_location])
+        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)
 
-        @test_lab.bootstrap_ssh.exec(%Q{sudo cp /etc/chef/validation.pem #{root(name)}/etc/chef/}, :silence => true)
+        @test_lab.bootstrap_ssh.exec(%Q{sudo cp /etc/chef/validation.pem #{root(container.name)}/etc/chef/}, :silence => true)
 
         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 = @test_lab.proxy_ssh(name)
-
-        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]
+      def chef_client_artifacts(container)
+        ssh = @test_lab.proxy_ssh(container.name)
 
         Cucumber::Chef::Config[:artifacts].each do |label, remote_path|
           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 '#{name}'." }
+            @ui.logger.info { "Retrieving artifact '#{remote_path}' from container '#{container.name}'." }
 
-            local_path = File.join(Cucumber::Chef.artifacts_dir, feature_dir, "#{feature_name}.txt")
+            local_path = File.join(Cucumber::Chef.artifacts_dir, "#{container.name}.log")
             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")
+            f = File.open(local_path, "w")
+            f.write(data)
 
             File.chmod(0644, local_path)
           end
@@ -364,9 +338,9 @@ module Cucumber
 
 ################################################################################
 
-      def config_network(name)
-        tempfile = Tempfile.new(name)
-        lxc_network_config = File.join("/etc/lxc", name)
+      def config_network(container)
+        tempfile = Tempfile.new(container.name)
+        lxc_network_config = File.join("/etc/lxc", container.name)
         File.open(tempfile, 'w') do |f|
           f.puts(Cucumber::Chef.generate_do_not_edit_warning("LXC Container Configuration"))
           f.puts("")
@@ -374,7 +348,7 @@ module Cucumber
           f.puts("lxc.network.flags = up")
           f.puts("lxc.network.link = br0")
           f.puts("lxc.network.name = eth0")
-          f.puts("lxc.network.hwaddr = #{@containers[name][:mac]}")
+          f.puts("lxc.network.hwaddr = #{container.mac}")
           f.puts("lxc.network.ipv4 = 0.0.0.0")
         end
         @test_lab.bootstrap_ssh.upload(tempfile.path, File.basename(tempfile.path))
@@ -388,14 +362,14 @@ module Cucumber
         dhcpd_config = File.join("/etc/dhcp/test-lab.conf")
         File.open(tempfile, 'w') do |f|
           f.puts(Cucumber::Chef.generate_do_not_edit_warning("DHCPD Configuration"))
-          @containers.each do |key, value|
-            next if [:mac, :ip].any?{ |z| value[z].nil? }
+          Container.all.each do |container|
+            next if [container.mac, container.ip].any?{ |z| z.nil? }
 
             f.puts
-            f.puts("host #{key} {")
-            f.puts("  hardware ethernet #{value[:mac]};")
-            f.puts("  fixed-address #{value[:ip]};")
-            f.puts("  ddns-hostname \"#{key}\";")
+            f.puts("host #{container.name} {")
+            f.puts("  hardware ethernet #{container.mac};")
+            f.puts("  fixed-address #{container.ip};")
+            f.puts("  ddns-hostname \"#{container.name}\";")
             f.puts("}")
           end
           f.flush
@@ -410,10 +384,6 @@ module Cucumber
 
 ################################################################################
 
-      def tag(name)
-        @containers[name].inspect.to_s
-      end
-
       def detect_arch(distro)
         @arch ||= @test_lab.bootstrap_ssh.exec("uname -m", :silence => true).output.chomp
         case distro.downcase
@@ -424,12 +394,6 @@ module Cucumber
         end
       end
 
-################################################################################
-
-      def containers
-        @test_lab.bootstrap_ssh.exec("sudo lxc-ls 2>&1", :silence => true).output.split("\n").uniq
-      end
-
 ################################################################################
 
       def running?(name)
@@ -471,43 +435,6 @@ module Cucumber
         end
       end
 
-################################################################################
-
-      def generate_ip
-        octets = [ 192..192,
-                   168..168,
-                   0..254,
-                   1..254 ]
-        ip = Array.new
-        for x in 1..4 do
-          ip << octets[x-1].to_a[rand(octets[x-1].count)].to_s
-        end
-        ip.join(".")
-      end
-
-################################################################################
-
-      def generate_mac
-        digits = [ %w(0),
-                   %w(0),
-                   %w(0),
-                   %w(0),
-                   %w(5),
-                   %w(e),
-                   %w(0 1 2 3 4 5 6 7 8 9 a b c d e f),
-                   %w(0 1 2 3 4 5 6 7 8 9 a b c d e f),
-                   %w(5 6 7 8 9 a b c d e f),
-                   %w(3 4 5 6 7 8 9 a b c d e f),
-                   %w(0 1 2 3 4 5 6 7 8 9 a b c d e f),
-                   %w(0 1 2 3 4 5 6 7 8 9 a b c d e f) ]
-        mac = ""
-        for x in 1..12 do
-          mac += digits[x-1][rand(digits[x-1].count)]
-          mac += ":" if (x.modulo(2) == 0) && (x != 12)
-        end
-        mac
-      end
-
 ################################################################################
 
     end