vagrant-parallels 0.0.1.dev

data/lib/vagrant-parallels/action/message_not_running.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class MessageNotRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.common.vm_not_running")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/action/message_will_not_destroy.rb

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class MessageWillNotDestroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.destroy.will_not_destroy",
+                              :name => env[:machine].name)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/action/prepare_nfs_settings.rb

@@ -0,0 +1,64 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class PrepareNFSSettings
+        def initialize(app,env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          using_nfs = false
+          env[:machine].config.vm.synced_folders.each do |id, opts|
+            if opts[:nfs]
+              using_nfs = true
+              break
+            end
+          end
+
+          if using_nfs
+            @logger.info("Using NFS, preparing NFS settings by reading host IP and machine IP")
+            env[:nfs_host_ip]    = read_host_ip(env[:machine])
+            env[:nfs_machine_ip] = read_machine_ip(env[:machine])
+
+            raise Vagrant::Errors::NFSNoHostonlyNetwork if !env[:nfs_machine_ip]
+          end
+        end
+
+        # Returns the IP address of the first host only network adapter
+        #
+        # @param [Machine] machine
+        # @return [String]
+        def read_host_ip(machine)
+          machine.provider.driver.read_network_interfaces.each do |adapter, opts|
+            if opts[:type] == :hostonly
+              machine.provider.driver.read_host_only_interfaces.each do |interface|
+                if interface[:name] == opts[:hostonly]
+                  return interface[:ip]
+                end
+              end
+            end
+          end
+
+          nil
+        end
+
+        # Returns the IP address of the guest by looking at the first
+        # enabled host only network.
+        #
+        # @return [String]
+        def read_machine_ip(machine)
+          machine.config.vm.networks.each do |type, options|
+            if type == :private_network && options[:ip].is_a?(String)
+              return options[:ip]
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/action/prune_nfs_exports.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class PruneNFSExports
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:host]
+            vms = env[:machine].provider.driver.read_vms
+            env[:host].nfs_prune(vms.values)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/action/register_template.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class RegisterTemplate
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          pvm_file = Pathname.glob(env[:machine].box.directory.join('*.pvm')).first
+
+          unless env[:machine].provider.driver.registered?(pvm_file.basename.to_s[0...-4])
+            env[:machine].provider.driver.register(pvm_file.to_s)
+          end
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/action/resume.rb

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class Resume
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          current_state = env[:machine].provider.state.id
+
+          if current_state == :suspended
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.unpausing")
+            env[:machine].provider.driver.resume
+          elsif current_state == :stopped
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.resuming")
+            env[:action_runner].run(Boot, env)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/action/share_folders.rb

@@ -0,0 +1,121 @@
+require "pathname"
+
+require "log4r"
+
+require "vagrant/util/platform"
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module Parallels
+    module Action
+      class ShareFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::share_folders")
+          @app    = app
+        end
+
+        def call(env)
+          @env = env
+
+          prepare_folders
+          create_metadata
+
+          @app.call(env)
+
+          mount_shared_folders
+        end
+
+        # This method returns an actual list of VirtualBox shared
+        # folders to create and their proper path.
+        def shared_folders
+          {}.tap do |result|
+            @env[:machine].config.vm.synced_folders.each do |id, data|
+              data = scoped_hash_override(data, :parallels)
+
+              # Ignore NFS shared folders
+              next if data[:nfs]
+
+              # Ignore disabled shared folders
+              next if data[:disabled]
+
+              # This to prevent overwriting the actual shared folders data
+              id = Pathname.new(id).to_s.split('/').drop_while{|i| i.empty?}.join('_')
+              result[id] = data.dup
+            end
+          end
+        end
+
+        # Prepares the shared folders by verifying they exist and creating them
+        # if they don't.
+        def prepare_folders
+          shared_folders.each do |id, options|
+            hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
+
+            if !hostpath.directory? && options[:create]
+              # Host path doesn't exist, so let's create it.
+              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
+
+              begin
+                hostpath.mkpath
+              rescue Errno::EACCES
+                raise Vagrant::Errors::SharedFolderCreateFailed,
+                  :path => hostpath.to_s
+              end
+            end
+          end
+        end
+
+        def create_metadata
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.creating")
+
+          folders = []
+          shared_folders.each do |id, data|
+            hostpath = File.expand_path(data[:hostpath], @env[:root_path])
+            hostpath = Vagrant::Util::Platform.cygwin_windows_path(hostpath)
+
+            folders << {
+              :name => id,
+              :hostpath => hostpath,
+              :transient => data[:transient]
+            }
+          end
+
+          @env[:machine].provider.driver.share_folders(folders)
+        end
+
+        # TODO: Fix this, doesn't execute at the correct time
+        def mount_shared_folders
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.mounting")
+
+          # short guestpaths first, so we don't step on ourselves
+          folders = shared_folders.sort_by do |id, data|
+            if data[:guestpath]
+              data[:guestpath].length
+            else
+              # A long enough path to just do this at the end.
+              10000
+            end
+          end
+
+          # Go through each folder and mount
+          folders.each do |id, data|
+            if data[:guestpath]
+              # Guest path specified, so mount the folder to specified point
+              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
+                                    :guest_path => data[:guestpath]))
+
+              # Symlink to mounted folder to guest path
+              @env[:machine].provider.driver.symlink(id, data[:guestpath])
+            else
+              # If no guest path is specified, then automounting is disabled
+              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
+                                    :host_path => data[:hostpath]))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/action/suspend.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module Parallels
+    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-parallels/action/unregister_template.rb

