rbvmomi 1.3.0 → 1.4.0

data/VERSION

@@ -1 +1 @@
-1.3.0
+1.4.0

data/bin/rbvmomish

@@ -17,6 +17,7 @@ Usage:
        rbvmomish [options]
 
 Predefined methods:
+conn: Returns the VIM connection
 si: Returns the ServiceInstance
 help: Displays this text.
 
@@ -92,6 +93,10 @@ def cookie str
   $vim.cookie = str
 end
 
+def conn
+  $vim
+end
+
 def si
   $vim.serviceInstance
 end

data/devel/merge-internal-vmodl.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# These types are not public and so may change between releases. Do not
+# use them directly.
+
+public_vmodl_filename = ARGV[0] or abort "public vmodl filename required"
+internal_vmodl_filename = ARGV[1] or abort "internal vmodl filename required"
+output_vmodl_filename = ARGV[2] or abort "output vmodl filename required"
+
+TYPES = %w(
+DynamicTypeEnumTypeInfo
+DynamicTypeMgrAllTypeInfo
+DynamicTypeMgrAnnotation
+DynamicTypeMgrDataTypeInfo
+DynamicTypeMgrFilterSpec
+DynamicTypeMgrManagedTypeInfo
+DynamicTypeMgrMethodTypeInfo
+DynamicTypeMgrMethodTypeInfoAnnotationType
+DynamicTypeMgrMoFilterSpec
+DynamicTypeMgrMoInstance
+DynamicTypeMgrParamTypeInfo
+DynamicTypeMgrParamTypeInfoAnnotationType
+DynamicTypeMgrPropertyTypeInfo
+DynamicTypeMgrPropertyTypeInfoAnnotationType
+DynamicTypeMgrTypeFilterSpec
+InternalDynamicTypeManager
+ReflectManagedMethodExecuter
+ReflectManagedMethodExecuterSoapArgument
+ReflectManagedMethodExecuterSoapFault
+ReflectManagedMethodExecuterSoapResult
+)
+
+METHODS = %w(
+HostSystem.RetrieveDynamicTypeManager
+HostSystem.RetrieveManagedMethodExecuter
+)
+
+public_vmodl = File.open(public_vmodl_filename, 'r') { |io| Marshal.load io }
+internal_vmodl = File.open(internal_vmodl_filename, 'r') { |io| Marshal.load io }
+
+TYPES.each do |k|
+  puts "Merging in #{k}"
+  fail unless internal_vmodl.member? k
+  public_vmodl[k] = internal_vmodl[k]
+end
+
+METHODS.each do |x|
+  puts "Merging in #{x}"
+  type, method = x.split '.'
+  public_vmodl[type]['methods'][method] = internal_vmodl[type]['methods'][method] or fail
+end
+
+File.open(output_vmodl_filename, 'w') { |io| Marshal.dump public_vmodl, io }

data/lib/rbvmomi/basic_types.rb

@@ -4,7 +4,7 @@ require 'pp'
 module RbVmomi
 module BasicTypes
 
-BUILTIN = %w(ManagedObject DataObject TypeName PropertyPath ManagedObjectReference MethodName MethodFault LocalizedMethodFault)
+BUILTIN = %w(ManagedObject DataObject TypeName PropertyPath ManagedObjectReference MethodName MethodFault LocalizedMethodFault KeyValue)
 
 class Base
   class << self
@@ -36,9 +36,8 @@ class ObjectWithProperties < Base
       end
     end
 
-    # XXX cache
     def full_props_desc
-      (self == ObjectWithProperties ? [] : superclass.full_props_desc) + props_desc
+      @full_props_desc ||= (self == ObjectWithProperties ? [] : superclass.full_props_desc) + props_desc
     end
 
     def find_prop_desc name
@@ -121,6 +120,8 @@ class DataObject < ObjectWithProperties
     keys.all? { |k| props[k] == o.props[k] }
   end
 
+  alias eql? ==
+
   def hash
     props.hash
   end
