vixen 0.0.6 → 0.0.7

data/lib/vixen.rb

@@ -1,6 +1,9 @@
 require 'ffi'
 
 module Vixen
+
+  @@logger = nil
+
   def self.local_connect(login = nil, password = nil)
     connect Vixen::Constants::VixServiceProvider[:vmware_workstation], nil, 0, login, password
   end
@@ -10,6 +13,18 @@ module Vixen
     Vixen::Model::Host.new(handle)
   end
 
+  def self.logger
+    return @@logger unless @@logger.nil?
+    require 'logger'
+    @@logger ||= Logger.new STDOUT
+    @@logger.level = Logger::WARN
+  end
+
+  def self.logger=(value)
+    @@logger = value
+  end
+
+  logger
 end
 
 $:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
@@ -20,4 +35,4 @@ require 'vixen/model/base'
 require 'vixen/model/host'
 require 'vixen/model/vm'
 require 'vixen/model/snapshot'
-
+require 'vixen/model/job'

data/lib/vixen/bridge.rb

@@ -1,11 +1,9 @@
 require 'ffi'
 require 'facter'
 
-module Vixen; end
 module Vixen::Bridge
   extend FFI::Library
 
-  require File.join(File.dirname(__FILE__), 'constants')
   extend Vixen::Constants
   include Vixen::Constants
 
@@ -46,11 +44,12 @@ module Vixen::Bridge
   attach_function :VixVM_PowerOn, [:handle, :int, :handle, :VixEventProc, :pointer], :handle
   attach_function :VixVM_CreateSnapshot, [:handle, :string, :string, :int, :handle, :VixEventProc, :pointer], :handle
   attach_function :VixJob_CheckCompletion, [:handle, :pointer], :int
+  attach_function :Vix_GetHandleType, [:handle], :int
 
   def self.connect(hostType, hostname, port, username, password)
-    job_handle = VixHandle[:invalid]
-    host_handle = VixHandle[:invalid]
-    job_handle = VixHost_Connect(VixApiVersion[:api_version],
+    hostname = "https://%s%s/sdk" % [hostname, port == 0 ? '' : ":#{port}"] if hostname
+    Vixen.logger.info "connecting to %s with username %s" % [hostname.inspect, username.inspect]
+    job = Vixen::Model::Job.new(VixHost_Connect(VixApiVersion[:api_version],
                                  hostType,
                                  hostname,
                                  port,
@@ -59,21 +58,20 @@ module Vixen::Bridge
                                  0,
                                  VixHandle[:invalid],
                                  nil,
-                                 nil)
-    host_handle = pointer_to_handle do |host_handle_pointer|
-      VixJob_Wait job_handle, VixPropertyId[:job_result_handle],
+                                 nil))
+    pointer_to_handle do |host_handle_pointer|
+      Vixen.logger.debug "waiting for connection to complete"
+      VixJob_Wait job.handle, VixPropertyId[:job_result_handle],
                   :pointer, host_handle_pointer,
                   :int, VixPropertyId[:none]
     end
-    Vix_ReleaseHandle job_handle
-    host_handle
   end
 
   def self.pointer_to(type, &block)
     pointer = FFI::MemoryPointer.new type, 1
     err = yield pointer
     unless err == VixError[:ok]
-      raise "problem executing pointer_to_handle block. (error: %s, %s)" %
+      raise "problem executing pointer_to_#{type} block. (error: %s, %s)" %
         [err, Vix_GetErrorText(err, nil)]
     end
     pointer.send "read_#{type}".to_sym
@@ -96,67 +94,92 @@ module Vixen::Bridge
   end
 
   def self.wait_for_async_job(operation, &block)
-    job_handle = yield
-    err = VixJob_Wait job_handle, VixPropertyId[:none]
+    job = Vixen::Model::Job.new(yield)
+    Vixen.logger.debug "Waiting for async %s job (%s)" %
+      [operation, job.handle]
+    err = VixJob_Wait job.handle, VixPropertyId[:none]
     unless err == VixError[:ok]
+      Vixen.logger.error "While executing %s VIX API returned error: %s: %s" %
+        [operation, err, Vix_GetErrorText(err, nil)]
       raise "couldn't %s. (error: %s, %s)" %
         [operation, err, Vix_GetErrorText(err, nil)]
     end
-    Vix_ReleaseHandle job_handle
   end
 
   def self.wait_for_async_handle_creation_job(operation, pointer_to_handle, &block)
-    job_handle = yield
-    sleep 0.5
-    err = VixJob_Wait job_handle, VixPropertyId[:job_result_handle],
+    job = Vixen::Model::Job.new(yield)
+    Vixen.logger.debug "Waiting for async %s job (%s) to create a new handle" %
+      [operation, job.handle]
+    err = VixJob_Wait job.handle, VixPropertyId[:job_result_handle],
                 :pointer, pointer_to_handle,
                 :int, VixPropertyId[:none]
     unless err == VixError[:ok]
