tamtam-vagrant-reload 1.1.2 → 1.2.1

data/vendor/cache/vagrant-2092df529ae7/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, "\\\\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/cache/vagrant-2092df529ae7/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("New-Item -Path '#{remote_ssh_dir}' -ItemType directory -Force", shell: "powershell")
+          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("Write-Output $env:TEMP\nWrite-Output $env:USERPROFILE", shell: "powershell") 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/cache/vagrant-2092df529ae7/plugins/guests/windows/cap/reboot.rb

@@ -0,0 +1,60 @@
+require "log4r"
+
+module VagrantPlugins
+  module GuestWindows
+    module Cap
+      class Reboot
+        DEFAULT_MAX_REBOOT_RETRY_DURATION = 120
+        WAIT_SLEEP_TIME = 5
+
+        def self.reboot(machine)
+          @logger = Log4r::Logger.new("vagrant::windows::reboot")
+          reboot_script = "shutdown /r /t 5 /f /d p:4:1 /c \"Vagrant Reboot Computer\""
+
+          comm = machine.communicate
+
+          script  = File.expand_path("../../scripts/reboot_detect.ps1", __FILE__)
+          script  = File.read(script)
+          if comm.test(script, error_check: false, shell: :powershell)
+            @logger.debug("Issuing reboot command for guest")
+            comm.execute(reboot_script, shell: :powershell)
+          else
+            @logger.debug("A reboot is already in progress")
+          end
+
+          machine.ui.info(I18n.t("vagrant.guests.capabilities.rebooting"))
+
+          @logger.debug("Waiting for machine to finish rebooting")
+
+          wait_remaining = ENV.fetch("VAGRANT_MAX_REBOOT_RETRY_DURATION",
+            DEFAULT_MAX_REBOOT_RETRY_DURATION).to_i
+          wait_remaining = DEFAULT_MAX_REBOOT_RETRY_DURATION if wait_remaining < 1
+
+          begin
+            wait_for_reboot(machine)
+          rescue => err
+            raise if wait_remaining < 0
+            @logger.debug("Exception caught while waiting for reboot: #{err}")
+            @logger.warn("Machine not ready, cannot start reboot yet. Trying again")
+            sleep(WAIT_SLEEP_TIME)
+            wait_remaining -= WAIT_SLEEP_TIME
+            retry
+          end
+        end
+
+        def self.wait_for_reboot(machine)
+          script  = File.expand_path("../../scripts/reboot_detect.ps1", __FILE__)
+          script  = File.read(script)
+
+          while machine.guest.ready? && machine.communicate.execute(script, error_check: false, shell: :powershell) != 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, shell: :powershell)
+        end
+      end
+    end
+  end
+end

data/vendor/cache/vagrant-2092df529ae7/plugins/guests/windows/cap/rsync.rb

@@ -0,0 +1,26 @@
+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
+            # NB: Per #11878, the `mkdir` command on Windows is different than used on Unix.
+            # This formulation matches the form used in the WinRM communicator plugin.
+            # This will ignore any -p switches, which are redundant in PowerShell,
+            # and ambiguous in PowerShell 4+
+            comm.execute("mkdir \"#{opts[:guestpath]}\" -force")
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/cache/vagrant-2092df529ae7/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/cache/vagrant-2092df529ae7/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/cache/vagrant-2092df529ae7/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/cache/vagrant-2092df529ae7/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/cache/vagrant-2092df529ae7/plugins/guests/windows/plugin.rb

@@ -0,0 +1,113 @@
+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, :create_tmp_path) do
+        require_relative "cap/file_system"
+        Cap::FileSystem
+      end
+
+      guest_capability(:windows, :decompress_zip) do
+        require_relative "cap/file_system"
+        Cap::FileSystem
+      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, :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/cache/vagrant-2092df529ae7/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.exe /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.exe /c mklink /D "$MountPoint" "$VmProviderUncPath" | out-null
+
+if ( $LASTEXITCODE -ne 0 )
+{
+  exit 1
+}

data/vendor/cache/vagrant-2092df529ae7/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/cache/vagrant-2092df529ae7/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)}

data/vendor/cache/vagrant-2092df529ae7/plugins/guests/windows/scripts/winrs_v3_get_adapters.ps1

@@ -0,0 +1,11 @@
+$adapters = get-ciminstance win32_networkadapter -filter "macaddress is not null"
+$processed = @()
+foreach ($adapter in $adapters) {
+  $Processed += new-object PSObject -Property @{
+    mac_address = $adapter.macaddress
+    net_connection_id = $adapter.netconnectionid
+    interface_index = $adapter.interfaceindex
+    index = $adapter.index
+  }
+}
+convertto-json -inputobject $processed

data/vendor/cache/vagrant-2092df529ae7/plugins/hosts/alt/cap/nfs.rb

@@ -0,0 +1,43 @@
+require "vagrant/util/subprocess"
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module HostALT
+    module Cap
+      class NFS
+        def self.nfs_check_command(env)
+          if systemd?
+            return "systemctl status --no-pager nfs-server.service"
+          else
+            return "/etc/init.d/nfs status"
+          end
+        end
+
+        def self.nfs_start_command(env)
+          if systemd?
+            return "systemctl start rpcbind nfs-server.service"
+          else
+            return "/etc/init.d/nfs restart"
+          end
+        end
+
+        def self.nfs_installed(environment)
+          if systemd?
+            system("systemctl --no-pager --no-legend --plain list-unit-files --all --type=service | grep --fixed-strings --quiet nfs-server.service")
+          else
+            system("rpm -q nfs-server --quiet 2>&1")
+          end
+        end
+
+        protected
+
+        # This tests to see if systemd is used on the system. This is used
+        # in newer versions of ALT, and requires a change in behavior.
+        def self.systemd?
+          result = Vagrant::Util::Subprocess.execute("ps", "-o", "comm=", "1")
+          return result.stdout.chomp == "systemd"
+        end
+      end
+    end
+  end
+end