mkuzmin-rbvmomi 1.8.2.1

data/lib/rbvmomi/vim.rb

@@ -0,0 +1,128 @@
+# 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]  :cookie If set, use cookie to connect instead of user/password
+  # @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[:cookie] ||= nil
+    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|
+      unless opts[:cookie]
+        vim.serviceContent.sessionManager.Login :userName => opts[:user], :password => opts[:password]
+      end
+      unless rev_given
+        rev = vim.serviceContent.about.apiVersion
+        vim.rev = [rev, '5.5'].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
+
+  def get_log_lines logKey, lines=5, start=nil, host=nil
+    diagMgr = self.serviceContent.diagnosticManager
+    if !start
+      log = diagMgr.BrowseDiagnosticLog(:host => host, :key => logKey, :start => 999999999)
+      lineEnd = log.lineEnd
+      start = lineEnd - lines
+    end
+    start = start < 0 ? 0 : start
+    log = diagMgr.BrowseDiagnosticLog(:host => host, :key => logKey, :start => start)
+    if log.lineText.size > 0
+      [log.lineText.slice(-lines, log.lineText.size), log.lineEnd]
+    else
+      [log.lineText, log.lineEnd]
+    end
+  end
+
+  def get_log_keys host=nil
+    diagMgr = self.serviceContent.diagnosticManager
+    keys = []
+    diagMgr.QueryDescriptions(:host => host).each do |desc|
+      keys << "#{desc.key}"
+    end
+    keys
+  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/vim/ComputeResource.rb

@@ -0,0 +1,51 @@
+class RbVmomi::VIM::ComputeResource
+  # Aggregate cluster information.
+  #
+  # @note Values are returned in a hash.
+  #
+  # @return [Mhz] totalCPU: Sum of the frequencies of each CPU in the cluster.
+  # @return [Mhz] usedCPU:  CPU cycles used across the cluster.
+  # @return [MB]  totalMem: Total RAM.
+  # @return [MB]  usedMem:  Used RAM.
+  def stats
+    filterSpec = RbVmomi::VIM.PropertyFilterSpec(
+      :objectSet => [{
+        :obj => self,
+        :selectSet => [
+          RbVmomi::VIM.TraversalSpec(
+            :name => 'tsHosts',
+            :type => 'ComputeResource',
+            :path => 'host',
+            :skip => false
+          )
+        ]
+      }],
+      :propSet => [{
+        :pathSet => %w(name overallStatus summary.hardware.cpuMhz
+                    summary.hardware.numCpuCores summary.hardware.memorySize
+                    summary.quickStats.overallCpuUsage
+                    summary.quickStats.overallMemoryUsage),
+        :type => 'HostSystem'
+      }]
+    )
+
+    result = _connection.propertyCollector.RetrieveProperties(:specSet => [filterSpec])
+
+    stats = {
+      :totalCPU => 0,
+      :totalMem => 0,
+      :usedCPU => 0,
+      :usedMem => 0,
+    }
+
+    result.each do |x|
+      next if x['overallStatus'] == 'red'
+      stats[:totalCPU] += x['summary.hardware.cpuMhz'] * x['summary.hardware.numCpuCores']
+      stats[:totalMem] += x['summary.hardware.memorySize'] / (1024*1024)
+      stats[:usedCPU] += x['summary.quickStats.overallCpuUsage'] || 0
+      stats[:usedMem] += x['summary.quickStats.overallMemoryUsage'] || 0
+    end
+
+    stats
+  end
+end

data/lib/rbvmomi/vim/Datacenter.rb

@@ -0,0 +1,17 @@
+class RbVmomi::VIM::Datacenter
+  # Traverse the given inventory +path+ to find a ComputeResource.
+  def find_compute_resource path
+    hostFolder.traverse path, RbVmomi::VIM::ComputeResource
+  end
+
+  # Find the Datastore with the given +name+.
+  def find_datastore name
+    datastore.find { |x| x.name == name }
+  end
+
+  # Traverse the given inventory +path+ to find a VirtualMachine.
+  def find_vm path
+    vmFolder.traverse path, RbVmomi::VIM::VirtualMachine
+  end
+end
+

