velir_virtualbox 0.8.4

data/lib/virtualbox/hw_virtualization.rb

@@ -0,0 +1,64 @@
+module VirtualBox
+  # Represents the HW virtualization properties on a VM.
+  class HWVirtualization < AbstractModel
+    attribute :parent, :readonly => true, :property => false
+    attribute_scope(:property_getter => Proc.new { |instance, *args| instance.get_property(*args) },
+                    :property_setter => Proc.new { |instance, *args| instance.set_property(*args) }) do
+      attribute :enabled, :boolean => true
+      attribute :exclusive, :boolean => true
+      attribute :vpid, :boolean => true
+      attribute :nested_paging, :boolean => true
+      attribute :force, :boolean => true
+    end
+
+    class << self
+      # Populates a relationship with another model.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [HWVirtualization]
+      def populate_relationship(caller, imachine)
+        data = new(caller, imachine)
+      end
+
+      # Saves the relationship.
+      #
+      # **This method typically won't be used except internally.**
+      def save_relationship(caller, instance)
+        instance.save
+      end
+    end
+
+    def initialize(parent, imachine)
+      write_attribute(:parent, parent)
+
+      # Load the attributes and mark the whole thing as existing
+      load_interface_attributes(imachine)
+      clear_dirty!
+      existing_record!
+    end
+
+    def get_property(interface, key)
+      interface.get_hw_virt_ex_property(key)
+    end
+
+    def set_property(interface, key, value)
+      interface.set_hw_virt_ex_property(key, value)
+    end
+
+    def validate
+      super
+
+      validates_inclusion_of :enabled, :exclusive, :vpid, :nested_paging, :in => [true, false]
+    end
+
+    def save
+      parent.with_open_session do |session|
+        machine = session.machine
+
+        # Save them
+        save_changed_interface_attributes(machine)
+      end
+    end
+  end
+end

data/lib/virtualbox/lib.rb

@@ -0,0 +1,84 @@
+module VirtualBox
+  # Used by the rest of the VirtualBox library to interface with
+  # the VirtualBox XPCOM library (VBoxXPCOMC). Most users will never need
+  # to interface with this class directly, except other to set the path to
+  # the `VBoxXPCOMC` lib.
+  #
+  # # Setting the Path to the VBoxXPCOMC Library
+  #
+  # This won't be necessary for 95% of users, and won't be necessary at all
+  # for windows users. But for unix users, the VirtualBox gem uses a dynamic
+  # library named `VBoxXPCOMC` to interface with VirtualBox. The gem does its
+  # best to guess the path to this gem based on the operating system ruby is
+  # running on, but in the case you get an error about it missing, you can
+  # easily set it:
+  #
+  #     VirtualBox::Lib.lib_path = "/path/to/VBoxXPCOMC.so"
+  #
+  # **Windows users will never need to do this.**
+  #
+  class Lib
+    @@lib_path = nil
+    @@lib = nil
+
+    attr_reader :interface
+    attr_reader :virtualbox
+    attr_reader :session
+
+    class << self
+      # Resets the initialized library (if there is any). This is primarily only
+      # used for testing.
+      def reset!
+        @@lib = nil
+      end
+
+      # The singleton instance of Lib.
+      #
+      # @return [Lib]
+      def lib
+        @@lib ||= new(lib_path)
+      end
+
+      # Sets the path to the VBoxXPCOMC library which is created with any
+      # VirtualBox install. 90% of the time, this won't have to be set manually,
+      # and instead the gem will try to find it for you.
+      #
+      # @param [String] Full path to the VBoxXPCOMC library
+      def lib_path=(value)
+        @@lib_path = value.nil? ? value : File.expand_path(value)
+      end
+
+      # Returns the path to the virtual box library. If the path
+      # has not yet been set, it attempts to infer it based on the
+      # platform ruby is running on.
+      def lib_path
+        if @@lib_path.nil?
+          if Platform.mac?
+            @@lib_path = ["/Applications/VirtualBox.app/Contents/MacOS/VBoxXPCOMC.dylib"]
+          elsif Platform.linux?
+            @@lib_path = ["/opt/VirtualBox/VBoxXPCOMC.so", "/usr/lib/virtualbox/VBoxXPCOMC.so"]
+          elsif Platform.solaris?
+            @@lib_path = ["/opt/VirtualBox/amd64/VBoxXPCOMC.so", "/opt/VirtualBox/i386/VBoxXPCOMC.so"]
+          elsif Platform.windows?
+            @@lib_path = "Unknown"
+          else
+            @@lib_path = "Unknown"
+          end
+        end
+
+        @@lib_path
+      end
+    end
+
+    def initialize(lib_path)
+      if Platform.windows?
+        @interface = COM::MSCOMInterface.new
+      else
+        @interface = COM::FFIInterface.create(lib_path)
+      end
+
+      @virtualbox = @interface.virtualbox
+      @session = @interface.session
+    end
+  end
+end

