virtualbox-com 0.9.6

data/lib/virtualbox/com/model/4.2.rb

@@ -0,0 +1,97 @@
+require_relative '4.2-gen'
+
+module VirtualBox
+module COM
+module Model
+
+class Progress < AbstractInterface
+    # This method blocks the execution while the operations represented
+    # by this {Progress} object execute, but yields a block every `x`
+    # percent (interval given in parameters).
+    def wait(interval_percent=1)
+        # If no block is given we just wait until completion, not worrying
+        # about tracking percentages.
+        if !block_given?
+            wait_for_completion(-1)
+            return
+        end
+
+        # Initial value forces the 0% yield
+        last_reported = -100
+
+        while true
+            delta = percent - last_reported
+            last_reported += delta
+            yield self if delta >= interval_percent
+            
+            # This either sleeps for half a second or returns on completion
+            wait_for_completion(500)
+            
+            break if completed || canceled
+            
+            # Pass off execution so other threads can run
+            Thread.pass
+        end
+    end
+end
+
+
+class EventSource < AbstractInterface
+    MODEL_MAP = {
+        :machine_event                    => :MachineEvent,
+        :snapshot_event                   => :SnapshotEvent,
+        :on_machine_state_changed         => :MachineStateChangedEvent,
+        :on_machine_data_changed          => :MachineDataChangedEvent,
+        :on_extra_data_changed            => :ExtraDataChangedEvent,
+        :on_extra_data_can_change         => :ExtraDataCanChangeEvent,
+        :on_medium_registered             => :MediumRegisteredEvent,
+        :on_machine_registered            => :MachineRegisteredEvent,
+        :on_session_state_changed         => :SessionStateChangedEvent,
+        :on_snapshot_taken                => :SnapshotTakenEvent,
+        :on_snapshot_deleted              => :SnapshotDeletedEvent,
+        :on_snapshot_changed              => :SnapshotChangedEvent,
+        :on_guest_property_changed        => :GuestPropertyChangedEvent,
+        :on_mouse_pointer_shape_changed   => :MousePointerShapEvent,
+        :on_mouse_capability_changed      => :MouseCapabilityChangedEvent,
+        :on_keyboard_leds_changed         => :KeyboardLedsChangedEvent,
+        :on_state_changed                 => :StateChangedEvent,
+        :on_additions_state_changed       => :AdditionsStateChangedEvent,
+        :on_network_adapter_changed       => :NetworkAdapterChangedEvent,
+        :on_serial_port_changed           => :SerialPortChangedEvent,
+        :on_parallel_port_changed         => :ParallelPortChangedEvent,
+        :on_storage_controller_changed    => :StorageControllerChangedEvent,
+        :on_medium_changed                => :MediumChangedEvent,
+        :on_vrde_server_changed           => :VRDEServerChangedEvent,
+        :on_usb_controller_changed        => :USBControllerChangedEvent,
+        :on_usb_device_state_changed      => :USBDeviceStateChangedEvent,
+        :on_shared_folder_changed         => :SharedFolderChangedEvent,
+        :on_runtime_error                 => :RuntimeErrorEvent,
+        :on_can_show_window               => :CanShowWindowEvent,
+        :on_show_window                   => :ShowWindowEvent,
+        :on_cpu_changed                   => :CPUChangedEvent,
+        :on_vrde_server_info_changed      => :VRDEServerInfoChangedEvent,
+        :on_event_source_changed          => :EventSourceChangedEvent,
+        :on_cpu_execution_cap_changed     => :CPUExecutionCapChangedEvent,
+        :on_guest_keyboard                => :GuestKeyboardEvent,
+        :on_guest_mouse                   => :GuestMouseEvent,
+        :on_nat_redirect                  => :NATRedirectEvent,
+        :on_host_pci_device_plug          => :HostPCIDevicePlugEvent,
+        :on_vbox_svc_availability_changed => :VBoxSVCAvailabilityChangedEvent,
+        :on_bandwidth_group_changed       => :BandwidthGroupChangedEvent,
+        :on_guest_monitor_changed         => :GuestMonitorChangedEvent,
+        :on_storage_device_changed        => :StorageDeviceChangedEvent,
+        :on_clipboard_mode_changed        => :ClipboardModeChangedEvent,
+        :on_drag_and_drop_mode_changed    => :DragAndDropModeChangedEvent,
+    }
+
+    def getEvent(*args)
+        if e = get_event(*args)
+            (model = MODEL_MAP[e.type]) ? e.cast(model) : e
+        end
+    end
+end
+
+
+end
+end
+end

