vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/cap/change_host_name.rb

@@ -1,41 +0,0 @@
-module VagrantPlugins
-  module GuestWindows
-    module Cap
-      module ChangeHostName
-
-        def self.change_host_name(machine, name)
-          change_host_name_and_wait(machine, name, machine.config.vm.graceful_halt_timeout)
-        end
-
-        def self.change_host_name_and_wait(machine, name, sleep_timeout)
-          # If the configured name matches the current name, then bail
-          # We cannot use %ComputerName% because it truncates at 15 chars
-          return if machine.communicate.test("if ([System.Net.Dns]::GetHostName() -eq '#{name}') { exit 0 } exit 1")
-          
-          # Rename and reboot host if rename succeeded
-          script = <<-EOH
-            $computer = Get-WmiObject -Class Win32_ComputerSystem
-            $retval = $computer.rename("#{name}").returnvalue
-            if ($retval -eq 0) {
-              shutdown /r /t 5 /f /d p:4:1 /c "Vagrant Rename Computer"
-            }
-            exit $retval
-          EOH
-
-          machine.communicate.execute(
-            script,
-            error_class: Errors::RenameComputerFailed,
-            error_key: :rename_computer_failed)
-
-          # Don't continue until the machine has shutdown and rebooted
-	  if machine.guest.capability?(:wait_for_reboot)
-            machine.guest.capability(:wait_for_reboot)
-          else
-            # use graceful_halt_timeout only if guest cannot wait for reboot
-            sleep(sleep_timeout)
-	  end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/cap/choose_addressable_ip_addr.rb

@@ -1,20 +0,0 @@
-module VagrantPlugins
-  module GuestWindows
-    module Cap
-      module ChooseAddressableIPAddr
-        def self.choose_addressable_ip_addr(machine, possible)
-          machine.communicate.tap do |comm|
-            possible.each do |ip|
-              command = "ping -n 1 -w 1 #{ip}"
-              if comm.test(command)
-                return ip
-              end
-            end
-          end
-
-          nil
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/cap/configure_networks.rb

@@ -1,80 +0,0 @@
-require "log4r"
-
-require_relative "../guest_network"
-
-module VagrantPlugins
-  module GuestWindows
-    module Cap
-      module ConfigureNetworks
-        @@logger = Log4r::Logger.new("vagrant::guest::windows::configure_networks")
-
-        def self.configure_networks(machine, networks)
-          @@logger.debug("Networks: #{networks.inspect}")
-
-          guest_network = GuestNetwork.new(machine.communicate)
-          if machine.provider_name.to_s.start_with?("vmware")
-            machine.ui.warn("Configuring secondary network adapters through VMware ")
-            machine.ui.warn("on Windows is not yet supported. You will need to manually")
-            machine.ui.warn("configure the network adapter.")
-          else
-            vm_interface_map = create_vm_interface_map(machine, guest_network)
-            networks.each do |network|
-              interface = vm_interface_map[network[:interface]+1]
-              if interface.nil?
-                @@logger.warn("Could not find interface for network #{network.inspect}")
-                next
-              end
-
-              network_type = network[:type].to_sym
-              if network_type == :static
-                guest_network.configure_static_interface(
-                  interface[:index],
-                  interface[:net_connection_id],
-                  network[:ip],
-                  network[:netmask])
-              elsif network_type == :dhcp
-                guest_network.configure_dhcp_interface(
-                  interface[:index],
-                  interface[:net_connection_id])
-              else
-                raise "#{network_type} network type is not supported, try static or dhcp"
-              end
-            end
-          end
-
-          if machine.config.windows.set_work_network
-            guest_network.set_all_networks_to_work
-          end
-        end
-
-        def self.create_vm_interface_map(machine, guest_network)
-          if !machine.provider.capability?(:nic_mac_addresses)
-            raise Vagrant::Errors::CantReadMACAddresses,
-              provider: machine.provider_name.to_s
-          end
-
-          driver_mac_address = machine.provider.capability(:nic_mac_addresses).invert
-          @@logger.debug("mac addresses: #{driver_mac_address.inspect}")
-
-          vm_interface_map = {}
-          guest_network.network_adapters.each do |nic|
-            @@logger.debug("nic: #{nic.inspect}")
-            naked_mac = nic[:mac_address].gsub(':','')
-            # If the :net_connection_id entry is nil then it is probably a virtual connection
-            # and should be ignored.
-            if driver_mac_address[naked_mac] && !nic[:net_connection_id].nil?
-              vm_interface_map[driver_mac_address[naked_mac]] = {
-                net_connection_id: nic[:net_connection_id],
-                mac_address: naked_mac,
-                interface_index: nic[:interface_index],
-                index: nic[:index] }
-            end
-          end
-
-          @@logger.debug("vm_interface_map: #{vm_interface_map.inspect}")
-          vm_interface_map
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/cap/halt.rb

