vagrant-parallels 1.0.5 → 1.0.6.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb12258f3633c2410bb455924faeb91121eab63e
-  data.tar.gz: 7c71d64c033ba1b47194953043e079da0f6e45d5
+  metadata.gz: c81c8a8004ab4f04103fe026fe8336bceb20087d
+  data.tar.gz: 7c35af159575f21dc35bea6d6b975ebb7e3449c8
 SHA512:
-  metadata.gz: f0b684db6250f2bd02b1be5e934d8d8365ae57504ba8448f60ac81fd629ffed3f14b4e26159c44d6042630b349133b430340ad82124c3e8478900bcbca6106a8
-  data.tar.gz: e659d2ca5ff2c560db321a1a1b32f0bf6f70bbe6bc870a0700b82cccf1e279bf9e9b421a49001f4135fc126141763d6b77a326c99f616da5faf0b86c70570eac
+  metadata.gz: 761ef849dd461d789b1826e347c4e42278123995083a5bea95b88f05cf7a11ec1c62b5ee3cce359ee193769bbed5cf4f01e86bd7448d43dfc9a117425d0c7eac
+  data.tar.gz: 658d8e9a2b6eebff58b9b343ebfedf33df44bbf6644ace802068c89668122826077e691b5bf6df811be0aabed5dc9fdbb294bdf37086972d5e5b1f6af9f170cf

data/lib/vagrant-parallels/action.rb

@@ -168,7 +168,6 @@ module VagrantPlugins
               b2.use EnvSet, :port_collision_repair => false
               b2.use Resume
               b2.use WaitForCommunicator, [:resuming, :running]
-              b2.use ForcePrlFsMount
             else
               b2.use MessageNotCreated
             end
@@ -284,7 +283,6 @@ module VagrantPlugins
       autoload :DestroyUnusedNetworkInterfaces, File.expand_path("../action/destroy_unused_network_interfaces", __FILE__)
       autoload :Export, File.expand_path("../action/export", __FILE__)
       autoload :ForcedHalt, File.expand_path("../action/forced_halt", __FILE__)
-      autoload :ForcePrlFsMount, File.expand_path("../action/force_prl_fs_mount", __FILE__)
       autoload :Import, File.expand_path("../action/import", __FILE__)
       autoload :IsSuspended, File.expand_path("../action/is_suspended", __FILE__)
       autoload :IsRunning, File.expand_path("../action/is_running", __FILE__)

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

@@ -2,307 +2,17 @@ require 'log4r'
 
 require 'vagrant/util/platform'
 
-require File.expand_path("../base", __FILE__)
+require File.expand_path("../pd_8", __FILE__)
 
 module VagrantPlugins
   module Parallels
     module Driver
       # Driver for Parallels Desktop 9.
-      class PD_9 < Base
+      class PD_9 < PD_8
         def initialize(uuid)
-          super()
+          super(uuid)
 
           @logger = Log4r::Logger.new("vagrant::provider::parallels::pd_9")