@@ -318,5 +319,23 @@ class ::Float
   def self.wsdl_name; 'xsd:float' end
 end
 
+class KeyValue
+  def self.wsdl_name; 'xsd:float' end
+  attr_accessor :key, :value
+
+  def initialize k, v
+    @key = k
+    @value = v
+  end
+
+  def [] i
+    if i == 0 then @key
+    elsif i == 1 then @value
+    else fail "invalid index #{i.inspect}"
+    end
+  end
+end
+
+
 end
 end

data/lib/rbvmomi/connection.rb

@@ -118,6 +118,13 @@ class Connection < TrivialSoap
       type(xml['type'] || t.wsdl_name).new self, 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
@@ -136,6 +143,10 @@ class Connection < TrivialSoap
       fail "attempted to deserialize an AnyType"
     else fail "unexpected type #{t.inspect}"
     end
+  rescue
+    $stderr.puts "#{$!.class} while deserializing #{xml.name} (#{typename}):"
+    $stderr.puts xml.to_s
+    raise
   end
 
   # hic sunt dracones
@@ -143,10 +154,19 @@ class Connection < TrivialSoap
     expected = type(type)
     fail "expected array, got #{o.class.wsdl_name}" if is_array and not o.is_a? Array
     case o
-    when Array
-      fail "expected #{expected.wsdl_name}, got array" unless is_array
-      o.each do |e|
-        obj2xml xml, name, expected.wsdl_name, false, e, attrs
+    when Array, BasicTypes::KeyValue
+      if o.is_a? BasicTypes::KeyValue and expected != BasicTypes::KeyValue
+        fail "expected #{expected.wsdl_name}, got KeyValue"
+      elsif expected == BasicTypes::KeyValue
+        xml.tag! name, attrs do
+          xml.tag! 'key', o[0]
+          xml.tag! 'value', o[1]
+        end
+      else
+        fail "expected #{expected.wsdl_name}, got array" unless is_array
+        o.each do |e|
+          obj2xml xml, name, expected.wsdl_name, false, e, attrs
+        end
       end
     when BasicTypes::ManagedObject
       fail "expected #{expected.wsdl_name}, got #{o.class.wsdl_name} for field #{name.inspect}" if expected and not expected >= o.class
@@ -168,7 +188,7 @@ class Connection < TrivialSoap
       fail "expected #{expected.wsdl_name}, got a hash" unless expected <= BasicTypes::DataObject
       obj2xml xml, name, type, false, expected.new(o), attrs
     when true, false
-      fail "expected #{expected.wsdl_name}, got a boolean" unless expected == BasicTypes::Boolean
+      fail "expected #{expected.wsdl_name}, got a boolean" unless [BasicTypes::Boolean, BasicTypes::AnyType].member? expected
       attrs['xsi:type'] = 'xsd:boolean' if expected == BasicTypes::AnyType
       xml.tag! name, (o ? '1' : '0'), attrs
     when Symbol, String
@@ -191,6 +211,10 @@ class Connection < TrivialSoap
     else fail "unexpected object class #{o.class}"
     end
     xml
+  rescue
+    $stderr.puts "#{$!.class} while serializing #{name} (#{type}):"
+    PP.pp o, $stderr
+    raise
   end
 
   def self.type name
@@ -204,6 +228,7 @@ class Connection < TrivialSoap
     when :float, :double then Float
     when :dateTime then Time
     when :base64Binary then BasicTypes::Binary
+    when :KeyValue then BasicTypes::KeyValue
     else
       if @loader.has_type? name
         const_get(name)

data/lib/rbvmomi/type_loader.rb

@@ -4,29 +4,19 @@ require 'monitor'
 
 module RbVmomi
 
-class TypeStore
-  def initialize fn
-    File.open(fn, 'r') do |io|
-      @db = Marshal.load io
-    end
-  end
-
-  def [](k)
-    @db[k]
-  end
-end
-
 class TypeLoader
-  attr_reader :typenames
-
   def initialize target, fn
     @target = target