data/lib/rbvmomi/vim/Datastore.rb

@@ -0,0 +1,68 @@
+# @note +download+ and +upload+ require +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::Datastore
+  CURLBIN = ENV['CURL'] || "curl" #@private
+
+  # Check whether a file exists on this datastore.
+  # @param path [String] Path on the datastore.
+  def exists? path
+    req = Net::HTTP::Head.new mkuripath(path)
+    req.initialize_http_header 'cookie' => _connection.cookie
+    resp = _connection.http.request req
+    case resp
+    when Net::HTTPSuccess
+      true
+    when Net::HTTPNotFound
+      false
+    else
+      fail resp.inspect
+    end
+  end
+
+  # Download a file from this datastore.
+  # @param remote_path [String] Source path on the datastore.
+  # @param local_path [String] Destination path on the local machine.
+  # @return [void]
+  def download remote_path, local_path
+    url = "http#{_connection.http.use_ssl? ? 's' : ''}://#{_connection.http.address}:#{_connection.http.port}#{mkuripath(remote_path)}"
+    pid = spawn CURLBIN, "-k", '--noproxy', '*', '-f',
+                "-o", local_path,
+                "-b", _connection.cookie,
+                url,
+                :out => '/dev/null'
+    Process.waitpid(pid, 0)
+    fail "download failed" unless $?.success?
+  end
+
+  # Upload a file to this datastore.
+  # @param remote_path [String] Destination path on the datastore.
+  # @param local_path [String] Source path on the local machine.
+  # @return [void]
+  def upload remote_path, local_path
+    url = "http#{_connection.http.use_ssl? ? 's' : ''}://#{_connection.http.address}:#{_connection.http.port}#{mkuripath(remote_path)}"
+    pid = spawn CURLBIN, "-k", '--noproxy', '*', '-f',
+                "-T", local_path,
+                "-b", _connection.cookie,
+                url,
+                :out => '/dev/null'
+    Process.waitpid(pid, 0)
+    fail "upload failed" unless $?.success?
+  end
+
+  private
+
+  def datacenter
+    return @datacenter if @datacenter
+    x = parent
+    while not x.is_a? RbVmomi::VIM::Datacenter
+      x = x.parent
+    end
+    fail unless x.is_a? RbVmomi::VIM::Datacenter
+    @datacenter = x
+  end
+
+  def mkuripath path
+    "/folder/#{URI.escape path}?dcPath=#{URI.escape datacenter.name}&dsName=#{URI.escape name}"
+  end
+end

data/lib/rbvmomi/vim/DynamicTypeMgrAllTypeInfo.rb

@@ -0,0 +1,75 @@
+class RbVmomi::VIM::DynamicTypeMgrAllTypeInfo
+  def toRbvmomiTypeHash
+    id2name = {}
+    id2name.merge!({
+      'string' => 'xsd:string',
+      'java.lang.String' => 'xsd:string',
+      'BOOLEAN' => 'xsd:boolean',
+      'BYTE' => 'xsd:byte',
+      'SHORT' => 'xsd:short',
+      'INT' => 'xsd:int',
+      'LONG' => 'xsd:long',
+      'FLOAT' => 'xsd:float',
+      'DOUBLE' => 'xsd:double',
+      'boolean' => 'xsd:boolean',
+      'byte' => 'xsd:byte',
+      'short' => 'xsd:short',
+      'int' => 'xsd:int',
+      'long' => 'xsd:long',
+      'float' => 'xsd:float',
+      'double' => 'xsd:double',
+      'vmodl.DateTime' => 'xsd:dateTime',
+      'vmodl.Binary' => 'xsd:base64Binary',
+      'vmodl.Any' => 'xsd:anyType',
+      'vim.KeyValue' => 'KeyValue',
+      'void' => nil,
+    })
+
+    %w(DataObject ManagedObject MethodFault MethodName DynamicData
+       PropertyPath RuntimeFault TypeName).each do |x|
+      id2name['vmodl.' + x] = x
+    end
+
+    types = {}
+    self.managedTypeInfo.each{|x| types.merge!(x.toRbvmomiTypeHash) }
+    self.dataTypeInfo.each{|x| types.merge!(x.toRbvmomiTypeHash) }
+
+    types.each do |k,t|
+      id2name[t['type-id']] = k
+    end
+
+    types = Hash[types.map do |k,t|
+      case t['kind']
+      when 'data'
+        t['wsdl_base'] = t['base-type-id'] ? id2name[t['base-type-id']] : 'DataObject'
+        #t.delete 'base-type-id'
+        t['props'].each do |x|
+          x['wsdl_type'] = id2name[x['type-id-ref']]
+          x.delete 'type-id-ref'
+        end
+      when 'managed'
+        t['wsdl_base'] = t['base-type-id'] ? id2name[t['base-type-id']] : 'ManagedObject'
+        #t.delete 'base-type-id'
+        t['props'].each do |x|
+          x['wsdl_type'] = id2name[x['type-id-ref']]
+          x.delete 'type-id-ref'
+        end
+        t['methods'].each do |mName,x|
+          if y = x['result']
+            y['wsdl_type'] = id2name[y['type-id-ref']]
+            #y.delete 'type-id-ref'
+          end
+          x['params'].each do |r|
+            r['wsdl_type'] = id2name[r['type-id-ref']]
+            r.delete 'type-id-ref'
+          end
+        end
+      when 'enum'
+      else fail
+      end
+      [k, t]
+    end]
+
+    types
+  end
+end

