virtualbox-ws 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b65ace3ebbb598bf587a6776bd4e4e309639103c
-  data.tar.gz: 318b9c8467b43c6b6de9e5e4fb056b6721d9bf80
+  metadata.gz: 14809e7c2980b37be12543d76529d87b45434fe9
+  data.tar.gz: 9f934f1477fe90ef9010247a64eec2695443adea
 SHA512:
-  metadata.gz: aa1237ee6dfd4b17e37b3f681dacd5238397501538438fd30d02092fc6f4fc83e900e164f0cbad6fdd07631a92d3614093f20e88ffdd8888d4376219d9d1e057
-  data.tar.gz: 99d997c9b0e8cf392c3b91f88c88a721b02e1690052f5c8d2fb75634f445f7b0ff9d260efba5eb8e94bbfcb4252e48e0f1c87d0340b2f4e7f304f44bca5a9704
+  metadata.gz: cdf1b1d99b76fca4015a7005f848eef358d9a26fc2877b0f4b1ac9a952b508e6099cc433a93e5bfb22d6d908333b9a097baea278c70855a46528ca4d479b2684
+  data.tar.gz: 6c22b4037d12e6320f6d1b18aea8b5b57da6ae425a0d97c77361687faef717ca0c60c3dbda91cd3a89943c4a34364ff4c20d3ec9aabde63a4d999b2a6a59687e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    virtualbox-ws (0.0.4)
+    virtualbox-ws (0.0.5)
       require_all
       savon
 

data/README.md

@@ -89,4 +89,64 @@ irb> virtual_box.register_machine(:machine => machine)
 ```
 irb> machine.launch_vm_process(:session => web_session.get_session_object)
  => #<VBox::Progress:0x00000005934040 @ref="47efe040fcc25df7-000000000000001f"> 
+```
+
+Example
+-------
+
+This is an example of creating a VM that is ready for Ubuntu x64 to be installed on it
+
+```ruby
+require 'virtualbox-ws'
+
+# Connect to the web service and logon
+# Get session object for future use
+web_session = VBox::WebsessionManager.new
+virtual_box = web_session.logon
+session = web_session.get_session_object
+
+# Create an Ubuntu x64 VM
+machine = virtual_box.create_machine(:name => 'machine_1112678', :os_type_id => 'Ubuntu_64')
+virtual_box.register_machine(:machine => machine)
+
+# Create a 50GB hard disk
+hard_disk = virtual_box.create_hard_disk(:format => 'vdi', :location => machine.settings_file_path.gsub('vbox', 'vdi'))
+hard_disk.create_base_storage(:logical_size => 50000000000)
+
+# Lock the VM for editing and obtain a mutable instance
+machine.lock_machine(:session => session)
+mutable = session.machine
+
+# Set some common properties
+mutable.cpu_count = 4
+mutable.memory_size = 1024
+mutable.rtc_use_utc = true
+mutable.vram_size = 16
+mutable.accelerate_3d_enabled = true
+mutable.audio_adapter.enabled = true
+
+# Add the hard disk
+mutable.add_storage_controller(:name => 'SATA1', :connection_type => 'SATA')
+mutable.attach_device(:name => 'SATA1', :type => 'HardDisk', :medium => hard_disk)
+
+# Add an ISO image
+mutable.add_storage_controller(:name => 'IDE1', :connection_type => 'IDE')
+iso = virtual_box.open_medium(:location => '/home/ay/Downloads/ubuntu-12.04.3-server-amd64.iso', :device_type => 'DVD')
+mutable.attach_device(:name => 'IDE1', :type => 'DVD', :medium => iso)
+
+# Set network adapter to bridged interface
+network_adapter = mutable.get_network_adapter(:slot => 0)
+network_adapter.attachment_type = 'Bridged'
+network_adapter.bridged_interface = virtual_box.host.network_interfaces.first.name
+
+# Enable USB
+mutable.add_usb_controller(:name => 'USB1', :type => 'OHCI')
+mutable.add_usb_controller(:name => 'USB2', :type => 'EHCI')
+
+# Save changes and unlock the VM
+mutable.save_settings
+session.unlock_machine
+
+# Start the VM
+machine.launch_vm_process(:session => session)
 ```

data/lib/core_ext/string.rb