data/lib/virtualbox/com/util.rb

@@ -0,0 +1,119 @@
+module VirtualBox
+module COM
+
+module Util
+    def self.platform
+        case RbConfig::CONFIG["host_os"].downcase
+        when /darwin/             then :mac
+        when /mswin|mingw|cygwin/ then :windows
+        when /linux/              then :linux
+        when /solaris/            then :solaris
+        when /freebsd/            then :freebsd
+        else                           :unknown
+        end
+    end
+    def self.jruby?
+        RbConfig::CONFIG["ruby_install_name"] == "jruby"
+    end
+
+
+    # An "almost complete" camel-caser. Camel cases a string with a few
+    # exceptions. For example: `get_foo` becomes `GetFoo`, but `get_os_type`
+    # becomes `GetOSType` since `os` is a special case.
+    #
+    # @param [String] string The string to camel case
+    # @return [String]
+    def self.camelize(string)
+        string.to_s.split(/_/).map {|part|
+            CAMELCASE_SPECIALS[part] || part.capitalize }.join
+    end
+
+    def self.uncamelize(name)
+        CAMELCASE_SPECIALS.each{|k,v|
+            name = name.gsub(v, k.capitalize) }
+        name.gsub(/([A-Z])/, "_\\0").downcase.gsub(/^_/, '')
+    end
+
+    CAMELCASE_SPECIALS = { # Order is important 
+        "fourcc_rgb" => "FOURCC_RGB",
+        "am79c970a"  => "Am79C970A",
+        "am79c973"   => "Am79C973",
+        "i82540em"   => "I82540EM",
+        "i82543gc"   => "I82543GC",
+        "i82545em"   => "I82545EM",
+        "efidual"    => "EFIDUAL",
+        "split2g"    => "Split2G",
+        "cpuid"      => "CPUID",
+        "cdrom"      => "CDROM",
+        "efi32"      => "EFI32",
+        "efi64"      => "EFI64",
+        "piix3"      => "PIIX3",
+        "piix4"      => "PIIX4",
+        "winmm"      => "WinMM",
+        "ac97"       => "AC97",
+        "acpi"       => "ACPI",
+        "alsa"       => "ALSA",
+        "apic"       => "APIC",
+        "bios"       => "BIOS",
+        "csam"       => "CSAM",
+        "dhcp"       => "DHCP",
+        "fifo"       => "FIFO",
+        "ich6"       => "ICH6",
+        "ich9"       => "ICH9",
+        "macs"       => "MACs",
+        "mmpm"       => "MMPM",
+        "patm"       => "PATM",
+        "sata"       => "SATA",
+        "sb16"       => "SB16",
+        "scsi"       => "SCSI",
+        "slip"       => "SLIP",
+        "tftp"       => "TFTP",
+        "vbox"       => "VBox",
+        "vpid"       => "VPID",
+        "vram"       => "VRAM",
+        "vrde"       => "VRDE",
+        "vrdp"       => "VRDP",
+        "api"        => "API",
+        "cpu"        => "CPU",
+        "dns"        => "DNS",
+        "dvd"        => "DVD",
+        "efi"        => "EFI",
+        "esx"        => "ESX",
+        "gid"        => "GID",
+        "hda"        => "HDA",
+        "hdd"        => "HDD",
+        "ide"        => "IDE",
+        "irq"        => "IRQ",
+        "mac"        => "MAC",
+        "nat"        => "NAT",
+        "oss"        => "OSS",
+        "pae"        => "PAE",
+        "pci"        => "PCI",
+        "pid"        => "PID",
+        "png"        => "PNG",
+        "ppp"        => "PPP",
+        "ps2"        => "PS2",
+        "pxe"        => "PXE",
+        "ram"        => "RAM",
+        "rtc"        => "RTC",
+        "sas"        => "SAS",
+        "svc"        => "SVC",
+        "tcp"        => "TCP",
+        "udp"        => "UDP",
+        "uid"        => "UID",
+        "usb"        => "USB",
+        "utc"        => "UTC",
+        "vdi"        => "VDI",
+        "vfs"        => "VFS",
+        "3d"         => "3D",
+        "hw"         => "HW",
+        "io"         => "IO",
+        "ip"         => "IP",
+        "os"         => "OS",
+        "vm"         => "VM",
+    }
+
+end
+
+end
+end

