vagrant-aws-detiber 0.7.2.pre.2

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

@@ -0,0 +1,80 @@
+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-419afb4dcffe/plugins/guests/windows/cap/halt.rb

@@ -0,0 +1,16 @@
+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-419afb4dcffe/plugins/guests/windows/cap/mount_shared_folder.rb

@@ -0,0 +1,57 @@
+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, "\\\\vboxsrv\\")
+        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-419afb4dcffe/plugins/guests/windows/cap/public_key.rb

@@ -0,0 +1,84 @@
+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-419afb4dcffe/plugins/guests/windows/cap/reboot.rb

@@ -0,0 +1,23 @@
+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-419afb4dcffe/plugins/guests/windows/cap/rsync.rb

@@ -0,0 +1,22 @@
+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-419afb4dcffe/plugins/guests/windows/config.rb

@@ -0,0 +1,23 @@
+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-419afb4dcffe/plugins/guests/windows/errors.rb

@@ -0,0 +1,22 @@
+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-419afb4dcffe/plugins/guests/windows/guest.rb

@@ -0,0 +1,10 @@
+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-419afb4dcffe/plugins/guests/windows/guest_network.rb

@@ -0,0 +1,125 @@
+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-419afb4dcffe/plugins/guests/windows/plugin.rb

@@ -0,0 +1,98 @@
+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-419afb4dcffe/plugins/guests/windows/scripts/mount_volume.ps1.erb

@@ -0,0 +1,48 @@
+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
+}

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/guests/windows/scripts/reboot_detect.ps1

@@ -0,0 +1,47 @@
+# Function to check whether machine is currently shutting down
+function ShuttingDown {
+    [string]$sourceCode = @"
+using System;
+using System.Runtime.InteropServices;
+
+namespace Vagrant {
+    public static class RemoteManager {
+        private const int SM_SHUTTINGDOWN = 0x2000;
+
+        [DllImport("User32.dll", CharSet = CharSet.Unicode)]
+        private static extern int GetSystemMetrics(int Index);
+
+        public static bool Shutdown() {
+            return (0 != GetSystemMetrics(SM_SHUTTINGDOWN));
+        }
+    }
+}
+"@
+    $type = Add-Type -TypeDefinition $sourceCode -PassThru
+    return $type::Shutdown()
+}
+
+if (ShuttingDown) {
+  exit 1
+} else {
+  # See if a reboot is scheduled in the future by trying to schedule a reboot
+  . shutdown.exe -f -r -t 60
+
+  if ($LASTEXITCODE -eq 1190) {
+    # reboot is already pending
+    exit 2
+  }
+
+  if ($LASTEXITCODE -eq 1115) {
+    # A system shutdown is in progress
+    exit 2
+  }
+
+  # Remove the pending reboot we just created above
+  if ($LASTEXITCODE -eq 0) {
+    . shutdown.exe -a
+  }
+}
+
+# no reboot in progress or scheduled
+exit 0

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/guests/windows/scripts/set_work_network.ps1

@@ -0,0 +1,6 @@
+# Get network connections
+$networkListManager = [Activator]::CreateInstance([Type]::GetTypeFromCLSID([Guid]"{DCB00C01-570F-4A9B-8D69-199FDBA5723B}"))
+$connections = $networkListManager.GetNetworkConnections()
+
+# Set network location to Private for all networks
+$connections | % {$_.GetNetwork().SetCategory(1)}