beaker 0.0.0

data/lib/beaker/hypervisor/vsphere.rb

@@ -0,0 +1,80 @@
+module Beaker 
+  class Vsphere < Beaker::Hypervisor
+
+    def initialize(vsphere_hosts, options, config)
+      @options = options
+      @@config = config['CONFIG'].dup
+      @logger = options[:logger]
+      @vsphere_hosts = vsphere_hosts
+      require 'yaml' unless defined?(YAML)
+      vsphere_credentials = VsphereHelper.load_config
+
+      @logger.notify "Connecting to vSphere at #{vsphere_credentials[:server]}" +
+        " with credentials for #{vsphere_credentials[:user]}"
+
+      vsphere_helper = VsphereHelper.new( vsphere_credentials )
+
+      vsphere_vms = {}
+      @vsphere_hosts.each do |h|
+        name = h["vmname"] || h.name
+        vsphere_vms[name] = h["snapshot"]
+      end
+      vms = vsphere_helper.find_vms(vsphere_vms.keys)
+      vsphere_vms.each_pair do |name, snap|
+        unless vm = vms[name]
+          raise "Couldn't find VM #{name} in vSphere!"
+        end
+
+        snapshot = vsphere_helper.find_snapshot(vm, snap) or
+          raise "Could not find snapshot '#{snap}' for VM #{vm.name}!"
+
+        @logger.notify "Reverting #{vm.name} to snapshot '#{snap}'"
+        start = Time.now
+        # This will block for each snapshot...
+        # The code to issue them all and then wait until they are all done sucks
+        snapshot.RevertToSnapshot_Task.wait_for_completion
+
+        time = Time.now - start
+        @logger.notify "Spent %.2f seconds reverting" % time
+
+        unless vm.runtime.powerState == "poweredOn"
+          @logger.notify "Booting #{vm.name}"
+          start = Time.now
+          vm.PowerOnVM_Task.wait_for_completion
+          @logger.notify "Spent %.2f seconds booting #{vm.name}" % (Time.now - start)
+        end
+      end
+
+      vsphere_helper.close
+    end
+
+    def cleanup
+      @logger.notify "Destroying vsphere boxes"
+      vsphere_credentials = VsphereHelper.load_config
+
+      @logger.notify "Connecting to vSphere at #{vsphere_credentials[:server]}" +
+        " with credentials for #{vsphere_credentials[:user]}"
+
+      vsphere_helper = VsphereHelper.new( vsphere_credentials )
+
+      vm_names = @vsphere_hosts.map {|h| h['vmname'] || h.name }
+      vms = vsphere_helper.find_vms vm_names
+      vm_names.each do |name|
+        unless vm = vms[name]
+          raise "Couldn't find VM #{name} in vSphere!"
+        end
+
+        if vm.runtime.powerState == "poweredOn"
+          @logger.notify "Shutting down #{vm.name}"
+          start = Time.now
+          vm.PowerOffVM_Task.wait_for_completion
+          @logger.notify(
+            "Spent %.2f seconds halting #{vm.name}" % (Time.now - start) )
+        end
+      end
+
+      vsphere_helper.close
+    end
+
+  end
+end

data/lib/beaker/hypervisor/vsphere_helper.rb

