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

data/lib/cucumber/chef/server.rb

@@ -0,0 +1,133 @@
+################################################################################
+#
+#      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 ServerError < Error; end
+
+    class Server
+      attr_accessor :test_lab, :stdout, :stderr, :stdin, :logger
+
+################################################################################
+
+      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=)
+
+        @test_lab = test_lab
+      end
+
+################################################################################
+
+      def up
+        user = Cucumber::Chef.lab_user
+        home_dir = Cucumber::Chef.lab_user_home_dir
+        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")}")
+
+        local_file = Cucumber::Chef.config_rb
+        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")
+
+          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)
+
+          Kernel.at_exit do
+            @test_lab.ssh.close
+          end
+        end
+
+        sleep(3)
+        ZTK::TCPSocketCheck.new(:host => @test_lab.ip, :port => 8787, :data => "\n\n").wait
+
+        artifacts = File.join(Cucumber::Chef.home_dir, "artifacts")
+        File.exists?(artifacts) && FileUtils.rm_rf(artifacts)
+
+        @server_thread
+      end
+
+################################################################################
+
+      def down
+      end
+
+################################################################################
+
+      def before(scenario)
+        # store the current scenario here; espcially since I don't know a better way to get at this information
+        # 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.chef_set_client_config(:chef_server_url => "http://192.168.255.254:4000",
+                                             :validation_client_name => "chef-validator")
+      end
+
+################################################################################
+
+      def after(scenario)
+        File.open(Cucumber::Chef.servers_bin, 'w') do |f|
+          f.puts(Marshal.dump(@test_lab.drb.servers))
+        end
+
+        # cleanup non-persistent lxc containers between tests
+        @test_lab.drb.servers.select{ |name, attributes| !attributes[:persist] }.each do |name, attributes|
+          @test_lab.drb.server_destroy(name)
+        end
+      end
+
+################################################################################
+
+      def at_exit
+        @test_lab.drb.shutdown
+        @server_thread.kill
+      end
+
+################################################################################
+
+    end
+
+  end
+end
+
+################################################################################

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

@@ -11,9 +11,9 @@ When /^I have the following SSH sessions:$/ do |table|
       @ssh_sessions[id] and !@ssh_sessions[id].closed? and @ssh_sessions[id].close
       @ssh_sessions[id] = ZTK::SSH.new
 
-      @ssh_sessions[id].config.proxy_host_name = $test_lab.labs_running.first.public_ip_address
-      @ssh_sessions[id].config.proxy_user = "ubuntu"
-      @ssh_sessions[id].config.proxy_keys = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{@ssh_sessions[id].config.proxy_user}")
+      @ssh_sessions[id].config.proxy_host_name = $test_lab.ip
+      @ssh_sessions[id].config.proxy_user = Cucumber::Chef.lab_user
+      @ssh_sessions[id].config.proxy_keys = Cucumber::Chef.lab_identity
 
       hash['hostname'] and (@ssh_sessions[id].config.host_name = hash['hostname'])
       hash['username'] and (@ssh_sessions[id].config.user = hash['username'])
@@ -32,14 +32,29 @@ When /^I ssh to "([^\"]*)" with the following credentials:$/ do |hostname, table
     @connection and !@connection.ssh.closed? and @connection.ssh.close
     @connection = ZTK::SSH.new
 
-    @connection.config.proxy_host_name = $test_lab.labs_running.first.public_ip_address
-    @connection.config.proxy_user = "ubuntu"
-    @connection.config.proxy_keys = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{@connection.config.proxy_user}")
+    @connection.config.proxy_host_name = $test_lab.ip
+    @connection.config.proxy_port = $test_lab.port
+    @connection.config.proxy_user = Cucumber::Chef.lab_user
+    @connection.config.proxy_keys = Cucumber::Chef.lab_identity
 
     hostname and (@connection.config.host_name = hostname)
-    session["username"] and (@connection.config.user = session["username"])
     session["password"] and (@connection.config.password = session["password"])