@@ -1,16 +0,0 @@
-module VagrantPlugins
-  module GuestWindows
-    module Cap
-      module Halt
-        def self.halt(machine)
-          # Fix vagrant-windows GH-129, if there's an existing scheduled
-          # reboot cancel it so shutdown succeeds
-          machine.communicate.execute("shutdown -a", error_check: false)
-
-          # Force shutdown the machine now
-          machine.communicate.execute("shutdown /s /t 1 /c \"Vagrant Halt\" /f /d p:4:1")
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/cap/mount_shared_folder.rb

@@ -1,57 +0,0 @@
-require "vagrant/util/template_renderer"
-require "base64"
-
-module VagrantPlugins
-  module GuestWindows
-    module Cap
-      class MountSharedFolder
-        def self.mount_virtualbox_shared_folder(machine, name, guestpath, options)
-          mount_shared_folder(machine, name, guestpath, "\\\\vboxsvr\\")
-        end
-
-        def self.mount_vmware_shared_folder(machine, name, guestpath, options)
-          mount_shared_folder(machine, name, guestpath, "\\\\vmware-host\\Shared Folders\\")
-        end
-
-        def self.mount_parallels_shared_folder(machine, name, guestpath, options)
-          mount_shared_folder(machine, name, guestpath, "\\\\psf\\")
-        end
-
-        def self.mount_smb_shared_folder(machine, name, guestpath, options)
-          if !options[:smb_password].to_s.empty?
-            # Ensure password is scrubbed
-            Vagrant::Util::CredentialScrubber.sensitive(options[:smb_password])
-          end
-          machine.communicate.execute("cmdkey /add:#{options[:smb_host]} /user:#{options[:smb_username]} /pass:#{options[:smb_password]}", {shell: :powershell, elevated: true})
-          mount_shared_folder(machine, name, guestpath, "\\\\#{options[:smb_host]}\\")
-        end
-
-        protected
-
-        def self.mount_shared_folder(machine, name, guestpath, vm_provider_unc_base)
-          name = name.gsub(/[\/\/]/,'_').sub(/^_/, '')
-
-          path = File.expand_path("../../scripts/mount_volume.ps1", __FILE__)
-          script = Vagrant::Util::TemplateRenderer.render(path, options: {
-            mount_point: guestpath,
-            share_name: name,
-            vm_provider_unc_path: vm_provider_unc_base + name,
-          })
-
-          if machine.config.vm.communicator == :winrm || machine.config.vm.communicator == :winssh
-            machine.communicate.execute(script, shell: :powershell)
-          else
-            # Convert script to double byte unicode string then base64 encode
-            # just like PowerShell -EncodedCommand expects.
-            # Suppress the progress stream from leaking to stderr.
-            wrapped_encoded_command = Base64.strict_encode64(
-              "$ProgressPreference='SilentlyContinue'; #{script}; exit $LASTEXITCODE".encode('UTF-16LE', 'UTF-8'))
-            # Execute encoded PowerShell script via OpenSSH shell
-            machine.communicate.execute("powershell.exe -noprofile -executionpolicy bypass " +
-              "-encodedcommand '#{wrapped_encoded_command}'", shell: "sh")
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/cap/public_key.rb

