rbvmomi 1.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.swp
+pkg/
+*.gemspec
+vmodl

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 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.

data/README.md

@@ -0,0 +1,12 @@
+RbVmomi
+=======
+
+Introduction
+------------
+
+RbVmomi is a Ruby interface to the VI API.
+
+Contributing
+------------
+
+Send patches to rlane@vmware.com.

data/Rakefile

@@ -0,0 +1,20 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rbvmomi"
+    gem.summary = "Ruby interface to the VI API"
+    #gem.description = ""
+    gem.email = "rlane@vmware.com"
+    gem.homepage = "https://github.com/rlane/rbvmomi"
+    gem.authors = ["Rich Lane"]
+    gem.add_dependency 'nokogiri', '>= 1.4.1'
+    gem.add_dependency 'builder'
+    gem.add_dependency 'trollop'
+    gem.add_dependency 'tokyocabinet'
+    gem.required_ruby_version = '>= 1.9.1'
+    gem.files.include 'vmodl.tc'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+

data/VERSION

@@ -0,0 +1 @@
+1.0.1

data/devel/analyze-vim-declarations.rb

@@ -0,0 +1,206 @@
+#!/usr/bin/env ruby
+require 'nokogiri'
+require 'tokyocabinet'
+
+include TokyoCabinet
+
+# usage: analyze-vim-declarations.rb vim-declarations.xml foo-declarations.xml vmodl.db
+
+XML_FNS = ARGV[0...-1]
+abort "must specify path to vim-declarations.xml" if XML_FNS.empty?
+OUT_FN = ARGV[-1] or abort "must specify path to output database"
+
+XML_FNS.each do |x|
+  abort "XML file #{x} does not exist" unless File.exists? x
+end
+
+db = HDB.new
+if !db.open(OUT_FN, HDB::OWRITER | HDB::OCREAT | HDB::OTRUNC | HDB::TDEFLATE)
+  abort "VMODL db open error: #{db.errmsg(db.ecode)}"
+end
+
+TYPES = {}
+VERSIONS = []
+
+ID2NAME = Hash.new { |h,k| fail "unknown type-id #{k.inspect}" }
+
+ID2NAME.merge!({
+  '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',
+  'vmodl.DateTime' => 'xsd:dateTime',
+  'vmodl.Binary' => 'xsd:base64Binary',
+  'vmodl.Any' => 'xsd:anyType',
+  'void' => nil,
+})
+
+%w(DataObject ManagedObject MethodFault MethodName
+   PropertyPath RuntimeFault TypeName).each do |x|
+  ID2NAME['vmodl.' + x] = x
+end
+
+def handle_data_object node
+  if TYPES[node['name']]
+    puts "Type #{node['name']} already exists"
+    return
+  end
+
+  ID2NAME[node['type-id']] = node['name']
+  TYPES[node['name']] = {
+    'kind' => 'data',
+    'base-type-id' => node['base-type-id'],
+    'props' => node.children.select { |x| x.name == 'property' }.map do |property|
+      {
+        'name' => property['name'],
+        'type-id-ref' => property['type-id-ref'],
+        'is-optional' => property['is-optional'] ? true : false,
+        'is-array' => property['is-array'] ? true : false,
+        'version-id-ref' => property['version-id-ref'],
+      }
+    end
+  }
+end
+
+def handle_managed_object node
+  if TYPES[node['name']]
+    puts "Type #{node['name']} already exists"
+    return
+  end
+  ID2NAME[node['type-id']] = node['name']
+  TYPES[node['name']] = {
+    'kind' => 'managed',
+    'base-type-id' => node['base-type-id'],
+    'props' => node.children.select { |x| x.name == 'property' }.map do |property|
+      {
+        'name' => property['name'],
+        'type-id-ref' => property['type-id-ref'],
+        'is-optional' => property['is-optional'] ? true : false,
+        'is-array' => property['is-array'] ? true : false,
+        'version-id-ref' => property['version-id-ref'],
+      }
+    end,
+    'methods' => Hash[
+      node.children.select { |x| x.name == 'method' }.map do |method|
+        [method['is-task'] ? "#{method['name']}_Task" : method['name'],
+         {
+           'params' => method.children.select { |x| x.name == 'parameter' }.map do |param|
+             {
+               'name' => param['name'],
+               'type-id-ref' => param['type-id-ref'],
+               'is-array' => param['is-array'] ? true : false,
+               'is-optional' => param['is-optional'] ? true : false,
+               'version-id-ref' => param['version-id-ref'],
+             }
+           end,
+           'result' => {
+             'type-id-ref' => method['type-id-ref'],
+             'is-array' => method['is-array'] ? true : false,
+             'is-optional' => method['is-optional'] ? true : false,
+             'is-task' => method['is-task'] ? true : false,
+             'version-id-ref' => method['version-id-ref'],
+           }
+         }
+        ]
+      end
+    ]
+  }
+end
+
+def handle_enum node
+  if TYPES[node['name']]
+    puts "Type #{node['name']} already exists"
+    return
+  end
+
+  ID2NAME[node['type-id']] = node['name']
+  TYPES[node['name']] = {
+    'kind' => 'enum',
+    'values' => node.children.map { |child| child['name'] },
+  }
+end
+
+def handle_fault node
+  handle_data_object node
+end
+
+def handle_version x
+  attrs = %w(display-name name service-namespace type-id version-id vmodl-name)
+  h = Hash[attrs.map { |k| [k, x[k]] }]
+  h['compatible'] = x.children.select(&:element?).map { |y| y.text }
+  VERSIONS << h
+end
+
+XML_FNS.each do |fn|
+  puts "parsing #{fn} ..."
+  xml = Nokogiri.parse(File.read(fn), nil, nil, Nokogiri::XML::ParseOptions::NOBLANKS)
+  xml.root.at('enums').children.each { |x| handle_enum x }
+  xml.root.at('managed-objects').children.each { |x| handle_managed_object x }
+  xml.root.at('data-objects').children.each { |x| handle_data_object x }
+  xml.root.at('faults').children.each { |x| handle_fault x }
+  #xml.root.at('definitions').at('version-types').children.each { |x| handle_version x }
+end
+
+munge_fault = lambda { |x| true }
+
+TYPES.each 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'
+      munge_fault[x]
+    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'
+      munge_fault[x]
+    end
+    t['methods'].each do |mName,x|
+      if y = x['result']
+        y['wsdl_type'] = ID2NAME[y['type-id-ref']]
+        y.delete 'type-id-ref'
+        munge_fault[y]
+      end
+      x['params'].each do |r|
+        r['wsdl_type'] = ID2NAME[r['type-id-ref']]
+        r.delete 'type-id-ref'
+        munge_fault[r]
+      end
+    end
+  when 'enum'
+  else fail
+  end
+end
+
+TYPES.each do |k,t|
+  db[k] = Marshal.dump t
+end
+
+db['_typenames'] = Marshal.dump TYPES.keys
+db['_versions'] = Marshal.dump VERSIONS
+
+db.close
+
+if filename = ENV['VERSION_GRAPH']
+  File.open(filename, 'w') do |io|
+    io.puts "digraph versions\n{"
+    VERSIONS.each do |h|
+      io.puts "\"#{h['vmodl-name']}\" [label=\"#{h['vmodl-name']} (#{h['version-id']})\"]"
+      h['compatible'].each do |x|
+        x =~ /^interface / or fail x
+        io.puts "\"#{h['vmodl-name']}\" -> \"#{$'}\""
+      end
+    end
+    io.puts "}\n"
+  end
+end