data/lib/virtualbox/com/version.rb

@@ -0,0 +1,5 @@
+module VirtualBox
+module COM
+    VERSION = "0.9.6"
+end
+end

data/lib/virtualbox/com/xpcomc-ffi.rb

@@ -0,0 +1,76 @@
+# Load FFI support
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
+  require 'ffi'
+end
+
+
+# Add model types to fit XPCOMC FFI implementation:
+#  INT8, INT16, INT32, INT64, UINT8, UINT16, UINT32, UINT64, WSTRING, BOOL
+require_relative 'xpcomc-ffi/model-types'
+
+module VirtualBox
+module COM
+class IID
+    class FFIStruct < ::FFI::Struct
+        layout :m0, :uint32,
+               :m1, :uint16,
+               :m2, :uint16,
+               :m3, [:uint8, 8]
+    end
+
+    def to_ffi
+        @ffi ||= begin
+                     data = FFIStruct.new
+                     data[:m0] = to_a[0]
+                     data[:m1] = to_a[1]
+                     data[:m2] = to_a[2]
+                     to_a[3..-1].each_index{|i| data[:m3][i] = to_a[3..-1][i] }
+                     data.freeze
+                 end
+    end
+end
+end
+end
+
+module VirtualBox
+module COM
+class AbstractInterface
+    def self.to_ffi
+        :pointer
+    end
+end
+end
+end
+
+
+module VirtualBox
+module COM
+class AbstractEnum
+    def self.to_ffi
+        UINT32
+    end
+end
+end
+end
+
+
+# Load FFI implementation
+require_relative 'xpcomc-ffi/xpcomc-vbox'
+require_relative 'xpcomc-ffi/binding'
+require_relative 'xpcomc-ffi/implementer'
+require_relative 'xpcomc-ffi/spec'
+require_relative 'xpcomc-ffi/lib'
+
+# Patch VirtualBox::COM
+module VirtualBox
+module COM
+    Implementer = XPCOMC::Implementer
+    Spec        = XPCOMC::Spec
+
+    def self.virtualbox ; XPCOMC::Lib.virtualbox ; end
+    def self.session    ; XPCOMC::Lib.session    ; end    
+end
+end
+
+# Init library
+VirtualBox::COM::XPCOMC::Lib.init

data/lib/virtualbox/com/xpcomc-ffi/binding.rb

@@ -0,0 +1,87 @@
+module VirtualBox
+module COM
+module XPCOMC
+
+# The Binding class hold all the FFI infrastructure
+class Binding
+    extend ::FFI::Library
+    attr_reader :object
+
+
+    # Retrieve a Binding class corresponding to the Model
+    # This will avoid polluting the model object with implementation data
+    def self.get(name)
+        Binding.const_get(name, false)
+    rescue NameError
+        const_set(name, Class.new(Binding)).bind(Model.get(name))
+    end
+
+
+    # Create the binding with the Model class
+    # This will also create the internal classes Object and Vtbl
+    # representing the FFI::Struct, all the necessary callbacks,
+    # a hash of the name/signatures
+    def self.bind(model)
+        raise "model already bound" if const_defined?(:Object, false)
+
+        # List of functions (name, signature)
+        # Defined in the order they appear in the Model definition
+        sigs = model.members.inject({}) do |list, spec| 
+            list.merge!(spec.signatures) 
+        end
+        const_set(:Sig, sigs)
+
+        # Register ffi callbacks
+        sigs.each {|name, sig| callback(name, sig.to_ffi, :uint) }
+
+        # Object layout
+        const_set(:Object, Class.new(::FFI::Struct))
+            .layout(:vtbl, :pointer)
+        
+        # Vtbl layout
+        const_set(:Vtbl,   Class.new(::FFI::Struct))
+            .layout(*sigs.map {|name,| [name, name] }.flatten)
+        
+        # IID
+        const_set(:IID, model::IID.to_ffi)
+
+        # Model
+        const_set(:Model, model)
+
+        self
+    end
+
+
+    # Initializes the interface to the FFI struct with the given pointer. The
+    # pointer is used to initialize the Object which is used to initialize
+    # the Vtbl itself.
+    def initialize(pointer)
+        @object = self.class::Object.new(pointer)
+        @vtbl   = self.class::Vtbl.new(@object[:vtbl])
+    end
+
+
+    # Calls a function on the vtbl of the FFI struct. This function handles
+    # converting the spec to proper arguments and also handles reading out
+    # the arguments, dereferencing pointers, setting up objects, etc. so that
+    # the return value is filled with nicely formatted Ruby objects.
+    #
+    # If the vtbl function being called only has one out parameter, then the
+    # return value will be that single object. If it has multiple, then it will
+    # be an array of objects.
+    def call(name, *args)
+        unless sig = self.class::Sig[name]
+            raise ArgumentError, "unknown function #{name} in Vtbl"
+        end
+        ffi_args = sig.prepare_args(args)
+        result   = @vtbl[name].call(@object, *ffi_args)        
+        if (result & 0x8000_0000) != 0
+            raise COMException, :vtbl => name, :code => result
+        end
+        sig.retrieve_values(ffi_args)
+    end
+end
+
+end
+end
+end

