vagrant-veertu 0.0.12

data/lib/vagrant-veertu/driver/base.rb

@@ -0,0 +1,240 @@
+require 'log4r'
+require 'inifile'
+
+require 'vagrant/util/busy'
+require 'vagrant/util/platform'
+require 'vagrant/util/retryable'
+require 'vagrant/util/subprocess'
+require 'vagrant/util/which'
+
+module VagrantPlugins
+  module ProviderVeertu
+    module Driver
+      # Base class for all VeertuManage drivers.
+      #
+      # This class provides useful tools for things such as executing
+      # VeertuManage and handling SIGINTs and so on.
+      class Base
+        # Include this so we can use `Subprocess` more easily.
+        include Vagrant::Util::Retryable
+
+        def initialize
+          @logger = Log4r::Logger.new("vagrant::provider::veertu::base")
+
+          # This flag is used to keep track of interrupted state (SIGINT)
+          @interrupted = false
+
+          ini_file = File.expand_path("~/.veertu_config")
+          if File.exist?(ini_file) then
+              file = IniFile.load(ini_file)
+              @veertumanage_path = file['VAGRANT']['manage_path']
+          end
+          @veertumanage_path ||= "/Applications/Veertu.app/Contents/SharedSupport/VeertuManage"
+
+          @logger.info("VeertuManage path: #{@veertumanage_path}")
+        end
+
+        # Clears the forwarded ports that have been set on the virtual machine.
+        def clear_forwarded_ports
+        end
+      
+        def max_network_adapters
+          36
+        end
+
+        # Deletes the virtual machine references by this driver.
+        def delete
+        end
+
+        # Execute a raw command straight through to VeertuManage.
+        #
+        # Accepts a retryable: true option if the command should be retried
+        # upon failure.
+        #
+        # Raises a VeertuManage error if it fails.
+        #
+        # @param [Array] command Command to execute.
+        def execute_command(command)
+        end
+
+        # Exports the virtual machine to the given path.
+        #
+        # @param [String] path Path to the OVF file.
+        # @yield [progress] Yields the block with the progress of the export.
+        def export(path)
+          raise NotImplementedError("please export manually")
+        end
+
+        # Forwards a set of ports for a VM.
+        #
+        # This will not affect any previously set forwarded ports,
+        # so be sure to delete those if you need to.
+        #
+        # The format of each port hash should be the following:
+        #
+        #     {
+        #       name: "foo",
+        #       hostport: 8500,
+        #       guestport: 80,
+        #       adapter: 1,
+        #       protocol: "tcp"
+        #     }
+        #
+        # Note that "adapter" and "protocol" are optional and will default
+        # to 1 and "tcp" respectively.
+        #
+        # @param [Array<Hash>] ports An array of ports to set. See documentation
+        #   for more information on the format.
+        def forward_ports(ports)
+        end
+
+        # Halts the virtual machine (pulls the plug).
+        def halt
+        end
+
+        # Imports the VM from an box file.
+        #
+        # @param [String] box Path to the box file.
+        # @return [String] UUID of the imported VM.
+        def import(box)
+        end
+
+
+        # Returns a list of forwarded ports for a VM.
+        #
+        # @param [String] uuid UUID of the VM to read from, or `nil` if this
+        #   VM.
+        # @param [Boolean] active_only If true, only VMs that are running will
+        #   be checked.
+        # @return [Array<Array>]
+        def read_forwarded_ports(uuid=nil, active_only=false)
+        end
+
+        # Returns the current state of this VM.
+        #
+        # @return [Symbol]
+        def read_state
+        end
+
+        # Returns a list of all forwarded ports in use by active
+        # virtual machines.
+        #
+        # @return [Array]
+        def read_used_ports
+        end
+
+        # Returns a list of all UUIDs of virtual machines currently
+        # known by VirtualBox.
+        #
+        # @return [Array<String>]
+        def read_vms
+        end
+
+        # Share a set of folders on this VM.
+        #
+        # @param [Array<Hash>] folders
+        def share_folders(folders)
+        end
+
+        # Reads the SSH port of this VM.
+        #
+        # @param [Integer] expected Expected guest port of SSH.
+        def ssh_port(expected)
+        end
+
+        # Starts the virtual machine.
+        #
+        # @param [String] mode Mode to boot the VM. Either "headless"
+        #   or "gui"
+        def start(mode)
+        end
+
+        # Suspend the virtual machine.
+        def suspend
+        end
+
+
+        # Verifies that the driver is ready to accept work.
+        #
+        # This should raise a VagrantError if things are not ready.
+        def verify!
+        end
+
+
+        # Checks if a VM with the given UUID exists.
+        #
+        # @return [Boolean]
+        def vm_exists?(uuid)
+        end
+
+        # Execute the given subcommand for VeertuManage and return the output.
+        def execute(*command, &block)
+          # Get the options hash if it exists
+          opts = {}
+          opts = command.pop if command.last.is_a?(Hash)
+
+          tries = 0
+          tries = 3 if opts[:retryable]
+
+          # Variable to store our execution result
+          r = nil
+
+          retryable(on: VagrantPlugins::ProviderVeertu::Errors::VeertuManageError, tries: tries, sleep: 1) do
+            # If there is an error with VeertuManage, this gets set to true
+            errored = false
+
+            # Execute the command
+            r = raw(*command, &block)
+
+            # If the command was a failure, then raise an exception that is
+            # nicely handled by Vagrant.
+            if r.exit_code != 0
+              if @interrupted
+                @logger.info("Exit code != 0, but interrupted. Ignoring.")
+              elsif r.exit_code == 126
+                # This exit code happens if VeertuManage is on the PATH,
+                # but another executable it tries to execute is missing.
+                raise Errors::VeertuManageNotFoundError
+              else
+                errored = true
+              end
+            end
+
+            # If there was an error running VeertuManage, show the error and the
+            # output.
+            if errored
+              raise VagrantPlugins::ProviderVeertu::Errors::VeertuManageError,
+                command: command.inspect,
+                stderr:  r.stderr,
+                stdout:  r.stdout
+            end
+          end
+
+          r.stdout.gsub("\r\n", "\n")
+        end
+
+        # Executes a command and returns the raw result object.
+        def raw(*command, &block)
+          int_callback = lambda do
+            @interrupted = true
+
+            # We have to execute this in a thread due to trap contexts
+            # and locks.
+            Thread.new { @logger.info("Interrupted.") }.join
+          end
+
+          # Append in the options for subprocess
+          command << { notify: [:stdout, :stderr] }
+
+          Vagrant::Util::Busy.busy(int_callback) do
+            @logger.debug(YAML::dump(command))
+            Vagrant::Util::Subprocess.execute(@veertumanage_path, *command, &block)
+          end
+        rescue Vagrant::Util::Subprocess::LaunchError => e
+          raise Vagrant::Errors::VBoxManageLaunchError,
+            message: e.to_s
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/driver/meta.rb

