virtualbox 0.8.6 → 0.9.0

data/Rakefile

@@ -1,12 +1,14 @@
+require "rbconfig"
 require "rubygems"
 require "bundler/setup"
 require "rake/testtask"
 
 require "cucumber"
 require "cucumber/rake/task"
-require "yard"
 Bundler::GemHelper.install_tasks
 
+include Rake::DSL
+
 task :default => "test:units"
 
 namespace :test do
@@ -31,7 +33,11 @@ namespace :test do
   rescue LoadError; end
 end
 
-YARD::Rake::YardocTask.new do |t|
-  t.options = ['--main', 'Readme.md', '--markup', 'markdown']
-  t.options += ['--title', 'VirtualBox Ruby Library Documentation']
-end
+if RbConfig::CONFIG["host_os"] !~ /^darwin11/
+  # YARD is broken on Lion
+  require "yard"
+  YARD::Rake::YardocTask.new do |t|
+    t.options = ['--main', 'Readme.md', '--markup', 'markdown']
+    t.options += ['--title', 'VirtualBox Ruby Library Documentation']
+  end
+end

data/TODO.md

@@ -0,0 +1,7 @@
+# VirtualBox 4.1 TODOs:
+
+* NetworkAdapter uses `network_adapter_counter` which is no longer supported.
+  It needs to use `get_max_network_adapters` instead.
+* NetworkAdapter `attach_to_*` methods are gone. Use `attachment_type` property
+  instead.
+* Appliance import must supply import options

data/lib/virtualbox.rb

@@ -1,11 +1,37 @@
-# Load the glob loader, which will handle the loading of all the other files
-libdir = File.join(File.dirname(__FILE__), "virtualbox")
-require File.expand_path("ext/glob_loader", libdir)
+require 'virtualbox/version'
 
-# Load them up
-VirtualBox::GlobLoader.glob_require(libdir, %w{ext/logger ext/platform ext/subclass_listing ext/byte_normalizer com abstract_model medium})
-
-# Setup the top-level module methods
 module VirtualBox
-  extend Version
+  autoload :AbstractModel, 'virtualbox/abstract_model'
+  autoload :Appliance, 'virtualbox/appliance'
+  autoload :AudioAdapter, 'virtualbox/audio_adapter'
+  autoload :BIOS, 'virtualbox/bios'
+  autoload :COM, 'virtualbox/com'
+  autoload :CPU, 'virtualbox/cpu'
+  autoload :DHCPServer, 'virtualbox/dhcp_server'
+  autoload :DVD, 'virtualbox/dvd'
+  autoload :ExtraData, 'virtualbox/extra_data'
+  autoload :Exceptions, 'virtualbox/exceptions'
+  autoload :ForwardedPort, 'virtualbox/forwarded_port'
+  autoload :Global, 'virtualbox/global'
+  autoload :HardDrive, 'virtualbox/hard_drive'
+  autoload :Host, 'virtualbox/host'
+  autoload :HostNetworkInterface, 'virtualbox/host_network_interface'
+  autoload :HWVirtualization, 'virtualbox/hw_virtualization'
+  autoload :Lib, 'virtualbox/lib'
+  autoload :Media, 'virtualbox/media'
+  autoload :Medium, 'virtualbox/medium'
+  autoload :MediumAttachment, 'virtualbox/medium_attachment'
+  autoload :NATEngine, 'virtualbox/nat_engine'
+  autoload :NATForwardedPort, 'virtualbox/nat_forwarded_port'
+  autoload :NetworkAdapter, 'virtualbox/network_adapter'
+  autoload :Proxies, 'virtualbox/proxies'
+  autoload :SharedFolder, 'virtualbox/shared_folder'
+  autoload :Snapshot, 'virtualbox/snapshot'
+  autoload :StorageController, 'virtualbox/storage_controller'
+  autoload :SystemProperties, 'virtualbox/system_properties'
+  autoload :USBController, 'virtualbox/usb_controller'
+  autoload :USBDeviceFilter, 'virtualbox/usb_device_filter'
+  autoload :VirtualSystemDescription, 'virtualbox/virtual_system_description'
+  autoload :VM, 'virtualbox/vm'
+  autoload :VRDEServer, 'virtualbox/vrde_server'
 end

data/lib/virtualbox/abstract_model.rb

@@ -1,10 +1,9 @@
-['abstract_model/attributable',
-  'abstract_model/interface_attributes',
-  'abstract_model/dirty',
-  'abstract_model/relatable',
-  'abstract_model/validatable'].each do |lib|
-  require File.expand_path(lib, File.dirname(__FILE__))
-end
+require 'virtualbox/abstract_model/attributable'
+require 'virtualbox/abstract_model/interface_attributes'
+require 'virtualbox/abstract_model/dirty'
+require 'virtualbox/abstract_model/relatable'
+require 'virtualbox/abstract_model/validatable'
+require 'virtualbox/ext/logger'
 
 module VirtualBox
   # AbstractModel is the base class used for most of virtualbox's classes.