@@ -1,6 +1,25 @@
 class String
   def to_a
-    self.split
+    [] << self
+  end
+
+  def to_num
+    if !self.match(/^[0-9]+$/).nil?
+      Integer(self)
+    elsif !self.match(/^[0-9]+\.[0-9]+$/).nil?
+      Float(self)
+    else
+      self
+    end
+  end
+
+  def vbox_class
+    VBox::ManagedObjectRef.new(self).get_interface_name
+  end
+
+  def to_vbox_object(cls)
+    return self if cls.nil?
+    VBox.const_get(cls[1..-1]).new(self)
   end
 
   def to_underscore

data/lib/virtualbox/base.rb

@@ -18,11 +18,11 @@ module VBox
     end
 
     def self.starts_with_acronym
-      define_method(:starts_with_acronym) {}
+      define_method(:acronym) {}
     end
 
     def self.soap_method(method_name, modifier=nil)
-      is_acronym_part = defined?(starts_with_acronym) ? '_' : ''
+      is_acronym_part = self.name.split('::').last.match(/^[A-Z]{2,}/).nil? ? '_' : ''
       modifier_part = modifier.nil? ? '' : modifier + '_'
       "i#{is_acronym_part}#{class_name}_#{modifier_part}#{method_name}".to_sym
     end
@@ -39,54 +39,24 @@ module VBox
       self.class.class_name
     end
 
-    def integerize(value)
-      if value.is_a?(Array)
-        value.map do |item|
-          begin
-            Integer(item)
-          rescue ArgumentError
-            item
-          end
-        end
-      else
-        begin
-          Integer(value)
-        rescue ArgumentError
-          value
-        end
-      end
-    end
-
-    def classify(result, force_array=false)
+    def process_result(result, force_array=false)
       if force_array
         return [] if result.nil?
         result = result.to_a
-
-        # Will assume here that in case of force_array all the items
-        # in the array are objects of the same class
-        val = result[0]
+        vbox_class = result.first.vbox_class
+        result.map { |item| item.to_vbox_object(vbox_class) }
       else
-        val = result
-      end
-
-      # If the result is not a string return it immediately
-      return integerize(result) unless val.is_a?(String)
-
-      # Check for a match
-      return integerize(result) if val.match(/^[0-9a-f]{16}-[0-9a-f]{16}$/).nil?
-
-      # Get VirtualBox interface name
-      class_str = ManagedObjectRef.new(val).get_interface_name
-
-      # ManagedObjectRef.get_interface_name returns nil
-      # for inexisting object reference
-      if class_str.nil?
-        result
-      else
-        if force_array
-          result.to_a.map { |item| VBox.const_get(class_str[1..-1]).new(item) }
+        return if result.nil?
+        if result.is_a?(Array)
+          result.map { |item| process_result(item) }
+        elsif result.is_a?(Hash)
+          result.update(result) { |_, value| process_result(value) }
+        elsif !!result == result
+          result
+        elsif !result.match(/^[0-9a-f]{16}-[0-9a-f]{16}$/).nil?
+          result.to_vbox_object(result.vbox_class)
         else
-          VBox.const_get(class_str[1..-1]).new(result)
+          result.to_num
         end
       end
     end
@@ -95,21 +65,26 @@ module VBox
       force_array = options[:force_array]
       force_tag = options[:force_tag]
 
-      # A special case for VirtualBox methods that have lowercase 'v' in IPv6
       if name.to_s.start_with?('ipv6') || name.to_s.include?('advertise_default_ipv6_route_enabled')
-        name = name.to_s.gsub('ipv6', 'i_pv6').to_sym
+        native_name = name.to_s.gsub('ipv6', 'i_pv6').to_sym
+      elsif name.to_s.include?('_3d_')
+        native_name = name.to_s.gsub('_3d_', '3_d_').to_sym
+      elsif name.to_s.include?('_2d_')
+        native_name = name.to_s.gsub('_2d_', '2_d_').to_sym
+      else
+        native_name = name
       end
 
       define_method(name) do
-        result = WebService.send_request(soap_method(name, 'get'), _this)
+        result = WebService.send_request(soap_method(native_name, 'get'), _this)
         process_result(result, force_array)
       end
 
       define_method("#{name}=") do |value|