@@ -0,0 +1,143 @@
+require "forwardable"
+require "thread"
+
+require "log4r"
+
+require "vagrant/util/retryable"
+
+require File.expand_path("../base", __FILE__)
+
+module VagrantPlugins
+  module ProviderVeertu
+    module Driver
+      class Meta < Base
+        # This is raised if the VM is not found when initializing a driver
+        # with a UUID.
+        class VMNotFound < StandardError; end
+
+        # We use forwardable to do all our driver forwarding
+        extend Forwardable
+
+        # We cache the read VirtualBox version here once we have one,
+        # since during the execution of Vagrant, it likely doesn't change.
+        @@version = nil
+        @@version_lock = Mutex.new
+
+        # The UUID of the virtual machine we represent
+        attr_reader :uuid
+
+        # The version of virtualbox that is running.
+        attr_reader :version
+
+        include Vagrant::Util::Retryable
+
+        def initialize(uuid=nil)
+          # Setup the base
+          super()
+
+          @logger = Log4r::Logger.new("vagrant::provider::veertu::meta")
+          @uuid = uuid
+
+          @@version_lock.synchronize do
+            if !@@version
+              # Read and assign the version of VirtualBox we know which
+              # specific driver to instantiate.
+              begin
+                @@version = read_version
+              rescue Vagrant::Errors::CommandUnavailable,
+                Vagrant::Errors::CommandUnavailableWindows
+                # This means that VirtualBox was not found, so we raise this
+                # error here.
+                raise Vagrant::Errors::VirtualBoxNotDetected
+              end
+            end
+          end
+
+          # Instantiate the proper version driver for Veertu
+          @logger.debug("Finding driver for Veertu version: #{@@version}")
+          driver_map   = {
+            "5.0" => Version_5_0,
+          }
+
+          driver_klass = nil
+          driver_map.each do |key, klass|
+            if @@version.start_with?(key)
+              driver_klass = klass
+              break
+            end
+          end
+
+          if !driver_klass
+            supported_versions = driver_map.keys.sort.join(", ")
+            raise Vagrant::Errors::VirtualBoxInvalidVersion,
+              supported_versions: supported_versions
+          end
+
+          @logger.info("Using VirtualBox driver: #{driver_klass}")
+          @driver = driver_klass.new(@uuid)
+          @version = @@version
+
+          if @uuid
+            # Verify the VM exists, and if it doesn't, then don't worry
+            # about it (mark the UUID as nil)
+            raise VMNotFound if !@driver.vm_exists?(@uuid)
+          end
+        end
+
+        def_delegators :@driver, :clear_forwarded_ports,
+          :clear_shared_folders,
+          :clonevm,
+          :create_dhcp_server,
+          :create_host_only_network,
+          :create_snapshot,
+          :delete,
+          :delete_snapshot,
+          :delete_unused_host_only_networks,
+          :discard_saved_state,
+          :enable_adapters,
+          :execute_command,
+          :export,
+          :forward_ports,
+          :halt,
+          :import,
+          :list_snapshots,
+          :read_forwarded_ports,
+          :read_bridged_interfaces,
+          :read_dhcp_servers,
+          :read_guest_additions_version,
+          :read_guest_ip,
+          :read_guest_property,
+          :read_host_only_interfaces,
+          :read_mac_address,
+          :read_mac_addresses,
+          :read_machine_folder,
+          :read_network_interfaces,
+          :read_state,
+          :read_used_ports,
+          :read_vms,
+          :reconfig_host_only,
+          :remove_dhcp_server,
+          :restore_snapshot,
+          :resume,
+          :set_mac_address,
+          :set_name,
+          :share_folders,
+          :ssh_port,
+          :start,
+          :suspend,
+          :verify!,
+          :verify_image,
+          :vm_exists?
+
+        protected
+
+        # This returns the version of VirtualBox that is running.
+        #
+        # @return [String]
+        def read_version
+          '5.0'
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/driver/version_5_0.rb

