ruby_vim_sdk 0.0.2

data/lib/ruby_vim_sdk/soap/stub_adapter.rb

@@ -0,0 +1,123 @@
+module VimSdk
+  module Soap
+
+    class StubAdapter
+      PC = Vmodl::Query::PropertyCollector
+
+      attr_reader :version
+
+      def initialize(uri, version, http_client)
+        @uri = URI.parse(uri)
+        @version = version
+        @version_id = compute_version_id(version)
+        @http_client = http_client
+        @cookie = ""
+        @property_collector = nil
+      end
+
+      def cookie
+        @http_client.cookie_manager.find(@uri)
+      end
+
+      def invoke_method(managed_object, method_info, arguments, outer_stub = nil)
+        outer_stub = self if outer_stub.nil?
+        headers = {"SOAPAction"      => @version_id,
+                   "Accept-Encoding" => "gzip, deflate",
+                   "Content-Type"    => "text/xml; charset=#{XML_ENCODING}"}
+
+        request = serialize_request(managed_object, method_info, arguments)
+        response = @http_client.post(@uri, request, headers)
+
+        status = response.code
+        if status == 200 || status == 500
+          object = SoapResponseDeserializer.new(outer_stub).deserialize(response.content, method_info.result_type)
+          if outer_stub != self
+            result = [status, object]
+          elsif status == 200
+            result = object
+          elsif object.kind_of?(Vmodl::MethodFault)
+            raise SoapException.new(object.msg, object)
+          else
+            raise SoapException.new("Unknown SOAP fault", object)
+          end
+        else
+          raise Net::HTTPError.new("#{status}", nil)
+        end
+        result
+      end
+
+      def invoke_property(managed_object, property_info)
+        filter_spec = PC::FilterSpec.new(
+          :object_set => [PC::ObjectSpec.new(:obj => managed_object, :skip => false)],
+          :prop_set => [PC::PropertySpec.new(:all => false, :type => managed_object.class,
+                                             :path_set => [property_info.wsdl_name])])
+
+        if @property_collector.nil?
+          service_instance    = Vim::ServiceInstance.new("ServiceInstance", self)
+          @property_collector = service_instance.retrieve_content.property_collector
+        end
+
+        @property_collector.retrieve_contents([filter_spec]).first.prop_set.first.val
+      end
+
+      def compute_version_id(version)
+        version_ns = VmomiSupport.version_namespace(version)
+        if version_ns.index("/")
+          "\"urn:#{version_ns}\""
+        else
+          ""
+        end
+      end
+
+      def serialize_request(managed_object, info, arguments)
+        if !VmomiSupport.is_child_version(@version, info.version)
+          fault = Vmodl::Fault::MethodNotFound.new
+          fault.receiver = managed_object
+          fault.method = info.name
+          raise SoapException(fault)
+        end
+
+        namespace_map = SOAP_NAMESPACE_MAP.dup
+        default_namespace = VmomiSupport.wsdl_namespace(@version)
+        namespace_map[default_namespace] = ""
+
+        result = [XML_HEADER, "\n", SOAP_ENVELOPE_START]
+        result << SOAP_BODY_START
+        result << "<#{info.wsdl_name} xmlns=\"#{default_namespace}\">"
+        property = Property.new("_this", "Vmodl.ManagedObject", @version)
+        property.type = Vmodl::ManagedObject
+        result << serialize(managed_object, property, @version, namespace_map)
+
+        info.arguments.zip(arguments).each do |parameter, argument|
+          result << serialize(argument, parameter, @version, namespace_map)
+        end
+
+        result << "</#{info.wsdl_name}>"
+        result << SOAP_BODY_END
+        result << SOAP_ENVELOPE_END
+
+        result.join("")
+      end
+
+      def serialize(object, info, version, namespace_map)
+        if version.nil?
+          if object.kind_of?(Array)
+            item_type = object.class.type_info
+            version = item_type.version
+          else
+            if object.nil?
+              return ""
+            end
+            version = object.class.type_info.version
+          end
+        end
+
+        writer = StringIO.new
+        SoapSerializer.new(writer, version, namespace_map).serialize(object, info)
+        writer.string
+      end
+
+    end
+
+  end
+end

data/lib/ruby_vim_sdk/soap_exception.rb

@@ -0,0 +1,12 @@
+module VimSdk
+  class SoapException < Exception
+
+    attr_reader :fault
+
+    def initialize(message, fault)
+      super(message)
+      @fault = fault
+    end
+
+  end
+end

data/lib/ruby_vim_sdk/typed_array.rb