@@ -1,84 +0,0 @@
-require "tempfile"
-
-require_relative '../../../communicators/winssh/communicator'
-
-module VagrantPlugins
-  module GuestWindows
-    module Cap
-      class PublicKey
-        def self.insert_public_key(machine, contents)
-          if machine.communicate.is_a?(CommunicatorWinSSH::Communicator)
-            contents = contents.strip
-            winssh_modify_authorized_keys machine do |keys|
-              if !keys.include?(contents)
-                keys << contents
-              end
-            end
-          else
-            raise Vagrant::Errors::SSHInsertKeyUnsupported
-          end
-        end
-
-        def self.remove_public_key(machine, contents)
-          if machine.communicate.is_a?(CommunicatorWinSSH::Communicator)
-            winssh_modify_authorized_keys machine do |keys|
-              keys.delete(contents)
-            end
-          else
-            raise Vagrant::Errors::SSHInsertKeyUnsupported
-          end
-        end
-
-        def self.winssh_modify_authorized_keys(machine)
-          comm = machine.communicate
-          directories = fetch_guest_paths(comm)
-          home_dir = directories[:home]
-          temp_dir = directories[:temp]
-
-          # Ensure the user's ssh directory exists
-          remote_ssh_dir = "#{home_dir}\\.ssh"
-          comm.execute("dir \"#{remote_ssh_dir}\"\n if errorlevel 1 (mkdir \"#{remote_ssh_dir}\")", shell: "cmd")
-          remote_upload_path = "#{temp_dir}\\vagrant-insert-pubkey-#{Time.now.to_i}"
-          remote_authkeys_path = "#{remote_ssh_dir}\\authorized_keys"
-
-          keys_file = Tempfile.new("vagrant-windows-insert-public-key")
-          keys_file.close
-          # Check if an authorized_keys file already exists
-          result = comm.execute("dir \"#{remote_authkeys_path}\"", shell: "cmd", error_check: false)
-          if result == 0
-            comm.download(remote_authkeys_path, keys_file.path)
-            keys = File.read(keys_file.path).split(/[\r\n]+/)
-          else
-            keys = []
-          end
-          yield keys
-          File.write(keys_file.path, keys.join("\r\n") + "\r\n")
-          comm.upload(keys_file.path, remote_upload_path)
-          keys_file.delete
-          comm.execute <<-EOC.gsub(/^\s*/, ""), shell: "powershell"
-            Set-Acl "#{remote_upload_path}" (Get-Acl "#{remote_authkeys_path}")
-            Move-Item -Force "#{remote_upload_path}" "#{remote_authkeys_path}"
-          EOC
-        end
-
-        # Fetch user's temporary and home directory paths from the Windows guest
-        #
-        # @param [Communicator]
-        # @return [Hash] {:temp, :home}
-        def self.fetch_guest_paths(communicator)
-          output = ""
-          communicator.execute("echo %TEMP%\necho %USERPROFILE%", shell: "cmd") do |type, data|
-            if type == :stdout
-              output << data
-            end
-          end
-          temp_dir, home_dir = output.strip.split(/[\r\n]+/)
-          if temp_dir.nil? || home_dir.nil?
-            raise Errors::PublicKeyDirectoryFailure
-          end
-          {temp: temp_dir, home: home_dir}
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/cap/reboot.rb

@@ -1,23 +0,0 @@
-module VagrantPlugins
-  module GuestWindows
-    module Cap
-      class Reboot
-        def self.wait_for_reboot(machine)
-          # Technically it should be possible to make it work with SSH
-          # too, but we don't yet.
-          return if machine.config.vm.communicator != :winrm
-
-          script  = File.expand_path("../../scripts/reboot_detect.ps1", __FILE__)
-          script  = File.read(script)
-          while machine.communicate.execute(script, error_check: false) != 0
-            sleep 10
-          end
-
-          # This re-establishes our symbolic links if they were
-          # created between now and a reboot
-          machine.communicate.execute("net use", error_check: false)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/cap/rsync.rb

