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

data/lib/cucumber/chef/provider.rb

@@ -0,0 +1,102 @@
+################################################################################
+#
+#      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.
+#
+################################################################################
+
+require 'cucumber/chef/providers/aws'
+require 'cucumber/chef/providers/vagrant'
+
+module Cucumber
+  module Chef
+
+    class ProviderError < Error; end
+
+    class Provider
+      attr_accessor :stdout, :stderr, :stdin, :logger
+
+      PROXY_METHODS = %w(create destroy up down status lab_exists? labs labs_running labs_shutdown id state username ip port chef_server_webui)
+
+################################################################################
+
+      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=)
+
+        @provider = case Cucumber::Chef::Config[:provider]
+        when :aws then
+          Cucumber::Chef::Provider::AWS.new(@stdout, @stderr, @stdin, @logger)
+        when :vagrant then
+          Cucumber::Chef::Provider::Vagrant.new(@stdout, @stderr, @stdin, @logger)
+        end
+      end
+
+################################################################################
+
+      def chef_server_webui
+        "http://#{ip}:4040/"
+      end
+
+      def chef_server_api
+        "http://#{ip}:4000/"
+      end
+
+      def status
+        if lab_exists?
+          details = {
+            "Provider" => @provider.class,
+            "ID" => self.id,
+            "State" => self.state,
+            "Username" => self.username,
+            "IP Address" => self.ip,
+            "Port" => self.port,
+            "Chef-Server API" => self.chef_server_api,
+            "Chef-Server WebUI" => self.chef_server_webui
+          }
+          max_key_length = details.collect{ |k,v| k.to_s.length }.max
+          details.each do |key,value|
+            @stdout.puts("%#{max_key_length}s: %s" % [key,value.inspect])
+          end
+        else
+          @stdout.puts("There are no cucumber-chef test labs to display information for!")
+        end
+
+      rescue Exception => e
+        Cucumber::Chef.logger.fatal { e.message }
+        Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+        raise ProviderError, e.message
+      end
+
+################################################################################
+
+      def method_missing(method_name, *method_args)
+        if Cucumber::Chef::Provider::PROXY_METHODS.include?(method_name.to_s)
+          Cucumber::Chef.logger.debug { "provider: #{method_name} #{method_args.inspect}" }
+          @provider.send(method_name.to_sym, *method_args)
+        else
+          super(method_name, *method_args)
+        end
+      end
+
+################################################################################
+
+    end
+
+  end
+end
+
+################################################################################

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

