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

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

@@ -23,45 +23,65 @@ module Cucumber::Chef::Helpers::Server
 
 ################################################################################
 
-  def server_create(name, attributes={})
-    if ((attributes[:persist] && @servers[name]) || (@servers[name] && @servers[name][:persist]))
-      attributes = @servers[name]
-      log("using existing attributes for container $#{name} #{server_tag(name)}$")
+  def server_init(name)
+    @containers[name] ||= Hash.new
+  end
+
+################################################################################
+
+  def server_delete(name)
+    @containers.delete(name)
+  end
+
+################################################################################
+
+  def server_set_attributes(name, attributes={})
+    @containers[name].merge!(attributes)
+  end
+
+################################################################################
+
+  def server_create(name)
+    server_init(name)
+
+    # if this is a new or non-persistent container destroy it
+    server_destroy(name) if !@containers[name][:persist]
+
+    attributes = @containers[name]
+    @containers[name] = {
+      :ip => generate_ip,
+      :mac => generate_mac,
+      :persist => true,
+      :distro => "ubuntu",
+      :release => "lucid",
+      :arch => detect_arch(attributes[:distro] || "ubuntu")
+    }.merge(attributes)
+
+    if server_running?(name)
+      logger.info { "Container '#{name}' is already running." }
     else
-      if (container_exists?(name) && (ENV['DESTROY'] == "1"))
-        server_destroy(name)
-      end
-      attributes = { :ip => generate_ip,
-                     :mac => generate_mac,
-                     :persist => true,
-                     :distro => "ubuntu",
-                     :release => "lucid",
-                     :arch => detect_arch(attributes[:distro] || "ubuntu") }.merge(attributes)
-    end
-    @servers = (@servers || Hash.new(nil)).merge(name => attributes)
-    $current_server = @servers[name][:ip]
-    if !server_running?(name)
-      log("please wait, creating container $#{name} #{server_tag(name)}$")
+      logger.info { "Please wait, creating container {#{name.inspect} => #{server_tag(name)}}." }
       bm = ::Benchmark.realtime do
         test_lab_config_dhcpd
         container_config_network(name)
-        container_create(name, @servers[name][:distro], @servers[name][:release], @servers[name][:arch])
+        container_create(name, @containers[name][:distro], @containers[name][:release], @containers[name][:arch])
       end
-      log("container $#{name}$ creation took %0.4f seconds" % bm)
+      logger.info { "Container '#{name}' creation took %0.4f seconds." % bm }
 
       bm = ::Benchmark.realtime do
-        ZTK::TCPSocketCheck.new(:host => @servers[name][:ip], :port => 22).wait
+        ZTK::TCPSocketCheck.new(:host => @containers[name][:ip], :port => 22).wait
       end
-      log("container $#{name}$ SSHD responded after %0.4f seconds" % bm)
-    else
-      log("container $#{name}$ is already running")
+      logger.info { "Container '#{name}' SSHD responded after %0.4f seconds." % bm }
     end
+
+    save_containers
   end
 
 ################################################################################
 
   def server_destroy(name)
     container_destroy(name)
+    test_lab_config_dhcpd
   end
 
 ################################################################################
@@ -70,16 +90,10 @@ module Cucumber::Chef::Helpers::Server
     container_running?(name)
   end
 
-################################################################################
-
-  def servers
-    containers
-  end
-
 ################################################################################
 
   def server_tag(name)
-    @servers[name].inspect.to_s
+    @containers[name].inspect.to_s
   end
 
 ################################################################################

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

@@ -27,7 +27,9 @@ module Cucumber::Chef::Helpers::TestLab
     dhcpd_config = File.join("/etc/dhcp/test-lab.conf")
     File.open(dhcpd_config, 'w') do |f|
       f.puts(Cucumber::Chef.generate_do_not_edit_warning("DHCPD Configuration"))
-      @servers.each do |key, value|
+      @containers.each do |key, value|
+        next if [:mac, :ip].any?{ |z| value[z].nil? }
+
         f.puts
         f.puts("host #{key} {")
         f.puts("  hardware ethernet #{value[:mac]};")
@@ -35,8 +37,12 @@ module Cucumber::Chef::Helpers::TestLab
         f.puts("  ddns-hostname \"#{key}\";")
         f.puts("}")
       end