data/lib/virtualbox/com/xpcomc-ffi/implementer.rb

@@ -0,0 +1,86 @@
+module VirtualBox
+module COM
+module XPCOMC
+
+# Implementer is a wrapper for the Binding class.
+# Performs lazy initialisation and enhance function call
+class Implementer
+    EXCEPTION_MAP = Hash.new(COMException).merge!({
+        0x8000_4001 => NotImplementedException,
+        0x8000_4002 => NoInterfaceException,
+        0x80BB_0001 => ObjectNotFoundException,
+        0x80BB_0002 => InvalidVMStateException,
+        0x80BB_0003 => VMErrorException,
+        0x80BB_0004 => FileErrorException,
+        0x80BB_0005 => SubsystemException,
+        0x80BB_0006 => PDMException,
+        0x80BB_0007 => InvalidObjectStateException,
+        0x80BB_0008 => HostErrorException,
+        0x80BB_0009 => NotSupportedException,
+        0x80BB_000A => XMLErrorException,
+        0x80BB_000B => InvalidSessionStateException,
+        0x80BB_000C => ObjectInUseException,
+        0x8007_0057 => InvalidArgException
+    }).freeze
+
+
+    # Initialize implementation of the COM interface
+    def initialize(interface, pointer)
+        unless interface.kind_of?(AbstractInterface)
+            raise ArgumentError, "only COM interface can be implemented"
+        end
+        @interface = interface	# For lazy creation of the
+        @pointer   = pointer	#  "binding" attribute
+    end
+
+
+    # Cast to another interface.
+    # Will raise NoInterfaceException if not supported
+    def cast(interface, pointer)
+        iid = Binding.get(interface)::IID
+        Model.create(interface, binding.call(:QueryInterface, iid))
+    rescue COMException => e
+        e.data.merge!(:mode => :cast)
+        raise EXCEPTION_MAP[e.data[:code]], e.data
+    end
+
+    # Reads a property 
+    def read_property(spec)
+        binding.call(spec.getter)
+    rescue COMException => e
+        e.data.merge!(:property => spec.name, :mode => :read)
+        raise EXCEPTION_MAP[e.data[:code]], e.data
+    end
+
+    # Writes a property
+    def write_property(spec, value)
+        binding.call(spec.setter, [value])
+    rescue COMException => e
+        e.data.merge!(:property => spec.name, :mode => :write)
+        raise EXCEPTION_MAP[e.data[:code]], e.data
+    end
+
+    # Calls a function
+    def call_function(spec, *args)
+        binding.call(spec.name,   *args)
+    rescue COMException => e
+        e.data.merge!(:function => spec.name, :mode => :call)
+        raise EXCEPTION_MAP[e.data[:code]], e.data
+    end
+
+
+    #--[ Private ]---------------------------------------------------------
+#    private
+
+    # Lazy initialisation of the binding attribute
+    def binding
+        @binding ||= begin
+                         name = @interface.class.name.split("::").last
+                         Binding.get(name).new(@pointer)
+                     end
+    end
+end
+
+end
+end
+end