gapinc-rbvmomi 1.6.0

data/lib/rbvmomi/vim/ObjectContent.rb

@@ -0,0 +1,23 @@
+class RbVmomi::VIM::ObjectContent
+  # Represent this ObjectContent as a hash.
+  # @return [Hash] A hash from property paths to values.
+  def to_hash
+    @cached_hash ||= to_hash_uncached
+  end
+
+  # Alias for +to_hash[k]+.
+  def [](k)
+    to_hash[k]
+  end
+
+  private
+
+  def to_hash_uncached
+    h = {}
+    propSet.each do |x|
+      fail if h.member? x.name
+      h[x.name] = x.val
+    end
+    h
+  end
+end

data/lib/rbvmomi/vim/ObjectUpdate.rb

@@ -0,0 +1,23 @@
+class RbVmomi::VIM::ObjectUpdate
+  # Represent this ObjectUpdate as a hash.
+  # @return [Hash] A hash from property paths to values.
+  def to_hash
+    @cached_hash ||= to_hash_uncached
+  end
+
+  # Alias for +to_hash[k]+.
+  def [](k)
+    to_hash[k]
+  end
+
+  private
+
+  def to_hash_uncached
+    h = {}
+    changeSet.each do |x|
+      fail if h.member? x.name
+      h[x.name] = x.val
+    end
+    h
+  end
+end

data/lib/rbvmomi/vim/OvfManager.rb