-        soap_message = {force_tag ? force_tag : name => value}
-        result = WebService.send_request(soap_method(name, 'set'), _this.merge(soap_message))
+        soap_message = {force_tag ? force_tag : native_name => value}
+        result = WebService.send_request(soap_method(native_name, 'set'), _this.merge(soap_message))
         process_result(result)
-      end if WebService.operations.include?(soap_method(name, 'set'))
+      end if WebService.operations.include?(soap_method(native_name, 'set'))
     end
 
     def self.vb_method(name, options={})
@@ -122,19 +97,5 @@ module VBox
         process_result(result, force_array)
       end
     end
-
-    def process_result(result, force_array=false)
-      if force_array
-        classify(result, true)
-      else
-        if result.is_a?(Array)
-          result.map do |item|
-            item.is_a?(Hash) ? item.update(item) { |_, value| classify(value) } : classify(item)
-          end
-        else
-          classify(result)
-        end
-      end
-    end
   end
 end

data/lib/virtualbox/classes/dhcp_server.rb

@@ -1,6 +1,8 @@
 module VBox
   class DHCPServer < Base
 
+    starts_with_acronym
+
     vb_attr :event_source
     vb_attr :enabled
     vb_attr :ip_address

data/lib/virtualbox/classes/events/cpu_changed_event.rb

@@ -1,6 +1,8 @@
 module VBox
   class CPUChangedEvent < Event
 
+    starts_with_acronym
+
     vb_attr :cpu
     vb_attr :add
 

data/lib/virtualbox/classes/events/cpu_execution_cap_changed_event.rb

@@ -1,6 +1,8 @@
 module VBox
   class CPUExecutionCapChangedEvent < Event
 
+    starts_with_acronym
+
     vb_attr :execution_cap
 
   end

data/lib/virtualbox/classes/events/nat_redirect_event.rb

@@ -1,6 +1,8 @@
 module VBox
   class NATRedirectEvent < MachineEvent
 
+    starts_with_acronym
+
     vb_attr :slot
     vb_attr :remove
     vb_attr :name

data/lib/virtualbox/classes/events/usb_controller_changed_event.rb

@@ -1,4 +1,7 @@
 module VBox
   class USBControllerChangedEvent < Event
+
+    starts_with_acronym
+
   end
 end

data/lib/virtualbox/classes/events/usb_device_state_changed_event.rb

@@ -1,6 +1,8 @@
 module VBox
   class USBDeviceStateChangedEvent < Event
 
+    starts_with_acronym
+
     vb_attr :device
     vb_attr :attached
     vb_attr :error

data/lib/virtualbox/classes/events/vrde_server_changed_event.rb

@@ -1,4 +1,7 @@
 module VBox
   class VRDEServerChangedEvent < Event
+
+    starts_with_acronym
+
   end
 end

data/lib/virtualbox/classes/events/vrde_server_info_changed_event.rb

@@ -1,4 +1,7 @@
 module VBox
   class VRDEServerInfoChangedEvent < Event
+
+    starts_with_acronym
+
   end
 end

data/lib/virtualbox/classes/machine.rb

@@ -84,7 +84,7 @@ module VBox
     vb_attr :usb_proxy_available
 
     vb_method :add_storage_controller
-    vb_method :add_udb_controller
+    vb_method :add_usb_controller
     vb_method :attach_device
     vb_method :attach_device_without_medium
     vb_method :attach_host_pci_device

data/lib/virtualbox/classes/nat_engine.rb

@@ -1,6 +1,8 @@
 module VBox
   class NATEngine < Base
 
+    starts_with_acronym
+
     vb_attr :network
     vb_attr :host_ip
     vb_attr :tftp_prefix, :force_tag => 'TFTPPrefix'

data/lib/virtualbox/classes/nat_network.rb

@@ -1,6 +1,8 @@
 module VBox
   class NATNetwork < Base
 
+    starts_with_acronym
+
     vb_attr :network_name
     vb_attr :enabled
     vb_attr :network

data/lib/virtualbox/classes/usb_controller.rb

@@ -1,6 +1,8 @@
 module VBox
   class USBController < Base
 
+    starts_with_acronym
+
     vb_attr :name
     vb_attr :type
     vb_attr :usb_standard

data/lib/virtualbox/classes/usb_device.rb