@@ -0,0 +1,9 @@
+module VimSdk
+
+  class TypedArray < Array
+    class << self
+      attr_accessor :item
+    end
+  end
+
+end

data/lib/ruby_vim_sdk/types.rb

@@ -0,0 +1,22 @@
+module VimSdk
+
+  class SoapBinary < String; end
+
+  class SoapBoolean
+    attr_accessor :value
+    def initialize(value)
+      @value = value
+    end
+  end
+
+  class SoapFloat < DelegateClass(Float); end
+  class SoapInteger < DelegateClass(Integer); end
+
+  class SoapByte < SoapInteger; end
+  class SoapDouble < SoapFloat; end
+  class SoapLong < SoapInteger; end
+  class SoapShort < SoapInteger; end
+  class SoapURI < String; end
+  class SoapEnum; end
+
+end

data/lib/ruby_vim_sdk/version.rb

@@ -0,0 +1,5 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module VimSdk
+  VERSION = "0.0.2"
+end

data/lib/ruby_vim_sdk/vmodl/data_object.rb

@@ -0,0 +1,102 @@
+module VimSdk
+  module Vmodl
+    class DataObject
+      @type_info = DataType.new("vmodl.DataObject", "DataObject", nil, VimSdk::BASE_VERSION, [])
+      @resolved_properties = nil
+
+      class << self
+        attr_reader :type_info
+
+        [:name, :wsdl_name, :version, :properties].each do |name|
+          define_method(name) { @type_info.send(name) }
+        end
+
+        def property_list(include_base_class_props = true)
+          return properties unless include_base_class_props
+          return @resolved_properties unless @resolved_properties.nil?
+
+          result = []
+          property_names = Set.new
+
+          current_class = self
+          while current_class != DataObject
+            properties = current_class.type_info.properties
+            if properties
+              properties.reverse.each do |property|
+                unless property_names.include?(property.name)
+                  result.unshift(property)
+                  property_names << property.name
+                end
+              end
+            end
+            current_class = current_class.superclass
+          end
+
+          @resolved_properties = result
+        end
+
+        def build_property_indices
+          @property_by_name = {}
+          @property_by_wsdl_name = {}
+          property_list.each do |property|
+            @property_by_name[property.name] = property
+            @property_by_wsdl_name[property.wsdl_name] = property
+          end
+        end
+
+        def property(options = {})
+          if options[:name]
+            @property_by_name[options[:name]]
+          elsif options[:wsdl_name]
+            @property_by_wsdl_name[options[:wsdl_name]]
+          end
+        end
+
+        def finalize
+          build_property_indices
+          @type_info.properties.each do |property|
+            property.type = VmomiSupport.loaded_type(property.type) if property.type.kind_of?(String)
+            self.instance_eval do
+              attr_accessor(property.name)
+            end
+          end
+        end
+
+      end
+
+      def initialize(properties = {})
+
+        self.class.property_list.each do |property|
+          subclasses = Set.new(property.type.ancestors)
+          if subclasses.include?(Array)
+            default_value = property.type.new
+          elsif property.optional?
+            default_value = nil
+          elsif property.type == SoapBoolean
+            default_value = false
+          elsif subclasses.include?(SoapEnum)
+            default_value = nil
+          elsif subclasses.include?(String)
+            default_value = ""
+          elsif [SoapByte, SoapShort, SoapLong, SoapInteger].include?(property.type)
+            default_value = 0
+          elsif [SoapFloat, SoapDouble].include?(property.type)
+            default_value = 0.0
+          else
+            default_value = nil
+          end
+          instance_variable_set("@#{property.name}", default_value)
+        end
+
+        properties.each do |key, value|
+          if self.class.property(:name => key.to_s)
+            instance_variable_set("@#{key}", value)
+          else
+            raise "Invalid property: #{key}"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ruby_vim_sdk/vmodl/managed_object.rb