@@ -0,0 +1,107 @@
+# @note +deployOVF+ and requires +curl+. If +curl+ is not in your +PATH+
+#       then set the +CURL+ environment variable to point to it.
+# @todo Use an HTTP library instead of executing +curl+.
+class RbVmomi::VIM::OvfManager
+  CURLBIN = ENV['CURL'] || "curl" #@private
+
+  # Deploy an OVF.
+  #
+  # @param [Hash] opts The options hash.
+  # @option opts [String]             :uri Location of the OVF.
+  # @option opts [String]             :vmName Name of the new VM.
+  # @option opts [VIM::Folder]        :vmFolder Folder to place the VM in.
+  # @option opts [VIM::HostSystem]    :host Host to use.
+  # @option opts [VIM::ResourcePool]  :resourcePool Resource pool to use.
+  # @option opts [VIM::Datastore]     :datastore Datastore to use.
+  # @option opts [String]             :diskProvisioning (thin) Disk provisioning mode.
+  # @option opts [Hash]               :networkMappings Network mappings.
+  # @option opts [Hash]               :propertyMappings Property mappings.
+  def deployOVF opts
+    opts = { :networkMappings => {},
+             :propertyMappings => {},
+             :diskProvisioning => :thin }.merge opts
+
+    %w(uri vmName vmFolder host resourcePool datastore).each do |k|
+      fail "parameter #{k} required" unless opts[k.to_sym]
+    end
+
+    ovfImportSpec = RbVmomi::VIM::OvfCreateImportSpecParams(
+      :hostSystem => opts[:host],
+      :locale => "US",
+      :entityName => opts[:vmName],
+      :deploymentOption => "",
+      :networkMapping => opts[:networkMappings].map{|from, to| RbVmomi::VIM::OvfNetworkMapping(:name => from, :network => to)},
+      :propertyMapping => opts[:propertyMappings].to_a,
+      :diskProvisioning => opts[:diskProvisioning]
+    )
+
+    result = CreateImportSpec(
+      :ovfDescriptor => open(opts[:uri]).read,
+      :resourcePool => opts[:resourcePool],
+      :datastore => opts[:datastore],
+      :cisp => ovfImportSpec
+    )
+
+    raise result.error[0].localizedMessage if result.error && !result.error.empty?
+
+    if result.warning
+      result.warning.each{|x| puts "OVF Warning: #{x.localizedMessage.chomp}" }
+    end
+
+    nfcLease = opts[:resourcePool].ImportVApp(:spec => result.importSpec,
+                                              :folder => opts[:vmFolder],
+                                              :host => opts[:host])
+
+    nfcLease.wait_until(:state) { nfcLease.state != "initializing" }
+    raise nfcLease.error if nfcLease.state == "error"
+    begin
+      nfcLease.HttpNfcLeaseProgress(:percent => 5)
+      progress = 5.0
+      result.fileItem.each do |fileItem|
+        deviceUrl = nfcLease.info.deviceUrl.find{|x| x.importKey == fileItem.deviceId}
+        if !deviceUrl
+          raise "Couldn't find deviceURL for device '#{fileItem.deviceId}'"
+        end
+
+        # XXX handle file:// URIs
+        ovfFilename = opts[:uri].to_s
+        tmp = ovfFilename.split(/\//)
+        tmp.pop
+        tmp << fileItem.path
+        filename = tmp.join("/")
+
+        method = fileItem.create ? "PUT" : "POST"
+
+        keepAliveThread = Thread.new do
+          while true
+            sleep 2 * 60
+            nfcLease.HttpNfcLeaseProgress(:percent => progress.to_i)
+          end
+        end
+
+        href = deviceUrl.url.gsub("*", opts[:host].config.network.vnic[0].spec.ip.ipAddress)
+        downloadCmd = "#{CURLBIN} -L '#{URI::escape(filename)}'"
+        uploadCmd = "#{CURLBIN} -Ss -X #{method} --insecure -T - -H 'Content-Type: application/x-vnd.vmware-streamVmdk' '#{URI::escape(href)}'"
+        # Previously we used to append "-H 'Content-Length: #{fileItem.size}'"
+        # to the uploadCmd. It is not clear to me why, but that leads to 
+        # trucation of the uploaded disk. Without this option curl can't tell
+        # the progress, but who cares
+        system("#{downloadCmd} | #{uploadCmd}", STDOUT => "/dev/null")
+        
+        keepAliveThread.kill
+        keepAliveThread.join
+        
+        progress += (90.0 / result.fileItem.length)
+        nfcLease.HttpNfcLeaseProgress(:percent => progress.to_i)
+      end
+
+      nfcLease.HttpNfcLeaseProgress(:percent => 100)
+      vm = nfcLease.info.entity
+      nfcLease.HttpNfcLeaseComplete
+      vm
+    end
+  rescue Exception
+    (nfcLease.HttpNfcLeaseAbort rescue nil) if nfcLease
+    raise
+  end
+end

data/lib/rbvmomi/vim/PerfCounterInfo.rb

@@ -0,0 +1,26 @@
+# Copyright (c) 2011 VMware, Inc.  All Rights Reserved.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+class RbVmomi::VIM::PerfCounterInfo
+  def name
+    "#{groupInfo.key}.#{nameInfo.key}"
+  end
+end
+

data/lib/rbvmomi/vim/PerformanceManager.rb

@@ -0,0 +1,85 @@
+require 'date'
+
+class Time
+  def to_datetime
+    # Convert seconds + microseconds into a fractional number of seconds
+    seconds = sec + Rational(usec, 10**6)
+
+    # Convert a UTC offset measured in minutes to one measured in a
+    # fraction of a day.
+    offset = Rational(utc_offset, 60 * 60 * 24)
+    DateTime.new(year, month, day, hour, min, seconds, offset)
+  end
+end
+
+RbVmomi::VIM::PerformanceManager
+class RbVmomi::VIM::PerformanceManager
+  def perfcounter_cached
+    @perfcounter ||= perfCounter
+  end
+  
+  def perfcounter_hash
+    @perfcounter_hash ||= Hash[perfcounter_cached.map{|x| [x.name, x]}]
+  end
+  
+  def perfcounter_idhash 
+    @perfcounter_idhash ||= Hash[perfcounter_cached.map{|x| [x.key, x]}]
+  end
+  
+  def provider_summary obj
+    @provider_summary ||= {}
+    @provider_summary[obj.class] ||= QueryPerfProviderSummary(:entity => obj)
+  end
+
+  def retrieve_stats objects, metrics, opts = {}
+    opts = opts.dup
+    max_samples = opts[:max_samples] || 1
+    realtime = false
+    if not opts[:interval]
+      provider = provider_summary objects.first
+      opts[:interval] = provider.refreshRate
+      realtime = true
+    else
+      provider = provider_summary objects.first
+      if opts[:interval] == provider.refreshRate
+        realtime = true
+      end
+    end
+      
+    metric_ids = metrics.map do |x| 
+      counter = perfcounter_hash[x]
+      if !counter
+        pp perfcounter_hash.keys
+        fail "Counter for #{x} couldn't be found"
+      end
+      RbVmomi::VIM::PerfMetricId(:counterId => counter.key, :instance => '*')
+    end
+    query_specs = objects.map do |obj|
+      RbVmomi::VIM::PerfQuerySpec({
+        :maxSample => max_samples, 
+        :entity => obj, 
+        :metricId => metric_ids, 
+        :intervalId => opts[:interval],
+        :startTime => (realtime == false ? opts[:start_time].to_datetime : nil),
+      })
+    end
+    stats = QueryPerf(:querySpec => query_specs)
+    
+    Hash[stats.map do |res|
+      [
+        res.entity, 
+        {
+          :sampleInfo => res.sampleInfo,
+          :metrics => Hash[res.value.map do |metric|
+            [perfcounter_idhash[metric.id.counterId].name, metric.value]
+          end]
+        }
+      ]
+    end]
+  end
+
+  def active_intervals
+    intervals = historicalInterval
+    Hash[(1..4).map { |level| [level, intervals.select { |x| x.enabled && x.level >= level }] }]
+  end
+end

data/lib/rbvmomi/vim/PropertyCollector.rb

@@ -0,0 +1,25 @@
+class RbVmomi::VIM::PropertyCollector
+  def collectMultiple objs, *pathSet
+    return {} if objs.empty?
+
+    klasses = objs.map{|x| x.class}.uniq 
+    klass = if klasses.length > 1
+      # common superclass
+      klasses.map(&:ancestors).inject(&:&)[0]
+    else
+      klasses.first
+    end
+
+    spec = {
+      :objectSet => objs.map{|x| { :obj => x }},
+      :propSet => [{
+        :pathSet => pathSet,
+        :type => klass.wsdl_name
+      }]
+    }
+    res = RetrieveProperties(:specSet => [spec])
+    Hash[res.map do |x|
+      [x.obj, x.to_hash]
+    end]
+  end
+end

data/lib/rbvmomi/vim/ReflectManagedMethodExecuter.rb

@@ -0,0 +1,30 @@
+module RbVmomi
+
+class VIM::ReflectManagedMethodExecuter
+  def fetch moid, prop
+    result = FetchSoap(:moid => moid, :version => 'urn:vim25/5.0', :prop => prop)
+    xml = Nokogiri(result.response)
+    _connection.deserializer.deserialize xml.root, nil
+  end
+
+  def execute moid, method, args
+    soap_args = args.map do |k,v|
+      VIM::ReflectManagedMethodExecuterSoapArgument.new.tap do |soap_arg|
+        soap_arg.name = k
+        xml = Builder::XmlMarkup.new :indent => 0
+        _connection.obj2xml xml, k, :anyType, false, v
+        soap_arg.val = xml.target!
+      end
+    end
+    result = ExecuteSoap(:moid => moid, :version => 'urn:vim25/5.0',
+                         :method => method, :argument => soap_args)
+    if result
+      _connection.deserializer.deserialize Nokogiri(result.response).root, nil
+    else
+      nil
+    end
+  end
+end
+
+end
+

data/lib/rbvmomi/vim/ResourcePool.rb

@@ -0,0 +1,55 @@
+class RbVmomi::VIM::ResourcePool
+  # Retrieve a child ResourcePool.
+  # @param name [String] Name of the child.
+  # @return [VIM::ResourcePool]
+  def find name
+    _connection.searchIndex.FindChild(:entity => self, :name => name)
+  end
+
+  # Retrieve a descendant of this ResourcePool.
+  # @param path [String] Path delimited by '/'.
+  # @return [VIM::ResourcePool]
+  def traverse path
+    es = path.split('/').reject(&:empty?)
+    es.inject(self) do |f,e|
+      f.find(e) || return
+    end
+  end
+
+  def resourcePoolSubTree fields = []
+    self.class.resourcePoolSubTree [self], fields
+  end
+  
+  def self.resourcePoolSubTree objs, fields = []
+    fields = (fields + ['name', 'resourcePool']).uniq
+    filterSpec = RbVmomi::VIM.PropertyFilterSpec(
+      :objectSet => objs.map do |obj|
+        RbVmomi::VIM.ObjectSpec(
+          :obj => obj,
+          :selectSet => [
+            RbVmomi::VIM.TraversalSpec(
+              :name => "tsRP",
+              :type => 'ResourcePool',
+              :path => 'resourcePool',
+              :skip => false,
+              :selectSet => [
+                RbVmomi::VIM.SelectionSpec(:name => "tsRP")
+              ]
+            )
+          ]
+        )
+      end,
+      :propSet => [{
+        :pathSet => fields,
+        :type => 'ResourcePool'
+      }]
+    )
+  
+    propCollector = objs.first._connection.propertyCollector
+    result = propCollector.RetrieveProperties(:specSet => [filterSpec])
+    
+    Hash[result.map do |x|
+      [x.obj, x.to_hash]
+    end]
+  end
+end

data/lib/rbvmomi/vim/ServiceInstance.rb

@@ -0,0 +1,55 @@
+class RbVmomi::VIM::ServiceInstance
+  # Retrieve a Datacenter.
+  # If no path is given the first datacenter will be returned.
+  # @param path (see Folder#traverse)
+  # @return [Datacenter]
+  def find_datacenter path=nil
+    if path
+      content.rootFolder.traverse path, RbVmomi::VIM::Datacenter
+    else
+      content.rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).first
+    end
+  end
+
+  # Wait for several tasks to complete.
+  # @param interested [Array] Property paths to watch for updates.
+  # @param tasks [Array] Tasks to wait on.
+  # @yield [Hash] Called when a property is updated on a task.
+  #               The parameter is a hash from tasks to hashes from
+  #               property path to value.
+  # @return [void]
+  def wait_for_multiple_tasks interested, tasks
+    version = ''
+    interested = (interested + ['info.state']).uniq
+    task_props = Hash.new { |h,k| h[k] = {} }
+
+    filter = _connection.propertyCollector.CreateFilter :spec => {
+      :propSet => [{ :type => 'Task', :all => false, :pathSet => interested }],
+      :objectSet => tasks.map { |x| { :obj => x } },
+    }, :partialUpdates => false
+
+    begin
+      until task_props.size == tasks.size and task_props.all? { |k,h| %w(success error).member? h['info.state'] }
+        result = _connection.propertyCollector.WaitForUpdates(:version => version)
+        version = result.version
+        os = result.filterSet[0].objectSet
+
+        os.each do |o|
+          changes = Hash[o.changeSet.map { |x| [x.name, x.val] }]
+
+          interested.each do |k|
+            task = tasks.find { |x| x._ref == o.obj._ref }
+            task_props[task][k] = changes[k] if changes.member? k
+          end
+        end
+
+        yield task_props if block_given?
+      end
+    ensure
+      _connection.propertyCollector.CancelWaitForUpdates
+      filter.DestroyPropertyFilter
+    end
+
+    task_props
+  end
+end