+      f.flush
+      f.close
     end
-    command_run_local("/etc/init.d/isc-dhcp-server restart")
+
+    command_run_local("service isc-dhcp-server restart")
+    command_run_local("service bind9 restart")
   end
 
 ################################################################################

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

@@ -23,29 +23,8 @@ module Cucumber::Chef::Helpers::Utility
 
 ################################################################################
 
-  def log(message)
-    Cucumber::Chef.logger.info { message.gsub("$", "'") }
-    return if !(ENV['VERBOSE'] == "1")
-
-    pattern = [ "\033[0m\033[36m", "\033[1m" ]
-
-    result = [ " \033[0m\033[34m[\033[1mCC\033[0m\033[34m] \033[36m" ]
-    result << pattern.first
-
-    sanity = message.split('').count{ |z| (z == "$") }
-    raise "You have a log message with an odd number of highlight markup characters! '#{message}' -> (sanity=#{sanity.inspect}) " if (sanity.modulo(2) != 0)
-
-    chunks = message.split("$")
-    chunks.each_with_index do |chunk, index|
-      result << pattern[index.modulo(pattern.length)]
-      result << chunk
-    end
-    result << "\033[0m"
-
-    STDOUT.puts(result.join)
-    STDOUT.flush if STDOUT.respond_to?(:flush)
-
-    true
+  def logger
+    Cucumber::Chef.logger
   end
 
 ################################################################################

data/lib/cucumber/chef/provider.rb

@@ -29,7 +29,7 @@ module Cucumber
     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)
+      PROXY_METHODS = %w(create destroy up halt reload status id state username ip port chef_server_api chef_server_webui alive? dead? exists?)
 
 ################################################################################
 
@@ -37,7 +37,7 @@ module Cucumber
         @stdout, @stderr, @stdin, @logger = stdout, stderr, stdin, logger
         @stdout.sync = true if @stdout.respond_to?(:sync=)
 
-        @provider = case Cucumber::Chef::Config[:provider]
+        @provider = case Cucumber::Chef::Config.provider
         when :aws then
           Cucumber::Chef::Provider::AWS.new(@stdout, @stderr, @stdin, @logger)
         when :vagrant then
@@ -56,23 +56,26 @@ module Cucumber
       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])
+        if exists?
+
+          headers = [:provider, :id, :state, :username, :"ip address", :port, :"chef-server api", :"chef-server webui", :"chef-server default user", :"chef-server default password"]
+          results = ZTK::Report.new.list([nil], headers) do |noop|
+
+            OpenStruct.new(
+              :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,
+              :"chef-server default user" => "admin",
+              :"chef-server default password" => Cucumber::Chef::Config.chef[:admin_password]
+            )
           end
         else
-          @stdout.puts("There are no cucumber-chef test labs to display information for!")
+          raise ProviderError, "No test labs exists!"
         end
 
       rescue Exception => e
@@ -85,8 +88,10 @@ module Cucumber
 
       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)
+          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}" }
+          result
         else
           super(method_name, *method_args)
         end

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

@@ -25,11 +25,11 @@ module Cucumber
       class AWSError < Error; end
 
       class AWS
-        attr_accessor :stdout, :stderr, :stdin, :logger
+        attr_accessor :connection, :server, :stdout, :stderr, :stdin, :logger
 
-        INVALID_STATES = %w( terminated pending )
-        RUNNING_STATES =  %w( running starting-up )
-        SHUTDOWN_STATES = %w( shutdown stopping stopped shutting-down )
+        INVALID_STATES = %w(terminated pending).map(&:to_sym)
+        RUNNING_STATES =  %w(running starting-up).map(&:to_sym)
+        SHUTDOWN_STATES = %w(shutdown stopping stopped shutting-down).map(&:to_sym)
         VALID_STATES = RUNNING_STATES+SHUTDOWN_STATES
 
 ################################################################################
@@ -40,55 +40,42 @@ module Cucumber
 
           @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]
+            :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
+
+          @server = filter_servers(@connection.servers, VALID_STATES)
         end
 
+################################################################################
+# CREATE
 ################################################################################
 
         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.")