+      Vixen.logger.error "While executing %s VIX API returned error: %s: %s" %
+        [operation, err, Vix_GetErrorText(err, nil)]
       raise "couldn't %s. (error: %s, %s)" %
         [operation, err, Vix_GetErrorText(err, nil)]
     end
-    Vix_ReleaseHandle job_handle
     err
   end
 
-  def self.running_vms(host_handle)
+  def self.spin_until_job_complete(operation, job)
+    while ( not pointer_to_bool do |bool_pointer|
+      Vixen.logger.debug "sleeping waiting for %s job (%s) to complete" %
+        [operation, job.handle]
+      sleep 0.01
+      Vixen.logger.debug "checking completion of %s job (%s)" %
+        [operation, job.handle]
+      thr = Thread.start { VixJob_CheckCompletion(job.handle, bool_pointer) }
+      thr.value
+    end) do
+    end
+  end
+
+  def self.running_vms(host_handle, &block)
     available_vms = []
 
     collect_proc = Proc.new do |job_handle, event_type, more_event_info, client_data|
       if event_type == VixEventType[:find_item]
         path = get_string_property more_event_info, VixPropertyId[:found_item_location]
-        available_vms << path if path
+        if path
+          Vixen.logger.debug "adding running vms %s" % path
+          available_vms << path
+        end
+      end
+      if block_given?
+        Vixen.logger.debug "preparing to call user-supplied block for running vms progress"
+        block.call job_handle, event_type, more_event_info, client_data
       end
     end
 
-    job_handle = VixHost_FindItems(host_handle,
+    Vixen.logger.debug "finding running vms"
+    job = Vixen::Model::Job.new(VixHost_FindItems(host_handle,
                                    VixFindItemType[:running_vms],
                                    VixHandle[:invalid],
                                    -1,
                                    collect_proc,
-                                   nil)
-
-    while ( not pointer_to_bool do |bool_pointer|
-      sleep 0.01
-      VixJob_CheckCompletion(job_handle, bool_pointer)
-    end) do
-    end
+                                   nil))
+    spin_until_job_complete "running vms", job
 
-    Vix_ReleaseHandle job_handle
     available_vms
   end
 
   def self.disconnect(handle)
+    Vixen.logger.debug "disconnecting from %s handle (%s)" %
+      [Vixen::Constants::VixHandleType[Vix_GetHandleType(handle)], handle]
     VixHost_Disconnect handle
   end
 
   def self.destroy(handle)
+    Vixen.logger.debug "destroying %s handle (%s)" %
+      [Vixen::Constants::VixHandleType[Vix_GetHandleType(handle)], handle]
     Vix_ReleaseHandle handle
   end
 
   def self.open_vm(host_handle, vm_path)
     vm_handle = pointer_to_handle do |vm_handle_pointer|
       wait_for_async_handle_creation_job "open vm", vm_handle_pointer do
+        Vixen.logger.info "opening %s" % vm_path
         VixHost_OpenVM host_handle, vm_path, VixVMOpenOptions[:normal],
                        VixHandle[:invalid], nil, nil
       end
@@ -166,6 +189,7 @@ module Vixen::Bridge
   def self.create_snapshot(vm_handle, name, description)
     snapshot_handle = pointer_to_handle do |snapshot_handle_pointer|
       wait_for_async_handle_creation_job "create snapshot", snapshot_handle_pointer do
+        Vixen.logger.info "creating %s snapshot" % name
         VixVM_CreateSnapshot vm_handle, name, description,
                              VixCreateSnapshotOptions[:include_memory],
                              VixHandle[:invalid], nil, nil
@@ -175,18 +199,21 @@ module Vixen::Bridge
 
   def self.current_snapshot(vm_handle)
     pointer_to_handle do |snapshot_handle_pointer|
+      Vixen.logger.debug "retrieving current snapshot"
       VixVM_GetCurrentSnapshot vm_handle, snapshot_handle_pointer
     end
   end
 
   def self.get_parent(snapshot_handle)
     pointer_to_handle do |snapshot_handle_pointer|
+      Vixen.logger.debug "retrieving snapshot parent"
       VixSnapshot_GetParent snapshot_handle, snapshot_handle_pointer
     end
   end
 
   def self.get_string_property(handle, property_id)
     string = pointer_to_string do |string_pointer|
+      Vixen.logger.debug "getting %s property" % Vixen::Constants::VixPropertyId[property_id]
       Vix_GetProperties(handle, property_id,
                         :pointer, string_pointer,
                         :int, VixPropertyId[:none])
@@ -198,6 +225,7 @@ module Vixen::Bridge
 
   def self.get_int_property(handle, property_id)
     pointer_to_int do |int_pointer|