-    @db = TypeStore.new fn
     @lock = Monitor.new
+    @db = {}
+    @id2wsdl = {}
+    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
   end
 
   def init
-    @typenames = Set.new(@db['_typenames'] + BasicTypes::BUILTIN)
     @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)
@@ -39,7 +29,7 @@ class TypeLoader
 
   def has_type? name
     fail unless name.is_a? String
-    @typenames.member? name
+    @db.member? name
   end
 
   def load_type name
@@ -51,6 +41,16 @@ class TypeLoader
     nil
   end
 
+  def add_types types
+    @lock.synchronize do
+      @db.merge! types
+    end
+  end
+
+  def typenames
+    @db.keys
+  end
+
   private
 
   def load_extension name

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/HostSystem.rb

@@ -0,0 +1,162 @@
+module RbVmomi
+
+class VIM::HostSystem
+  def esxcli
+    @cached_esxcli ||= VIM::EsxcliNamespace.root(self)
+  end
+
+  def dtm
+    @cached_dtm ||= RetrieveDynamicTypeManager()
+  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

data/lib/rbvmomi/vim/ReflectManagedMethodExecuter.rb

@@ -0,0 +1,26 @@
+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.xml2obj 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)
+    _connection.xml2obj Nokogiri(result.response).root, nil
+  end
+end
+
+end
+

data/test/test_deserialization.rb

@@ -282,4 +282,14 @@ end
 </val>
     EOS
   end
+
+  def test_keyvalue
+    obj = ['a', 'b']
+    check <<-EOS, obj, 'KeyValue'
+<root>
+  <key>a</key>
+  <value>b</value>
+</root>
+    EOS
+  end
 end

data/test/test_serialization.rb

@@ -208,4 +208,22 @@ class SerializationTest < Test::Unit::TestCase
     EOS
 
   end
+
+  def test_keyvalue
+    obj = RbVmomi::BasicTypes::KeyValue.new('a', 'b')
+    check <<-EOS, obj, 'KeyValue', false
+<root>
+  <key>a</key>
+  <value>b</value>
+</root>
+    EOS
+
+    obj = ['a', 'b']
+    check <<-EOS, obj, 'KeyValue', false
+<root>
+  <key>a</key>
+  <value>b</value>
+</root>
+    EOS
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: rbvmomi
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors: 
 - Rich Lane
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-02 00:00:00 -07:00
+date: 2011-10-19 00:00:00 -07:00
 default_executable: rbvmomish
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -54,7 +54,6 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.html
 - README.rdoc
 files: 
 - .yardopts
@@ -65,6 +64,7 @@ files:
 - bin/rbvmomish
 - devel/analyze-vim-declarations.rb
 - devel/analyze-xml.rb
+- devel/merge-internal-vmodl.rb
 - examples/annotate.rb
 - examples/clone_vm.rb
 - examples/create_vm-1.9.rb
@@ -91,13 +91,18 @@ files:
 - lib/rbvmomi/vim/ComputeResource.rb
 - lib/rbvmomi/vim/Datacenter.rb
 - lib/rbvmomi/vim/Datastore.rb
+- lib/rbvmomi/vim/DynamicTypeMgrAllTypeInfo.rb
+- lib/rbvmomi/vim/DynamicTypeMgrDataTypeInfo.rb
+- lib/rbvmomi/vim/DynamicTypeMgrManagedTypeInfo.rb
 - lib/rbvmomi/vim/Folder.rb
+- lib/rbvmomi/vim/HostSystem.rb
 - lib/rbvmomi/vim/ManagedEntity.rb
 - lib/rbvmomi/vim/ManagedObject.rb
 - lib/rbvmomi/vim/ObjectContent.rb
 - lib/rbvmomi/vim/ObjectUpdate.rb
 - lib/rbvmomi/vim/OvfManager.rb
 - lib/rbvmomi/vim/PropertyCollector.rb