+          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.")
           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]
+              :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
+            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
                 @server.wait_for { ready? }
+                tag_server
+                ZTK::TCPSocketCheck.new(:host => self.ip, :port => self.port, :wait => 120).wait
               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
@@ -97,17 +84,15 @@ module Cucumber
           raise AWSError, e.message
         end
 
+################################################################################
+# DESTROY
 ################################################################################
 
         def destroy
-          if ((l = labs).count > 0)
-            @stdout.puts("Destroying Servers:")
-            l.each do |server|
-              @stdout.puts("  * #{server.public_ip_address}")
-              server.destroy
-            end
+          if exists?
+            @server.destroy
           else
-            @stdout.puts("There are no cucumber-chef test labs to destroy!")
+            raise AWSError, "We could not find a test lab!"
           end
 
         rescue Exception => e
@@ -116,32 +101,39 @@ module Cucumber
           raise AWSError, e.message
         end
 
+################################################################################
+# UP
 ################################################################################
 
         def up
-          if (lab_exists? && (@server = labs_shutdown.first))
+          if (exists? && dead?)
             if @server.start
+              @server.wait_for { ready? }
+              ZTK::TCPSocketCheck.new(:host => self.ip, :port => self.port, :wait => 120).wait
+            else
+              raise AWSError, "Failed to boot the test lab!"
+            end
+          else
+            raise AWSError, "We could not find a powered off test lab."
+          end
 
-              @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")
+        rescue Exception => e
+          Cucumber::Chef.logger.fatal { e.message }
+          Cucumber::Chef.logger.fatal { e.backtrace.join("\n") }
+          raise AWSError, e.message
+        end
 
-              @stdout.puts("Successfully started up cucumber-chef test lab!")
+################################################################################
+# HALT
+################################################################################
 
-              info
-            else
-              @stdout.puts("Failed to start up cucumber-chef test lab!")
+        def halt
+          if (exists? && alive?)
+            if !@server.stop
+              raise AWSError, "Failed to halt the test lab!"
             end
           else
-            @stdout.puts("There are no available cucumber-chef test labs to start up!")
+            raise AWSError, "We could not find a running test lab."
           end
 
         rescue Exception => e
@@ -150,17 +142,17 @@ module Cucumber
           raise AWSError, e.message
         end
 
+################################################################################
+# RELOAD
 ################################################################################
 
-        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!")
+        def reload
+          if (exists? && alive?)
+            if !@server.restart
+              raise AWSError, "Failed to reload the test lab!"
             end
           else
-            @stdout.puts("There are no available cucumber-chef test labs top shutdown!")
+            raise AWSError, "We could not find a running test lab."
           end
 
         rescue Exception => e
@@ -169,91 +161,68 @@ module Cucumber
           raise AWSError, e.message
         end
 
+################################################################################
+
+        def exists?
+          !!@server
+        end
+
+        def alive?
+          (exists? && RUNNING_STATES.include?(self.state))
+        end
+
+        def dead?
+          (exists? && SHUTDOWN_STATES.include?(self.state))
+        end
+
 ################################################################################
 
         def id
-          labs_running.first.id
+          @server.id
         end
 
         def state
-          labs_running.first.state
+          @server.state.to_sym
         end
 
         def username
-          labs_running.first.username
+          @server.username
         end
 
         def ip
-          labs_running.first.public_ip_address
+          @server.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
-
+    private
 ################################################################################
 
-        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 filter_servers(servers, states=VALID_STATES)
+          Cucumber::Chef.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}" }
 
-        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 } )
+            ( 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}, state='#{server.state}'" }
+            Cucumber::Chef.logger.debug("results") { "id=#{server.id.inspect}, state=#{server.state.inspect}" }
           end
-          results
+          results.first
         end
 
-
-################################################################################
-    private
 ################################################################################
 
         def tag_server
           {
-            "cucumber-chef-mode" => Cucumber::Chef::Config[:mode],
-            "cucumber-chef-user" => Cucumber::Chef::Config[:user],
+            "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
@@ -266,7 +235,7 @@ module Cucumber
 ################################################################################
 
         def ensure_security_group
-          security_group_name = Cucumber::Chef::Config[:aws][:aws_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 }