bbrowning-virtualbox 0.7.6.dev

data/lib/virtualbox/com/nil_interface.rb

@@ -0,0 +1,7 @@
+module VirtualBox
+  module COM
+    # Used for tests
+    class NilInterface < BaseInterface
+    end
+  end
+end

data/lib/virtualbox/com/util.rb

@@ -0,0 +1,32 @@
+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
+
+        # Gets an interface within the current version namespace.
+        def versioned_interface(interface)
+          Object.module_eval("::VirtualBox::COM::Interface::#{version_const}::#{interface}")
+        end
+
+        # Returns a namespace representation for a version.
+        def version_const
+          "Version_" + @__version.upcase.gsub(".", "_")
+        end
+
+        def set_interface_version(version)
+          @__version = version
+        end
+      end
+    end
+  end
+end

data/lib/virtualbox/cpu.rb

@@ -0,0 +1,61 @@
+module VirtualBox
+  # Represents the CPU properties on a VM.
+  class CPU < 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 :pae, :boolean => true
+      attribute :synthetic, :boolean => true
+    end
+
+    class << self
+      # Populates a relationship with another model.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [CPU]
+      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_cpu_property(key)
+    end
+
+    def set_property(interface, key, value)
+      interface.set_cpu_property(key, value)
+    end
+
+    def validate
+      super
+
+      validates_inclusion_of :pae, :synthetic, :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/dhcp_server.rb

@@ -0,0 +1,89 @@
+module VirtualBox
+  class DHCPServer < AbstractModel
+    attribute :parent, :readonly => true, :property => false
+    attribute :parent_collection, :readonly => true, :property => false
+    attribute :interface, :readonly => true, :property => false
+    attribute :enabled
+    attribute :ip_address
+    attribute :network_mask
+    attribute :network_name, :readonly => true
+    attribute :lower_ip
+    attribute :upper_ip
+
+    class << self
+      # Populates a relationship with another model.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [Array<DHCPServer>]
+      def populate_relationship(caller, servers)
+        relation = Proxies::Collection.new(caller, self)
+
+        servers.each do |interface|
+          relation << new(interface)
+        end
+
+        relation
+      end
+
+      # Creates a DHCP server for the given network name.
+      # This method should not be called directly, its recommended that you call
+      # the `create` method on the `dhcp_servers` relationship on
+      # `VirtualBox::Global` object.
+      def create(proxy, network_name)
+        interface = proxy.parent.lib.virtualbox.create_dhcp_server(network_name)
+        new(interface)
+      end
+    end
+
+    def initialize(raw)
+      initialize_attributes(raw)
+    end
+
+    def initialize_attributes(raw)
+      write_attribute(:interface, raw)
+
+      load_interface_attributes(interface)
+      existing_record!
+    end
+
+    def added_to_relationship(proxy)
+      write_attribute(:parent, proxy.parent)
+      write_attribute(:parent_collection, proxy)
+    end
+
+    def save
+      configs = [:ip_address, :network_mask, :lower_ip, :upper_ip]
+      configs_changed = configs.map { |key| changed?(key) }.any? { |i| i }
+
+      if configs_changed
+        interface.set_configuration(ip_address, network_mask, lower_ip, upper_ip)
+
+        # Clear the dirtiness so that the abstract model doesn't try
+        # to save the attributes
+        configs.each do |key|
+          clear_dirty!(key)
+        end
+      end
+
+      save_changed_interface_attributes(interface)
+    end
+
+    # Removes the DHCP server.
+    def destroy
+      parent.lib.virtualbox.remove_dhcp_server(interface)
+      parent_collection.delete(self, true)
+      true
+    end
+
+    # Returns the host network associated with this DHCP server, if it
+    # exists.
+    def host_network
+      return nil unless network_name =~ /^HostInterfaceNetworking-(.+?)$/
+
+      parent.host.network_interfaces.detect do |i|
+        i.interface_type == :host_only && i.name == $1.to_s
+      end
+    end
+  end
+end

data/lib/virtualbox/dvd.rb

@@ -0,0 +1,27 @@
+module VirtualBox
+  # Represents a DVD image stored by VirtualBox. These DVD images can be
+  # 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
+  #
+  # The only method at the moment of finding DVDs is to use {DVD.all}, which
+  # returns an array of {DVD}s.
+  #
+  #     DVD.all
+  #
+  class DVD < Medium
+    class << self
+      # Returns an array of all available DVDs as DVD objects
+      def all
+        Global.global.media.dvds
+      end
+
+      # Override of {Medium.device_type}.
+      def device_type
+        :dvd
+      end
+    end
+  end
+end

data/lib/virtualbox/exceptions.rb

@@ -0,0 +1,39 @@
+module VirtualBox
+  # Gem specific exceptions will reside under this namespace for easy
+  # documentation and searching.
+  module Exceptions
+    class Exception < ::Exception; end
+
+    class NonSettableRelationshipException < Exception; end
+    class ValidationFailedException < Exception; end
+    class MediumLocationInUseException < Exception; end
+    class MediumCreationFailedException < Exception; end
+    class MediumNotUpdatableException < Exception; end
+    class ReadonlyVMStateException < Exception; end
+    class UnsupportedVersionException < 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/byte_normalizer.rb

