vagrant-vmware-free 0.0.1

data/lib/vagrant_vmware_free/action/suspend.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    module Action
+      class Suspend
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].provider.state.id == :running
+            env[:ui].info I18n.t("vagrant.actions.vm.suspend.suspending")
+            env[:machine].provider.driver.suspend
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_vmware_free/action/wait_for_vm_tools.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    module Action
+      class WaitForVMTools
+        include VagrantPlugins::ProviderVMwareFree::Driver::VIX
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          wait_for_vmtools(env[:machine].provider.driver.vm_handle)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_vmware_free/config.rb

@@ -0,0 +1,38 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    class Config < Vagrant.plugin('2', :config)
+      attr_reader :name
+
+      def initialize
+        # @auto_nat_dns_proxy = UNSET_VALUE
+        # @customizations   = []
+        # @destroy_unused_network_interfaces = UNSET_VALUE
+        @name             = UNSET_VALUE
+        # @network_adapters = {}
+        # @gui              = UNSET_VALUE
+
+        # We require that network adapter 1 is a NAT device.
+        # network_adapter(1, :nat)
+      end
+
+      def finalize!
+        # Default is to auto the DNS proxy
+        # @auto_nat_dns_proxy = true if @auto_nat_dns_proxy == UNSET_VALUE
+
+        # if @destroy_unused_network_interfaces == UNSET_VALUE
+          # @destroy_unused_network_interfaces = false
+        # end
+
+        # Default is to not show a GUI
+        # @gui = false if @gui == UNSET_VALUE
+
+        # The default name is just nothing, and we default it
+        @name = nil if @name == UNSET_VALUE
+      end
+
+      def validate(machine)
+        {}
+      end
+    end
+  end
+end

data/lib/vagrant_vmware_free/driver/base.rb

@@ -0,0 +1,14 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    module Driver
+      class Base
+        include VIX
+        
+        def initialize(uuid)
+          @uuid = uuid
+          @logger = Log4r::Logger.new('vagrant::provider::vmware-free::fusion')
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_vmware_free/driver/fusion.rb

@@ -0,0 +1,17 @@
+require 'log4r'
+require_relative 'base'
+
+module VagrantPlugins
+  module ProviderVMwareFree
+    module Driver
+      class Fusion < Base
+        def initialize(uuid)
+          super(uuid)
+
+          @logger = Log4r::Logger.new('vagrant::provider::vmware-free::fusion')
+          @uuid = uuid
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_vmware_free/driver/fusion_6.rb