@@ -0,0 +1,200 @@
+require 'yaml' unless defined?(YAML)
+require 'rubygems' unless defined?(Gem)
+begin
+  require 'beaker/logger'
+rescue LoadError
+  require File.expand_path(File.join(File.dirname(__FILE__), '..', 'logger.rb'))
+end
+
+class VsphereHelper
+  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
+    # 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
+    end
+
+    return vsphere_credentials
+  end
+
+  def self.load_fog_credentials
+    vInfo = YAML.load_file( File.join(ENV['HOME'], '.fog') )
+
+    vsphere_credentials = {}
+    vsphere_credentials[:server] = vInfo[:default][:vsphere_server]
+    vsphere_credentials[:user]   = vInfo[:default][:vsphere_username]
+    vsphere_credentials[:pass]   = vInfo[:default][:vsphere_password]
+
+    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
+
+  def search_child_snaps tree, snapname
+    snapshot = nil
+    tree.each do |child|
+      if child.name == snapname
+        snapshot ||= child.snapshot
+      else
+        snapshot ||= search_child_snaps child.childSnapshotList, snapname
+      end
+    end
+    snapshot
+  end
+
+  def find_customization name
+    csm = @connection.serviceContent.customizationSpecManager
+
+    begin
+      customizationSpec = csm.GetCustomizationSpec({:name => name}).spec
+    rescue
+      customizationSpec = nil
+    end
+
+    return customizationSpec
+  end
+
+  # an easier wrapper around the horrid PropertyCollector interface,
+  # necessary for searching VMs in all Datacenters that may be nested
+  # within folders of arbitrary depth
+  # returns a hash array of <name> => <VirtualMachine ManagedObjects>
+  def find_vms names, connection = @connection
+    names = names.is_a?(Array) ? names : [ names ]
+    containerView = get_base_vm_container_from connection
+    propertyCollector = connection.propertyCollector
+
+    objectSet = [{
+      :obj => containerView,
+      :skip => true,
+      :selectSet => [ RbVmomi::VIM::TraversalSpec.new({
+          :name => 'gettingTheVMs',
+          :path => 'view',
+          :skip => false,
+          :type => 'ContainerView'
+      }) ]
+    }]
+
+    propSet = [{
+      :pathSet => [ 'name' ],
+      :type => 'VirtualMachine'
+    }]
+
+    results = propertyCollector.RetrievePropertiesEx({
+      :specSet => [{
+        :objectSet => objectSet,
+        :propSet   => propSet
+      }],
+      :options => { :maxObjects => nil }
+    })
+
+    vms = {}
+    results.objects.each do |result|
+      name = result.propSet.first.val
+      next unless names.include? name
+      vms[name] = result.obj
+    end
+
+    while results.token do
+      results = propertyCollector.ContinueRetrievePropertiesEx({:token => results.token})
+      results.objects.each do |result|
+        name = result.propSet.first.val
+        next unless names.include? name
+        vms[name] = result.obj
+      end
+    end
+    vms
+  end
+
+  def find_datastore datastorename
+    datacenter = @connection.serviceInstance.find_datacenter
+    datacenter.find_datastore(datastorename)
+  end
+
+  def find_folder foldername
+    datacenter = @connection.serviceInstance.find_datacenter
+    base = datacenter.vmFolder
+    folders = foldername.split('/')
+    folders.each do |folder|
+      case base
+        when RbVmomi::VIM::Folder
+          base = base.childEntity.find { |f| f.name == folder }
+        else
+          abort "Unexpected object type encountered (#{base.class}) while finding folder"
+      end
+    end
+
+    base
+  end
+
+  def find_pool poolname
+    datacenter = @connection.serviceInstance.find_datacenter
+    base = datacenter.hostFolder
+    pools = poolname.split('/')
+    pools.each do |pool|
+      case base
+        when RbVmomi::VIM::Folder
+          base = base.childEntity.find { |f| f.name == pool }
+        when RbVmomi::VIM::ClusterComputeResource
+          base = base.resourcePool.resourcePool.find { |f| f.name == pool }
+        when RbVmomi::VIM::ResourcePool
+          base = base.resourcePool.find { |f| f.name == pool }
+        else
+          abort "Unexpected object type encountered (#{base.class}) while finding resource pool"
+      end
+    end
+
+    base = base.resourcePool unless base.is_a?(RbVmomi::VIM::ResourcePool) and base.respond_to?(:resourcePool)
+    base
+  end
+
+  def get_base_vm_container_from connection
+    viewManager = connection.serviceContent.viewManager
+    viewManager.CreateContainerView({
+      :container => connection.serviceContent.rootFolder,
+      :recursive => true,
+      :type      => [ 'VirtualMachine' ]
+    })
+  end
+
+  def close
+    @connection.close
+  end
+end
+

