beaker 0.0.0 → 1.0.0

data/lib/beaker/hypervisor/vcloud_pooled.rb

@@ -0,0 +1,97 @@
+require 'yaml' unless defined?(YAML)
+require 'json'
+require 'net/http'
+
+module Beaker 
+  class VcloudPooled < Beaker::Hypervisor
+    CHARMAP = [('a'..'z'),('0'..'9')].map{|r| r.to_a}.flatten
+    SSH_EXCEPTIONS = [
+      SocketError,
+      Timeout::Error,
+      Errno::ETIMEDOUT,
+      Errno::EHOSTDOWN,
+      Errno::EHOSTUNREACH,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::ENETUNREACH,
+    ]
+
+    def initialize(vcloud_hosts, options)
+      @options = options
+      @logger = options[:logger]
+      @vcloud_hosts = vcloud_hosts
+
+      raise 'You must specify a datastore for vCloud instances!' unless @options['datastore']
+      raise 'You must specify a resource pool for vCloud instances!' unless @options['resourcepool']
+      raise 'You must specify a folder for vCloud instances!' unless @options['folder']
+    end
+
+    def provision
+      start = Time.now
+      try = 1
+      @vcloud_hosts.each_with_index do |h, i|
+        if h['template'] =~ /\//
+          templatefolders = h['template'].split('/')
+          h['template'] = templatefolders.pop
+        end
+
+        @logger.notify "Requesting '#{h['template']}' VM from vCloud host pool"
+
+        begin
+          uri = URI.parse(@options['pooling_api']+'/vm/'+h['template'])
+
+          http = Net::HTTP.new( uri.host, uri.port )
+          request = Net::HTTP::Post.new(uri.request_uri)
+
+          request.set_form_data({'pool' => @options['resourcepool'], 'folder' => 'foo'})
+
+          attempts = @options[:timeout].to_i / 5
+          response = http.request(request)
+          parsed_response = JSON.parse(response.body)
+          if parsed_response[h['template']] && parsed_response[h['template']]['ok'] && parsed_response[h['template']]['hostname'] 
+            h['vmhostname'] = parsed_response[h['template']]['hostname']
+          else
+            raise "VcloudPooled.provision - no vCloud host free for #{h.name} in pool"
+          end
+        rescue JSON::ParserError, RuntimeError, *SSH_EXCEPTIONS => e
+          if try <= attempts
+            sleep 5
+            try += 1
+            retry
+          end
+          report_and_raise(@logger, e, 'vCloudPooled.provision')
+        end
+
+        @logger.notify "Using available vCloud host '#{h['vmhostname']}' (#{h.name})"
+      end
+
+      @logger.notify 'Spent %.2f seconds grabbing VMs' % (Time.now - start)
+    end
+
+    def cleanup
+      vm_names = @vcloud_hosts.map {|h| h['vmhostname'] }.compact
+      if @vcloud_hosts.length != vm_names.length
+        @logger.warn "Some hosts did not have vmhostname set correctly! This likely means VM provisioning was not successful"
+      end
+
+      start = Time.now
+      vm_names.each do |name|
+        @logger.notify "Handing '#{name}' back to pooling API for VM destruction"
+
+        uri = URI.parse(@options['pooling_api']+'/vm/'+name)
+
+        http = Net::HTTP.new( uri.host, uri.port )
+        request = Net::HTTP::Delete.new(uri.request_uri)
+
+        begin
+          response = http.request(request)
+        rescue *SSH_EXCEPTIONS => e
+          report_and_raise(@logger, e, 'vCloudPooled.cleanup (http.request)')
+        end
+      end 
+
+      @logger.notify "Spent %.2f seconds cleaning up" % (Time.now - start)
+    end
+
+  end
+end

data/lib/beaker/hypervisor/vsphere.rb

@@ -1,13 +1,16 @@
+require 'yaml' unless defined?(YAML)
+
 module Beaker 
   class Vsphere < Beaker::Hypervisor
 
-    def initialize(vsphere_hosts, options, config)
+    def initialize(vsphere_hosts, options)
       @options = options
-      @@config = config['CONFIG'].dup
       @logger = options[:logger]
       @vsphere_hosts = vsphere_hosts
-      require 'yaml' unless defined?(YAML)
-      vsphere_credentials = VsphereHelper.load_config
+    end
+
+    def provision
+      vsphere_credentials = VsphereHelper.load_config(@options[:dot_fog])
 
       @logger.notify "Connecting to vSphere at #{vsphere_credentials[:server]}" +
         " with credentials for #{vsphere_credentials[:user]}"