@@ -0,0 +1,17 @@
+module VirtualBox::ByteNormalizer
+  # So that this is only defined once (suppress warnings)
+  if !defined?(THOUSAND)
+    THOUSAND = 1024.0
+    BYTE = 1.0
+    KILOBYTE = BYTE * THOUSAND
+    MEGABYTE = KILOBYTE * THOUSAND
+  end
+
+  def bytes_to_megabytes(b)
+    b / MEGABYTE
+  end
+
+  def megabytes_to_bytes(mb)
+    mb * MEGABYTE
+  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

@@ -0,0 +1,27 @@
+require 'rbconfig'
+
+module VirtualBox
+  class Platform
+    class << self
+      def mac?
+        platform.include?("darwin")
+      end
+
+      def windows?
+        platform.include?("mswin") || platform.include?("mingw") || platform.include?("cygwin")
+      end
+
+      def linux?
+        platform.include?("linux")
+      end
+
+      def solaris?
+        platform.include?("solaris")
+      end
+
+      def platform
+        RbConfig::CONFIG["target_os"].downcase
+      end
+    end
+  end
+end

data/lib/virtualbox/ext/subclass_listing.rb

@@ -0,0 +1,24 @@
+# From: http://snippets.dzone.com/posts/show/2992
+module VirtualBox::SubclassListing
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def subclasses(direct = false)
+      classes = []
+      if direct
+        ObjectSpace.each_object(Class) do |c|
+          next unless c.superclass == self
+          classes << c
+        end
+      else
+        ObjectSpace.each_object(Class) do |c|
+          next unless c.ancestors.include?(self) and (c != self)
+          classes << c
+        end
+      end
+      classes
+    end
+  end
+end

data/lib/virtualbox/extra_data.rb

@@ -0,0 +1,127 @@
+module VirtualBox
+  # Represents "extra data" which can be set on a specific
+  # virtual machine or on VirtualBox as a whole. Extra data is persistent
+  # key-value storage which is available as a way to store any information
+  # wanted. VirtualBox uses it for storing statistics and settings. You can
+  # use it for anything!
+  #
+  # # Extra Data on a Virtual Machine
+  #
+  # Setting extra data on a virtual machine is easy. All {VM} objects have a
+  # `extra_data` relationship which is just a simple ruby hash, so you can treat
+  # it like one! Once the data is set, simply saving the VM will save the
+  # extra data. An example below:
+  #
+  #     vm = VirtualBox::VM.find("FooVM")
+  #     vm.extra_data["ruby-accessed"]  = "yes, yes it was"
+  #     vm.save
+  #
+  # Now, let's say you open up the VM again some other time:
+  #
+  #     vm = VirtualBox::VM.find("FooVM")
+  #     puts vm.extra_data["ruby-accessed"]
+  #
+  # It acts just like a hash!
+  #
+  # # Global Extra Data
+  #
+  # Extra data doesn't need to be tied to a specific virtual machine. It can also
+  # exist globally. Setting global extra-data is just as easy:
+  #
+  #     VirtualBox::ExtraData.global["some-key"] = "some value"
+  #     VirtualBox::ExtraData.global.save
+  #
+  class ExtraData < Hash
+    include AbstractModel::Dirty
+
+    attr_accessor :parent
+    attr_reader :interface
+
+    @@global_data = nil
+
+    class << self
+      # Gets the global extra data. This will "cache" the data for
+      # future use unless you set the `reload` paramter to true.
+      #
+      # @param [Boolean] reload If true, will reload new global data.
+      # @return [Array<ExtraData>]
+      def global(reload=false)
+        if !@@global_data || reload
+          @@global_data = Global.global.extra_data
+        end
+
+        @@global_data
+      end
+
+      # Populates a relationship with another model.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [Array<ExtraData>]
+      def populate_relationship(caller, interface)
+        data = new(caller, interface)
+
+        interface.get_extra_data_keys.each do |key|
+          data[key] = interface.get_extra_data(key)
+        end
+
+        data.clear_dirty!
+        data
+      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, data)
+        data.save
+      end
+    end
+
+    # Initializes an extra data object.
+    #
+    # @param [Hash] data Initial attributes to populate.
+    def initialize(parent, interface)
+      @parent = parent
+      @interface = interface
+    end
+
+    # Set an extradata key-value pair. Overrides ruby hash implementation
+    # to set dirty state. Otherwise that, behaves the same way.
+    def []=(key,value)
+      set_dirty!(key, self[key], value)
+      super
+    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.
+    #
+    # @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
+      changes.each do |key, value|
+        interface.set_extra_data(key.to_s, value[1].to_s)
+
+        clear_dirty!(key)
+
+        if value[1].nil?
+          # Remove the key from the hash altogether
+          hash_delete(key.to_s)
+        end
+      end
+    end
+
+    # Alias away the old delete method so its still accessible somehow
+    alias :hash_delete :delete
+
+    # Deletes the specified extra data.
+    #
+    # @param [String] key The extra data key to delete
+    def delete(key)
+      interface.set_extra_data(key.to_s, nil)
+      hash_delete(key.to_s)
+    end
+  end
+end