@@ -1,6 +1,8 @@
 module VBox
   class USBDevice < Base
 
+    starts_with_acronym
+
     vb_attr :id
     vb_attr :vendor_id
     vb_attr :product_id

data/lib/virtualbox/classes/usb_device_filter.rb

@@ -1,6 +1,8 @@
 module VBox
   class USBDeviceFilter < Base
 
+    starts_with_acronym
+
     vb_attr :name
     vb_attr :active
     vb_attr :vendor_id

data/lib/virtualbox/classes/usb_device_filters.rb

@@ -1,6 +1,8 @@
 module VBox
   class USBDeviceFilters < Base
 
+    starts_with_acronym
+
     vb_attr :device_filters
 
     vb_method :create_device_filter

data/lib/virtualbox/classes/vfs_explorer.rb

@@ -1,6 +1,8 @@
 module VBox
   class VFSExplorer < Base
 
+    starts_with_acronym
+
     vb_attr :path
     vb_attr :type
 

data/lib/virtualbox/classes/vrde_server.rb

@@ -1,6 +1,8 @@
 module VBox
   class VRDEServer < Base
 
+    starts_with_acronym
+
     vb_attr :enabled
     vb_attr :auth_type
     vb_attr :auth_timeout

data/lib/virtualbox/classes/vrde_server_info.rb

@@ -1,6 +1,8 @@
 module VBox
   class VRDEServerInfo < Base
 
+    starts_with_acronym
+
     vb_attr :active
     vb_attr :port
     vb_attr :number_of_clients

data/lib/virtualbox/classes/websession_manager.rb

@@ -18,9 +18,8 @@ module VBox
     def logon
       args = Hash[:username => WebService.configuration.vboxweb_user,
                   :password => WebService.configuration.vboxweb_pass]
-      key = WebService.send_request(:i_websession_manager_logon, args)
-      @ref = key
-      VirtualBox.new(key)
+      @ref = WebService.send_request(:i_websession_manager_logon, args)
+      VirtualBox.new(@ref)
     end
 
     def logoff

data/lib/virtualbox/configuration.rb

@@ -1,35 +1,33 @@
 require 'logger'
 
 
-module VBox
-  module WebService
-    class Configuration
+module VBox::WebService
+  class Configuration
 
-      attr_accessor :vboxweb_host, :vboxweb_port, :vboxweb_user, :vboxweb_pass, :log_level, :logger
+    attr_accessor :vboxweb_host, :vboxweb_port, :vboxweb_user, :vboxweb_pass, :log_level, :logger
 
-      def initialize
-        @vboxweb_host = ENV['VBOXWEB_HOST'] || '127.0.0.1'
-        @vboxweb_port = ENV['VBOXWEB_PORT'] || '18083'
-        @vboxweb_user = ENV['VBOXWEB_USER']
-        @vboxweb_pass = ENV['VBOXWEB_PASS']
-        @log_level = ENV['VBOXWEB_LOGGING'] || 'ERROR'
-        @logger = Logger.new(STDOUT)
-        @logger.level = Logger.const_get(@log_level)
-      end
-
-      def log_level=(log_level)
-        @log_level = ['ERROR', 'INFO', 'DEBUG'].include?(log_level) ? log_level : 'ERROR'
-        @logger.level = Logger.const_get(@log_level)
-      end
+    def initialize
+      @vboxweb_host = ENV['VBOXWEB_HOST'] || '127.0.0.1'
+      @vboxweb_port = ENV['VBOXWEB_PORT'] || '18083'
+      @vboxweb_user = ENV['VBOXWEB_USER']
+      @vboxweb_pass = ENV['VBOXWEB_PASS']
+      @log_level = ENV['VBOXWEB_LOGGING'] || 'ERROR'
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger.const_get(@log_level)
     end
 
-    class << self
-      attr_accessor :configuration
+    def log_level=(log_level)
+      @log_level = ['ERROR', 'INFO', 'DEBUG'].include?(log_level) ? log_level : 'ERROR'
+      @logger.level = Logger.const_get(@log_level)
     end
+  end
 
-    def self.configure
-      self.configuration ||= Configuration.new
-      yield configuration
-    end
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield configuration
   end
 end

data/lib/virtualbox/exceptions.rb