data/lib/rbvmomi/vim/DynamicTypeMgrDataTypeInfo.rb

@@ -0,0 +1,20 @@
+class RbVmomi::VIM::DynamicTypeMgrDataTypeInfo
+  def toRbvmomiTypeHash
+    {
+      self.wsdlName => {
+        'kind' => 'data',
+        'type-id' => self.name,
+        'base-type-id' => self.base.first,
+        'props' => self.property.map do |prop|
+          {
+            'name' => prop.name,
+            'type-id-ref' => prop.type.gsub("[]", ""),
+            'is-array' => (prop.type =~ /\[\]$/) ? true : false,
+            'is-optional' => prop.annotation.find{|a| a.name == "optional"} ? true : false,
+            'version-id-ref' => prop.version,
+          }
+        end,
+      }
+    }
+  end
+end

data/lib/rbvmomi/vim/DynamicTypeMgrManagedTypeInfo.rb

@@ -0,0 +1,46 @@
+class RbVmomi::VIM::DynamicTypeMgrManagedTypeInfo
+  def toRbvmomiTypeHash
+    {
+      self.wsdlName => {
+        'kind' => 'managed',
+        'type-id' => self.name,
+        'base-type-id' => self.base.first,
+        'props' => self.property.map do |prop|
+          {
+            'name' => prop.name,
+            'type-id-ref' => prop.type.gsub("[]", ""),
+            'is-array' => (prop.type =~ /\[\]$/) ? true : false,
+            'is-optional' => prop.annotation.find{|a| a.name == "optional"} ? true : false,
+            'version-id-ref' => prop.version,
+          }
+        end,
+        'methods' => Hash[
+          self.method.map do |method|
+            result = method.returnTypeInfo
+
+            [method.wsdlName,
+             {
+               'params' => method.paramTypeInfo.map do |param|
+                 {
+                   'name' => param.name,
+                   'type-id-ref' => param.type.gsub("[]", ""),
+                   'is-array' => (param.type =~ /\[\]$/) ? true : false,
+                   'is-optional' => param.annotation.find{|a| a.name == "optional"} ? true : false,
+                   'version-id-ref' => param.version,
+                 }
+               end,
+               'result' => {
+                 'name' => result.name,
+                 'type-id-ref' => result.type.gsub("[]", ""),
+                 'is-array' => (result.type =~ /\[\]$/) ? true : false,
+                 'is-optional' => result.annotation.find{|a| a.name == "optional"} ? true : false,
+                 'version-id-ref' => result.version,
+               }
+             }
+            ]
+          end
+        ]
+      }
+    }
+  end
+end

data/lib/rbvmomi/vim/Folder.rb

