bbrowning-virtualbox 0.7.6.dev

data/lib/virtualbox/storage_controller.rb

@@ -0,0 +1,160 @@
+module VirtualBox
+  # Represents a single storage controller which can be attached to a
+  # virtual machine.
+  #
+  # **Currently, storage controllers can not be created from scratch.
+  # Therefore, the only way to use this model is through a relationship
+  # of a {VM} object.**
+  #
+  # # Attributes and Relationships
+  #
+  # Properties of the storage controller are exposed using standard ruby instance
+  # methods which are generated on the fly. Because of this, they are not listed
+  # below as available instance methods.
+  #
+  # These attributes can be accessed and modified via standard ruby-style
+  # `instance.attribute` and `instance.attribute=` methods. The attributes are
+  # listed below.
+  #
+  # Relationships are also accessed like attributes but can't be set. Instead,
+  # they are typically references to other objects such as an {AttachedDevice} which
+  # in turn have their own attributes which can be modified.
+  #
+  # ## Attributes
+  #
+  # This is copied directly from the class header, but lists all available
+  # attributes. If you don't understand what this means, read {Attributable}.
+  #
+  #     attribute :parent, :readonly => true
+  #     attribute :name
+  #     attribute :type
+  #     attribute :max_ports, :populate_key => :maxportcount
+  #     attribute :ports, :populate_key => :portcount
+  #
+  # ## Relationships
+  #
+  # In addition to the basic attributes, a virtual machine is related
+  # to other things. The relationships are listed below. If you don't
+  # understand this, read {Relatable}.
+  #
+  #     relationship :devices, AttachedDevice, :dependent => :destroy
+  #
+  class StorageController < AbstractModel
+    attribute :parent, :readonly => true, :property => false
+    attribute :interface, :readonly => true, :property => false
+    attribute :name, :readonly => true
+    attribute :port_count
+    attribute :bus, :readonly => true
+    attribute :controller_type
+
+    class << self
+      # Populates a relationship with another model.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [Array<StorageController>]
+      def populate_relationship(caller, data)
+        if data.is_a?(COM::Util.versioned_interface(:Machine))
+          populate_array_relationship(caller, data)
+        elsif data.is_a?(MediumAttachment)
+          populate_attachment_relationship(caller, data)
+        end
+      end
+
+      # Populates a has many relationship for a {VM}.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [Array<StorageController>]
+      def populate_array_relationship(caller, imachine)
+        relation = Proxies::Collection.new(caller)
+
+        imachine.storage_controllers.each do |icontroller|
+          relation << new(caller, icontroller)
+        end
+
+        relation
+      end
+
+      # Populates a single relationship for a {MediumAttachment}.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [Array<StorageController>]
+      def populate_attachment_relationship(caller, attachment)
+        # Find the storage controller with the matching name
+        attachment.parent.storage_controllers.find do |sc|
+          sc.name == attachment.controller_name
+        end
+      end
+
+      # Destroys a relationship with another model.
+      #
+      # **This method typically won't be used except internally.**
+      def destroy_relationship(caller, data, *args)
+        data.each { |v| v.destroy(*args) }
+      end
+
+      # Saves the relationship. This simply calls {#save} on every
+      # member of the relationship.
+      #
+      # **This method typically won't be used except internally.**
+      def save_relationship(caller, controllers)
+        controllers.each do |sc|
+          sc.save
+        end
+      end
+    end
+
+    # Since storage controllers still can't be created from scratch,
+    # this method shouldn't be called. Instead, storage controllers
+    # can be retrieved through relationships of other models such
+    # as {VM}.
+    def initialize(caller, icontroller)
+      super()
+
+      populate_attributes({
+        :parent => caller,
+        :interface => icontroller
+      }, :ignore_relationships => true)
+      load_interface_attributes(icontroller)
+      clear_dirty!
+    end
+
+    # Retrieves the array of medium attachments related to this storage controller.
+    # This is not implemented as a relationship simply because it would have been
+    # difficult to do so (circular) and its not really necessary.
+    def medium_attachments
+      parent.medium_attachments.find_all do |ma|
+        ma.storage_controller == self
+      end
+    end
+
+    # Saves the storage controller. This method shouldn't be called directly.
+    # Instead, {VM#save} should be called, which will save all attached storage
+    # controllers as well. This will setup the proper parameter for `interface`
+    # here.
+    def save
+      parent.with_open_session do |session|
+        machine = session.machine
+        save_changed_interface_attributes(machine.get_storage_controller_by_name(name))
+      end
+    end
+
+    # Destroys the storage controller. This first detaches all attachments on this
+    # storage controller. Note that this does *not* delete the media on the attachments,
+    # unless specified by the options.
+    def destroy(*args)
+      # First remove all attachments
+      medium_attachments.each do |ma|
+        ma.destroy(*args)
+      end
+
+      # Finally, remove ourselves
+      parent.with_open_session do |session|
+        machine = session.machine
+        machine.remove_storage_controller(name)
+      end
+    end
+  end
+end