@@ -50,7 +53,7 @@ module Beaker
 
     def cleanup
       @logger.notify "Destroying vsphere boxes"
-      vsphere_credentials = VsphereHelper.load_config
+      vsphere_credentials = VsphereHelper.load_config(@options[:dot_fog])
 
       @logger.notify "Connecting to vSphere at #{vsphere_credentials[:server]}" +
         " with credentials for #{vsphere_credentials[:user]}"

data/lib/beaker/hypervisor/vsphere_helper.rb

@@ -1,5 +1,5 @@
 require 'yaml' unless defined?(YAML)
-require 'rubygems' unless defined?(Gem)
+require 'rbvmomi'
 begin
   require 'beaker/logger'
 rescue LoadError
@@ -7,35 +7,29 @@ rescue LoadError
 end
 
 class VsphereHelper
-  def initialize vInfo = {}
+  def initialize vInfo
     @logger = vInfo[:logger] || Beaker::Logger.new
-    begin
-      require 'rbvmomi'
-    rescue LoadError
-      raise "Unable to load RbVmomi, please ensure its installed"
-    end
     @connection = RbVmomi::VIM.connect :host     => vInfo[:server],
                                        :user     => vInfo[:user],
                                        :password => vInfo[:pass],
                                        :insecure => true
   end
 
-  def self.load_config
+  def self.load_config(dot_fog = '.fog')
     # support Fog/Cloud Provisioner layout
     # (ie, someplace besides my made up conf)
     vsphere_credentials = nil
-    if File.exists? '/etc/plharness/vsphere'
-      vsphere_credentials = load_legacy_credentials
-
-    elsif File.exists?( File.join(ENV['HOME'], '.fog') )
-      vsphere_credentials = load_fog_credentials
+    if File.exists?( dot_fog )
+      vsphere_credentials = load_fog_credentials(dot_fog)
+    else
+      raise ArgumentError, ".fog file '#{dot_fog}' does not exist"
     end
 
     return vsphere_credentials
   end
 
-  def self.load_fog_credentials
-    vInfo = YAML.load_file( File.join(ENV['HOME'], '.fog') )
+  def self.load_fog_credentials(dot_fog = '.fog')
+    vInfo = YAML.load_file( dot_fog )
 
     vsphere_credentials = {}
     vsphere_credentials[:server] = vInfo[:default][:vsphere_server]
@@ -45,24 +39,6 @@ class VsphereHelper
     return vsphere_credentials
   end
 
-  def self.load_legacy_credentials
-    vInfo = YAML.load_file '/etc/plharness/vsphere'
-
-    puts(
-      "Use of /etc/plharness/vsphere as a config file is deprecated.\n" +
-      "Please use ~/.fog instead\n" +
-      "See http://docs.puppetlabs.com/pe/2.0/" +
-      "cloudprovisioner_configuring.html for format"
-    )
-
-    vsphere_credentials = {}
-    vsphere_credentials[:server] = vInfo['location']
-    vsphere_credentials[:user]   = vInfo['user']
-    vsphere_credentials[:pass]   = vInfo['pass']
-
-    return vsphere_credentials
-  end
-
   def find_snapshot vm, snapname
     search_child_snaps vm.snapshot.rootSnapshotList, snapname
   end
@@ -193,6 +169,40 @@ class VsphereHelper
     })
   end
 
+  def wait_for_tasks tasks, try, attempts
+    obj_set = tasks.map { |task| { :obj => task } }
+    filter = @connection.propertyCollector.CreateFilter(
+      :spec => {
+        :propSet => [{ :type => 'Task',
+                       :all  => false,
+                       :pathSet => ['info.state']}],
+        :objectSet => obj_set
+      },
+      :partialUpdates => false
+    )
+    ver = ''
+    while true
+      result = @connection.propertyCollector.WaitForUpdates(:version => ver)
+      ver = result.version
+      complete = 0
+      tasks.each do |task|
+        if ['success', 'error'].member? task.info.state
+          complete += 1
+        end
+      end
+      break if (complete == tasks.length)
+      if try <= attempts
+        sleep 5
+        try += 1
+      else
+        raise "unable to complete Vsphere tasks before timeout"
+      end
+    end
+
+    filter.DestroyPropertyFilter
+    tasks
+  end
+
   def close
     @connection.close
   end

data/lib/beaker/network_manager.rb

@@ -10,15 +10,18 @@ module Beaker
   class NetworkManager
     HYPERVISOR_TYPES = ['solaris', 'blimpy', 'vsphere', 'fusion', 'aix', 'vcloud', 'vagrant']
 