+      Vixen.logger.debug "getting %s property" % Vixen::Constants::VixPropertyId[property_id]
       Vix_GetProperties(handle, property_id,
                         :pointer, int_pointer,
                         :int, VixPropertyId[:none])
@@ -206,24 +234,28 @@ module Vixen::Bridge
 
   def self.power_on(vm_handle)
     wait_for_async_job "power on VM" do
+      Vixen.logger.debug "powering on vm (%s)" % vm_handle
       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
+      Vixen.logger.debug "powering off vm (%s)" % vm_handle
       VixVM_PowerOff vm_handle, VixVMPowerOptions[:normal], nil, nil
     end
   end
 
   def self.reset(vm_handle)
     wait_for_async_job "reset VM" do
+      Vixen.logger.debug "resetting vm (%s)" % vm_handle
       VixVM_Reset vm_handle, VixVMPowerOptions[:normal], nil, nil
     end
   end
 
   def self.suspend(vm_handle)
     wait_for_async_job "suspend VM" do
+      Vixen.logger.debug "suspending vm (%s)" % vm_handle
       VixVM_Suspend vm_handle, VixVMPowerOptions[:normal], nil, nil
     end
   end

data/lib/vixen/model/base.rb

@@ -1,12 +1,8 @@
 require File.join(File.dirname(__FILE__), '..', 'bridge')
-require File.join(File.dirname(__FILE__), '..', 'constants')
 
 module Vixen::Model; end
 
 class Vixen::Model::Base
-  extend Vixen::Constants
-  include Vixen::Constants
-
   attr_reader :handle
 
   def initialize(handle)

data/lib/vixen/model/host.rb

@@ -5,24 +5,23 @@ class Vixen::Model::Host < Vixen::Model::Base
   def self.finalize(handle)
     proc do
       Vixen::Bridge.disconnect(handle)
-      Vixen::Bridge.destroy(handle)
     end
   end
 
-  def open_vm(path)
-    Vixen::Model::VM.new(Vixen::Bridge.open_vm handle, path)
+  def open_vm(path, &block)
+    Vixen::Model::VM.new(Vixen::Bridge.open_vm(handle, path, &block))
   end
 
-  def running_vms
+  def running_vms(&block)
     vms = []
-    paths_of_running_vms.each do |path|
-      vms << open_vm(path)
+    paths_of_running_vms(&block).each do |path|
+      vms << open_vm(path, &block)
     end
     vms
   end
 
-  def paths_of_running_vms
-    Vixen::Bridge.running_vms(handle) || []
+  def paths_of_running_vms(&block)
+    Vixen::Bridge.running_vms(handle, &block) || []
   end
 
 end

data/lib/vixen/model/job.rb

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+class Vixen::Model::Job < Vixen::Model::Base
+end

data/lib/vixen/model/snapshot.rb

@@ -3,18 +3,18 @@ require File.join(File.dirname(__FILE__), 'base')
 class Vixen::Model::Snapshot < Vixen::Model::Base
   def display_name
     return @display_name unless @display_name.nil?
-    @display_name = get_string_property VixPropertyId[:snapshot_displayname]
+    @display_name = get_string_property Vixen::Constants::VixPropertyId[:snapshot_displayname]
   end
 
   def description
     return @description unless @description.nil?
-    @description = get_string_property VixPropertyId[:snapshot_description]
+    @description = get_string_property Vixen::Constants::VixPropertyId[:snapshot_description]
   end
 
   def parent
     return @parent unless @parent.nil?
     parent_handle = Vixen::Bridge.get_parent handle
-    @parent = parent_handle == VixHandle[:invalid] ? nil : self.class.new(parent_handle)
+    @parent = parent_handle == Vixen::Constants::VixHandle[:invalid] ? nil : self.class.new(parent_handle)
   end
 
   def full_name

data/lib/vixen/model/vm.rb

@@ -75,7 +75,7 @@ class Vixen::Model::VM < Vixen::Model::Base
       :suspended, :tools_running, :resetting, :blocked_on_msg, :paused,
       :resuming
     ].each do |state|
-      states << state if ((bitwise_state & VixPowerState[state]) == VixPowerState[state])
+      states << state if ((bitwise_state & Vixen::Constants::VixPowerState[state]) == Vixen::Constants::VixPowerState[state])
     end
     states
   end

data/vixen.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'vixen'
-  s.version = '0.0.6'
+  s.version = '0.0.7'
   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.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-19 00:00:00.000000000 Z
+date: 2012-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -63,6 +63,7 @@ files:
 - lib/vixen/constants.rb
 - lib/vixen/model/base.rb
 - lib/vixen/model/host.rb
+- lib/vixen/model/job.rb
 - lib/vixen/model/snapshot.rb
 - lib/vixen/model/vm.rb
 - vixen.gemspec