cucumber-chef 2.0.4 → 2.0.5

data/.travis.yml

@@ -1,15 +1,12 @@
 language: ruby
 
 rvm:
-  - ree-1.8.7
-  - 1.8.7
   - 1.9.2
   - 1.9.3
 
 branches:
   only:
     - master
-    - 2.0.0.rc1
 
 notifications:
   irc:

data/TODO.md

@@ -5,21 +5,21 @@
 * Various OS baseboxes
 * Make it easy to use OSC server
 * Provide a libvirt capability
-* Ship a release candidate
 * Write test for cucumber-chef ssh
 * Write tests for the stuff pulled from cucumber-nagios
 * Make recipes food-critic compliant
 * Fork ubuntu ami to 'amy'
-* Merge Zach's changes
 * Get cukes passing
 * Improve cuke coverage to include all functionality described in the help task
 * Plug into Relish
-* Refactor ssh and connect into one ssh task that takes an optional container
 
 ## DONE
 
 * RC branch
 * Go through the bugs
+* Merge Zach's changes
+* Ship a release candidate
+* Refactor ssh and connect into one ssh task that takes an optional container
 
 ## IDEAS
 

data/bin/cc-knife

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 require 'cucumber-chef'
 
-$logger = Cucumber::Chef::Logger.new
-$logger.level = (Cucumber::Chef.is_rc? ? Cucumber::Chef::Logger::DEBUG : Cucumber::Chef::Logger::INFO)
+$logger = ZTK::Logger.new(Cucumber::Chef.log_file)
+Cucumber::Chef.is_rc? and ($logger.level = ZTK::Logger::DEBUG)
 
 # if we have bundler binstubs use that; otherwise attempt to detect
 knife = (Cucumber::Chef.locate(:file, "bin", "knife") rescue nil)

data/bin/cc-push

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+require 'cucumber-chef'
+
+def run(command)
+  puts "Executing: '#{command}'"
+  @ssh.exec(command)
+end
+
+$logger = ZTK::Logger.new(Cucumber::Chef.log_file)
+Cucumber::Chef.is_rc? and ($logger.level = ZTK::Logger::DEBUG)
+
+message = "cc-push v#{Cucumber::Chef::VERSION}"
+puts(message)
+$logger.info { message }
+
+Cucumber::Chef::Config.load
+if (test_lab = Cucumber::Chef::TestLab.new) && (test_lab.labs_running.count > 0)
+  @ssh = ZTK::SSH.new
+  @ssh.config.host_name = test_lab.labs_running.first.public_ip_address
+  @ssh.config.user = "ubuntu"
+  @ssh.config.keys = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{@ssh.config.user}")
+
+  gem_name = "cucumber-chef-#{Cucumber::Chef::VERSION}.gem"
+
+  puts %x(cd #{Cucumber::Chef.root} && gem build cucumber-chef.gemspec -V)
+
+  local_file = File.join(Cucumber::Chef.root, gem_name)
+  remote_file = File.join("/", "home", @ssh.config.user, gem_name)
+  puts("#{local_file} -> #{@ssh.config.user}@#{test_lab.labs_running.first.public_ip_address}:#{remote_file}")
+  @ssh.upload(local_file, remote_file)
+  FileUtils.rm_f(File.join(Cucumber::Chef.root, "*.gem"))
+
+  run("cd #{File.dirname(remote_file)}; ls -la | grep 'cucumber-chef-'; sudo gem uninstall cucumber-chef -a -I -x -V; rm -f /usr/lib/ruby/gems/1.8/cache/#{gem_name}; sudo gem install #{gem_name} -l -V; rm -f *.gem")
+
+else
+  puts("No running cucumber-chef test labs to connect to!")
+  exit(1)
+end

data/bin/cc-server

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+if RUBY_VERSION < "1.9"
+  exit if fork
+  Process.setsid
+  exit if fork
+  Dir.chdir "/"
+  STDIN.reopen "/dev/null"
+  STDOUT.reopen "/dev/null", "a"
+  STDERR.reopen "/dev/null", "a"
+else
+  Process.daemon
+end
+
+Dir.chdir(File.join("/home", "ubuntu"))
+
+require 'drb/drb'
+require 'drb/acl'
+require 'cucumber-chef'
+require 'cucumber/chef/helpers'
+
+class FrontObject
+  attr_accessor :servers
+
+  include Cucumber::Chef
+  include Cucumber::Chef::Helpers
+
+  def initialize
+    knife_rb = Cucumber::Chef.locate(:file, ".chef", "knife.rb")
+    Chef::Config.from_file(knife_rb)
+  end
+
+  def shutdown
+    DRb.stop_service
+  end
+
+end
+
+hostname = %x( hostname -f ).chomp
+
+list = %w( deny all allow 127.0.0.1 )
+ARGV[0] and (list += [ 'allow', ARGV[0] ])
+acl = ACL.new(list)
+
+# This will break everything:
+# $SAFE = 1
+
+DRb.start_service("druby://:8787", FrontObject.new)
+DRb.thread.join

data/bin/cucumber-chef

@@ -57,8 +57,8 @@ class CucumberChef < Thor
         exit(255)
       end
 
-      $logger = Cucumber::Chef::Logger.new
-      Cucumber::Chef.is_rc? and ($logger.level = Cucumber::Chef::Logger::DEBUG)
+      $logger = ZTK::Logger.new(Cucumber::Chef.log_file)
+      Cucumber::Chef.is_rc? and ($logger.level = ZTK::Logger::DEBUG)
 
       message = "cucumber-chef v#{Cucumber::Chef::VERSION}"
       puts(set_color(message, :green, true))
@@ -259,26 +259,25 @@ class CucumberChef < Thor
 
     puts
     if (test_lab = Cucumber::Chef::TestLab.new) && (test_lab.labs_running.count > 0)
-      ssh = Cucumber::Chef::SSH.new
+      ssh = ZTK::SSH.new
 
       if args.size == 0
-        ssh.config[:host] = test_lab.labs_running.first.public_ip_address
-        ssh.config[:ssh_user] = "ubuntu"
-        ssh.config[:identity_file] = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config[:ssh_user]}")
+        ssh.config.host_name = test_lab.labs_running.first.public_ip_address
+        ssh.config.user = "ubuntu"
+        ssh.config.keys = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config.user}")
 
         puts([set_color("Attempting SSH connection to cucumber-chef '", :blue, true), set_color("test lab", :cyan, true), set_color("'...", :blue, true)].join)
         ssh.console
       else
         container = args[0]
 