@@ -1,22 +0,0 @@
-module VagrantPlugins
-  module GuestWindows
-    module Cap
-      class RSync
-        def self.rsync_scrub_guestpath( machine, opts )
-          # Windows guests most often use cygwin-dependent rsync utilities
-          # that expect "/cygdrive/c" instead of "c:" as the path prefix
-          # some vagrant code may pass guest paths with drive-lettered paths here
-          opts[:guestpath].gsub( /^([a-zA-Z]):/, '/cygdrive/\1' )
-        end
-
-        def self.rsync_pre(machine, opts)
-          machine.communicate.tap do |comm|
-            # rsync does not construct any gaps in the path to the target directory
-            # make sure that all subdirectories are created
-            comm.execute("mkdir -p '#{opts[:guestpath]}'")
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/config.rb

@@ -1,23 +0,0 @@
-module VagrantPlugins
-  module GuestWindows
-    class Config < Vagrant.plugin("2", :config)
-      attr_accessor :set_work_network
-
-      def initialize
-        @set_work_network = UNSET_VALUE
-      end
-
-      def validate(machine)
-        errors = []
-
-        errors << "windows.set_work_network cannot be nil." if @set_work_network.nil?
-
-        { "Windows Guest" => errors }
-      end
-
-      def finalize!
-        @set_work_network = false if @set_work_network == UNSET_VALUE
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/errors.rb

@@ -1,22 +0,0 @@
-module VagrantPlugins
-  module GuestWindows
-    module Errors
-      # A convenient superclass for all our errors.
-      class WindowsError < Vagrant::Errors::VagrantError
-        error_namespace("vagrant_windows.errors")
-      end
-
-      class NetworkWinRMRequired < WindowsError
-        error_key(:network_winrm_required)
-      end
-
-      class RenameComputerFailed < WindowsError
-        error_key(:rename_computer_failed)
-      end
-
-      class PublicKeyDirectoryFailure < WindowsError
-        error_key(:public_key_directory_failure)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/guest.rb

@@ -1,10 +0,0 @@
-module VagrantPlugins
-  module GuestWindows
-    class Guest < Vagrant.plugin("2", :guest)
-      def detect?(machine)
-        # See if the Windows directory is present.
-        machine.communicate.test("test -d $Env:SystemRoot")
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/guest_network.rb

