vagrant-rbvmomi 1.8.1

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/devel/benchmark.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+require 'tempfile'
+
+if ENV['RBVMOMI_COVERAGE'] == '1'
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'rbvmomi'
+require 'rbvmomi/deserialization'
+require 'benchmark'
+require 'libxml'
+
+NS_XSI = 'http://www.w3.org/2001/XMLSchema-instance'
+
+VIM = RbVmomi::VIM
+$conn = VIM.new(:ns => 'urn:vim25', :rev => '4.0')
+raw = File.read(ARGV[0])
+
+def diff a, b
+  a_io = Tempfile.new 'rbvmomi-diff-a'
+  b_io = Tempfile.new 'rbvmomi-diff-b'
+  PP.pp a, a_io
+  PP.pp b, b_io
+  a_io.close
+  b_io.close
+  system("diff -u #{a_io.path} #{b_io.path}")
+  a_io.unlink
+  b_io.unlink
+end
+
+begin
+  deserializer = RbVmomi::OldDeserializer.new($conn)
+  end_time = Time.now + 1
+  n = 0
+  while n == 0 or end_time > Time.now
+    deserializer.deserialize Nokogiri::XML(raw).root
+    n += 1
+  end
+  N = n*10
+end
+
+puts "iterations: #{N}"
+
+parsed_nokogiri = Nokogiri::XML(raw)
+parsed_libxml = LibXML::XML::Parser.string(raw).parse
+
+if true
+  nokogiri_xml = parsed_nokogiri.root
+  libxml_xml = parsed_libxml.root
+
+  old_nokogiri_result = RbVmomi::OldDeserializer.new($conn).deserialize nokogiri_xml
+  new_nokogiri_result = RbVmomi::NewDeserializer.new($conn).deserialize nokogiri_xml
+  new_libxml_result = RbVmomi::NewDeserializer.new($conn).deserialize libxml_xml
+
+  if new_nokogiri_result != old_nokogiri_result
+    puts "new_nokogiri_result doesnt match old_nokogiri_result"
+    puts "old_nokogiri_result:"
+    pp old_nokogiri_result
+    puts "new_nokogiri_result:"
+    pp new_nokogiri_result
+    puts "diff:"
+    diff old_nokogiri_result, new_nokogiri_result
+    exit 1
+  end
+
+  if new_libxml_result != old_nokogiri_result
+    puts "new_libxml_result doesnt match old_nokogiri_result"
+    puts "old_nokogiri_result:"
+    pp old_nokogiri_result
+    puts "new_libxml_result:"
+    pp new_libxml_result
+    puts "diff:"
+    diff old_nokogiri_result, new_libxml_result
+    exit 1
+  end
+
+  puts "all results match"
+end
+
+Benchmark.bmbm do|b|
+  GC.start
+  b.report("nokogiri parsing") do
+    N.times { Nokogiri::XML(raw) }
+  end
+  
+  GC.start
+  b.report("libxml parsing") do
+    N.times do
+      LibXML::XML::Parser.string(raw).parse
+    end
+  end
+  
+  GC.start
+  b.report("old deserialization (nokogiri)") do
+    deserializer = RbVmomi::OldDeserializer.new($conn)
+    N.times do
+      deserializer.deserialize Nokogiri::XML(raw).root
+    end
+  end
+
+  GC.start
+  b.report("new deserialization (nokogiri)") do
+    deserializer = RbVmomi::NewDeserializer.new($conn)
+    N.times do
+      deserializer.deserialize Nokogiri::XML(raw).root
+    end
+  end
+
+  GC.start
+  b.report("new deserialization (libxml)") do
+    deserializer = RbVmomi::NewDeserializer.new($conn)
+    N.times do
+      deserializer.deserialize LibXML::XML::Parser.string(raw).parse.root
+    end
+  end
+end

data/devel/collisions.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# Find collisions between VMODL property names and Ruby methods
+require 'rbvmomi'
+VIM = RbVmomi::VIM
+
+conn = VIM.new(:ns => 'urn:vim25', :rev => '4.0')
+
+VIM.loader.typenames.each do |name|
+  klass = VIM.loader.get name
+  next unless klass.respond_to? :kind and [:managed, :data].member? klass.kind
+  methods = klass.kind == :managed ?
+    RbVmomi::BasicTypes::ObjectWithMethods.instance_methods : 
+    RbVmomi::BasicTypes::ObjectWithProperties.instance_methods
+  klass.props_desc.each do |x|
+    name = x['name']
+    puts "collision: #{klass}##{name}" if methods.member? name.to_sym
+  end
+end