-        ssh.config[:proxy] = true
-        ssh.config[:proxy_host] = test_lab.labs_running.first.public_ip_address
-        ssh.config[:proxy_ssh_user] = "ubuntu"
-        ssh.config[:proxy_identity_file] = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config[:proxy_ssh_user]}")
+        ssh.config.proxy_host_name = test_lab.labs_running.first.public_ip_address
+        ssh.config.proxy_user = "ubuntu"
+        ssh.config.proxy_keys = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config.proxy_user}")
 
-        ssh.config[:host] = container
-        ssh.config[:ssh_user] = "root"
-        ssh.config[:identity_file] = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config[:proxy_ssh_user]}")
+        ssh.config.host_name = container
+        ssh.config.user = "root"
+        ssh.config.keys = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config.proxy_user}")
 
         puts([set_color("Attempting SSH connection to cucumber-chef container '", :blue, true), set_color(container, :cyan, true), set_color("'...", :blue, true)].join)
         ssh.console
@@ -305,16 +304,15 @@ class CucumberChef < Thor
 
     puts
     if (test_lab = Cucumber::Chef::TestLab.new) && (test_lab.labs_running.count > 0)
-      ssh = Cucumber::Chef::SSH.new
+      ssh = ZTK::SSH.new
 
-      ssh.config[:proxy] = true
-      ssh.config[:proxy_host] = test_lab.labs_running.first.public_ip_address
-      ssh.config[:proxy_ssh_user] = "ubuntu"
-      ssh.config[:proxy_identity_file] = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config[:proxy_ssh_user]}")
+      ssh.config.proxy_host_name = test_lab.labs_running.first.public_ip_address
+      ssh.config.proxy_user = "ubuntu"
+      ssh.config.proxy_keys = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config.proxy_user}")
 
