cucumber-chef 2.1.0.rc.2 → 2.1.0.rc.3

data/lib/cucumber/chef/server.rb

@@ -37,10 +37,10 @@ module Cucumber
 
 ################################################################################
 
-      def up
+      def up(options={})
         user = Cucumber::Chef.lab_user
         home_dir = Cucumber::Chef.lab_user_home_dir
-        provider = Cucumber::Chef::Config[:provider].to_s
+        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")}")
@@ -49,32 +49,52 @@ module Cucumber
         remote_file = File.join(home_dir, ".cucumber-chef", "config.rb")
         @test_lab.ssh.upload(local_file, remote_file)
 
-        @server_thread = Thread.new do
-          @test_lab.ssh.exec("sudo pkill -9 -f cc-server")
+        begin
+          self.ping
+        rescue
+          @background = ZTK::Background.new
+          @background.process do
+            self.down
 
-          destroy = (ENV['DESTROY'] == '1' ? "DESTROY='1'" : nil)
-          verbose = (ENV['VERBOSE'] == '1' ? "VERBOSE='1'" : nil)
-          log_level = ((!ENV['LOG_LEVEL'].nil? && !ENV['LOG_LEVEL'].empty?) ? "LOG_LEVEL=#{ENV['LOG_LEVEL'].inspect}" : nil)
-          command = ["sudo", destroy, verbose, log_level, "cc-server", Cucumber::Chef.external_ip].compact.join(" ")
-          @test_lab.ssh.exec(command, :silence => false)
+            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
-            @test_lab.ssh.close
+            self.at_exit
           end
         end
 
-        sleep(3)
-        ZTK::TCPSocketCheck.new(:host => @test_lab.ip, :port => 8787, :data => "\n\n").wait
+        ZTK::RescueRetry.try(:tries => 30) do
+          self.ping
+        end
 
-        artifacts = File.join(Cucumber::Chef.home_dir, "artifacts")
-        File.exists?(artifacts) && FileUtils.rm_rf(artifacts)
+        File.exists?(Cucumber::Chef.artifacts_dir) && FileUtils.rm_rf(Cucumber::Chef.artifacts_dir)
 
-        @server_thread
+        true
+      end
+
+################################################################################
+
+      def ping
+        @drb and DRb.stop_service
+        @drb = DRbObject.new_with_uri("druby://#{@test_lab.ip}:8787")
+        @drb and DRb.start_service
+        @drb.ping
       end
 
 ################################################################################
 
       def down
+        (@test_lab.drb.shutdown rescue nil)
       end
 
 ################################################################################
@@ -84,20 +104,7 @@ module Cucumber
         # we use various aspects of the scenario to name our artifacts
         $scenario = scenario
 
-        # cleanup previous lxc containers if asked
-        if ENV['DESTROY']
-          Cucumber::Chef.logger.info("'containers' are being destroyed")
-          @test_lab.drb.servers.each do |name, value|
-            @test_lab.drb.server_destroy(name)
-          end
-          File.exists?(Cucumber::Chef.servers_bin) && File.delete(Cucumber::Chef.servers_bin)
-        else
-          Cucumber::Chef.logger.info("'containers' are being persisted")
-        end
-
-        if File.exists?(Cucumber::Chef.servers_bin)
-          @test_lab.drb.servers = (Marshal.load(IO.read(Cucumber::Chef.servers_bin)) rescue Hash.new(nil))
-        end
+        @test_lab.drb.load_containers
 
         @test_lab.drb.chef_set_client_config(:chef_server_url => "http://192.168.255.254:4000",
                                              :validation_client_name => "chef-validator")
@@ -106,12 +113,10 @@ module Cucumber
 ################################################################################
 
       def after(scenario)
-        File.open(Cucumber::Chef.servers_bin, 'w') do |f|
-          f.puts(Marshal.dump(@test_lab.drb.servers))
-        end
+        @test_lab.drb.save_containers
 
-        # cleanup non-persistent lxc containers between tests
-        @test_lab.drb.servers.select{ |name, attributes| !attributes[:persist] }.each do |name, attributes|
+        # cleanup non-persistent lxc containers after tests
+        @test_lab.drb.containers.select{ |name, attributes| !attributes[:persist] }.each do |name, attributes|
           @test_lab.drb.server_destroy(name)
         end
       end
@@ -119,8 +124,9 @@ module Cucumber
 ################################################################################
 
       def at_exit
-        @test_lab.drb.shutdown
-        @server_thread.kill
+        @logger.fatal { "Waiting for cc-server to shutdown." }
+        self.down
+        @background.wait
       end
 
 ################################################################################

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