@@ -218,7 +217,7 @@ module VirtualBox
     # Overwrites {Attributable#write_attribute} to set the dirty state of
     # the written attribute. See {Dirty#set_dirty!} as well.
     def write_attribute(name, value)
-      set_dirty!(name, read_attribute(name), value) unless lazy_attribute?(name) && !loaded_attribute?(name)
+      set_dirty!(name, read_attribute(name), value)
       super
     end
 

data/lib/virtualbox/abstract_model/attributable.rb

@@ -153,7 +153,7 @@ module VirtualBox
         #   a custom populate key to use for {Attributable#populate_attributes}
         def attribute(name, options = {})
           name = name.to_sym
-          attributes[name] = defined?(@__attribute_scope) ? @__attribute_scope : {}
+          attributes[name] = defined?(@__attribute_scope) ? @__attribute_scope.dup : {}
           attributes[name].merge!(options)
 
           # Create the method for reading this attribute
@@ -225,6 +225,20 @@ module VirtualBox
         end
       end
 
+      # Reset attributes which basically causes all lazy attributes to
+      # be reset. This forces them to reload when they're accessed.
+      def reset_attributes
+        # Find the lazy attributes
+        to_delete = []
+        attributes.each do |name, value|
+          to_delete << name if lazy_attribute?(name)
+        end
+
+        # Delete them!
+        to_delete.each { |key| attributes.delete(key) }
+      end
+
+
       # Writes an attribute. This method ignores the `readonly` option
       # on attribute definitions. This method is mostly meant for
       # internal use on setting attributes (including readonly
@@ -245,7 +259,7 @@ module VirtualBox
           assert_version_match(options[:version], VirtualBox.version) if options[:version]
           if lazy_attribute?(name) && !loaded_attribute?(name)
             # Load the lazy attribute
-            load_attribute(name.to_sym)
+            attributes[name] = load_attribute(name.to_sym)
           end
 
           if attributes[name].nil?

data/lib/virtualbox/abstract_model/interface_attributes.rb

@@ -19,6 +19,15 @@ module VirtualBox
       # @param [Symbol] key The attribute to load
       # @param [VirtualBox::COM::Interface] interface The interface
       def load_interface_attribute(key, interface)
+        value = read_interface_attribute(key, interface)
+        return if !value
+
+        write_attribute(key, value)
+      end
+
+      # Reads a single interface attribute without loading it into the
+      # given key.
+      def read_interface_attribute(key, interface)
         # Return unless we have a valid interface attribute with a getter
         return unless has_attribute?(key)
         options = self.class.attributes[key.to_sym]
@@ -29,7 +38,7 @@ module VirtualBox
 
         # Convert the getter to a proc and call it
         getter = spec_to_proc(getter)
-        write_attribute(key, getter.call(self, interface, key))
+        getter.call(self, interface, key)
       end
 
       # Saves all the attributes which have an interface setter.

data/lib/virtualbox/abstract_model/relatable.rb

@@ -182,6 +182,17 @@ module VirtualBox
         end
       end
 
+      # Resets a relationship. This resets all lazy relationships.
+      def reset_relationships
+        to_delete = []
+        relationship_data.each do |key, value|
+          to_delete << key if lazy_relationship?(key)
+        end
+
+        # Delete them!
+        to_delete.each { |key| relationship_data.delete(key) }
+      end
+
       # Reads a relationship. This is equivalent to {Attributable#read_attribute},
       # but for relationships.
       def read_relationship(name)

data/lib/virtualbox/appliance.rb

@@ -41,7 +41,7 @@ module VirtualBox
     # it will be yielded every percent that the operation progresses. This can be
     # done to check the progress of the import.
     def import(&block)
-      interface.import_machines.wait(&block)
+      interface.import_machines([:keep_all_macs, :keep_all_nats]).wait(&block)
     end
 
     # Exports the machines to the given path. If a block is given, it will be yielded

data/lib/virtualbox/com.rb

@@ -1,23 +1,24 @@
 module VirtualBox
   module COM
     WSTRING = :unicode_string
+    T_INT8 = :int8
+    T_UINT8 = :uint8
     T_INT32 = :int
     T_INT64 = :long
-    T_ULONG = :ulong
-    T_UINT8 = :uchar
     T_UINT16 = :ushort
     T_UINT32 = :uint
     T_UINT64 = :ulong
     T_BOOL = :char