data/lib/rbvmomi/vim/Task.rb

@@ -0,0 +1,65 @@
+class RbVmomi::VIM::Task
+  # Wait for a task to finish.
+  # @return +info.result+ on success.
+  # @raise +info.error+ on error.
+  def wait_for_completion
+    wait_until('info.state') { %w(success error).member? info.state }
+    case info.state
+    when 'success'
+      info.result
+    when 'error'
+      raise info.error
+    end
+  end
+  
+  # Wait for all child tasks to finish. If any one child task failed,
+  # the exception of the first failing task is thrown.
+  # @return [Hash] Map of tasks to their +info.result+ on success.
+  # @raise +info.error+ on error.
+  def wait_for_childtask_completion
+    si = _connection.serviceInstance
+    tasks_props = si.wait_for_multiple_tasks(
+      ['info.state', 'info.result', 'info.error'],
+      self.child_tasks
+    )
+    Hash[tasks_props.map do |task, props|
+      case props['info.state']
+      when 'success'
+        [task, props['info.result']]
+      when 'error'
+        raise props['info.error']
+      end
+    end]
+  end
+
+  # Wait for a task to finish, with progress notifications.
+  # @return (see #wait_for_completion)
+  # @raise (see #wait_for_completion)
+  # @yield [info.progress]
+  def wait_for_progress
+    wait_until('info.state', 'info.progress') do
+      yield info.progress if block_given?
+      %w(success error).member? info.state
+    end
+    case info.state
+    when 'success'
+      info.result
+    when 'error'
+      raise info.error
+    end
+  end
+  
+  # Get child tasks of this task.
+  # @return [Array] List of VIM::Task objects
+  def child_tasks
+    tm = _connection.serviceContent.taskManager
+    col = tm.CreateCollectorForTasks(:filter => {
+      :rootTaskKey => [self.info.key],
+    })
+    # XXX: Likely this is not enough and we need to collect pages other
+    #      than the latest.
+    tasks = col.latestPage.map{|x| x.task}
+    col.DestroyCollector()
+    tasks
+  end
+end

