rbvmomi2 3.0.0

data/lib/rbvmomi/vim/Datacenter.rb

@@ -0,0 +1,25 @@
+# Copyright (c) 2011-2017 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+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
+
+  # Traverse the given inventory +path+ to find a Folder.
+  def find_folder path
+    vmFolder.traverse path, RbVmomi::VIM::Folder
+  end
+end
+

data/lib/rbvmomi/vim/Datastore.rb

@@ -0,0 +1,72 @@
+# Copyright (c) 2011-2017 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+# @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
+    datacenter_path_str = datacenter.path[1..-1].map{|elem| elem[1]}.join('/')
+    "/folder/#{URI.escape path}?dcPath=#{URI.escape datacenter_path_str }&dsName=#{URI.escape name}"
+  end
+end

data/lib/rbvmomi/vim/DynamicTypeMgrAllTypeInfo.rb

@@ -0,0 +1,78 @@
+# Copyright (c) 2011-2017 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+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,23 @@
+# Copyright (c) 2011-2017 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+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,54 @@
+# Copyright (c) 2011-2017 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+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' => (
+               if result.nil? then
+                 nil
+               else
+                 {
+                   '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
+end

data/lib/rbvmomi/vim/Folder.rb

@@ -0,0 +1,214 @@
+# Copyright (c) 2011-2017 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+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
+
+  # Finds a virtual machine or host by BIOS or instance UUID
+  #
+  # @param uuid [String] UUID to find
+  # @param type [Class] return nil unless found entity <tt>is_a?(type)</tt>
+  # @param dc [RbVmomi::VIM::Datacenter] restricts query to specified datacenter
+  #
+  # @return [VIM::ManagedEntity]
+  def findByUuid(uuid, type = RbVmomi::VIM::VirtualMachine, dc = nil, instance_uuid = false)
+    prop_specs = {
+      :entity       => self,
+      :instanceUuid => instance_uuid,
+      :uuid         => uuid,
+      :vmSearch     => type == RbVmomi::VIM::VirtualMachine
+    }
+    prop_specs[:datacenter] = dc if dc
+    x = _connection.searchIndex.FindByUuid(prop_specs)
+    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
+    }
+    _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

data/lib/rbvmomi/vim/HostSystem.rb