-    session["keyfile"] and (@connection.config.keys = session["keyfile"])
+
+    if username = session["username"]
+      if username == "$lxc$"
+        @connection.config.user = Cucumber::Chef.lxc_user
+      else
+        @connection.config.user = username
+      end
+    end
+
+    if keyfile = session["keyfile"]
+      if keyfile == "$lxc$"
+        @connection.config.keys = Cucumber::Chef.lxc_identity
+      else
+        @connection.config.keys = keyfile
+      end
+    end
 
   }.should_not raise_error
 end

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

@@ -4,7 +4,7 @@ CUCUMBER_CHEF_BOOTSTRAP_DONE="/.cucumber-chef-bootstrap-finished"
 
 export DEBIAN_FRONTEND=noninteractive
 
-sed -i "s/127.0.0.1 localhost/127.0.0.1 <%= @hostname %> <%= @hostname.split(".")[0] %> localhost/" /etc/hosts
+echo "127.0.0.1 <%= @hostname %>" | tee -a /etc/hosts
 echo "<%= @hostname %>" | tee /etc/hostname
 hostname <%= @hostname %>
 

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

@@ -1,7 +1,7 @@
 ################################################################################
 #
 #      Author: Zachary Patten <zachary@jovelabs.com>
-#   Copyright: Copyright (c) 2011-2013 Atalanta Systems Ltd
+#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
 #     License: Apache License, Version 2.0
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,33 +20,11 @@
 
 tag = Cucumber::Chef.tag("cucumber-chef")
 puts("  * #{tag}")
-Cucumber::Chef.load_config(tag)
+Cucumber::Chef.boot(tag)
 
 if ($test_lab = Cucumber::Chef::TestLab.new) && ($test_lab.labs_running.count > 0)
-  $test_lab.ssh.exec("sudo mkdir -p /home/#{$test_lab.ssh.config.user}/.cucumber-chef")
-  $test_lab.ssh.exec("sudo cp -f /home/#{$test_lab.ssh.config.user}/.chef/knife.rb /home/#{$test_lab.ssh.config.user}/.cucumber-chef/knife.rb")
-  $test_lab.ssh.exec("sudo chown -R #{$test_lab.ssh.config.user}:#{$test_lab.ssh.config.user} /home/#{$test_lab.ssh.config.user}/.cucumber-chef")
-
-  local_file = Cucumber::Chef.config_rb
-  remote_file = File.join("/", "home", $test_lab.ssh.config.user, ".cucumber-chef", "config.rb")
-  $test_lab.ssh.upload(local_file, remote_file)
-
-  $cc_server_thread = Thread.new do
-    $test_lab.ssh.exec("sudo pkill -9 -f cc-server")
-
-    destroy = (ENV['DESTROY'] == '1' ? 'DESTROY="1"' : nil)
-    verbose = (ENV['VERBOSE'] == '1' ? 'VERBOSE="1"' : nil)
-    command = ["sudo", destroy, verbose, "cc-server", Cucumber::Chef.external_ip].compact.join(" ")
-    $test_lab.ssh.exec(command, :silence => false)
-
-    Kernel.at_exit do
-      $test_lab.ssh.close
-    end
-  end
-
-  ZTK::TCPSocketCheck.new(:host => $test_lab.labs_running.first.public_ip_address, :port => 8787, :data => "\n\n").wait
-
-  FileUtils.rm_rf(File.join(Cucumber::Chef.locate(:directory, ".cucumber-chef"), "artifacts"))
+  $cc_server = Cucumber::Chef::Server.new($test_lab)
+  $cc_server.up
 else
   message = "No running cucumber-chef test labs to connect to!"
   Cucumber::Chef.logger.fatal { message }
@@ -55,57 +33,19 @@ end
 
 
 ################################################################################
-# BEFORE HOOK
+# HOOKS
 ################################################################################
 
 Before do |scenario|