@@ -1,28 +1,26 @@
-module VBox
-  module WebService
-    class Error < StandardError; end
+module VBox::WebService
+  class Error < StandardError; end
 
-    class ConnectionError < Error
-      def initialize(endpoint, message)
-        @endpoint = endpoint
-        @message = message
-      end
+  class ConnectionError < Error
+    def initialize(endpoint, message)
+      @endpoint = endpoint
+      @message = message
+    end
 
-      def to_s
-        "Could not connect to VirtualBox SOAP Web Service at #{@endpoint}. #{@message}"
-      end
+    def to_s
+      "Could not connect to VirtualBox SOAP Web Service at #{@endpoint}. #{@message}"
     end
+  end
 
-    class NoWebServiceError < ConnectionError
-      def initialize(endpoint, message = 'No VirtualBox SOAP service found')
-        super
-      end
+  class NoWebServiceError < ConnectionError
+    def initialize(endpoint, message = 'No VirtualBox SOAP service found')
+      super
     end
+  end
 
-    class UnknownError < Error; end
+  class UnknownError < Error; end
 
-    class ArgumentError < Error; end
+  class ArgumentError < Error; end
 
-    class NotImplementedError < Error; end
-  end
+  class NotImplementedError < Error; end
 end

data/lib/virtualbox/version.rb

@@ -1,3 +1,3 @@
 module VBox
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/lib/virtualbox/webservice.rb

@@ -1,104 +1,99 @@
 require 'savon'
 
 
-module VBox
-  module WebService
-    class << self
-      def connect
-        # Initialize configuration here in case if it was not initialized in client
-        self.configuration ||= Configuration.new
+module VBox::WebService
+  class << self
+    def connect
+      # Initialize configuration here in case if it was not initialized in client
+      self.configuration ||= Configuration.new
 
-        host = configuration.vboxweb_host
-        port = configuration.vboxweb_port
-        log_level = configuration.log_level
-        @logger = configuration.logger
+      host = configuration.vboxweb_host
+      port = configuration.vboxweb_port
+      log_level = configuration.log_level
+      @logger = configuration.logger
 
-        # Savon XML logging
-        savon_debug = log_level == 'DEBUG'
+      # Savon XML logging
+      savon_debug = log_level == 'DEBUG'
 
-        endpoint = "http://#{host}:#{port}"
-        wsdl = endpoint + '/?wsdl'
-        @logger.info("VirtualBox SOAP web service endpoint: #{endpoint}")
-        @logger.info("VirtualBox SOAP web service WSDL: #{wsdl}")
+      endpoint = "http://#{host}:#{port}"
+      wsdl = endpoint + '/?wsdl'
+      @logger.info("VirtualBox SOAP web service endpoint: #{endpoint}")
+      @logger.info("VirtualBox SOAP web service WSDL: #{wsdl}")
 
-        # Create web service connection
-        @conn = Savon.client(:wsdl => wsdl, :endpoint => endpoint, :log => savon_debug, :pretty_print_xml => savon_debug)
+      # Create web service connection
+      @conn = Savon.client(:wsdl => wsdl, :endpoint => endpoint, :log => savon_debug, :pretty_print_xml => savon_debug)
 
-        # Check if we really connected to a VirtualBox SOAP web service
-        unless operations.include?(:i_websession_manager_logon)
-          @logger.fatal("Could not connect to VirtualBox SOAP Web Service at #{endpoint}. No VirtualBox SOAP service found")
-          raise NoWebServiceError.new(endpoint)
-        end
+      # Check if we really connected to a VirtualBox SOAP web service
+      unless operations.include?(:i_websession_manager_logon)
+        @logger.fatal("Could not connect to VirtualBox SOAP Web Service at #{endpoint}. No VirtualBox SOAP service found")
+        raise NoWebServiceError.new(endpoint)
       end
+    end
 
-      def operations
-        @conn.operations
-      end
+    def operations
+      @conn.operations
+    end
 
-      def send_request(soap_method, soap_message)
-        @logger.info("Request operation: #{soap_method}")
+    def send_request(soap_method, soap_message)
+      @logger.info("Request operation: #{soap_method}")
 
