rbvmomi 1.4.0 → 1.5.0

data/lib/rbvmomi/deserialization.rb

@@ -0,0 +1,235 @@
+# Copyright (c) 2011 VMware, Inc.  All Rights Reserved.
+require 'time'
+
+module RbVmomi
+
+class NewDeserializer
+  NS_XSI = 'http://www.w3.org/2001/XMLSchema-instance'
+
+  DEMANGLED_ARRAY_TYPES = {
+    'AnyType' => 'xsd:anyType',
+    'DateTime' => 'xsd:dateTime',
+  }
+  %w(Boolean String Byte Short Int Long Float Double).each do |x|
+    DEMANGLED_ARRAY_TYPES[x] = "xsd:#{x.downcase}"
+  end
+
+  BUILTIN_TYPE_ACTIONS = {
+    'xsd:string' => :string,
+    'xsd:boolean' => :boolean,
+    'xsd:byte' => :int,
+    'xsd:short' => :int,
+    'xsd:int' => :int,
+    'xsd:long' => :int,
+    'xsd:float' => :float,
+    'xsd:dateTime' => :date,
+    'PropertyPath' => :string,
+    'MethodName' => :string,
+    'TypeName' => :string,
+    'xsd:base64Binary' => :binary,
+    'KeyValue' => :keyvalue,
+  }
+
+  BUILTIN_TYPE_ACTIONS.dup.each do |k,v|
+    if k =~ /^xsd:/
+      BUILTIN_TYPE_ACTIONS[$'] = v
+    end
+  end
+
+  def initialize conn
+    @conn = conn
+    @loader = conn.class.loader
+  end
+
+  def deserialize node, type=nil
+    type_attr = node['type']
+    type = type_attr if type_attr
+
+    if action = BUILTIN_TYPE_ACTIONS[type]
+      case action
+      when :string
+        node.content
+      when :boolean
+        node.content == '1' || node.content == 'true'
+      when :int
+        node.content.to_i
+      when :float
+        node.content.to_f
+      when :date
+        leaf_date node
+      when :binary
+        leaf_binary node
+      when :keyvalue
+        leaf_keyvalue node
+      else fail
+      end
+    else
+      if type =~ /^ArrayOf/
+        type = DEMANGLED_ARRAY_TYPES[$'] || $'
+        return node.children.select(&:element?).map { |c| deserialize c, type }
+      end
+
+      klass = @loader.get(type) or fail "no such type #{type}"
+      case klass.kind
+      when :data
+        traverse_data node, klass
+      when :enum
+        node.content
+      when :managed
+        leaf_managed node, klass
+      else fail
+      end
+    end
+  end
+
+  def traverse_data node, klass
+    obj = klass.new nil
+    props = obj.props
+    children = node.children.select(&:element?)
+    n = children.size
+    i = 0
+
+    klass.full_props_desc.each do |desc|
+      name = desc['name']
+      child_type = desc['wsdl_type']
+
+      # Ignore unknown fields
+      while child = children[i] and not klass.full_props_set.member? child.name
+        i += 1
+      end
+
+      if desc['is-array']
+        a = []
+        while ((child = children[i]) && (child.name == name))
+          child = children[i]
+          a << deserialize(child, child_type)
+          i += 1
+        end
+        props[name.to_sym] = a
+      elsif ((child = children[i]) && (child.name == name))
+        props[name.to_sym] = deserialize(child, child_type)
+        i += 1
+      end
+    end
+
+    obj
+  end
+
+  def leaf_managed node, klass
+    type_attr = node['type']
+    klass = @loader.get(type_attr) if type_attr
+    klass.new(@conn, node.content)
+  end
+
+  def leaf_date node
+    Time.parse node.content
+  end
+
+  def leaf_binary node
+    node.content.unpack('m')[0]
+  end
+
+  # XXX does the value need to be deserialized?
+  def leaf_keyvalue node
+    h = {}
+    node.children.each do |child|
+      next unless child.element?
+      h[child.name] = child.content
+    end
+    [h['key'], h['value']]
+  end 
+end
+
+class OldDeserializer
+  NS_XSI = 'http://www.w3.org/2001/XMLSchema-instance'
+
+  def initialize conn
+    @conn = conn
+  end
+
+  def deserialize xml, typename=nil
+    if IS_JRUBY
+      type_attr = xml.attribute_nodes.find { |a| a.name == 'type' &&
+                                                 a.namespace &&
+                                                 a.namespace.prefix == 'xsi' }
+    else
+      type_attr = xml.attribute_with_ns('type', NS_XSI)
+    end
+    typename = (type_attr || typename).to_s
+
+    if typename =~ /^ArrayOf/
+      typename = demangle_array_type $'
+      return xml.children.select(&:element?).map { |c| deserialize c, typename }
+    end
+
+    t = @conn.type typename
+    if t <= BasicTypes::DataObject
+      props_desc = t.full_props_desc
+      h = {}
+      props_desc.select { |d| d['is-array'] }.each { |d| h[d['name'].to_sym] = [] }
+      xml.children.each do |c|
+        next unless c.element?
+        field = c.name.to_sym
+        d = t.find_prop_desc(field.to_s) or next
+        o = deserialize c, d['wsdl_type']
+        if h[field].is_a? Array
+          h[field] << o
+        else
+          h[field] = o
+        end
+      end
+      t.new h
+    elsif t == BasicTypes::ManagedObjectReference
+      @conn.type(xml['type']).new @conn, xml.text
+    elsif t <= BasicTypes::ManagedObject
+      @conn.type(xml['type'] || t.wsdl_name).new @conn, xml.text
+    elsif t <= BasicTypes::Enum
+      xml.text
+    elsif t <= BasicTypes::KeyValue
+      h = {}
+      xml.children.each do |c|
+        next unless c.element?
+        h[c.name] = c.text
+      end
+      [h['key'], h['value']]
+    elsif t <= String
+      xml.text
+    elsif t <= Symbol
+      xml.text.to_sym
+    elsif t <= Integer
+      xml.text.to_i
+    elsif t <= Float
+      xml.text.to_f
+    elsif t <= Time
+      Time.parse xml.text
+    elsif t == BasicTypes::Boolean
+      xml.text == 'true' || xml.text == '1'
+    elsif t == BasicTypes::Binary
+      xml.text.unpack('m')[0]
+    elsif t == BasicTypes::AnyType
+      fail "attempted to deserialize an AnyType"
+    else fail "unexpected type #{t.inspect} (#{t.ancestors * '/'})"
+    end
+  rescue
+    $stderr.puts "#{$!.class} while deserializing #{xml.name} (#{typename}):"
+    $stderr.puts xml.to_s
+    raise
+  end
+
+  def demangle_array_type x
+    case x
+    when 'AnyType' then 'anyType'
+    when 'DateTime' then 'dateTime'
+    when 'Boolean', 'String', 'Byte', 'Short', 'Int', 'Long', 'Float', 'Double' then x.downcase
+    else x
+    end
+  end
+end
+
+if ENV['RBVMOMI_NEW_DESERIALIZER'] == '1'
+  Deserializer = NewDeserializer
+else
+  Deserializer = OldDeserializer
+end
+
+end

data/lib/rbvmomi/trivial_soap.rb

@@ -20,6 +20,10 @@ class RbVmomi::TrivialSoap
     restart_http
   end
 
+  def host
+    @opts[:host]
+  end
+
   def close
     @http.finish rescue IOError
   end
@@ -65,10 +69,9 @@ class RbVmomi::TrivialSoap
     xml
   end
 
-  def request action, &b
+  def request action, body
     headers = { 'content-type' => 'text/xml; charset=utf-8', 'SOAPAction' => action }
     headers['cookie'] = @cookie if @cookie
-    body = soap_envelope(&b).target!
 
     if @debug
       $stderr.puts "Request:"
@@ -101,6 +104,6 @@ class RbVmomi::TrivialSoap
       $stderr.puts
     end
 
-    nk.xpath('//soapenv:Body/*').select(&:element?).first
+    [nk.xpath('//soapenv:Body/*').select(&:element?).first, response.body.size]
   end
 end

data/lib/rbvmomi/type_loader.rb

@@ -5,40 +5,41 @@ require 'monitor'
 module RbVmomi
 
 class TypeLoader
-  def initialize target, fn
-    @target = target
+  def initialize fn, extension_dirs, namespace
+    @extension_dirs = extension_dirs
+    @namespace = namespace
     @lock = Monitor.new
     @db = {}
     @id2wsdl = {}
+    @loaded = {}
     add_types Hash[BasicTypes::BUILTIN.map { |k| [k,nil] }]
     vmodl_database = File.open(fn, 'r') { |io| Marshal.load io }
     vmodl_database.reject! { |k,v| k =~ /^_/ }
     add_types vmodl_database
+    preload
   end
 
-  def init
-    @target.constants.select { |x| has_type? x.to_s }.each { |x| load_type x.to_s }
-    BasicTypes::BUILTIN.each do |x|
-      @target.const_set x, BasicTypes.const_get(x)
-      load_extension x
-    end
-    Object.constants.map(&:to_s).select { |x| has_type? x }.each do |x|
-      load_type x
-    end
+  def preload
+    names = (@namespace.constants + Object.constants).map(&:to_s).uniq.
+                                                      select { |x| has? x }
+    names.each { |x| get(x) }
   end
 
-  def has_type? name
+  def has? name
     fail unless name.is_a? String
-    @db.member? name
+    @db.member?(name) or BasicTypes::BUILTIN.member?(name)
   end
 
-  def load_type name
+  def get name
     fail unless name.is_a? String
+    return @loaded[name] if @loaded.member? name
     @lock.synchronize do
-      @target.const_set name, make_type(name)
+      return @loaded[name] if @loaded.member? name
+      klass = make_type(name)
+      @namespace.const_set name, klass
       load_extension name
+      @loaded[name] = klass
     end
-    nil
   end
 
   def add_types types
@@ -54,15 +55,14 @@ class TypeLoader
   private
 
   def load_extension name
-    dirs = @target.extension_dirs
-    dirs.map { |x| File.join(x, "#{name}.rb") }.
-         select { |x| File.exists? x }.
-         each { |x| load x }
+    @extension_dirs.map { |x| File.join(x, "#{name}.rb") }.
+                    select { |x| File.exists? x }.
+                    each { |x| load x }
   end
 
   def make_type name
     name = name.to_s
-    fail if BasicTypes::BUILTIN.member? name
+    return BasicTypes.const_get(name) if BasicTypes::BUILTIN.member? name
     desc = @db[name] or fail "unknown VMODL type #{name}"
     case desc['kind']
     when 'data' then make_data_type name, desc
@@ -73,14 +73,14 @@ class TypeLoader
   end
 
   def make_data_type name, desc
-    superclass = @target.const_get desc['wsdl_base']
+    superclass = get desc['wsdl_base']
     Class.new(superclass).tap do |klass|
       klass.init name, desc['props']
     end
   end
 
   def make_managed_type name, desc
-    superclass = @target.const_get desc['wsdl_base']
+    superclass = get desc['wsdl_base']
     Class.new(superclass).tap do |klass|
       klass.init name, desc['props'], desc['methods']
     end

data/lib/rbvmomi/vim.rb

@@ -41,25 +41,10 @@ class VIM < Connection
   end
 
   def close
-    VIM::SessionManager(self, 'SessionManager').Logout
+    VIM::SessionManager(self, 'SessionManager').Logout rescue RbVmomi::Fault
+    self.cookie = nil
     super
   end
-
-  def cookie= cookie
-    super
-    ObjectSpace.undefine_finalizer self
-    ObjectSpace.define_finalizer(self, self.class.finalizer(cookie,@opts))
-  end
-
-  def self.finalizer cookie, opts
-    proc do |object_id|
-      new(opts).tap do |vim|
-        vim.instance_variable_set :@cookie, cookie
-        vim.close
-      end
-      nil
-    end
-  end
   
   def rev= x
     super

data/lib/rbvmomi/vim/ComputeResource.rb

@@ -29,7 +29,7 @@ class RbVmomi::VIM::ComputeResource
       }]
     )
 