@@ -0,0 +1,294 @@
+################################################################################
+#
+#      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 Provider
+
+      class AWSError < Error; end
+
+      class AWS
+        attr_accessor :stdout, :stderr, :stdin, :logger
+
+        INVALID_STATES = %w( terminated pending )
+        RUNNING_STATES =  %w( running starting-up )
+        SHUTDOWN_STATES = %w( shutdown stopping stopped shutting-down )
+        VALID_STATES = RUNNING_STATES+SHUTDOWN_STATES
+
+################################################################################
+
+        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=)
+
+          @connection = Fog::Compute.new(
+            :provider => 'AWS',
+            :aws_access_key_id => Cucumber::Chef::Config[:aws][:aws_access_key_id],
+            :aws_secret_access_key => Cucumber::Chef::Config[:aws][:aws_secret_access_key],
+            :region => Cucumber::Chef::Config[:aws][:region]
+          )
+          ensure_security_group
+        end
+
+################################################################################
+
+        def create
+          if (lab_exists? && (@server = labs_running.first))
+            @stdout.puts("A test lab already exists using the AWS credentials you have supplied; attempting to reprovision it.")
+          else
+            server_definition = {
+              :image_id => Cucumber::Chef::Config.aws_image_id,
+              :groups => Cucumber::Chef::Config[:aws][:aws_security_group],
+              :flavor_id => Cucumber::Chef::Config[:aws][:aws_instance_type],
+              :key_name => Cucumber::Chef::Config[:aws][:aws_ssh_key_id],
+              :availability_zone => Cucumber::Chef::Config[:aws][:availability_zone],
+              :tags => { "purpose" => "cucumber-chef", "cucumber-chef-mode" => Cucumber::Chef::Config[:mode] },
+              :identity_file => Cucumber::Chef::Config[:aws][:identity_file]
+            }
+            if (@server = @connection.servers.create(server_definition))
+              @stdout.puts("Provisioning cucumber-chef test lab platform.")
+
+              @stdout.print("Waiting for instance...")
+              Cucumber::Chef.spinner do
+                @server.wait_for { ready? }
+              end
+              @stdout.puts("done.\n")
+
+              tag_server
+
+              @stdout.print("Waiting for 20 seconds...")
+              Cucumber::Chef.spinner do
+                sleep(20)
+              end
+              @stdout.print("done.\n")
+            end
+          end
+
+          if @server
+            @stdout.print("Waiting for SSHD...")
+            Cucumber::Chef.spinner do
+              ZTK::TCPSocketCheck.new(:host => @server.public_ip_address, :port => 22, :wait => 120).wait
+            end
+            @stdout.puts("done.\n")
+          end
+
+          self
+
+        rescue Exception => e
+          Cucumber::Chef.logger.fatal { e.message }
+          Cucumber::Chef.logger.fatal { "Backtrace:\n#{e.backtrace.join("\n")}" }
+          raise AWSError, e.message
+        end
+
+################################################################################
+
+        def destroy
+          if ((l = labs).count > 0)
+            @stdout.puts("Destroying Servers:")
+            l.each do |server|
+              @stdout.puts("  * #{server.public_ip_address}")
+              server.destroy
+            end
+          else
+            @stdout.puts("There are no cucumber-chef test labs to destroy!")
+          end
+
+        rescue Exception => e
+          Cucumber::Chef.logger.fatal { e.message }
+          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          raise AWSError, e.message
+        end
+
+################################################################################
+
+        def up
+          if (lab_exists? && (@server = labs_shutdown.first))
+            if @server.start
+
+              @stdout.print("Waiting for instance...")
+              Cucumber::Chef.spinner do
+                @server.wait_for { ready? }
+              end
+              @stdout.puts("done.\n")
+
+              @stdout.print("Waiting for SSHD...")
+              Cucumber::Chef.spinner do
+                ZTK::TCPSocketCheck.new(:host => @server.public_ip_address, :port => 22, :wait => 120).wait
+              end
+              @stdout.puts("done.\n")
+
+              @stdout.puts("Successfully started up cucumber-chef test lab!")
+
+              info
+            else
+              @stdout.puts("Failed to start up cucumber-chef test lab!")
+            end
+          else
+            @stdout.puts("There are no available cucumber-chef test labs to start up!")
+          end
+
+        rescue Exception => e
+          Cucumber::Chef.logger.fatal { e.message }
+          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          raise AWSError, e.message
+        end
+
+################################################################################
+
+        def down
+          if (lab_exists? && (@server = labs_running.first))
+            if @server.stop
+              @stdout.puts("Successfully shutdown cucumber-chef test lab!")
+            else
+              @stdout.puts("Failed to shutdown cucumber-chef test lab!")
+            end
+          else
+            @stdout.puts("There are no available cucumber-chef test labs top shutdown!")
+          end
+
+        rescue Exception => e
+          Cucumber::Chef.logger.fatal { e.message }
+          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          raise AWSError, e.message
+        end
+
+################################################################################
+
+        def id
+          labs_running.first.id
+        end
+
+        def state
+          labs_running.first.state
+        end
+
+        def username
+          labs_running.first.username
+        end
+
+        def ip
+          labs_running.first.public_ip_address
+        end
+
+        def port
+          22
+        end
+
+################################################################################
+
+        def lab_exists?
+          (labs.size > 0)
+        end
+
+################################################################################
+
+        def labs
+          @servers ||= @connection.servers
+          results = @servers.select do |server|
+            Cucumber::Chef.logger.debug("candidate") { "ID=#{server.id}, state='#{server.state}'" }
+            ( server.tags['cucumber-chef-mode'] == Cucumber::Chef::Config[:mode].to_s &&
+              server.tags['cucumber-chef-user'] == Cucumber::Chef::Config[:user].to_s &&
+              VALID_STATES.any?{ |state| state == server.state } )
+          end
+          results.each do |server|
+            Cucumber::Chef.logger.debug("results") { "ID=#{server.id}, state='#{server.state}'" }
+          end
+          results
+        end
+
+################################################################################
+
+        def labs_running
+          @servers ||= @connection.servers
+          results = @servers.select do |server|
+            Cucumber::Chef.logger.debug("candidate") { "ID=#{server.id}, state='#{server.state}'" }
+            ( server.tags['cucumber-chef-mode'] == Cucumber::Chef::Config[:mode].to_s &&
+              server.tags['cucumber-chef-user'] == Cucumber::Chef::Config[:user].to_s &&
+              RUNNING_STATES.any?{ |state| state == server.state } )
+          end
+          results.each do |server|
+            Cucumber::Chef.logger.debug("results") { "ID=#{server.id}, state='#{server.state}'" }
+          end
+          results
+        end
+
+################################################################################
+
+        def labs_shutdown
+          @servers ||= @connection.servers
+          results = @servers.select do |server|
+            Cucumber::Chef.logger.debug("candidate") { "ID=#{server.id}, state='#{server.state}'" }
+            ( server.tags['cucumber-chef-mode'] == Cucumber::Chef::Config[:mode].to_s &&
+              server.tags['cucumber-chef-user'] == Cucumber::Chef::Config[:user].to_s &&
+              SHUTDOWN_STATES.any?{ |state| state == server.state } )
+          end
+          results.each do |server|
+            Cucumber::Chef.logger.debug("results") { "ID=#{server.id}, state='#{server.state}'" }
+          end
+          results
+        end
+
+
+################################################################################
+    private
+################################################################################
+
+        def tag_server
+          {
+            "cucumber-chef-mode" => Cucumber::Chef::Config[:mode],
+            "cucumber-chef-user" => Cucumber::Chef::Config[:user],
+            "purpose" => "cucumber-chef"
+          }.each do |k, v|
+            tag = @connection.tags.new
+            tag.resource_id = @server.id
+            tag.key, tag.value = k, v
+            tag.save
+          end
+        end
+
+################################################################################
+
+        def ensure_security_group
+          security_group_name = Cucumber::Chef::Config[:aws][:aws_security_group]
+          if (security_group = @connection.security_groups.get(security_group_name))
+            port_ranges = security_group.ip_permissions.collect{ |entry| entry["fromPort"]..entry["toPort"] }
+            security_group.authorize_port_range(22..22) if port_ranges.none?{ |port_range| port_range === 22 }
+            security_group.authorize_port_range(4000..4000) if port_ranges.none?{ |port_range| port_range === 4000 }
+            security_group.authorize_port_range(4040..4040) if port_ranges.none?{ |port_range| port_range === 4040 }
+            security_group.authorize_port_range(8787..8787) if port_ranges.none?{ |port_range| port_range === 8787 }
+          elsif (security_group = @connection.security_groups.new(:name => security_group_name, :description => "cucumber-chef test lab")).save
+            security_group.authorize_port_range(22..22)
+            security_group.authorize_port_range(4000..4000)
+            security_group.authorize_port_range(4040..4040)
+            security_group.authorize_port_range(8787..8787)
+          else
+            raise AWSError, "Could not find an existing or create a new AWS security group."
+          end
+        end
+
+################################################################################
+
+      end
+
+    end
+  end
+end
+
+################################################################################

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