-      ssh.config[:host] = container
-      ssh.config[:ssh_user] = "root"
-      ssh.config[:identity_file] = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config[:proxy_ssh_user]}")
+      ssh.config.host_name = container
+      ssh.config.user = "root"
+      ssh.config.keys = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config.proxy_user}")
 
       puts([set_color("Attempting to collect diagnostic information on cucumber-chef container '", :blue, true), set_color(container, :cyan, true), set_color("'...", :blue, true)].join)
       if @options.strace?
@@ -362,11 +360,11 @@ class CucumberChef < Thor
 
     puts
     if (test_lab = Cucumber::Chef::TestLab.new) && (test_lab.labs_running.count > 0)
-      ssh = Cucumber::Chef::SSH.new
+      ssh = ZTK::SSH.new
 
-      ssh.config[:host] = test_lab.labs_running.first.public_ip_address
-      ssh.config[:ssh_user] = "ubuntu"
-      ssh.config[:identity_file] = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config[:ssh_user]}")
+      ssh.config.host_name = test_lab.labs_running.first.public_ip_address
+      ssh.config.user = "ubuntu"
+      ssh.config.keys = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{ssh.config.user}")
 
       puts(set_color("Getting container processes from cucumber-chef test lab...", :blue, true))
       puts
@@ -420,32 +418,6 @@ class CucumberChef < Thor
     fatal(e)
   end
 
-################################################################################
-
-  desc "test [cucumber-options]", "Test a project using the cucumber-chef test suite."
-  method_option :destroy, :type => :boolean, :desc => "destroy all containers before test run", :aliases => "-z", :default => false
-  def test(*args)
-    load_config
-
-    puts
-    root_path = Cucumber::Chef.locate_parent(".cucumber-chef")
-    features_path = File.expand_path(File.join(root_path, "features"))
-
-    unless (File.exists?(features_path) && File.directory?(features_path))
-      raise Error, "Features directory '#{features_path}' does not exist."
-    else
-      puts("Using features directory: #{features_path}")
-    end
-
-    runner = Cucumber::Chef::TestRunner.new(features_path)
-    runner.run(@options.destroy?, args)
-    puts
-
-  rescue Cucumber::Chef::Error => e
-    $logger.fatal { e.backtrace.join("\n") }
-    fatal(e)
-  end
-
 ################################################################################
 
 end

data/cucumber-chef.gemspec

@@ -36,18 +36,18 @@ Gem::Specification.new do |s|
 
   s.add_dependency("chef", ">= 0.10.10")
   s.add_dependency("cucumber", ">= 1.2.0")
-  s.add_dependency("erubis", ">= 2.7.0")
   s.add_dependency("fog", ">= 1.3.1")
-  s.add_dependency("net-sftp", ">= 2.0.5")
-  s.add_dependency("net-ssh",  ">= 2.2.2")
   s.add_dependency("mixlib-config", ">= 1.1.2")
   s.add_dependency("thor", ">= 0.15.2")
   s.add_dependency("rake", ">= 0.9.2")
   s.add_dependency("ubuntu_ami", ">= 0.4.0")
+  s.add_dependency("rspec", ">= 2.10.0")
+  s.add_dependency("ztk")
 
-  s.add_development_dependency("rspec", ">= 2.10.0")
   s.add_development_dependency("simplecov", ">= 0.6.4")
   s.add_development_dependency("pry")
+  s.add_development_dependency("yard")
+  s.add_development_dependency("redcarpet")
 
   s.files        = `git ls-files`.split("\n")
   s.test_files   = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/cucumber/chef.rb

@@ -27,14 +27,11 @@ require 'stringio'
 
 require 'chef'
 require 'chef/cookbook_uploader'
-require 'erubis'
 require 'fog'
 require 'json'
 require 'mixlib/config'
-require 'net/ssh'
-require 'net/ssh/proxy/command'
-require 'net/sftp'
 require 'ubuntu_ami'
+require 'ztk'
 
 ################################################################################
 
@@ -46,16 +43,9 @@ module Cucumber
     class Error < StandardError; end
 
     autoload :Bootstrap, 'cucumber/chef/bootstrap'