-  # store the current scenario here; espcially since I don't know a better way to get at this information
-  # we use various aspects of the scenario to name our artifacts
-  $scenario = scenario
-
-  # cleanup previous lxc containers if asked
-  if ENV['DESTROY']
-    log("$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
-    log("$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.chef_set_client_config(:chef_server_url => "http://192.168.255.254:4000",
-                                       :validation_client_name => "chef-validator")
+  $cc_server.before(scenario)
 end
 
-
-################################################################################
-# AFTER HOOK
-################################################################################
-
 After do |scenario|
-  File.open(Cucumber::Chef.servers_bin, 'w') do |f|
-    f.puts(Marshal.dump($test_lab.drb.servers))
-  end
-
-  # cleanup non-persistent lxc containers between tests
-  $test_lab.drb.servers.select{ |name, attributes| !attributes[:persist] }.each do |name, attributes|
-    $test_lab.drb.server_destroy(name)
-  end
+  $cc_server.after(scenario)
 end
 
-
-################################################################################
-# EXIT HOOK
-################################################################################
-
 Kernel.at_exit do
-  $test_lab.drb.shutdown
-  $cc_server_thread.kill
+  $cc_server.at_exit
 end
 
 ################################################################################

data/lib/cucumber/chef/test_lab.rb

@@ -25,40 +25,27 @@ module Cucumber
     class TestLabError < Error; end
 
     class TestLab
-      attr_reader :connection, :server
-      attr_accessor :stdout, :stderr, :stdin
-
-      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
+      attr_accessor :provider, :stdout, :stderr, :stdin, :logger
 
 ################################################################################
 
-      def initialize(stdout=STDOUT, stderr=STDERR, stdin=STDIN)
-        @stdout, @stderr, @stdin = stdout, stderr, stdin
+      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
+        @provider = Cucumber::Chef::Provider.new(@stdout, @stderr, @stdin, @logger)
       end
 
 ################################################################################
 
       def ssh
         if (!defined?(@ssh) || @ssh.nil?)
-          ssh_private_key_file = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{Cucumber::Chef::Config[:lab_user]}")
-          File.chmod(0400, ssh_private_key_file)
           @ssh ||= ZTK::SSH.new
 
-          @ssh.config.host_name = self.labs_running.first.public_ip_address
-          @ssh.config.user = Cucumber::Chef::Config[:lab_user]
-          @ssh.config.keys = ssh_private_key_file
+          @ssh.config.host_name = self.ip
+          @ssh.config.port = self.port
+          @ssh.config.user = Cucumber::Chef.lab_user
+          @ssh.config.keys = Cucumber::Chef.lab_identity
         end
         @ssh
       end
@@ -69,17 +56,16 @@ module Cucumber
         container = container.to_sym
         @proxy_ssh ||= Hash.new
         if (!defined?(@proxy_ssh[container]) || @proxy_ssh[container].nil?)
-          ssh_private_key_file = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{Cucumber::Chef::Config[:lab_user]}")
-          File.chmod(0400, ssh_private_key_file)
           @proxy_ssh[container] ||= ZTK::SSH.new
 
-          @proxy_ssh[container].config.proxy_host_name = self.labs_running.first.public_ip_address
-          @proxy_ssh[container].config.proxy_user = Cucumber::Chef::Config[:lab_user]
-          @proxy_ssh[container].config.proxy_keys = ssh_private_key_file
+          @proxy_ssh[container].config.proxy_host_name = self.ip
+          @proxy_ssh[container].config.proxy_port = self.port
+          @proxy_ssh[container].config.proxy_user = Cucumber::Chef.lab_user
+          @proxy_ssh[container].config.proxy_keys = Cucumber::Chef.lab_identity
 
           @proxy_ssh[container].config.host_name = container
-          @proxy_ssh[container].config.user = Cucumber::Chef::Config[:lxc_user]
-          @proxy_ssh[container].config.keys = ssh_private_key_file
+          @proxy_ssh[container].config.user = Cucumber::Chef.lxc_user
+          @proxy_ssh[container].config.keys = Cucumber::Chef.lxc_identity
         end
         @proxy_ssh[container]
       end
@@ -88,7 +74,7 @@ module Cucumber
 
       def drb
         if (!defined?(@drb) || @drb.nil?)
-          @drb ||= DRbObject.new_with_uri("druby://#{self.labs_running.first.public_ip_address}:8787")
+          @drb ||= DRbObject.new_with_uri("druby://#{self.ip}:8787")
           @drb and DRb.start_service
           @drb.servers = Hash.new(nil)
         end
@@ -97,287 +83,12 @@ module Cucumber
 
 ################################################################################
 
-      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
-
-        @server
-
-      rescue Exception => e
-        Cucumber::Chef.logger.fatal { e.message }
-        Cucumber::Chef.logger.fatal { "Backtrace:\n#{e.backtrace.join("\n")}" }
-        raise TestLabError, 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 TestLabError, e.message
-      end
-
-################################################################################
-
-      def start
-        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 TestLabError, e.message
-      end
-
-
-      def stop
-        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 TestLabError, e.message
-      end
-
-################################################################################
-
-      def info
-        if lab_exists?
-          labs.each do |lab|
-            @stdout.puts("Instance ID: #{lab.id}")
-            @stdout.puts("State: #{lab.state}")
-            @stdout.puts("Username: #{lab.username}") if lab.username
-            if (lab.public_ip_address || lab.private_ip_address)
-              @stdout.puts
-              @stdout.puts("IP Address:")
-              @stdout.puts("  Public...: #{lab.public_ip_address}") if lab.public_ip_address
-              @stdout.puts("  Private..: #{lab.private_ip_address}") if lab.private_ip_address
-            end
-            if (lab.dns_name || lab.private_dns_name)
-              @stdout.puts
-              @stdout.puts("DNS:")
-              @stdout.puts("  Public...: #{lab.dns_name}") if lab.dns_name
-              @stdout.puts("  Private..: #{lab.private_dns_name}") if lab.private_dns_name
-            end
-            if (lab.tags.count > 0)
-              @stdout.puts
-              @stdout.puts("Tags:")
-              lab.tags.to_hash.each do |k,v|
-                @stdout.puts("  #{k}: #{v}")
-              end
-            end
-            if lab.public_ip_address
-              @stdout.puts
-              @stdout.puts("Chef-Server WebUI:")
-              @stdout.puts("  http://#{lab.public_ip_address}:4040/")
-            end
-            @stdout.puts
-            if (labs_running.include?(lab) && (n = nodes))
-              @stdout.puts
-              @stdout.puts("Nodes:")
-              n.each do |node|
-                @stdout.puts("  * #{node.name} (#{node.cloud.public_ipv4})")
-              end
-            end
-            if (labs_running.include?(lab) && (c = clients))
-              @stdout.puts
-              @stdout.puts("Clients:")
-              c.each do |client|
-                @stdout.puts("  * #{client.name}")
-              end
-            end
-          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 TestLabError, e.message
-      end
-
-################################################################################
-
-      def lab_exists?
-        (labs.size > 0)
-      end
-
-################################################################################
-
-      def labs
-        results = @connection.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
-        results = @connection.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
-        results = @connection.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
-
-################################################################################
-
-      def nodes
-        Cucumber::Chef.load_knife
-        query = "tags:#{Cucumber::Chef::Config[:mode]} AND tags:#{Cucumber::Chef::Config[:user]}"
-        Cucumber::Chef.logger.debug { "query(#{query})" }
-        nodes, offset, total = ::Chef::Search::Query.new.search("node", URI.escape(query))
-        nodes.compact
-      end
-
-      def clients
-        Cucumber::Chef.load_knife
-        query = "tags:#{Cucumber::Chef::Config[:mode]} AND tags:#{Cucumber::Chef::Config[:user]}"
-        Cucumber::Chef.logger.debug { "query(#{query})" }
-        clients, offset, total = ::Chef::Search::Query.new.search("client", URI.escape(query))
-        clients.compact
-      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)
+      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)
         else
-          raise TestLabError, "Could not find an existing or create a new AWS security group."
+          super(method_name, *method_args)
         end
       end