@@ -0,0 +1,121 @@
+################################################################################
+#
+#      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 Provider
+
+      class VagrantError < Error; end
+
+      class Vagrant
+        attr_accessor :env, :vm, :stdout, :stderr, :stdin, :logger
+
+################################################################################
+
+        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=)
+
+          # @env = ::Vagrant::Environment.new
+          @env = ::Vagrant::Environment.new(:ui_class => ::Vagrant::UI::Colored)
+          @vm = @env.primary_vm
+        end
+
+################################################################################
+
+        def create
+          @stdout.puts("Provisioning cucumber-chef test lab platform.")
+
+          @stdout.print("Waiting for instance...")
+          Cucumber::Chef.spinner do
+            @env.cli("up")
+          end
+          @stdout.puts("done.\n")
+
+          @stdout.print("Waiting for SSHD...")
+          Cucumber::Chef.spinner do
+            ZTK::TCPSocketCheck.new(:host => self.ip, :port => 22, :wait => 120).wait
+          end
+          @stdout.puts("done.\n")
+
+          self
+        end
+
+        def destroy
+          @env.cli("destroy", "--force")
+        end
+
+        def up
+          @env.cli("up")
+        end
+
+        def down
+          @env.cli("halt")
+        end
+
+################################################################################
+
+        def id
+          @vm.name
+        end
+
+        def state
+          @vm.state
+        end
+
+        def username
+          @vm.config.ssh.username
+        end
+
+        def ip
+          @vm.config.ssh.host
+        end
+
+        def port
+          @vm.config.vm.forwarded_ports.select{ |fwd_port| (fwd_port[:name] == "ssh") }.first[:hostport].to_i
+        end
+
+################################################################################
+
+        def lab_exists?
+          (@env.vms.count > 0)
+        end
+
+        def labs
+          [@env.primary_vm]
+        end
+
+        def labs_running
+          [@env.primary_vm]
+        end
+
+        def labs_shutdown
+          Array.new # @env.vms
+        end
+
+################################################################################
+
+      end
+
+    end
+  end
+end
+
+################################################################################

