beaker 0.0.0 → 1.0.0

data/lib/beaker/host/unix.rb

@@ -1,6 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'host'))
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'command_factory'))
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'command'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'options'))
 
 module Unix
   class Host < Beaker::Host
@@ -17,7 +18,8 @@ module Unix
     include Unix::Pkg
 
     def self.pe_defaults
-      {
+      h = Beaker::Options::OptionsHash.new
+      h.merge({
         'user'          => 'root',
         'group'         => 'pe-puppet',
         'puppetpath'    => '/etc/puppetlabs/puppet',
@@ -29,11 +31,12 @@ module Unix
         'distmoduledir' => '/etc/puppetlabs/puppet/modules',
         'sitemoduledir' => '/opt/puppet/share/puppet/modules',
         'pathseparator' => ':',
-      }
+      })
     end
 
     def self.foss_defaults
-      {
+      h = Beaker::Options::OptionsHash.new
+      h.merge({
         'user'              => 'root',
         'group'             => 'puppet',
         'puppetpath'        => '/etc/puppet',
@@ -48,7 +51,7 @@ module Unix
         'distmoduledir'     => '/etc/puppet/modules',
         'sitemoduledir'     => '/usr/share/puppet/modules',
         'pathseparator'     => ':',
-      }
+      })
     end
   end
 end

data/lib/beaker/host/unix/pkg.rb

@@ -1,22 +1,52 @@
 module Unix::Pkg
   include Beaker::CommandFactory
 
-  def check_for_package name
+  def check_for_package(name)
     result = exec(Beaker::Command.new("which #{name}"), :acceptable_exit_codes => (0...127))
-    result.exit_code == 0
+    case self['platform']
+    when /solaris-10/
+      result.stdout =~ %r|/.*/#{name}|
+    else  
+      result.exit_code == 0
+    end
   end
 
-  def install_package name
-    if self['platform'] =~ /el-4/
-      @logger.debug("Package installation not supported on rhel4")
-    elsif self['platform'] =~ /(fedora)|(centos)|(el)/
-      execute("yum -y install #{name}")
-    elsif self['platform'] =~ /(ubuntu)|(debian)/
-      execute("apt-get update")
-      execute("apt-get install -y #{name}")
-    else
-      raise "Package #{name} cannot be installed on #{host}"
+  def install_package(name, cmdline_args = '')
+    case self['platform']
+      when /sles-/
+        execute("zypper --non-interactive in #{name}")
+      when /el-4/
+        @logger.debug("Package installation not supported on rhel4")
+      when /fedora|centos|el-/
+        execute("yum -y #{cmdline_args} install #{name}")
+      when /ubuntu|debian/
+        execute("apt-get update")
+        execute("apt-get install #{cmdline_args} -y #{name}")
+      when /solaris-11/
+        execute("pkg #{cmdline_args} install #{name}")
+      when /solaris-10/
+        execute("pkgutil -i -y #{cmdline_args} #{name}")
+      else
+        raise "Package #{name} cannot be installed on #{self}"
     end
   end
 
+  def uninstall_package(name, cmdline_args = '')
+    case self['platform']
+      when /sles-/
+        execute("zypper --non-interactive rm #{name}")
+      when /el-4/
+        @logger.debug("Package uninstallation not supported on rhel4")
+      when /fedora|centos|el-/
+        execute("yum -y #{cmdline_args} remove #{name}")
+      when /ubuntu|debian/
+        execute("apt-get purge #{cmdline_args} -y #{name}")
+      when /solaris-11/
+        execute("pkg #{cmdline_args} uninstall #{name}")
+      when /solaris-10/
+        execute("pkgutil -r -y #{cmdline_args} #{name}")
+      else
+        raise "Package #{name} cannot be installed on #{self}"
+    end
+  end
 end

data/lib/beaker/host/windows.rb

