rbvmomi 1.0.2 → 1.1.0

data/lib/rbvmomi/vim/ComputeResource.rb

@@ -0,0 +1,51 @@
+class RbVmomi::VIM::ComputeResource
+  # Aggregate cluster information.
+  #
+  # @note Values are returned in a hash.
+  #
+  # @return [Mhz] totalCPU: Sum of the frequencies of each CPU in the cluster.
+  # @return [Mhz] usedCPU: CPU cycles used across the cluster.
+  # @return [MB] totalMem: Total RAM.
+  # @return [MB] usedMem: Used RAM.
+  def stats
+    filterSpec = RbVmomi::VIM.PropertyFilterSpec(
+      objectSet: [{
+        obj: self,
+        selectSet: [
+          RbVmomi::VIM.TraversalSpec(
+            name: 'tsHosts',
+            type: 'ComputeResource',
+            path: 'host',
+            skip: false,
+          )
+        ]
+      }],
+      propSet: [{
+        pathSet: %w(name overallStatus summary.hardware.cpuMhz
+                    summary.hardware.numCpuCores summary.hardware.memorySize
+                    summary.quickStats.overallCpuUsage
+                    summary.quickStats.overallMemoryUsage),
+        type: 'HostSystem'
+      }]
+    )
+
+    result = @soap.propertyCollector.RetrieveProperties(specSet: [filterSpec])
+
+    stats = {
+      totalCPU: 0,
+      totalMem: 0,
+      usedCPU: 0,
+      usedMem: 0,
+    }
+
+    result.each do |x|
+      next if x['overallStatus'] == 'red'
+      stats[:totalCPU] += x['summary.hardware.cpuMhz'] * x['summary.hardware.numCpuCores']
+      stats[:totalMem] += x['summary.hardware.memorySize'] / (1024*1024)
+      stats[:usedCPU] += x['summary.quickStats.overallCpuUsage'] || 0
+      stats[:usedMem] += x['summary.quickStats.overallMemoryUsage'] || 0
+    end
+
+    stats
+  end
+end

data/lib/rbvmomi/vim/Datacenter.rb

@@ -0,0 +1,17 @@
+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
+end
+

data/lib/rbvmomi/vim/Datastore.rb

@@ -0,0 +1,68 @@
+# @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' => @soap.cookie
+    resp = @soap.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#{@soap.http.use_ssl? ? 's' : ''}://#{@soap.http.address}:#{@soap.http.port}#{mkuripath(remote_path)}"
+    pid = spawn CURLBIN, "-k", '--noproxy', '*', '-f',
+                "-o", local_path,
+                "-b", @soap.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#{@soap.http.use_ssl? ? 's' : ''}://#{@soap.http.address}:#{@soap.http.port}#{mkuripath(remote_path)}"
+    pid = spawn CURLBIN, "-k", '--noproxy', '*', '-f',
+                "-T", local_path,
+                "-b", @soap.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? Datacenter
+      x = x.parent
+    end
+    fail unless x.is_a? Datacenter
+    @datacenter = x
+  end
+
+  def mkuripath path
+    "/folder/#{URI.escape path}?dcPath=#{URI.escape datacenter.name}&dsName=#{URI.escape name}"
+  end
+end

data/lib/rbvmomi/vim/Folder.rb

@@ -0,0 +1,112 @@
+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 = @soap.searchIndex.FindChild(entity: self, name: name)
+    x if x.is_a? type
+  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 '/'.
+  # @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
+    es = path.split('/').reject(&:empty?)
+    return self if es.empty?
+    final = es.pop
+
+    p = es.inject(self) do |f,e|
+      f.find(e, Folder) || (create && f.CreateFolder(name: e)) || return
+    end
+
+    if x = p.find(final, type)
+      x
+    elsif create and type == Folder
+      p.CreateFolder(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] 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'] }]
+    propSpecs.each do |k,v|
+      case k
+      when RbVmomi::VIM::ManagedEntity
+        k = k.wsdl_name
+      when Symbol, String
+        k = k.to_s
+      else
+        fail "key must be a ManagedEntity"
+      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 = @soap.propertyCollector.RetrieveProperties(specSet: [filterSpec])
+
+    tree = { self => {} }
+    result.each do |x|
+      obj = x.obj
+      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/ManagedEntity.rb