@@ -20,31 +20,31 @@
 ################################################################################
 
 Given /^I have a server called "([^\"]*)"$/ do |name|
-  @servers = (@servers || Hash.new(nil)).merge(name => Hash.new(nil))
+  $test_lab.drb.server_init(name)
 end
 
 And /^"([^\"]*)" is running "([^\"]*)" "([^\"]*)"$/ do |name, distro, release|
-  @servers[name].merge!( :distro => distro, :release => release )
+  $test_lab.drb.server_set_attributes(name, :distro => distro, :release => release)
 end
 
 And /^"([^\"]*)" has "([^\"]*)" architecture$/ do |name, arch|
-  @servers[name].merge!( :arch => arch )
+  $test_lab.drb.server_set_attributes(name, :arch => arch)
 end
 
 And /^"([^\"]*)" should( not)? be persist[ae]nt$/ do |name, boolean|
-  @servers[name].merge!( :persist => (!boolean ? true : false) )
+  $test_lab.drb.server_set_attributes(name, :persist => (!boolean ? true : false))
 end
 
 And /^"([^\"]*)" has an IP address of "([^\"]*)"$/ do |name, ip|
-  @servers[name].merge!( :ip => ip )
+  $test_lab.drb.server_set_attributes(name, :ip => ip)
 end
 
 And /^"([^\"]*)" has a MAC address of "([^\"]*)"$/ do |name, mac|
-  @servers[name].merge!( :mac => ip )
+  $test_lab.drb.server_set_attributes(name, :mac => mac)
 end
 
 And /^"([^\"]*)" has been provisioned$/ do |name|
-  $test_lab.drb.server_create(name, @servers[name])
+  $test_lab.drb.server_create(name)
 end
 
 And /^the "([^\"]*)" role has been added to the "([^\"]*)" run list$/ do |role, name|

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