-        # Filter out the password string
-        log_soap_message = soap_message.clone
-        if soap_method == :i_websession_manager_logon
-          log_soap_message[:password] = '<filtered>' if log_soap_message.has_key?(:password)
-        end
+      # Filter out the password string
+      log_soap_message = soap_message.clone
+      if soap_method == :i_websession_manager_logon
+        log_soap_message[:password] = '<filtered>' if log_soap_message.has_key?(:password)
+      end
 
-        @logger.info("Request message: #{log_soap_message}")
+      @logger.info("Request message: #{log_soap_message}")
 
-        begin
-          response = @conn.call(soap_method, :message => soap_message)
-        rescue Savon::SOAPFault => e
-          @logger.debug(e.message)
-          parse_soap_fault(e.message)
-        rescue Savon::HTTPError => e
-          @logger.error(e.message)
-          raise
-        end
-        parse_response(response)
+      begin
+        response = @conn.call(soap_method, :message => soap_message)
+      rescue Savon::SOAPFault => e
+        @logger.debug(e.message)
+        parse_soap_fault(e.message)
+      rescue Savon::HTTPError => e
+        @logger.error(e.message)
+        raise
       end
+      parse_response(response)
+    end
 
-      def parse_soap_fault(message)
-        error_code = message.match(/0x[[:xdigit:]]+/)
-        if error_code.nil?
-          if message.match(/Validation constraint violation: data type mismatch  in element <\S+>/).nil?
-            raise UnknownError, message
-          else
-            argument = message.match(/<\S+>/).to_s[1..-2].to_underscore
-            raise ArgumentError, "Argument #{argument} is of invalid data type"
-          end
+    def parse_soap_fault(message)
+      error_code = message.match(/0x[[:xdigit:]]+/)
+      if error_code.nil?
+        if message.match(/Validation constraint violation: data type mismatch  in element <\S+>/).nil?
+          raise UnknownError, message
         else
-          error_message = message.split("(SOAP-ENV:Client) VirtualBox error: rc=#{error_code} ")[1].split(" (#{error_code})")[0]
-          raise UnknownError, message if error_message.nil?
-          argument = error_message.match(/\sa[A-Z]\S+\s/)
-          if argument.nil?
-            if error_message.match(/Method \S+ is not implemented/).nil?
-              raise Error, error_message
-            else
-              raise NotImplementedError, error_message
-            end
+          argument = message.match(/<\S+>/).to_s[1..-2].to_underscore
+          raise ArgumentError, "Argument #{argument} is of invalid data type"
+        end
+      else
+        error_message = message.split("(SOAP-ENV:Client) VirtualBox error: rc=#{error_code} ")[1].split(" (#{error_code})")[0]
+        raise UnknownError, message if error_message.nil?
+        argument = error_message.match(/\sa[A-Z]\S+\s/)
+        if argument.nil?
+          if error_message.match(/Method \S+ is not implemented/).nil?
+            raise Error, error_message
           else
-            error_message.gsub!(argument.to_s.strip, argument.to_s.strip[1..-1].to_underscore).
-                          gsub!(/\s\(must be .*\)/, '')
-            raise ArgumentError, error_message
+            raise NotImplementedError, error_message
           end
+        else
+          error_message.gsub!(argument.to_s.strip, argument.to_s.strip[1..-1].to_underscore).
+                        gsub!(/\s\(must be .*\)/, '')
+          raise ArgumentError, error_message
         end
       end
+    end
 
-      def parse_response(response)
-        @logger.info("Response: #{response.body}")
-        response_struct = response.body[response.body.keys[0]]
-        if response_struct.nil?
-          nil
-        else
-          if response_struct.keys.length > 1
-            returnval = response_struct[:returnval].nil? || response_struct[:returnval]
-            response_struct.delete(:returnval)
-            [returnval, response_struct]
-          else
-            response_struct[:returnval]
-          end
-        end
+    def parse_response(response)
+      @logger.info("Response: #{response.body}")
+      response_struct = response.body[response.body.keys[0]]
+      return if response_struct.nil?
+      if response_struct.keys.length > 1
+        returnval = response_struct[:returnval].nil? || response_struct[:returnval]
+        response_struct.delete(:returnval)
+        [returnval, response_struct]
+      else
+        response_struct[:returnval]
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: virtualbox-ws
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Andriy Yurchuk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-06 00:00:00.000000000 Z
+date: 2013-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: require_all