@@ -0,0 +1,177 @@
+# Copyright (c) 2011-2017 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+module RbVmomi
+
+class VIM::HostSystem
+  def esxcli
+    @cached_esxcli ||= VIM::EsxcliNamespace.root(self)
+  end
+
+  def dtm
+    @cached_dtm ||= begin
+        RetrieveDynamicTypeManager()
+      rescue VIM::MethodNotFound
+        if summary.config.product.version >= '4.1.0'
+          if summary.config.product.version < '5.0.0' and direct?
+            VIM::InternalDynamicTypeManager(_connection, 'ha-dynamic-type-manager')
+          else
+            raise "esxcli not supported through VC before 5.0.0"
+          end
+        else
+          raise "esxcli not supported before 4.1.0"
+        end
+      end
+  end
+
+  def dti
+    @cached_dti ||= dtm.DynamicTypeMgrQueryTypeInfo
+  end
+
+  def create_dynamic_managed_object inst
+    wsdlName = dti.managedTypeInfo.find { |x| x.name == inst.moType }.wsdlName
+    _connection.type(wsdlName).new(_connection, inst.id)
+  end
+
+  def cli_info_fetcher
+    # XXX there can be more than one
+    return @cached_cli_info_fetcher if @cached_cli_info_fetcher
+    inst = dtm.DynamicTypeMgrQueryMoInstances.find { |x| x.moType == 'vim.CLIInfo' }
+    @cached_cli_info_fetcher = create_dynamic_managed_object inst
+  end
+
+  def mme
+    @cached_mme ||= RetrieveManagedMethodExecuter()
+  end
+
+  def direct?
+    @ref == 'ha-host'
+  end
+end
+
+class VIM::EsxcliNamespace
+  ESXCLI_PREFIX = 'vim.EsxCLI.'
+
+  attr_reader :name, :parent, :host, :type, :instance, :type_info, :namespaces, :commands
+
+  def self.root host
+    type_hash = host.dti.toRbvmomiTypeHash
+    VIM.loader.add_types type_hash
+    all_instances = host.dtm.DynamicTypeMgrQueryMoInstances
+    instances = Hash[all_instances.select { |x| x.moType.start_with? ESXCLI_PREFIX }.
+                                   map { |x| [x.moType,x.id] }]
+    type_infos = Hash[host.dti.managedTypeInfo.map { |x| [x.name,x] }]
+    new('root', nil, host).tap do |root|
+      instances.each do |type,instance|
+        path = type.split('.')[2..-1]
+        ns = path.inject(root) { |b,v| b.namespaces[v] }
+        ns.realize type, instance, type_infos[type]
+      end
+    end
+  end
+
+  def initialize name, parent, host
+    @name = name
+    @parent = parent
+    @host = host
+    @type = nil
+    @instance = nil
+    @type_info = nil
+    @namespaces = Hash.new { |h,k| h[k] = self.class.new k, self, host }
+    @commands = {}
+    @cached_cli_info = nil
+  end
+
+  def realize type, instance, type_info
+    fail if @type or @instance
+    @type = type
+    @instance = instance
+    @type_info = type_info
+    @type_info.method.each do |method_type_info|
+      name = method_type_info.name
+      @commands[name] = VIM::EsxcliCommand.new self, method_type_info
+    end
+  end
+
+  def type_name
+    if @type then @type
+    elsif @parent then "#{@parent.type_name}.#{@name}"
+    else 'vim.EsxCLI'
+    end
+  end
+
+  def cli_info
+    @cached_cli_info ||=
+      if @host.direct?
+        @host.cli_info_fetcher.VimCLIInfoFetchCLIInfo(:typeName => type_name)
+      else
+        @host.mme.execute(@host.cli_info_fetcher._ref,
+                          "vim.CLIInfo.FetchCLIInfo", :typeName => type_name)
+      end
+  end
+
+  def obj
+    conn = @host._connection
+    conn.type(@type_info.wsdlName).new(conn, @instance)
+  end
+
+  def method_missing(name, *args)
+    name = name.to_s
+    if @namespaces.member? name and args.empty?
+      @namespaces[name]
+    elsif @commands.member? name
+      @commands[name].call(*args)
+    else
+      raise NoMethodError
+    end
+  end
+
+  def pretty_print q
+    q.text @name
+    q.text ' '
+    q.group 2 do
+      q.text '{'
+      q.breakable
+      items = (@namespaces.values+@commands.values).sort_by(&:name)
+      q.seplist items, nil, :each do |v|
+        if v.is_a? VIM::EsxcliNamespace
+          q.pp v
+        else
+          q.text v.name
+        end
+      end
+    end
+    q.breakable
+    q.text '}'
+  end
+end
+
+class VIM::EsxcliCommand
+  attr_reader :ns, :type_info, :cli_info
+
+  def initialize ns, type_info
+    @ns = ns
+    @type_info = type_info
+    @cached_cli_info = nil
+  end
+
+  def name
+    @type_info.name
+  end
+
+  def cli_info
+    @cached_cli_info ||= @ns.cli_info.method.find { |x| x.name == @type_info.name }
+  end
+
+  def call args={}
+    if @ns.host.direct?
+      @ns.obj._call @type_info.wsdlName, args
+    else
+      real_args = Set.new(type_info.paramTypeInfo.map(&:name))
+      args = args.reject { |k,v| !real_args.member?(k.to_s) }
+      @ns.host.mme.execute(@ns.obj._ref, "#{@ns.type_name}.#{@type_info.name}", args)
+    end
+  end
+end
+
+end