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

data/cucumber-chef.gemspec

@@ -46,9 +46,9 @@ Gem::Specification.new do |s|
   s.add_dependency("rspec", ">= 2.10.0")
 
   # Support
-  s.add_dependency("thor", ">= 0.15.2")
   s.add_dependency("mixlib-config", ">= 1.1.2")
   s.add_dependency("rake", ">= 0.9.2")
+  s.add_dependency("thor", ">= 0.15.2")
   s.add_dependency("ubuntu_ami", ">= 0.4.0")
   s.add_dependency("ztk", ">= 0.0.15")
 

data/lib/cucumber/chef.rb

@@ -19,10 +19,11 @@
 #
 ################################################################################
 
-require 'drb/drb'
+require 'drb'
 require 'readline'
 require 'socket'
 require 'stringio'
+require 'benchmark'
 
 ################################################################################
 
@@ -46,7 +47,6 @@ module Cucumber
 
     class Error < StandardError; end
 
-    autoload :Bootstrap, 'cucumber/chef/bootstrap'
     autoload :Config, 'cucumber/chef/config'
     autoload :Provider, 'cucumber/chef/provider'
     autoload :Provisioner, 'cucumber/chef/provisioner'

data/lib/cucumber/chef/config.rb

@@ -162,27 +162,35 @@ module Cucumber
 
 ################################################################################
 
-      mode            :user
-      prerelease      (Cucumber::Chef.is_rc? ? true : false)
+      mode              :user
+      prerelease        (Cucumber::Chef.is_rc? ? true : false)
 
-      provider        :vagrant
-      librarian_chef  false
+      provider          :vagrant
+      librarian_chef    false
 
-      user            (ENV['OPSCODE_USER'] || ENV['USER'])
+      user              (ENV['OPSCODE_USER'] || ENV['USER'])
 
-      artifacts       ({"chef-client-log" => "/var/log/chef/client.log",
-                        "chef-client-stacktrace" => "/var/chef/cache/chef-stacktrace.out"})
+      artifacts         ({"chef-client-log" => "/var/log/chef/client.log",
+                          "chef-client-stacktrace" => "/var/chef/cache/chef-stacktrace.out"})
 
-      aws             ({:lab_user => "ubuntu",
-                        :lxc_user => "root",
-                        :ubuntu_release => "precise",
-                        :aws_instance_arch => "i386",
-                        :aws_instance_disk_store => "ebs",
-                        :aws_instance_type => "m1.small",
-                        :aws_security_group => "cucumber-chef"})
+      aws               ({:lab_user => "ubuntu",
+                          :lxc_user => "root",
+                          :ubuntu_release => "precise",
+                          :aws_instance_arch => "i386",
+                          :aws_instance_disk_store => "ebs",
+                          :aws_instance_type => "m1.small",
+                          :aws_security_group => "cucumber-chef"})
 
-      vagrant         ({:lab_user => "vagrant",
-                        :lxc_user => "root"})
+      vagrant           ({:lab_user => "vagrant",
+                          :lxc_user => "root"})
+
+      chef              ({:amqp_password => "p@ssw0rd1",
+                          :admin_password => "p@ssw0rd1"})
+
+      test_lab          ({:hostname => "cucumber-chef",
+                          :tld => "test-lab"})
+
+      command_timeout   (60 * 30)
 
 ################################################################################
 

data/lib/cucumber/chef/helpers.rb

@@ -26,8 +26,6 @@ module Cucumber
     # definitions.
     module Helpers
 
-      require 'benchmark'
-
       require 'cucumber/chef/helpers/chef_client'
       require 'cucumber/chef/helpers/chef_server'
       require 'cucumber/chef/helpers/command'

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

@@ -33,7 +33,7 @@ module Cucumber::Chef::Helpers::ChefClient
       :ssl_verify_mode => :verify_none,
       :environment => nil # use default; i.e. set no value
     }).merge(config)
-    log("setting chef client config $#{@chef_client_config.inspect}$")
+    logger.info { "Setting chef client config '#{@chef_client_config.inspect}'." }
 
     true
   end
@@ -42,27 +42,33 @@ module Cucumber::Chef::Helpers::ChefClient
 
   # call this before chef_run_client
   def chef_set_client_attributes(name, attributes={})
-    @servers[name] ||= Hash.new
-    @servers[name][:chef_client] = (@servers[name][:chef_client] || {}).merge(attributes) { |k,o,n| (k = (o + n).uniq) }
-    log("setting chef client attributes to $#{@servers[name][:chef_client].inspect}$ for container $#{name}$")
+    @containers[name] ||= Hash.new
+    @containers[name][:chef_client] = (@containers[name][:chef_client] || {}).merge(attributes) { |k,o,n| (k = (o + n).uniq) }
+    logger.info { "Setting chef client attributes to '#{@containers[name][:chef_client].inspect}' for container '#{name}'." }
 
     true
   end
 
 ################################################################################
 