data/lib/virtualbox/system_properties.rb

@@ -0,0 +1,74 @@
+module VirtualBox
+  # Represents the system properties associated with this VirtualBox
+  # installation. Many of these properties are readonly and represent
+  # limits on the system (max RAM available, max CPU, etc.). There are
+  # also configurable options which can be saved such as the default
+  # hard disk folder, or default machine folder.
+  class SystemProperties < AbstractModel
+    attribute :interface, :readonly => true, :property => false
+    attribute :min_guest_ram, :readonly => true
+    attribute :max_guest_ram, :readonly => true
+    attribute :min_guest_vram, :readonly => true
+    attribute :max_guest_vram, :readonly => true
+    attribute :min_guest_cpu_count, :readonly => true
+    attribute :max_guest_cpu_count, :readonly => true
+    attribute :max_vdi_size, :readonly => true
+    attribute :network_adapter_count, :readonly => true
+    attribute :serial_port_count, :readonly => true
+    attribute :parallel_port_count, :readonly => true
+    attribute :max_boot_position, :readonly => true
+    attribute :default_machine_folder
+    attribute :default_hard_disk_folder
+    attribute :medium_formats, :readonly => true
+    attribute :default_hard_disk_format
+    attribute :remote_display_auth_library
+    attribute :web_service_auth_library
+    attribute :log_history_count
+    attribute :default_audio_driver, :readonly => true
+
+    class << self
+      # Populates the system properties relationship for anything
+      # which is related to it.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [SystemProperties]
+      def populate_relationship(caller, data)
+        new(data)
+      end
+
+      # Saves the relationship. This simply calls {#save} on the
+      # relationship object.
+      #
+      # **This method typically won't be used except internally.**
+      def save_relationship(caller, item)
+        item.save
+      end
+    end
+
+    # Initializes the system properties object. This shouldn't be called
+    # directly. Instead `Global#system_properties` should be used to
+    # retrieve this object.
+    def initialize(isysprop)
+      initialize_attributes(isysprop)
+    end
+
+    # Initializes the attributes of an existing shared folder.
+    def initialize_attributes(isysprop)
+      # Save the interface to an attribute
+      write_attribute(:interface, isysprop)
+
+      # Load the attributes from the interface
+      load_interface_attributes(interface)
+
+      # Clear dirty and mark as existing
+      clear_dirty!
+      existing_record!
+    end
+
+    # Saves the system properties.
+    def save
+      save_changed_interface_attributes(interface)
+    end
+  end
+end

data/lib/virtualbox/usb_controller.rb

@@ -0,0 +1,59 @@
+module VirtualBox
+  # Represents a USB controller within VirtualBox. This class is a relationship
+  # to {VM} objects.
+  class USBController < AbstractModel
+    attribute :parent, :readonly => true, :property => false
+    attribute :interface, :readonly => true, :property => false
+    attribute :enabled, :boolean => true
+    attribute :enabled_ehci, :boolean => true
+    attribute :usb_standard, :readonly => true
+    relationship :device_filters, :USBDeviceFilter
+
+    class << self
+      # Populates the USB controller relationship for anything
+      # which is related to it.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [USBController]
+      def populate_relationship(caller, machine)
+        new(caller, machine.usb_controller)
+      end
+
+      # Saves the relationship. This simply calls {#save} on the
+      # relationship object.
+      #
+      # **This method typically won't be used except internally.**
+      def save_relationship(caller, item)
+        item.save
+      end
+    end
+
+    def initialize(parent, iusb)
+      initialize_attributes(parent, iusb)
+    end
+
+    def initialize_attributes(parent, iusb)
+      # Write the parent and interface attributes
+      write_attribute(:parent, parent)
+      write_attribute(:interface, iusb)
+
+      # Load the interface attributes
+      load_interface_attributes(interface)
+
+      # Setup the relationships
+      populate_relationships(interface)
+
+      # Clear dirty and mark as existing
+      clear_dirty!
+      existing_record!
+    end
+
+    # Saves the USB controller.
+    def save
+      parent.with_open_session do |session|
+        save_changed_interface_attributes(session.machine.usb_controller)
+      end
+    end
+  end
+end

data/lib/virtualbox/usb_device_filter.rb