data/lib/cucumber/chef/provisioner.rb

@@ -32,26 +32,27 @@ module Cucumber
 
 ################################################################################
 
-      def initialize(server, stdout=STDOUT, stderr=STDERR, stdin=STDIN)
-        @server = server
+      def initialize(test_lab, stdout=STDOUT, stderr=STDERR, stdin=STDIN)
+        @test_lab = test_lab
         @stdout, @stderr, @stdin = stdout, stderr, stdin
         @stdout.sync = true if @stdout.respond_to?(:sync=)
 
         @ssh = ZTK::SSH.new(:stdout => @stdout, :stderr => @stderr, :stdin => @stdin)
-        @ssh.config.host_name = @server.public_ip_address
-        @ssh.config.user = Cucumber::Chef::Config[:lab_user]
-        @ssh.config.keys = Cucumber::Chef::Config[:aws][:identity_file]
+        @ssh.config.host_name = @test_lab.ip
+        @ssh.config.port = @test_lab.port
+        @ssh.config.user = Cucumber::Chef.lab_user
+        @ssh.config.keys = Cucumber::Chef::Config[Cucumber::Chef::Config[:provider]][:identity_file]
 
         # @command = Cucumber::Chef::Command.new(@stdout, @stderr, @stdin)
 
-        @cookbooks_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "chef_repo", "cookbooks"))
-        @roles_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "chef_repo", "roles"))
+        @cookbooks_path = File.join(Cucumber::Chef.root_dir, "chef_repo", "cookbooks")
+        @roles_path = File.join(Cucumber::Chef.root_dir, "chef_repo", "roles")
       end
 
 ################################################################################
 
       def build
-        template_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "lib", "cucumber", "chef", "templates", "bootstrap", "ubuntu-precise-test-lab.erb"))
+        template_file = File.join(Cucumber::Chef.root_dir, "lib", "cucumber", "chef", "templates", "bootstrap", "ubuntu-precise-test-lab.erb")
 
         bootstrap(template_file)
         wait_for_chef_server
@@ -79,21 +80,24 @@ module Cucumber
       def bootstrap(template_file)
         raise ProvisionerError, "You must have the environment variable 'USER' set." if !Cucumber::Chef::Config[:user]
 
-        @stdout.print("Bootstrapping AWS EC2 instance...")
+        @stdout.print("Bootstrapping #{Cucumber::Chef::Config[:provider].upcase} instance...")
         Cucumber::Chef.spinner do
           attributes = {
             "run_list" => "role[test_lab]",
             "cucumber_chef" => {
               "version" => Cucumber::Chef::VERSION,
               "prerelease" => Cucumber::Chef::Config[:prerelease]
-            }
+            },
+            "lab_user" => Cucumber::Chef.lab_user,
+            "lxc_user" => Cucumber::Chef.lxc_user
           }
 
           bootstrap = Cucumber::Chef::Bootstrap.new(@stdout, @stderr, @stdin)
-          bootstrap.config[:host] = @server.public_ip_address
-          bootstrap.config[:ssh_user] = Cucumber::Chef::Config[:lab_user]
+          bootstrap.config[:host] = @test_lab.ip
+          bootstrap.config[:port] = @test_lab.port
+          bootstrap.config[:ssh_user] = Cucumber::Chef.lab_user
           bootstrap.config[:use_sudo] = true
-          bootstrap.config[:identity_file] = Cucumber::Chef::Config[:aws][:identity_file]
+          bootstrap.config[:identity_file] = Cucumber::Chef.bootstrap_identity
           bootstrap.config[:template_file] = template_file
           bootstrap.config[:context][:hostname] = HOSTNAME
           bootstrap.config[:context][:chef_server] = HOSTNAME
@@ -111,8 +115,8 @@ module Cucumber
       def download_chef_credentials
         @stdout.print("Downloading chef-server credentials...")
         Cucumber::Chef.spinner do
-          local_path = Cucumber::Chef.locate(:directory, ".cucumber-chef")
-          remote_path = File.join("/", "home", @ssh.config.user, ".chef")
+          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")
 
           files = [ "#{Cucumber::Chef::Config[:user]}.pem", "validation.pem" ]
           files.each do |file|
@@ -127,10 +131,10 @@ module Cucumber
       def download_proxy_ssh_credentials
         @stdout.print("Downloading container SSH credentials...")
         Cucumber::Chef.spinner do
-          local_path = Cucumber::Chef.locate(:directory, ".cucumber-chef")
-          remote_path = File.join("/", "home", @ssh.config.user, ".ssh")
+          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")
 
