virtualbox 0.5.4 → 0.6.0

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

@@ -0,0 +1,9 @@
+module VirtualBox
+  module COM
+    module Interface
+      class VRDPAuthType < AbstractEnum
+        map [:null, :external, :guest]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module VirtualBox
+  module COM
+    module Interface
+      class VRDPServer < AbstractInterface
+        IID = "72e671bc-1712-4052-ad6b-e45e76d9d3e4"
+
+        property :enabled, T_BOOL
+        property :ports, WSTRING
+        property :net_address, WSTRING
+        property :auth_type, :VRDPAuthType
+        property :auth_timeout, T_UINT32
+        property :allow_multi_connection, T_BOOL
+        property :reuse_single_connection, T_BOOL
+      end
+    end
+  end
+end

data/lib/virtualbox/com/mscom_interface.rb

@@ -0,0 +1,22 @@
+module VirtualBox
+  module COM
+    class MSCOMInterface
+      # The VirtualBox and Session interfaces, both of which are extremely
+      # important in interfacing with the VirtualBox API. Once these have been
+      # initialized, all other parts of the API can be accessed via these
+      # instances.
+      attr_reader :virtualbox
+      attr_reader :session
+
+      def initialize
+        initialize_mscom
+      end
+
+      def initialize_mscom
+        require 'win32ole'
+        @virtualbox = Interface::VirtualBox.new(Implementer::MSCOM, self, WIN32OLE.new("VirtualBox.VirtualBox"))
+        @session = Interface::Session.new(Implementer::MSCOM, self, WIN32OLE.new("VirtualBox.Session"))
+      end
+    end
+  end
+end

data/lib/virtualbox/com/util.rb

@@ -0,0 +1,18 @@
+module VirtualBox
+  module COM
+    class Util
+      class <<self
+        # Returns a boolean true/false whether the given COM interface
+        # exists.
+        #
+        # @return [Boolean]
+        def interface?(name)
+          COM::Interface.const_get(name.to_sym)
+          true
+        rescue NameError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/virtualbox/dvd.rb

@@ -1,6 +1,8 @@
 module VirtualBox
   # Represents a DVD image stored by VirtualBox. These DVD images can be
-  # mounted onto virtual machines.
+  # mounted onto virtual machines. Because DVD just inherits from {Medium},
+  # it also inherits all methods and attributes which are on {Medium}. For more
+  # attributes, the ability to destroy, etc, please view {Medium}.
   #
   # # Finding all DVDs
   #
@@ -9,106 +11,17 @@ module VirtualBox
   #
   #     DVD.all
   #
-  # # Empty Drives
-  #
-  # Sometimes it is useful to have an empty drive. This is the case where you
-  # may have a DVD drive but it has no disk in it. To create an {AttachedDevice},
-  # an image _must_ be specified, and an empty drive is a simple option. Creating
-  # an empty drive is simple:
-  #
-  #     DVD.empty_drive
-  #
-  class DVD < Image
+  class DVD < Medium
     class <<self
       # Returns an array of all available DVDs as DVD objects
       def all
         Global.global.media.dvds
       end
 
-      # Returns an array of all available DVDs by parsing the VBoxManage
-      # output
-      def all_from_command
-        raw = Command.vboxmanage("list", "dvds")
-        parse_raw(raw)
-      end
-
-      # Returns an empty drive. This is useful for creating new
-      # or modifyingn existing {AttachedDevice} objects and
-      # attaching an empty drive to them.
-      #
-      # @return [DVD]
-      def empty_drive
-        new(:empty_drive)
-      end
-
-      def populate_relationship(caller, doc)
-        result = Proxies::Collection.new(caller)
-
-        # TODO: Location in this case is relative the vboxconfig path.
-        # We need to expand it. Also, size/accessible is not available.
-        doc.css("MediaRegistry DVDImages Image").each do |hd_node|
-          data = {}
-          hd_node.attributes.each do |key, value|
-            data[key.downcase.to_sym] = value.to_s
-          end
-
-          # Massage UUID to proper format
-          data[:uuid] = data[:uuid][1..-2]
-
-          result << new(data)
-        end
-
-        result
-      end
-    end
-
-    def initialize(*args)
-      if args.length == 1 && args[0] == :empty_drive
-        @empty_drive = true
-      else
-        super
+      # Override of {Medium.device_type}.
+      def device_type
+        :dvd
       end
     end