@@ -0,0 +1,74 @@
+module VirtualBox
+  # Represents a USB device filter within VirtualBox. This class
+  # is a relationship to {USBController} objects.
+  class USBDeviceFilter < AbstractModel
+    attribute :parent, :readonly => true, :property => false
+    attribute :parent_collection, :readonly => true, :property => false
+    attribute :interface, :readonly => true, :property => false
+    attribute :name
+    attribute :active, :boolean => true
+    attribute :vendor_id
+    attribute :product_id
+    attribute :revision
+    attribute :manufacturer
+    attribute :product
+    attribute :serial_number
+    attribute :port
+    attribute :remote
+    attribute :masked_interfaces
+
+    class << self
+      # Populates the USB controller relationship for anything
+      # which is related to it.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [USBDeviceFilter]
+      def populate_relationship(caller, usbcontroller)
+        result = Proxies::Collection.new(caller)
+
+        usbcontroller.device_filters.each do |filter|
+          result << new(filter)
+        end
+
+        result
+      end
+
+      # Saves the relationship. This simply calls {#save} on the
+      # relationship object.
+      #
+      # **This method typically won't be used except internally.**
+      def save_relationship(caller, item)
+        item.save
+      end
+    end
+
+    def initialize(iusb)
+      initialize_attributes(iusb)
+    end
+
+    def initialize_attributes(iusb)
+      # Write the parent and interface attributes
+      write_attribute(:interface, iusb)
+
+      # Load the interface attributes
+      load_interface_attributes(interface)
+
+      # Clear dirty and mark as existing
+      clear_dirty!
+      existing_record!
+    end
+
+    def added_to_relationship(proxy)
+      write_attribute(:parent, proxy.parent)
+      write_attribute(:parent_collection, proxy)
+    end
+
+    # Saves the USB device.
+    def save
+      parent.with_open_session do |session|
+        # TODO: save_changed_interface_attributes(session.machine.usb_controller)
+      end
+    end
+  end
+end

data/lib/virtualbox/version.rb

@@ -0,0 +1,36 @@
+module VirtualBox
+  VERSION = "0.7.6.dev"
+
+  module Version
+    # Returns a boolean denoting whether the current VirtualBox
+    # version is supported or not. This will return `false` if the
+    # version is invalid, the version is not detected, etc. That means
+    # that even if VirtualBox is not installed, this will simply
+    # return `false`.
+    #
+    # @return [Boolean]
+    def supported?
+      !version.nil?
+    end
+
+    # Returns the version string of the VirtualBox installed, ex. "3.1.6"
+    # This string is cached since the version typically doesn't change
+    # during runtime. If you must refresh the version, send the boolean
+    # `true` as the first parameter.
+    def version(refresh=false)
+      @_version = Lib.lib.virtualbox.version if @_version.nil? || refresh
+      @_version
+    rescue Exception
+      nil
+    end
+
+    # Returns the revision string of the VirtualBox installed, ex. "51742"
+    # This string is cached since the revision doesn't typically change during
+    # runtime. If you must refresh the version, send the boolean `true` as the
+    # first parameter.
+    def revision(refresh=false)
+      @_revision = Lib.lib.virtualbox.revision.to_s if @_revision.nil? || refresh
+      @_revision
+    end
+  end
+end

data/lib/virtualbox/virtual_system_description.rb

@@ -0,0 +1,47 @@
+module VirtualBox
+  # Represents a description of a virtual system in an {Appliance}. This contains
+  # the values that are in the OVF files as well as recommend values from VirtualBox.
+  class VirtualSystemDescription < AbstractModel
+    attribute :interface, :readonly => true
+    attribute :descriptions, :readonly => true, :default => {}
+
+    class << self
+      def populate_relationship(caller, data)
+        result = Proxies::Collection.new(caller)
+
+        data.each do |vsd|
+          result << new(vsd)
+        end
+
+        result
+      end
+    end
+
+    def initialize(ivsd)
+      write_attribute(:interface, ivsd)
+      initialize_attributes(ivsd)
+    end
+
+    def initialize_attributes(ivsd)
+      # Grab all the descriptions, iterate over each, and add to the hash of
+      # descriptions. This multiple loop method is used instead of `get_description` since
+      # that method doesn't work well with MSCOM.
+      COM::Util.versioned_interface(:VirtualSystemDescriptionType).each_with_index do |type, index|
+        COM::Util.versioned_interface(:VirtualSystemDescriptionValueType).each_with_index do |value_type, value_index|
+          value = ivsd.get_values_by_type(type, value_type)
+          if value && value != [] && value != [nil]
+            descriptions[type] ||= {}
+            descriptions[type][value_type] = value.first
+          end
+        end
+      end
+
+      # Clear dirtiness, since this should only be called initially and
+      # therefore shouldn't affect dirtiness
+      clear_dirty!
+
+      # But this is an existing record
+      existing_record!
+    end
+  end
+end