beaker-vmware 0.1.0 → 0.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDk5NThiYWUzYjYyYzBiY2EwOGE3MTdiNDg3NjRkNmI2YjkyZTM3OQ==
+    N2JhNTJkYmI3ZWI5YTAxNmM5MTExOWI3ZGM3NDA4NzBlMTI4OTEyYg==
   data.tar.gz: !binary |-
-    Y2E4OWZkNDljZTQ2YmZjMWU5MjJmYTEyNWRhMjJlMmM5ZmZlMGE2MQ==
+    ZGE5MGIxYTE3OTU4YmZhNTU1MjZiNjFmN2M2YzRlMjM1ODE2MWMxMw==
 SHA512:
   metadata.gz: !binary |-
-    YzU4MmM3NWNiYWQyYjU4ZDY3NjM3YWNlMzZkMGRhNDk4MmFhMGE4ZmZhNzhi
-    YzBkYjk4MTMxMTdlZjQzMTI4Y2ZlOWRmZDdmM2VkNzBmMjgzYWFhYmZkN2Fj
-    ZDRlODM3NmQ4MzA4YzlhNGU2NjdjYWNjYTMzZmIyMGVkNjBiNWM=
+    NjZmMjFkMDQzZTZlZjQzYjhkYzNkNGY4MjM0NmZmN2Y3YjMzZDk2MjhmZGM4
+    MjQ4MzgzNTA2YjBjY2QzYzQ3ZjJmZTBiMjZmMDIwMDA4NmQzNTMyZmRlOGE2
+    YWVjOWFjZGFlZGI2ODVhNTgyYzdlNDkzZGQwZmYyYTExN2M4YmQ=
   data.tar.gz: !binary |-
-    ZTQ1MzYzZTBjMTUwNTI3NzgxMDY0ZWM3MWVkZWJhOGY2YjNiNTk4ZTY3MmZm
-    MDE3NmFhZmU5YjkzMDAwYmVkMTQxNTlmMWUxNTkxMGU2NTY1Yzk4YWVmMTFh
-    MDMzYzc1MjRkM2E5N2YxMjNkOGIwZjQ5ZTMyODgxN2FlMDNhNjQ=
+    NDhiZWVhYmE1MDAxYjY0MDYzNzViYjY2NDk5ZDZmOTg1MjRiMDJkOTEyNGVk
+    YzQ2NDczYTAxM2QwNjQ0YjRkMWZmZTAxZDMzMmQwZjg5MGFjODI1OTdmYTUw
+    ODNlM2E1Y2Q2NjVkM2UzMzg0N2Y4MTUwY2Q3NzZlMDJkNzA4ZGI=

data/README.md

@@ -4,7 +4,7 @@ Beaker library to use vmware fusion hypervisor
 
 # How to use this wizardry
 
-This gem that allows you to use hosts with [vmware_fusion](vmware_fusion.md) hypervisor with [beaker](https://github.com/puppetlabs/beaker). 
+This gem that allows you to use hosts with [vmware_fusion](vmware_fusion.md) and [vsphere](vsphere.md) hypervisor with [beaker](https://github.com/puppetlabs/beaker). 
 
 ### Right Now? (beaker 3.x)
 

data/beaker-vmware.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |s|
   # Run time dependencies
   s.add_runtime_dependency 'stringify-hash', '~> 0.0.0'
   s.add_runtime_dependency 'fission', '~> 0.4'
+  s.add_runtime_dependency 'rbvmomi', '~> 1.9'
 
 end
 

data/lib/beaker-vmware/version.rb

@@ -1,3 +1,3 @@
 module BeakerVmware
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/beaker/hypervisor/vsphere.rb

@@ -0,0 +1,86 @@
+require 'yaml' unless defined?(YAML)
+require 'beaker/hypervisor/vsphere_helper'
+
+module Beaker
+  class Vsphere < Beaker::Hypervisor
+
+    def initialize(vsphere_hosts, options)
+      @options = options
+      @logger = options[:logger]
+      @hosts = vsphere_hosts
+    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]}"
+
+      vsphere_helper = VsphereHelper.new( vsphere_credentials )
+
+      vsphere_vms = {}
+      @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
+
+        if snap
+          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
+        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
+      end
+
+      vsphere_helper.close
+    end
+
+    def cleanup
+      @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]}"
+
+      vsphere_helper = VsphereHelper.new( vsphere_credentials )
+
+      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
+      end
+
+      vsphere_helper.close
+    end
+
+  end
+end