data/devel/analyze-xml.rb

@@ -0,0 +1,46 @@
+require 'nokogiri'
+
+# removes line breaks and whitespace between xml nodes.
+def prepare_xml(xml)
+	xml = xml.gsub(/\n+/, "")
+	xml = xml.gsub(/(>)\s*(<)/, '\1\2')
+end
+
+def analyze_xml x, tree
+	subtree = (tree[x.name] ||= { :attributes => [], :min_occur => nil, :max_occur => nil })
+	attrs = x.attributes.keys.sort
+	subtree[:attributes] << attrs unless subtree[:attributes].member? attrs
+
+	child_occurs = Hash.new 0
+	x.children.select(&:element?).each do |c|
+		child_occurs[c.name] += 1
+		analyze_xml c, subtree
+	end
+
+	subtree.select { |k,v| k.is_a? String }.each do |k,v|
+		v[:min_occur] = [v[:min_occur], child_occurs[k]].compact.min
+		v[:max_occur] = [v[:max_occur], child_occurs[k]].compact.max
+	end
+end
+
+def print_tree tree, indent=0
+	tree.select { |k,v| k.is_a? String }.sort.each do |k,v|
+		attrs = v[:attributes] || []
+		min, max = v[:min_occur], v[:max_occur]
+		numsym = if min == 0 and max == 0 then fail
+		         elsif min == 0 and max == 1 then '?'
+						 elsif min == 0 then '*'
+						 elsif min == 1 and max == 1 then ''
+						 else '+'
+						 end
+		puts "#{'  '*indent}#{k}#{numsym}: #{attrs.sort.map { |a| "[#{a * ' '}]"} * ', '} {#{min},#{max}}"
+		print_tree v, (indent+1)
+	end
+end	
+
+tree = {}
+ARGV.each do |fn|
+	nk = Nokogiri(prepare_xml(File.read fn))
+	analyze_xml nk.root, tree
+end
+print_tree tree

data/lib/rbvmomi.rb

@@ -0,0 +1,283 @@
+# Copyright (c) 2010 VMware, Inc.  All Rights Reserved.
+require 'trivial_soap'
+require 'time'
+
+module RbVmomi
+
+class Boolean; def self.wsdl_name; 'xsd:boolean' end end
+class AnyType; def self.wsdl_name; 'xsd:anyType' end end
+class Binary; def self.wsdl_name; 'xsd:base64Binary' end end
+
+def self.type name
+  fail unless name and (name.is_a? String or name.is_a? Symbol)
+  name = $' if name.to_s =~ /^xsd:/
+  case name.to_sym
+  when :anyType then AnyType
+  when :boolean then Boolean
+  when :string then String
+  when :int, :long, :short, :byte then Integer
+  when :float, :double then Float
+  when :dateTime then Time
+  when :base64Binary then Binary
+  else
+    if VIM.has_type? name
+      VIM.type name
+    else
+      fail "no such type #{name.inspect}"
+    end
+  end
+end
+
+class DeserializationFailed < Exception; end
+
+class Soap < TrivialSoap
+  NS_XSI = 'http://www.w3.org/2001/XMLSchema-instance'
+
+  def initialize opts
+    @vim_debug = opts[:vim_debug]
+    super opts
+    @ns = @opts[:ns] or fail "no namespace specified"
+    if @opts[:rev]
+      @rev = @opts[:rev]
+    elsif @opts[:host]
+      @rev = '4.0'
+      @rev = serviceContent.about.apiVersion
+    else
+      fail "no revision specified"
+    end
+  end
+
+  def serviceInstance
+    VIM::ServiceInstance self, 'ServiceInstance'
+  end
+
+  def serviceContent
+    @serviceContent ||= serviceInstance.RetrieveServiceContent
+  end
+
+  %w(rootFolder propertyCollector searchIndex).map(&:to_sym).each do |s|
+    define_method(s) { serviceContent.send s }
+  end
+
+  alias root rootFolder
+
+  def emit_request xml, method, descs, this, params
+    xml.tag! method, :xmlns => @ns do
+      obj2xml xml, '_this', 'ManagedObject', false, this
+      descs.each do |d|
+        k = d['name'].to_sym
+        if params.member? k or params.member? k.to_s
+          v = params.member?(k) ? params[k] : params[k.to_s]
+          obj2xml xml, d['name'], d['wsdl_type'], d['is-array'], v
+        else
+          fail "missing required parameter #{d['name']}" unless d['is-optional']
+        end
+      end
+    end
+  end
+
+  def parse_response resp, desc
+    if resp.at('faultcode')
+      detail = resp.at('detail')
+      fault = detail && xml2obj(detail.children.first, 'MethodFault')
+      msg = resp.at('faultstring').text
+      if fault
+        raise RbVmomi.fault msg, fault
+      else
+        fail "#{resp.at('faultcode').text}: #{msg}"
+      end
+    else
+      if desc
+        type = desc['is-task'] ? 'Task' : desc['wsdl_type']
+        returnvals = resp.children.select(&:element?).map { |c| xml2obj c, type }
+        desc['is-array'] ? returnvals : returnvals.first
+      else
+        nil
+      end
+    end
+  end
+
+  def call method, desc, this, params
+    fail "this is not a managed object" unless this.is_a? RbVmomi::VIM::ManagedObject
+    fail "parameters must be passed as a hash" unless params.is_a? Hash
+    fail unless desc.is_a? Hash
+
+    if @vim_debug
+      $stderr.puts "Request #{method}:"
+      PP.pp({ _this: this }.merge(params), $stderr)
+      $stderr.puts
+      start_time = Time.now
+    end
+
+    resp = request "#{@ns}/#{@rev}" do |xml|
+      emit_request xml, method, desc['params'], this, params
+    end
+
+    ret = parse_response resp, desc['result']
+
+    if @vim_debug
+      end_time = Time.now
+      $stderr.puts "Response (in #{'%.3f' % (end_time - start_time)} s)"
+      PP.pp ret, $stderr
+      $stderr.puts
+    end
+
+    ret
+  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
+
+  def xml2obj xml, type
+    type = (xml.attribute_with_ns('type', NS_XSI) || type).to_s
+
+    if type =~ /^ArrayOf/
+      type = demangle_array_type $'
+      return xml.children.select(&:element?).map { |c| xml2obj c, type }
+    end
+
+    t = RbVmomi.type type
+    if t <= VIM::DataObject
+      #puts "deserializing data object #{t} from #{xml.name}"
+      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
+        #puts "field #{field.to_s}: #{t.find_prop_desc(field.to_s).inspect}"
+        d = t.find_prop_desc(field.to_s) or next
+        o = xml2obj c, d['wsdl_type']
+        if h[field].is_a? Array
+          h[field] << o
+        else
+          h[field] = o
+        end
+      end
+      t.new h
+    elsif t == VIM::ManagedObjectReference
+      RbVmomi.type(xml['type']).new self, xml.text
+    elsif t <= VIM::ManagedObject
+      RbVmomi.type(xml['type'] || t.wsdl_name).new self, xml.text
+    elsif t <= VIM::Enum
+      xml.text
+    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 == Boolean
+      xml.text == 'true' || xml.text == '1'
+    elsif t == Binary
+      xml.text.unpack('m')[0]
+    elsif t == AnyType
+      fail "attempted to deserialize an AnyType"
+    else fail "unexpected type #{t.inspect}"
+    end
+  end
+
+  def obj2xml xml, name, type, is_array, o, attrs={}
+    expected = RbVmomi.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
+      end
+    when VIM::ManagedObject
+      fail "expected #{expected.wsdl_name}, got #{o.class.wsdl_name} for field #{name.inspect}" if expected and not expected >= o.class
+      xml.tag! name, o._ref, :type => o.class.wsdl_name
+    when VIM::DataObject
+      fail "expected #{expected.wsdl_name}, got #{o.class.wsdl_name} for field #{name.inspect}" if expected and not expected >= o.class
+      xml.tag! name, attrs.merge("xsi:type" => o.class.wsdl_name) do
+        o.class.full_props_desc.each do |desc|
+          if o.props.member? desc['name'].to_sym
+            v = o.props[desc['name'].to_sym]
+            next if v.nil?
+            obj2xml xml, desc['name'], desc['wsdl_type'], desc['is-array'], v
+          end
+        end
+      end
+    when VIM::Enum
+      xml.tag! name, o.value.to_s, attrs
+    when Hash
+      fail "expected #{expected.wsdl_name}, got a hash" unless expected <= VIM::DataObject
+      obj2xml xml, name, type, false, expected.new(o), attrs
+    when true, false
+      fail "expected #{expected.wsdl_name}, got a boolean" unless expected == Boolean
+      attrs['xsi:type'] = 'xsd:boolean' if expected == AnyType
+      xml.tag! name, (o ? '1' : '0'), attrs
+    when Symbol, String
+      if expected == Binary
+        attrs['xsi:type'] = 'xsd:base64Binary' if expected == AnyType
+        xml.tag! name, [o].pack('m').chomp, attrs
+      else
+        attrs['xsi:type'] = 'xsd:string' if expected == AnyType
+        xml.tag! name, o.to_s, attrs
+      end
+    when Integer
+      attrs['xsi:type'] = 'xsd:long' if expected == AnyType
+      xml.tag! name, o.to_s, attrs
+    when Float
+      attrs['xsi:type'] = 'xsd:double' if expected == AnyType
+      xml.tag! name, o.to_s, attrs
+    when DateTime
+      attrs['xsi:type'] = 'xsd:dateTime' if expected == AnyType
+      xml.tag! name, o.to_s, attrs
+    else fail "unexpected object class #{o.class}"
+    end
+    xml
+  end
+end
+
+# XXX fault class hierarchy
+class Fault < StandardError
+  attr_reader :fault
+
+  def initialize msg, fault
+    super "#{fault.class.wsdl_name}: #{msg}"
+    @fault = fault
+  end
+end
+
+def self.fault msg, fault
+  Fault.new(msg, fault)
+end
+
+# host, port, ssl, user, password, path, debug
+def self.connect opts
+  fail unless opts.is_a? Hash
+  fail "host option required" unless opts[:host]
+  opts[:user] ||= 'root'
+  opts[:password] ||= ''
+  opts[:ssl] = true unless opts.member? :ssl
+  opts[:port] ||= (opts[:ssl] ? 443 : 80)
+  opts[:path] ||= '/sdk'
+  opts[:ns] ||= 'urn:vim25'
+  opts[:debug] = (!ENV['RBVMOMI_DEBUG'].empty? rescue false) unless opts.member? :debug
+  opts[:vim_debug] = (!ENV['RBVMOMI_VIM_DEBUG'].empty? rescue false) unless opts.member? :vim_debug
+
+  Soap.new(opts).tap do |vim|
+    vim.serviceContent.sessionManager.Login :userName => opts[:user], :password => opts[:password]
+  end
+end
+
+end
+
+require 'rbvmomi/types'
+vmodl_fn = ENV['VMODL'] || File.join(File.dirname(__FILE__), "../vmodl.tc")
+RbVmomi::VIM.load vmodl_fn
+
+require 'rbvmomi/extensions'