@@ -0,0 +1,188 @@
+require 'log4r'
+require 'securerandom'
+require 'yaml'
+
+module VagrantPlugins
+  module ProviderVMwareFree
+    module Driver
+      class Fusion_6 < Fusion
+        include VagrantPlugins::ProviderVMwareFree::Util::VMX
+        include VagrantPlugins::ProviderVMwareFree::Driver::VIX
+        INVENTORY = File.join(ENV['HOME'], '.vagrant.d', 'vmware.yml')
+
+        attr_reader :vmx_path
+        attr_reader :vm_handle
+        attr_accessor :ip_address
+
+        def initialize(uuid)
+          super(uuid)
+          @logger = Log4r::Logger.new('vagrant::provider::vmware-free::fusion_6')
+          @host_handle = get_host_handle
+
+          if @uuid
+            read_vms.each do |k, v|
+              @vmx_path = v[:config] if k == uuid
+            end
+            @vm_handle = get_vm_handle(@host_handle, @uuid)
+          end
+        end
+
+        def import(vmx_file, dest_file)
+          box_handle = open_vmx(@host_handle, vmx_file)
+          jobHandle = VixVM_Clone(box_handle, :VIX_INVALID_HANDLE, :VIX_CLONETYPE_FULL, dest_file, 0, :VIX_INVALID_HANDLE, nil, nil)
+          code, values = wait(jobHandle)
+
+          raise VIXError, "VixError: #{code}" if (code != 0)
+          new_uuid = SecureRandom.uuid
+
+          inventory = YAML.load_file(INVENTORY)
+
+          inventory[new_uuid] = { config: dest_file }
+
+          File.open(INVENTORY, 'wb') do |f|
+            f.write(inventory.to_yaml)
+          end
+
+          new_uuid
+        end
+
+        def delete
+          job_handle = VixVM_Delete(@vm_handle, :VIX_VMDELETE_DISK_FILES, nil, nil)
+          code, values = wait(job_handle)
+          raise VIXError, code: code if (code != 0)
+
+          inventory = YAML.load_file(INVENTORY)
+          inventory.delete @uuid
+          File.open(INVENTORY, 'wb') do |f|
+            f.write(inventory.to_yaml)
+          end
+
+          nil
+        end
+
+        def resume(mode='headless')
+          start(mode)
+        end
+
+        def vm_exists?(uuid)
+          inventory = YAML.load_file(INVENTORY)
+          inventory.each do |k, v|
+            return true if k == uuid
+          end
+
+          false
+        end
+
+        # Follwing methods are stubs for now
+
+        def read_vms
+          YAML.load_file(INVENTORY)
+        end
+
+        def set_value(key, value)
+          vmx = vmx_parse(@vmx_path)
+          vmx[key] = value
+          vmx_save(@vmx_path, vmx)
+          nil
+        end
+
+        def set_name(name)
+          inventory = read_vms
+          inventory[@uuid]['name'] = name
+          File.open(INVENTORY, 'wb') do |f|
+            f.write(inventory.to_yaml)
+          end
+
+          set_value('displayName', name)
+        end
+
+        def clear_forwarded_ports
+        end
+
+        def read_forwarded_ports
+          {}
+        end
+
+        def read_used_ports
+          {}
+        end
+
+        def clear_shared_folders
+        end
+
+        def share_folders(folders)
+
+        end
+
+        def start(mode)
+          if mode == 'gui'
+            mode = :VIX_VMPOWEROP_LAUNCH_GUI
+          else
+            mode = :VIX_VMPOWEROP_NORMAL
+          end
+
+          jobHandle = VixVM_PowerOn(@vm_handle, :VIX_VMPOWEROP_NORMAL, :VIX_INVALID_HANDLE, nil, nil)
+          code, values = wait(jobHandle)
+          raise VIXError, code: code if (code != 0)
+          nil
+        end
+
+        def halt
+          code, values = wait(VixVM_PowerOff(@vm_handle, :VIX_VMPOWEROP_NORMAL, nil, nil))
+        end
+
+        def read_state
+          code, state = get_properties(@vm_handle, [:VIX_PROPERTY_VM_POWER_STATE])
+          state = state[:VIX_PROPERTY_VM_POWER_STATE]
+
+          raise VIXError, "VixError: #{code}" if (code != 0)
+          @logger.debug("VM_POWER_STATE: #{state}")
+
+          states_enum = VIX.enum_type(:VixPowerState)
+
+          if state & states_enum[:VIX_POWERSTATE_POWERED_OFF] != 0
+            :poweroff
+          elsif state & states_enum[:VIX_POWERSTATE_POWERED_ON] != 0
+            :running
+          elsif state & states_enum[:VIX_POWERSTATE_SUSPENDED] != 0
+            :saved
+          elsif state & states_enum[:VIX_POWERSTATE_SUSPENDING] != 0
+            :saving
+          elsif state & states_enum[:VIX_POWERSTATE_POWERING_ON] != 0
+            :booting
+          else
+            false
+          end
+        end
+
+        protected
+
+        def get_host_handle
+          @logger.debug('Connecting to VIX...')
+          jobHandle = VixHost_Connect(:VIX_API_VERSION, :VIX_SERVICEPROVIDER_VMWARE_WORKSTATION,
+                                       '', 0, '', '', 0, :VIX_INVALID_HANDLE, nil, nil)
+          code, values = wait(jobHandle, [:VIX_PROPERTY_JOB_RESULT_HANDLE])
+
+          raise VIXError, code: code if (code != 0)
+
+          values[:VIX_PROPERTY_JOB_RESULT_HANDLE]
+        end
+
+        def get_vm_handle(host_handle, uuid)
+          return nil if !uuid
+          return nil if !vm_exists?(uuid)
+          open_vmx(host_handle, @vmx_path)
+        end
+
+        def open_vmx(host_handle, vmx_path)
+          jobHandle = VixHost_OpenVM(host_handle, vmx_path, :VIX_VMOPEN_NORMAL, :VIX_INVALID_HANDLE, nil, nil)
+          code, values = wait(jobHandle, [:VIX_PROPERTY_JOB_RESULT_HANDLE])
+
+          raise VIXError, code if (code != 0)
+
+          values[:VIX_PROPERTY_JOB_RESULT_HANDLE]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_vmware_free/driver/meta.rb