data/lib/beaker/hypervisor/vsphere_helper.rb

@@ -0,0 +1,204 @@
+require 'yaml' unless defined?(YAML)
+require 'rbvmomi'
+require 'beaker/logger'
+
+class VsphereHelper
+  def initialize vInfo
+    @logger = vInfo[:logger] || Beaker::Logger.new
+    @connection = RbVmomi::VIM.connect :host     => vInfo[:server],
+                                       :user     => vInfo[:user],
+                                       :password => vInfo[:pass],
+                                       :insecure => true
+  end
+
+  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?( 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(dot_fog = '.fog')
+    vInfo = YAML.load_file( dot_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 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
+  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(dc,datastorename)
+    datacenter = @connection.serviceInstance.find_datacenter(dc)
+    datacenter.find_datastore(datastorename)
+  end
+
+  def find_folder(dc,foldername)
+    datacenter = @connection.serviceInstance.find_datacenter(dc)
+    base = datacenter.vmFolder.traverse(foldername)
+    if base != nil
+      base
+    else
+      abort "Failed to find folder #{foldername}"
+    end
+  end
+
+  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"
+      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 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
+end
+

data/spec/beaker/hypervisor/vsphere_helper_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+module Beaker
+  describe VsphereHelper do
+    let( :logger )         { double('logger').as_null_object }
+    let( :vInfo )          { { :server => "vsphere.labs.net", :user => "vsphere@labs.com", :pass => "supersekritpassword" } }
+    let( :vsphere_helper ) { VsphereHelper.new ( vInfo.merge( { :logger => logger } ) ) }
+    let( :snaplist )       { { 'snap1' => { 'snap1sub1' => nil ,
+                                            'snap1sub2' => nil },
+                               'snap2' => nil,
+                               'snap3' => { 'snap3sub1' => nil ,
+                                            'snap3sub2' => nil ,
+                                            'snap3sub3' => nil } } }
+    let( :vms )            {  [ MockRbVmomiVM.new( 'mockvm1', snaplist ),
+                                MockRbVmomiVM.new( 'mockvm2', snaplist ),
+                                MockRbVmomiVM.new( 'mockvm3', snaplist ) ] }
+
+    before :each do
+     stub_const( "RbVmomi", MockRbVmomi )
+    end
+
+    describe "#load_config" do
+
+      it 'can load a .fog file' do
+        allow( File ).to receive( :exists? ).and_return( true )
+        allow( YAML ).to receive( :load_file ).and_return( fog_file_contents )
+
+        expect( VsphereHelper.load_config ).to be === vInfo
+
+      end
+
+      it 'raises an error when the .fog file is missing' do
+        allow( File ).to receive( :exists? ).and_return( false )
+
+        expect{ VsphereHelper.load_config }.to raise_error( ArgumentError )
+
+      end
+
+    end
+
+   describe "#find_snapshot" do
+     it 'can find a given snapshot name' do
+       mockvm = MockRbVmomiVM.new( 'mockvm', snaplist )
+
+       expect( vsphere_helper.find_snapshot( mockvm, 'snap2' ) ).to be === mockvm.get_snapshot( 'snap2' )
+
+     end
+
+   end
+
+   describe "#find_customization" do
+     it 'returns the customization spec' do
+
+       expect( vsphere_helper.find_customization( 'name' ) ).to be === true
+
+     end
+
+   end
+
+   describe "#find_vms" do
+     it 'finds the list of vms' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       connection.set_info( vms )
+
+       expect( vsphere_helper.find_vms( 'mockvm1' ) ).to be === {vms[0].name => vms[0]}
+     end
+
+     it 'returns {} when no vm is found' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       connection.set_info( vms )
+
+       expect( vsphere_helper.find_vms( 'novm' ) ).to be === {}
+     end
+
+   end
+
+   describe "#find_datastore" do
+     it 'finds the datastore from the connection object' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       dc = connection.serviceInstance.find_datacenter('testdc')
+       expect(vsphere_helper.find_datastore( dc,'datastorename' ) ).to be === true
+     end
+
+   end
+
+   describe "#find_folder" do
+     it 'can find a folder in the datacenter' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       expect(vsphere_helper.find_folder( 'testdc','root' ) ).to be === connection.serviceInstance.find_datacenter('testdc').vmFolder
+     end
+
+   end
+
+   describe "#find_pool" do
+     it 'can find a pool in a folder in the datacenter' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       dc = connection.serviceInstance.find_datacenter('testdc')
+       dc.hostFolder = MockRbVmomi::VIM::Folder.new
+       dc.hostFolder.name = "/root"
+
+       expect(vsphere_helper.find_pool( 'testdc','root' ) ).to be === connection.serviceInstance.find_datacenter('testdc').hostFolder
+
+     end
+     it 'can find a pool in a clustercomputeresource in the datacenter' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       dc = connection.serviceInstance.find_datacenter('testdc')
+       dc.hostFolder = MockRbVmomi::VIM::ClusterComputeResource.new
+       dc.hostFolder.name = "/root"
+
+       expect(vsphere_helper.find_pool( 'testdc','root' ) ).to be === connection.serviceInstance.find_datacenter('testdc').hostFolder
+     end
+     it 'can find a pool in a resourcepool in the datacenter' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       dc = connection.serviceInstance.find_datacenter('testdc')
+       dc.hostFolder = MockRbVmomi::VIM::ResourcePool.new
+       dc.hostFolder.name = "/root"
+
+       expect(vsphere_helper.find_pool( 'testdc','root' ) ).to be === connection.serviceInstance.find_datacenter('testdc').hostFolder
+     end
+
+   end
+
+   describe "#wait_for_tasks" do
+     it "can wait for tasks to error" do
+       allow( vsphere_helper ).to receive( :sleep ).and_return( true )
+       vms.each do |vm|
+         vm.info.state = 'error'
+       end
+
+       expect(vsphere_helper.wait_for_tasks( vms, 0, 5 ) ).to be === vms
+     end
+
+     it "can wait for tasks to succeed" do
+       allow( vsphere_helper ).to receive( :sleep ).and_return( true )
+       vms.each do |vm|
+         vm.info.state = 'success'
+       end
+
+       expect(vsphere_helper.wait_for_tasks( vms, 0, 5 ) ).to be === vms
+     end
+
+     it "errors when tasks fail to error/success before timing out" do
+       allow( vsphere_helper ).to receive( :sleep ).and_return( true )
+       vms.each do |vm|
+         vm.info.state = 'nope'
+       end
+
+       expect{ vsphere_helper.wait_for_tasks( vms, 0, 5 ) }.to raise_error
+     end
+
+   end
+
+   describe "#close" do
+     it 'closes the connection' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       expect( connection ).to receive( :close ).once
+       
+       vsphere_helper.close
+     end
+   end
+
+ end
+end

data/spec/beaker/hypervisor/vsphere_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module Beaker
+  describe Vsphere do
+
+    before :each do
+      MockVsphereHelper.set_config( fog_file_contents )
+      MockVsphereHelper.set_vms( make_hosts() )
+     stub_const( "VsphereHelper", MockVsphereHelper )
+    end
+
+    describe "#provision" do
+
+      it 'provisions hosts' do 
+        MockVsphereHelper.powerOff
+        vsphere = Beaker::Vsphere.new( make_hosts(), make_opts )
+
+        vsphere.provision
+
+        hosts =  vsphere.instance_variable_get( :@hosts )
+        hosts.each do |host|
+          expect( MockVsphereHelper.find_vm( host.name ).powerState ) == "poweredOn"
+        end
+        
+      end
+
+      it 'raises an error if a vm is missing in Vsphere' do
+        MockVsphereHelper.powerOff
+        hosts = make_hosts()
+        hosts[0][:vmname] = 'unknown'
+        vsphere = Beaker::Vsphere.new( hosts, make_opts )
+
+        expect{ vsphere.provision }.to raise_error
+
+      end
+
+      it 'raises an error if a vm does not have a given snapshot name' do
+        MockVsphereHelper.powerOff
+        hosts = make_hosts()
+        hosts[0]["snapshot"] = 'unknown'
+        vsphere = Beaker::Vsphere.new( hosts, make_opts )
+
+        expect{ vsphere.provision }.to raise_error
+
+      end
+
+      it 'provisions hosts if no snapshot is provided' do
+        MockVsphereHelper.powerOff
+        hosts = make_hosts()
+        hosts[0]["snapshot"] = nil
+        vsphere = Beaker::Vsphere.new( hosts, make_opts )
+
+        vsphere.provision
+
+        hosts.each do |host|
+          expect( MockVsphereHelper.find_vm( host.name ).powerState ) == "poweredOn"
+        end
+
+      end
+
+    end
+
+    describe "#cleanup" do
+
+      it "cleans up" do
+        MockVsphereHelper.powerOn
+        vsphere = Beaker::Vsphere.new( make_hosts(), make_opts )
+        vsphere.cleanup
+
+        hosts =  vsphere.instance_variable_get( :@hosts )
+        hosts.each do |host|
+          expect( MockVsphereHelper.find_vm( host.name ).powerState ) == "poweredOff"
+        end
+      end
+
+      it 'raises an error if a vm is missing in Vsphere' do
+        MockVsphereHelper.powerOn
+        hosts = make_hosts()
+        hosts[0][:vmname] = 'unknown'
+        vsphere = Beaker::Vsphere.new( hosts, make_opts )
+
+        expect{ vsphere.cleanup }.to raise_error
+
+      end
+
+    end
+
+  end
+
+end

data/vsphere.md

@@ -0,0 +1,54 @@
+This doc describes beaker's vSphere hypervisor. This is the interaction layer
+that beaker will use to get Systems Under Test (SUTs) from any vSphere
+infrastructure that you might have.
+
+**Note** that if you're a puppet-internal user, or an external user that is
+using the vmpooler hypervisor, please refer to our [vmpooler doc](https://github.com/puppetlabs/beaker-vmpooler)
+for info, as it can be different than the information here. 
+
+The harness can use vms and snapshots that live within vSphere as well.
+To do this create a `~/.fog` file with your vSphere credentials:
+
+### example .fog file ###
+
+    :default:
+      :vsphere_server: 'vsphere.example.com'
+      :vsphere_username: 'joe'
+      :vsphere_password: 'MyP@$$w0rd'
+
+These follow the conventions used by Cloud Provisioner and Fog.
+
+>Note: Your fog credential file location may be specified in the 'CONFIG' section using the 'dot_fog' setting
+
+There are two possible `hypervisor` hypervisor-types to use for vSphere testing, `vsphere` and `vcloud`.
+
+### `hypervisor: vsphere`
+This option locates an existing static VM, optionally reverts it to a pre-existing snapshot, and runs tests on it.
+
+### `hypervisor: vcloud`
+This option clones a new VM from a pre-existing template, runs tests on the newly-provisioned clone, then deletes the clone once testing completes.
+
+The `vcloud` option requires a slightly-modified test configuration file, specifying both the target template as well as three additional parameters in the 'CONFIG' section ('datastore', 'datacenter', and 'folder').  Optionally, a resourcepool may be specified via the 'resourcepool' setting in the 'CONFIG' section.  Template can be expressed in the 'HOSTS' section, or you can set the template to be used via the `BEAKER_vcloud_template` environment variable.
+
+#### example vcloud hosts file ###
+    HOSTS:
+      master-vm:
+        roles:
+          - master
+          - agent
+          - dashboard
+        platform: ubuntu-10.04-amd64
+        template: ubuntu-1004-x86_64
+        hypervisor: vcloud
+      agent-vm:
+        roles:
+          - agent
+        platform: ubuntu-10.04-i386
+        template: ubuntu-1004-i386
+        hypervisor: vcloud
+    CONFIG:
+      consoleport: 443
+      datacenter: testdc
+      datastore: instance0
+      resourcepool: Delivery/Quality Assurance/FOSS/Dynamic
+      folder: delivery/Quality Assurance/FOSS/Dynamic

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beaker-vmware
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Rishi Javia, Kevin Imber, Tony Vu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-18 00:00:00.000000000 Z
+date: 2017-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -164,6 +164,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rbvmomi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
 description: For use for the Beaker acceptance testing tool
 email:
 - rishi.javia@puppet.com, kevin.imber@puppet.com, tony.vu@puppet.com
@@ -183,9 +197,14 @@ files:
 - bin/beaker-vmware
 - lib/beaker-vmware/version.rb
 - lib/beaker/hypervisor/fusion.rb
+- lib/beaker/hypervisor/vsphere.rb
+- lib/beaker/hypervisor/vsphere_helper.rb
 - spec/beaker/hypervisor/fusion_spec.rb
+- spec/beaker/hypervisor/vsphere_helper_spec.rb
+- spec/beaker/hypervisor/vsphere_spec.rb
 - spec/spec_helper.rb
 - vmware_fusion.md
+- vsphere.md
 homepage: https://github.com/puppetlabs/beaker-vmware
 licenses:
 - Apache2