vixen 0.0.3 → 0.0.4

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -19,13 +19,19 @@ Vixen can also be used on virtual machines that are not currently active:
 ```ruby
 require 'vixen'
 path = '/Users/jeff/Documents/Virtual Machines/win2003sat.vmwarevm/Windows Server 2003 Enterprise x64 Edition.vmx'
-puts Vixen.local_connect.open_vm(path).current_snapshot.full_name
+puts Vixen.local_connect.open_vm(path).power_on.current_snapshot.full_name
 ```
 
+Capabilities
+------------
+
+ * View running VMs
+ * Control power state (on, off, suspend, reset) of VMs
+ * Viewing the current snapshot
+
 Limitations
 -----------
-Vixen currently only supports VMware Fusion 5.
-It also only lists the current snapshot of each of the running virtual machines.
+Vixen currently only supports running on Mac OS X or Linux.
 
 See Also
 --------

data/lib/vixen/bridge.rb

@@ -43,27 +43,27 @@ module Vixen::Bridge
   attach_function :Vix_FreeBuffer, [:pointer], :void
   attach_function :VixVM_GetCurrentSnapshot, [:handle, :pointer], :int
   attach_function :VixSnapshot_GetParent, [:handle, :pointer], :int
+  attach_function :VixVM_PowerOn, [:handle, :int, :handle, :VixEventProc, :pointer], :handle
 
   def self.connect(hostType, hostname, port, username, password)
     job_handle = VixHandle[:invalid]
     host_handle = VixHandle[:invalid]
-    job_handle = VixHost_Connect(VixApiVersion[:api_version], 
-                                 hostType, 
-                                 hostname, 
-                                 port, 
-                                 username, 
-                                 password, 
-                                 0, 
-                                 VixHandle[:invalid], 
-                                 nil, 
+    job_handle = VixHost_Connect(VixApiVersion[:api_version],
+                                 hostType,
+                                 hostname,
+                                 port,
+                                 username,
+                                 password,
+                                 0,
+                                 VixHandle[:invalid],
+                                 nil,
                                  nil)
     host_handle = pointer_to_handle do |host_handle_pointer|
-      VixJob_Wait(job_handle, 
-                  VixPropertyId[:job_result_handle], 
-                  :pointer, host_handle_pointer, 
-                  :int, VixPropertyId[:none])
+      VixJob_Wait job_handle, VixPropertyId[:job_result_handle],
+                  :pointer, host_handle_pointer,
+                  :int, VixPropertyId[:none]
     end
-    Vix_ReleaseHandle(job_handle)
+    Vix_ReleaseHandle job_handle
     host_handle
   end
 
@@ -74,7 +74,7 @@ module Vixen::Bridge
       raise "problem executing pointer_to_handle block. (error: %s, %s)" %
         [err, Vix_GetErrorText(err, nil)]
     end
-    pointer.send("read_#{type}".to_sym)
+    pointer.send "read_#{type}".to_sym
   end
 
   def self.pointer_to_handle(&block)
@@ -85,6 +85,20 @@ module Vixen::Bridge
     pointer_to :pointer, &block
   end
 
+  def self.pointer_to_int(&block)
+    pointer_to :int, &block
+  end
+
+  def self.wait_for_async_job(operation, &block)
+    job_handle = yield
+    err = VixJob_Wait job_handle, VixPropertyId[:none]
+    unless err == VixError[:ok]
+      raise "couldn't %s. (error: %s, %s)" %
+        [operation, err, Vix_GetErrorText(err, nil)]
+    end
+    Vix_ReleaseHandle job_handle
+  end
+
   def self.running_vms(host_handle)
     available_vms = []
 
@@ -105,19 +119,18 @@ module Vixen::Bridge
     # FIXME: we seem to go into deadlock without this sleep
     # I'm not exactly sure why
     sleep 0.5
-    err = VixJob_Wait(job_handle, 
-                      VixPropertyId[:none] )
+    err = VixJob_Wait job_handle, VixPropertyId[:none]
 
-    Vix_ReleaseHandle(job_handle)
+    Vix_ReleaseHandle job_handle
     available_vms
   end
 
   def self.disconnect(handle)
-    VixHost_Disconnect(handle)
+    VixHost_Disconnect handle
   end
 
   def self.destroy(handle)
-    Vix_ReleaseHandle(handle)
+    Vix_ReleaseHandle handle
   end
 
   def self.open_vm(host_handle, vm_path)
@@ -133,26 +146,25 @@ module Vixen::Bridge
                   :pointer, vm_handle_pointer,
                   :int, VixPropertyId[:none])
     end
-    Vix_ReleaseHandle(job_handle)
+    Vix_ReleaseHandle job_handle
     vm_handle
   end
 
   def self.current_snapshot(vm_handle)
     pointer_to_handle do |snapshot_handle_pointer|
-      VixVM_GetCurrentSnapshot(vm_handle, snapshot_handle_pointer)
+      VixVM_GetCurrentSnapshot vm_handle, snapshot_handle_pointer
     end
   end
 
   def self.get_parent(snapshot_handle)
     pointer_to_handle do |snapshot_handle_pointer|