+- lib/rbvmomi/vim/ReflectManagedMethodExecuter.rb
 - lib/rbvmomi/vim/ResourcePool.rb
 - lib/rbvmomi/vim/ServiceInstance.rb
 - lib/rbvmomi/vim/Task.rb
@@ -109,7 +114,6 @@ files:
 - test/test_parse_response.rb
 - test/test_serialization.rb
 - vmodl.db
-- README.html
 has_rdoc: true
 homepage: https://github.com/rlane/rbvmomi
 licenses: []

data/README.html

@@ -1,76 +0,0 @@
-<h1>RbVmomi</h1>
-
-<h2>Introduction</h2>
-
-<p>RbVmomi is a Ruby interface to the vSphere API. Like the Perl and Java SDKs,
-you can use it to manage ESX and VirtualCenter servers. The current release
-supports the vSphere 4.1 API.</p>
-
-<h2>Usage</h2>
-
-<p>A simple example of turning on a VM:</p>
-
-<pre><code>require 'rbvmomi'
-conn = RbVmomi.connect host: 'foo', user: 'bar', password: 'baz'
-dc = conn.serviceInstance.find_datacenter("mydatacenter") or fail "datacenter not found"
-vm = dc.find_vm("myvm") or fail "VM not found"
-vm.PowerOn_Task.wait_for_completion
-</code></pre>
-
-<p>This code uses several RbVmomi extensions to the VI API for concision. The
-expanded snippet below uses only standard API calls and should be familiar to
-users of the Java SDK:</p>
-
-<pre><code>require 'rbvmomi'
-conn = RbVmomi.connect host: 'foo', user: 'bar', password: 'baz'
-rootFolder = conn.serviceInstance.content.rootFolder
-dc = rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).find { |x| x.name == "mydatacenter" } or fail "datacenter not found"
-vm = dc.vmFolder.childEntity.grep(RbVmomi::VIM::VirtualMachine).find { |x| x.name == "myvm" } or fail "VM not found"
-task = vm.PowerOn_Task
-filter = conn.propertyCollector.CreateFilter(
-  spec: {
-    propSet: [{ type =&gt; 'Task', all: false, pathSet: ['info.state']}],
-    objectSet: [{ obj: task }]
-  },
-  partialUpdates: false
-)
-ver = ''
-while true
-  result = conn.propertyCollector.WaitForUpdates(version: ver)
-  ver = result.version
-  break if ['success', ['error'].member? task.info.state
-end
-filter.DestroyPropertyFilter
-raise task.info.error if task.info.state == 'error'
-</code></pre>
-
-<p>As you can see, the extensions RbVmomi adds can dramatically decrease the code
-needed to perform simple tasks while still letting you use the full power of
-the API when necessary. RbVmomi extensions are often more efficient than a
-naive implementation; for example, the find_vm method on VIM::Datacenter used
-in the first example uses the SearchIndex for fast lookups.</p>
-
-<p>A few important points:</p>
-
-<ul>
-<li>Ruby 1.9 is required.</li>
-<li>Properties are exposed as methods: vm.summary</li>
-<li>All class, method, parameter, and property names match the <a href="http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/index.html">official documentation</a>.</li>
-<li>Data object types can usually be inferred from context, so you may simply use a hash instead.</li>
-<li>Enumeration values are simply strings.</li>
-<li>Example code is included in the examples/ directory.</li>
-<li>A set of helper methods for Trollop is included to speed up development of
-command line apps. See the included examples for usage.</li>
-<li>This is a side project of a VMware developer and is entirely unsupported by VMware.</li>
-</ul>
-
-<p>Built-in extensions are in lib/rbvmomi/extensions.rb. You are encouraged to
-reopen VIM classes in your applications and add extensions of your own. If you
-write something generally useful please send it to me and I'll add it in. One
-important point about extensions is that since VIM classes are lazily loaded,
-you need to trigger this loading before you can reopen the class. Putting the
-class name on a line by itself before reopening is enough.</p>
-
-<h2>Development</h2>
-
-<p>Send patches to rlane@vmware.com.</p>