@@ -1,6 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'host'))
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'command_factory'))
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'command'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'options'))
 
 module Windows
   class Host < Beaker::Host
@@ -17,18 +18,21 @@ module Windows
     include Windows::Pkg
 
     def self.pe_defaults
-      {
+      h = Beaker::Options::OptionsHash.new
+      h.merge({
         'user'          => 'Administrator',
         'group'         => 'Administrators',
         'puppetpath'    => '`cygpath -smF 35`/PuppetLabs/puppet/etc',
         'puppetvardir'  => '`cygpath -smF 35`/PuppetLabs/puppet/var',
-        'puppetbindir'  => '`cygpath -F 38`/Puppet Labs/Puppet Enterprise/bin',
+        #if an x86 Program Files dir exists then use it, default to just Program Files
+        'puppetbindir'  => '$( [ -d "/cygdrive/c/Program Files (x86)" ] && echo "/cygdrive/c/Program Files (x86)" || echo "/cygdrive/c/Program Files" )/Puppet Labs/Puppet Enterprise/bin',
         'pathseparator' => ';',
-      }
+      })
     end
 
     def self.foss_defaults
-      {
+      h = Beaker::Options::OptionsHash.new
+      h.merge({
         'user'              => 'Administrator',
         'group'             => 'Administrators',
         'puppetpath'        => '`cygpath -smF 35`/PuppetLabs/puppet/etc',
@@ -38,7 +42,7 @@ module Windows
         # PATH related variables need to be Unix, which cygwin converts
         'hierabindir'       => '/opt/puppet-git-repos/hiera/bin',
         'pathseparator'     => ';',
-      }
+      })
     end
   end
 end

data/lib/beaker/host/windows/group.rb

@@ -5,7 +5,7 @@ module Windows::Group
     execute('cmd /c echo "" | wmic group where localaccount="true" get name /format:value') do |result|
       groups = []
       result.stdout.each_line do |line|
-        groups << (line.match(/^Name=([\w ]+)/) or next)[1]
+        groups << (line.match(/^Name=(.+)$/) or next)[1]
       end
 
       yield result if block_given?

data/lib/beaker/host/windows/pkg.rb

@@ -1,26 +1,59 @@
 module Windows::Pkg
   include Beaker::CommandFactory
 
-  def check_for_package name
+  def check_for_package(name)
     result = exec(Beaker::Command.new("which #{name}"), :acceptable_exit_codes => (0...127))
     result.exit_code == 0 
   end
 
-  def install_package name
+  def install_package(name, cmdline_args = '')
     cygwin = ""
     rootdir = ""
-    result = exec(Beaker::Command.new("wmic os get osarchitecture | grep 32"), :acceptable_exit_codes => (0...127))
-    if result.exit_code == 0 #32 bit version
-      rootdir = "c:\\\\cygwin"
-      cygwin = "setup-x86.exe"
-    else  #64 bit version
+
+    arch = identify_windows_architecture
+
+    if arch == '64'
       rootdir = "c:\\\\cygwin64"
       cygwin = "setup-x86_64.exe"
+    else #32 bit version
+      rootdir = "c:\\\\cygwin"
+      cygwin = "setup-x86.exe"
     end
+
     if not check_for_package(cygwin)
       execute("curl --retry 5 http://cygwin.com/#{cygwin} -o /cygdrive/c/Windows/System32/#{cygwin}")
     end
-    execute("#{cygwin} -q -n -N -d -R #{rootdir} -s http://cygwin.osuosl.org -P #{name}") 
+    execute("#{cygwin} -q -n -N -d -R #{cmdline_args} #{rootdir} -s http://cygwin.osuosl.org -P #{name}") 
+  end
+
+  def uninstall_package(name, cmdline_args = '')
+    raise "Package #{name} cannot be uninstalled on #{self}"
+  end
+
+  private
+
+  # @api private
+  def identify_windows_architecture
+    arch = nil
+    execute("echo '' | wmic os get osarchitecture", 
+            :acceptable_exit_codes => (0...127)) do |result|
+
+      arch = if result.exit_code == 0
+        result.stdout =~ /64/ ? '64' : '32'
+      else
+        identify_windows_architecture_from_os_name_for_win2003
+      end
+    end
+    arch
   end
 