-
-    # Override of {Image#empty_drive?}. This will only be true if
-    # the DVD was created with {DVD.empty_drive}.
-    #
-    # @return [Boolean]
-    def empty_drive?
-      @empty_drive || false
-    end
-
-    # Override of {Image#image_type}.
-    def image_type
-      "dvddrive"
-    end
-
-    # Deletes the DVD from VBox managed list and also from disk.
-    # This method will fail if the disk is currently mounted to any
-    # virtual machine. This method also does nothing for empty drives
-    # (see {DVD.empty_drive}) and will return false automatically in
-    # that case.
-    #
-    # @param [Boolean] raise_errors If true, {Exceptions::CommandFailedException}
-    #   will be raised if the command failed.
-    # @return [Boolean] True if command was successful, false otherwise.
-    def destroy(raise_errors=false)
-      return false if empty_drive?
-
-      Command.vboxmanage("closemedium", "dvd", uuid, "--delete")
-      Global.reload!
-      true
-    rescue Exceptions::CommandFailedException
-      raise if raise_errors
-      false
-    end
-
-    # Lazy load the lazy attributes for this model.
-    def load_attribute(name)
-      # Since the lazy attributes are related, we just load them all at once
-      loaded_image = self.class.all_from_command.detect { |o| o.uuid == self.uuid }
-
-      write_attribute(:accessible, loaded_image.accessible)
-    end
   end
 end

data/lib/virtualbox/exceptions.rb

@@ -9,5 +9,29 @@ module VirtualBox
     class InvalidRelationshipObjectException < Exception; end
     class NonSettableRelationshipException < Exception; end
     class ValidationFailedException < Exception; end
+
+    class FFIException < Exception
+      attr_accessor :data
+
+      def initialize(data={})
+        @data = data
+        super("Error in API call to #{data[:function]}: #{data[:result_code]}")
+      end
+    end
+
+    # FFI Exceptions, these exceptions are only raised on *nix machines
+    # when some error occurs in the foreign function interface.
+    class ObjectNotFoundException < FFIException; end
+    class InvalidVMStateException < FFIException; end
+    class VMErrorException < FFIException; end
+    class FileErrorException < FFIException; end
+    class SubsystemException < FFIException; end
+    class PDMException < FFIException; end
+    class InvalidObjectStateException < FFIException; end
+    class HostErrorException < FFIException; end
+    class NotSupportedException < FFIException; end
+    class XMLErrorException < FFIException; end
+    class InvalidSessionStateException < FFIException; end
+    class ObjectInUseException < FFIException; end
   end
 end

data/lib/virtualbox/ext/glob_loader.rb

@@ -0,0 +1,22 @@
+module VirtualBox
+  # Eases the processes of loading specific files then globbing
+  # the rest from a specified directory.
+  module GlobLoader
+    # Glob requires all ruby files in a directory, optionally loading select
+    # files initially (since others may depend on them).
+    #
+    # @param [String] dir The directory to glob
+    # @param [Array<String>] initial_files Initial files (relative to `dir`)
+    #   to load
+    def self.glob_require(dir, initial_files=[])
+      initial_files.each do |file|
+        require File.expand_path(file, dir)
+      end
+
+      # Glob require the rest
+      Dir[File.join(dir, "**", "*.rb")].each do |f|
+        require File.expand_path(f)
+      end
+    end
+  end
+end

data/lib/virtualbox/ext/logger.rb