@@ -0,0 +1,46 @@
+class RbVmomi::VIM::ManagedEntity
+  # Retrieve the ancestors of the entity.
+  # @return [Array] Ancestors of this entity, starting with the root.
+  def path
+    filterSpec = RbVmomi::VIM.PropertyFilterSpec(
+      objectSet: [{
+        obj: self,
+        selectSet: [
+          RbVmomi::VIM.TraversalSpec(
+            name: 'tsME',
+            type: 'ManagedEntity',
+            path: 'parent',
+            skip: false,
+            selectSet: [
+              RbVmomi::VIM.SelectionSpec(name: 'tsME')
+            ]
+          )
+        ]
+      }],
+      propSet: [{
+        pathSet: %w(name parent),
+        type: 'ManagedEntity'
+      }]
+    )
+
+    result = @soap.propertyCollector.RetrieveProperties(specSet: [filterSpec])
+
+    tree = {}
+    result.each { |x| tree[x.obj] = [x['parent'], x['name']] }
+    a = []
+    cur = self
+    while cur
+      parent, name = *tree[cur]
+      a << [cur, name]
+      cur = parent
+    end
+    a.reverse
+  end
+
+  # Return a string representation of +path+ suitable for display.
+  # @return [String]
+  # @see #path
+  def pretty_path
+    path[1..-1].map { |x| x[1] } * '/'
+  end
+end

data/lib/rbvmomi/vim/ManagedObject.rb

@@ -0,0 +1,55 @@
+class RbVmomi::VIM::ManagedObject
+  # Wait for updates on an object until a condition becomes true.
+  #
+  # @param pathSet [Array] Property paths to wait for updates to.
+  # @yield Called when an update to a subscribed property occurs.
+  # @yieldreturn [Boolean] Whether to stop waiting.
+  #
+  # @todo Pass the current property values to the block.
+  def wait_until *pathSet, &b
+    all = pathSet.empty?
+    filter = @soap.propertyCollector.CreateFilter :spec => {
+      :propSet => [{ :type => self.class.wsdl_name, :all => all, :pathSet => pathSet }],
+      :objectSet => [{ :obj => self }],
+    }, :partialUpdates => false
+    ver = ''
+    loop do
+      result = @soap.propertyCollector.WaitForUpdates(version: ver)
+      ver = result.version
+      if x = b.call
+        return x
+      end
+    end
+  ensure
+    filter.DestroyPropertyFilter if filter
+  end
+
+  # Efficiently retrieve multiple properties from an object.
+  # @param pathSet [Array] Properties to return.
+  # @return [Hash] Hash from property paths to values.
+  def collect! *pathSet
+    spec = {
+      objectSet: [{ obj: self }],
+      propSet: [{
+        pathSet: pathSet,
+        type: self.class.wsdl_name
+      }]
+    }
+    @soap.propertyCollector.RetrieveProperties(specSet: [spec])[0].to_hash
+  end
+
+  # Efficiently retrieve multiple properties from an object.
+  # @param pathSet (see #collect!)
+  # @yield [*values] Property values in same order as +pathSet+.
+  # @return [Array] Property values in same order as +pathSet+, or the return
+  #                 value from the block if it is given.
+  def collect *pathSet
+    h = collect! *pathSet
+    a = pathSet.map { |k| h[k.to_s] }
+    if block_given?
+      yield a
+    else
+      a
+    end
+  end
+end

data/lib/rbvmomi/vim/ObjectContent.rb

@@ -0,0 +1,23 @@
+class RbVmomi::VIM::ObjectContent
+  # Represent this ObjectContent as a hash.
+  # @return [Hash] A hash from property paths to values.
+  def to_hash
+    @cached_hash ||= to_hash_uncached
+  end
+
+  # Alias for +to_hash[k]+.
+  def [](k)
+    to_hash[k]
+  end
+
+  private
+
+  def to_hash_uncached
+    h = {}
+    propSet.each do |x|
+      fail if h.member? x.name
+      h[x.name] = x.val
+    end
+    h
+  end
+end

data/lib/rbvmomi/vim/ObjectUpdate.rb

@@ -0,0 +1,23 @@
+class RbVmomi::VIM::ObjectUpdate
+  # Represent this ObjectUpdate as a hash.
+  # @return [Hash] A hash from property paths to values.
+  def to_hash
+    @cached_hash ||= to_hash_uncached
+  end
+
+  # Alias for +to_hash[k]+.
+  def [](k)
+    to_hash[k]
+  end
+
+  private
+
+  def to_hash_uncached
+    h = {}
+    changeSet.each do |x|
+      fail if h.member? x.name
+      h[x.name] = x.val
+    end
+    h
+  end
+end