-    def initialize(config, options, logger)
+    def initialize(options, logger)
       @logger = logger
       @options = options
       @hosts = []
-      @config = config
       @virtual_machines = {}
       @noprovision_machines = []
-      @config['HOSTS'].each_key do |name|
-        host_info = @config['HOSTS'][name]
+    end
+
+    def provision
+      #sort hosts into those to be provisioned and those to use non-provisioned
+      @options['HOSTS'].each_key do |name|
+        host_info = @options['HOSTS'][name]
         #check to see if this host has a hypervisor 
         hypervisor = host_info['hypervisor'] 
         #provision this box
@@ -34,24 +37,21 @@ module Beaker
           @logger.debug "No hypervisor for #{name}, connecting to host without provisioning"
           @noprovision_machines << name
         end
-
       end
-    end
 
-    def provision
       @provisioned_set = {}
       @virtual_machines.each do |type, names|
         hosts_for_type = []
         #set up host objects for provisioned provisioned_set
         names.each do |name|
-          host = Beaker::Host.create(name, @options, @config)
+          host = Beaker::Host.create(name, @options)
           hosts_for_type << host
         end
-        @provisioned_set[type] = Beaker::Hypervisor.create(type, hosts_for_type, @options, @config)
+        @provisioned_set[type] = Beaker::Hypervisor.create(type, hosts_for_type, @options)
         @hosts << hosts_for_type
       end
       @noprovision_machines.each do |name|
-        @hosts << Beaker::Host.create(name, @options, @config)
+        @hosts << Beaker::Host.create(name, @options)
       end
       @hosts = @hosts.flatten
       @hosts
@@ -63,8 +63,12 @@ module Beaker
       @hosts.each {|host| host.close }
 
       if not @options[:preserve_hosts]
-        @provisioned_set.each_key do |type|
-          @provisioned_set[type].cleanup
+        if @provisioned_set
+          @provisioned_set.each_key do |type|
+            if @provisioned_set[type]
+              @provisioned_set[type].cleanup
+            end
+          end
         end
       end
     end

data/lib/beaker/options/command_line_parser.rb

