beaker-vmware 1.0.0 → 2.0.0

data/beaker-vmware.gemspec

@@ -1,35 +1,34 @@
-# -*- encoding: utf-8 -*-
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift File.expand_path('lib', __dir__)
 require 'beaker-vmware/version'
 
 Gem::Specification.new do |s|
-  s.name        = "beaker-vmware"
+  s.name        = 'beaker-vmware'
   s.version     = BeakerVmware::VERSION
-  s.authors     = ["Vox Pupuli"]
-  s.email       = ["voxpupuli@groups.io"]
-  s.homepage    = "https://github.com/voxpupuli/beaker-vmware"
-  s.summary     = %q{Beaker DSL Extension Helpers!}
-  s.description = %q{For use for the Beaker acceptance testing tool}
+  s.authors     = ['Vox Pupuli']
+  s.email       = ['voxpupuli@groups.io']
+  s.homepage    = 'https://github.com/voxpupuli/beaker-vmware'
+  s.summary     = 'Beaker DSL Extension Helpers!'
+  s.description = 'For use for the Beaker acceptance testing tool'
   s.license     = 'Apache2'
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = Gem::Requirement.new('>= 2.7')
 
   # Testing dependencies
+  s.add_development_dependency 'fakefs', '~> 2.4'
+  s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'rspec-its'
-  s.add_development_dependency 'fakefs', '~> 0.6'
-  s.add_development_dependency 'rake'
-
-  # Documentation dependencies
-  s.add_development_dependency 'yard'
-  s.add_development_dependency 'markdown'
-  s.add_development_dependency 'thin'
-
+  s.add_development_dependency 'rubocop', '~> 1.48.1'
+  s.add_development_dependency 'rubocop-performance', '~> 1.10'
+  s.add_development_dependency 'rubocop-rake', '~> 0.2'
+  s.add_development_dependency 'rubocop-rspec', '>= 1.44'
   # Run time dependencies
-  s.add_runtime_dependency 'stringify-hash', '~> 0.0.0'
+  s.add_runtime_dependency 'beaker', '>= 4', '< 6'
   s.add_runtime_dependency 'fission', '~> 0.4'
-  s.add_runtime_dependency 'rbvmomi', '~> 1.9'
+  s.add_runtime_dependency 'rbvmomi', '>= 1.9', '< 4.0'
+  s.add_runtime_dependency 'stringify-hash', '~> 0.0.0'
 end

data/bin/beaker-vmware

@@ -4,7 +4,7 @@ require 'rubygems' unless defined?(Gem)
 require 'beaker-vmware'
 
 VERSION_STRING =