data/lib/rbvmomi/vim/OvfManager.rb

@@ -0,0 +1,93 @@
+# @note +deployOVF+ and requires +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::OvfManager
+  CURLBIN = ENV['CURL'] || "curl" #@private
+
+  # Deploy an OVF.
+  #
+  # @param [Hash] opts The options hash.
+  # @option opts [String]             :uri Location of the OVF.
+  # @option opts [String]             :vmName Name of the new VM.
+  # @option opts [VIM::Folder]        :vmFolder Folder to place the VM in.
+  # @option opts [VIM::HostSystem]    :host Host to use.
+  # @option opts [VIM::ResourcePool]  :resourcePool Resource pool to use.
+  # @option opts [VIM::Datastore]     :datastore Datastore to use.
+  # @option opts [String]             :diskProvisioning (thin) Disk provisioning mode.
+  # @option opts [Hash]               :networkMappings Network mappings.
+  # @option opts [Hash]               :propertyMappings Property mappings.
+  def deployOVF opts
+    opts = { networkMappings: {},
+             propertyMappings: {},
+             diskProvisioning: :thin }.merge opts
+
+    %w(uri vmName vmFolder host resourcePool datastore).each do |k|
+      fail "parameter #{k} required" unless opts[k.to_sym]
+    end
+
+    ovfImportSpec = RbVmomi::VIM::OvfCreateImportSpecParams(
+      hostSystem: opts[:host],
+      locale: "US",
+      entityName: opts[:vmName],
+      deploymentOption: "",
+      networkMapping: opts[:networkMappings].map{|from, to| RbVmomi::VIM::OvfNetworkMapping(name: from, network: to)},
+      propertyMapping: opts[:propertyMappings].map{|key, value| RbVmomi::VIM::KeyValue(key: key, value: value)},
+      diskProvisioning: opts[:diskProvisioning]
+    )
+
+    result = CreateImportSpec(
+      ovfDescriptor: open(opts[:uri]).read,
+      resourcePool: opts[:resourcePool],
+      datastore: opts[:datastore],
+      cisp: ovfImportSpec
+    )
+
+    raise result.error[0].localizedMessage if result.error && !result.error.empty?
+
+    if result.warning
+      result.warning.each{|x| puts "OVF Warning: #{x.localizedMessage.chomp}" }
+    end
+
+    nfcLease = opts[:resourcePool].ImportVApp(spec: result.importSpec,
+                                              folder: opts[:vmFolder],
+                                              host: opts[:host])
+
+    nfcLease.wait_until(:state) { nfcLease.state != "initializing" }
+    raise nfcLease.error if nfcLease.state == "error"
+
+    begin
+      nfcLease.HttpNfcLeaseProgress(percent: 5)
+      progress = 0.0
+      result.fileItem.each do |fileItem|
+        deviceUrl = nfcLease.info.deviceUrl.find{|x| x.importKey == fileItem.deviceId}
+        if !deviceUrl
+          raise "Couldn't find deviceURL for device '#{fileItem.deviceId}'"
+        end
+
+        # XXX handle file:// URIs
+        ovfFilename = opts[:uri].to_s
+        tmp = ovfFilename.split(/\//)
+        tmp.pop
+        tmp << fileItem.path
+        filename = tmp.join("/")
+
+        method = fileItem.create ? "PUT" : "POST"
+
+        href = deviceUrl.url.gsub("*", opts[:host].config.network.vnic[0].spec.ip.ipAddress)
+        downloadCmd = "#{CURLBIN} -L '#{filename}'"
+        uploadCmd = "#{CURLBIN} -X #{method} --insecure -T - -H 'Content-Type: application/x-vnd.vmware-streamVmdk' -H 'Content-Length: #{fileItem.size}' '#{href}'"
+        system("#{downloadCmd} | #{uploadCmd}")
+        progress += (95.0 / result.fileItem.length)
+        nfcLease.HttpNfcLeaseProgress(percent: progress.to_i)
+      end
+
+      nfcLease.HttpNfcLeaseProgress(percent: 100)
+      vm = nfcLease.info.entity
+      nfcLease.HttpNfcLeaseComplete
+      vm
+    end
+  rescue Exception
+    nfcLease.HttpNfcLeaseAbort
+    raise
+  end
+end