+  # @api private
+  def identify_windows_architecture_from_os_name_for_win2003
+    arch = nil
+    execute("echo '' | wmic os get name | grep x64",
+            :acceptable_exit_codes => (0...127)) do |result|
+      arch = result.exit_code == 0 ? '64' : '32'
+    end
+    arch
+  end
 end

data/lib/beaker/hypervisor.rb

@@ -5,30 +5,43 @@ module Beaker
       @logger.debug "No post-provisioning configuration necessary for #{self.class.name} boxes"
     end
 
-    def self.create type, hosts_to_provision, options, config
+    def self.create(type, hosts_to_provision, options)
       @logger = options[:logger]
       @logger.notify("Beaker::Hypervisor, found some #{type} boxes to create") 
-      case type
+      hyper_class = case type
         when /aix/
-          Beaker::Aixer.new hosts_to_provision, options, config
+          Beaker::Aixer
         when /solaris/
-          Beaker::Solaris.new hosts_to_provision, options, config
+          Beaker::Solaris
         when /vsphere/
-          Beaker::Vsphere.new hosts_to_provision, options, config
+          Beaker::Vsphere
         when /fusion/
-          Beaker::Fusion.new hosts_to_provision, options, config
+          Beaker::Fusion
         when /blimpy/
-          Beaker::Blimper.new hosts_to_provision, options, config
+          Beaker::Blimper
         when /vcloud/
-          Beaker::Vcloud.new hosts_to_provision, options, config
+          if options['pooling_api']
+            Beaker::VcloudPooled
+          else
+            Beaker::Vcloud
+          end
         when /vagrant/
-          Beaker::Vagrant.new hosts_to_provision, options, config
+          Beaker::Vagrant
         end
+      hypervisor = hyper_class.new(hosts_to_provision, options)
+      hypervisor.provision
+
+      hypervisor
+    end
+
+    def provision
+      nil
     end
+
   end
 end
 
-%w( vsphere_helper vagrant fusion blimper vsphere vcloud aixer solaris).each do |lib|
+%w( vsphere_helper vagrant fusion blimper vsphere vcloud vcloud_pooled aixer solaris).each do |lib|
   begin
     require "hypervisor/#{lib}"
   rescue LoadError

data/lib/beaker/hypervisor/aixer.rb

@@ -1,35 +1,31 @@
-module Beaker 
+module Beaker
   class Aixer < Beaker::Hypervisor
 
-    def initialize(aix_hosts, options, config)
+    def initialize(aix_hosts, options)
       @options = options
-      @config = config['CONFIG'].dup
       @logger = options[:logger]
       @aix_hosts = aix_hosts
       #aix machines are reverted to known state, not a snapshot
-      fog_file = nil
-      if File.exists?( File.join(ENV['HOME'], '.fog') )
-        fog_file = YAML.load_file( File.join(ENV['HOME'], '.fog') )
+      @fog_file = nil
+      if File.exists?( @options[:dot_fog] )
+        @fog_file = YAML.load_file( @options[:dot_fog] )
       end
-      raise "Cant load ~/.fog config" unless fog_file
+      raise "Cant load #{@options[:dot_fog]} config" unless @fog_file
 
+    end
+
+    def provision
       # Running the rake task on rpm-builder