@@ -0,0 +1,24 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class UnregisterTemplate
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          vm_name = Pathname.glob(
+            env[:machine].box.directory.join('*.pvm')
+            ).first.basename.to_s[0...-4]
+
+          if env[:machine].provider.driver.registered?(vm_name)
+            env[:machine].provider.driver.unregister(vm_name)
+          end
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/driver/prl_ctl.rb

@@ -0,0 +1,281 @@
+require 'log4r'
+require 'json'
+
+require 'vagrant/util/busy'
+require 'vagrant/util/platform'
+require 'vagrant/util/retryable'
+require 'vagrant/util/subprocess'
+
+module VagrantPlugins
+  module Parallels
+    module Driver
+      # Base class for all Parallels drivers.
+      #
+      # This class provides useful tools for things such as executing
+      # PrlCtl and handling SIGINTs and so on.
+      class PrlCtl
+        # Include this so we can use `Subprocess` more easily.
+        include Vagrant::Util::Retryable
+
+        attr_reader :uuid
+
+        def initialize(uuid)
+          @logger = Log4r::Logger.new("vagrant::provider::parallels::prlctl")
+
+          # This flag is used to keep track of interrupted state (SIGINT)
+          @interrupted = false
+
+          # Store machine id
+          @uuid = uuid
+
+          # Set the path to prlctl
+          @manager_path = "prlctl"
+
+          @logger.info("Parallels path: #{@manager_path}")
+        end
+
+        # Returns the current state of this VM.
+        #
+        # @return [Symbol]
+        def read_state
+          read_settings(@uuid).fetch('State', 'inaccessible').to_sym
+        end
+
+        # Returns a hash of all UUIDs of virtual machines currently
+        # known by Parallels. Hash keys is VM names
+        #
+        # @return [Hash]
+        def read_vms
+          list = {}
+          json({}) { execute('list', '--all', '--json', retryable: true) }.each do |item|
+            list[item.fetch('name')] = item.fetch('uuid')
+          end
+
+          list
+        end
+
+        # Returns a hash of all UUIDs of VM templates currently
+        # known by Parallels. Hash keys is template names
+        #
+        # @return [Hash]
+        def read_templates
+          list = {}
+          json({}) { execute('list', '--template', '--json', retryable: true) }.each do |item|
+            list[item.fetch('name')] = item.fetch('uuid')
+          end
+
+          list
+        end
+
+        def read_mac_address
+          read_settings.fetch('Hardware', {}).fetch('net0', {}).fetch('mac', nil)
+        end
+
+        # Verifies that the driver is ready to accept work.
+        #
+        # This should raise a VagrantError if things are not ready.
+        def verify!
+          execute('--version')
+        end
+
+        def clear_shared_folders
+          read_settings.fetch("Host Shared Folders", {}).keys.drop(1).each do |folder|
+            execute("set", @uuid, "--shf-host-del", folder)
+          end
+        end
+
+        def import(template_name, vm_name)
+          last = 0
+          execute("clone", template_name, '--name', vm_name) do |type, data|
+            lines = data.split("\r")
+            # The progress of the import will be in the last line. Do a greedy
+            # regular expression to find what we're looking for.
+            if lines.last =~ /.+?(\d{,3})%/
+              current = $1.to_i
+              if current > last
+                last = current
+                yield current if block_given?
+              end
+            end
+          end
+          @uuid = read_settings(vm_name).fetch('ID', vm_name)
+        end
+
+        def delete_adapters
+          read_settings.fetch('Hardware').each do |k, _|
+            if k != 'net0' and k.start_with? 'net'
+              execute('set', @uuid, '--device-del', k)
+            end
+          end
+        end
+
+        def resume
+          execute('resume', @uuid)
+        end
+
+        def suspend
+          execute('suspend', @uuid)
+        end
+
+        def start
+          execute('start', @uuid)
+        end
+
+        def halt(force=false)
+          args = ['stop', @uuid]
+          args << '--kill' if force
+          execute(*args)
+        end
+
+        def delete
+          execute('delete', @uuid)
+        end
+
+        def register(pvm_file)
+          execute("register", pvm_file)
+        end
+
+        def unregister(uuid)
+          execute("unregister", uuid)
+        end
+
+        def registered?(name)
+          read_templates.has_key?(name) || read_vms.has_key?(name)
+        end
+
+        def set_mac_address(mac)
+          execute('set', @uuid, '--device-set', 'net0', '--type', 'shared', '--mac', mac)
+        end
+
+        def ssh_port(expected_port)
+          22
+        end
+
+        def read_guest_tools_version
+          read_settings.fetch('GuestTools', {}).fetch('version', nil)
+        end
+
+        def share_folders(folders)
+          folders.each do |folder|
+            # Add the shared folder
+            execute('set', @uuid, '--shf-host-add', folder[:name], '--path', folder[:hostpath])
+          end
+        end
+
+        def symlink(id, path)
+          guest_execute('ln', '-sf', "/media/psf/#{id}", path)
+        end
+
+        def execute_command(command)
+          raw(*command)
+        end
+
+        def ready?
+          !!guest_execute('uname') rescue false
+        end
+
+        def ip
+          mac_addr = read_mac_address.downcase
+          File.foreach("/Library/Preferences/Parallels/parallels_dhcp_leases") do |line|
+            if line.include? mac_addr
+              ip = line[/^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})/]
+              return ip
+            end
+          end
+        end
+
+        private
+
+        def read_settings(uuid=nil)
+          uuid ||= @uuid
+          json({}) { execute('list', uuid, '--info', '--json', retryable: true).gsub(/^(INFO)?\[/, '').gsub(/\]$/, '') }
+        end
+
+        def json(default=nil)
+          data = yield
+          JSON.parse(data) rescue default
+        end
+
+        def guest_execute(*command)
+          execute('exec', @uuid, *command)
+        end
+
+        # Execute the given subcommand for PrlCtl 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
+
+          # If there is an error with PrlCtl, this gets set to true
+          errored = false
+
+          retryable(on: VagrantPlugins::Parallels::Errors::ParallelsError, tries: tries, sleep: 1) do
+            # Execute the command
+            r = raw(@manager_path, *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 PrlCtl is on the PATH,
+                # but another executable it tries to execute is missing.
+                # This is usually indicative of a corrupted Parallels install.
+                raise VagrantPlugins::Parallels::Errors::ParallelsErrorNotFoundError
+              else
+                errored = true
+              end
+            else
+              if r.stderr =~ /failed to open \/dev\/prlctl/i
+                # This catches an error message that only shows when kernel
+                # drivers aren't properly installed.
+                @logger.error("Error message about unable to open prlctl")
+                raise VagrantPlugins::Parallels::Errors::ParallelsErrorKernelModuleNotLoaded
+              end
+
+              if r.stderr =~ /Unable to perform/i
+                @logger.info("VM not running for command to work.")
+                errored = true
+              elsif r.stderr =~ /Invalid usage/i
+                @logger.info("PrlCtl error text found, assuming error.")
+                errored = true
+              end
+            end
+          end
+
+          # If there was an error running PrlCtl, show the error and the
+          # output.
+          if errored
+            raise VagrantPlugins::Parallels::Errors::ParallelsError,
+              command: command.inspect,
+              stderr:  r.stderr
+          end
+
+          r.stdout
+        end
+
+        # Executes a command and returns the raw result object.
+        def raw(cli, *command, &block)
+          int_callback = lambda do
+            @interrupted = true
+            @logger.info("Interrupted.")
+          end
+
+          # Append in the options for subprocess
+          command << { notify: [:stdout, :stderr] }
+
+          Vagrant::Util::Busy.busy(int_callback) do
+            Vagrant::Util::Subprocess.execute(cli, *command, &block)
+          end
+        end
+      end
+    end
+  end
+end