+
+    autoload :AbstractEnum, 'virtualbox/com/abstract_enum'
+    autoload :AbstractImplementer, 'virtualbox/com/abstract_implementer'
+    autoload :AbstractInterface, 'virtualbox/com/abstract_interface'
+    autoload :BaseInterface, 'virtualbox/com/base_interface'
+    autoload :FFI, 'virtualbox/com/ffi'
+    autoload :FFIInterface, 'virtualbox/com/ffi_interface'
+    autoload :Implementer, 'virtualbox/com/implementer'
+    autoload :MSCOMInterface, 'virtualbox/com/mscom_interface'
+    autoload :NilInterface, 'virtualbox/com/nil_interface'
+    autoload :Util, 'virtualbox/com/util'
   end
 end
-
-# The com directory of the gem
-comdir = File.join(File.dirname(__FILE__), 'com')
-
-# Require the abstract interface first then glob load all
-# of the interfaces
-require File.expand_path("abstract_interface", comdir)
-require File.expand_path("abstract_enum", comdir)
-VirtualBox::GlobLoader.glob_require(File.join(comdir, "interface"))
-VirtualBox::GlobLoader.glob_require(comdir, %w{base_interface abstract_interface abstract_implementer util ffi/interface ffi/util implementer/base})

data/lib/virtualbox/com/abstract_enum.rb

@@ -11,23 +11,39 @@ module VirtualBox
         # can be indexed with `[]` and an integer and returns a value of
         # some sort. If value is left nil, it will return the current mapping
         def map(value = nil)
-          @map = value if value
+          if value
+            # Convert the array to a hash of equal structure
+            if value.is_a?(Array)
+              result = {}
+              value.each_index do |i|
+                result[value[i]] = i
+              end
+
+              value = result
+            end
+
+            # Store both the map and the reverse map since both lookups
+            # are frequently used.
+            @map = value
+            @reverse_map = @map.invert
+          end
+
           @map
         end
 
         # Returns the symbol associatd with the given key
-        def [](key)
-          @map[key]
+        def [](index)
+          @reverse_map[index]
         end
 
         # Returns the index associated with a value
         def index(key)
-          @map.index(key)
+          @map[key]
         end
 
         # Iterate over the enum, yielding each item to a block.
         def each
-          @map.each do |key|
+          @map.each do |key, value|
             yield key
           end
         end

data/lib/virtualbox/com/abstract_interface.rb

@@ -36,6 +36,17 @@ module VirtualBox
       attr_reader :lib
 
       class << self
+        # This sets the parent class type. This defaults to NSISupports, but
+        # can be explicitly set to nil (no parent) if necessary.
+        def parent(type=nil)
+          @parent = type
+        end
+
+        # Returns the parent.
+        def get_parent
+          defined?(@parent) ? @parent : :NSISupports
+        end
+
         # Adds a function to the interface with the given name and function
         # spec. The spec determines the arguments required, the order they
         # are required in, and any out-arguments.

data/lib/virtualbox/com/base_interface.rb

@@ -1,38 +1,7 @@
-require 'thread'
-
 module VirtualBox
   module COM
     class BaseInterface
-      def initialize
-        @task_queue = Queue.new
-
-        @lib_thread = Thread.new(@task_queue) do |queue|
-          while true
-            task, result = queue.pop
-
-            # Run the task, set the return value, and run the waiter
-            # which will simply finish that thread
-            result << task.call
-          end
-        end
-      end
-
-      # This function takes a block and runs it on a thread which is
-      # guaranteed to be the same since the first time this is
-      # called. This is required by the MSCOM implementation and is a
-      # good idea in general so that multiple API calls aren't firing
-      # at once.
-      def on_lib_thread(&task)
-        # If we're already on the lib thread, then just run it!
-        return task.call if Thread.current == @lib_thread
-
-        # Add the task to the queue
-        result = Queue.new
-        @task_queue << [task, result]
-
-        # Pop the result off of the result queue
-        result.pop
-      end
+      # Nothing for now
     end
   end
 end

data/lib/virtualbox/com/{ffi/vboxxpcomc.rb → ffi.rb}

@@ -1,6 +1,13 @@
+require 'ffi'
+
 module VirtualBox
   module COM
     module FFI
+      autoload :Interface, 'virtualbox/com/ffi/interface'
+      autoload :Util, 'virtualbox/com/ffi/util'
+
+      extend ::FFI::Library
+
       # Callback types for VBOXXPCOMC
       callback :pfnGetVersion, [], :uint
       callback :pfnComInitialize, [:string, :pointer, :string, :pointer], :void

data/lib/virtualbox/com/ffi/interface.rb