-    autoload :Bootstrap, 'cucumber/chef/bootstrap'
-    autoload :Command, 'cucumber/chef/command'
     autoload :Config, 'cucumber/chef/config'
-    autoload :Logger, 'cucumber/chef/logger'
     autoload :Provisioner, 'cucumber/chef/provisioner'
-    autoload :SSH, 'cucumber/chef/ssh'
-    autoload :TCPSocket, 'cucumber/chef/tcp_socket'
-    autoload :Template, 'cucumber/chef/template'
     autoload :TestLab, 'cucumber/chef/test_lab'
-    autoload :TestRunner, 'cucumber/chef/test_runner'
 
     require 'cucumber/chef/utility'
     extend(Cucumber::Chef::Utility)

data/lib/cucumber/chef/bootstrap.rb

@@ -33,7 +33,7 @@ module Cucumber
         @stdout, @stderr, @stdin = stdout, stderr, stdin
         @stdout.sync = true if @stdout.respond_to?(:sync=)
 
-        @ssh = Cucumber::Chef::SSH.new(@stdout, @stderr, @stdin)
+        @ssh = ZTK::SSH.new(:stdout => @stdout, :stderr => @stderr, :stdin => @stdin)
         @config = Hash.new(nil)
         @config[:context] = Hash.new(nil)
       end
@@ -69,14 +69,14 @@ module Cucumber
 
         $logger.debug { "prepare(#{@config[:host]})" }
 
-        @ssh.config[:host] = @config[:host]
-        @ssh.config[:ssh_user] = @config[:ssh_user]
-        @ssh.config[:ssh_password] = @config[:ssh_password]
-        @ssh.config[:identity_file] = @config[:identity_file]
-        @ssh.config[:timeout] = 5
+        @ssh.config.host_name = @config[:host]
+        @ssh.config.user = @config[:ssh_user]
+        @ssh.config.password = @config[:ssh_password]
+        @ssh.config.keys = @config[:identity_file]
+        @ssh.config.timeout = 5
 
         $logger.debug { "template_file(#{@config[:template_file]})" }
-        command = Cucumber::Chef::Template.render(@config[:template_file], @config[:context])
+        command = ZTK::Template.render(@config[:template_file], @config[:context])
         command = "sudo #{command}" if @config[:use_sudo]
 
         $logger.debug { "begin(#{@config[:host]})" }

data/lib/cucumber/chef/helpers.rb

@@ -22,10 +22,10 @@
 module Cucumber
   module Chef
 
+    # This module includes all of the helper methods meant to drive step
+    # definitions.
     module Helpers
 
-################################################################################
-
       require 'cucumber/chef/helpers/chef_client'
       require 'cucumber/chef/helpers/chef_server'
       require 'cucumber/chef/helpers/command'
@@ -34,8 +34,6 @@ module Cucumber
       require 'cucumber/chef/helpers/test_lab'
       require 'cucumber/chef/helpers/utility'
 
-################################################################################
-
       def self.included(base)
         base.send(:include, Cucumber::Chef::Helpers::ChefClient)
         base.send(:include, Cucumber::Chef::Helpers::ChefServer)
@@ -46,11 +44,7 @@ module Cucumber
         base.send(:include, Cucumber::Chef::Helpers::Utility)
       end
 
-################################################################################
-
     end
 
   end
 end
-
-################################################################################

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

@@ -43,6 +43,7 @@ module Cucumber::Chef::Helpers::ChefServer
     end
     cookbook_repo = ::Chef::CookbookLoader.new(cookbook_path)
     cookbook_repo.each do |name, cbook|
+      next if name != cookbook
       ::Chef::CookbookUploader.new(cbook, cookbook_path, :force => true).upload_cookbooks
       log("chef-server", "uploaded cookbook '#{cookbook}' from path '#{cookbook_path}'")
     end

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

@@ -25,6 +25,9 @@ module Cucumber::Chef::Helpers::Container
 
   def container_create(name, distro, release, arch)
     unless container_exists?(name)
+      chef_server_node_destroy(name)
+      chef_server_client_destroy(name)
+
       cache_rootfs = container_cache_root(name, distro, release, arch)
       log(name, "has triggered first time lxc distro cache build; this will take a while") if !File.exists?(cache_rootfs)
 