@@ -1,125 +0,0 @@
-require "log4r"
-
-module VagrantPlugins
-  module GuestWindows
-    # Manages the remote Windows guest network.
-    class GuestNetwork
-      PS_GET_WSMAN_VER = '((test-wsman).productversion.split(" ") | select -last 1).split("\.")[0]'
-      WQL_NET_ADAPTERS_V2 = 'SELECT * FROM Win32_NetworkAdapter WHERE MACAddress IS NOT NULL'
-
-      def initialize(communicator)
-        @logger       = Log4r::Logger.new("vagrant::windows::guestnetwork")
-        @communicator = communicator
-      end
-
-      # Returns an array of all NICs on the guest. Each array entry is a
-      # Hash of the NICs properties.
-      #
-      # @return [Array]
-      def network_adapters
-        wsman_version == 2? network_adapters_v2_winrm : network_adapters_v3_winrm
-      end
-
-      # Checks to see if the specified NIC is currently configured for DHCP.
-      #
-      # @return [Boolean]
-      def is_dhcp_enabled(nic_index)
-        cmd = <<-EOH
-          if (Get-WmiObject -Class Win32_NetworkAdapterConfiguration -Filter "Index=#{nic_index} and DHCPEnabled=True") {
-            exit 0
-          }
-          exit 1
-        EOH
-        @communicator.test(cmd)
-      end
-
-      # Configures the specified interface for DHCP
-      #
-      # @param [Integer] The interface index.
-      # @param [String] The unique name of the NIC, such as 'Local Area Connection'.
-      def configure_dhcp_interface(nic_index, net_connection_id)
-        @logger.info("Configuring NIC #{net_connection_id} for DHCP")
-        if !is_dhcp_enabled(nic_index)
-          netsh = "netsh interface ip set address \"#{net_connection_id}\" dhcp"
-          @communicator.execute(netsh)
-        end
-      end
-
-      # Configures the specified interface using a static address
-      #
-      # @param [Integer] The interface index.
-      # @param [String] The unique name of the NIC, such as 'Local Area Connection'.
-      # @param [String] The static IP address to assign to the specified NIC.
-      # @param [String] The network mask to use with the static IP.
-      def configure_static_interface(nic_index, net_connection_id, ip, netmask)
-        @logger.info("Configuring NIC #{net_connection_id} using static ip #{ip}")
-        #netsh interface ip set address "Local Area Connection 2" static 192.168.33.10 255.255.255.0
-        netsh = "netsh interface ip set address \"#{net_connection_id}\" static #{ip} #{netmask}"
-        @communicator.execute(netsh)
-      end
-
-      # Sets all networks on the guest to 'Work Network' mode. This is
-      # to allow guest access from the host via a private IP on Win7
-      # https://github.com/WinRb/vagrant-windows/issues/63
-      def set_all_networks_to_work
-        @logger.info("Setting all networks to 'Work Network'")
-        command = File.read(File.expand_path("../scripts/set_work_network.ps1", __FILE__))
-        @communicator.execute(command, { shell: :powershell })
-      end
-
-      protected
-
-      # Checks the WinRS version on the guest. Usually 2 on Windows 7/2008
-      # and 3 on Windows 8/2012.
-      #
-      # @return [Integer]
-      def wsman_version
-        @logger.debug("querying WSMan version")
-        version = ''
-        @communicator.execute(PS_GET_WSMAN_VER, { shell: :powershell }) do |type, line|
-          version = version + "#{line}" if type == :stdout && !line.nil?
-        end
-        @logger.debug("wsman version: #{version}")
-        Integer(version)
-      end
-
-      # Returns an array of all NICs on the guest. Each array entry is a
-      # Hash of the NICs properties. This method should only be used on
-      # guests that have WinRS version 2.
-      #
-      # @return [Array]
-      def network_adapters_v2_winrm
-        @logger.debug("querying network adapters")
-
-        # Get all NICs that have a MAC address
-        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa394216(v=vs.85).aspx
-        adapters = @communicator.execute(WQL_NET_ADAPTERS_V2, { shell: :wql } )[:win32_network_adapter]
-        @logger.debug("#{adapters.inspect}")
-        return adapters
-      end
-
-      # Returns an array of all NICs on the guest. Each array entry is a
-      # Hash of the NICs properties. This method should only be used on
-      # guests that have WinRS version 3.
-      #
-      # This method is a workaround until the WinRM gem supports WinRS version 3.
-      #
-      # @return [Array]
-      def network_adapters_v3_winrm
-        command = File.read(File.expand_path("../scripts/winrs_v3_get_adapters.ps1", __FILE__))
-        output = ""
-        @communicator.execute(command, { shell: :powershell }) do |type, line|
-          output = output + "#{line}" if type == :stdout && !line.nil?
-        end
-
-        adapters = []
-        JSON.parse(output).each do |nic|
-          adapters << nic.inject({}){ |memo,(k,v)| memo[k.to_sym] = v; memo }
-        end
-
-        @logger.debug("#{adapters.inspect}")
-        return adapters
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/plugin.rb