data/lib/beaker/logger.rb

@@ -0,0 +1,167 @@
+module Beaker
+  class Logger
+    NORMAL         = "\e[00;00m"
+    BRIGHT_NORMAL  = "\e[00;01m"
+    BLACK          = "\e[00;30m"
+    RED            = "\e[00;31m"
+    GREEN          = "\e[00;32m"
+    YELLOW         = "\e[00;33m"
+    BLUE           = "\e[00;34m"
+    MAGENTA        = "\e[00;35m"
+    CYAN           = "\e[00;36m"
+    WHITE          = "\e[00;37m"
+    GREY           = "\e[01;30m"
+    BRIGHT_RED     = "\e[01;31m"
+    BRIGHT_GREEN   = "\e[01;32m"
+    BRIGHT_YELLOW  = "\e[01;33m"
+    BRIGHT_BLUE    = "\e[01;34m"
+    BRIGHT_MAGENTA = "\e[01;35m"
+    BRIGHT_CYAN    = "\e[01;36m"
+    BRIGHT_WHITE   = "\e[01;37m"
+
+    LOG_LEVELS      = {
+      :debug  => 1,
+      :warn   => 2,
+      :normal => 3,
+      :info   => 4
+    }
+
+    attr_accessor :color, :log_level, :destinations
+
+    def initialize(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      @color = options[:color]
+      @log_level = options[:debug] ? :debug : :normal
+      @destinations = []
+
+      dests = args
+      dests << STDOUT unless options[:quiet]
+      dests.uniq!
+      dests.each {|dest| add_destination(dest)}
+    end
+
+    def add_destination(dest)
+      case dest
+      when IO
+        @destinations << dest
+      when String
+        @destinations << File.open(dest, 'w')
+      else
+        raise "Unsuitable log destination #{dest.inspect}"
+      end
+    end
+
+    def remove_destination(dest)
+      case dest
+      when IO
+        @destinations.delete(dest)
+      when String
+        @destinations.delete_if {|d| d.respond_to?(:path) and d.path == dest}
+      else
+        raise "Unsuitable log destination #{dest.inspect}"
+      end
+    end
+
+    def is_debug?
+      LOG_LEVELS[@log_level] <= LOG_LEVELS[:debug]
+    end
+
+    def is_warn?
+      LOG_LEVELS[@log_level] <= LOG_LEVELS[:warn]
+    end
+
+    def host_output *args
+      return unless is_debug?
+      strings = strip_colors_from args
+      string = strings.join
+      optionally_color GREY, string, false
+    end
+
+    def debug *args
+      return unless is_debug?
+      optionally_color WHITE, args
+    end
+
+    def warn *args
+      return unless is_warn?
+      strings = args.map {|msg| "Warning: #{msg}" }
+      optionally_color YELLOW, strings
+    end
+
+    def success *args
+      optionally_color GREEN, args
+    end
+
+    def notify *args
+      optionally_color BRIGHT_WHITE, args
+    end
+
+    def error *args
+      optionally_color BRIGHT_RED, args
+    end
+
+    def strip_colors_from lines
+      Array(lines).map do |line|
+        line.gsub /\e\[(\d+;)?\d+m/, ''
+      end
+    end
+
+    def optionally_color color_code, msg, add_newline = true
+      print_statement = add_newline ? :puts : :print
+      @destinations.each do |to|
+        to.print color_code if @color
+        to.send print_statement, msg
+        to.print NORMAL if @color
+      end
+    end
+
+    # utility method to get the current call stack and format it
+    # to a human-readable string (which some IDEs/editors
+    # will recognize as links to the line numbers in the trace)
+    def pretty_backtrace backtrace = caller(1)
+      trace = purge_harness_files_from( Array( backtrace ) )
+      expand_symlinks( trace ).join "\n"
+    end
+
+   private
+    def expand_symlinks backtrace
+      backtrace.collect do |line|
+        file_path, line_num = line.split( ":" )
+        expanded_path = expand_symlink File.expand_path( file_path )
+        expanded_path.to_s + ":" + line_num.to_s
+      end
+    end
+
+    def purge_harness_files_from backtrace
+      mostly_purged = backtrace.reject do |line|
+        # LOADED_FEATURES is an array of anything `require`d, i.e. everything
+        # but the test in question
+        $LOADED_FEATURES.any? do |require_path|
+          line.include? require_path
+        end
+      end
+
+      # And remove lines that contain our program name in them
+      completely_purged = mostly_purged.reject {|line| line.include? $0 }
+    end
+
+    # utility method that takes a path as input, checks each component
+    # of the path to see if it is a symlink, and expands
+    # it if it is.  returns the expanded path.
+    def expand_symlink file_path
+      file_path.split( "/" ).inject do |full_path, next_dir|
+        next_path = full_path + "/" + next_dir
+        if File.symlink? next_path
+          link = File.readlink next_path
+          next_path =
+              case link
+                when /^\// then link
+                else
+                  File.expand_path( full_path + "/" + link )
+              end
+        end
+        next_path
+      end
+    end
+  end
+end

data/lib/beaker/network_manager.rb

@@ -0,0 +1,73 @@
+%w(hypervisor).each do |lib|
+  begin
+    require "beaker/#{lib}"
+  rescue LoadError
+    require File.expand_path(File.join(File.dirname(__FILE__), lib))
+  end
+end
+
+module Beaker
+  class NetworkManager
+    HYPERVISOR_TYPES = ['solaris', 'blimpy', 'vsphere', 'fusion', 'aix', 'vcloud', 'vagrant']
+
+    def initialize(config, options, logger)
+      @logger = logger
+      @options = options
+      @hosts = []
+      @config = config
+      @virtual_machines = {}
+      @noprovision_machines = []
+      @config['HOSTS'].each_key do |name|
+        host_info = @config['HOSTS'][name]
+        #check to see if this host has a hypervisor 
+        hypervisor = host_info['hypervisor'] 
+        #provision this box
+        # - only if we are running with --provision
+        # - only if we have a hypervisor
+        # - only if either the specific hosts has no specification or has 'provision' in its config
+        if @options[:provision] && hypervisor && (host_info.has_key?('provision') ? host_info['provision'] : true) #obey config file provision, defaults to provisioning vms
+          raise "Invalid hypervisor: #{hypervisor} (#{name})" unless HYPERVISOR_TYPES.include? hypervisor
+          @logger.debug "Hypervisor for #{name} is #{host_info['hypervisor'] || 'default' }, and I'm going to use #{hypervisor}"
+          @virtual_machines[hypervisor] = [] unless @virtual_machines[hypervisor]
+          @virtual_machines[hypervisor] << name
+        else #this is a non-provisioned machine, deal with it without hypervisors
+          @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)
+          hosts_for_type << host
+        end
+        @provisioned_set[type] = Beaker::Hypervisor.create(type, hosts_for_type, @options, @config)
+        @hosts << hosts_for_type
+      end
+      @noprovision_machines.each do |name|
+        @hosts << Beaker::Host.create(name, @options, @config)
+      end
+      @hosts = @hosts.flatten
+      @hosts
+    end
+
+    def cleanup
+      #only cleanup if we aren't preserving hosts
+      #shut down connections
+      @hosts.each {|host| host.close }
+
+      if not @options[:preserve_hosts]
+        @provisioned_set.each_key do |type|
+          @provisioned_set[type].cleanup
+        end
+      end
+    end
+
+  end
+end