-    result = @soap.propertyCollector.RetrieveProperties(:specSet => [filterSpec])
+    result = _connection.propertyCollector.RetrieveProperties(:specSet => [filterSpec])
 
     stats = {
       :totalCPU => 0,

data/lib/rbvmomi/vim/Datastore.rb

@@ -8,8 +8,8 @@ class RbVmomi::VIM::Datastore
   # @param path [String] Path on the datastore.
   def exists? path
     req = Net::HTTP::Head.new mkuripath(path)
-    req.initialize_http_header 'cookie' => @soap.cookie
-    resp = @soap.http.request req
+    req.initialize_http_header 'cookie' => _connection.cookie
+    resp = _connection.http.request req
     case resp
     when Net::HTTPSuccess
       true
@@ -25,10 +25,10 @@ class RbVmomi::VIM::Datastore
   # @param local_path [String] Destination path on the local machine.
   # @return [void]
   def download remote_path, local_path
-    url = "http#{@soap.http.use_ssl? ? 's' : ''}://#{@soap.http.address}:#{@soap.http.port}#{mkuripath(remote_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", @soap.cookie,
+                "-b", _connection.cookie,
                 url,
                 :out => '/dev/null'
     Process.waitpid(pid, 0)
@@ -40,10 +40,10 @@ class RbVmomi::VIM::Datastore
   # @param local_path [String] Source path on the local machine.
   # @return [void]
   def upload remote_path, local_path
-    url = "http#{@soap.http.use_ssl? ? 's' : ''}://#{@soap.http.address}:#{@soap.http.port}#{mkuripath(remote_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", @soap.cookie,
+                "-b", _connection.cookie,
                 url,
                 :out => '/dev/null'
     Process.waitpid(pid, 0)

data/lib/rbvmomi/vim/Folder.rb

@@ -4,7 +4,7 @@ class RbVmomi::VIM::Folder
   # @param type [Class] Return nil unless the found entity <tt>is_a? type</tt>.
   # @return [VIM::ManagedEntity]
   def find name, type=Object
-    x = @soap.searchIndex.FindChild(:entity => self, :name => name)
+    x = _connection.searchIndex.FindChild(:entity => self, :name => name)
     x if x.is_a? type
   end
 
@@ -19,7 +19,7 @@ class RbVmomi::VIM::Folder
       :vmSearch => type == RbVmomi::VIM::VirtualMachine
     }
     propSpecs[:datacenter] = dc if dc