@@ -34,9 +37,9 @@ module Cucumber::Chef::Helpers::Container
       omnibus_chef_client = File.join("/", "opt", "opscode", "bin", "chef-client")
       if !File.exists?(File.join(cache_rootfs, omnibus_chef_client))
         case distro.downcase
-        when "ubuntu":
-          %x(chroot #{cache_rootfs} /bin/bash -c 'apt-get -y --force-yes install wget' 2>&1)
-        when "fedora":
+        when "ubuntu" then
+          %x( chroot #{cache_rootfs} /bin/bash -c 'apt-get -y --force-yes install wget' 2>&1 )
+        when "fedora" then
           %x( yum --nogpgcheck --installroot=#{cache_rootfs} -y install wget openssh-server )
         end
         %x( chroot #{cache_rootfs} /bin/bash -c 'wget http://opscode.com/chef/install.sh -O - | bash' 2>&1 )
@@ -110,7 +113,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 = #{@servers[name][:mac]}")
       f.puts("lxc.network.ipv4 = 0.0.0.0")
     end
   end
@@ -131,18 +134,18 @@ module Cucumber::Chef::Helpers::Container
 
   def container_cache_root(name, distro, release, arch)
     case distro.downcase
-    when "ubuntu":
+    when "ubuntu" then
       cache_root = File.join("/", "var", "cache", "lxc", release, "rootfs-#{arch}")
-    when "fedora":
+    when "fedora" then
       cache_root = File.join("/", "var", "cache", "lxc", distro, arch, release, "rootfs")
     end
   end
 
   def container_create_command(name, distro, release, arch)
     case distro.downcase
-    when "ubuntu":
+    when "ubuntu" then
       "lxc-create -n #{name} -f /etc/lxc/#{name} -t #{distro} -- --release #{release} --arch #{arch}"
-    when "fedora":
+    when "fedora" then
       "lxc-create -n #{name} -f /etc/lxc/#{name} -t #{distro} -- --release #{release}"
     end
   end

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

@@ -25,16 +25,16 @@ module Cucumber::Chef::Helpers::Server
 
   def detect_arch(distro)
     case distro.downcase
-    when "ubuntu":
+    when "ubuntu" then
       ((RUBY_PLATFORM =~ /x86_64/) ? "amd64" : "i386")
-    when "fedora":
+    when "fedora" then
       ((RUBY_PLATFORM =~ /x86_64/) ? "amd64" : "i686")
     end
   end
 
   def server_create(name, attributes={})
-    if ((attributes[:persist] && $servers[name]) || ($servers[name] && $servers[name][:persist]))
-      attributes = $servers[name]
+    if ((attributes[:persist] && @servers[name]) || (@servers[name] && @servers[name][:persist]))
+      attributes = @servers[name]
     else
       server_destroy(name) if (container_exists?(name) && (ENV['DESTROY'] == "1"))
       attributes = { :ip => generate_ip,
@@ -44,20 +44,20 @@ module Cucumber::Chef::Helpers::Server
                      :release => "lucid",
                      :arch => detect_arch(attributes[:distro] || "ubuntu") }.merge(attributes)
     end
-    $servers = ($servers || Hash.new(nil)).merge(name => attributes)
-    $current_server = $servers[name][:ip]
+    @servers = (@servers || Hash.new(nil)).merge(name => attributes)
+    $current_server = @servers[name][:ip]
     if !server_running?(name)
-      log(name, "is being provisioned") if $servers[name]
+      log(name, "is being provisioned") if @servers[name]
 
       test_lab_config_dhcpd
       container_config_network(name)
-      container_create(name, $servers[name][:distro], $servers[name][:release], $servers[name][:arch])
-      Cucumber::Chef::TCPSocket.new($servers[name][:ip], 22).wait
+      container_create(name, @servers[name][:distro], @servers[name][:release], @servers[name][:arch])
+      ZTK::TCPSocketCheck.new(:host => @servers[name][:ip], :port => 22).wait
     end
   end
 
   def server_destroy(name)
-    log(name, "is being destroyed") if $servers[name]
+    log(name, "is being destroyed") if @servers[name]
 
     container_destroy(name)
   end