-          @uuid = uuid
-        end
-
-
-        def compact(uuid)
-          used_drives = read_settings.fetch('Hardware', {}).select { |name, _| name.start_with? 'hdd' }
-          used_drives.each_value do |drive_params|
-            execute(:prl_disk_tool, 'compact', '--hdd', drive_params["image"]) do |type, data|
-              lines = data.split("\r")
-              # The progress of the compact will be in the last line. Do a greedy
-              # regular expression to find what we're looking for.
-              if lines.last =~ /.+?(\d{,3}) ?%/
-                yield $1.to_i if block_given?
-              end
-            end
-          end
-        end
-
-        def clear_shared_folders
-          share_ids = read_shared_folders.keys
-          share_ids.each do |id|
-            execute("set", @uuid, "--shf-host-del", id)
-          end
-        end
-
-        def create_host_only_network(options)
-          # Create the interface
-          execute(:prlsrvctl, "net", "add", options[:network_id], "--type", "host-only")
-
-          # Configure it
-          args = ["--ip", "#{options[:adapter_ip]}/#{options[:netmask]}"]
-          if options[:dhcp]
-            args.concat(["--dhcp-ip", options[:dhcp][:ip],
-                         "--ip-scope-start", options[:dhcp][:lower],
-                         "--ip-scope-end", options[:dhcp][:upper]])
-          end
-
-          execute(:prlsrvctl, "net", "set", options[:network_id], *args)
-
-          # Determine interface to which it has been bound
-          net_info = json { execute(:prlsrvctl, 'net', 'info', options[:network_id], '--json', retryable: true) }
-          iface_name = net_info['Bound To']
-
-          # Return the details
-          return {
-            :name => iface_name,
-            :ip   => options[:adapter_ip],
-            :netmask => options[:netmask],
-            :dhcp => options[:dhcp]
-          }
-        end
-
-        def delete
-          execute('delete', @uuid)
-        end
-
-        def delete_disabled_adapters
-          read_settings.fetch('Hardware', {}).each do |adapter, params|
-            if adapter.start_with?('net') and !params.fetch("enabled", true)
-              execute('set', @uuid, '--device-del', adapter)
-            end
-          end
-        end
-
-        def delete_unused_host_only_networks
-          networks = read_virtual_networks
-
-          # 'Shared'(vnic0) and 'Host-Only'(vnic1) are default in Parallels Desktop
-          # They should not be deleted anyway.
-          networks.keep_if do |net|
-            net['Type'] == "host-only" &&
-              net['Bound To'].match(/^(?>vnic|Parallels Host-Only #)(\d+)$/)[1].to_i >= 2
-          end
-
-          read_vms_info.each do |vm|
-            used_nets = vm.fetch('Hardware', {}).select { |name, _| name.start_with? 'net' }
-            used_nets.each_value do |net_params|
-              networks.delete_if { |net|  net['Bound To'] == net_params.fetch('iface', nil) }
-            end
-
-          end
-
-          networks.each do |net|
-            # Delete the actual host only network interface.
-            execute(:prlsrvctl, "net", "del", net["Network ID"])
-          end
-        end
-
-        def enable_adapters(adapters)
-          # Get adapters which have already configured for this VM
-          # Such adapters will be just overridden
-          existing_adapters = read_settings.fetch('Hardware', {}).keys.select { |name| name.start_with? 'net' }
-
-          # Disable all previously existing adapters (except shared 'vnet0')
-          existing_adapters.each do |adapter|
-            if adapter != 'vnet0'
-              execute('set', @uuid, '--device-set', adapter, '--disable')
-            end
-          end
-
-          adapters.each do |adapter|
-            args = []
-            if existing_adapters.include? "net#{adapter[:adapter]}"
-              args.concat(["--device-set","net#{adapter[:adapter]}", "--enable"])
-            else
-              args.concat(["--device-add", "net"])
-            end
-
-            if adapter[:type] == :hostonly
-              # Oddly enough, but there is a 'bridge' anyway.
-              # The only difference is the destination interface:
-              # - in host-only (private) network it will be bridged to the 'vnicX' device
-              # - in real bridge (public) network it will be bridged to the assigned device
-              args.concat(["--type", "bridged", "--iface", adapter[:hostonly]])
-            elsif adapter[:type] == :bridge
-              args.concat(["--type", "bridged", "--iface", adapter[:bridge]])
-            elsif adapter[:type] == :shared
-              args.concat(["--type", "shared"])
-            end
-
-            if adapter[:mac_address]
-              args.concat(["--mac", adapter[:mac_address]])
-            end
-
-            if adapter[:nic_type]
-              args.concat(["--adapter-type", adapter[:nic_type].to_s])
-            end
-
-            execute("set", @uuid, *args)
-          end
-        end
-
-        def execute_command(command)
-          execute(*command)
-        end
-
-        def export(path, tpl_name)
-          execute("clone", @uuid, "--name", tpl_name, "--template", "--dst", path.to_s) do |type, data|
-            lines = data.split("\r")
-            # The progress of the export will be in the last line. Do a greedy
-            # regular expression to find what we're looking for.
-            if lines.last =~ /.+?(\d{,3}) ?%/
-              yield $1.to_i if block_given?
-            end
-          end
-          read_vms[tpl_name]
-        end
-
-        def halt(force=false)
-          args = ['stop', @uuid]
-          args << '--kill' if force
-          execute(*args)
-        end
-
-        def import(template_uuid)
-          template_name = read_vms.key(template_uuid)
-          vm_name = "#{template_name}_#{(Time.now.to_f * 1000.0).to_i}_#{rand(100000)}"
-
-          execute("clone", template_uuid, '--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}) ?%/
-              yield $1.to_i if block_given?
-            end
-          end
-          read_vms[vm_name]
-        end
-
-        def read_bridged_interfaces
-          host_hw_info = read_host_info.fetch("Hardware info")
-          net_list = host_hw_info.select do |name, attrs|
-            # Get all network interfaces except 'vnicXXX'
-            attrs.fetch("type") == "net" and name !~ /^(vnic(.+?))$/
-          end
-
-          bridged_ifaces = []
-          net_list.keys.each do |iface|
-            info = {}
-            ifconfig = execute(:ifconfig, iface)
-            # Assign default values
-            info[:name]    = iface
-            info[:ip]      = "0.0.0.0"
-            info[:netmask] = "0.0.0.0"
-            info[:status]  = "Down"
-
-            if ifconfig =~ /(?<=inet\s)(\S*)/
-              info[:ip] = $1.to_s
-            end
-            if ifconfig =~ /(?<=netmask\s)(\S*)/
-              # Netmask will be converted from hex to dec:
-              # '0xffffff00' -> '255.255.255.0'
-              info[:netmask] = $1.hex.to_s(16).scan(/../).each.map{|octet| octet.hex}.join(".")
-            end
-            if ifconfig =~ /\W(UP)\W/ and ifconfig !~ /(?<=status:\s)inactive$/
-              info[:status] = "Up"
-            end
-
-            bridged_ifaces << info
-          end
-          bridged_ifaces
-        end
-
-        def read_guest_ip
-          mac_addr = read_mac_address.downcase
-          leases_file = "/Library/Preferences/Parallels/parallels_dhcp_leases"
-          begin
-            File.open(leases_file).grep(/#{mac_addr}/) do |line|
-              return line[/^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})/]
-            end
-          rescue Errno::EACCES
-            raise Errors::DhcpLeasesNotAccessible, :leases_file => leases_file.to_s
-          rescue Errno::ENOENT
-            # File does not exist
-            # Perhaps, it is the fist start of Parallels Desktop
-            return nil
-          end
-
-          nil
-        end
-
-        def read_guest_tools_version
-          read_settings.fetch('GuestTools', {}).fetch('version', nil)
-        end
-
-        def read_host_info
-          json { execute('server', 'info', '--json', retryable: true) }
-        end
-
-        def read_host_only_interfaces
-          net_list = read_virtual_networks
-          net_list.keep_if { |net| net['Type'] == "host-only" }
-
-          hostonly_ifaces = []
-          net_list.each do |iface|
-            info = {}
-            net_info = json { execute(:prlsrvctl, 'net', 'info', iface['Network ID'], '--json') }
-            # Really we need to work with bounded virtual interface
-            info[:name]     = net_info['Bound To']
-            info[:ip]       = net_info['Parallels adapter']['IP address']
-            info[:netmask]  = net_info['Parallels adapter']['Subnet mask']
-            # Such interfaces are always in 'Up'
-            info[:status]   = "Up"
-
-            # There may be a fake DHCPv4 parameters
-            # We can trust them only if adapter IP and DHCP IP are in the same subnet
-            dhcp_ip = net_info['DHCPv4 server']['Server address']
-            if network_address(info[:ip], info[:netmask]) == network_address(dhcp_ip, info[:netmask])
-              info[:dhcp] = {
-                :ip      => dhcp_ip,
-                :lower   => net_info['DHCPv4 server']['IP scope start address'],
-                :upper   => net_info['DHCPv4 server']['IP scope end address']
-              }
-            end
-            hostonly_ifaces << info
-          end
-          hostonly_ifaces
-        end
-
-        def read_mac_address
-          read_settings.fetch('Hardware', {}).fetch('net0', {}).fetch('mac', nil)
-        end
-
-        def read_network_interfaces
-          nics = {}
-
-          # Get enabled VM's network interfaces
-          ifaces = read_settings.fetch('Hardware', {}).keep_if do |dev, params|
-            dev.start_with?('net') and params.fetch("enabled", true)
-          end
-          ifaces.each do |name, params|
-            adapter = name.match(/^net(\d+)$/)[1].to_i
-            nics[adapter] ||= {}
-
-            if params['type'] == "shared"
-              nics[adapter][:type] = :shared
-            elsif params['type'] == "host"
-              # It is PD internal host-only network and it is bounded to 'vnic1'
-              nics[adapter][:type] = :hostonly
-              nics[adapter][:hostonly] = "vnic1"
-            elsif params['type'] == "bridged" and params.fetch('iface','').start_with?('vnic')
-              # Bridged to the 'vnicXX'? Then it is a host-only, actually.
-              nics[adapter][:type] = :hostonly
-              nics[adapter][:hostonly] = params.fetch('iface','')
-            elsif params['type'] == "bridged"
-              nics[adapter][:type] = :bridged
-              nics[adapter][:bridge] = params.fetch('iface','')
-            end
-          end
-          nics
         end
 
         def read_settings
@@ -310,50 +20,12 @@ module VagrantPlugins
           vm.last
         end
 
-        def read_shared_interface
-          # There should be only one Shared interface
-          shared_net = read_virtual_networks.detect { |net| net['Type'] == 'shared' }
-          return nil if !shared_net
-
-          net_info = json { execute(:prlsrvctl, 'net', 'info', shared_net['Network ID'], '--json') }
-          info = {
-            name:    net_info['Bound To'],
-            ip:      net_info['Parallels adapter']['IP address'],
-            netmask: net_info['Parallels adapter']['Subnet mask'],
-            status:  "Up"
-          }
-
-          if net_info.key?('DHCPv4 server')
-            info[:dhcp] = {
-              ip:    net_info['DHCPv4 server']['Server address'],
-              lower: net_info['DHCPv4 server']['IP scope start address'],
-              upper: net_info['DHCPv4 server']['IP scope end address']
-            }
-          end
-
-          info
-        end
-
-        def read_shared_folders
-          shf_info = read_settings.fetch("Host Shared Folders", {})
-          list = {}
-          shf_info.delete_if {|k,v| k == "enabled"}.each do |id, data|
-            list[id] = data.fetch("path")
-          end
-
-          list
-        end
-
         def read_state
           vm = json { execute('list', @uuid, '--json', retryable: true) }
           return nil if !vm.last
           vm.last.fetch('status').to_sym
         end
 
-        def read_virtual_networks
-          json { execute(:prlsrvctl, 'net', 'list', '--json', retryable: true) }
-        end
-
         def read_vms
           results = {}
           vms_arr = json([]) do
@@ -380,76 +52,6 @@ module VagrantPlugins
           end
           vms_arr | templates_arr
         end
-
-        def read_vms_paths
-          list = {}
-          read_vms_info.each do |item|
-            if Dir.exists? item.fetch('Home')
-              list[File.realpath item.fetch('Home')] = item.fetch('ID')
-            end
-          end
-
-          list
-        end
-
-        def register(pvm_file)
-          execute("register", pvm_file)
-        end
-
-        def registered?(uuid)
-          read_vms.has_value?(uuid)
-        end
-
-        def resume
-          execute('resume', @uuid)
-        end
-
-        def set_mac_address(mac)
-          execute('set', @uuid, '--device-set', 'net0', '--type', 'shared', '--mac', mac)
-        end
-
-        def set_name(name)
-          execute('set', @uuid, '--name', name, :retryable => true)
-        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 ssh_port(expected_port)
-          expected_port
-        end
-
-        def start
-          execute('start', @uuid)
-        end
-
-        def suspend
-          execute('suspend', @uuid)
-        end
-
-        def unregister(uuid)
-          execute("unregister", uuid)
-        end
-
-        def verify!
-          version
-        end
-
-        def version
-          if execute('--version', retryable: true) =~ /prlctl version ([\d\.]+)/
-            $1.downcase
-          else
-            raise VagrantPlugins::Parallels::Errors::ParallelsInstallIncomplete
-          end
-        end
-
-        def vm_exists?(uuid)
-          raw("list", uuid).exit_code == 0
-        end
       end
     end
   end

data/lib/vagrant-parallels/guest_cap/linux/mount_parallels_shared_folder.rb

@@ -4,74 +4,35 @@ module VagrantPlugins
       class MountParallelsSharedFolder
 
         def self.mount_parallels_shared_folder(machine, name, guestpath, options)
+          # Expand the guest path so we can handle things like "~/vagrant"
           expanded_guest_path = machine.guest.capability(
             :shell_expand_guest_path, guestpath)
 
-          mount_commands = []
-
-          if options[:owner].is_a? Integer
-            mount_uid = options[:owner]
-          else
-            mount_uid = "`id -u #{options[:owner]}`"
-          end
-
-          if options[:group].is_a? Integer
-            mount_gid = options[:group]
-            mount_gid_old = options[:group]
-          else
-            mount_gid = "`getent group #{options[:group]} | cut -d: -f3`"
-            mount_gid_old = "`id -g #{options[:group]}`"
-          end
-
-          # First mount command uses getent to get the group
-          mount_options = "-o uid=#{mount_uid},gid=#{mount_gid}"
-          mount_options += ",#{options[:mount_options].join(",")}" if options[:mount_options]
-          mount_commands << "mount -t prl_fs #{mount_options} #{name} #{expanded_guest_path}"
-
-          # Second mount command uses the old style `id -g`
-          mount_options = "-o uid=#{mount_uid},gid=#{mount_gid_old}"
-          mount_options += ",#{options[:mount_options].join(",")}" if options[:mount_options]
-          mount_commands << "mount -t prl_fs #{mount_options} #{name} #{expanded_guest_path}"
-
-          # Clear prior symlink if exists
-          if machine.communicate.test("test -L #{expanded_guest_path}")
-            machine.communicate.sudo("rm #{expanded_guest_path}")
-          end
-
-          # Create the guest path if it doesn't exist
-          machine.communicate.sudo("mkdir -p #{expanded_guest_path}")
-
-          # Attempt to mount the folder. We retry here a few times because
-          # it can fail early on.
-          attempts = 0
-          while true
-            success = true
-
-            mount_commands.each do |command|
-              no_such_device = false
-              status = machine.communicate.sudo(command, error_check: false) do |type, data|
-                no_such_device = true if type == :stderr && data =~ /No such device/i
-              end
-
-              success = status == 0 && !no_such_device
-              break if success
+          machine.communicate.tap do |comm|
+            # clear prior symlink
+            if comm.test("test -L \"#{expanded_guest_path}\"", :sudo => true)
+              comm.sudo("rm \"#{expanded_guest_path}\"")
             end
 
-            break if success
+            # clear prior directory if exists
+            if comm.test("test -d \"#{expanded_guest_path}\"", :sudo => true)
+              comm.sudo("rm -Rf \"#{expanded_guest_path}\"")
+            end
 
-            attempts += 1
-            if attempts > 10
-              raise Vagrant::Errors::LinuxMountFailed,
-                    command: mount_commands.join("\n")
+            # create intermediate directories if needed
+            intermediate_dir = File.dirname(expanded_guest_path)
+            if !comm.test("test -d \"#{intermediate_dir}\"", :sudo => true)
+              comm.sudo("mkdir -p \"#{intermediate_dir}\"")
             end
 
-            sleep 2
-          end
+            # finally make the symlink
+            comm.sudo("ln -s \"/media/psf/#{name}\" \"#{expanded_guest_path}\"")
 
-          # Emit an upstart event if we can
-          if machine.communicate.test("test -x /sbin/initctl")
-            machine.communicate.sudo(
-              "/sbin/initctl emit --no-wait vagrant-mounted MOUNTPOINT=#{expanded_guest_path}")
+            # Emit an upstart event if we can
+            if comm.test("test -x /sbin/initctl")
+              comm.sudo(
+                "/sbin/initctl emit --no-wait vagrant-mounted MOUNTPOINT=#{expanded_guest_path}")
+            end
           end
         end
       end

data/lib/vagrant-parallels/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Parallels
-    VERSION = "1.0.5"
+    VERSION = "1.0.6.rc1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-parallels
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6.rc1
 platform: ruby
 authors:
 - Mikhail Zholobov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-23 00:00:00.000000000 Z
+date: 2014-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -90,7 +90,6 @@ files:
 - lib/vagrant-parallels/action/destroy.rb
 - lib/vagrant-parallels/action/destroy_unused_network_interfaces.rb
 - lib/vagrant-parallels/action/export.rb
-- lib/vagrant-parallels/action/force_prl_fs_mount.rb
 - lib/vagrant-parallels/action/forced_halt.rb
 - lib/vagrant-parallels/action/import.rb
 - lib/vagrant-parallels/action/is_running.rb

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

@@ -1,55 +0,0 @@
-require "log4r"
-require 'vagrant/util/platform'
-
-module VagrantPlugins
-  module Parallels
-    module Action
-      class ForcePrlFsMount
-        # This middleware forces the prl_fs mount after the Resume, because
-        # there is bug in Linux guests - custom shared folders are missed after
-        # the resume [GH-102]
-        include Vagrant::Action::Builtin::MixinSyncedFolders
-
-        def initialize(app, env)
-          @app = app
-          @logger = Log4r::Logger.new("vagrant::plugins::parallels::force_prl_fs_mount")
-        end
-
-        def call(env)
-          # Only for Linux guests!
-          if env[:machine].communicate.test("uname -s | grep 'Linux'")
-            folders = synced_folders(env[:machine])[:parallels]
-
-            # Go through each folder and make sure to create it if
-            # it does not exist on host
-            folders.each do |id, data|
-              data[:hostpath] = File.expand_path(data[:hostpath], env[:root_path])
-
-              # Create the hostpath if it doesn't exist and we've been told to
-              if !File.directory?(data[:hostpath]) && data[:create]
-                @logger.info("Creating shared folder host directory: #{data[:hostpath]}")
-                begin
-                  Pathname.new(data[:hostpath]).mkpath
-                rescue Errno::EACCES
-                  raise Vagrant::Errors::SharedFolderCreateFailed,
-                        path: data[:hostpath]
-                end
-              end
-
-              if File.directory?(data[:hostpath])
-                data[:hostpath] = File.realpath(data[:hostpath])
-                data[:hostpath] = Vagrant::Util::Platform.fs_real_path(data[:hostpath]).to_s
-              end
-            end
-
-            opts = nil
-            instance = VagrantPlugins::Parallels::SyncedFolder.new
-            instance.enable(env[:machine], folders, opts)
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end