data/devel/merge-internal-vmodl.rb

@@ -0,0 +1,59 @@
+#!/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(
+DVSKeyedOpaqueData
+DVSOpaqueDataConfigSpec
+DVPortgroupSelection
+DVPortSelection
+DVSSelection
+DynamicTypeEnumTypeInfo
+DynamicTypeMgrAllTypeInfo
+DynamicTypeMgrAnnotation
+DynamicTypeMgrDataTypeInfo
+DynamicTypeMgrFilterSpec
+DynamicTypeMgrManagedTypeInfo
+DynamicTypeMgrMethodTypeInfo
+DynamicTypeMgrMethodTypeInfoAnnotationType
+DynamicTypeMgrMoFilterSpec
+DynamicTypeMgrMoInstance
+DynamicTypeMgrParamTypeInfo
+DynamicTypeMgrParamTypeInfoAnnotationType
+DynamicTypeMgrPropertyTypeInfo
+DynamicTypeMgrPropertyTypeInfoAnnotationType
+DynamicTypeMgrTypeFilterSpec
+InternalDynamicTypeManager
+ReflectManagedMethodExecuter
+ReflectManagedMethodExecuterSoapArgument
+ReflectManagedMethodExecuterSoapFault
+ReflectManagedMethodExecuterSoapResult
+SelectionSet
+)
+
+METHODS = %w(
+DistributedVirtualSwitchManager.UpdateDvsOpaqueData_Task
+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 "Couldn't find type #{k} in internal VMODL" 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/devel/merge-manual-vmodl.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# Manually merge two versions of vmodl.db
+
+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"
+
+public_vmodl = File.open(public_vmodl_filename, 'r') { |io| Marshal.load io }
+internal_vmodl = File.open(internal_vmodl_filename, 'r') { |io| Marshal.load io }
+
+db = {}
+tn = {}
+public_vmodl.each do |k,v|
+  unless k == '_typenames'
+    db[k] = v
+  else
+    tn['_typenames'] = v
+  end
+end
+
+internal_vmodl.each do |k, v|
+  unless k == '_typenames'
+    db[k] = v unless db[k]
+  else
+    tn['_typenames'] = tn['_typenames'] + v
+  end
+end
+
+db['_typenames'] = tn
+
+
+File.open(output_vmodl_filename, 'w') { |io| Marshal.dump db, io }

data/examples/annotate.rb

@@ -0,0 +1,54 @@
+require 'trollop'
+require 'rbvmomi'
+require 'rbvmomi/trollop'
+
+VIM = RbVmomi::VIM
+CMDS = %w(get set)
+
+opts = Trollop.options do
+  banner <<-EOS
+Annotate a VM.
+
+Usage:
+    annotate.rb [options] VM get
+    annotate.rb [options] VM set annotation
+
+Commands: #{CMDS * ' '}
+
+VIM connection options:
+    EOS
+
+    rbvmomi_connection_opts
+
+    text <<-EOS
+
+VM location options:
+    EOS
+
+    rbvmomi_datacenter_opt
+
+    text <<-EOS
+
+Other options:
+  EOS
+
+  stop_on CMDS
+end
+
+vm_name = ARGV[0] or Trollop.die("no VM name given")
+cmd = ARGV[1] or Trollop.die("no command given")
+abort "invalid command" unless CMDS.member? cmd
+Trollop.die("must specify host") unless opts[:host]
+
+vim = VIM.connect opts
+
+dc = vim.serviceInstance.find_datacenter(opts[:datacenter]) or abort "datacenter not found"
+vm = dc.find_vm(vm_name) or abort "VM not found"
+
+case cmd
+when 'get'
+  puts vm.config.annotation
+when 'set'
+  value = ARGV[2] or Trollop.die("no annotation given")
+  vm.ReconfigVM_Task(:spec => VIM.VirtualMachineConfigSpec(:annotation => value)).wait_for_completion
+end

data/examples/cached_ovf_deploy.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+require 'trollop'
+require 'rbvmomi'
+require 'rbvmomi/trollop'
+require 'rbvmomi/utils/deploy'
+require 'rbvmomi/utils/admission_control'
+require 'yaml'
+
+VIM = RbVmomi::VIM
+
+opts = Trollop.options do
+  banner <<-EOS
+Deploy an OVF to a cluster, using a cached template if available.
+
+Usage:
+    cached_ovf_deploy.rb [options] <vmname> <ovfurl>
+
+VIM connection options:
+    EOS
+
+    rbvmomi_connection_opts
+
+    text <<-EOS
+
+VM location options:
+    EOS
+
+    rbvmomi_datacenter_opt
+    rbvmomi_datastore_opt
+
+    text <<-EOS
+
+Other options:
+  EOS
+
+  opt :template_name, "Name to give to the (cached) template", :type => :string
+  opt :template_path, "Path where templates are stored", :default => 'templates', :type => :string
+  opt :computer_path, "Path to the cluster to deploy into", :type => :string
+  opt :network, "Name of the network to attach template to", :type => :string
+  opt :vm_folder_path, "Path to VM folder to deploy VM into", :type => :string
+  opt :lease, "Lease in days", :type => :int, :default => 3
+end
+
+Trollop.die("must specify host") unless opts[:host]
+Trollop.die("no cluster path given") unless opts[:computer_path]
+template_folder_path = opts[:template_path]
+template_name = opts[:template_name] or Trollop.die("no template name given")
+vm_name = ARGV[0] or Trollop.die("no VM name given")
+ovf_url = ARGV[1] or Trollop.die("No OVF URL given")
+
+vim = VIM.connect opts
+dc = vim.serviceInstance.find_datacenter(opts[:datacenter]) or abort "datacenter not found"
+
+root_vm_folder = dc.vmFolder
+vm_folder = root_vm_folder
+if opts[:vm_folder_path]
+  vm_folder = root_vm_folder.traverse(opts[:vm_folder_path], VIM::Folder)
+end
+template_folder = root_vm_folder.traverse!(template_folder_path, VIM::Folder)
+
+scheduler = AdmissionControlledResourceScheduler.new(
+  vim,
+  :datacenter => dc,
+  :computer_names => [opts[:computer_path]],
+  :vm_folder => vm_folder,
+  :rp_path => '/',
+  :datastore_paths => [opts[:datastore]],
+  :max_vms_per_pod => nil, # No limits
+  :min_ds_free => nil, # No limits
+)
+scheduler.make_placement_decision
+
+datastore = scheduler.datastore
+computer = scheduler.pick_computer
+# XXX: Do this properly
+if opts[:network]
+  network = computer.network.find{|x| x.name == opts[:network]}
+else
+  network = computer.network[0]
+end
+
+lease_tool = LeaseTool.new
+lease = opts[:lease] * 24 * 60 * 60
+deployer = CachedOvfDeployer.new(
+  vim, network, computer, template_folder, vm_folder, datastore
+)
+template = deployer.lookup_template template_name
+
+if !template
+  puts "#{Time.now}: Uploading/Preparing OVF template ..."
+  
+  template = deployer.upload_ovf_as_template(
+    ovf_url, template_name,
+    :run_without_interruptions => true,
+    :config => lease_tool.set_lease_in_vm_config({}, lease)
+  )
+end
+
+puts "#{Time.now}: Cloning template ..."
+config = {
+  :numCPUs => opts[:cpus],
+  :memoryMB => opts[:memory],
+}
+config = lease_tool.set_lease_in_vm_config(config, lease)
+vm = deployer.linked_clone template, vm_name, config
+
+puts "#{Time.now}: Powering On VM ..."
+# XXX: Add a retrying version?
+vm.PowerOnVM_Task.wait_for_completion
+
+puts "#{Time.now}: Waiting for VM to be up ..."
+ip = nil
+while !(ip = vm.guest_ip)
+  sleep 5
+end
+
+puts "#{Time.now}: VM got IP: #{ip}"
+
+puts "#{Time.now}: Done"
+