@@ -0,0 +1,78 @@
+module VimSdk
+  module Vmodl
+    class ManagedObject < DataObject
+      @type_info = ManagedType.new("vmodl.ManagedObject", "ManagedObject", nil, VimSdk::BASE_VERSION, [], [])
+
+      class << self
+
+        [:managed_methods].each do |name|
+          define_method(name) { @type_info.send(name) }
+        end
+
+        def invoke_method(object, managed_method, *args)
+          object.__stub__.invoke_method(object, managed_method, args)
+        end
+
+        def invoke_property(object, property)
+          object.__stub__.invoke_property(object, property)
+        end
+
+        def finalize
+          build_property_indices
+
+          @type_info.properties.each do |property|
+            property.type = VmomiSupport.loaded_type(property.type) if property.type.kind_of?(String)
+            self.instance_eval do
+              define_method(property.name) do |*args|
+                if args.length != 0
+                  raise ArgumentError, "wrong number of arguments (#{args.length} for 0)"
+                end
+                self.class.invoke_property(self, property)
+              end
+            end
+          end
+
+          @type_info.managed_methods.each do |method|
+            method.result_type = VmomiSupport.loaded_type(method.result_type) if method.result_type.kind_of?(String)
+            method.arguments.each do |argument|
+              argument.type = VmomiSupport.loaded_type(argument.type) if argument.type.kind_of?(String)
+            end
+            self.instance_eval do
+              define_method(method.name) do |*args|
+                if args.length != method.arguments.length
+                  raise ArgumentError, "wrong number of arguments (#{args.length} for #{method.arguments.length})"
+                end
+                self.class.invoke_method(self, method, *args)
+              end
+            end
+          end
+        end
+      end
+
+      attr_accessor :__mo_id__
+      attr_accessor :__stub__
+
+      def initialize(mo_id, stub = nil)
+        @__mo_id__ = mo_id
+        @__stub__ = stub
+      end
+
+      def to_s
+        "<[#{self.class.name}] #{@__mo_id__}>"
+      end
+
+      def to_str
+        @__mo_id__
+      end
+
+      def hash
+        __mo_id__.hash
+      end
+
+      def eql?(other)
+        @__mo_id__ == other.__mo_id__
+      end
+
+    end
+  end
+end

data/lib/ruby_vim_sdk/vmodl/method_name.rb

@@ -0,0 +1,7 @@
+module VimSdk
+  module Vmodl
+    class MethodName < String
+
+    end
+  end
+end

data/lib/ruby_vim_sdk/vmodl/property_path.rb

@@ -0,0 +1,7 @@
+module VimSdk
+  module Vmodl
+    class PropertyPath < String
+
+    end
+  end
+end

data/lib/ruby_vim_sdk/vmodl/type_name.rb

@@ -0,0 +1,7 @@
+module VimSdk
+  module Vmodl
+    class TypeName < String
+
+    end
+  end
+end

data/lib/ruby_vim_sdk/vmodl_helper.rb

@@ -0,0 +1,33 @@
+module VimSdk::VmodlHelper
+  UNDERSCORE_EXCEPTIONS = {
+    "numCPUs" => "num_cpus",
+    "importVApp" => "import_vapp"
+  }
+
+  # Borrowed mostly from activesupport
+  def camelize(word)
+    word.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+
+  # Borrowed mostly from activesupport
+  def underscore(word)
+    exception = UNDERSCORE_EXCEPTIONS[word]
+    return exception if exception
+
+    word = word.dup
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.downcase!
+    word
+  end
+
+  def vmodl_type_to_ruby(name)
+    name.split(".").collect { |part| camelize(part) }.join(".")
+  end
+
+  def vmodl_property_to_ruby(name)
+    underscore(name)
+  end
+
+  module_function :camelize, :underscore, :vmodl_type_to_ruby, :vmodl_property_to_ruby
+end

data/lib/ruby_vim_sdk/vmomi_support.rb