@@ -0,0 +1,207 @@
+class RbVmomi::VIM::Folder
+  # Retrieve a child entity
+  # @param name [String] Name of the child.
+  # @param type [Class] Return nil unless the found entity <tt>is_a? type</tt>.
+  # @return [VIM::ManagedEntity]
+  def find name, type=Object
+    x = _connection.searchIndex.FindChild(:entity => self, :name => name)
+    x if x.is_a? type
+  end
+
+  # Retrieve a virtual machine or host by DNS name
+  # @param name [String] The fully qualified domain name to find.
+  # @param type [Class] Return nil unless the found entity <tt>is_a? type</tt>.
+  # @param dc [RbVmomi::VIM::Datacenter] Restricts the query to entities in the given Datacenter.
+  # @return [VIM::ManagedEntity]
+  def findByDnsName name, type=RbVmomi::VIM::VirtualMachine, dc=nil
+    propSpecs = {
+      :entity => self, :dnsName => name,
+      :vmSearch => type == RbVmomi::VIM::VirtualMachine
+    }
+    propSpecs[:datacenter] = dc if dc
+    x = _connection.searchIndex.FindByDnsName(propSpecs)
+    x if x.is_a? type
+  end
+
+  # Retrieve a virtual machine or host by IP address
+  # @param ip [String] The IP address is in dot-decimal notation.
+  # @param type [Class] Return nil unless the found entity <tt>is_a? type</tt>.
+  # @param dc [RbVmomi::VIM::Datacenter] Restricts the query to entities in the given Datacenter.
+  # @return [VIM::ManagedEntity]
+  def findByIp ip, type=RbVmomi::VIM::VirtualMachine, dc=nil
+    propSpecs = {
+      :entity => self, :ip => ip,
+      :vmSearch => type == RbVmomi::VIM::VirtualMachine
+    }
+    propSpecs[:datacenter] = dc if dc
+    x = _connection.searchIndex.FindByIp(propSpecs)
+    x if x.is_a? type
+  end
+
+  # Retrieve a virtual machine or host by BIOS UUID.
+  # @param uuid [String] The UUID to find.
+  # @param type [Class] Return nil unless the found entity <tt>is_a? type</tt>.
+  # @param dc [RbVmomi::VIM::Datacenter] Restricts the query to entities in the given Datacenter.
+  # @return [VIM::ManagedEntity]
+  def findByUuid uuid, type=RbVmomi::VIM::VirtualMachine, dc=nil
+    propSpecs = {
+      :entity => self, :uuid => uuid, :instanceUuid => false,
+      :vmSearch => type == RbVmomi::VIM::VirtualMachine
+    }
+    propSpecs[:datacenter] = dc if dc
+    x = _connection.searchIndex.FindByUuid(propSpecs)
+    x if x.is_a? type
+  end
+
+  # Retrieve a managed entity by inventory path.
+  # @param path [String] A path of the form "My Folder/My Datacenter/vm/Discovered VM/VM1"
+  # @return [VIM::ManagedEntity]
+  def findByInventoryPath path
+    propSpecs = {
+      :entity => self, :inventoryPath => path
+    }
+    x = _connection.searchIndex.FindByInventoryPath(propSpecs)
+  end
+
+  # Alias to <tt>traverse path, type, true</tt>
+  # @see #traverse
+  def traverse! path, type=Object
+    traverse path, type, true
+  end
+
+  # Retrieve a descendant of this Folder.
+  # @param path [String] Path delimited by '/', or an array of path elements.
+  # @param type (see Folder#find)
+  # @param create [Boolean] If set, create folders that don't exist.
+  # @return (see Folder#find)
+  # @todo Move +create+ functionality into another method.
+  def traverse path, type=Object, create=false
+    if path.is_a? String
+      es = path.split('/').reject(&:empty?)
+    elsif path.is_a? Enumerable
+      es = path
+    else
+      fail "unexpected path class #{path.class}"
+    end
+    return self if es.empty?
+    final = es.pop
+
+    p = es.inject(self) do |f,e|
+      f.find(e, RbVmomi::VIM::Folder) || (create && f.CreateFolder(:name => e)) || return
+    end
+
+    if x = p.find(final, type)
+      x
+    elsif create and type == RbVmomi::VIM::Folder
+      p.CreateFolder(:name => final)
+    elsif create and type == RbVmomi::VIM::Datacenter
+      p.CreateDatacenter(:name => final)
+    else
+      nil
+    end
+  end
+
+  # Alias to +childEntity+.
+  def children
+    childEntity
+  end
+
+  # Efficiently retrieve properties from descendants of this folder.
+  #
+  # @param propSpecs [Hash] Specification of which properties to retrieve from
+  #                         which entities. Keys may be symbols, strings, or
+  #                         classes identifying ManagedEntity subtypes to be
+  #                         included in the results. Values are an array of
+  #                         property paths (strings) or the symbol :all.
+  #
+  # @return [Hash] Hash of ManagedObjects to properties.
+  def inventory_flat propSpecs={}
+    propSet = [{ :type => 'Folder', :pathSet => ['name', 'parent', 'childEntity'] }]
+    propSpecs.each do |k,v|
+      case k
+      when Class
+        fail "key must be a subclass of ManagedEntity" unless k < RbVmomi::VIM::ManagedEntity
+        k = k.wsdl_name
+      when Symbol, String
+        k = k.to_s
+      else
+        fail "invalid key"
+      end
+
+      h = { :type => k }
+      if v == :all
+        h[:all] = true
+      elsif v.is_a? Array
+        h[:pathSet] = v + %w(parent)
+      else
+        fail "value must be an array of property paths or :all"
+      end
+      propSet << h
+    end
+
+    filterSpec = RbVmomi::VIM.PropertyFilterSpec(
+      :objectSet => [
+        :obj => self,
+        :selectSet => [
+          RbVmomi::VIM.TraversalSpec(
+            :name => 'tsFolder',
+            :type => 'Folder',
+            :path => 'childEntity',
+            :skip => false,
+            :selectSet => [
+              RbVmomi::VIM.SelectionSpec(:name => 'tsFolder')
+            ]
+          )
+        ]
+      ],
+      :propSet => propSet
+    )
+
+    result = _connection.propertyCollector.RetrieveProperties(:specSet => [filterSpec])
+    {}.tap do |h|
+      result.each { |r| h[r.obj] = r }
+    end
+  end
+
+  # Efficiently retrieve properties from descendants of this folder.
+  #
+  # @param propSpecs [Hash] Specification of which properties to retrieve from
+  #                         which entities. Keys may be symbols, strings, or
+  #                         classes identifying ManagedEntity subtypes to be
+  #                         included in the results. Values are an array of
+  #                         property paths (strings) or the symbol :all.
+  #
+  # @return [Hash] Tree of inventory items. Each node is a hash from
+  #                VIM::ObjectContent to children.
+  def inventory_tree propSpecs={}
+    inv = inventory_flat propSpecs
+    children = inv.values.group_by { |v| v['parent'] }
+    rec = lambda { |parent| Hash[(children[parent]||[]).map { |x| [x, rec[x.obj]] }] }
+    rec[self]
+  end
+
+  # Efficiently retrieve properties from descendants of this folder.
+  #
+  # @param propSpecs [Hash] Specification of which properties to retrieve from
+  #                         which entities. Keys may be symbols, strings, or
+  #                         classes identifying ManagedEntity subtypes to be
+  #                         included in the results. Values are an array of
+  #                         property paths (strings) or the symbol :all.
+  #
+  # @return [Hash] Tree of inventory items. Folders are hashes from child name
+  #                to child result. Objects are hashes from property path to
+  #                value.
+  #
+  # @deprecated
+  def inventory propSpecs={}
+    inv = inventory_flat propSpecs
+    tree = { self => {} }
+    inv.each do |obj,x|
+      next if obj == self
+      h = Hash[x.propSet.map { |y| [y.name, y.val] }]
+      tree[h['parent']][h['name']] = [obj, h]
+      tree[obj] = {} if obj.is_a? RbVmomi::VIM::Folder
+    end
+    tree
+  end
+end