mkuzmin-rbvmomi 1.8.2.1

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,110 @@
+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
+      
+    instances = opts[:instance] || '*'
+    if !instances.is_a?(Array)
+      instances = [instances]
+    end
+    metric_ids = []
+    metrics.each do |x| 
+      counter = perfcounter_hash[x]
+      if !counter
+        pp perfcounter_hash.keys
+        fail "Counter for #{x} couldn't be found"
+      end
+      instances.each do |instance|
+        metric_ids << RbVmomi::VIM::PerfMetricId(:counterId => counter.key, 
+                                                 :instance => instance)
+      end
+    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)
+    
+    if !opts[:multi_instance]
+      Hash[stats.map do |res|
+        [
+          res.entity, 
+          {
+            :sampleInfo => res.sampleInfo,
+            :metrics => Hash[res.value.map do |metric|
+              metric_name = perfcounter_idhash[metric.id.counterId].name
+              [metric_name, metric.value]
+            end]
+          }
+        ]
+      end]
+    else
+      Hash[stats.map do |res|
+        [
+          res.entity, 
+          {
+            :sampleInfo => res.sampleInfo,
+            :metrics => Hash[res.value.map do |metric|
+              metric_name = perfcounter_idhash[metric.id.counterId].name
+              [[metric_name, metric.id.instance], metric.value]
+            end]
+          }
+        ]
+      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,74 @@
+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)
+    spec = update_spec_add_delta_disk_layer_on_all_disks
+    self.ReconfigVM_Task(:spec => spec).wait_for_completion
+  end
+  
+  # Updates a passed in spec to perform the task of adding a delta disk layer
+  # on top of all disks. Does the same as add_delta_disk_layer_on_all_disks
+  # but instead of issuing the ReconfigVM_Task, it just constructs the 
+  # spec, so that the caller can batch a couple of updates into one 
+  # ReconfigVM_Task.
+  def update_spec_add_delta_disk_layer_on_all_disks spec = {}
+    devices,  = self.collect 'config.hardware.device'
+    disks = devices.grep(RbVmomi::VIM::VirtualDisk)
+    device_change = []
+    disks.each do |disk|
+      device_change << {
+        :operation => :remove,
+        :device => disk
+      }
+      device_change << {
+        :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
+        },
+      }
+    end
+    if spec.is_a?(RbVmomi::VIM::VirtualMachineConfigSpec)
+      spec.deviceChange ||= []
+      spec.deviceChange += device_change
+    else
+      spec[:deviceChange] ||= []
+      spec[:deviceChange] += device_change
+    end
+    spec
+  end 
+end