data/lib/rbvmomi/vim/VirtualMachine.rb

@@ -0,0 +1,59 @@
+class RbVmomi::VIM::VirtualMachine
+  # Retrieve the MAC addresses for all virtual NICs.
+  # @return [Hash] Keyed by device label.
+  def macs
+    Hash[self.config.hardware.device.grep(RbVmomi::VIM::VirtualEthernetCard).map { |x| [x.deviceInfo.label, x.macAddress] }]
+  end
+  
+  # Retrieve all virtual disk devices.
+  # @return [Array] Array of virtual disk devices.
+  def disks
+    self.config.hardware.device.grep(RbVmomi::VIM::VirtualDisk)
+  end
+  
+  # Get the IP of the guest, but only if it is not stale 
+  # @return [String] Current IP reported (as per VMware Tools) or nil
+  def guest_ip 
+    g = self.guest
+    if g.ipAddress && (g.toolsStatus == "toolsOk" || g.toolsStatus == "toolsOld")
+      g.ipAddress
+    else
+      nil
+    end
+  end  
+
+  # Add a layer of delta disks (redo logs) in front of every disk on the VM.
+  # This is similar to taking a snapshot and makes the VM a valid target for
+  # creating a linked clone.
+  #
+  # Background: The API for linked clones is quite strange. We can't create 
+  # a linked straight from any VM. The disks of the VM for which we can create a
+  # linked clone need to be read-only and thus VC demands that the VM we
+  # are cloning from uses delta-disks. Only then it will allow us to
+  # share the base disk.
+  def add_delta_disk_layer_on_all_disks
+    devices,  = self.collect 'config.hardware.device'
+    disks = devices.grep(RbVmomi::VIM::VirtualDisk)
+    # XXX: Should create a single reconfig spec instead of one per disk
+    disks.each do |disk|
+      spec = {
+        :deviceChange => [
+          {
+            :operation => :remove,
+            :device => disk
+          },
+          {
+            :operation => :add,
+            :fileOperation => :create,
+            :device => disk.dup.tap { |x|
+              x.backing = x.backing.dup
+              x.backing.fileName = "[#{disk.backing.datastore.name}]"
+              x.backing.parent = disk.backing
+            },
+          }
+        ]
+      }
+      self.ReconfigVM_Task(:spec => spec).wait_for_completion
+    end
+  end 
+end