@@ -3,29 +3,6 @@ require 'ffi'
 module VirtualBox
   module COM
     module FFI
-      extend ::FFI::Library
-
-      # FFI specific types
-      NSRESULT_TYPE = :uint
-
-      # Creates all the FFI classes for a given version.
-      def self.for_version(version, &block)
-        @__module = Module.new
-        ::VirtualBox::COM::Util.set_interface_version(version)
-        const_set(::VirtualBox::COM::Util.version_const, @__module)
-        instance_eval(&block)
-        @__module = Kernel
-      end
-
-      # Returns a Class which creates an FFI interface to the specified
-      # com interface and potentially a parent class as well.
-      def self.create_interface(interface, parent=nil)
-        klass = Class.new(Interface)
-        @__module.const_set(interface, klass)
-        klass.com_interface(interface, parent)
-        klass
-      end
-
       # Represents a VirtualBox XPCOM C interface, which is a C struct
       # which emulates an object (a struct with function pointers
       # and getters/setters). This class does **a lot** of magic which pretty
@@ -36,6 +13,9 @@ module VirtualBox
       class Interface
         extend ::FFI::Library
 
+        # FFI specific types
+        NSRESULT_TYPE = :uint
+
         attr_reader :vtbl_parent
         attr_reader :vtbl
 
@@ -46,11 +26,11 @@ module VirtualBox
           # XPCOM C structs are setup, the properties are first, in
           # `GetFoo` and `SetFoo` format. And the functions are next. They are
           # put into the struct in the order defined in the {AbstractInterface}.
-          def com_interface(interface, parent=nil)
+          def com_interface(interface)
             # Create the parent class and vtbl class
             interface = ::VirtualBox::COM::Util.versioned_interface(interface)
             define_vtbl_parent_for_interface(interface)
-            define_vtbl_for_interface(interface, parent)
+            define_vtbl_for_interface(interface)
           end
 
           # Creates the parent of the vtbl class associated with a given
@@ -64,7 +44,10 @@ module VirtualBox
           end
 
           # Creates the vtbl class associated with a given interface.
-          def define_vtbl_for_interface(interface, parent=nil)
+          def define_vtbl_for_interface(interface)
+            # Get the parent for the interface
+            parent = interface.get_parent
+
             # Define the properties, then the functions, since thats the order
             # the FFI structs are in
             layout_args.clear
@@ -88,7 +71,7 @@ module VirtualBox
           def define_interface_parent(parent)
             return if parent.nil?
 
-            parent_klass = Object.module_eval("::VirtualBox::COM::FFI::#{::VirtualBox::COM::Util.version_const}::#{parent}::Vtbl")
+            parent_klass = Util.versioned_interface(parent).const_get("Vtbl")
             layout_args << [:superklass, parent_klass]
           end
 

data/lib/virtualbox/com/ffi/util.rb

@@ -18,7 +18,36 @@ module VirtualBox
           #
           # @return [Class]
           def versioned_interface(interface)
-            ::VirtualBox::COM::FFI.const_get(::VirtualBox::COM::Util.version_const).const_get(interface)
+            version = ::VirtualBox::COM::Util.version
+            loaded_interfaces[version] ||= {}
+            loaded_interfaces[version][interface] ||= load_interface(interface)
+          end
+
+          # This keeps a hash of all the loaded interface classes by both
+          # version and name. Example:
+          #
+          #   loaded_interfaces["4.0.x"][:VirtualBox]
+          #
+          def loaded_interfaces
+            @loaded_interfaces ||= {}
+          end
+
+          # Loads an interface with the current version.
+          def load_interface(interface)
+            @current_constant ||= 1
+
+            # Create a new class that is an interface
+            klass = Class.new(Interface)
+
+            # Note that the klass must exist in a real constant path
+            # because FFI gem exists by climbing up the full path of the
+            # class. Dumb.
+            const_set("FFIClass#{@current_constant}", klass)
+            @current_constant += 1
+
+            # Create the actual interface on this empty class and return!
+            klass.com_interface(interface)
+            klass
           end
 
           # Converts a function spec from {AbstractInterface} to an FFI
@@ -55,7 +84,7 @@ module VirtualBox
                   elsif interface.superclass == COM::AbstractEnum
                     T_UINT32
                   end
-                rescue NameError
+                rescue NameError,LoadError
                   # Default to a pointer, since not all interfaces are implemented
                   :pointer
                 end
@@ -79,6 +108,7 @@ module VirtualBox
           # @return [String]
           def camelize(string)
             special_cases = {
+              "api" => "API",
               "os" => "OS",
               "dhcp" => "DHCP",
               "dvd" => "DVD",