data/lib/virtualbox/media.rb

@@ -0,0 +1,20 @@
+module VirtualBox
+  # Represents the media registry within the global VirtualBox configuration.
+  class Media < AbstractModel
+    attribute :parent, :readonly => true
+    relationship :hard_drives, :HardDrive
+    relationship :dvds, :DVD
+
+    class << self
+      def populate_relationship(caller, lib)
+        new(caller, lib)
+      end
+    end
+
+    def initialize(parent, lib)
+      populate_attributes({ :parent => parent }, :ignore_relationships => true)
+      populate_relationship(:hard_drives, lib.virtualbox.hard_disks)
+      populate_relationship(:dvds, lib.virtualbox.dvd_images)
+    end
+  end
+end

data/lib/virtualbox/medium.rb

@@ -0,0 +1,145 @@
+module VirtualBox
+  # Represents a medium object part of VirtualBox. A medium is a
+  # hard drive, DVD, floppy disk, etc. Each of these share common
+  # properties represented here.
+  class Medium < AbstractModel
+    include SubclassListing
+
+    attribute :uuid, :readonly => true, :property => :id
+    attribute :type, :readonly => true
+    attribute :description, :readonly => true
+    attribute :location, :readonly => true
+    attribute :state, :readonly => true, :property => :refresh_state
+    attribute :interface, :readonly => true, :property => false
+    relationship :children, :Medium, :lazy => true
+
+    class << self
+      # Populates a relationship with another model. Depending on the data sent
+      # through as the `media` parameter, this can either return a single value
+      # or an array of values. {Global}, for example, has a relationship of media,
+      # while a {MediumAttachment} has a relationship with a single medium.
+      #
+      # **This method typically won't be used except internally.**
+      def populate_relationship(caller, media)
+        if media.is_a?(Array)
+          # has many relationship
+          populate_array_relationship(caller, media)
+        else
+          # has one relationship
+          populate_single_relationship(caller, media)
+        end
+      end
+
+      # Populates a relationship which has many media.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [Array<Medium>]
+      def populate_array_relationship(caller, media)
+        relation = Proxies::Collection.new(caller)
+
+        media.each do |medium|
+          # Skip media this class isn't interested in
+          next if device_type != :all && medium.device_type != device_type
+
+          # Wrap it up and add to the relationship
+          relation << new(medium)
+        end
+
+        relation
+      end
+
+      # Populates a relationship which has one medium. This method goes one step
+      # further and instantiates the proper class for the type of medium given.
+      # For example, given a `device_type` of `:hard_drive`, it would return a
+      # {HardDrive} object.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [Medium]
+      def populate_single_relationship(caller, medium)
+        return nil if medium.nil?
+
+        subclasses.each do |subclass|
+          # Skip this class unless the device type matches
+          next unless subclass.device_type == medium.device_type
+
+          # Wrap it up and return it
+          return subclass.new(medium)
+        end
+
+        # If all else fails, just wrap it in a Medium
+        new(medium)
+      end
+
+      # Specifies the device type that a {Medium} class is interested in. This
+      # is `:all` on {Medium}, but is expected to be overridden by child classes.
+      # The value returned should be one of {COM::Interface::DeviceType}.
+      #
+      # @return [Symbol]
+      def device_type
+        :all
+      end
+    end
+
+    # Initializes a medium object, retrieving the attributes and information
+    # from the {COM::Interface::Medium} object given as the parameter. This initialization
+    # is done automatically by virtualbox when populating a relationship. Mediums should
+    # never be initialized manually.
+    #
+    # @param [COM::Interface::Medium] imedium
+    def initialize(imedium)
+      write_attribute(:interface, imedium)
+      initialize_attributes(imedium)
+    end
+
+    def initialize_attributes(imedium)
+      # First refresh the state (required for many attributes)
+      imedium.refresh_state
+
+      # Load interface attributes
+      load_interface_attributes(imedium)
+
+      # 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
+
+    def load_relationship(name)
+      # Populate children
+      populate_relationship(name, interface.children)
+    end
+
+    # Returns the basename of the images location (the file name +extension)
+    #
+    # @return [String]
+    def filename
+      File.basename(location.to_s)
+    end
+
+    # Destroys the medium, optionally also phsyically destroying the backing
+    # storage. This removes this medium from the VirtualBox media registry.
+    # In order to remove the medium, it must not be attached to any virtual
+    # machine. If it is, an exception of some sort will be raised.
+    # This action happens *immediately* when the method is called, and is not
+    # deferred to a save.
+    def destroy(destroy_backing=false)
+      if destroy_backing
+        destroy_storage
+      else
+        interface.close
+      end
+    end
+
+    # Destroys the backing store of the medium and the media registry. This is
+    # analagous to calling {#destroy} with the first parameter set to true. This
+    # method requires that the medium not be attached to any virtual machine
+    # (running or not).
+    def destroy_storage
+      interface.delete_storage.wait_for_completion(-1)
+    end
+  end
+end