-          files = { "id_rsa" => "id_rsa-#{Cucumber::Chef::Config[:lab_user]}" }
+          files = { "id_rsa" => "id_rsa-#{@ssh.config.user}" }
           files.each do |remote_file, local_file|
             local = File.join(local_path, local_file)
             File.exists?(local) and File.delete(local)
@@ -146,16 +150,15 @@ module Cucumber
       def render_knife_rb
         @stdout.print("Building 'cc-knife' configuration...")
         Cucumber::Chef.spinner do
-          template_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "lib", "cucumber", "chef", "templates", "cucumber-chef", "knife-rb.erb"))
-          knife_rb = File.expand_path(File.join(Cucumber::Chef.locate(:directory, ".cucumber-chef"), "knife.rb"))
+          template_file = File.join(Cucumber::Chef.root_dir, "lib", "cucumber", "chef", "templates", "cucumber-chef", "knife-rb.erb")
 
           context = {
-            :chef_server => @server.public_ip_address,
+            :chef_server => @test_lab.ip,
             :librarian_chef => Cucumber::Chef::Config[:librarian_chef],
             :user => Cucumber::Chef::Config[:user]
           }
 
-          File.open(knife_rb, 'w') do |f|
+          File.open(Cucumber::Chef.knife_rb, 'w') do |f|
             f.puts(ZTK::Template.render(template_file, context))
           end
         end
@@ -169,7 +172,7 @@ module Cucumber
         @stdout.print("Uploading cucumber-chef cookbooks...")
 
         Cucumber::Chef.spinner do
-          Cucumber::Chef.load_knife
+          Cucumber::Chef.load_chef_config
           cookbook_repo = ::Chef::CookbookLoader.new(@cookbooks_path)
           cookbook_repo.each do |name, cookbook|
             Cucumber::Chef.logger.debug { "::Chef::CookbookUploader(#{name}) ATTEMPT" }
@@ -190,7 +193,7 @@ module Cucumber
         @stdout.print("Uploading cucumber-chef test lab role...")
 
         Cucumber::Chef.spinner do
-          Cucumber::Chef.load_knife
+          Cucumber::Chef.load_chef_config
           ::Chef::Config[:role_path] = @roles_path
           [ "test_lab" ].each do |name|
             role = ::Chef::Role.from_disk(name)
@@ -210,7 +213,7 @@ module Cucumber
         @stdout.print("Tagging cucumber-chef test lab node...")
 
         Cucumber::Chef.spinner do
-          Cucumber::Chef.load_knife
+          Cucumber::Chef.load_chef_config
           node = ::Chef::Node.load(HOSTNAME)
           [ Cucumber::Chef::Config[:mode].to_s, Cucumber::Chef::Config[:user].to_s ].each do |tag|
             node.tags << tag
@@ -230,7 +233,7 @@ module Cucumber
         @stdout.print("Setting up cucumber-chef test lab run list...")
 
         Cucumber::Chef.spinner do
-          Cucumber::Chef.load_knife
+          Cucumber::Chef.load_chef_config
           node = ::Chef::Node.load(HOSTNAME)
           [ "role[test_lab]" ].each do |entry|
             node.run_list << entry
@@ -260,13 +263,13 @@ module Cucumber
       def wait_for_chef_server
         @stdout.print("Waiting for Chef-Server...")
         Cucumber::Chef.spinner do
-          ZTK::TCPSocketCheck.new(:host => @server.public_ip_address, :port => 4000, :data => "GET", :wait => 120).wait
+          ZTK::TCPSocketCheck.new(:host => @test_lab.ip, :port => 4000, :data => "GET", :wait => 120).wait
         end
         @stdout.puts("done.\n")
 
         @stdout.print("Waiting for Chef-WebUI...")
         Cucumber::Chef.spinner do
-          ZTK::TCPSocketCheck.new(:host => @server.public_ip_address, :port => 4040, :data => "GET", :wait => 120).wait
+          ZTK::TCPSocketCheck.new(:host => @test_lab.ip, :port => 4040, :data => "GET", :wait => 120).wait
         end
         @stdout.puts("done.\n")
       end
@@ -284,7 +287,7 @@ module Cucumber
 
         @stdout.print("Waiting for SSHD...")
         Cucumber::Chef.spinner do
-          ZTK::TCPSocketCheck.new(:host => @server.public_ip_address, :port => 22, :wait => 120).wait
+          ZTK::TCPSocketCheck.new(:host => @test_lab.ip, :port => 22, :wait => 120).wait
         end
         @stdout.puts("done.\n")