-      hypername = fog_file[:default][:aix_hypervisor_server]
-      hyperconf = {
-        'HOSTS'  => {
+      hypername = @fog_file[:default][:aix_hypervisor_server]
+      hyperopts = @options.dup
+      hyperopts['HOSTS'] = {
           hypername => { 'platform' => 'el-6-x86_64' }
-        },
-        'CONFIG' => {
-          'user' => fog_file[:default][:aix_hypervisor_username] || ENV['USER'],
-          'ssh'  => {
-            :keys => fog_file[:default][:aix_hypervisor_keyfile] || "#{ENV['HOME']}/.ssh/id_rsa"
-          }
-        }
       }
-      hyperconfig = Beaker::TestConfig.new( hyperconf, @options )
 
       @logger.notify "Connecting to hypervisor at #{hypername}"
-      hypervisor = Beaker::Host.create( hypername, @options, hyperconfig )
+      hypervisor = Beaker::Host.create( hypername, hyperopts )
+      hypervisor[:user] = @fog_file[:default][:aix_hypervisor_username] || hypervisor[:user]
+      hypervisor[:ssh][:keys] = [@fog_file[:default][:aix_hypervisor_keyfile]] || hypervisor[:ssh][:keys]
 
       @aix_hosts.each do |host|
         vm_name = host['vmname'] || host.name

data/lib/beaker/hypervisor/blimper.rb

@@ -1,3 +1,6 @@
+require 'blimpy'
+require 'yaml' unless defined?(YAML)
+
 module Beaker 
   class Blimper < Beaker::Hypervisor
 
@@ -21,93 +24,89 @@ module Beaker
       ports
     end
 
-  def initialize(blimpy_hosts, options, config)
-    @options = options
-    @config = config['CONFIG'].dup
-    @logger = options[:logger]
-    @blimpy_hosts = blimpy_hosts
-    require 'rubygems' unless defined?(Gem)
-    require 'yaml' unless defined?(YAML)
-    begin
-      require 'blimpy'
-    rescue LoadError
-      raise "Unable to load Blimpy, please ensure its installed"
+    def initialize(blimpy_hosts, options)
+      @options = options
+      @logger = options[:logger]
+      @blimpy_hosts = blimpy_hosts
+      @blimpy = Blimpy
     end
-    ami_spec= YAML.load_file('config/image_templates/ec2.yaml')["AMI"]
 
-    fleet = Blimpy.fleet do |fleet|
-      @blimpy_hosts.each do |host|
-        amitype = host['vmname'] || host['platform']
-        amisize = host['amisize'] || 'm1.small'
-        #use snapshot provided for this host 
-        image_type = host['snapshot'] 
-        if not image_type
-          raise "No snapshot/image_type provided for blimpy provisioning"
-        end
-        ami = ami_spec[amitype]
-        fleet.add(:aws) do |ship|
-          ship.name = host.name
-          ship.ports = amiports(host)
-          ship.image_id = ami[:image][image_type.to_sym]
-          if not ship.image_id
-            raise "No image_id found for host #{ship.name} (#{amitype}:#{amisize}) using snapshot/image_type #{image_type}"
+    def provision
+      ami_spec= YAML.load_file(@options[:ec2_yaml])["AMI"]
+
+      fleet = @blimpy.fleet do |fleet|
+        @blimpy_hosts.each do |host|
+          amitype = host['vmname'] || host['platform']
+          amisize = host['amisize'] || 'm1.small'
+          #use snapshot provided for this host 
+          image_type = host['snapshot'] 
+          if not image_type
+            raise "No snapshot/image_type provided for blimpy provisioning"
+          end
+          ami = ami_spec[amitype]
+          fleet.add(:aws) do |ship|
+            ship.name = host.name
+            ship.ports = amiports(host)
+            ship.image_id = ami[:image][image_type.to_sym]
+            if not ship.image_id
+              raise "No image_id found for host #{ship.name} (#{amitype}:#{amisize}) using snapshot/image_type #{image_type}"
+            end
+            ship.flavor = amisize
+            ship.region = ami[:region]
+            ship.username = 'root'
           end
-          ship.flavor = amisize
-          ship.region = ami[:region]
-          ship.username = 'root'
+          @logger.debug "Added #{host.name} (#{amitype}:#{amisize}) using snapshot/image_type #{image_type} to blimpy fleet"
         end
-        @logger.debug "Added #{host.name} (#{amitype}:#{amisize}) using snapshot/image_type #{image_type} to blimpy fleet"
       end
-    end
 
-    # Attempt to start the fleet, we wrap it with some error handling that deals
-    # with generic Fog errors and retrying in case these errors are transient.
-    fleet_retries = 0
-    begin
-      fleet.start
-    rescue Fog::Errors::Error => ex
-      fleet_retries += 1
-      if fleet_retries <= 3
-        sleep_time = rand(10) + 10
-        @logger.notify("Calling fleet.destroy, sleeping #{sleep_time} seconds and retrying fleet.start due to Fog::Errors::Error (#{
-ex.message}), retry attempt #{fleet_retries}.")
-        begin
-          timeout(30) do
-            fleet.destroy
+      # Attempt to start the fleet, we wrap it with some error handling that deals
+      # with generic Fog errors and retrying in case these errors are transient.
+      fleet_retries = 0
+      begin
+        fleet.start
+      rescue Fog::Errors::Error => ex
+        fleet_retries += 1
+        if fleet_retries <= 3
+          sleep_time = rand(10) + 10
+          @logger.notify("Calling fleet.destroy, sleeping #{sleep_time} seconds and retrying fleet.start due to Fog::Errors::Error (#{
+  ex.message}), retry attempt #{fleet_retries}.")
+          begin
+            timeout(30) do
+              fleet.destroy
+            end
+          rescue
           end
