virtualbox 0.4.3 → 0.5.0

data/lib/virtualbox/shared_folder.rb

@@ -86,8 +86,8 @@ module VirtualBox
   #
   class SharedFolder < AbstractModel
     attribute :parent, :readonly => :readonly
-    attribute :name, :populate_key => "SharedFolderNameMachineMapping"
-    attribute :hostpath, :populate_key => "SharedFolderPathMachineMapping"
+    attribute :name
+    attribute :hostpath
 
     class <<self
       # Populates the shared folder relationship for anything which is related to it.
@@ -95,15 +95,12 @@ module VirtualBox
       # **This method typically won't be used except internally.**
       #
       # @return [Array<SharedFolder>]
-      def populate_relationship(caller, data)
+      def populate_relationship(caller, doc)
         relation = Proxies::Collection.new(caller)
 
         counter = 1
-        loop do
-          break unless data["SharedFolderNameMachineMapping#{counter}".downcase.to_sym]
-
-          folder = new(counter, caller, data)
-          relation.push(folder)
+        doc.css("Hardware SharedFolders SharedFolder").each do |folder|
+          relation << new(counter, caller, folder)
           counter += 1
         end
 
@@ -156,10 +153,8 @@ module VirtualBox
     def initialize_for_relationship(index, caller, data)
       # Setup the index specific attributes
       populate_data = {}