@@ -0,0 +1,284 @@
+require 'log4r'
+require 'json'
+require "vagrant/util/platform"
+
+require File.expand_path("../base", __FILE__)
+
+module VagrantPlugins
+  module ProviderVeertu
+    module Driver
+      # Driver for Veertu 1.2.0.x
+      class Version_5_0 < Base
+        def initialize(uuid)
+          super()
+
+          @logger = Log4r::Logger.new("vagrant::provider::veertu_5_0")
+          @uuid = uuid
+        end
+        
+        def read_bridged_interfaces
+          raise Errors::VeertuUnsupported, action: 'bridged interfaces'
+        end
+
+        def clear_forwarded_ports
+          read_forwarded_ports(@uuid).each do |nic, name, _, _|
+            execute("modify", @uuid, 'delete', '--port-forwarding', name)
+          end
+        end
+
+        def delete
+          execute("delete",'--yes', @uuid)
+        end
+
+        def execute_command(command)
+          execute(*command)
+        end
+
+        def export(path)
+          execute("export", @uuid, "--output", path.to_s)
+        end
+
+        def forward_ports(ports)
+          ports.each do |options|
+            name = options[:name]
+            protocol = options[:protocol] || "tcp"
+            host_ip = options[:hostip] || "127.0.0.1"
+            host_port = options[:hostport]
+            guest_ip = options[:guestip] || ""
+            guest_port = options[:guestport]
+            execute('--machine-readable', 'modify', @uuid, 'add', '--port-forwarding', name, '--host-ip',
+                    host_ip, '--host-port', host_port.to_s, '--protocol', protocol, '--guest-ip',
+                    guest_ip, '--guest-port', guest_port.to_s)
+
+          end
+        end
+
+        def get_machine_id(machine_name)
+          vm = get_vm_info(machine_name)
+          return vm['id'] 
+        end
+        
+        def set_name(name)
+          execute('modify', @uuid, 'set', '--rename', '--name', name)  
+        end
+        
+        def halt
+          execute("shutdown", @uuid)
+        end
+
+        def import(box)
+          box = Vagrant::Util::Platform.cygwin_windows_path(box)
+
+          output = ""
+          total = ""
+          last  = 0
+
+          # Dry-run the import to get the suggested name and path
+          @logger.debug("Doing dry-run import to determine parallel-safe name...")
+          output = execute("import", "-n", box)
+          result = /Suggested VM name "(.+?)"/.match(output)
+          if !result
+            raise Vagrant::Errors::VirtualBoxNoName, output: output
+          end
+          suggested_name = result[1].to_s
+
+          # Append millisecond plus a random to the path in case we're
+          # importing the same box elsewhere.
+          specified_name = "#{suggested_name}_#{(Time.now.to_f * 1000.0).to_i}_#{rand(100000)}"
+          @logger.debug("-- Parallel safe name: #{specified_name}")
+
+          # Build the specified name param list
+          name_params = [
+            "--os-family", "0",
+            "--name", specified_name,
+          ]
+
+          # Extract the disks list and build the disk target params
+          disk_params = []
+          disks = output.scan(/(\d+): Hard disk image: source image=.+, target path=(.+),/)
+          disks.each do |unit_num, path|
+            disk_params << "--vsys"
+            disk_params << "0"
+            disk_params << "--unit"
+            disk_params << unit_num
+            disk_params << "--disk"
+            disk_params << path.reverse.sub("/#{suggested_name}/".reverse, "/#{specified_name}/".reverse).reverse # Replace only last occurrence
+          end
+          success_json = execute("--machine-readable", "import", box , *name_params, *disk_params)
+          begin
+            success = JSON.parse(success_json)
+            if success['status'] == 'ok'
+              puts 'imported successfully'
+            end
+          rescue JSON::ParserError
+            puts 'json parse error'
+            return nil
+          end
+          puts specified_name
+          machine_id = get_machine_id(specified_name)
+          puts machine_id
+          return machine_id 
+        end
+
+        def read_forwarded_ports(uuid=nil, active_only=false)
+          uuid ||= @uuid
+
+          @logger.debug("read_forward_ports: uuid=#{uuid} active_only=#{active_only}")
+
+          results = []
+          current_nic = 'nat'
+          vm_info = get_vm_info(uuid)
+          if active_only && vm_info['status'] != "running"
+                return []
+          end
+          port_forwarding_rules = vm_info['port_forwarding']
+          
+          port_forwarding_rules.each do |rule|
+            result = [current_nic, rule['name'], rule['host_port'], rule['guest_port']]
+            results << result
+            @logger.debug("  - #{result.inspect}")
+          end
+
+          results
+        end
+
+        def read_host_only_interfaces
+          vms_array = get_vm_list()
+          info = {}
+          vms_array.each do |vm|
+            info['name'] = vm['name']
+            info['uuid'] = vm['id']
+          end
+          info
+        end
+
+        def read_network_interfaces
+          return { '0' => {:type => :nat}}
+        end
+
+        def read_state
+          vm = get_vm_info(@uuid)
+          status =  vm['status']
+          @logger.debug('getting machine status')
+          @logger.debug(status)
+          return status.to_sym
+        end
+
+        def read_used_ports
+          ports = []
+          vms_array = get_vm_list()
+          vms_array.each do |vm|
+              # Ignore our own used ports
+              uuid = vm['uuid']
+              next if uuid  == @uuid
+
+              read_forwarded_ports(uuid, true).each do |_, _, hostport, _|
+                ports << hostport
+              end
+          end
+
+          ports
+        end
+
+        def read_guest_ip(adapter_number)
+          vm_info = get_vm_info(@uuid)
+          return vm_info['ip']
+        end
+
+        def read_vms
+          results = {}
+          vms = get_vm_list()
+          vms.each do |vm|
+            results[vm[:id]] = vm[:name]
+          end
+          results
+        end
+
+
+        def ssh_port(expected_port)
+          expected_port = expected_port.to_s
+          @logger.debug("Searching for SSH port: #{expected_port.inspect}")
+
+          # Look for the forwarded port only by comparing the guest port
+          read_forwarded_ports.each do |_, _, hostport, guestport|
+            if guestport == expected_port
+              return hostport
+            end
+          end
+
+          nil
+        end
+
+        def resume
+          start(nil)
+        end
+
+        def start(mode)
+          if mode == 'headless'
+            execute('--machine-readable', 'modify', @uuid, 'set', '--headless', '1')
+          elsif mode == 'gui'
+            execute('--machine-readable', 'modify', @uuid, 'set', '--headless', '0')
+          end
+          json_success  = execute('--machine-readable', 'start', @uuid)
+          result = JSON.parse(json_success)
+          if result['status'] == 'ok'
+            return true
+          end
+
+          # If we reached this point then it didn't work out.
+          raise Vagrant::Errors::VBoxManageError,
+            command: command.inspect,
+            stderr: r.stderr
+        end
+
+        def suspend
+          execute("pause", @uuid)
+        end
+
+        def verify!
+          # This command sometimes fails if kernel drivers aren't properly loaded
+          # so we just run the command and verify that it succeeded.
+          execute("list", retryable: true)
+        end
+
+        def vm_exists?(uuid)
+          5.times do |i|
+            info = get_vm_info(uuid)
+            if info
+              return true
+            else
+              return false
+            end
+            sleep 2
+          end
+
+          # If we reach this point, it means that we consistently got the
+          # failure, do a standard vboxmanage now. This will raise an
+          # exception if it fails again.
+          execute("show", uuid)
+          return true
+        end
+
+        protected
+        
+        def get_vm_list()
+          vms_json = execute("--machine-readable", "list", retryable: true)
+          vms = JSON.parse(vms_json)
+          return vms
+        end
+        
+        def get_vm_info(uuid)
+          # puts caller
+          begin
+            vm_info_json = execute('--machine-readable', 'show', uuid, retryable: true)
+            vm_info = JSON.parse(vm_info_json)
+            return vm_info
+          rescue JSON::ParserError
+            return nil
+          end
+        end
+        
+      end
+    end
+  end
+end