@@ -0,0 +1,199 @@
+module Beaker
+  module Options
+    #An object that parses arguments in the format ['--option', 'value', '--option2', 'value2', '--switch']
+    class CommandLineParser
+
+      # @example Create a CommanLineParser
+      #   a = CommandLineParser.new     
+      #    
+      # @note All of Beaker's supported command line options are defined here
+      def initialize
+        @cmd_options = Beaker::Options::OptionsHash.new
+
+        @optparse = OptionParser.new do|opts|
+          # Set a banner
+          opts.banner = "Usage: #{File.basename($0)} [options...]"
+
+          opts.on '-h', '--hosts FILE',
+                  'Use host configuration FILE',
+                  '(default sample.cfg)'  do |file|
+            @cmd_options[:hosts_file] = file
+          end
+
+          opts.on '-o', '--options-file FILE',
+                  'Read options from FILE',
+                  'This should evaluate to a ruby hash.',
+                  'CLI optons are given precedence.' do |file|
+            @cmd_options[:options_file] =  file
+          end
+
+          opts.on '--type TYPE',
+                  'one of git or pe', 
+                  'used to determine underlying path structure of puppet install',
+                  '(default pe)' do |type|
+            @cmd_options[:type] = type
+          end
+
+          opts.on '--helper PATH/TO/SCRIPT',
+                  'Ruby file evaluated prior to tests',
+                  '(a la spec_helper)' do |script|
+            @cmd_options[:helper] = script
+          end
+
+          opts.on  '--load-path /PATH/TO/DIR,/ADDITIONAL/DIR/PATHS',
+                   'Add paths to LOAD_PATH'  do |value|
+            @cmd_options[:load_path] = value
+          end
+
+          opts.on  '-t', '--tests /PATH/TO/DIR,/ADDITIONA/DIR/PATHS,/PATH/TO/FILE.rb',
+                   'Execute tests from paths and files' do |value|
+            @cmd_options[:tests] = value
+          end
+
+          opts.on '--pre-suite /PRE-SUITE/DIR/PATH,/ADDITIONAL/DIR/PATHS,/PATH/TO/FILE.rb',
+                  'Path to project specific steps to be run BEFORE testing' do |value|
+            @cmd_options[:pre_suite] = value
+          end
+
+          opts.on '--post-suite /POST-SUITE/DIR/PATH,/OPTIONAL/ADDITONAL/DIR/PATHS,/PATH/TO/FILE.rb',
+                  'Path to project specific steps to be run AFTER testing' do |value|
+            @cmd_options[:post_suite] = value
+          end
+
+          opts.on '--[no-]provision',
+                  'Do not provision vm images before testing',
+                  '(default: true)' do |bool|
+            @cmd_options[:provision] = bool
+          end
+
+          opts.on '--[no-]preserve-hosts',
+                  'Preserve cloud instances' do |value|
+            @cmd_options[:preserve_hosts] = value
+          end
+
+          opts.on '--root-keys',
+                  'Install puppetlabs pubkeys for superuser',
+                  '(default: false)' do |bool|
+            @cmd_options[:root_keys] = bool
+          end
+
+          opts.on '--keyfile /PATH/TO/SSH/KEY',
+                  'Specify alternate SSH key',
+                  '(default: ~/.ssh/id_rsa)' do |key|
+            @cmd_options[:keyfile] = key
+          end
+
+          opts.on '--timeout TIMEOUT',
+                  '(vCloud only) Specify a provisioning timeout (in seconds)',
+                  '(default: 300)' do |value|
+            @cmd_options[:timeout] = value
+          end
+
+          opts.on '-i URI', '--install URI',
+                  'Install a project repo/app on the SUTs', 
+                  'Provide full git URI or use short form KEYWORD/name',
+                  'supported keywords: PUPPET, FACTER, HIERA, HIERA-PUPPET' do |value|
+            @cmd_options[:install] = value
+          end
+
+          opts.on('-m', '--modules URI', 'Select puppet module git install URI') do |value|
+            @cmd_options[:modules] = value
+          end
+
+          opts.on '-q', '--[no-]quiet',
+                  'Do not log output to STDOUT',
+                  '(default: false)' do |bool|
+            @cmd_options[:quiet] = bool
+          end
+
+          opts.on '-x', '--[no-]xml',
+                  'Emit JUnit XML reports on tests',
+                  '(default: false)' do |bool|
+            @cmd_options[:xml] = bool
+          end
+
+          opts.on '--[no-]color',
+                  'Do not display color in log output',
+                  '(default: true)' do |bool|
+            @cmd_options[:color] = bool
+          end
+
+          opts.on '--[no-]debug',
+                  'Enable full debugging',
+                  '(default: false)' do |bool|
+            @cmd_options[:debug] = bool
+          end
+
+          opts.on  '-d', '--[no-]dry-run',
+                   'Report what would happen on targets',
+                   '(default: false)' do |bool|
+            @cmd_options[:dry_run] = bool
+            $dry_run = bool
+          end
+
+          opts.on '--fail-mode [MODE]',
+                  'How should the harness react to errors/failures',
+                  'Possible values:',
+                  'fast (skip all subsequent tests, cleanup, exit)',
+                  'stop (skip all subsequent tests, do no cleanup, exit immediately)'  do |mode|
+            @cmd_options[:fail_mode] = mode
+          end
+
+          opts.on '--[no-]ntp',
+                  'Sync time on SUTs before testing',
+                  '(default: false)' do |bool|
+            @cmd_options[:timesync] = bool
+          end
+
+          opts.on '--repo-proxy',
+                  'Proxy packaging repositories on ubuntu, debian and solaris-11',
+                  '(default: false)' do
+            @cmd_options[:repo_proxy] = true
+          end
+
+          opts.on '--add-el-extras',
+                  'Add Extra Packages for Enterprise Linux (EPEL) repository to el-* hosts',
+                  '(default: false)' do
+            @cmd_options[:add_el_extras] = true
+          end
+
+          opts.on '-c', '--config FILE',
+                  'DEPRECATED use --hosts' do |file|
+            @cmd_options[:hosts_file] = file
+          end
+
+          opts.on('--help', 'Display this screen' ) do 
+            @cmd_options[:help] = true
+          end
+        end
+
+      end
+
+      # Parse an array of arguments into a Hash of options
+      # @param [Array] args The array of arguments to consume
+      #
+      # @example
+      #   args = ['--option', 'value', '--option2', 'value2', '--switch']
+      #   parser = CommandLineParser.new
+      #   parser.parse!(args) == {:option => 'value, :options2 => value, :switch => true}
+      #
+      # @return [Hash] Return the Hash of options
+      def parse!( args = ARGV )
+        @optparse.parse!(args)
+        @cmd_options
+      end
+
+      # Generate a string representing the supported arguments
+      #
+      # @example 
+      #    parser = CommandLineParser.new 
+      #    parser.usage = "Options:  ..." 
+      #
+      # @return [String] Return a string representing the available arguments
+      def usage
+        @optparse.help
+      end
+
+    end
+  end
+end