@@ -0,0 +1,38 @@
+require 'logger'
+
+module VirtualBox
+  # Provides logger functionality for VirtualBox. This class is available on most
+  # VirtualBox classes through mixins. To access the logger, simply call the {logger}
+  # method. This returns a standard Ruby logger which can be modified.
+  module Logger
+    @@logger = nil
+    @@logger_output = nil
+
+    # Make the logger available both on a class and instance level
+    # once included.
+    def self.included(base)
+      base.extend self
+    end
+
+    # Sets up the output stream for the logger. This should be called before any
+    # calls to {logger}. If the logger has already been instantiated, then a new
+    # logger will be created on the next call with the new output setup.
+    def logger_output=(value)
+      @@logger_output = value
+      @@logger = nil
+    end
+
+    # Accesses the logger. If logger output is specified and this is the first load,
+    # then the logger will be properly setup to point to that output. Logging
+    # levels should also be set once the logger is created. The logger is a standard
+    # Ruby `Logger`.
+    #
+    # The VirtualBox gem can get very verybose very quickly, so choose a log level
+    # which suits the granularity needed.
+    #
+    # @return [Logger]
+    def logger
+      @@logger ||= ::Logger.new(@@logger_output)
+    end
+  end
+end

data/lib/virtualbox/ext/platform.rb

@@ -6,7 +6,7 @@ module VirtualBox
       end
 
       def windows?
-        platform.include?("mswin") || platform.include?("mingw")
+        platform.include?("mswin") || platform.include?("mingw") || platform.include?("cygwin")
       end
 
       def linux?

data/lib/virtualbox/extra_data.rb

@@ -35,6 +35,7 @@ module VirtualBox
     include AbstractModel::Dirty
 
     attr_accessor :parent
+    attr_reader :interface
 
     @@global_data = nil
 
@@ -57,11 +58,11 @@ module VirtualBox
       # **This method typically won't be used except internally.**
       #
       # @return [Array<ExtraData>]
-      def populate_relationship(caller, doc)
-        data = new(caller)
+      def populate_relationship(caller, interface)
+        data = new(caller, interface)
 
-        doc.css("ExtraData ExtraDataItem").each do |extradata|
-          data[extradata["name"].to_s] = extradata["value"].to_s
+        interface.get_extra_data_keys.each do |key|
+          data[key] = interface.get_extra_data(key)
         end
 
         data.clear_dirty!
@@ -80,8 +81,9 @@ module VirtualBox
     # Initializes an extra data object.
     #
     # @param [Hash] data Initial attributes to populate.
-    def initialize(parent=nil)
-      @parent = parent || "global"
+    def initialize(parent, interface)
+      @parent = parent
+      @interface = interface
     end
 
     # Set an extradata key-value pair. Overrides ruby hash implementation
@@ -91,19 +93,6 @@ module VirtualBox
       super
     end
 
-    # Special accessor for parent name attribute. This returns
-    # either the parent name if its a VM object, otherwise
-    # just returns the default.
-    #
-    # @return [String]
-    def parent_name
-      if parent.is_a?(VM)
-        parent.name
-      else
-        parent
-      end
-    end
-
     # Saves extra data. This method does the same thing for both new
     # and existing extra data, since virtualbox will overwrite old data or
     # create it if it doesn't exist.
@@ -111,30 +100,29 @@ module VirtualBox
     # @param [Boolean] raise_errors If true, {Exceptions::CommandFailedException}
     #   will be raised if the command failed.
     # @return [Boolean] True if command was successful, false otherwise.
-    def save(raise_errors=false)
+    def save
       changes.each do |key, value|
-        Command.vboxmanage("setextradata", parent_name, key, value[1])
+        interface.set_extra_data(key.to_s, value[1].to_s)
+
         clear_dirty!(key)
-      end
 
-      true
-    rescue Exceptions::CommandFailedException
-      raise if raise_errors
-      false
+        if value[1].nil?
+          # Remove the key from the hash altogether
+          hash_delete(key.to_s)
+        end
+      end
     end
 