@@ -0,0 +1,122 @@
+require 'forwardable'
+require 'log4r'
+require 'cfpropertylist'
+
+require_relative('base')
+
+module VagrantPlugins
+  module ProviderVMwareFree
+    module Driver
+      class Meta < Base
+        class VMNotFound < StandardError; end
+
+        extend Forwardable
+
+        attr_reader :uuid
+        attr_reader :version
+
+        def initialize(uuid=nil)
+          super(uuid)
+
+          @logger = Log4r::Logger::new('vagrant::provider::vmware-free::meta')
+          @uuid = uuid
+
+          begin
+            @host = read_host_type_and_version || ""
+          rescue ProviderVMwareFree::Errors::CommandUnavailable,
+            ProviderVMwareFree::Errors::CommandUnavailableWindows
+            # This means that VirtualBox was not found, so we raise this
+            # error here.
+            raise ProviderVMwareFree::Errors::VMWareNotDetected
+          end
+
+          @logger.debug("Using #{@host[:product]} version: #{@host[:version]}")
+
+          driver_map = {
+            fusion: {
+              '6.0' => Fusion_6,
+            },
+          }
+
+          driver_klass = nil
+          driver_map[@host[:product]].each do |key, klass|
+            if @host[:version].start_with? key
+              driver_klass = klass
+              break
+            end
+          end
+
+          if !driver_klass
+            raise ProviderVMwareFree::Errors::VMWareInvalidVersion
+          end
+
+          @logger.info("Using driver: #{driver_klass}")
+          @driver = driver_klass.new(@uuid)
+
+          @logger.debug("UUID: #{@uuid}")
+          if @uuid
+            # require 'debugger';debugger
+            raise VMNotFound if !@driver.vm_exists?(@uuid)
+          end
+        end
+
+        def_delegators :@driver, :clear_forwarded_ports,
+        :clear_shared_folders,
+        :create_dhcp_server,
+        :create_host_only_network,
+        :delete,
+        :delete_unused_host_only_networks,
+        :discard_saved_state,
+        :enable_adapters,
+        :execute_command,
+        :export,
+        :forward_ports,
+        :halt,
+        :import,
+        :ip_address,
+        :ip_address=,
+        :read_forwarded_ports,
+        :read_bridged_interfaces,
+        :read_guest_additions_version,
+        :read_host_only_interfaces,
+        :read_mac_address,
+        :read_mac_addresses,
+        :read_machine_folder,
+        :read_network_interfaces,
+        :read_state,
+        :read_used_ports,
+        :read_vms,
+        :resume,
+        :set_mac_address,
+        :set_name,
+        :set_value,
+        :share_folders,
+        :ssh_port,
+        :start,
+        :suspend,
+        :verify!,
+        :verify_image,
+        :vm_exists?,
+        :vm_handle,
+        :vmx_path
+
+        protected
+
+        def read_host_type_and_version
+          host = {}
+
+          if /darwin/ =~ RUBY_PLATFORM
+            host[:product] = :fusion
+
+            fusion_plist = CFPropertyList::List.new(file: '/Applications/VMware Fusion.app/Contents/Info.plist')
+            version = CFPropertyList.native_types(fusion_plist.value)['CFBundleShortVersionString']
+
+            host[:version] = version
+          end
+          
+          host
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_vmware_free/driver/vix.rb

@@ -0,0 +1,19 @@
+require 'ffi'
+
+module VagrantPlugins
+  module ProviderVMwareFree
+    module Driver
+      
+      module VIX
+        class VIXError < StandardError; end
+        extend FFI::Library
+
+        ffi_lib '/Applications/VMware Fusion.app/Contents/Public/libvixAllProducts.dylib'
+      end
+    end
+  end
+end
+
+require_relative('vix/types')
+require_relative('vix/functions')
+require_relative('vix/helpers')

data/lib/vagrant_vmware_free/driver/vix/functions.rb

@@ -0,0 +1,38 @@
+module VagrantPlugins
+  module ProviderVMwareFree
+    module Driver
+      module VIX
+        attach_function :VixHost_Connect, [
+          :int, :VixServiceProvider, :string, :int,
+          :string, :string, :VixHostOptions, :VixHandle,
+          :VixEventProc, :pointer], :VixHandle
+        
+        attach_function :VixHost_OpenVM, [
+          :VixHandle, :string, :VixVMOpenOptions,
+          :VixHandle, :VixEventProc, :pointer], :VixHandle
+        
+        attach_function :VixVM_PowerOn, [
+          :VixHandle, :VixVMPowerOpOptions, :VixHandle,
+          :VixEventProc, :pointer], :VixHandle
+
+        attach_function :VixJob_Wait, [:VixHandle, :varargs], :VixError
+
+        attach_function :VixVM_PowerOff, [:VixHandle, :VixVMPowerOpOptions, :VixEventProc, :pointer], :VixHandle
+
+        attach_function :VixVM_Clone, [:VixHandle, :VixHandle, :VixCloneType, :string, :int, :VixHandle, :pointer, :pointer], :VixHandle
+
+        attach_function :Vix_ReleaseHandle, [:VixHandle], :void
+
+        attach_function :Vix_GetProperties, [:VixHandle, :varargs], :VixError
+
+        attach_function :VixVM_WaitForToolsInGuest, [:VixHandle, :int, :pointer, :pointer], :VixHandle
+
+        attach_function :VixVM_ReadVariable, [:VixHandle, :VixVariableType, :string, :int, :pointer, :pointer], :VixHandle
+
+        attach_function :VixVM_Delete, [:VixHandle, :VixVMDeleteOptions, :pointer, :pointer], :VixHandle
+
+        attach_function :VixVM_PowerOff, [:VixHandle, :VixVMPowerOpOptions, :pointer, :pointer], :VixHandle
+      end
+    end
+  end
+end