cucumber-chef 2.1.0.rc.6 → 2.1.0.rc.7

data/bin/cc-knife

@@ -4,12 +4,12 @@ require 'cucumber-chef'
 # if we have bundler binstubs use that; otherwise attempt to detect
 knife = (Cucumber::Chef.locate(:file, "bin", "knife") rescue "/usr/bin/env knife")
 
-message = "cc-knife v#{Cucumber::Chef::VERSION}"
-puts(message)
-Cucumber::Chef.logger.info { message }
+tag = Cucumber::Chef.tag("cc-knife")
+puts(tag)
+Cucumber::Chef.boot(tag)
 
-Cucumber::Chef::Config.load
-if (test_lab = Cucumber::Chef::TestLab.new) && test_lab.alive?
+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)

data/bin/cc-push

@@ -4,14 +4,14 @@ require 'cucumber-chef'
 tag = Cucumber::Chef.tag("cc-push")
 puts(tag)
 Cucumber::Chef.boot(tag)
-$logger = Cucumber::Chef.logger
 
-if ($test_lab = Cucumber::Chef::TestLab.new) && $test_lab.alive?
+ui = ZTK::UI.new(:logger => Cucumber::Chef.logger)
+if (test_lab = Cucumber::Chef::TestLab.new(ui)) && test_lab.alive?
   gem_name = "cucumber-chef-#{Cucumber::Chef::VERSION}.gem"
   gem_path = File.join(Cucumber::Chef.root_dir, gem_name)
 
-  $logger.info { "gem_name == '#{gem_name}'" }
-  $logger.info { "gem_path == '#{gem_path}'" }
+  ui.logger.info { "gem_name == '#{gem_name}'" }
+  ui.logger.info { "gem_path == '#{gem_path}'" }
 
   if !File.exists?(gem_path)
     puts
@@ -21,13 +21,13 @@ if ($test_lab = Cucumber::Chef::TestLab.new) && $test_lab.alive?
     puts
   else
     local_file = File.join(Cucumber::Chef.root_dir, gem_name)
-    remote_file = File.join("/", "home", $test_lab.ssh.config.user, gem_name)
-    $logger.info { "#{local_file} -> #{$test_lab.ssh.config.user}@#{$test_lab.ip}:#{remote_file}" }
+    remote_file = File.join("/", "home", test_lab.bootstrap_ssh.config.user, gem_name)
+    ui.logger.info { "#{local_file} -> #{test_lab.bootstrap_ssh.config.user}@#{test_lab.ip}:#{remote_file}" }
 
-    $test_lab.ssh.upload(local_file, remote_file)
+    test_lab.bootstrap_ssh.upload(local_file, remote_file)
     FileUtils.rm_f(File.join(Cucumber::Chef.root_dir, "*.gem"))
 