-    # Deletes the extra data.
+    # Alias away the old delete method so its still accessible somehow
+    alias :hash_delete :delete
+
+    # Deletes the specified extra data. This method is deferred, meaning that
+    # although the key itself is marked to be deleted (by setting the value
+    # to nil), the deletion itself does not occur until {#save} is called.
     #
-    # @param [Boolean] raise_errors If true, {Exceptions::CommandFailedException}
-    #   will be raised if the command failed.
-    # @return [Boolean] True if command was successful, false otherwise.
-    def delete(key, raise_errors=false)
-      Command.vboxmanage("setextradata", parent_name, key)
-      super(key)
-      true
-    rescue Exceptions::CommandFailedException
-      raise if raise_errors
-      false
+    # @param [String] key The extra data key to delete
+    def delete(key)
+      self[key] = nil
     end
   end
 end

data/lib/virtualbox/forwarded_port.rb

@@ -132,25 +132,47 @@ module VirtualBox
       validates_presence_of :hostport
     end
 
+    # Retrieves the device for the forwarded port. This tries to "do the
+    # right thing" depending on the first NIC of the VM parent by either
+    # setting the forwarded port type to "pcnet" or "e1000." If the device
+    # was already set manually, this method will simply return that value
+    # instead.
+    #
+    # @return [String] Device type for the forwarded port
+    def device
+      # Return the current or default value if it is:
+      #  * an existing record, since it was already mucked with, no need to
+      #    modify it again
+      #  * device setting changed, since we should return what the user set
+      #    it to
+      #  * If the parent is nil, since we can't infer the type without a parent
+      return read_attribute(:device) if !new_record? || device_changed? || parent.nil?
+
+      device_map = {
+        :Am79C970A => "pcnet",
+        :Am79C973 => "pcnet",
+        :I82540EM => "e1000",
+        :I82543GC => "e1000",
+        :I82545EM => "e1000"
+      }
+
+      return device_map[parent.network_adapters[0].adapter_type]
+    end
+
     # Saves the forwarded port.
     #
-    # @param [Boolean] raise_errors If true, {Exceptions::CommandFailedException}
-    #   will be raised if the command failed.
     # @return [Boolean] True if command was successful, false otherwise.
-    def save(raise_errors=false)
+    def save
       return true if !new_record? && !changed?
 
-      if !valid?
-        raise Exceptions::ValidationFailedException.new(errors) if raise_errors
-        return false
-      end
+      raise Exceptions::ValidationFailedException.new(errors) if !valid?
 
-      destroy(raise_errors) if name_changed?
+      destroy if name_changed?
 
       parent.extra_data["#{key_prefix}Protocol"] = protocol
       parent.extra_data["#{key_prefix}GuestPort"] = guestport
       parent.extra_data["#{key_prefix}HostPort"] = hostport
-      result = parent.extra_data.save(raise_errors)
+      result = parent.extra_data.save
 
       clear_dirty!
       existing_record!
@@ -163,13 +185,13 @@ module VirtualBox
     # @param [Boolean] raise_errors If true, {Exceptions::CommandFailedException}
     #   will be raised if the command failed.
     # @return [Boolean] True if command was successful, false otherwise.
-    def destroy(raise_errors=false)
+    def destroy
       results = []
 
       if !new_record?
-        results << parent.extra_data.delete("#{key_prefix(true)}Protocol", raise_errors)
-        results << parent.extra_data.delete("#{key_prefix(true)}GuestPort", raise_errors)
-        results << parent.extra_data.delete("#{key_prefix(true)}HostPort", raise_errors)
+        results << parent.extra_data.delete("#{key_prefix(true)}Protocol")
+        results << parent.extra_data.delete("#{key_prefix(true)}GuestPort")
+        results << parent.extra_data.delete("#{key_prefix(true)}HostPort")
 
         new_record!
       end