@@ -0,0 +1,280 @@
+module VimSdk
+
+  module VmomiSupport
+
+    @logger = Logger.new(STDOUT)
+
+    @type_info = {}
+    @wsdl_type_info = {}
+
+    @versions = {}
+    @version_ids = {}
+    @version_parents = {}
+    @version_namespaces = {}
+    @service_version_namespaces = {BASE_VERSION => XMLNS_VMODL_BASE.split(":").last}
+
+    @wsdl_types = {
+      [XMLNS_XSD, "void"] => NilClass,
+      [XMLNS_XSD, "anyType"] => Object,
+      [XMLNS_XSD, "boolean"] => SoapBoolean,
+      [XMLNS_XSD, "byte"] => SoapByte,
+      [XMLNS_XSD, "short"] => SoapShort,
+      [XMLNS_XSD, "int"] => SoapInteger,
+      [XMLNS_XSD, "long"] => SoapLong,
+      [XMLNS_XSD, "float"] => SoapFloat,
+      [XMLNS_XSD, "double"] => SoapDouble,
+      [XMLNS_XSD, "string"] => String,
+      [XMLNS_XSD, "anyURI"] => SoapURI,
+      [XMLNS_XSD, "base64Binary"] => SoapBinary,
+      [XMLNS_XSD, "dateTime"] => Time,
+      [XMLNS_VMODL_BASE, "DataObject"] => Vmodl::DataObject,
+      [XMLNS_VMODL_BASE, "ManagedObject"] => Vmodl::ManagedObject,
+      [XMLNS_VMODL_BASE, "MethodName"] => Vmodl::MethodName,
+      [XMLNS_VMODL_BASE, "PropertyPath"] => Vmodl::PropertyPath,
+      [XMLNS_VMODL_BASE, "TypeName"] => Vmodl::TypeName
+    }
+    @wsdl_names = @wsdl_types.invert
+    @wsdl_type_namespaces = Set.new
+
+    @wsdl_types.dup.each do |namespaced_name, type|
+      namespace, name = namespaced_name
+      vmodl_name = namespace == XMLNS_VMODL_BASE ? "Vmodl.#{name}" : name
+      if type != NilClass
+        @wsdl_type_namespaces << namespace
+        array_type = Class.new(TypedArray) { @item = type }
+        type.const_set(:TypedArray, array_type)
+        array_name = "ArrayOf#{VmodlHelper.camelize(name)}"
+        array_namespace = XMLNS_VMODL_BASE
+        @wsdl_types[[array_namespace, array_name]] = array_type
+        @wsdl_names[array_type] = [array_namespace, array_name]
+      end
+    end
+
+    @wsdl_names[Class] = [XMLNS_XSD, "TypeName"]
+    @wsdl_names[FalseClass] = [XMLNS_XSD, "boolean"]
+    @wsdl_names[TrueClass] = [XMLNS_XSD, "boolean"]
+    @wsdl_names[Fixnum] = [XMLNS_XSD, "int"]
+    @wsdl_names[Float] = [XMLNS_XSD, "float"]
+
+    @types = {
+      "Void"   => @wsdl_types[[XMLNS_XSD, "void"]],
+      "AnyType"=> @wsdl_types[[XMLNS_XSD, "anyType"]],
+      "String" => @wsdl_types[[XMLNS_XSD, "string"]],
+      "Bool"   => @wsdl_types[[XMLNS_XSD, "boolean"]],
+      "Boolean"=> @wsdl_types[[XMLNS_XSD, "boolean"]],
+      "Byte"   => @wsdl_types[[XMLNS_XSD, "byte"]],
+      "Short"  => @wsdl_types[[XMLNS_XSD, "short"]],
+      "Int"    => @wsdl_types[[XMLNS_XSD, "int"]],
+      "Long"   => @wsdl_types[[XMLNS_XSD, "long"]],
+      "Float"  => @wsdl_types[[XMLNS_XSD, "float"]],
+      "Double" => @wsdl_types[[XMLNS_XSD, "double"]],
+      "Vmodl.URI"        => @wsdl_types[[XMLNS_XSD, "anyURI"]],
+      "Vmodl.Binary"     => @wsdl_types[[XMLNS_XSD, "base64Binary"]],
+      "Vmodl.DateTime"   => @wsdl_types[[XMLNS_XSD, "dateTime"]],
+      "Vmodl.TypeName"   => @wsdl_types[[XMLNS_VMODL_BASE, "TypeName"]],
+      "Vmodl.MethodName" => @wsdl_types[[XMLNS_VMODL_BASE, "MethodName"]],
+      "Vmodl.DataObject" => @wsdl_types[[XMLNS_VMODL_BASE, "DataObject"]],
+      "Vmodl.ManagedObject" => @wsdl_types[[XMLNS_VMODL_BASE, "ManagedObject"]],
+      "Vmodl.PropertyPath"  => @wsdl_types[[XMLNS_VMODL_BASE, "PropertyPath"]]
+    }
+
+    @types.dup.each do |name, type|
+      if type != NilClass
+        array_type = type.const_get(:TypedArray)
+        array_name = "#{name}[]"
+        @types[array_name] = array_type
+      end
+    end
+
+    class << self
+
+      attr_reader :logger
+
+      def add_version(version, ns, version_id, is_legacy, service_ns)
+        unless @version_parents.has_key?(version)
+          @version_namespaces[version] = ns
+          @versions["#{ns}/#{version_id}"] = version unless version_id.empty?
+          @versions[ns] = version if is_legacy || ns.empty?
+          @version_ids[version] = version_id
+          service_ns = ns if service_ns.nil?
+          @service_version_namespaces[version] = service_ns
+          @version_parents[version] = {}
+        end
+      end
+
+      def add_version_parent(version, parent)
+        @version_parents[version][parent] = true
+      end
+
+      def create_data_type(*args)
+        add_type(DataType.new(*args))
+      end
+
+      def create_enum_type(*args)
+        add_type(EnumType.new(*args))
+      end
+
+      def create_managed_type(*args)
+        add_type(ManagedType.new(*args))
+      end
+
+      def version_namespace(version)
+        namespace = @version_namespaces[version]
+        version_id = @version_ids[version]
+
+        if version_id
+          "#{namespace}/#{version_id}"
+        else
+          namespace
+        end
+      end
+
+      def add_type(type)
+        @type_info[type.name] = type
+        namespace = wsdl_namespace(type.version)
+        @wsdl_type_namespaces << namespace
+
+        if @wsdl_type_info.has_key?([namespace, type.wsdl_name])
+          raise "Duplicate wsdl type #{type.wsdl_name} (already in typemap)" if @wsdl_type_info[namespace, type.wsdl_name] != type
+        else
+          @wsdl_type_info[[namespace, type.wsdl_name]] = type
+        end
+      end
+
+      def wsdl_namespace(version)
+        "urn:#{@service_version_namespaces[version]}"
+      end
+
+      def is_child_version(a, b)
+        a == b || (@version_parents[a] && @version_parents[a][b])
+      end
+
+      def compatible_type(type, version)
+        if type.respond_to?(:version)
+          type = type.superclass until is_child_version(version, type.version)
+        end
+        type
+      end
+
+      def guess_wsdl_type(name)
+        @wsdl_type_namespaces.each do |namespace|
+          type = @wsdl_types[[namespace, name]]
+          return type if type
+        end
+        raise "Couldn't guess type for #{name}"
+      end
+
+      def load_types
+        @type_info.each_value do |type|
+          load_type(type) unless @types.has_key?(type.name)
+        end
+
+        @types.each_value do |clazz|
+          type_info = clazz.instance_eval { @type_info }
+          if type_info
+            if type_info.kind_of?(DataType)
+              clazz.finalize
+            elsif type_info.class == EnumType
+              type_info.values.each do |value|
+                clazz.const_set(VmodlHelper.underscore(value).upcase, value)
+              end
+            end
+          end
+        end
+      end
+
+      def load_type(type)
+        if type.respond_to?(:parent)
+          parent = type.parent
+        else
+          parent = nil
+        end
+
+        unless parent.nil? || @types.has_key?(type.parent)
+          load_type(@type_info[type.parent])
+        end
+
+        names = type.name.split(".")
+
+        current_name = ""
+        current_module = VimSdk
+
+        names[0..-2].each do |name|
+          if current_name.empty?
+            current_name = name
+          else
+            current_name = "#{current_name}.#{name}"
+          end
+
+          module_name = name.to_sym
+          unless current_module.const_defined?(module_name)
+            if @type_info.has_key?(current_name)
+              load_type(@type_info[current_name])
+            else
+              current_module.const_set(module_name, Module.new)
+            end
+          end
+          current_module = current_module.const_get(module_name)
+        end
+
+        if type.kind_of?(EnumType)
+          super_class = SoapEnum
+        else
+          super_class = @types[type.parent]
+        end
+
+        clazz = Class.new(super_class) do
+          @type_info = type
+        end
+        current_module.const_set(names.last, clazz)
+
+        array_clazz = Class.new(TypedArray) do
+          @item = clazz
+        end
+        clazz.const_set(:TypedArray, array_clazz)
+
+        @types[type.name] = clazz
+        @types["#{type.name}[]"] = array_clazz
+        @wsdl_types[[wsdl_namespace(type.version), type.wsdl_name]] = clazz
+        @wsdl_types[[wsdl_namespace(type.version), "ArrayOf#{type.wsdl_name}"]] = array_clazz
+      end
+
+      def loaded_type(type_name)
+        raise "Can't find #{type_name}" unless @types[type_name]
+        @types[type_name]
+      end
+
+      def loaded_wsdl_type(namespace, name)
+        raise "Can't find #{namespace}/#{name}" unless @wsdl_types[[namespace, name]]
+        @wsdl_types[[namespace, name]]
+      end
+
+      def qualified_wsdl_name(type)
+        result = @wsdl_names[type]
+        if result
+          result
+        else
+          if type.ancestors.include?(Array)
+            type_info = type.class.type_info
+            [type_info.version, "ArrayOf#{type_info.wsdl_name}"]
+          else
+            namespace = wsdl_namespace(type.version)
+            [namespace, type.type_info.wsdl_name]
+          end
+        end
+      end
+
+      def wsdl_name(type)
+        qualified_wsdl_name(type).last
+      end
+    end
+
+    require "ruby_vim_sdk/missing_types"
+    require "ruby_vim_sdk/core_types"
+    require "ruby_vim_sdk/server_objects"
+
+    load_types
+  end
+
+  DYNAMIC_TYPES = Set.new([Class, Vmodl::TypeName, Vmodl::MethodName, Vmodl::PropertyPath])
+end