-  def chef_run_client(name,*args)
+  def chef_run_client(name, *args)
     chef_config_client(name)
-    log("removing artifacts #{Cucumber::Chef::Config[:artifacts].values.collect{|z| "$#{z}$" }.join(' ')}")
-    (command_run_remote(name, "/bin/rm -fv #{Cucumber::Chef::Config[:artifacts].values.join(' ')}") rescue nil)
 
-    log("running chef client on container $#{name}$")
+    logger.info { "Removing artifacts #{Cucumber::Chef::Config[:artifacts].values.collect{|z| "'#{z}'" }.join(' ')}." }
+    (command_run_chroot(name, "/bin/rm -fv #{Cucumber::Chef::Config[:artifacts].values.join(' ')}") rescue nil)
+
+    logger.info { "Running chef client on container '#{name}'." }
+
+    arguments = {
+      "--json-attributes" => File.join("/etc", "chef", "attributes.json").to_s,
+      "--log_level" => (ENV['LOG_LEVEL'] || "INFO").downcase
+    }.reject{ |k,v| v.nil? }.sort
 
     output = nil
     bm = ::Benchmark.realtime do
-      output = command_run_remote(name, ["/usr/bin/chef-client --json-attributes /etc/chef/attributes.json --node-name #{name}", args].flatten.join(" "))
+      output = command_run_chroot(name, ["/usr/bin/chef-client", arguments, args].flatten.join(" "))
     end
-    log("chef client run on container $#{name}$ took %0.4f seconds" % bm)
+    logger.info { "Chef client run on container '#{name}' took %0.4f seconds." % bm }
 
     output
   end
@@ -90,7 +96,7 @@ module Cucumber::Chef::Helpers::ChefClient
     attributes_json = File.join("/", container_root(name), "etc", "chef", "attributes.json")
     FileUtils.mkdir_p(File.dirname(attributes_json))
     File.open(attributes_json, 'w') do |f|
-      f.puts((@servers[name][:chef_client] || {}).to_json)
+      f.puts((@containers[name][:chef_client] || {}).to_json)
     end
 
     # make sure our log location is there
@@ -108,16 +114,7 @@ module Cucumber::Chef::Helpers::ChefClient
     # this is messy and needs to be refactored into a more configurable
     # solution; but for now this should do the trick
 
-    ssh = ZTK::SSH.new
-
-    ssh.config.proxy_host_name = $test_lab.ip
-    ssh.config.proxy_port = $test_lab.port
-    ssh.config.proxy_user = Cucumber::Chef.lab_user
-    ssh.config.proxy_keys = Cucumber::Chef.lab_identity
-
-    ssh.config.host_name = name
-    ssh.config.user = Cucumber::Chef.lxc_user
-    ssh.config.keys = Cucumber::Chef.lxc_identity
+    ssh = $test_lab.proxy_ssh(name)
 
     feature_file = $scenario.file_colon_line.split(":").first
     feature_line = $scenario.file_colon_line.split(":").last
@@ -129,9 +126,9 @@ module Cucumber::Chef::Helpers::ChefClient
     Cucumber::Chef::Config[:artifacts].each do |label, remote_path|
       result = ssh.exec("/bin/bash -c '[[ -f #{remote_path} ]] ; echo $?'", :silence => true)
       if (result.output =~ /0/)
-        log("retrieving artifact $#{remote_path}$ from container $#{name}$")
+        logger.info { "Retrieving artifact '#{remote_path}' from container '#{name}'." }
 
-        local_path = File.join(Cucumber::Chef.locate(:directory, ".cucumber-chef"), "artifacts", feature_dir, "#{feature_name}.txt")
+        local_path = File.join(Cucumber::Chef.artifacts_dir, feature_dir, "#{feature_name}.txt")
         tmp_path = File.join("/tmp", label)
 
         FileUtils.mkdir_p(File.dirname(local_path))

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

@@ -25,14 +25,14 @@ module Cucumber::Chef::Helpers::ChefServer
 
   def chef_server_node_destroy(name)
     (::Chef::Node.load(name).destroy rescue nil)
-    log("destroyed chef node $#{name}$")
+    logger.info { "Destroyed chef node '#{name}'." }
   end
 
 ################################################################################
 
   def chef_server_client_destroy(name)
     (::Chef::ApiClient.load(name).destroy rescue nil)
-    log("destroyed chef client $#{name}$")
+    logger.info { "Destroyed chef client '#{name}'." }
   end
 
 ################################################################################
@@ -45,7 +45,7 @@ module Cucumber::Chef::Helpers::ChefServer
     cookbook_repo.each do |name, cbook|
       next if name != cookbook
       ::Chef::CookbookUploader.new(cbook, cookbook_path, :force => true).upload_cookbooks
-      log("uploaded chef cookbook $#{cookbook}$ from $#{cookbook_path}$")
+      logger.info { "Uploaded chef cookbook '#{cookbook}' from '#{cookbook_path}'." }
     end
   end
 
@@ -59,7 +59,7 @@ module Cucumber::Chef::Helpers::ChefServer
     ::Chef::Config[:role_path] = expanded_role_path
     role = ::Chef::Role.from_disk(role)
     role.save
-    log("updated chef role $#{role}$ from $#{role_path}$")
+    logger.info { "Updated chef role '#{role}' from '#{role_path}'." }
   end
 
 ################################################################################
@@ -100,7 +100,7 @@ module Cucumber::Chef::Helpers::ChefServer
     items.each do |item|
       next if File.directory?(item)
 
-      item_name = %w( json rb ).collect{ |ext| (item =~ /#{ext}/ ? File.basename(item, ".#{ext}") : nil) }.compact.first
+      item_name = %w(json rb).collect{ |ext| (item =~ /#{ext}/ ? File.basename(item, ".#{ext}") : nil) }.compact.first
       item_path = File.basename(item)
       databag_item_path = File.expand_path(File.join(databag_path, item_path))
 
@@ -113,10 +113,10 @@ module Cucumber::Chef::Helpers::ChefServer
       loop do
         chef_data = ::Chef::DataBagItem.load(databag, item_name).raw_data
         break if chef_data == raw_data
-        log("waiting on chef data bag to update")
+        logger.info { "Waiting on chef data bag to update; sleeping 1 second." }
         sleep(1)
       end
-      log("updated chef data bag item $#{databag}/#{item_path}$ from $#{databag_path}$")
+      logger.info { "Updated chef data bag item '#{databag}/#{item_path}' from '#{databag_path}'." }
     end
   end
 

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

@@ -23,47 +23,34 @@ module Cucumber::Chef::Helpers::Command
 
 ################################################################################
 
-  def command_run_remote(name, command, expected_exit_code=0)
-    command = %Q(ssh -i #{File.join(Cucumber::Chef.lab_user_home_dir, ".ssh", "id_rsa")} #{name} #{command} 2>&1)
-    logger.info { "command_run_remote(#{command})" }
-    output = %x(#{command})
-    if !expected_exit_code.nil? && ($? != expected_exit_code)
-      message = "command_run_remote(#{command}) failed (code=#{$?},output='#{output.chomp}')"
-      logger.fatal { message }
-      logger.fatal { "output(#{output.chomp})" }
-      raise message
-    end
-    output
+  def command_run_remote(name, command, options={})
+    expected_exit_code = (options[:expected_exit_code] || 0)
+    options.reject!{ |k,v| k == :expected_exit_code }
+
+    identity_file = File.join(Cucumber::Chef.lab_user_home_dir, ".ssh", "id_rsa")
+
+    command = %W(/usr/bin/ssh #{ENV['LOG_LEVEL'] == 'DEBUG' ? "-v" : nil} -i #{identity_file} #{name} #{command})
+    ::ZTK::Command.new({:timeout => Cucumber::Chef::Config.command_timeout}.merge(options)).exec(command.compact.join(" "), :silence => true, :exit_code => expected_exit_code)
   end
 
 ################################################################################
 
-  def command_run_chroot(name, command, expected_exit_code=0)
-    command = %Q(chroot #{container_root(name)} /bin/bash -c '#{command.gsub("'", '"')}' 2>&1)
-    logger.info { "command_run_chroot(#{command})" }
-    output = %x(#{command})
-    if !expected_exit_code.nil? && ($? != expected_exit_code)
-      message = "command_run_chroot(#{command}) failed (#{$?})"
-      logger.fatal { message }
-      logger.fatal { "output(#{output.chomp})" }
-      raise message
-    end
-    output
+  def command_run_chroot(name, command, options={})
+    expected_exit_code = (options[:expected_exit_code] || 0)
+    options.reject!{ |k,v| k == :expected_exit_code }
+
+    command = %Q(/usr/sbin/chroot #{container_root(name)} /bin/bash -c '#{command.gsub("'", '"')}')
+    ::ZTK::Command.new({:timeout => Cucumber::Chef::Config.command_timeout}.merge(options)).exec(command, :silence => true, :exit_code => expected_exit_code)
   end
 
 ################################################################################
 
-  def command_run_local(command, expected_exit_code=0)
-    command = %Q(/bin/bash -c '#{command.gsub("'", '"')}' 2>&1)
-    logger.info { "command_run_local(#{command})" }
-    output = %x(#{command})
-    if !expected_exit_code.nil? && ($? != expected_exit_code)
-      message = "command_run_local(#{command}) failed (#{$?})"
-      logger.fatal { message }
-      logger.fatal { "output(#{output.chomp})" }
-      raise message
-    end
-    output
+  def command_run_local(command, options={})
+    expected_exit_code = (options[:expected_exit_code] || 0)
+    options.reject!{ |k,v| k == :expected_exit_code }
+
+    command = %Q(/bin/bash -c '#{command.gsub("'", '"')}')
+    ::ZTK::Command.new({:timeout => Cucumber::Chef::Config.command_timeout}.merge(options)).exec(command, :silence => true, :exit_code => expected_exit_code)
   end
 
 ################################################################################

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

@@ -21,18 +21,46 @@
 
 module Cucumber::Chef::Helpers::Container
 
+################################################################################
+
+  def load_containers
+    logger.debug { "Reading '#{Cucumber::Chef.containers_bin}'." }
+    @containers = ((Marshal.load(IO.read(Cucumber::Chef.containers_bin)) rescue Hash.new) || Hash.new)
+
+    logger.info { "-" * 8 }
+    @containers.each do |key, value|
+      logger.info { "LOAD CONTAINER: #{key.inspect} => #{value.inspect}" }
+    end
+  end
+
+################################################################################
+
+  def save_containers
+    logger.debug { "Writing '#{Cucumber::Chef.containers_bin}'." }
+    logger.info { "-" * 8 }
+    @containers.each do |key, value|
+      logger.info { "SAVE CONTAINER: #{key.inspect} => #{value.inspect}" }
+    end
+
+    File.open(Cucumber::Chef.containers_bin, 'w') do |f|
+      f.puts(Marshal.dump(@containers))
+    end
+  end
+
 ################################################################################
 
   def container_create(name, distro, release, arch)
     unless container_exists?(name)
       cache_rootfs = container_cache_root(name, distro, release, arch)
       if !File.exists?(cache_rootfs)
-        log("$#{name}$ has triggered building the lxc file cache for $#{distro}$")
-        log("this one time process per distro can take up to 10 minutes or longer depending on the test lab")
+        logger.warn { "'#{name}' has triggered building the lxc file cache for '#{distro}'." }
+        logger.warn { "This one time process per distro can take up to 10 minutes or longer depending on the test lab." }
       end
 
       command_run_local(container_create_command(name, distro, release, arch))
 
+      commands = Array.new
+
       # install omnibus into the distro/release file cache if it's not already there
       omnibus_chef_client = File.join("/", "opt", "chef", "bin", "chef-client")
       omnibus_cache = File.join(cache_rootfs, omnibus_chef_client)
@@ -40,27 +68,32 @@ module Cucumber::Chef::Helpers::Container
       if !File.exists?(omnibus_cache)
         case distro.downcase
         when "ubuntu" then
-          command_run_local("chroot #{cache_rootfs} /bin/bash -c 'apt-get -y --force-yes install wget'")
+          commands << "chroot #{cache_rootfs} /bin/bash -c 'apt-get -y --force-yes install wget'"
         when "fedora" then
-          command_run_local("yum --nogpgcheck --installroot=#{cache_rootfs} -y install wget openssh-server")
+          commands << "yum --nogpgcheck --installroot=#{cache_rootfs} -y install wget openssh-server"
         end
-        command_run_local("chroot #{cache_rootfs} /bin/bash -c 'wget http://www.opscode.com/chef/install.sh -O - | bash'")
+        commands << "chroot #{cache_rootfs} /bin/bash -c 'locale-gen en_US'"
+        commands << "chroot #{cache_rootfs} /bin/bash -c 'wget http://www.opscode.com/chef/install.sh -O - | bash'"
         if distro.downcase == "fedora"
-          command_run_local("chroot #{cache_rootfs} /bin/bash -c 'rpm -Uvh --nodeps /tmp/*rpm'")
+          commands << "chroot #{cache_rootfs} /bin/bash -c 'rpm -Uvh --nodeps /tmp/*rpm'"
         end
-        command_run_local("lxc-destroy -n #{name}")
-        command_run_local(container_create_command(name, distro, release, arch))
+        commands << "lxc-destroy -n #{name}"
+        commands << container_create_command(name, distro, release, arch)
       end
 
-      command_run_local("mkdir -p #{File.join(container_root(name), Cucumber::Chef.lxc_user_home_dir, ".ssh")}")
-      command_run_local("chmod 0755 #{File.join(container_root(name), Cucumber::Chef.lxc_user_home_dir, ".ssh")}")
-      command_run_local("cat #{File.join(Cucumber::Chef.lab_user_home_dir, ".ssh", "id_rsa.pub")} | tee -a #{File.join(container_root(name), Cucumber::Chef.lxc_user_home_dir, ".ssh", "authorized_keys")}")
+      commands << <<-EOH
+mkdir -vp #{File.join(container_root(name), Cucumber::Chef.lxc_user_home_dir, ".ssh")}
+chmod 0700 #{File.join(container_root(name), Cucumber::Chef.lxc_user_home_dir, ".ssh")}
+cat #{File.join(Cucumber::Chef.lab_user_home_dir, ".ssh", "id_rsa.pub")} | tee -a #{File.join(container_root(name), Cucumber::Chef.lxc_user_home_dir, ".ssh", "authorized_keys")}
+
+rm -vf #{File.join(container_root(name), "etc", "motd")}
+cp -v /etc/motd #{File.join(container_root(name), "etc", "motd")}
+echo '    You are now logged in to the "#{name}" container!\n' | tee -a #{File.join(container_root(name), "etc", "motd")}
+echo '127.0.0.1 #{name}.#{Cucumber::Chef::Config.test_lab[:tld]} #{name}' | tee -a #{File.join(container_root(name), "etc", "hosts")}
+echo '#{name}.test-lab' | tee #{File.join(container_root(name), "etc", "hostname")}
+EOH
 
-      command_run_local("rm -f #{container_root(name)}/etc/motd")
-      command_run_local("cp /etc/motd #{container_root(name)}/etc/motd")
-      command_run_local("echo '    You are now logged in to the #{name} container!\n' >> #{container_root(name)}/etc/motd")
-      command_run_local("sed -i 's/localhost #{name}/#{name}.test-lab #{name} localhost/' #{container_root(name)}/etc/hosts")
-      command_run_local("echo '#{name}.test-lab' | tee #{container_root(name)}/etc/hostname")
+      command_run_local(commands.join("\n"))
     end
     container_start(name)
   end
@@ -71,21 +104,21 @@ module Cucumber::Chef::Helpers::Container
       chef_server_client_destroy(name)
       container_stop(name)
       command_run_local("lxc-destroy -n #{name}")
-      log("destroyed container $#{name}$")
+      logger.info { "Destroyed container '#{name}'." }
     end
   end
 
 ################################################################################
 
   def container_start(name)
-    status = command_run_local("lxc-info -n #{name}")
+    status = command_run_local("lxc-info -n #{name}").output
     if status.include?("STOPPED")
       command_run_local("lxc-start -d -n #{name}")
     end
   end
 
   def container_stop(name)
-    status = command_run_local("lxc-info -n #{name}")
+    status = command_run_local("lxc-info -n #{name}").output
     if status.include?("RUNNING")
       command_run_local("lxc-stop -n #{name}")
     end
@@ -94,7 +127,7 @@ module Cucumber::Chef::Helpers::Container
 ################################################################################
 
   def container_running?(name)
-    status = command_run_local("lxc-info -n #{name}")
+    status = command_run_local("lxc-info -n #{name}").output
     status.include?("RUNNING")
   end
 
@@ -109,7 +142,7 @@ module Cucumber::Chef::Helpers::Container
       f.puts("lxc.network.flags = up")
       f.puts("lxc.network.link = br0")
       f.puts("lxc.network.name = eth0")
-      f.puts("lxc.network.hwaddr = #{@servers[name][:mac]}")
+      f.puts("lxc.network.hwaddr = #{@containers[name][:mac]}")
       f.puts("lxc.network.ipv4 = 0.0.0.0")
     end
   end
@@ -140,7 +173,7 @@ module Cucumber::Chef::Helpers::Container
   def container_create_command(name, distro, release, arch)
     case distro.downcase
     when "ubuntu" then
-      "lxc-create -n #{name} -f /etc/lxc/#{name} -t #{distro} -- --release #{release} --arch #{arch}"
+      "DEBIAN_FRONTEND=noninteractive lxc-create -n #{name} -f /etc/lxc/#{name} -t #{distro} -- --release #{release} --arch #{arch}"
     when "fedora" then
       "lxc-create -n #{name} -f /etc/lxc/#{name} -t #{distro} -- --release #{release}"
     end