-      VixSnapshot_GetParent(snapshot_handle, snapshot_handle_pointer)
+      VixSnapshot_GetParent snapshot_handle, snapshot_handle_pointer
     end
   end
 
   def self.get_string_property(handle, property_id)
     string = pointer_to_string do |string_pointer|
-      Vix_GetProperties(handle,
-                        property_id,
+      Vix_GetProperties(handle, property_id,
                         :pointer, string_pointer,
                         :int, VixPropertyId[:none])
     end
@@ -161,4 +173,40 @@ module Vixen::Bridge
     return value
   end
 
+  def self.get_int_property(handle, property_id)
+    pointer_to_int do |int_pointer|
+      Vix_GetProperties(handle, property_id,
+                        :pointer, int_pointer,
+                        :int, VixPropertyId[:none])
+    end
+  end
+
+  def self.power_on(vm_handle)
+    wait_for_async_job "power on VM" do
+      VixVM_PowerOn vm_handle, VixVMPowerOptions[:normal], VixHandle[:invalid], nil, nil
+    end
+  end
+
+  def self.power_off(vm_handle)
+    wait_for_async_job "power off VM" do
+      VixVM_PowerOff vm_handle, VixVMPowerOptions[:normal], nil, nil
+    end
+  end
+
+  def self.reset(vm_handle)
+    wait_for_async_job "reset VM" do
+      VixVM_Reset vm_handle, VixVMPowerOptions[:normal], nil, nil
+    end
+  end
+
+  def self.suspend(vm_handle)
+    wait_for_async_job "suspend VM" do
+      VixVM_Suspend vm_handle, VixVMPowerOptions[:normal], nil, nil
+    end
+  end
+
+  def self.current_power_state(vm_handle)
+    get_int_property vm_handle, VixPropertyId[:vm_power_state]
+  end
+
 end

data/lib/vixen/constants.rb

@@ -21,7 +21,7 @@ module Vixen::Constants
                           :blob,    6 )
 
   VixError = enum( :ok, 0 )
-  
+
   VixPropertyId = enum( :none,                                     0,
                         :meta_data_container,                      2,
                         :host_hosttype,                           50,
@@ -94,4 +94,22 @@ module Vixen::Constants
                           :registered_vms, 4 )
 
   VixVMOpenOptions = enum( :normal, 0x0 )
+
+  VixVMPowerOptions = enum( :normal,                         0,
+                            :from_guest,                0x0004,
+                            :suppress_snapshot_poweron, 0x0080,
+                            :launch_gui,                0x0200,
+                            :start_vm_paused,           0x1000 )
+
+  VixPowerState = enum( :powering_off,   0x0001,
+                        :powered_off,    0x0002,
+                        :powering_on,    0x0004,
+                        :powered_on,     0x0008,
+                        :suspending,     0x0010,
+                        :suspended,      0x0020,
+                        :tools_running,  0x0040,
+                        :resetting,      0x0080,
+                        :blocked_on_msg, 0x0100,
+                        :paused,         0x0200,
+                        :resuming,       0x0800 )
 end

data/lib/vixen/model/vm.rb

@@ -6,4 +6,69 @@ class Vixen::Model::VM < Vixen::Model::Base
   def current_snapshot
     Vixen::Model::Snapshot.new(Vixen::Bridge.current_snapshot(handle))
   end
+
+  def power_on
+    return self if powered_on? or powering_on? or resuming?
+    Vixen::Bridge.power_on handle
+    self
+  end
+
+  def resume
+    power_on
+  end
+
+  def suspend
+    Vixen::Bridge.suspend handle
+    self
+  end
+
+  def power_off
+    Vixen::Bridge.power_off handle
+    self
+  end
+
+  def reset
+    Vixen::Bridge.reset handle
+    self
+  end
+
+  def powering_off?
+    current_power_states.include? :powering_off
+  end
+
+  def powered_off?
+    current_power_states.include? :powered_off
+  end
+
+  def powering_on?
+    current_power_states.include? :powering_on
+  end
+
+  def powered_on?
+    current_power_states.include? :powered_on
+  end
+
+  def resuming?
+    current_power_states.include? :resuming
+  end
+
+  def suspending?
+    current_power_states.include? :suspending
+  end
+
+  def suspended?
+    current_power_states.include? :suspended
+  end
+
+  def current_power_states
+    states = []
+    bitwise_state = Vixen::Bridge.current_power_state handle
+    [ :powering_off, :powered_off, :powering_on, :powered_on, :suspending,
+      :suspended, :tools_running, :resetting, :blocked_on_msg, :paused,
+      :resuming
+    ].each do |state|
+      states << state if ((bitwise_state & VixPowerState[state]) == VixPowerState[state])
+    end
+    states
+  end
 end

data/vixen.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'vixen'
-  s.version = '0.0.3'
+  s.version = '0.0.4'
   s.summary = 'Ruby bindings for VMware VIX API'
   s.description = <<-EOF
   Vixen is an easy way to interact with VMware virtual machines from Ruby. 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vixen
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -51,6 +51,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- Gemfile
 - LICENSE
 - MIT.LICENSE
 - README.md