vixen 0.0.3

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+*.gem
+Gemfile.lock
+.rvmrc
+.rspec

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2012 Jeff Weiss
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/MIT.LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2012 Jeff Weiss
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,33 @@
+Getting Vixen
+=============
+
+```shell
+$ gem install vixen
+```
+
+Using Vixen
+===========
+
+```ruby
+require 'vixen'
+
+Vixen.local_connect.running_vms.each { |vm| puts "Current Snapshot: #{vm.current_snapshot}" }
+```
+
+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
+```
+
+Limitations
+-----------
+Vixen currently only supports VMware Fusion 5.
+It also only lists the current snapshot of each of the running virtual machines.
+
+See Also
+--------
+
+ * [Official VMware VIX 1.12 documentation](http://www.vmware.com/support/developer/vix-api/vix112_reference/)

data/lib/vixen.rb

@@ -0,0 +1,23 @@
+require 'ffi'
+
+module Vixen
+  def self.local_connect(login = nil, password = nil)
+    connect Vixen::Constants::VixServiceProvider[:vmware_workstation], nil, 0, login, password
+  end
+
+  def self.connect(host_type, hostname, port, username, password)
+    handle = Vixen::Bridge.connect(host_type, hostname, port, username, password)
+    Vixen::Model::Host.new(handle)
+  end
+
+end
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'vixen/constants'
+require 'vixen/bridge'
+require 'vixen/model/base'
+require 'vixen/model/host'
+require 'vixen/model/vm'
+require 'vixen/model/snapshot'
+

data/lib/vixen/bridge.rb

@@ -0,0 +1,164 @@
+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
+
+
+  def self.library_location
+    kernel = Facter.value(:kernel) || ''
+    arch = Facter.value(:architecture)
+    case kernel.downcase
+    when 'darwin'
+      ext = 'dylib'
+    when 'linux'
+      ext = 'so'
+    when 'windows'
+      ext = 'dll'
+    end
+    File.join(File.dirname(__FILE__), %W[.. .. ext #{kernel} #{arch} libvixAllProducts.#{ext}])
+  end
+
+  ffi_lib library_location
+
+  typedef :int, :handle
+
+  callback :VixEventProc, [:handle, :int, :handle, :pointer], :void
+
+  attach_function :VixHost_Connect, [:int, :int, :string, :int, :string, :string, :int, :handle, :VixEventProc, :pointer], :handle
+  attach_function :VixHost_Disconnect, [:handle], :void
+  attach_function :VixHost_FindItems, [:handle, :int, :handle, :int, :VixEventProc, :pointer], :handle
+  attach_function :VixHost_OpenVM, [:handle, :string, :int, :handle, :VixEventProc, :pointer], :handle
+  attach_function :VixHost_RegisterVM, [:handle, :string, :VixEventProc, :pointer], :handle
+  attach_function :VixHost_UnregisterVM, [:handle, :string, :VixEventProc, :pointer], :handle
+  attach_function :Vix_ReleaseHandle, [:handle], :void
+  attach_function :Vix_GetErrorText, [:int, :string], :string
+  attach_function :VixJob_Wait, [:handle, :int, :varargs], :int
+  attach_function :Vix_GetProperties, [:handle, :int, :varargs], :int
+  attach_function :Vix_FreeBuffer, [:pointer], :void
+  attach_function :VixVM_GetCurrentSnapshot, [:handle, :pointer], :int
+  attach_function :VixSnapshot_GetParent, [:handle, :pointer], :int
+
+  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, 
+                                 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])
+    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)" %
+        [err, Vix_GetErrorText(err, nil)]
+    end
+    pointer.send("read_#{type}".to_sym)
+  end
+
+  def self.pointer_to_handle(&block)
+    pointer_to :int, &block
+  end
+
+  def self.pointer_to_string(&block)
+    pointer_to :pointer, &block
+  end
+
+  def self.running_vms(host_handle)
+    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
+      end
+    end
+
+    job_handle = VixHost_FindItems(host_handle,
+                                   VixFindItemType[:running_vms],
+                                   VixHandle[:invalid],
+                                   -1,
+                                   collect_proc,
+                                   nil)
+
+    # 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] )
+
+    Vix_ReleaseHandle(job_handle)
+    available_vms
+  end
+
+  def self.disconnect(handle)
+    VixHost_Disconnect(handle)
+  end
+
+  def self.destroy(handle)
+    Vix_ReleaseHandle(handle)
+  end
+
+  def self.open_vm(host_handle, vm_path)
+    job_handle = VixHost_OpenVM(host_handle,
+                                vm_path,
+                                VixVMOpenOptions[:normal],
+                                VixHandle[:invalid],
+                                nil,
+                                nil)
+    vm_handle = pointer_to_handle do |vm_handle_pointer|
+      VixJob_Wait(job_handle,
+                  VixPropertyId[:job_result_handle],
+                  :pointer, vm_handle_pointer,
+                  :int, VixPropertyId[:none])
+    end
+    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)
+    end
+  end
+
+  def self.get_parent(snapshot_handle)
+    pointer_to_handle do |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,
+                        :pointer, string_pointer,
+                        :int, VixPropertyId[:none])
+    end
+    value = string.read_string.force_encoding("UTF-8").dup
+    Vix_FreeBuffer(string)
+    return value
+  end
+
+end

data/lib/vixen/constants.rb

@@ -0,0 +1,97 @@
+module Vixen::Constants
+  extend FFI::Library
+
+  VixHandle = enum( :invalid, 0 )
+
+  VixHandleType = enum( :none,                0,
+                        :host,                2,
+                        :vm,                  3,
+                        :network,             5,
+                        :job,                 6,
+                        :snapshot,            7,
+                        :property_list,       9,
+                        :metadata_container, 11 )
+
+  VixPropertyType = enum( :any,     0,
+                          :integer, 1,
+                          :string,  2,
+                          :bool,    3,
+                          :handle,  4,
+                          :int64,   5,
+                          :blob,    6 )
+
+  VixError = enum( :ok, 0 )
+  
+  VixPropertyId = enum( :none,                                     0,
+                        :meta_data_container,                      2,
+                        :host_hosttype,                           50,
+                        :host_api_version,                        51,
+                        :vm_num_vcpus,                           101,
+                        :vm_vmx_pathname,                        103,
+                        :vm_vmteam_pathname,                     105,
+                        :vm_memory_size,                         106,
+                        :vm_read_only,                           107,
+                        :vm_name,                                108,
+                        :vm_guestos,                             109,
+                        :vm_in_vmteam,                           128,
+                        :vm_power_state,                         129,
+                        :vm_tools_state,                         152,
+                        :vm_is_running,                          196,
+                        :vm_supported_features,                  197,
+                        :vm_ssl_error,                           293,
+                        :job_result_error_code,                 3000,
+                        :job_result_vm_in_group,                3001,
+                        :job_result_user_message,               3002,
+                        :job_result_exit_code,                  3004,
+                        :job_result_command_output,             3005,
+                        :job_result_handle,                     3010,
+                        :job_result_guest_object_exists,        3011,
+                        :job_result_guest_program_elapsed_time, 3017,
+                        :job_result_guest_program_exit_code,    3018,
+                        :job_result_item_name,                  3035,
+                        :job_result_found_item_description,     3036,
+                        :job_result_shared_folder_const,        3046,
+                        :job_result_shared_folder_host,         3048,
+                        :job_result_shared_folder_flags,        3049,
+                        :job_result_process_id,                 3051,
+                        :job_result_process_owner,              3052,
+                        :job_result_process_command,            3053,
+                        :job_result_file_flags,                 3054,
+                        :job_result_process_start_time,         3055,
+                        :job_result_vm_variable_string,         3056,
+                        :job_result_process_being_debugged,     3057,
+                        :job_result_screen_image_size,          3058,
+                        :job_result_screen_image_data,          3059,
+                        :job_result_file_size,                  3061,
+                        :job_result_file_mod_time,              3062,
+                        :job_result_extra_error_info,           3084,
+                        :found_item_location,                   4010,
+                        :snapshot_displayname,                  4200,
+                        :snapshot_description,                  4201,
+                        :snapshot_powerstate,                   4205,
+                        :guest_sharedfolders_shares_path,       4525,
+                        :vm_encryption_password,                7001 )
+
+  VixEventType = enum( :job_completed, 2,
+                       :job_progress,  3,
+                       :find_item,     8 )
+
+  VixFileAttributes = enum( :directory, 1,
+                            :symlink,   2 )
+
+  VixHostOptions = enum( :verify_ssl_cert, 0x4000 )
+
+  VixServiceProvider = enum( :default,                    1,
+                             :vmware_server,              2,
+                             :vmware_workstation,         3,
+                             :vmare_player,               4,
+                             :vmware_vi_server,          10,
+                             :vmware_workstation_shared, 11 )
+
+  VixApiVersion = enum( :api_version, -1 )
+
+  VixFindItemType = enum( :running_vms,    1,
+                          :registered_vms, 4 )
+
+  VixVMOpenOptions = enum( :normal, 0x0 )
+end

data/lib/vixen/model/base.rb

@@ -0,0 +1,27 @@
+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)
+    @handle = handle
+
+    ObjectSpace.define_finalizer( self, self.class.finalize(handle) )
+  end
+
+  def self.finalize(handle)
+    proc do
+      Vixen::Bridge.destroy(handle)
+    end
+  end
+
+  def get_string_property(property_id)
+    Vixen::Bridge.get_string_property handle, property_id
+  end
+end

data/lib/vixen/model/host.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), 'base')
+require File.join(File.dirname(__FILE__), 'vm')
+
+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)
+  end
+
+  def running_vms
+    vms = []
+    paths_of_running_vms.each do |path|
+      vms << open_vm(path)
+    end
+    vms
+  end
+
+  def paths_of_running_vms
+    Vixen::Bridge.running_vms(handle) || []
+  end
+
+end

data/lib/vixen/model/snapshot.rb

@@ -0,0 +1,28 @@
+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]
+  end
+
+  def description
+    return @description unless @description.nil?
+    @description = get_string_property 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)
+  end
+
+  def full_name
+    root = parent ? parent.full_name : File::SEPARATOR
+    File.join(root, display_name)
+  end
+
+  def to_s
+    display_name
+  end
+end

data/lib/vixen/model/vm.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), 'base')
+require File.join(File.dirname(__FILE__), 'snapshot')
+
+class Vixen::Model::VM < Vixen::Model::Base
+
+  def current_snapshot
+    Vixen::Model::Snapshot.new(Vixen::Bridge.current_snapshot(handle))
+  end
+end

data/vixen.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name = 'vixen'
+  s.version = '0.0.3'
+  s.summary = 'Ruby bindings for VMware VIX API'
+  s.description = <<-EOF
+  Vixen is an easy way to interact with VMware virtual machines from Ruby. 
+
+  Vixen is not affliated with or endorsed by VMware.
+EOF
+  s.author = 'Jeff Weiss'
+  s.email = 'vixen-gem@jeffweiss.org'
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = ['lib']
+  s.platform = Gem::Platform::RUBY
+  s.homepage = "https://github.com/jeffweiss/vixen"
+  s.licenses = ['Apache-2', 'MIT']
+  s.required_ruby_version = '>= 1.8.7'
+  s.add_runtime_dependency 'ffi', '>= 1.1.5'
+  s.add_runtime_dependency 'facter', '>= 1.6.14'
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: vixen
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Jeff Weiss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+- !ruby/object:Gem::Dependency
+  name: facter
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.14
+description: ! "  Vixen is an easy way to interact with VMware virtual machines from
+  Ruby. \n\n  Vixen is not affliated with or endorsed by VMware.\n"
+email: vixen-gem@jeffweiss.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- LICENSE
+- MIT.LICENSE
+- README.md
+- ext/darwin/x86_64/libvixAllProducts.dylib
+- ext/linux/i386/libvixAllProducts.so
+- ext/linux/x86_64/libvixAllProducts.so
+- lib/vixen.rb
+- lib/vixen/bridge.rb
+- lib/vixen/constants.rb
+- lib/vixen/model/base.rb
+- lib/vixen/model/host.rb
+- lib/vixen/model/snapshot.rb
+- lib/vixen/model/vm.rb
+- vixen.gemspec
+homepage: https://github.com/jeffweiss/vixen
+licenses:
+- Apache-2
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.19
+signing_key: 
+specification_version: 3
+summary: Ruby bindings for VMware VIX API
+test_files: []