rbvmomi2 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a9290a6ccd179ef5e0dddb1d0956a1ba976a368ceb1534b44b13024fbe7a2fb5
+  data.tar.gz: 2cb20596b8f3cef9db32468e2f110f3abdcef70235a466efe81726259a650ea7
+SHA512:
+  metadata.gz: 8238c2c399f04f57930ac7bb2437de3eb2abc16723700366a6c57c97076f9043e342393bca69cc511ebe1fe91d9df354149144cff04f859c8178471fe5644381
+  data.tar.gz: ed586f8b93ded01b4ade32d1c4e95b1e349c94584084db14e83a6433b011e0c70f85a6df7674ac4228e1bc4d7d94814ba91bb0d2cb55f84bcfd828dc6fc802bf

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010-2017 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,114 @@
+# RbVmomi
+
+[<img src="https://badge.fury.io/rb/rbvmomi.svg" alt="gem-version">](https://rubygems.org/gems/rbvmomi) 
+[<img src="https://travis-ci.org/vmware/rbvmomi.svg?branch=master" alt="travis-ci">](http://travis-ci.org/vmware/rbvmomi) 
+[<img src="https://badges.gitter.im/vmware/rbvmomi.svg">](https://gitter.im/vmware/rbvmomi)
+
+This is a community-supported, open source project at VMware. It is built and
+maintained by programmers like you!
+
+## Introduction
+
+RbVmomi is a Ruby interface to the vSphere API. Like the Perl and Java SDKs,
+you can use it to manage ESX and vCenter servers. The current release
+supports the vSphere 6.5 API. RbVmomi specific documentation is
+[online](http://rdoc.info/github/vmware/rbvmomi/master/frames) and is meant to
+be used alongside the official [documentation](http://pubs.vmware.com/vsphere-65/index.jsp#com.vmware.wssdk.apiref.doc/right-pane.html).
+
+## Installation
+
+    gem install rbvmomi
+
+### Support for older Ruby versions
+
+RbVmomi supports Ruby 1.8.7 and higher, but certain dependencies may need
+pinning to older versions to get a compatible set of gems.
+
+On Ruby 1.8.7:
+
+* use `nokogiri` 1.5.x (Gemfile: `gem 'nokogiri', '< 1.6'`)
+
+
+On both Ruby 1.9 and 1.8.7:
+
+* use `json` 1.x (Gemfile: `gem 'json', '< 2'`)
+
+
+## Usage
+
+A simple example of turning on a VM:
+
+```ruby
+require 'rbvmomi'
+
+vim = RbVmomi::VIM.connect(host: 'foo', user: 'bar', password: 'baz')
+dc = vim.serviceInstance.find_datacenter('my_datacenter') || fail('datacenter not found')
+vm = dc.find_vm('my_vm') || fail('VM not found')
+vm.PowerOnVM_Task.wait_for_completion
+```
+
+This code uses several RbVmomi extensions to the vSphere API for concision.
+The expanded snippet below uses only standard API calls and should be familiar
+to users of the Java SDK:
+
+```ruby
+require 'rbvmomi'
+
+vim = RbVmomi::VIM.connect(host: 'foo', user: 'bar', password: 'baz')
+root_folder = vim.serviceInstance.content.rootFolder
+dc = root_folder.childEntity.grep(RbVmomi::VIM::Datacenter).find { |x| x.name == 'mydatacenter' } || fail('datacenter not found')
+vm = dc.vmFolder.childEntity.grep(RbVmomi::VIM::VirtualMachine).find { |x| x.name == 'my_vm' } || fail('VM not found')
+task = vm.PowerOnVM_Task
+filter = vim.propertyCollector.CreateFilter(
+  spec: {
+    propSet: [{ type: 'Task', all: false, pathSet: ['info.state']}],
+    objectSet: [{ obj: task }]
+  },
+  partialUpdates: false
+)
+ver = ''
+loop do
+  result = vim.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'
+```
+
+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.
+
+A few important points:
+
+*   All class, method, parameter, and property names match the official [documentation](http://pubs.vmware.com/vsphere-65/index.jsp#com.vmware.wssdk.apiref.doc/right-pane.html).
+*   Properties are exposed as accessor methods.
+*   Data object types can usually be inferred from context, so you may use a hash instead.
+*   Enumeration values are simply strings.
+*   Example code is included in the examples/ directory.
+*   A set of helper methods for Optimist is included to speed up development of
+    command line apps. See the included examples for usage.
+*   If you don't have trusted SSL certificates installed on the host you're
+    connecting to, you'll get an `OpenSSL::SSL::SSLError` "certificate verify
+    failed". You can work around this by using the `:insecure` option to
+    `RbVmomi::VIM.connect`.
+*   This is a side project of a VMware employee and is entirely unsupported by
+    VMware.
+
+
+Built-in extensions are under `lib/rbvmomi/vim/`. You are encouraged to reopen
+VIM classes in your applications and add extensions of your own. If you write
+something generally useful please open a [pull request](https://github.com/vmware/rbvmomi/pulls) so it can be merged back in
+
+## Development
+
+Open an issue on the [issues page](https://github.com/vmware/rbvmomi/issues)
+or  fork the project on [GitHub](https://github.com/vmware/rbvmomi) and send a
+[pull request](https://github.com/vmware/rbvmomi/pulls).
+
+## Support
+
+You can chat on [Gitter](https://gitter.im/vmware/rbvmomi) or join the [VMware {code} Slack team](https://vmwarecode.slack.com/) and join the [#rbvmomi channel](https://vmwarecode.slack.com/messages/rbvmomi).

data/exe/rbvmomish

@@ -0,0 +1,138 @@
+#!/usr/bin/env ruby
+# TODO keepalive
+# TODO rc file
+# TODO proxy support?
+require 'optimist'
+require 'readline'
+require 'rbvmomi'
+require 'rbvmomi/optimist'
+
+VIM = RbVmomi::VIM
+
+opts = Optimist.options do
+  banner <<-EOS
+vSphere API console.
+
+Usage:
+       rbvmomish [options]
+
+Predefined methods:
+conn: Returns the VIM connection
+si: Returns the ServiceInstance
+help: Displays this text.
+
+Special syntax:
+Adding a '#' suffix to an expression displays information about the type of the
+result, including its properties and methods, instead of the value.
+
+VIM connection options:
+  EOS
+
+  rbvmomi_connection_opts
+
+  text <<-EOS
+
+Other options:
+  EOS
+
+  $optimist = self
+end
+
+begin
+  $vim = VIM.connect opts
+rescue Errno::EHOSTUNREACH
+  abort $!.message
+end
+
+typenames = VIM.loader.typenames
+Readline.completion_append_character = " "
+Readline.completion_proc = lambda do |word|
+  return unless word
+  prefix_regex = /^#{Regexp.escape(word)}/
+  candidates = typenames.sort
+  candidates.find_all { |e| e.match(prefix_regex) }
+end
+
+history_fn = "#{ENV['HOME']}/.rbvmomish-history"
+IO.foreach(history_fn) { |l| Readline::HISTORY << l.chomp } rescue nil
+history = File.open(history_fn, 'a')
+
+def type name
+  klass = VIM.type(name) rescue err("invalid type #{name.inspect}")
+  q = lambda { |x| x =~ /^xsd:/ ? $' : x }
+  if klass < VIM::DataObject
+    puts "Data Object #{klass}"
+    klass.full_props_desc.each do |desc|
+      puts " #{desc['name']}: #{q[desc['wsdl_type']]}#{desc['is-array'] ? '[]' : ''}"
+    end
+  elsif klass < VIM::ManagedObject
+    puts "Managed Object #{klass}"
+    puts
+    puts "Properties:"
+    klass.full_props_desc.each do |desc|
+      puts " #{desc['name']}: #{q[desc['wsdl_type']]}#{desc['is-array'] ? '[]' : ''}"
+    end
+    puts
+    puts "Methods:"
+    klass.full_methods_desc.sort_by(&:first).each do |name,desc|
+      params = desc['params']
+      puts " #{name}(#{params.map { |x| "#{x['name']} : #{q[x['wsdl_type'] || 'void']}#{x['is-array'] ? '[]' : ''}" } * ', '}) : #{q[desc['result']['wsdl_type'] || 'void']}"
+    end
+  else
+    err("cannot introspect type #{klass}")
+  end
+  nil
+end
+
+class UserError < RuntimeError; end
+def err msg
+  raise UserError.new(msg)
+end
+
+def cookie str
+  $vim.cookie = str
+end
+
+def conn
+  $vim
+end
+
+def si
+  $vim.serviceInstance
+end
+
+def help
+  $optimist.educate
+  :no_result
+end
+
+$binding = $vim.instance_eval { binding }
+
+loop do
+begin
+  input = Readline.readline("#{opts[:host]}> ", false) or break
+  input = input.strip
+  next if input.empty?
+
+  (history.puts input; Readline::HISTORY << input) unless input == Readline::HISTORY.to_a[-1]
+
+  result = eval(input, $binding)
+  if input =~ /\#$/
+    type result.class.wsdl_name
+  else
+    pp result unless result == :no_result
+  end
+rescue SystemExit, IOError
+  raise
+rescue RuntimeError, RbVmomi::Fault
+  puts "#{$!.class}: #{$!.message}"
+  puts $!.backtrace * "\n"
+rescue UserError
+  puts $!.message
+rescue Interrupt
+  puts
+rescue Exception
+  puts "#{$!.class}: #{$!.message}"
+  puts $!.backtrace * "\n"
+end
+end

data/lib/rbvmomi/basic_types.rb

@@ -0,0 +1,383 @@
+# Copyright (c) 2011-2017 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+require 'pp'
+require 'set'
+
+module RbVmomi
+module BasicTypes
+
+BUILTIN = Set.new %w(ManagedObject DataObject TypeName PropertyPath ManagedObjectReference MethodName MethodFault LocalizedMethodFault KeyValue)
+
+class Base
+  class << self
+    attr_accessor :wsdl_name
+
+    def init wsdl_name=self.name
+      @wsdl_name = wsdl_name
+    end
+
+    def to_s
+      @wsdl_name
+    end
+  end
+
+  init
+end
+
+class ObjectWithProperties < Base
+  class << self
+    attr_accessor :props_desc
+
+    def init name=self.name, props=[]
+      super name
+      @props_desc = props
+      @props_desc.each do |d|
+        sym = d['name'].to_sym
+        define_method(sym) { _get_property sym }
+        define_method(:"#{sym}=") { |x| _set_property sym, x }
+      end
+    end
+
+    def full_props_set
+      @full_props_set ||= Set.new(full_props_desc.map { |x| x['name'] })
+    end
+
+    def full_props_desc
+      @full_props_desc ||= (self == ObjectWithProperties ? [] : superclass.full_props_desc) + props_desc
+    end
+
+    def find_prop_desc name
+      full_props_desc.find { |x| x['name'] == name.to_s }
+    end
+  end
+
+  def _get_property sym
+    fail 'unimplemented'
+  end
+
+  def _set_property sym, val
+    fail 'unimplemented'
+  end
+
+  init
+end
+
+class ObjectWithMethods < ObjectWithProperties
+  class << self
+    attr_accessor :methods_desc
+
+    def init name=self.name, props=[], methods={}
+      super name, props
+      @methods_desc = methods
+
+      @methods_desc.each do |k,d|
+        sym = k.to_sym
+        define_method(sym) { |*args| _call sym, *args }
+        define_method(:"#{sym}!") { |*args| _call sym, *args }
+      end
+    end
+
+    # XXX cache
+    def full_methods_desc
+      (self == ObjectWithMethods ? {} : superclass.full_methods_desc).merge methods_desc
+    end
+  end
+
+  init
+end
+
+class DataObject < ObjectWithProperties
+  attr_reader :props
+
+  def self.kind; :data end
+
+  def initialize props={}
+    # Deserialization fast path
+    if props == nil
+      @props = {}
+      return
+    end
+
+    @props = Hash[props.map { |k,v| [k.to_sym, v] }]
+    #self.class.full_props_desc.each do |desc|
+      #fail "missing required property #{desc['name'].inspect} of #{self.class.wsdl_name}" if @props[desc['name'].to_sym].nil? and not desc['is-optional']
+    #end
+    @props.each do |k,v|
+      fail "unexpected property name #{k}" unless self.class.find_prop_desc(k)
+    end
+  end
+
+  def initialize_copy(source)  
+    super  
+    @props = @props.dup  
+  end 
+
+  def _get_property sym
+    @props[sym]
+  end
+
+  def [] sym
+    _get_property sym
+  end
+
+  def _set_property sym, val
+    @props[sym] = val
+  end
+
+  def []= sym, val
+    _set_property sym, val
+  end
+
+  def == o
+    return false unless o.class == self.class
+    keys = (props.keys + o.props.keys).uniq
+    keys.all? { |k| props[k] == o.props[k] }
+  end
+
+  alias eql? ==
+
+  def hash
+    props.hash
+  end
+
+  def pretty_print q
+    q.text self.class.wsdl_name
+    q.group 2 do
+      q.text '('
+      q.breakable
+      props = @props.sort_by { |k,v| k.to_s }
+      q.seplist props, nil, :each do |e|
+        k, v = e
+        q.group do
+          q.text k.to_s
+          q.text ': '
+          q.pp v
+        end
+      end
+    end
+    q.breakable
+    q.text ')'
+  end
+
+  def to_json(*args)
+    h = self.props
+    m = h.merge({ JSON.create_id => self.class.name })
+    m.to_json(*args)
+  end
+
+  init
+end
+
+class ManagedObject < ObjectWithMethods
+  def self.kind; :managed end
+
+  def initialize connection, ref
+    super()
+    @connection = connection
+    @soap = @connection # XXX deprecated
+    @ref = ref
+  end
+
+  def _connection
+    @connection
+  end
+
+  def _ref
+    @ref
+  end
+
+  def _get_property sym
+    ret = @connection.propertyCollector.RetrieveProperties(:specSet => [{
+      :propSet => [{ :type => self.class.wsdl_name, :pathSet => [sym.to_s] }],
+      :objectSet => [{ :obj => self }],
+    }])[0]
+
+    if !ret
+      return nil
+    elsif ret.propSet.empty?
+      return nil if ret.missingSet.empty?
+      raise ret.missingSet[0].fault
+    else
+      ret.propSet[0].val
+    end
+  end
+
+  def _set_property sym, val
+    fail 'unimplemented'
+  end
+
+  def _call method, o={}
+    fail "parameters must be passed as a hash" unless o.is_a? Hash
+    desc = self.class.full_methods_desc[method.to_s] or fail "unknown method"
+    @connection.call method, desc, self, o
+  end
+
+  def to_s
+    "#{self.class.wsdl_name}(#{@ref.inspect})"
+  end
+
+  def pretty_print pp
+    pp.text to_s
+  end
+
+  def [] k
+    _get_property k
+  end
+
+  def == x
+    out = (x.class == self.class && x._ref == @ref) 
+    out = (x._connection.instanceUuid == self._connection.instanceUuid) if out && x._connection.host
+    out
+  end
+
+  alias eql? ==
+
+  def hash
+    [self.class, @ref].hash
+  end
+
+  init 'ManagedObject'
+end
+
+class Enum < Base
+  class << self
+    attr_accessor :values
+
+    def init name=self.name, values=[]
+      super name
+      @values = values
+    end
+  end
+
+  def self.kind; :enum end
+
+  attr_reader :value
+
+  def initialize value
+    @value = value
+  end
+
+  init
+end
+
+class MethodFault < DataObject
+  init 'MethodFault', [
+    {
+      'name' => 'faultCause',
+      'wsdl_type' => 'LocalizedMethodFault',
+      'is-array' => false,
+      'is-optional' => true,
+    }, {
+      'name' => 'faultMessage',
+      'wsdl_type' => 'LocalizableMessage',
+      'is-array' => true,
+      'is-optional' => true,
+    },
+  ]
+
+  def self.=== exn
+    exn.class == RbVmomi::Fault and self <= exn.fault.class
+  end
+end
+
+class LocalizedMethodFault < DataObject
+  init 'LocalizedMethodFault', [
+    {
+      'name' => 'fault',
+      'wsdl_type' => 'MethodFault',
+      'is-array' => false,
+      'is-optional' => false,
+    }, {
+      'name' => 'localizedMessage',
+      'wsdl_type' => 'xsd:string',
+      'is-array' => false,
+      'is-optional' => true,
+    },
+  ]
+
+  def exception
+    RbVmomi::Fault.new(self.localizedMessage, self.fault)
+  end
+end
+
+class RuntimeFault < MethodFault
+  init
+end
+
+class MethodName < String
+  def self.wsdl_name; 'MethodName' end
+end
+
+class PropertyPath < String
+  def self.wsdl_name; 'PropertyPath' end
+end
+
+class TypeName < String
+  def self.wsdl_name; 'TypeName' end
+end
+
+class ManagedObjectReference
+  def self.wsdl_name; 'ManagedObjectReference' end
+end
+
+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
+
+class ::Class
+  def wsdl_name; self.class.name end
+end
+
+class ::String
+  def self.wsdl_name; 'xsd:string' end
+end
+
+class ::Integer
+  def self.wsdl_name; 'xsd:int' end
+end
+
+class ::Float
+  def self.wsdl_name; 'xsd:float' end
+end
+
+class Int
+  def self.wsdl_name; 'xsd:int' end
+  
+  def initialize x
+    @val = x
+  end
+  
+  def to_s
+    @val.to_s
+  end
+end
+
+class KeyValue
+  def self.wsdl_name; 'KeyValue' 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