data/lib/rbvmomi/vim.rb

@@ -0,0 +1,99 @@
+# Copyright (c) 2011 VMware, Inc.  All Rights Reserved.
+require 'rbvmomi'
+
+module RbVmomi
+
+# A connection to one vSphere SDK endpoint.
+# @see #serviceInstance
+class VIM < Connection
+  # Connect to a vSphere SDK endpoint
+  #
+  # @param [Hash] opts The options hash.
+  # @option opts [String]  :host Host to connect to.
+  # @option opts [Numeric] :port (443) Port to connect to.
+  # @option opts [Boolean] :ssl (true) Whether to use SSL.
+  # @option opts [Boolean] :insecure (false) If true, ignore SSL certificate errors.
+  # @option opts [String]  :user (root) Username.
+  # @option opts [String]  :password Password.
+  # @option opts [String]  :path (/sdk) SDK endpoint path.
+  # @option opts [Boolean] :debug (false) If true, print SOAP traffic to stderr.
+  def self.connect opts
+    fail unless opts.is_a? Hash
+    fail "host option required" unless opts[:host]
+    opts[:user] ||= 'root'
+    opts[:password] ||= ''
+    opts[:ssl] = true unless opts.member? :ssl or opts[:"no-ssl"]
+    opts[:insecure] ||= false
+    opts[:port] ||= (opts[:ssl] ? 443 : 80)
+    opts[:path] ||= '/sdk'
+    opts[:ns] ||= 'urn:vim25'
+    rev_given = opts[:rev] != nil
+    opts[:rev] = '4.0' unless rev_given
+    opts[:debug] = (!ENV['RBVMOMI_DEBUG'].empty? rescue false) unless opts.member? :debug
+
+    new(opts).tap do |vim|
+      vim.serviceContent.sessionManager.Login :userName => opts[:user], :password => opts[:password]
+      unless rev_given
+        rev = vim.serviceContent.about.apiVersion
+        vim.rev = [rev, '5.0'].min
+      end
+    end
+  end
+
+  def close
+    VIM::SessionManager(self, 'SessionManager').Logout rescue RbVmomi::Fault
+    self.cookie = nil
+    super
+  end
+  
+  def rev= x
+    super
+    @serviceContent = nil
+  end
+
+  # Return the ServiceInstance
+  #
+  # The ServiceInstance is the root of the vSphere inventory.
+  # @see http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.ServiceInstance.html
+  def serviceInstance
+    VIM::ServiceInstance self, 'ServiceInstance'
+  end
+
+  # Alias to serviceInstance.RetrieveServiceContent
+  def serviceContent
+    @serviceContent ||= serviceInstance.RetrieveServiceContent
+  end
+
+  # Alias to serviceContent.rootFolder
+  def rootFolder
+    serviceContent.rootFolder
+  end
+
+  alias root rootFolder
+
+  # Alias to serviceContent.propertyCollector
+  def propertyCollector
+    serviceContent.propertyCollector
+  end
+
+  # Alias to serviceContent.searchIndex
+  def searchIndex
+    serviceContent.searchIndex
+  end
+
+  # @private
+  def pretty_print pp
+    pp.text "VIM(#{@opts[:host]})"
+  end
+  
+  def instanceUuid
+    serviceContent.about.instanceUuid
+  end
+
+  add_extension_dir File.join(File.dirname(__FILE__), "vim")
+  (ENV['RBVMOMI_VIM_EXTENSION_PATH']||'').split(':').each { |dir| add_extension_dir dir }
+
+  load_vmodl(ENV['VMODL'] || File.join(File.dirname(__FILE__), "../../vmodl.db"))
+end
+
+end

data/lib/rbvmomi.rb

@@ -0,0 +1,15 @@
+# Copyright (c) 2010 VMware, Inc.  All Rights Reserved.
+module RbVmomi
+
+# @private
+# @deprecated Use +RbVmomi::VIM.connect+.
+  def self.connect opts
+    VIM.connect opts
+  end
+
+end
+
+require 'rbvmomi/version'
+require 'rbvmomi/connection'
+require 'rbvmomi/vim'
+