-    x = @soap.searchIndex.FindByDnsName(propSpecs)
+    x = _connection.searchIndex.FindByDnsName(propSpecs)
     x if x.is_a? type
   end
 
@@ -34,7 +34,7 @@ class RbVmomi::VIM::Folder
       :vmSearch => type == RbVmomi::VIM::VirtualMachine
     }
     propSpecs[:datacenter] = dc if dc
-    x = @soap.searchIndex.FindByIp(propSpecs)
+    x = _connection.searchIndex.FindByIp(propSpecs)
     x if x.is_a? type
   end
 
@@ -49,7 +49,7 @@ class RbVmomi::VIM::Folder
       :vmSearch => type == RbVmomi::VIM::VirtualMachine
     }
     propSpecs[:datacenter] = dc if dc
-    x = @soap.searchIndex.FindByUuid(propSpecs)
+    x = _connection.searchIndex.FindByUuid(propSpecs)
     x if x.is_a? type
   end
 
@@ -104,21 +104,18 @@ class RbVmomi::VIM::Folder
   #                         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.
-  #
-  # @todo Return ObjectContent instead of the leaf hash.
-  def inventory propSpecs={}
-    propSet = [{ :type => 'Folder', :pathSet => ['name', 'parent'] }]
+  # @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 RbVmomi::VIM::ManagedEntity
+      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 "key must be a ManagedEntity"
+        fail "invalid key"
       end
 
       h = { :type => k }
@@ -150,11 +147,46 @@ class RbVmomi::VIM::Folder
       :propSet => propSet
     )
 
-    result = @soap.propertyCollector.RetrieveProperties(:specSet => [filterSpec])
+    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 => {} }
-    result.each do |x|
-      obj = x.obj
+    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]