-      self.class.attributes.each do |name, options|
-        key = options[:populate_key] || name
-        value = data["#{key}#{index}".downcase.to_sym]
-        populate_data[key] = value
+      data.attributes.each do |key, value|
+        populate_data[key.downcase.to_sym] = value.to_s
       end
 
       populate_attributes(populate_data.merge({

data/lib/virtualbox/storage_controller.rb

@@ -43,7 +43,6 @@ module VirtualBox
     attribute :parent, :readonly => true
     attribute :name
     attribute :type
-    attribute :max_ports, :populate_key => :maxportcount
     attribute :ports, :populate_key => :portcount
     relationship :devices, AttachedDevice, :dependent => :destroy
 
@@ -53,14 +52,12 @@ module VirtualBox
       # **This method typically won't be used except internally.**
       #
       # @return [Array<StorageController>]
-      def populate_relationship(caller, data)
-        relation = []
+      def populate_relationship(caller, doc)
+        relation = Proxies::Collection.new(caller)
 
         counter = 0
-        loop do
-          break unless data["storagecontrollername#{counter}".to_sym]
-          nic = new(counter, caller, data)
-          relation.push(nic)
+        doc.css("StorageControllers StorageController").each do |sc|
+          relation << new(counter, caller, sc)
           counter += 1
         end
 
@@ -96,37 +93,12 @@ module VirtualBox
 
       # Setup the index specific attributes
       populate_data = {}
-      self.class.attributes.each do |name, options|
-        key = options[:populate_key] || name
-        value = data["storagecontroller#{key}#{index}".to_sym]
-        populate_data[key] = value
+      data.attributes.each do |key,value|
+        populate_data[key.downcase.to_sym] = value.to_s
       end
 
-      # Make sure to merge in device data so those relationships will be
-      # setup properly
-      populate_data.merge!(extract_devices(index, data))
-
-      populate_attributes(populate_data.merge({
-        :parent => caller
-      }))
-    end
-
-    # Extracts related devices for a storage controller.
-    #
-    # **This method typically won't be used except internally.**
-    #
-    # @return [Hash]
-    def extract_devices(index, data)
-      name = data["storagecontrollername#{index}".downcase.to_sym].downcase
-
-      device_data = {}
-      data.each do |k,v|
-        next unless k.to_s =~ /^#{name}-/
-
-        device_data[k] = v
-      end
-
-      device_data
+      populate_attributes(populate_data.merge({:parent => caller}), :ignore_relationships => true)
+      populate_relationship(:devices, data)
     end
   end
 end

data/lib/virtualbox/system_property.rb

@@ -0,0 +1,55 @@
+module VirtualBox
+  # Represents the system properties of the system which VirtualBox
+  # is running on. These system properties are immutable values which
+  # are typically limits or specs of the host system. Some examples
+  # of available properties are `Maximum guest RAM size` or
+  # `Maximum Devices per SATA Port`.
+  #
+  # # Retrieving the System Properties
+  #
+  # Retrieving the system properties is done by calling the {all} method.
+  # Since {SystemProperty} inherits from `Hash`, you can treat it just like
+  # one. The keys are simply the typical keys downcased with spaces replaced
+  # with underscores, and converted to a symbol. An example of accessing
+  # system properties is shown below:
+  #
+  #     properties = VirtualBox::SystemProperty.all
+  #     puts properties[:log_history_count]
+  #     puts properties[:maximum_guest_ram_size]
+  #
+  # Since {SystemProperty} is simply a hash, you can also iterate over it,
+  # convert it easily to an array, etc.
+  class SystemProperty < Hash
+    class <<self
+      # Returns the hash of all system properties. Each call will invoke a
+      # system call to retrieve the properties (as in they're not cached
+      # on the class), so if you need to access them many times, please
+      # cache them yourself.
+      #
+      # @return [SystemProperty]
+      def all
+        raw = Command.vboxmanage("list", "systemproperties")
+        parse_raw(raw)
+      end
+
+      # Parses the raw output of vboxmanage. This parses the raw output from
+      # VBoxManage to parse the system properties.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @param [String] data The raw output from vboxmanage.
+      # @return [SystemProperty]
+      def parse_raw(data)
+        result = new
+        data.split("\n").each do |line|
+          next unless line =~ /^(.+?):\s+(.+?)$/
+          value = $2.to_s
+          key = $1.to_s.downcase.gsub(/\s/, "_")
+          result[key.to_sym] = value
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/virtualbox/usb.rb

@@ -0,0 +1,72 @@
+module VirtualBox
+  # Represents a single USB device of a virtual machine.
+  #
+  # **Currently, new USB devices can't be created, so the only way to get this
+  # object is through a {VM}'s `usbs` relationship.**
+  #
+  # # Attributes
+  #
+  # Properties of the model 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. If you aren't sure what this means or you can't understand
+  # why the below is listed, please read {Attributable}.
+  #
+  #     attribute :parent, :readonly => :readonly
+  #     attribute :name
+  #     attribute :active
+  #     attribute :manufacturer
+  #     attribute :product
+  #     attribute :remote
+  #
+  class USB < AbstractModel
+    attribute :parent, :readonly => :readonly
+    attribute :name
+    attribute :active
+    attribute :manufacturer
+    attribute :product
+    attribute :remote
+
+    class <<self
+      # Populates the usb device relationship for anything which is related to it.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [Array<USB>]
+      def populate_relationship(caller, doc)
+        relation = Proxies::Collection.new(caller)
+
+        doc.css("Hardware USBController DeviceFilter").each do |device|
+          relation << new(caller, device)
+        end
+
+        relation
+      end
+    end
+
+    # Since there is currently no way to create a _new_ usb device, this is
+    # only used internally. Developers should NOT try to initialize their
+    # own usb device objects.
+    def initialize(caller, data)
+      super()
+
+      # Set the parent
+      write_attribute(:parent, caller)
+
+      # Convert each attribute value to a string
+      attrs = {}
+
+      data.attributes.each do |key, value|
+        attrs[key.to_sym] = value.to_s
+      end
+
+      populate_attributes(attrs)
+
+      # Clear dirtiness
+      clear_dirty!
+    end
+  end
+end

data/lib/virtualbox/vm.rb

@@ -42,6 +42,7 @@ module VirtualBox
   #     attribute :uuid, :readonly => true
   #     attribute :name
   #     attribute :ostype
+  #     attribute :description, :readonly => true
   #     attribute :memory
   #     attribute :vram
   #     attribute :acpi
@@ -63,9 +64,14 @@ module VirtualBox
   #     attribute :clipboard
   #     attribute :monitorcount
   #     attribute :usb
+  #     attribute :ehci
   #     attribute :audio
+  #     attribute :audiocontroller
+  #     attribute :audiodriver
   #     attribute :vrdp
-  #     attribute :vrdpports
+  #     attribute :vrdpport
+  #     attribute :vrdpauthtype
+  #     attribute :vrdpauthtimeout
   #     attribute :state, :populate_key => :vmstate, :readonly => true
   #
   # ## Relationships
@@ -75,6 +81,7 @@ module VirtualBox
   # understand this, read {Relatable}.
   #
   #     relationship :nics, Nic
+  #     relationship :usbs, USB
   #     relationship :storage_controllers, StorageController, :dependent => :destroy
   #     relationship :shared_folders, SharedFolder
   #     relationship :extra_data, ExtraData
@@ -84,12 +91,13 @@ module VirtualBox
     attribute :uuid, :readonly => true
     attribute :name
     attribute :ostype
+    attribute :description, :readonly => true
     attribute :memory
     attribute :vram
     attribute :acpi
     attribute :ioapic
     attribute :cpus
-    attribute :synthcpu
+    attribute :synthcpu, :lazy => true
     attribute :pae
     attribute :hwvirtex
     attribute :hwvirtexexcl
@@ -105,11 +113,17 @@ module VirtualBox
     attribute :clipboard
     attribute :monitorcount
     attribute :usb
+    attribute :ehci
     attribute :audio
+    attribute :audiocontroller
+    attribute :audiodriver
     attribute :vrdp
-    attribute :vrdpports
-    attribute :state, :populate_key => :vmstate, :readonly => true
+    attribute :vrdpport
+    attribute :vrdpauthtype
+    attribute :vrdpauthtimeout
+    attribute :state, :populate_key => :vmstate, :readonly => true, :lazy => true
     relationship :nics, Nic
+    relationship :usbs, USB
     relationship :storage_controllers, StorageController, :dependent => :destroy
     relationship :shared_folders, SharedFolder
     relationship :extra_data, ExtraData
@@ -119,9 +133,8 @@ module VirtualBox
       # Returns an array of all available VMs.
       #
       # @return [Array<VM>]
-      def all
-        raw = Command.vboxmanage("list", "vms")
-        parse_vm_list(raw)
+      def all(reload=false)
+        Global.global(reload).vms
       end
 
       # Finds a VM by UUID or registered name and returns a
@@ -129,9 +142,20 @@ module VirtualBox
       #
       # @return [VM]
       def find(name)
-        new(raw_info(name))
-      rescue Exceptions::CommandFailedException
-        nil
+        all(true).detect { |o| o.name == name || o.uuid == name }
+      end
+
+      # Loads a VM from its XML configuration file. All VMs managed
+      # by VirtualBox have an XML configuration file somewhere. If
+      # given the path, this will instantiate the VM that way. Typically
+      # this method will only be called internally. Users of the class
+      # should use {all} or {find} instead.
+      #
+      # @param [String] location Full path to the XML file.
+      # @return [VM]
+      def load_from_xml(location)
+        vm_doc = Command.parse_xml(location)
+        new(vm_doc)
       end
 
       # Imports a VM, blocking the entire thread during this time.
@@ -147,16 +171,6 @@ module VirtualBox
         find(parse_vm_name(raw))
       end
 
-      # Gets the non-machine-readable info for a given VM and returns
-      # it as a raw string.
-      #
-      # **This method typically won't be used except internally.**
-      #
-      # @return [String]
-      def human_info(name)
-        Command.vboxmanage("showvminfo", name)
-      end
-
       # Gets the VM info (machine readable) for a given VM and returns it
       # as a hash.
       #
@@ -204,6 +218,17 @@ module VirtualBox
         return nil unless raw =~ /VM name "(.+?)"/
         $1.to_s
       end
+
+      def populate_relationship(caller, doc)
+        result = Proxies::Collection.new(caller)
+
+        doc.css("Global MachineRegistry MachineEntry").each do |entry|
+          location = Global.expand_path(entry[:src])
+          result << load_from_xml(location)
+        end
+
+        result
+      end
     end
 
     # Creates a new instance of a virtual machine.
@@ -215,8 +240,77 @@ module VirtualBox
     def initialize(data)
       super()
 
-      populate_attributes(data)
-      @original_name = data[:name]
+      initialize_attributes(data)
+      populate_relationships(data)
+      @original_name = name
+    end
+
+    def initialize_attributes(doc)
+      attribute_associations = {
+        :uuid     => ["Machine", :uuid],
+        :name     => ["Machine", :name],
+        :ostype   => ["Machine", :OSType],
+        :description => ["Machine Description"],
+        :memory   => ["Hardware Memory", :RAMSize],
+        :vram     => ["Hardware Display", :VRAMSize],
+        :acpi     => ["Hardware BIOS ACPI", :enabled],
+        :ioapic   => ["Hardware BIOS IOAPIC", :enabled],
+        :cpus     => ["Hardware CPU", :count],
+        :pae      => ["Hardware CPU PAE", :enabled],
+        :hwvirtex => ["Hardware CPU HardwareVirtEx", :enabled],
+        :hwvirtexexcl => ["Hardware CPU HardwareVirtEx", :exclusive],
+        :nestedpaging => ["Hardware CPU HardwareVirtExNestedPaging", :enabled],
+        :vtxvpid  => ["Hardware CPU HardwareVirtExVPID", :enabled],
+        :accelerate3d => ["Hardware Display", :accelerate3D],
+        :accelerate2dvideo => ["Hardware Display", :accelerate2DVideo],
+        :biosbootmenu => ["Hardware BIOS BootMenu", :mode],
+        :boot1    => ["Hardware Boot Order[position=\"1\"]", :device],
+        :boot2    => ["Hardware Boot Order[position=\"2\"]", :device],
+        :boot3    => ["Hardware Boot Order[position=\"3\"]", :device],
+        :boot4    => ["Hardware Boot Order[position=\"4\"]", :device],
+        :clipboard  => ["Hardware Clipboard", :mode],
+        :monitorcount => ["Hardware Display", :monitorCount],
+        :usb  => ["Hardware USBController", :enabled],
+        :ehci => ["Hardware USBController", :enabledEhci],
+        :audio            => ["Hardware AudioAdapter", :enabled],
+        :audiocontroller => ["Hardware AudioAdapter", :controller],
+        :audiodriver     => ["Hardware AudioAdapter", :driver],
+        :vrdp            => ["Hardware RemoteDisplay", :enabled],
+        :vrdpport        => ["Hardware RemoteDisplay", :port],
+        :vrdpauthtype    => ["Hardware RemoteDisplay", :authType],
+        :vrdpauthtimeout => ["Hardware RemoteDisplay", :authTimeout],
+      }
+
+      attribute_associations.each do |name, search_data|
+        css, key = search_data
+        node = doc.css(css)[0]
+
+        # key is passed in for attributes, else you get the element inner text
+        value = (key ? node[key] : node.inner_text) if node
+
+        # Special cases
+        value = value[1..-2] if name == :uuid
+
+        write_attribute(name, value)
+      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
+
+    def load_attribute(name)
+      info = self.class.raw_info(@original_name)
+
+      if name == :state
+        # Simply force a state reload, and it'll write the attribute up
+        write_attribute(:state, info[:vmstate])
+      end
+
+      write_attribute(:synthcpu, info[:synthcpu]) unless loaded_attribute?(:synthcpu)
     end
 
     # State of the virtual machine. Returns the state of the virtual
@@ -228,8 +322,7 @@ module VirtualBox
     # @return [String] Virtual machine state.
     def state(reload=false)
       if reload
-        info = self.class.raw_info(@original_name)
-        write_attribute(:state, info[:vmstate])
+        load_attribute(:state)
       end
 
       read_attribute(:state)
@@ -248,6 +341,9 @@ module VirtualBox
 
       super()
 
+      # Force reload
+      Global.reload!
+
       true
     rescue Exceptions::CommandFailedException
       raise if raise_errors
@@ -420,7 +516,12 @@ module VirtualBox
       # unregistering a VM
       super
 
-      Command.vboxmanage("unregistervm", @original_name, "--delete")
+      if Command.vboxmanage("unregistervm", @original_name, "--delete")
+        Global.reload!
+        return true
+      else
+        return false
+      end
     end
 
     # Returns true if the virtual machine state is running