-    $test_lab.ssh.exec(<<-EOH
+    test_lab.bootstrap_ssh.exec(<<-EOH
 sudo /bin/bash -c '
 pkill -9 cc-server
 cd #{File.dirname(remote_file)}
@@ -36,11 +36,11 @@ gem uninstall cucumber-chef ztk --all --ignore-dependencies --executables --back
 rm -fv /usr/lib/ruby/gems/1.8/cache/#{gem_name}
 gem cleanup cucumber-chef --backtrace
 gem install #{remote_file} --backtrace
-rm -fv /home/#{$test_lab.ssh.config.user}/*.gem
+rm -fv /home/#{test_lab.bootstrap_ssh.config.user}/*.gem
 exit 0'
 EOH
     )
-    File.exists?(gem_path) && File.delete(gem_path)
+    File.exists?(gem_path) and File.delete(gem_path)
   end
 
 else

data/cucumber-chef.gemspec

@@ -51,7 +51,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", ">= 0.0.15")
+  s.add_dependency("ztk", ">= 1.0.0")
 
   s.add_development_dependency("simplecov", ">= 0.6.4")
   s.add_development_dependency("pry", ">= 0")

data/lib/cucumber/chef/client.rb

@@ -24,15 +24,13 @@ module Cucumber
     class ClientError < Error; end
 
     class Client
-      attr_accessor :test_lab, :stdout, :stderr, :stdin, :logger
+      attr_accessor :test_lab
 
 ################################################################################
 
-      def initialize(test_lab, stdout=STDOUT, stderr=STDERR, stdin=STDIN, logger=$logger)
-        @stdout, @stderr, @stdin, @logger = stdout, stderr, stdin, logger
-        @stdout.sync = true if @stdout.respond_to?(:sync=)
-
+      def initialize(test_lab, ui=ZTK::UI.new)
         @test_lab = test_lab
+        @ui = ui
       end
 
 ################################################################################
@@ -124,7 +122,7 @@ module Cucumber
 ################################################################################
 
       def at_exit
-        @logger.fatal { "Waiting for cc-server to shutdown." }
+        @ui.logger.fatal { "Waiting for cc-server to shutdown." }
         self.down
         @background.wait
       end

data/lib/cucumber/chef/config.rb

@@ -184,7 +184,8 @@ module Cucumber
       vagrant           ({:lab_user => "vagrant",
                           :lxc_user => "root"})
 
-      chef              ({:amqp_password => "p@ssw0rd1",
+      chef              ({:version => "10.18.2",
+                          :amqp_password => "p@ssw0rd1",
                           :admin_password => "p@ssw0rd1"})
 
       test_lab          ({:hostname => "cucumber-chef",

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

@@ -73,7 +73,8 @@ module Cucumber::Chef::Helpers::Container
           commands << "yum --nogpgcheck --installroot=#{cache_rootfs} -y install wget openssh-server"
         end
         commands << "chroot #{cache_rootfs} /bin/bash -c 'locale-gen en_US'"
-        commands << "chroot #{cache_rootfs} /bin/bash -c 'wget http://www.opscode.com/chef/install.sh -O - | bash'"
+        commands << "chroot #{cache_rootfs} /bin/bash -c 'wget http://www.opscode.com/chef/install.sh'"
+        commands << "chroot #{cache_rootfs} /bin/bash -c 'bash install.sh -v #{Cucumber::Chef::Config.chef[:version]}'"
         if distro.downcase == "fedora"
           commands << "chroot #{cache_rootfs} /bin/bash -c 'rpm -Uvh --nodeps /tmp/*rpm'"
         end

data/lib/cucumber/chef/provider.rb

@@ -27,21 +27,18 @@ module Cucumber
     class ProviderError < Error; end
 
     class Provider
-      attr_accessor :stdout, :stderr, :stdin, :logger
-
       PROXY_METHODS = %w(create destroy up halt reload status id state username ip port chef_server_api chef_server_webui alive? dead? exists?)
 
 ################################################################################
 
-      def initialize(stdout=STDOUT, stderr=STDERR, stdin=STDIN, logger=$logger)
-        @stdout, @stderr, @stdin, @logger = stdout, stderr, stdin, logger
-        @stdout.sync = true if @stdout.respond_to?(:sync=)
+      def initialize(ui=ZTK::UI.new)
+        @ui = ui
 
         @provider = case Cucumber::Chef::Config.provider
         when :aws then
-          Cucumber::Chef::Provider::AWS.new(@stdout, @stderr, @stdin, @logger)
+          Cucumber::Chef::Provider::AWS.new(@ui)
         when :vagrant then
-          Cucumber::Chef::Provider::Vagrant.new(@stdout, @stderr, @stdin, @logger)
+          Cucumber::Chef::Provider::Vagrant.new(@ui)
         end
       end
 
@@ -79,8 +76,8 @@ module Cucumber
         end
 
       rescue Exception => e
-        Cucumber::Chef.logger.fatal { e.message }
-        Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+        @ui.logger.fatal { e.message }
+        @ui.logger.fatal { e.backtrace.join("\n") }
         raise ProviderError, e.message
       end
 
@@ -90,7 +87,7 @@ module Cucumber
         if Cucumber::Chef::Provider::PROXY_METHODS.include?(method_name.to_s)
           result = @provider.send(method_name.to_sym, *method_args)
           splat = [method_name, *method_args].flatten.compact
-          Cucumber::Chef.logger.debug { "Provider: #{splat.inspect}=#{result.inspect}" }
+          @ui.logger.debug { "Provider: #{splat.inspect}=#{result.inspect}" }
           result
         else
           super(method_name, *method_args)

data/lib/cucumber/chef/providers/aws.rb

@@ -25,7 +25,7 @@ module Cucumber
       class AWSError < Error; end
 
       class AWS
-        attr_accessor :connection, :server, :stdout, :stderr, :stdin, :logger
+        attr_accessor :connection, :server
 
         INVALID_STATES = %w(terminated pending).map(&:to_sym)
         RUNNING_STATES =  %w(running starting-up).map(&:to_sym)
@@ -34,9 +34,8 @@ module Cucumber
 
 ################################################################################
 
-        def initialize(stdout=STDOUT, stderr=STDERR, stdin=STDIN, logger=$logger)
-          @stdout, @stderr, @stdin, @logger = stdout, stderr, stdin, logger
-          @stdout.sync = true if @stdout.respond_to?(:sync=)
+        def initialize(ui=ZTK::UI.new)
+          @ui = ui
 
           @connection = Fog::Compute.new(
             :provider => 'AWS',
@@ -55,7 +54,7 @@ module Cucumber
 
         def create
           if (exists? && alive?)
-            @stdout.puts("A test lab already exists using the #{Cucumber::Chef::Config.provider.upcase} credentials you have supplied; attempting to reprovision it.")
+            @ui.stdout.puts("A test lab already exists using the #{Cucumber::Chef::Config.provider.upcase} credentials you have supplied; attempting to reprovision it.")
           else
             server_definition = {
               :image_id => Cucumber::Chef::Config.aws_image_id,
@@ -68,7 +67,7 @@ module Cucumber
             }
 
             if (@server = @connection.servers.create(server_definition))
-              ZTK::Benchmark.bench(:message => "Creating #{Cucumber::Chef::Config.provider.upcase} instance", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+              ZTK::Benchmark.bench(:message => "Creating #{Cucumber::Chef::Config.provider.upcase} instance", :mark => "completed in %0.4f seconds.", :ui => @ui) do
                 @server.wait_for { ready? }
                 tag_server
                 ZTK::TCPSocketCheck.new(:host => self.ip, :port => self.port, :wait => 120).wait
@@ -79,8 +78,8 @@ module Cucumber
           self
 
         rescue Exception => e
-          Cucumber::Chef.logger.fatal { e.message }
-          Cucumber::Chef.logger.fatal { "Backtrace:\n#{e.backtrace.join("\n")}" }
+          @ui.logger.fatal { e.message }
+          @ui.logger.fatal { "Backtrace:\n#{e.backtrace.join("\n")}" }
           raise AWSError, e.message
         end
 
@@ -96,8 +95,8 @@ module Cucumber
           end
 
         rescue Exception => e
-          Cucumber::Chef.logger.fatal { e.message }
-          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          @ui.logger.fatal { e.message }
+          @ui.logger.fatal { e.backtrace.join("\n") }
           raise AWSError, e.message
         end
 
@@ -118,8 +117,8 @@ module Cucumber
           end
 
         rescue Exception => e
-          Cucumber::Chef.logger.fatal { e.message }
-          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          @ui.logger.fatal { e.message }
+          @ui.logger.fatal { e.backtrace.join("\n") }
           raise AWSError, e.message
         end
 
@@ -137,8 +136,8 @@ module Cucumber
           end
 
         rescue Exception => e
-          Cucumber::Chef.logger.fatal { e.message }
-          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          @ui.logger.fatal { e.message }
+          @ui.logger.fatal { e.backtrace.join("\n") }
           raise AWSError, e.message
         end
 
@@ -156,8 +155,8 @@ module Cucumber
           end
 
         rescue Exception => e
-          Cucumber::Chef.logger.fatal { e.message }
-          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          @ui.logger.fatal { e.message }
+          @ui.logger.fatal { e.backtrace.join("\n") }
           raise AWSError, e.message
         end
 
@@ -203,16 +202,16 @@ module Cucumber
 ################################################################################
 
         def filter_servers(servers, states=VALID_STATES)
-          Cucumber::Chef.logger.debug("states") { states.collect{ |s| s.inspect }.join(", ") }
+          @ui.logger.debug("states") { states.collect{ |s| s.inspect }.join(", ") }
           results = servers.select do |server|
-            Cucumber::Chef.logger.debug("candidate") { "id=#{server.id.inspect}, state=#{server.state.inspect}, tags=#{server.tags.inspect}" }
+            @ui.logger.debug("candidate") { "id=#{server.id.inspect}, state=#{server.state.inspect}, tags=#{server.tags.inspect}" }
 
             ( server.tags['cucumber-chef-mode'] == Cucumber::Chef::Config.mode.to_s &&
               server.tags['cucumber-chef-user'] == Cucumber::Chef::Config.user.to_s &&
               states.any?{ |state| state.to_s == server.state } )
           end
           results.each do |server|
-            Cucumber::Chef.logger.debug("results") { "id=#{server.id.inspect}, state=#{server.state.inspect}" }
+            @ui.logger.debug("results") { "id=#{server.id.inspect}, state=#{server.state.inspect}" }
           end
           results.first
         end

data/lib/cucumber/chef/providers/vagrant.rb

@@ -25,7 +25,7 @@ module Cucumber
       class VagrantError < Error; end
 
       class Vagrant
-        attr_accessor :env, :vm, :stdout, :stderr, :stdin, :logger
+        attr_accessor :env, :vm
 
         INVALID_STATES = %w(not_created aborted).map(&:to_sym)
         RUNNING_STATES =  %w(running).map(&:to_sym)
@@ -34,9 +34,8 @@ module Cucumber
 
 ################################################################################
 
-        def initialize(stdout=STDOUT, stderr=STDERR, stdin=STDIN, logger=$logger)
-          @stdout, @stderr, @stdin, @logger = stdout, stderr, stdin, logger
-          @stdout.sync = true if @stdout.respond_to?(:sync=)
+        def initialize(ui=ZTK::UI.new)
+          @ui = ui
 
           @env = ::Vagrant::Environment.new
           @vm = @env.primary_vm
@@ -55,8 +54,8 @@ module Cucumber
           self
 
         rescue Exception => e
-          Cucumber::Chef.logger.fatal { e.message }
-          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          @ui.logger.fatal { e.message }
+          @ui.logger.fatal { e.backtrace.join("\n") }
           raise VagrantError, e.message
         end
 
@@ -72,8 +71,8 @@ module Cucumber
           end
 
         rescue Exception => e
-          Cucumber::Chef.logger.fatal { e.message }
-          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          @ui.logger.fatal { e.message }
+          @ui.logger.fatal { e.backtrace.join("\n") }
           raise VagrantError, e.message
         end
 
@@ -90,8 +89,8 @@ module Cucumber
           end
 
         rescue Exception => e
-          Cucumber::Chef.logger.fatal { e.message }
-          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          @ui.logger.fatal { e.message }
+          @ui.logger.fatal { e.backtrace.join("\n") }
           raise VagrantError, e.message
         end
 
@@ -107,8 +106,8 @@ module Cucumber
           end
 
         rescue Exception => e
-          Cucumber::Chef.logger.fatal { e.message }
-          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          @ui.logger.fatal { e.message }
+          @ui.logger.fatal { e.backtrace.join("\n") }
           raise VagrantError, e.message
         end
 
@@ -124,8 +123,8 @@ module Cucumber
           end
 
         rescue Exception => e
-          Cucumber::Chef.logger.fatal { e.message }
-          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          @ui.logger.fatal { e.message }
+          @ui.logger.fatal { e.backtrace.join("\n") }
           raise VagrantError, e.message
         end
 

data/lib/cucumber/chef/provisioner.rb

@@ -25,15 +25,15 @@ module Cucumber
     class ProvisionerError < Error; end
 
     class Provisioner
-      attr_accessor :test_lab, :stdout, :stderr, :stdin
+      attr_accessor :test_lab
 
 ################################################################################
 
-      def initialize(test_lab, stdout=STDOUT, stderr=STDERR, stdin=STDIN)
-        @stdout, @stderr, @stdin = stdout, stderr, stdin
-        @stdout.sync = true if @stdout.respond_to?(:sync=)
+      def initialize(test_lab, ui=ZTK::UI.new)
+        test_lab.nil? and raise ProvisionerError, "You must supply a test lab!"
 
         @test_lab = test_lab
+        @ui       = ui
 
         @cookbooks_path = File.join(Cucumber::Chef.root_dir, "chef_repo", "cookbooks")
         @roles_path = File.join(Cucumber::Chef.root_dir, "chef_repo", "roles")
@@ -69,7 +69,7 @@ module Cucumber
       def bootstrap
         raise ProvisionerError, "You must have the environment variable 'USER' set." if !Cucumber::Chef::Config.user
 
-        ZTK::Benchmark.bench(:message => "Bootstrapping #{Cucumber::Chef::Config.provider.upcase} instance", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+        ZTK::Benchmark.bench(:message => "Bootstrapping #{Cucumber::Chef::Config.provider.upcase} instance", :mark => "completed in %0.4f seconds.", :ui => @ui) do
           chef_client_attributes = {
             "run_list" => "role[test_lab]",
             "cucumber_chef" => {
@@ -86,7 +86,8 @@ module Cucumber
             :admin_password => Cucumber::Chef::Config.chef[:admin_password],
             :user => Cucumber::Chef::Config.user,
             :hostname_short => Cucumber::Chef.lab_hostname_short,
-            :hostname_full => Cucumber::Chef.lab_hostname_full
+            :hostname_full => Cucumber::Chef.lab_hostname_full,
+            :chef_version => Cucumber::Chef::Config.chef[:version]
           }
 
           local_bootstrap_file = Tempfile.new("bootstrap")
@@ -108,7 +109,7 @@ module Cucumber
 ################################################################################
 
       def download_chef_credentials
-        ZTK::Benchmark.bench(:message => "Downloading chef-server credentials", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+        ZTK::Benchmark.bench(:message => "Downloading chef-server credentials", :mark => "completed in %0.4f seconds.", :ui => @ui) do
           local_path = File.join(Cucumber::Chef.home_dir, Cucumber::Chef::Config.provider.to_s)
           remote_path = File.join(Cucumber::Chef.lab_user_home_dir, ".chef")
 
@@ -122,7 +123,7 @@ module Cucumber
 ################################################################################
 
       def download_proxy_ssh_credentials
-        ZTK::Benchmark.bench(:message => "Downloading proxy SSH credentials", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+        ZTK::Benchmark.bench(:message => "Downloading proxy SSH credentials", :mark => "completed in %0.4f seconds.", :ui => @ui) do
           local_path = File.join(Cucumber::Chef.home_dir, Cucumber::Chef::Config.provider.to_s)
           remote_path = File.join(Cucumber::Chef.lab_user_home_dir, ".ssh")
 
@@ -139,7 +140,7 @@ module Cucumber
 ################################################################################
 
       def render_knife_rb
-        ZTK::Benchmark.bench(:message => "Building 'cc-knife' configuration", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+        ZTK::Benchmark.bench(:message => "Building 'cc-knife' configuration", :mark => "completed in %0.4f seconds.", :ui => @ui) do
           template_file = File.join(Cucumber::Chef.root_dir, "lib", "cucumber", "chef", "templates", "cucumber-chef", "knife-rb.erb")
 
           context = {
@@ -157,8 +158,8 @@ module Cucumber
 ################################################################################
 
       def upload_cookbook
-        Cucumber::Chef.logger.debug { "Uploading cucumber-chef cookbooks..." }
-        ZTK::Benchmark.bench(:message => "Uploading 'cucumber-chef' cookbooks", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+        @ui.logger.debug { "Uploading cucumber-chef cookbooks..." }
+        ZTK::Benchmark.bench(:message => "Uploading 'cucumber-chef' cookbooks", :mark => "completed in %0.4f seconds.", :ui => @ui) do
           @test_lab.knife_cli(%Q{cookbook upload cucumber-chef -o #{@cookbooks_path}}, :silence => true)
         end
       end
@@ -166,8 +167,8 @@ module Cucumber
 ################################################################################
 
       def upload_role
-        Cucumber::Chef.logger.debug { "Uploading cucumber-chef test lab role..." }
-        ZTK::Benchmark.bench(:message => "Uploading 'cucumber-chef' roles", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+        @ui.logger.debug { "Uploading cucumber-chef test lab role..." }
+        ZTK::Benchmark.bench(:message => "Uploading 'cucumber-chef' roles", :mark => "completed in %0.4f seconds.", :ui => @ui) do
           @test_lab.knife_cli(%Q{role from file #{File.join(@roles_path, "test_lab.rb")}}, :silence => true)
         end
       end
@@ -175,8 +176,8 @@ module Cucumber
 ################################################################################
 
       def tag_node
-        Cucumber::Chef.logger.debug { "Tagging cucumber-chef test lab node..." }
-        ZTK::Benchmark.bench(:message => "Tagging 'cucumber-chef' node", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+        @ui.logger.debug { "Tagging cucumber-chef test lab node..." }
+        ZTK::Benchmark.bench(:message => "Tagging 'cucumber-chef' node", :mark => "completed in %0.4f seconds.", :ui => @ui) do
           @test_lab.knife_cli(%Q{tag create #{Cucumber::Chef.lab_hostname_full} #{Cucumber::Chef::Config.mode}}, :silence => true)
         end
       end
@@ -184,8 +185,8 @@ module Cucumber
 ################################################################################
 
       def add_node_role
-        Cucumber::Chef.logger.debug { "Setting up cucumber-chef test lab run list..." }
-        ZTK::Benchmark.bench(:message => "Setting 'cucumber-chef' run list", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+        @ui.logger.debug { "Setting up cucumber-chef test lab run list..." }
+        ZTK::Benchmark.bench(:message => "Setting 'cucumber-chef' run list", :mark => "completed in %0.4f seconds.", :ui => @ui) do
           @test_lab.knife_cli(%Q{node run_list add #{Cucumber::Chef.lab_hostname_full} "role[test_lab]"}, :silence => true)
         end
       end
@@ -193,7 +194,7 @@ module Cucumber
 ################################################################################
 
       def chef_first_run
-        ZTK::Benchmark.bench(:message => "Performing chef-client run", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+        ZTK::Benchmark.bench(:message => "Performing chef-client run", :mark => "completed in %0.4f seconds.", :ui => @ui) do
           command = "/usr/bin/chef-client -j /etc/chef/first-boot.json -l debug"
           command = "sudo #{command}"
           @test_lab.bootstrap_ssh.exec(command, :silence => true)
@@ -203,11 +204,11 @@ module Cucumber
 ################################################################################
 
       def wait_for_chef_server
-        ZTK::Benchmark.bench(:message => "Waiting for the chef-server", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+        ZTK::Benchmark.bench(:message => "Waiting for the chef-server", :mark => "completed in %0.4f seconds.", :ui => @ui) do
           ZTK::TCPSocketCheck.new(:host => @test_lab.ip, :port => 4000, :data => "GET", :wait => 120).wait
         end
 
-        ZTK::Benchmark.bench(:message => "Waiting for the chef-server-webui", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+        ZTK::Benchmark.bench(:message => "Waiting for the chef-server-webui", :mark => "completed in %0.4f seconds.", :ui => @ui) do
           ZTK::TCPSocketCheck.new(:host => @test_lab.ip, :port => 4040, :data => "GET", :wait => 120).wait
         end
       end
@@ -215,7 +216,7 @@ module Cucumber
 ################################################################################
 
       def reboot_test_lab
-        ZTK::Benchmark.bench(:message => "Rebooting the test lab", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
+        ZTK::Benchmark.bench(:message => "Rebooting the test lab", :mark => "completed in %0.4f seconds.", :ui => @ui) do
           command = "sudo reboot"
           @test_lab.bootstrap_ssh.exec(command, :silence => true)
           ZTK::TCPSocketCheck.new(:host => @test_lab.ip, :port => @test_lab.port, :wait => 120).wait

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

@@ -22,11 +22,12 @@ tag = Cucumber::Chef.tag("cucumber-chef")
 puts("  * #{tag}")
 Cucumber::Chef.boot(tag)
 
-if (($test_lab = Cucumber::Chef::TestLab.new) && $test_lab.alive?)
+$ui = ZTK::UI.new(:logger => Cucumber::Chef.logger)
+if (($test_lab = Cucumber::Chef::TestLab.new($ui)) && $test_lab.alive?)
   $test_lab.cc_client.up
 else
   message = "No running cucumber-chef test labs to connect to!"
-  Cucumber::Chef.logger.fatal { message }
+  $ui.logger.fatal { message }
   raise message
 end
 

data/lib/cucumber/chef/test_lab.rb

@@ -25,15 +25,14 @@ module Cucumber
     class TestLabError < Error; end
 
     class TestLab
-      attr_accessor :provider, :stdout, :stderr, :stdin, :logger
+      attr_accessor :provider
 
 ################################################################################
 
-      def initialize(stdout=STDOUT, stderr=STDERR, stdin=STDIN, logger=$logger)
-        @stdout, @stderr, @stdin, @logger = stdout, stderr, stdin, logger
-        @stdout.sync = true if @stdout.respond_to?(:sync=)
+      def initialize(ui=ZTK::UI.new)
+        @ui = ui
 
-        @provider = Cucumber::Chef::Provider.new(@stdout, @stderr, @stdin, @logger)
+        @provider = Cucumber::Chef::Provider.new(@ui)
       end
 
 ################################################################################
@@ -42,7 +41,7 @@ module Cucumber
         dead? and raise TestLabError, "The test lab must be running in order to start a bootstrap SSH session!"
 
         if (!defined?(@ssh) || @ssh.nil?)
-          @ssh ||= ZTK::SSH.new(:stdout => @stdout, :stderr => @stderr, :stdin => @stdin, :timeout => Cucumber::Chef::Config.command_timeout)
+          @ssh ||= ZTK::SSH.new(:ui => @ui, :timeout => Cucumber::Chef::Config.command_timeout)
 
           @ssh.config.host_name = self.ip
           @ssh.config.port = self.port
@@ -58,7 +57,7 @@ module Cucumber
         dead? and raise TestLabError, "The test lab must be running in order to start an SSH session!"
 
         if (!defined?(@ssh) || @ssh.nil?)
-          @ssh ||= ZTK::SSH.new(:stdout => @stdout, :stderr => @stderr, :stdin => @stdin, :timeout => Cucumber::Chef::Config.command_timeout)
+          @ssh ||= ZTK::SSH.new(:ui => @ui, :timeout => Cucumber::Chef::Config.command_timeout)
 
           @ssh.config.host_name = self.ip
           @ssh.config.port = self.port
@@ -76,7 +75,7 @@ module Cucumber
         container = container.to_sym
         @proxy_ssh ||= Hash.new
         if (!defined?(@proxy_ssh[container]) || @proxy_ssh[container].nil?)
-          @proxy_ssh[container] ||= ZTK::SSH.new(:stdout => @stdout, :stderr => @stderr, :stdin => @stdin, :timeout => Cucumber::Chef::Config.command_timeout)
+          @proxy_ssh[container] ||= ZTK::SSH.new(:ui => @ui, :timeout => Cucumber::Chef::Config.command_timeout)
 
           @proxy_ssh[container].config.proxy_host_name = self.ip
           @proxy_ssh[container].config.proxy_port = self.port
@@ -95,7 +94,7 @@ module Cucumber
       def cc_client
         dead? and raise TestLabError, "The test lab must be running in order to start the cc-server/client session!"
 
-        @cc_client ||= Cucumber::Chef::Client.new(self, @stdout, @stderr, @stdin, @logger)
+        @cc_client ||= Cucumber::Chef::Client.new(self, @ui)
         @cc_client
       end
 
@@ -130,7 +129,7 @@ module Cucumber
         if Cucumber::Chef::Provider::PROXY_METHODS.include?(method_name.to_s)
           result = @provider.send(method_name.to_sym, *method_args)
           splat = [method_name, *method_args].flatten.compact
-          Cucumber::Chef.logger.debug { "TestLab: #{splat.inspect}=#{result.inspect}" }
+          @ui.logger.debug { "TestLab: #{splat.inspect}=#{result.inspect}" }
           result
         else
           super(method_name, *method_args)

data/lib/cucumber/chef/version.rb

@@ -24,7 +24,7 @@ module Cucumber
 
 ################################################################################
 
-    VERSION = "2.1.0.rc.6" unless const_defined?(:VERSION)
+    VERSION = "2.1.0.rc.7" unless const_defined?(:VERSION)
 
 ################################################################################
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-chef
 version: !ruby/object:Gem::Version
-  version: 2.1.0.rc.6
+  version: 2.1.0.rc.7
   prerelease: 6
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-03 00:00:00.000000000 Z
+date: 2013-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -179,7 +179,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.0.15
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -187,7 +187,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.0.15
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement