beaker-vcloud 1.1.0 → 2.0.0

data/bin/beaker-vcloud

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

data/lib/beaker/hypervisor/vcloud.rb

@@ -4,13 +4,12 @@ require 'rbvmomi'
 
 module Beaker
   class Vcloud < Beaker::Hypervisor
-
     def self.new(vcloud_hosts, options)
       # Warning for pre-vmpooler style hosts configuration. TODO: remove this eventually.
       if options['pooling_api'] && !options['datacenter']
-        options[:logger].warn "It looks like you may be trying to access vmpooler with `hypervisor: vcloud`. "\
-                              "This functionality has been removed. Change your hosts to `hypervisor: vmpooler` "\
-                              "and remove unused :datacenter, :folder, and :datastore from CONFIG."
+        options[:logger].warn 'It looks like you may be trying to access vmpooler with `hypervisor: vcloud`. ' \
+                              'This functionality has been removed. Change your hosts to `hypervisor: vmpooler` ' \
+                              'and remove unused :datacenter, :folder, and :datastore from CONFIG.'
       end
       super
     end
@@ -23,76 +22,71 @@ module Beaker
       raise 'You must specify a datastore for vCloud instances!' unless @options['datastore']
       raise 'You must specify a folder for vCloud instances!' unless @options['folder']
       raise 'You must specify a datacenter for vCloud instances!' unless @options['datacenter']
+
       @vcenter_credentials = get_fog_credentials(@options[:dot_fog], @options[:vcenter_instance] || :default)
     end
 
     def connect_to_vsphere
       @logger.notify "Connecting to vSphere at #{@vcenter_credentials[:vsphere_server]}" +
-        " with credentials for #{@vcenter_credentials[:vsphere_username]}"
+                     " with credentials for #{@vcenter_credentials[:vsphere_username]}"
 
-      @vsphere_helper = VsphereHelper.new :server => @vcenter_credentials[:vsphere_server],
-                                          :user   => @vcenter_credentials[:vsphere_username],
-                                          :pass   => @vcenter_credentials[:vsphere_password]
+      @vsphere_helper = VsphereHelper.new server: @vcenter_credentials[:vsphere_server],
+                                          user: @vcenter_credentials[:vsphere_username],
+                                          pass: @vcenter_credentials[:vsphere_password]
     end
 
-    def wait_for_dns_resolution host, try, attempts
+    def wait_for_dns_resolution(host, try, attempts)
       @logger.notify "Waiting for #{host['vmhostname']} DNS resolution"
       begin
         Socket.getaddrinfo(host['vmhostname'], nil)
-      rescue
-        if try <= attempts
-          sleep 5
-          try += 1
+      rescue StandardError
+        raise "DNS resolution failed after #{@options[:timeout].to_i} seconds" unless try <= attempts
 
-          retry
-        else
-          raise "DNS resolution failed after #{@options[:timeout].to_i} seconds"
-        end
+        sleep 5
+        try += 1
+
+        retry
       end
     end
 
-    def booting_host host, try, attempts
+    def booting_host(host, try, attempts)
       @logger.notify "Booting #{host['vmhostname']} (#{host.name}) and waiting for it to register with vSphere"
-      until
-        @vsphere_helper.find_vms(host['vmhostname'])[host['vmhostname']].summary.guest.toolsRunningStatus == 'guestToolsRunning' and
-        @vsphere_helper.find_vms(host['vmhostname'])[host['vmhostname']].summary.guest.ipAddress != nil
-        if try <= attempts
-          sleep 5
-          try += 1
-        else
-          raise "vSphere registration failed after #{@options[:timeout].to_i} seconds"
-        end
+      until @vsphere_helper.find_vms(host['vmhostname'])[host['vmhostname']].summary.guest.toolsRunningStatus == 'guestToolsRunning' and
+            !@vsphere_helper.find_vms(host['vmhostname'])[host['vmhostname']].summary.guest.ipAddress.nil?
+        raise "vSphere registration failed after #{@options[:timeout].to_i} seconds" unless try <= attempts
+
+        sleep 5
+        try += 1
+
       end
     end
 
     # Directly borrowed from openstack hypervisor
     def enable_root(host)
-      if host['user'] != 'root'
-        copy_ssh_to_root(host, @options)
-        enable_root_login(host, @options)
-        host['user'] = 'root'
-        host.close
-      end
+      return unless host['user'] != 'root'
+
+      copy_ssh_to_root(host, @options)
+      enable_root_login(host, @options)
+      host['user'] = 'root'
+      host.close
     end
 
-    def create_clone_spec host
+    def create_clone_spec(host)
       # Add VM annotation
       configSpec = RbVmomi::VIM.VirtualMachineConfigSpec(
-        :annotation =>
-          'Base template:  ' + host['template'] + "\n" +
-          'Creation time:  ' + Time.now.strftime("%Y-%m-%d %H:%M") + "\n\n" +
-          'CI build link:  ' + ( ENV['BUILD_URL'] || 'Deployed independently of CI' ) +
+        annotation: 'Base template:  ' + host['template'] + "\n" +
+          'Creation time:  ' + Time.now.strftime('%Y-%m-%d %H:%M') + "\n\n" +
+          'CI build link:  ' + (ENV['BUILD_URL'] || 'Deployed independently of CI') +
           'department:     ' + @options[:department] +
           'project:        ' + @options[:project],
-        :extraConfig => [
-          { :key   => 'guestinfo.hostname',
-            :value => host['vmhostname']
-          }
-        ]
+        extraConfig: [
+          { key: 'guestinfo.hostname',
+            value: host['vmhostname'], },
+        ],
       )
 
       # Are we using a customization spec?
-      customizationSpec = @vsphere_helper.find_customization( host['template'] )
+      customizationSpec = @vsphere_helper.find_customization(host['template'])
 
       if customizationSpec
         # Print a logger message if using a customization spec
@@ -101,45 +95,44 @@ module Beaker
 
       # Put the VM in the specified folder and resource pool
       relocateSpec = RbVmomi::VIM.VirtualMachineRelocateSpec(
-        :datastore    => @vsphere_helper.find_datastore(@options['datacenter'],@options['datastore']),
-        :pool         => @options['resourcepool'] ? @vsphere_helper.find_pool(@options['datacenter'],@options['resourcepool']) : nil,
-        :diskMoveType => :moveChildMostDiskBacking
+        datastore: @vsphere_helper.find_datastore(@options['datacenter'], @options['datastore']),
+        pool: if @options['resourcepool']
+                @vsphere_helper.find_pool(@options['datacenter'],
+                                          @options['resourcepool'])
+              end,
+        diskMoveType: :moveChildMostDiskBacking,
       )
 
       # Create a clone spec