-"
+  "
                                  _ .--.
                                 ( `    )
         beaker-vmware         .-'      `--,
@@ -25,8 +25,6 @@ VERSION_STRING =
                      '=='
 "
 
-
-
 puts BeakerVmware::VERSION
 
 exit 0

data/lib/beaker/hypervisor/fusion.rb

@@ -1,29 +1,30 @@
 module Beaker
   class Fusion < Beaker::Hypervisor
-
     def initialize(fusion_hosts, options)
       require 'rubygems' unless defined?(Gem)
       begin
         require 'fission'
       rescue LoadError
-        raise "Unable to load fission, please ensure it is installed!"
+        raise 'Unable to load fission, please ensure it is installed!'
       end
       @logger = options[:logger]
       @options = options
       @hosts = fusion_hosts
-      #check preconditions for fusion
+      # check preconditions for fusion
       @hosts.each do |host|
-        raise "You must specify a snapshot for Fusion instances, no snapshot defined for #{host.name}!" unless host["snapshot"]
+        unless host['snapshot']
+          raise "You must specify a snapshot for Fusion instances, no snapshot defined for #{host.name}!"
+        end
       end
       @fission = Fission::VM
     end
 
     def provision
-      available = @fission.all.data.collect{|vm| vm.name}.sort.join(", ")
+      available = @fission.all.data.collect { |vm| vm.name }.sort.join(', ')
       @logger.notify "Available VM names: #{available}"
 
       @hosts.each do |host|
-        vm_name = host["vmname"] || host.name
+        vm_name = host['vmname'] || host.name
         vm = @fission.new vm_name
         raise "Could not find VM '#{vm_name}' for #{host.name}!" unless vm.exists?
 
@@ -32,34 +33,31 @@ module Beaker
           raise "No snapshots available for VM #{host.name} (vmname: '#{vm_name}')"
         end
 
-        available_snapshots = vm_snapshots.sort.join(", ")
+        available_snapshots = vm_snapshots.sort.join(', ')
         @logger.notify "Available snapshots for #{host.name}: #{available_snapshots}"
-        snap_name = host["snapshot"]
-        raise "Could not find snapshot '#{snap_name}' for host #{host.name}!" unless vm.snapshots.data.include? snap_name
+        snap_name = host['snapshot']
+        unless vm.snapshots.data.include? snap_name
+          raise "Could not find snapshot '#{snap_name}' for host #{host.name}!"
+        end
 
         @logger.notify "Reverting #{host.name} to snapshot '#{snap_name}'"
         start = Time.now
         vm.revert_to_snapshot snap_name
-        while vm.running?.data
-          sleep 1
-        end
+        sleep 1 while vm.running?.data
         time = Time.now - start
-        @logger.notify "Spent %.2f seconds reverting" % time
+        @logger.notify 'Spent %.2f seconds reverting' % time
 
         @logger.notify "Resuming #{host.name}"
         start = Time.now
-        vm.start :headless => true
-        until vm.running?.data
-          sleep 1
-        end
+        vm.start headless: true
+        sleep 1 until vm.running?.data
         time = Time.now - start
-        @logger.notify "Spent %.2f seconds resuming VM" % time
-      end
-      end #revert_fusion
-
-      def cleanup
-        @logger.notify "No cleanup for fusion boxes"
+        @logger.notify 'Spent %.2f seconds resuming VM' % time
       end
+    end # revert_fusion
 
+    def cleanup
+      @logger.notify 'No cleanup for fusion boxes'
+    end
   end
 end

data/lib/beaker/hypervisor/vsphere.rb

@@ -3,7 +3,6 @@ require 'beaker/hypervisor/vsphere_helper'
 
 module Beaker
   class Vsphere < Beaker::Hypervisor
-
     def initialize(vsphere_hosts, options)
       @options = options
       @logger = options[:logger]
@@ -14,14 +13,14 @@ module Beaker
       vsphere_credentials = VsphereHelper.load_config(@options[:dot_fog])
 
       @logger.notify "Connecting to vSphere at #{vsphere_credentials[:server]}" +
-        " with credentials for #{vsphere_credentials[:user]}"
+                     " with credentials for #{vsphere_credentials[:user]}"
 
-      vsphere_helper = VsphereHelper.new( vsphere_credentials )
+      vsphere_helper = VsphereHelper.new(vsphere_credentials)
 
       vsphere_vms = {}
       @hosts.each do |h|
-        name = h["vmname"] || h.name
-        vsphere_vms[name] = h["snapshot"]
+        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|
@@ -40,47 +39,47 @@ module Beaker
           snapshot.RevertToSnapshot_Task.wait_for_completion
 
           time = Time.now - start
-          @logger.notify "Spent %.2f seconds reverting" % time
+          @logger.notify 'Spent %.2f seconds reverting' % time
         end
 
-        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
+        next if vm.runtime.powerState == 'poweredOn'
+
+        @logger.notify "Booting #{vm.name}"
+        start = Time.now
+        vm.PowerOnVM_Task.wait_for_completion
+        @logger.notify format("Spent %.2f seconds booting #{vm.name}", (Time.now - start))
       end
 
       vsphere_helper.close
     end
 
     def cleanup
-      @logger.notify "Destroying vsphere boxes"
+      @logger.notify 'Destroying vsphere boxes'
       vsphere_credentials = VsphereHelper.load_config(@options[:dot_fog])
 
       @logger.notify "Connecting to vSphere at #{vsphere_credentials[:server]}" +
-        " with credentials for #{vsphere_credentials[:user]}"
+                     " with credentials for #{vsphere_credentials[:user]}"
 
-      vsphere_helper = VsphereHelper.new( vsphere_credentials )
+      vsphere_helper = VsphereHelper.new(vsphere_credentials)
 
-      vm_names = @hosts.map {|h| h['vmname'] || h.name }
+      vm_names = @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
+        next unless vm.runtime.powerState == 'poweredOn'
+
+        @logger.notify "Shutting down #{vm.name}"
+        start = Time.now
+        vm.PowerOffVM_Task.wait_for_completion
+        @logger.notify(
+          format("Spent %.2f seconds halting #{vm.name}", (Time.now - start)),
+        )
       end
 
       vsphere_helper.close
     end
-
   end
 end

data/lib/beaker/hypervisor/vsphere_helper.rb

@@ -3,12 +3,12 @@ require 'rbvmomi'
 require 'beaker/logger'
 
 class VsphereHelper
-  def initialize vInfo
+  def initialize(vInfo)
     @logger = vInfo[:logger] || Beaker::Logger.new
-    @connection = RbVmomi::VIM.connect :host     => vInfo[:server],
-                                       :user     => vInfo[:user],
-                                       :password => vInfo[:pass],
-                                       :insecure => true
+    @connection = RbVmomi::VIM.connect host: vInfo[:server],
+                                       user: vInfo[:user],
+                                       password: vInfo[:pass],
+                                       insecure: true
   end
 
   def self.load_config(dot_fog = '.fog')
@@ -19,121 +19,121 @@ class VsphereHelper
     vsphere_credentials[:user]   = default[:vsphere_username]
     vsphere_credentials[:pass]   = default[:vsphere_password]
 
-    return vsphere_credentials
+    vsphere_credentials
   end
 
-  def find_snapshot vm, snapname
-    if vm.snapshot
-      search_child_snaps vm.snapshot.rootSnapshotList, snapname
-    else
-      raise "vm #{vm.name} has no snapshots to revert to"
-    end
+  def find_snapshot(vm, snapname)
+    raise "vm #{vm.name} has no snapshots to revert to" unless vm.snapshot
+
+    search_child_snaps vm.snapshot.rootSnapshotList, snapname
   end
 
-  def search_child_snaps tree, snapname
+  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
+      snapshot ||= if child.name == snapname
+                     child.snapshot
+                   else
+                     search_child_snaps child.childSnapshotList, snapname
+                   end
     end
     snapshot
   end
 
-  def find_customization name
+  def find_customization(name)
     csm = @connection.serviceContent.customizationSpecManager
 
     begin
-      customizationSpec = csm.GetCustomizationSpec({:name => name}).spec
-    rescue
+      customizationSpec = csm.GetCustomizationSpec({ name: name }).spec
+    rescue StandardError
       customizationSpec = nil
     end
 
-    return customizationSpec
+    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 ]
+  def find_vms(names, connection = @connection)
+    names = [names] unless names.is_a?(Array)
     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'