data/lib/virtualbox/medium_attachment.rb

@@ -0,0 +1,61 @@
+module VirtualBox
+  # Represents the attachment of a medium (DVD, Hard Drive, etc) to a
+  # virtual machine, and specifically to a {StorageController}.
+  class MediumAttachment < AbstractModel
+    attribute :parent, :readonly => true, :property => false
+    attribute :controller_name, :readonly => :true, :property => :controller
+    attribute :port, :readonly => true
+    attribute :device, :readonly => true
+    attribute :passthrough, :readonly => true
+    attribute :type, :readonly => true
+    relationship :medium, :Medium
+    relationship :storage_controller, :StorageController
+
+    class << self
+      # Populates a relationship with another model.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [Array<MediumAttachment>]
+      def populate_relationship(caller, imachine)
+        relation = Proxies::Collection.new(caller)
+
+        imachine.medium_attachments.each do |ima|
+          relation << new(caller, ima)
+        end
+
+        relation
+      end
+    end
+
+    def initialize(parent, imedium_attachment)
+      populate_attributes({:parent => parent}, :ignore_relationships => true)
+      initialize_attributes(imedium_attachment)
+    end
+
+    def initialize_attributes(ima)
+      load_interface_attributes(ima)
+      populate_relationship(:medium, ima.medium)
+      populate_relationship(:storage_controller, self)
+    end
+
+    # Detaches the medium from it's parent virtual machine. Note that this
+    # **does not delete** the `medium` which this attachment references; it
+    # merely removes the assocation of said medium with this attachment's
+    # virtual machine.
+    def detach
+      parent.with_open_session do |session|
+        machine = session.machine
+
+        machine.detach_device(storage_controller.name, port, device)
+      end
+    end
+
+    # Destroy this medium attachment. This simply detaches the medium attachment.
+    # This will also delete the medium if that option is specified.
+    def destroy(opts={})
+      detach
+      medium.destroy(opts[:destroy_medium] == :delete) if opts[:destroy_medium] && medium
+    end
+  end
+end

data/lib/virtualbox/nat_engine.rb

@@ -0,0 +1,71 @@
+module VirtualBox
+  # Represents a NAT engine for a given {NetworkAdapter}. This data is
+  # available through the `nat_driver` relationship on
+  # {NetworkAdapter} only if the adapter is a NAT adapter.
+  class NATEngine < AbstractModel
+    attribute :parent, :readonly => true, :property => false
+    attribute :network
+    attribute :tftp_prefix
+    attribute :tftp_boot_file
+    attribute :tftp_next_server
+    attribute :alias_mode
+    attribute :dns_pass_domain
+    attribute :dns_proxy
+    attribute :dns_use_host_resolver
+    attribute :interface, :readonly => true, :property => false
+    relationship :forwarded_ports, :NATForwardedPort
+
+    class << self
+      # Populates the NAT engine for anything which is related to it.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [NATEngine]
+      def populate_relationship(caller, inat)
+        return nil if inat.nil?
+        new(caller, inat)
+      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, item)
+        item.save
+      end
+    end
+
+    def initialize(caller, inat)
+      super()
+      initialize_attributes(caller, inat)
+    end
+
+    # Initializes the attributes of an existing NAT engine.
+    def initialize_attributes(parent, inat)
+      write_attribute(:parent, parent)
+      write_attribute(:interface, inat)
+
+      # Load the interface attributes associated with this model
+      load_interface_attributes(inat)
+      populate_relationships(inat)
+
+      # Clear dirty and set as existing
+      clear_dirty!
+      existing_record!
+    end
+
+    def save
+      modify_engine do |nat|
+        save_changed_interface_attributes(nat)
+        save_relationships
+      end
+    end
+
+    # Helper method to get the mutable `INATEngine` interface.
+    def modify_engine
+      parent.modify_adapter do |adapter|
+        yield adapter.nat_driver
+      end
+    end
+  end
+end