-        rescue
+          sleep sleep_time
+          retry
+        else
+          @logger.error("Retried Fog #{fleet_retries} times, giving up and throwing the exception")
+          raise ex
         end
-        sleep sleep_time
-        retry
-      else
-        @logger.error("Retried Fog #{fleet_retries} times, giving up and throwing the exception")
-        raise ex
       end
-    end
 
-    # Configure our nodes to match the blimp fleet
-    # Also generate hosts entries for the fleet, since we're iterating
-    etc_hosts = "127.0.0.1\tlocalhost localhost.localdomain\n"
-    fleet.ships.each do |ship|
-      ship.wait_for_sshd
-      name = ship.name
-      host = @blimpy_hosts.select { |host| host.name == name }[0]
-      host['ip'] = ship.dns
-      host.exec(Command.new("hostname #{name}"))
-      ip = get_ip(host) 
-      domain = get_domain_name(host)
-      etc_hosts += "#{ip}\t#{name}\t#{name}.#{domain}\n"
-    end
+      # Configure our nodes to match the blimp fleet
+      # Also generate hosts entries for the fleet, since we're iterating
+      etc_hosts = "127.0.0.1\tlocalhost localhost.localdomain\n"
+      fleet.ships.each do |ship|
+        ship.wait_for_sshd
+        name = ship.name
+        host = @blimpy_hosts.select { |host| host.name == name }[0]
+        host['ip'] = ship.dns
+        host.exec(Command.new("hostname #{name}"))
+        ip = get_ip(host) 
+        domain = get_domain_name(host)
+        etc_hosts += "#{ip}\t#{name}\t#{name}.#{domain}\n"
+      end
 
-    # Send our hosts information to the nodes
-    @blimpy_hosts.each do |host|
-      set_etc_hosts(host, etc_hosts)
-    end
+      # Send our hosts information to the nodes
+      @blimpy_hosts.each do |host|
+        set_etc_hosts(host, etc_hosts)
+      end
 
     end #revert_blimpy
 
     def cleanup
-      fleet = Blimpy.fleet do |fleet|
+      fleet = @blimpy.fleet do |fleet|
         @blimpy_hosts.each do |host|
           fleet.add(:aws) do |ship|
             ship.name = host.name