@@ -1,98 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module GuestWindows
-    autoload :Errors, File.expand_path("../errors", __FILE__)
-
-    class Plugin < Vagrant.plugin("2")
-      name "Windows guest."
-      description "Windows guest support."
-
-      config(:windows) do
-        require_relative "config"
-        Config
-      end
-
-      guest(:windows)  do
-        require_relative "guest"
-        init!
-        Guest
-      end
-
-      guest_capability(:windows, :change_host_name) do
-        require_relative "cap/change_host_name"
-        Cap::ChangeHostName
-      end
-
-      guest_capability(:windows, :configure_networks) do
-        require_relative "cap/configure_networks"
-        Cap::ConfigureNetworks
-      end
-
-      guest_capability(:windows, :halt) do
-        require_relative "cap/halt"
-        Cap::Halt
-      end
-
-      guest_capability(:windows, :mount_virtualbox_shared_folder) do
-        require_relative "cap/mount_shared_folder"
-        Cap::MountSharedFolder
-      end
-
-      guest_capability(:windows, :mount_vmware_shared_folder) do
-        require_relative "cap/mount_shared_folder"
-        Cap::MountSharedFolder
-      end
-
-      guest_capability(:windows, :mount_parallels_shared_folder) do
-        require_relative "cap/mount_shared_folder"
-        Cap::MountSharedFolder
-      end
-
-      guest_capability(:windows, :wait_for_reboot) do
-        require_relative "cap/reboot"
-        Cap::Reboot
-      end
-
-      guest_capability(:windows, :choose_addressable_ip_addr) do
-        require_relative "cap/choose_addressable_ip_addr"
-        Cap::ChooseAddressableIPAddr
-      end
-
-      guest_capability(:windows, :mount_smb_shared_folder) do
-        require_relative "cap/mount_shared_folder"
-        Cap::MountSharedFolder
-      end
-
-      guest_capability(:windows, :rsync_scrub_guestpath) do
-        require_relative "cap/rsync"
-        Cap::RSync
-      end
-
-      guest_capability(:windows, :rsync_pre) do
-        require_relative "cap/rsync"
-        Cap::RSync
-      end
-
-      guest_capability(:windows, :insert_public_key) do
-        require_relative "cap/public_key"
-        Cap::PublicKey
-      end
-
-      guest_capability(:windows, :remove_public_key) do
-        require_relative "cap/public_key"
-        Cap::PublicKey
-      end
-
-      protected
-
-      def self.init!
-        return if defined?(@_init)
-        I18n.load_path << File.expand_path(
-          "templates/locales/guest_windows.yml", Vagrant.source_root)
-        I18n.reload!
-        @_init = true
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/guests/windows/scripts/mount_volume.ps1.erb

@@ -1,48 +0,0 @@
-function Test-ReparsePoint([string]$path) {
-  $file = Get-Item $path -Force -ea 0
-  return [bool]($file.Attributes -band [IO.FileAttributes]::ReparsePoint)
-}
-
-$MountPoint = [System.IO.Path]::GetFullPath("<%= options[:mount_point] %>")
-$ShareName = "<%= options[:share_name] %>"
-$VmProviderUncPath = "<%= options[:vm_provider_unc_path] %>"
-
-# https://github.com/BIAINC/vagrant-windows/issues/4
-# Not sure why this works, but it does.
-
-& net use $ShareName 2>&1 | Out-Null
-
-Write-Debug "Attempting to mount $ShareName to $MountPoint"
-if( (Test-Path "$MountPoint") -and (Test-ReparsePoint "$MountPoint") )
-{
-  Write-Debug "Junction already exists, so I will delete it"
-  # Powershell refuses to delete junctions, oh well use cmd
-  cmd /c rd "$MountPoint"
-
-  if ( $LASTEXITCODE -ne 0 )
-  {
-    Write-Error "Failed to delete symbolic link at $MountPoint"
-    exit 1
-  }
-
-}
-elseif(Test-Path $MountPoint)
-{
-  Write-Error "Mount point already exists and is not a symbolic link"
-  exit 1
-}
-
-$BaseDirectory = [System.IO.Path]::GetDirectoryName($MountPoint)
-
-if (-not (Test-Path $BaseDirectory))
-{
-  Write-Debug "Creating parent directory for mount point $BaseDirectory"
-  New-Item $BaseDirectory -Type Directory -Force | Out-Null
-}
-
-cmd /c mklink /D "$MountPoint" "$VmProviderUncPath" | out-null
-
-if ( $LASTEXITCODE -ne 0 )
-{
-  exit 1
-}