@@ -29,8 +29,8 @@ When /^I ssh to "([^\"]*)" with the following credentials:$/ do |hostname, table
   session = table.hashes.first
   lambda {
 
-    @connection and !@connection.ssh.closed? and @connection.ssh.close
-    @connection = ZTK::SSH.new
+    @connection and @connection.ssh.shutdown!
+    @connection = ZTK::SSH.new(:timeout => 120, :ignore_exit_status => true)
 
     @connection.config.proxy_host_name = $test_lab.ip
     @connection.config.proxy_port = $test_lab.port
@@ -60,8 +60,9 @@ When /^I ssh to "([^\"]*)" with the following credentials:$/ do |hostname, table
 end
 
 And /^I run "([^\"]*)"$/ do |command|
-  @output = @connection.exec(command, :silence => true).output
-  Cucumber::Chef.logger.info { @output.chomp }
+  @result = @connection.exec(command, :silence => true)
+  @output = @result.output
+  @exit_code = @result.exit_code
 end
 
 Then /^I should( not)? see "([^\"]*)" in the output$/ do |boolean, string|
@@ -80,6 +81,10 @@ Then /^I should( not)? see the "([^\"]*)" of "([^\"]*)" in the output$/ do |bool
   end
 end
 
+Then /^the exit code should be "([^\"]*)"$/ do |exit_code|
+  @exit_code.to_i.should == exit_code.to_i
+end
+
 Then /^(path|directory|file|symlink) "([^\"]*)" should exist$/ do |type, path|
   parent = File.dirname path
   child = File.basename path

data/lib/cucumber/chef/templates/bootstrap/ubuntu-precise-test-lab.erb

@@ -1,12 +1,19 @@
-bash -c '
+#!/bin/env bash
+#
+# Cucumber-Chef Bootstrap Script
+#
+# Generated <%= Time.now.utc %>
+#
+set -x
+
 CUCUMBER_CHEF_BOOTSTRAP_DONE="/.cucumber-chef-bootstrap-finished"
 [ -f ${CUCUMBER_CHEF_BOOTSTRAP_DONE} ] && echo "Already bootstrapped!" && exit
 
 export DEBIAN_FRONTEND=noninteractive
 
-echo "127.0.0.1 <%= @hostname %>" | tee -a /etc/hosts
-echo "<%= @hostname %>" | tee /etc/hostname
-hostname <%= @hostname %>
+echo "127.0.0.1 <%= @hostname_full %> <%= @hostname_short %>" | tee -a /etc/hosts
+echo "<%= @hostname_full %>" | tee /etc/hostname
+hostname <%= @hostname_full %>
 
 echo "deb http://apt.opscode.com/ `lsb_release -cs`-0.10 main" | tee /etc/apt/sources.list.d/opscode.list
 mkdir -p /etc/apt/trusted.gpg.d
@@ -19,7 +26,7 @@ chown -R ${SUDO_USER}:${SUDO_USER} ${HOME}/.gnupg
 apt-get -q -y upgrade
 
 cat <<EOF | debconf-set-selections
-chef chef/chef_server_url string http://<%= @chef_server %>:4000
+chef chef/chef_server_url string http://<%= @hostname_short %>:4000
 chef-solr chef-solr/amqp_password password <%= @amqp_password %>
 chef-server-webui chef-server-webui/admin_password password <%= @admin_password %>
 EOF
@@ -93,8 +100,7 @@ if [ ! -f /etc/chef/client.pem ]; then
 fi
 
 cat <<EOF > /etc/chef/first-boot.json
-<%= @attributes.to_json %>
+<%= @chef_client_attributes.to_json %>
 EOF
 
 touch ${CUCUMBER_CHEF_BOOTSTRAP_DONE}
-'

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

@@ -22,7 +22,7 @@ tag = Cucumber::Chef.tag("cucumber-chef")
 puts("  * #{tag}")
 Cucumber::Chef.boot(tag)
 
-if ($test_lab = Cucumber::Chef::TestLab.new) && ($test_lab.labs_running.count > 0)
+if (($test_lab = Cucumber::Chef::TestLab.new) && $test_lab.alive?)
   $cc_server = Cucumber::Chef::Server.new($test_lab)
   $cc_server.up
 else

data/lib/cucumber/chef/test_lab.rb

@@ -36,11 +36,29 @@ module Cucumber
         @provider = Cucumber::Chef::Provider.new(@stdout, @stderr, @stdin, @logger)
       end
 
+################################################################################
+
+      def bootstrap_ssh
+        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.config.host_name = self.ip
+          @ssh.config.port = self.port
+          @ssh.config.user = Cucumber::Chef.bootstrap_user
+          @ssh.config.keys = Cucumber::Chef.bootstrap_identity
+        end
+        @ssh
+      end
+
 ################################################################################
 
       def ssh
+        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
+          @ssh ||= ZTK::SSH.new(:stdout => @stdout, :stderr => @stderr, :stdin => @stdin, :timeout => Cucumber::Chef::Config.command_timeout)
 
           @ssh.config.host_name = self.ip
           @ssh.config.port = self.port
@@ -53,10 +71,12 @@ module Cucumber
 ################################################################################
 
       def proxy_ssh(container)
+        dead? and raise TestLabError, "The test lab must be running in order to start a proxy SSH session!"
+
         container = container.to_sym
         @proxy_ssh ||= Hash.new
         if (!defined?(@proxy_ssh[container]) || @proxy_ssh[container].nil?)
-          @proxy_ssh[container] ||= ZTK::SSH.new
+          @proxy_ssh[container] ||= ZTK::SSH.new(:stdout => @stdout, :stderr => @stderr, :stdin => @stdin, :timeout => Cucumber::Chef::Config.command_timeout)
 
           @proxy_ssh[container].config.proxy_host_name = self.ip
           @proxy_ssh[container].config.proxy_port = self.port
@@ -73,20 +93,29 @@ module Cucumber
 ################################################################################
 
       def drb
-        if (!defined?(@drb) || @drb.nil?)
-          @drb ||= DRbObject.new_with_uri("druby://#{self.ip}:8787")
-          @drb and DRb.start_service
-          @drb.servers = Hash.new(nil)
-        end
+        dead? and raise TestLabError, "The test lab must be running in order to start a Drb session!"
+
+        # @drb and DRb.stop_service
+        @drb ||= DRbObject.new_with_uri("druby://#{self.ip}:8787")
+        @drb and DRb.start_service
         @drb
       end
 
+################################################################################
+
+      def cc_server
+        @cc_server ||= Cucumber::Chef::Server.new(self, @stdout, @stderr, @stdin, @logger)
+        @cc_server
+      end
+
 ################################################################################
 
       def method_missing(method_name, *method_args)
         if Cucumber::Chef::Provider::PROXY_METHODS.include?(method_name.to_s)
-          Cucumber::Chef.logger.debug { "test_lab: #{method_name} #{method_args.inspect}" }
-          @provider.send(method_name.to_sym, *method_args)
+          result = @provider.send(method_name.to_sym, *method_args)
+          splat = [method_name, *method_args].flatten.compact
+          Cucumber::Chef.logger.debug { "test_lab: #{splat.inspect} -> #{result.inspect}" }
+          result
         else
           super(method_name, *method_args)
         end

data/lib/cucumber/chef/utility.rb

@@ -66,26 +66,6 @@ module Cucumber
         File.expand_path(File.join(parent[0..(parent.length - 2)]))
       end
 
-################################################################################
-
-      def spinner(stdout=STDOUT, stderr=STDERR, stdin=STDIN)
-        spinning_chars = %w[| / - \\]
-        count = 0
-        spinner = Thread.new do
-          while count do
-            stdout.print spinning_chars[(count+=1) % spinning_chars.length]
-            stdout.flush if stdout.respond_to?(:flush)
-            sleep(0.25)
-            stdout.print "\b"
-            stdout.flush if stdout.respond_to?(:flush)
-          end
-        end
-        yield.tap do
-          count = false
-          spinner.join
-        end
-      end
-
 ################################################################################
 
       def generate_do_not_edit_warning(message=nil)
@@ -130,6 +110,14 @@ module Cucumber
         home_dir
       end
 
+################################################################################
+
+      def artifacts_dir
+        artifacts_dir = File.join(Cucumber::Chef.home_dir, Cucumber::Chef::Config.provider.to_s, "artifacts")
+        FileUtils.mkdir_p(File.dirname(artifacts_dir))
+        artifacts_dir
+      end
+
 ################################################################################
 
       def log_file
@@ -149,17 +137,17 @@ module Cucumber
 ################################################################################
 
       def knife_rb
-        knife_rb = File.join(Cucumber::Chef.home_dir, Cucumber::Chef::Config[:provider].to_s, "knife.rb")
+        knife_rb = File.join(Cucumber::Chef.home_dir, Cucumber::Chef::Config.provider.to_s, "knife.rb")
         FileUtils.mkdir_p(File.dirname(knife_rb))
         knife_rb
       end
 
 ################################################################################
 
-      def servers_bin
-        servers_bin = File.join(Cucumber::Chef.home_dir, Cucumber::Chef::Config[:provider].to_s, "servers.bin")
-        FileUtils.mkdir_p(File.dirname(servers_bin))
-        servers_bin
+      def containers_bin
+        containers_bin = File.join(Cucumber::Chef.home_dir, "containers.bin")
+        FileUtils.mkdir_p(File.dirname(containers_bin))
+        containers_bin
       end
 
 ################################################################################
@@ -167,11 +155,11 @@ module Cucumber
 ################################################################################
 
       def bootstrap_user
-        Cucumber::Chef::Config[Cucumber::Chef::Config[:provider]][:lab_user]
+        Cucumber::Chef::Config[Cucumber::Chef::Config.provider][:lab_user]
       end
 
       def bootstrap_identity
-        bootstrap_identity = Cucumber::Chef::Config[Cucumber::Chef::Config[:provider]][:identity_file]
+        bootstrap_identity = Cucumber::Chef::Config[Cucumber::Chef::Config.provider][:identity_file]
         File.exists?(bootstrap_identity) && File.chmod(0400, bootstrap_identity)
         bootstrap_identity
       end
@@ -181,35 +169,43 @@ module Cucumber
 ################################################################################
 
       def lab_user
-        Cucumber::Chef::Config[Cucumber::Chef::Config[:provider]][:lab_user]
+        Cucumber::Chef::Config[Cucumber::Chef::Config.provider][:lab_user]
       end
 
       def lab_user_home_dir
-        user = Cucumber::Chef::Config[Cucumber::Chef::Config[:provider]][:lab_user]
+        user = Cucumber::Chef::Config[Cucumber::Chef::Config.provider][:lab_user]
         ((user == "root") ? "/root" : "/home/#{user}")
       end
 
       def lab_identity
-        lab_identity = File.join(Cucumber::Chef.home_dir, Cucumber::Chef::Config[:provider].to_s, "id_rsa-#{lab_user}")
+        lab_identity = File.join(Cucumber::Chef.home_dir, Cucumber::Chef::Config.provider.to_s, "id_rsa-#{lab_user}")
         File.exists?(lab_identity) && File.chmod(0400, lab_identity)
         lab_identity
       end
 
+      def lab_hostname_short
+        Cucumber::Chef::Config.test_lab[:hostname]
+      end
+
+      def lab_hostname_full
+        "#{lab_hostname_short}.#{Cucumber::Chef::Config.test_lab[:tld]}"
+      end
+
 ################################################################################
 # Container SSH Helpers
 ################################################################################
 
       def lxc_user
-        Cucumber::Chef::Config[Cucumber::Chef::Config[:provider]][:lxc_user]
+        Cucumber::Chef::Config[Cucumber::Chef::Config.provider][:lxc_user]
       end
 
       def lxc_user_home_dir
-        user = Cucumber::Chef::Config[Cucumber::Chef::Config[:provider]][:lxc_user]
+        user = Cucumber::Chef::Config[Cucumber::Chef::Config.provider][:lxc_user]
         ((user == "root") ? "/root" : "/home/#{user}")
       end
 
       def lxc_identity
-        lxc_identity = File.join(Cucumber::Chef.home_dir, Cucumber::Chef::Config[:provider].to_s, "id_rsa-#{lab_user}")
+        lxc_identity = File.join(Cucumber::Chef.home_dir, Cucumber::Chef::Config.provider.to_s, "id_rsa-#{lab_user}")
         File.exists?(lxc_identity) && File.chmod(0400, lxc_identity)
         lxc_identity
       end
@@ -241,8 +237,7 @@ module Cucumber
 ################################################################################
 
       def load_chef_config
-        test_lab = (Cucumber::Chef::TestLab.new rescue nil)
-        if (test_lab && ((test_lab.labs_running.count rescue 0) > 0))
+        if (test_lab = (Cucumber::Chef::TestLab.new rescue nil)) && test_lab.alive?
           if File.exists?(Cucumber::Chef.knife_rb)
             logger.info { "load_chef_config(#{Cucumber::Chef.knife_rb})" }
             ::Chef::Config.from_file(Cucumber::Chef.knife_rb)
@@ -266,31 +261,43 @@ module Cucumber
           $logger = ZTK::Logger.new(Cucumber::Chef.log_file)
           Cucumber::Chef.is_rc? and ($logger.level = ZTK::Logger::DEBUG)
 
-          headers = {
-            "program" => $0.to_s.inspect,
+          dependencies = {
             "cucumber_chef_version" => Cucumber::Chef::VERSION.inspect,
-            "uname" => %x(uname -a).chomp.strip.inspect,
-            "chef_repo" => chef_repo.inspect,
             "chef_version" => ::Chef::VERSION.inspect,
             "vagrant_version" => ::Vagrant::VERSION.inspect,
             "fog_version" => ::Fog::VERSION.inspect,
-            "log_file" => log_file.inspect,
-            # "config_rb" => config_rb,
-            # "knife_rb" => knife_rb,
-            "servers_bin" => servers_bin.inspect,
             "ruby_version" => RUBY_VERSION.inspect,
             "ruby_patchlevel" => RUBY_PATCHLEVEL.inspect,
-            "ruby_platform" => RUBY_PLATFORM.inspect
+            "ruby_platform" => RUBY_PLATFORM.inspect,
+            "ztk_version" => ::ZTK::VERSION.inspect
+            # "cucumber_version" => ::Cucumber::VERSION.inspect
           }
           if RUBY_VERSION >= "1.9"
-            headers.merge!("ruby_engine" => RUBY_ENGINE.inspect)
+            dependencies.merge!("ruby_engine" => RUBY_ENGINE.inspect)
           end
-          max_key_length = headers.keys.collect{ |key| key.to_s.length }.max
+
+          details = {
+            "program" => $0.to_s.inspect,
+            "uname" => %x(uname -a).chomp.strip.inspect,
+            "chef_repo" => chef_repo.inspect,
+            "log_file" => log_file.inspect,
+            "config_rb" => config_rb.inspect,
+            "knife_rb" => knife_rb.inspect,
+            "containers_bin" => containers_bin.inspect
+          }
+
+          max_key_length = [dependencies.keys.collect{ |key| key.to_s.length }.max, details.keys.collect{ |key| key.to_s.length }.max].max + 2
 
           $logger.info { ("=" * 80) }
-          headers.sort.each do |key, value|
-            $logger.info { "%#{max_key_length}s: %s" % [ key.upcase, value.to_s ] }
+          details.sort.each do |key, value|
+            $logger.info { " %s%s: %s" % [ key.upcase, '.' * (max_key_length - key.length), value.to_s ] }
+          end
+          $logger.info { ("-" * (max_key_length * 2)) }
+          dependencies.sort.each do |key, value|
+            $logger.info { " %s%s: %s" % [ key.upcase, '.' * (max_key_length - key.length), value.to_s ] }
           end
+          $logger.info { ("-" * (max_key_length * 2)) }
+
         end
 
         $logger