-      }) ]
+      obj: containerView,
+      skip: true,
+      selectSet: [RbVmomi::VIM::TraversalSpec.new({
+                                                    name: 'gettingTheVMs',
+                                                    path: 'view',
+                                                    skip: false,
+                                                    type: 'ContainerView',
+                                                  })],
     }]
 
     propSet = [{
-      :pathSet => [ 'name' ],
-      :type => 'VirtualMachine'
+      pathSet: ['name'],
+      type: 'VirtualMachine',
     }]
 
     results = propertyCollector.RetrievePropertiesEx({
-      :specSet => [{
-        :objectSet => objectSet,
-        :propSet   => propSet
-      }],
-      :options => { :maxObjects => nil }
-    })
+                                                       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})
+    while results.token
+      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(dc,datastorename)
+  def find_datastore(dc, datastorename)
     datacenter = @connection.serviceInstance.find_datacenter(dc)
     datacenter.find_datastore(datastorename)
   end
 
-  def find_folder(dc,foldername)
+  def find_folder(dc, foldername)
     datacenter = @connection.serviceInstance.find_datacenter(dc)
     base = datacenter.vmFolder.traverse(foldername)
-    if base != nil
-      base
-    else
+    if base.nil?
       abort "Failed to find folder #{foldername}"
+    else
+      base
     end
   end
 