-      spec = RbVmomi::VIM.VirtualMachineCloneSpec(
-        :config        => configSpec,
-        :location      => relocateSpec,
-        :customization => customizationSpec,
-        :powerOn       => true,
-        :template      => false
+      RbVmomi::VIM.VirtualMachineCloneSpec(
+        config: configSpec,
+        location: relocateSpec,
+        customization: customizationSpec,
+        powerOn: true,
+        template: false,
       )
-      spec
     end
 
     def provision
       connect_to_vsphere
       begin
-
         try = 1
         attempts = @options[:timeout].to_i / 5
 
         start = Time.now
         tasks = []
-        @hosts.each_with_index do |h, i|
-          if h['name']
-            h['vmhostname'] = h['name']
-          else
-            h['vmhostname'] = generate_host_name
-          end
+        @hosts.each_with_index do |h, _i|
+          h['vmhostname'] = (h['name'] || generate_host_name)
 
-          if h['template'].nil? and defined?(ENV['BEAKER_vcloud_template'])
-            h['template'] = ENV['BEAKER_vcloud_template']
+          if h['template'].nil? and defined?(ENV.fetch('BEAKER_vcloud_template', nil))
+            h['template'] = ENV.fetch('BEAKER_vcloud_template', nil)
           end
 
-          raise "Missing template configuration for #{h}.  Set template in nodeset or set ENV[BEAKER_vcloud_template]" unless h['template']
+          unless h['template']
+            raise "Missing template configuration for #{h}.  Set template in nodeset or set ENV[BEAKER_vcloud_template]"
+          end
 
-          if h['template'] =~ /\//
+          if %r{/}.match?(h['template'])
             templatefolders = h['template'].split('/')
             h['template'] = templatefolders.pop
           end
@@ -149,60 +142,60 @@ module Beaker
           vm = {}
 
           if templatefolders
-            vm[h['template']] = @vsphere_helper.find_folder(@options['datacenter'],templatefolders.join('/')).find(h['template'])
+            vm[h['template']] =
+              @vsphere_helper.find_folder(@options['datacenter'], templatefolders.join('/')).find(h['template'])
           else
             vm = @vsphere_helper.find_vms(h['template'])
           end
 
-          if vm.length == 0
-            raise "Unable to find template '#{h['template']}'!"
-          end
+          raise "Unable to find template '#{h['template']}'!" if vm.length == 0
 
           spec = create_clone_spec(h)
 
           # Deploy from specified template
-          tasks << vm[h['template']].CloneVM_Task( :folder => @vsphere_helper.find_folder(@options['datacenter'],@options['folder']), :name => h['vmhostname'], :spec => spec )
+          tasks << vm[h['template']].CloneVM_Task(
+            folder: @vsphere_helper.find_folder(@options['datacenter'],
+                                                @options['folder']), name: h['vmhostname'], spec: spec
+          )
         end
 
         try = (Time.now - start) / 5
         @vsphere_helper.wait_for_tasks(tasks, try, attempts)
-        @logger.notify 'Spent %.2f seconds deploying VMs' % (Time.now - start)
+        @logger.notify format('Spent %.2f seconds deploying VMs', (Time.now - start))
 
         try = (Time.now - start) / 5
         duration = run_and_report_duration do
-          @hosts.each_with_index do |h, i|
+          @hosts.each_with_index do |h, _i|
             booting_host(h, try, attempts)
           end
         end
-        @logger.notify "Spent %.2f seconds booting and waiting for vSphere registration" % duration
+        @logger.notify 'Spent %.2f seconds booting and waiting for vSphere registration' % duration
 
         try = (Time.now - start) / 5
         duration = run_and_report_duration do
           @hosts.each do |host|
             repeat_fibonacci_style_for 8 do
-              @vsphere_helper.find_vms(host['vmhostname'])[host['vmhostname']].summary.guest.ipAddress != nil
+              !@vsphere_helper.find_vms(host['vmhostname'])[host['vmhostname']].summary.guest.ipAddress.nil?
             end
             host[:ip] = @vsphere_helper.find_vms(host['vmhostname'])[host['vmhostname']].summary.guest.ipAddress
             enable_root(host) unless host.is_cygwin?
           end
         end
 
-        @logger.notify "Spent %.2f seconds waiting for DNS resolution" % duration
-
-      rescue => e
+        @logger.notify 'Spent %.2f seconds waiting for DNS resolution' % duration
+      rescue StandardError => e
         @vsphere_helper.close
-        report_and_raise(@logger, e, "Vcloud.provision")
+        report_and_raise(@logger, e, 'Vcloud.provision')
       end
-
     end
 
     def cleanup
-      @logger.notify "Destroying vCloud boxes"
+      @logger.notify 'Destroying vCloud boxes'
       connect_to_vsphere
 
-      vm_names = @hosts.map {|h| h['vmhostname'] }.compact
+      vm_names = @hosts.map { |h| h['vmhostname'] }.compact
       if @hosts.length != vm_names.length
-        @logger.warn "Some hosts did not have vmhostname set correctly! This likely means VM provisioning was not successful"
+        @logger.warn 'Some hosts did not have vmhostname set correctly! This likely means VM provisioning was not successful'
       end
       vms = @vsphere_helper.find_vms vm_names
       begin
@@ -224,12 +217,11 @@ module Beaker
             vm.Destroy_Task
           end
           @logger.notify "Spent %.2f seconds destroying #{vm.name}" % duration
-
         end
-      rescue RbVmomi::Fault => ex
-        if ex.fault.is_a?(RbVmomi::VIM::ManagedObjectNotFound)
-          #it's already gone, don't bother trying to delete it
-          name = vms.key(ex.fault.obj)
+      rescue RbVmomi::Fault => e
+        if e.fault.is_a?(RbVmomi::VIM::ManagedObjectNotFound)
+          # it's already gone, don't bother trying to delete it
+          name = vms.key(e.fault.obj)
           vms.delete(name)
           vm_names.delete(name)
           @logger.warn "Unable to destroy #{name}, it was not found in vSphere"
@@ -238,6 +230,5 @@ module Beaker
       end
       @vsphere_helper.close
     end
-
   end
 end

data/lib/beaker-vcloud/version.rb

@@ -1,3 +1,3 @@
 module BeakerVcloud
-  VERSION = '1.1.0'
+  VERSION = '2.0.0'
 end

data/spec/beaker/hypervisor/vcloud_spec.rb

@@ -2,43 +2,41 @@ require 'spec_helper'
 
 module Beaker
   describe Vcloud do
-
-    before :each do
-      MockVsphereHelper.set_config( fog_file_contents )
-      MockVsphereHelper.set_vms( make_hosts() )
-      stub_const( "VsphereHelper", MockVsphereHelper )
-      stub_const( "Net", MockNet )
-      json = double( 'json' )
-      allow( json ).to receive( :parse ) do |arg|
+    before do
+      MockVsphereHelper.set_config(fog_file_contents)
+      MockVsphereHelper.set_vms(make_hosts)
+      stub_const('VsphereHelper', MockVsphereHelper)
+      stub_const('Net', MockNet)
+      json = double('json')
+      allow(json).to receive(:parse) do |arg|
         arg
       end
-      stub_const( "JSON", json )
-      allow( Socket ).to receive( :getaddrinfo ).and_return( true )
-      allow_any_instance_of( Beaker::Shared ).to receive( :get_fog_credentials ).and_return( fog_file_contents )
-      allow_any_instance_of( VsphereHelper ).to receive( :new ).and_return (MockVsphereHelper)
+      stub_const('JSON', json)
+      allow(Socket).to receive(:getaddrinfo).and_return(true)
+      allow_any_instance_of(Beaker::Shared).to receive(:get_fog_credentials).and_return(fog_file_contents)
+      allow_any_instance_of(VsphereHelper).to receive(:new).and_return(MockVsphereHelper)
     end
 
-    describe "#provision" do
-
+    describe '#provision' do
       it 'warns about deprecated behavior if pooling_api is provided' do
         opts = make_opts
         opts[:pooling_api] = 'testpool'
-        expect( opts[:logger] ).to receive( :warn ).once
-        expect{ Beaker::Vcloud.new( make_hosts, opts ) }.to raise_error( /datacenter/ )
+        expect(opts[:logger]).to receive(:warn).once
+        expect { Beaker::Vcloud.new(make_hosts, opts) }.to raise_error(/datacenter/)
       end
 
       it 'does not instantiate vmpooler if pooling_api is provided' do
         opts = make_opts
         opts[:pooling_api] = 'testpool'
-        expect{ Beaker::Vcloud.new( make_hosts, opts ) }.to raise_error( /datacenter/ )
+        expect { Beaker::Vcloud.new(make_hosts, opts) }.to raise_error(/datacenter/)
       end
 
       it 'ignores pooling_api and instantiates self' do
         opts = make_opts
         opts[:pooling_api] = 'testpool'
         opts[:datacenter] = 'testdatacenter'
-        hypervisor = Beaker::Vcloud.new( make_hosts, opts)
-        expect( hypervisor.class ).to be Beaker::Vcloud
+        hypervisor = Beaker::Vcloud.new(make_hosts, opts)
+        expect(hypervisor.class).to be Beaker::Vcloud
       end
 
       it 'provisions hosts and add them to the pool' do
@@ -48,18 +46,17 @@ module Beaker
         opts[:pooling_api] = nil
         opts[:datacenter] = 'testdc'
 
-        vcloud = Beaker::Vcloud.new( make_hosts, opts )
-        allow( vcloud ).to receive( :require ).and_return( true )
-        allow( vcloud ).to receive( :sleep ).and_return( true )
+        vcloud = Beaker::Vcloud.new(make_hosts, opts)
+        allow(vcloud).to receive(:require).and_return(true)
+        allow(vcloud).to receive(:sleep).and_return(true)
         vcloud.provision
 
-        hosts = vcloud.instance_variable_get( :@hosts )
-        hosts.each do | host |
+        hosts = vcloud.instance_variable_get(:@hosts)
+        hosts.each do |host|
           name = host['vmhostname']
-          vm = MockVsphereHelper.find_vm( name )
-          expect( vm.toolsRunningStatus ).to be === "guestToolsRunning"
+          vm = MockVsphereHelper.find_vm(name)
+          expect(vm.toolsRunningStatus).to be === 'guestToolsRunning'
         end
-
       end
 
       it 'does not run enable_root on cygwin hosts' do
@@ -71,44 +68,37 @@ module Beaker
 
         hosts = make_hosts
         hosts.each do |host|
-          allow( host ).to receive( :is_cygwin? ).and_return( true )
+          allow(host).to receive(:is_cygwin?).and_return(true)
         end
-        vcloud = Beaker::Vcloud.new( hosts, opts )
-        allow( vcloud ).to receive( :require ).and_return( true )
-        allow( vcloud ).to receive( :sleep ).and_return( true )
-        expect( vcloud ).to receive( :enable_root ).never
+        vcloud = Beaker::Vcloud.new(hosts, opts)
+        allow(vcloud).to receive(:require).and_return(true)
+        allow(vcloud).to receive(:sleep).and_return(true)
+        expect(vcloud).not_to receive(:enable_root)
         vcloud.provision
-
       end
-
     end
 
-    describe "#cleanup" do
-
-      it "cleans up hosts not in the pool" do
+    describe '#cleanup' do
+      it 'cleans up hosts not in the pool' do
         MockVsphereHelper.powerOn
 
         opts = make_opts
         opts[:pooling_api] = nil
         opts[:datacenter] = 'testdc'
 
-        vcloud = Beaker::Vcloud.new( make_hosts, opts )
-        allow( vcloud ).to receive( :require ).and_return( true )
-        allow( vcloud ).to receive( :sleep ).and_return( true )
+        vcloud = Beaker::Vcloud.new(make_hosts, opts)
+        allow(vcloud).to receive(:require).and_return(true)
+        allow(vcloud).to receive(:sleep).and_return(true)
         vcloud.provision
         vcloud.cleanup
 
-        hosts = vcloud.instance_variable_get( :@hosts )
-        vm_names = hosts.map {|h| h['vmhostname'] }.compact
-        vm_names.each do | name |
-          vm = MockVsphereHelper.find_vm( name )
-          expect( vm.runtime.powerState ).to be === "poweredOff"
+        hosts = vcloud.instance_variable_get(:@hosts)
+        vm_names = hosts.map { |h| h['vmhostname'] }.compact
+        vm_names.each do |name|
+          vm = MockVsphereHelper.find_vm(name)
+          expect(vm.runtime.powerState).to be === 'poweredOff'
         end
-
       end
-
     end
-
   end
-
 end