-  def find_pool(dc,poolname)
+  def find_pool(dc, poolname)
     datacenter = @connection.serviceInstance.find_datacenter(dc)
     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"
+      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
 
@@ -141,43 +141,41 @@ class VsphereHelper
     base
   end
 
-  def get_base_vm_container_from connection
+  def get_base_vm_container_from(connection)
     viewManager = connection.serviceContent.viewManager
     viewManager.CreateContainerView({
-      :container => connection.serviceContent.rootFolder,
-      :recursive => true,
-      :type      => [ 'VirtualMachine' ]
-    })
+                                      container: connection.serviceContent.rootFolder,
+                                      recursive: true,
+                                      type: ['VirtualMachine'],
+                                    })
   end
 
-  def wait_for_tasks tasks, try, attempts
-    obj_set = tasks.map { |task| { :obj => task } }
+  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
+      spec: {
+        propSet: [{ type: 'Task',
+                    all: false,
+                    pathSet: ['info.state'], }],
+        objectSet: obj_set,
       },
-      :partialUpdates => false
+      partialUpdates: false,
     )
     ver = ''
     while true
-      result = @connection.propertyCollector.WaitForUpdates(:version => ver)
+      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"
+        complete += 1 if %w[success error].member? task.info.state
       end
+      break if complete == tasks.length
+
+      raise 'unable to complete Vsphere tasks before timeout' unless try <= attempts
+
+      sleep 5
+      try += 1
+
     end
 
     filter.DestroyPropertyFilter
@@ -188,4 +186,3 @@ class VsphereHelper
     @connection.close
   end
 end
-

data/lib/beaker-vmware/version.rb

@@ -1,3 +1,3 @@
 module BeakerVmware
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/spec/beaker/hypervisor/fusion_spec.rb

@@ -2,40 +2,38 @@ require 'spec_helper'
 
 module Beaker
   describe Fusion do
-    let( :fusion ) { Beaker::Fusion.new( @hosts, make_opts ) }
-
-    before :each do
-     stub_const( "Fission::VM", true )
-      @hosts = make_hosts()
-      MockFission.presets( @hosts )
-      allow_any_instance_of( Fusion ).to receive( :require ).with( 'fission' ).and_return( true )
-      fusion.instance_variable_set( :@fission, MockFission ) 
+    let(:fusion) { Beaker::Fusion.new(@hosts, make_opts) }
+
+    before do
+      stub_const('Fission::VM', true)
+      @hosts = make_hosts
+      MockFission.presets(@hosts)
+      allow_any_instance_of(Fusion).to receive(:require).with('fission').and_return(true)
+      fusion.instance_variable_set(:@fission, MockFission)
     end
 
-    it "can interoperate with the fission library to provision hosts"  do
+    it 'can interoperate with the fission library to provision hosts' do
       fusion.provision
     end
 
-    it "raises an error if unknown snapshot name is used" do
+    it 'raises an error if unknown snapshot name is used' do
       @hosts[0][:snapshot] = 'unknown'
-      expect{ fusion.provision }.to raise_error
+      expect { fusion.provision }.to raise_error
     end
 
     it 'raises an error if snapshots is nil' do
       MockFissionVM.set_snapshots(nil)
-      expect{ fusion.provision }.to raise_error(/No snapshots available/)
+      expect { fusion.provision }.to raise_error(/No snapshots available/)
     end
 
     it 'raises an error if snapshots are empty' do
       MockFissionVM.set_snapshots([])
-      expect{ fusion.provision }.to raise_error(/No snapshots available/)
+      expect { fusion.provision }.to raise_error(/No snapshots available/)
     end
 
     it 'host fails init with nil snapshot' do
       @hosts[0][:snapshot] = nil
-      expect{ Beaker::Fusion.new( @hosts, make_opts) }.to raise_error(/specify a snapshot/)
+      expect { Beaker::Fusion.new(@hosts, make_opts) }.to raise_error(/specify a snapshot/)
     end
-
   end
-
 end