<#
.SYNOPSIS
Lädt zentrale Veeam Konfiguration aus JSON.
#>
param(
[string]$Path = (Join-Path ( Split-Path $PSScriptRoot -Parent )"Config\VeeamConfig.json")
)
if(!(Test-Path $Path))
{
throw `
"Konfigurationsdatei nicht gefunden: $Path"
}
$Content =
Get-Content `
-Path $Path `
-Raw
$Configuration =
$Content |
ConvertFrom-Json
return $Configuration
}
496 lines
26 KiB
PowerShell
496 lines
26 KiB
PowerShell
#Requires -Version 5.1
|
|
# Skriptversion: 1.0.1
|
|
# Versionsstand: 2026-10-15
|
|
<#
|
|
Korrigierte Kopie auf Basis des Originalskripts, mit denselben acht Optionen.
|
|
Windows-Verwaltungsrechner erforderlich. Die CMD-/SH-Dateien werden separat geliefert.
|
|
-LibraryOnly laedt nur Funktionen fuer isolierte Tests; fuehrt keine Aktionen aus.
|
|
#>
|
|
[CmdletBinding()]
|
|
param([switch]$LibraryOnly)
|
|
|
|
function Initialize-Configuration {
|
|
# Ablage auf dem ausfuehrenden Windows-Verwaltungsrechner:
|
|
# C:\SCAN\SCRIPT\NDTrack-Geprueft.ps1
|
|
$script:ScriptFolder = 'C:\SCAN\SCRIPT'
|
|
$script:SourcePath = 'C:\SCAN\NDTRACK'
|
|
$script:LinuxSourcePath = 'C:\SCAN\NDTRACK'
|
|
$script:DestinationPath = '' # Leer = Systemlaufwerk automatisch per WMI/DCOM ermitteln
|
|
$script:ServerDestinationPaths = @{} # Optional: @{ 'sql01.firma.example' = 'D:\ndtrack' }
|
|
$script:TaskName = 'NDTRACK'
|
|
$script:WindowsLauncher = 'RunNdTrackWindows_Local.cmd'
|
|
$script:LinuxLauncher = 'RunNdTrackLinuxUnix_Local.sh'
|
|
$script:Ergebnisordner = 'C:\SCAN\RESULTS'
|
|
$script:LogFolder = 'C:\SCAN\SCRIPT\Logs'
|
|
$script:TargetDomain = '' # Leer = DNS-Domaene des angemeldeten Benutzers
|
|
$script:DomainController = '' # Optional: FQDN eines DCs der Zieldomaene
|
|
$script:TestServers = @() # Zum Test z.B. @('GARRDSV003'); leer = AD/RDS
|
|
$script:RDSConnectionBroker = '' # Leer: wird bei Option 8 abgefragt
|
|
# Option 8 verwendet einen VOLLSTAENDIGEN, auf den RDS-Servern erreichbaren CMD-Pfad.
|
|
# Bei UNC-Pfaden muss der Remote-Ausfuehrungskontext Zugriff auf die Freigabe haben.
|
|
$script:RDSLauncherPath = '' # Kein Freigabepfad wird geraten.
|
|
}
|
|
|
|
function ShowMenu {
|
|
Write-Host @'
|
|
NDTRACK - Version 1.0.1 (Stand: 2026-10-15)
|
|
|
|
1: Windows - NDTrack-Dateien auf Server kopieren
|
|
2: Windows - Task NDTRACK erstellen und sofort starten
|
|
3: Windows - Scan-Dateien von Servern holen
|
|
4: Linux - NDTrack-Dateien auf Server kopieren
|
|
5: Linux - Scan per SSH starten
|
|
6: Linux - Scan-Dateien von Servern holen
|
|
7: Windows - aufraeumen (Task und NDTrack entfernen)
|
|
8: Linux - aufraeumen (NDTrack entfernen)
|
|
0: Beenden
|
|
'@
|
|
Read-Host 'Auswahl (0-8)'
|
|
}
|
|
|
|
function Assert-ServerName {
|
|
param([string]$Name)
|
|
if ($Name -notmatch '^[A-Za-z0-9][A-Za-z0-9.-]*$') {
|
|
throw "Ungueltiger Servername: $Name (DNS-Name oder IPv4 verwenden)."
|
|
}
|
|
}
|
|
function Get-DirectoryEndpoint {
|
|
# Keine kundenspezifischen Domain-DNs oder Servernamen.
|
|
if ($script:DomainController) {
|
|
Assert-ServerName $script:DomainController
|
|
return $script:DomainController
|
|
}
|
|
if ($script:TargetDomain) {
|
|
Assert-ServerName $script:TargetDomain
|
|
return $script:TargetDomain
|
|
}
|
|
if ($env:USERDNSDOMAIN) {
|
|
Assert-ServerName $env:USERDNSDOMAIN
|
|
return $env:USERDNSDOMAIN
|
|
}
|
|
throw 'Keine Benutzerdomaene ermittelbar. TargetDomain oder DomainController konfigurieren oder TestServers mit expliziten Zielservern fuellen.'
|
|
}
|
|
function GetADServer {
|
|
if ($script:TestServers.Count) {
|
|
foreach ($server in $script:TestServers) { Assert-ServerName $server }
|
|
return $script:TestServers | Sort-Object -Unique
|
|
}
|
|
$endpoint = Get-DirectoryEndpoint
|
|
$root = $null; $entry = $null; $searcher = $null; $results = $null
|
|
try {
|
|
$root = New-Object System.DirectoryServices.DirectoryEntry("LDAP://$endpoint/RootDSE")
|
|
$namingContext = [string]$root.Properties['defaultNamingContext'].Value
|
|
$dc = [string]$root.Properties['dnsHostName'].Value
|
|
if (-not $namingContext -or -not $dc) { throw 'RootDSE liefert keine AD-Domaene bzw. keinen DC.' }
|
|
Assert-ServerName $dc
|
|
# Optionalen DC auf Zugehoerigkeit zur expliziten Zieldomaene pruefen.
|
|
if ($script:TargetDomain) {
|
|
Assert-ServerName $script:TargetDomain
|
|
$expected = ($script:TargetDomain.TrimEnd('.').Split('.') | ForEach-Object { 'DC=' + $_ }) -join ','
|
|
if ($namingContext -ine $expected) { throw "DC gehoert zu $namingContext, erwartet wurde $expected." }
|
|
}
|
|
Write-Host "AD-AUSWAHL: $namingContext ueber $dc (aktuelles Windows-Konto)."
|
|
$entry = New-Object System.DirectoryServices.DirectoryEntry("LDAP://$dc/$namingContext")
|
|
$searcher = New-Object System.DirectoryServices.DirectorySearcher($entry)
|
|
$searcher.Filter = '(&(objectCategory=computer)(operatingSystem=*Server*)(!(userAccountControl:1.2.840.113556.1.4.803:=2)))'
|
|
$searcher.PageSize = 1000
|
|
[void]$searcher.PropertiesToLoad.Add('dnshostname')
|
|
[void]$searcher.PropertiesToLoad.Add('name')
|
|
$results = $searcher.FindAll()
|
|
$servers = @($results | ForEach-Object {
|
|
if ($_.Properties['dnshostname'].Count) {
|
|
$name = [string]$_.Properties['dnshostname'][0]
|
|
Assert-ServerName $name
|
|
$name
|
|
} else {
|
|
Write-Warning "AD-Computer $($_.Properties['name'][0]) ohne DNS-Hostnamen wird uebersprungen."
|
|
}
|
|
} | Sort-Object -Unique)
|
|
if (-not $servers.Count) { throw 'Keine aktivierten Windows-Server mit DNS-Hostnamen gefunden.' }
|
|
$servers
|
|
}
|
|
catch { throw "AD-Abfrage fuer '$endpoint' fehlgeschlagen: $($_.Exception.Message)" }
|
|
finally {
|
|
if ($null -ne $results) { $results.Dispose() }
|
|
if ($null -ne $searcher) { $searcher.Dispose() }
|
|
if ($null -ne $entry) { $entry.Dispose() }
|
|
if ($null -ne $root) { $root.Dispose() }
|
|
}
|
|
}
|
|
function GetRDSServer {
|
|
if ($script:TestServers.Count) { return $script:TestServers }
|
|
Import-Module RemoteDesktop -ErrorAction Stop
|
|
if (-not $script:RDSConnectionBroker) { $script:RDSConnectionBroker = Read-Host 'RDS Connection Broker (FQDN)' }
|
|
Assert-ServerName $script:RDSConnectionBroker
|
|
Get-RDServer -ConnectionBroker $script:RDSConnectionBroker -Role 'RDS-RD-SERVER' -ErrorAction Stop |
|
|
Select-Object -ExpandProperty Server -Unique
|
|
}
|
|
function GetLinuxServer {
|
|
$path = Read-Host 'Vollstaendiger Pfad zur Linux-Serverliste'
|
|
if (-not (Test-Path -LiteralPath $path -PathType Leaf)) { throw "Serverliste nicht gefunden: $path" }
|
|
$names = @(Get-Content -LiteralPath $path -ErrorAction Stop | ForEach-Object { $_.Trim() } |
|
|
Where-Object { $_ -and -not $_.StartsWith('#') } | Sort-Object -Unique)
|
|
foreach ($name in $names) { Assert-ServerName $name }
|
|
$names
|
|
}
|
|
function Resolve-WindowsFolder {
|
|
param([string]$Server)
|
|
Assert-ServerName $Server
|
|
$folder = $script:DestinationPath
|
|
$overrides = Get-Variable -Name ServerDestinationPaths -Scope Script -ErrorAction SilentlyContinue
|
|
if ($overrides -and $overrides.Value.ContainsKey($Server)) { $folder = $overrides.Value[$Server] }
|
|
if (-not $folder) {
|
|
$cimSession = $null
|
|
try {
|
|
$options = New-CimSessionOption -Protocol Dcom -ErrorAction Stop
|
|
$cimSession = New-CimSession -ComputerName $Server -SessionOption $options -ErrorAction Stop
|
|
$os = Get-CimInstance -CimSession $cimSession -ClassName Win32_OperatingSystem -Property SystemDrive -ErrorAction Stop
|
|
$drive = [string]$os.SystemDrive
|
|
if ($drive -notmatch '^[A-Za-z]:$') { throw 'Kein gueltiges Systemlaufwerk vom Zielserver erhalten.' }
|
|
$folder = $drive + '\ndtrack'
|
|
} catch {
|
|
throw "Systemlaufwerk von '$Server' konnte per WMI/DCOM nicht ermittelt werden: $($_.Exception.Message)"
|
|
} finally {
|
|
if ($null -ne $cimSession) { Remove-CimSession -CimSession $cimSession -ErrorAction SilentlyContinue }
|
|
}
|
|
}
|
|
if ($folder -notmatch '^[A-Za-z]:\\[^"\r\n]+$' -or $folder -match '(?:^|\\)\.\.?(?:\\|$)') { throw 'Ungueltiger lokaler NDTrack-Zielpfad.' }
|
|
$folder.TrimEnd('\')
|
|
}
|
|
function Get-WindowsSharePath {
|
|
param([string]$Server)
|
|
$folder = Resolve-WindowsFolder $Server
|
|
'\\{0}\{1}$\{2}' -f $Server,$folder.Substring(0,1),$folder.Substring(3)
|
|
}
|
|
function CheckDirectory {
|
|
$paths = @($script:ScriptFolder,$script:SourcePath,$script:LinuxSourcePath,
|
|
$script:Ergebnisordner,$script:LogFolder) | Select-Object -Unique
|
|
foreach ($path in $paths) {
|
|
if (Test-Path -LiteralPath $path -ErrorAction Stop) {
|
|
if (-not (Test-Path -LiteralPath $path -PathType Container -ErrorAction Stop)) {
|
|
throw "Pfad ist eine Datei statt eines Ordners: $path"
|
|
}
|
|
Write-Host "ORDNER VORHANDEN: $path"
|
|
} else {
|
|
New-Item -Path $path -ItemType Directory -Force -ErrorAction Stop | Out-Null
|
|
Write-Host "ORDNER ANGELEGT: $path"
|
|
}
|
|
}
|
|
}
|
|
function Test-SourceFiles {
|
|
param([string]$Path,[string]$Launcher)
|
|
if (-not (Test-Path -LiteralPath $Path -PathType Container -ErrorAction Stop)) {
|
|
throw "Quellordner fehlt: $Path"
|
|
}
|
|
$files = @(Get-ChildItem -LiteralPath $Path -File -Recurse -Force -ErrorAction Stop)
|
|
if ($files.Count -eq 0) {
|
|
throw "Keine Dateien in $Path gefunden. Bitte das vollstaendige NDTrack-Paket dort ablegen und das Skript erneut starten. Leere Unterordner reichen nicht aus."
|
|
}
|
|
if ($Launcher) {
|
|
$launcherPath = Join-Path $Path $Launcher
|
|
if (-not (Test-Path -LiteralPath $launcherPath -PathType Leaf -ErrorAction Stop)) {
|
|
throw "Benoetigte Startdatei fehlt: $launcherPath"
|
|
}
|
|
if ((Get-Item -LiteralPath $launcherPath -ErrorAction Stop).Length -eq 0) {
|
|
throw "Startdatei ist leer: $launcherPath"
|
|
}
|
|
}
|
|
Write-Host "QUELLE GEPRUEFT: $Path - $($files.Count) Datei(en) vorhanden."
|
|
}
|
|
function CopyFile {
|
|
param([string[]]$Servers)
|
|
Test-SourceFiles -Path $script:SourcePath -Launcher $script:WindowsLauncher
|
|
foreach ($server in $Servers) {
|
|
try {
|
|
$folder = Resolve-WindowsFolder $server
|
|
$remote = '\\{0}\{1}$\{2}' -f $server,$folder.Substring(0,1),$folder.Substring(3)
|
|
$share = '\\{0}\{1}$' -f $server,$folder.Substring(0,1)
|
|
if (-not (Test-Path -LiteralPath $share -PathType Container -ErrorAction Stop)) {
|
|
throw "Freigabe nicht erreichbar: $share. Laufwerk, Freigabe und Berechtigungen pruefen."
|
|
}
|
|
if (Test-Path -LiteralPath ($remote + '\.ndtrack-running') -ErrorAction Stop) {
|
|
throw 'Scan-Sperre vorhanden; laufenden Scan bzw. verwaiste Sperre pruefen.'
|
|
}
|
|
New-Item -Path $remote -ItemType Directory -Force -ErrorAction Stop | Out-Null
|
|
Get-ChildItem -LiteralPath $script:SourcePath -Force -ErrorAction Stop |
|
|
Where-Object { $_.Name -notin @('inventory','Result','Ergebnisse','.ndtrack-running') } |
|
|
Copy-Item -Destination $remote -Recurse -Force -ErrorAction Stop
|
|
Write-Host "KOPIERT: $server -> $remote"
|
|
$server
|
|
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
|
|
}
|
|
}
|
|
function Assert-TaskNotRunning {
|
|
param([string]$Server,[string]$Name)
|
|
$service=$null; $root=$null; $tasks=$null
|
|
try {
|
|
$service = New-Object -ComObject 'Schedule.Service' -ErrorAction Stop
|
|
$service.Connect($Server)
|
|
$root = $service.GetFolder('\')
|
|
$tasks = $root.GetTasks(1)
|
|
foreach ($task in $tasks) {
|
|
try {
|
|
if ($task.Name -ieq $Name -and $task.State -in @(2,4)) { throw 'NDTRACK-Task ist bereits aktiv.' }
|
|
} finally { [void][Runtime.InteropServices.Marshal]::ReleaseComObject($task) }
|
|
}
|
|
} finally {
|
|
foreach ($item in @($tasks,$root,$service)) {
|
|
if ($null -ne $item) { [void][Runtime.InteropServices.Marshal]::ReleaseComObject($item) }
|
|
}
|
|
}
|
|
}
|
|
function CreateScheduledTask {
|
|
param([string[]]$Servers,[pscredential]$Credential)
|
|
if ($null -eq $Credential) { throw 'Kein Task-Konto angegeben.' }
|
|
foreach ($server in $Servers) {
|
|
$xmlFile = $null
|
|
$stage = 'Zielpfad ermitteln'
|
|
try {
|
|
$folder = Resolve-WindowsFolder $server
|
|
$share = '\\{0}\{1}$\{2}' -f $server,$folder.Substring(0,1),$folder.Substring(3)
|
|
$stage = 'CMD und Scan-Sperre ueber SMB pruefen'
|
|
if (-not (Test-Path -LiteralPath ($share + '\' + $script:WindowsLauncher) -PathType Leaf -ErrorAction Stop)) { throw 'CMD fehlt; zuerst Option 1 ausfuehren.' }
|
|
if (Test-Path -LiteralPath ($share + '\.ndtrack-running') -ErrorAction Stop) { throw 'Scan-Sperre vorhanden.' }
|
|
$stage = 'Task-Zustand ueber Task-Scheduler-RPC pruefen'
|
|
Assert-TaskNotRunning -Server $server -Name $script:TaskName
|
|
# XML erhaelt das Arbeitsverzeichnis und verhindert einen zweiten zeitgesteuerten Start.
|
|
$escapedFolder = [Security.SecurityElement]::Escape($folder)
|
|
$escapedUser = [Security.SecurityElement]::Escape($Credential.UserName)
|
|
$arguments = [Security.SecurityElement]::Escape(('/d /s /c ""{0}\{1}""' -f $folder,$script:WindowsLauncher))
|
|
$xml = @"
|
|
<?xml version="1.0" encoding="UTF-16"?>
|
|
<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
|
|
<Triggers />
|
|
<Principals><Principal id="Author"><UserId>$escapedUser</UserId><LogonType>Password</LogonType><RunLevel>HighestAvailable</RunLevel></Principal></Principals>
|
|
<Settings><MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy><DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries><StopIfGoingOnBatteries>false</StopIfGoingOnBatteries><AllowStartOnDemand>true</AllowStartOnDemand><Enabled>true</Enabled></Settings>
|
|
<Actions Context="Author"><Exec><Command>%SystemRoot%\System32\cmd.exe</Command><Arguments>$arguments</Arguments><WorkingDirectory>$escapedFolder</WorkingDirectory></Exec></Actions>
|
|
</Task>
|
|
"@
|
|
$xmlFile = [IO.Path]::GetTempFileName()
|
|
[IO.File]::WriteAllText($xmlFile,$xml,[Text.Encoding]::Unicode)
|
|
$stage = 'Task mit schtasks.exe registrieren'
|
|
# Aktuelles Konto verwaltet den Remote-Task; Credential ist nur das Ausfuehrungskonto.
|
|
# Passwort wie beim Original nur an /RP uebergeben, nie in XML oder Log schreiben.
|
|
Invoke-NativeChecked 'schtasks.exe' @('/Create','/S',$server,'/TN',$script:TaskName,'/XML',$xmlFile,'/RU',$Credential.UserName,'/RP',$Credential.GetNetworkCredential().Password,'/F')
|
|
$stage = 'Task mit schtasks.exe starten'
|
|
Invoke-NativeChecked 'schtasks.exe' @('/Run','/S',$server,'/TN',$script:TaskName)
|
|
Write-Host "START ANGEFORDERT: $server - Task NDTRACK erstellt und Start ausgeloest; Scan-Abschluss noch nicht bestaetigt."
|
|
} catch { Write-Warning "${server}: $stage fehlgeschlagen: $($_.Exception.Message)" }
|
|
finally { if ($xmlFile -and (Test-Path -LiteralPath $xmlFile)) { Remove-Item -LiteralPath $xmlFile -Force -ErrorAction SilentlyContinue } }
|
|
}
|
|
}
|
|
function Invoke-WindowsScan {
|
|
param([string[]]$Servers,[string]$LauncherPath)
|
|
foreach ($server in $Servers) {
|
|
try {
|
|
Assert-ServerName $server
|
|
Invoke-Command -ComputerName $server -ErrorAction Stop -ScriptBlock {
|
|
param($path)
|
|
$ErrorActionPreference = 'Stop'
|
|
if (-not (Test-Path -LiteralPath $path -PathType Leaf)) { throw "CMD nicht erreichbar: $path" }
|
|
$folder = Split-Path -Parent $path
|
|
$lock = Join-Path $folder '.ndtrack-running'
|
|
New-Item -Path $lock -ItemType Directory -ErrorAction Stop | Out-Null
|
|
try {
|
|
$process = Start-Process -FilePath "$env:SystemRoot\System32\cmd.exe" -ArgumentList ('/d /s /c ""{0}""' -f $path) -WorkingDirectory $folder -Wait -PassThru -NoNewWindow -ErrorAction Stop
|
|
if ($process.ExitCode -ne 0) { throw "CMD-Exitcode: $($process.ExitCode)" }
|
|
} finally { Remove-Item -LiteralPath $lock -Force -ErrorAction Stop }
|
|
} -ArgumentList $LauncherPath
|
|
Write-Host "BEENDET: $server - CMD-Exitcode 0."
|
|
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
|
|
}
|
|
}
|
|
function RunNDTRACKRemotely {
|
|
param([string[]]$Servers)
|
|
foreach ($server in $Servers) {
|
|
try {
|
|
$folder = Resolve-WindowsFolder $server
|
|
Invoke-WindowsScan @($server) ($folder + '\' + $script:WindowsLauncher)
|
|
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
|
|
}
|
|
}
|
|
function Scan_RDS_SINA {
|
|
param([string[]]$Servers)
|
|
if (-not $script:RDSLauncherPath) { $script:RDSLauncherPath = Read-Host 'Vollstaendiger CMD-Pfad auf den RDS-Servern (lokal oder UNC)' }
|
|
if ($script:RDSLauncherPath -notmatch '^(?:[A-Za-z]:\\|\\\\).+\.cmd$' -or $script:RDSLauncherPath.Contains('"')) { throw 'Gueltigen absoluten RDS-CMD-Pfad konfigurieren.' }
|
|
Invoke-WindowsScan $Servers $script:RDSLauncherPath
|
|
}
|
|
function GetInventoryFiles {
|
|
param([string[]]$Servers)
|
|
$batch = Join-Path $script:Ergebnisordner ('Windows-' + [guid]::NewGuid().ToString('N'))
|
|
foreach ($server in $Servers) {
|
|
$session = $null
|
|
try {
|
|
$remote = Resolve-WindowsFolder $server
|
|
$session = New-PSSession -ComputerName $server -ErrorAction Stop
|
|
Invoke-Command -Session $session -ErrorAction Stop -ScriptBlock {
|
|
param($folder,$name)
|
|
$ErrorActionPreference = 'Stop'
|
|
if (Test-Path -LiteralPath (Join-Path $folder '.ndtrack-running')) { throw 'Scan laeuft oder Sperre ist verwaist.' }
|
|
$task = Get-ScheduledTask | Where-Object { $_.TaskName -eq $name -and $_.TaskPath -eq '\' }
|
|
if ($task) {
|
|
$info = Get-ScheduledTaskInfo -TaskName $name -TaskPath '\'
|
|
if ($task.State -in @('Running','Queued') -or $info.LastTaskResult -ne 0 -or $info.NextRunTime -gt (Get-Date)) { throw 'Task noch ausstehend/aktiv oder letzter Lauf fehlerhaft.' }
|
|
}
|
|
$inventory = Join-Path $folder 'inventory'
|
|
$files = @(Get-ChildItem -LiteralPath $inventory -File -Recurse)
|
|
if (-not $files.Count) { throw 'Keine Inventardateien vorhanden.' }
|
|
} -ArgumentList $remote,$script:TaskName
|
|
$inventory = $remote + '\inventory'
|
|
|
|
$target = Join-Path $batch $server
|
|
New-Item -Path $target -ItemType Directory -Force -ErrorAction Stop | Out-Null
|
|
Copy-Item -Path "$inventory\*" -FromSession $session -Destination $target -Recurse -Force -ErrorAction Stop
|
|
Write-Host "EINGESAMMELT: $server -> $target (vorhandene Dateien, Alter nicht bewertet)."
|
|
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
|
|
finally { if ($null -ne $session) { Remove-PSSession -Session $session } }
|
|
}
|
|
}
|
|
function DeleteScheduledTask {
|
|
param([string[]]$Servers)
|
|
foreach ($server in $Servers) {
|
|
try {
|
|
Invoke-Command -ComputerName $server -ErrorAction Stop -ScriptBlock {
|
|
param($name)
|
|
$ErrorActionPreference = 'Stop'
|
|
$task = Get-ScheduledTask | Where-Object { $_.TaskName -eq $name -and $_.TaskPath -eq '\' }
|
|
if ($task) {
|
|
Disable-ScheduledTask -TaskName $name -TaskPath '\' | Out-Null
|
|
Stop-ScheduledTask -TaskName $name -TaskPath '\'
|
|
$deadline = (Get-Date).AddSeconds(30)
|
|
do {
|
|
$state = (Get-ScheduledTask -TaskName $name -TaskPath '\').State
|
|
if ($state -notin @('Running','Queued')) { break }
|
|
Start-Sleep -Milliseconds 500
|
|
} while ((Get-Date) -lt $deadline)
|
|
if ($state -in @('Running','Queued')) { throw 'Task konnte nicht gestoppt werden.' }
|
|
Unregister-ScheduledTask -TaskName $name -TaskPath '\' -Confirm:$false
|
|
}
|
|
} -ArgumentList $script:TaskName
|
|
$server
|
|
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
|
|
}
|
|
}
|
|
function DeleteFile {
|
|
param([string[]]$Servers)
|
|
foreach ($server in $Servers) {
|
|
try {
|
|
$folder = Resolve-WindowsFolder $server
|
|
Invoke-Command -ComputerName $server -ErrorAction Stop -ScriptBlock {
|
|
param($folder)
|
|
$ErrorActionPreference = 'Stop'
|
|
# Nur den dedizierten NDTrack-Ordner entfernen.
|
|
if ($folder.TrimEnd('\') -notmatch '^[A-Za-z]:\\.+$' -or $folder -match '(?:^|\\)\.\.?(?:\\|$)' -or (Split-Path $folder.TrimEnd('\') -Leaf) -ne 'ndtrack') { throw 'Loeschen nur fuer einen dedizierten ndtrack-Ordner erlaubt.' }
|
|
if (Test-Path -LiteralPath (Join-Path $folder '.ndtrack-running')) { throw 'Direkter Scan aktiv oder Sperre verwaist.' }
|
|
$processes = @(Get-CimInstance Win32_Process -Filter "Name = 'ndtrack.exe'")
|
|
foreach ($process in $processes) {
|
|
if (-not $process.ExecutablePath -or $process.ExecutablePath.StartsWith($folder.TrimEnd('\')+'\',[StringComparison]::OrdinalIgnoreCase)) { throw 'NDTrack-Prozess noch aktiv; keine Dateien geloescht.' }
|
|
}
|
|
if (Test-Path -LiteralPath $folder) { Remove-Item -LiteralPath $folder -Recurse -Force }
|
|
} -ArgumentList $folder
|
|
Write-Host "ENTFERNT: $server - NDTrack-Ordner."
|
|
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
|
|
}
|
|
}
|
|
# Native Programme: Exitcode immer direkt pruefen.
|
|
function Invoke-NativeChecked {
|
|
param([string]$Program,[string[]]$Arguments)
|
|
& $Program @Arguments | Out-Host
|
|
if ($LASTEXITCODE -ne 0) { throw "$Program fehlgeschlagen (Exitcode $LASTEXITCODE)." }
|
|
}
|
|
function Get-LinuxUser {
|
|
$userName = Read-Host 'Linux-SSH-Benutzer (z.B. scanuser; kein Windows-Domaenenformat)'
|
|
if ($userName -notmatch '^[a-zA-Z_][a-zA-Z0-9_.-]*[$]?$') { throw 'Ungueltiger Linux-Benutzername.' }
|
|
$userName
|
|
}
|
|
function Invoke-LinuxCommand {
|
|
param([string]$Server,[string]$User,[string]$Command)
|
|
Assert-ServerName $Server
|
|
Invoke-NativeChecked 'ssh' @('-o','ConnectTimeout=15','-l',$User,$Server,$Command)
|
|
}
|
|
function CopyFileLinux {
|
|
param([string[]]$Servers,[string]$User)
|
|
Test-SourceFiles -Path $script:LinuxSourcePath -Launcher $script:LinuxLauncher
|
|
foreach ($server in $Servers) {
|
|
try {
|
|
Invoke-LinuxCommand $server $User 'test ! -d "$HOME/ndtrack/.ndtrack-running" && mkdir -p "$HOME/ndtrack"'
|
|
$items = @(Get-ChildItem -LiteralPath $script:LinuxSourcePath -Force -ErrorAction Stop | Where-Object { $_.Name -notin @('inventory','.ndtrack-running') })
|
|
foreach ($item in $items) { Invoke-NativeChecked 'scp' @('-r','-o','ConnectTimeout=15',$item.FullName,"${User}@${server}:ndtrack/") }
|
|
Write-Host "KOPIERT: $server"
|
|
$server
|
|
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
|
|
}
|
|
}
|
|
function RunNDTRACKRemotelyLinux {
|
|
param([string[]]$Servers,[string]$User)
|
|
foreach ($server in $Servers) {
|
|
try {
|
|
# Interpreter aus der Shebang verwenden; Startdatei muss synchron laufen.
|
|
$command = 'cd "$HOME/ndtrack" && mkdir .ndtrack-running && { trap ''rmdir "$HOME/ndtrack/.ndtrack-running"'' EXIT; chmod u+x ./RunNdTrackLinuxUnix_Local.sh && ./RunNdTrackLinuxUnix_Local.sh; }'
|
|
Invoke-LinuxCommand $server $User $command
|
|
Write-Host "BEENDET: $server - SH-Exitcode 0."
|
|
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
|
|
}
|
|
}
|
|
function GetInventoryFilesLinux {
|
|
param([string[]]$Servers,[string]$User)
|
|
$batch = Join-Path $script:Ergebnisordner ('Linux-' + [guid]::NewGuid().ToString('N'))
|
|
foreach ($server in $Servers) {
|
|
try {
|
|
Invoke-LinuxCommand $server $User 'test ! -d "$HOME/ndtrack/.ndtrack-running" && test -d "$HOME/ndtrack/inventory" && test -n "$(find "$HOME/ndtrack/inventory" -type f -print -quit)"'
|
|
$target = Join-Path $batch $server
|
|
New-Item -Path $target -ItemType Directory -Force -ErrorAction Stop | Out-Null
|
|
Invoke-NativeChecked 'scp' @('-r','-o','ConnectTimeout=15',"${User}@${server}:ndtrack/inventory",$target)
|
|
Write-Host "EINGESAMMELT: $server -> $target (vorhandene Dateien, Alter nicht bewertet)."
|
|
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
|
|
}
|
|
}
|
|
function DeleteFileLinux {
|
|
param([string[]]$Servers,[string]$User)
|
|
foreach ($server in $Servers) {
|
|
try {
|
|
# Bei fehlendem pgrep ebenfalls abbrechen statt einen laufenden Scan zu riskieren.
|
|
$command = 'test -n "$HOME" && test "$HOME" != / && test ! -d "$HOME/ndtrack/.ndtrack-running" && command -v pgrep >/dev/null && { pgrep -x ndtrack >/dev/null; rc=$?; test "$rc" -eq 1; } && rm -rf -- "$HOME/ndtrack"'
|
|
Invoke-LinuxCommand $server $User $command
|
|
Write-Host "ENTFERNT: $server - NDTrack-Ordner."
|
|
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
|
|
}
|
|
}
|
|
function Invoke-MenuOption {
|
|
param([string]$Choice)
|
|
switch ($Choice) {
|
|
'1' { CopyFile @(GetADServer) | Out-Null }
|
|
'2' {
|
|
$credential = Get-Credential -Message 'Ausfuehrungskonto fuer Task NDTRACK'
|
|
if ($null -eq $credential) { throw 'Kontoabfrage abgebrochen.' }
|
|
CreateScheduledTask @(GetADServer) $credential
|
|
}
|
|
'3' { GetInventoryFiles @(GetADServer) }
|
|
'4' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; CopyFileLinux $servers $userName | Out-Null }
|
|
'5' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; RunNDTRACKRemotelyLinux $servers $userName }
|
|
'6' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; GetInventoryFilesLinux $servers $userName }
|
|
'7' { $servers = @(GetADServer); $cleared = @(DeleteScheduledTask $servers); if ($cleared.Count) { DeleteFile $cleared } }
|
|
'8' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; DeleteFileLinux $servers $userName }
|
|
'0' { return }
|
|
default { throw 'Bitte eine Option zwischen 0 und 8 waehlen.' }
|
|
}
|
|
}
|
|
if (-not $LibraryOnly) {
|
|
if ($env:OS -ne 'Windows_NT') { throw 'Auf einem Windows-Verwaltungsrechner ausfuehren; Mac nur zum Bearbeiten/Testen.' }
|
|
Initialize-Configuration
|
|
CheckDirectory
|
|
Test-SourceFiles -Path $script:SourcePath
|
|
do {
|
|
$choice = ShowMenu
|
|
if ($choice -eq '0') { break }
|
|
$transcriptStarted = $false
|
|
try {
|
|
$log = Join-Path $script:LogFolder ('NDTrack-{0}.log' -f (Get-Date -Format 'yyyyMMdd-HHmmss-fff'))
|
|
Start-Transcript -Path $log -ErrorAction Stop | Out-Null
|
|
$transcriptStarted = $true
|
|
Invoke-MenuOption $choice
|
|
} catch { Write-Warning $_.Exception.Message }
|
|
finally { if ($transcriptStarted) { Stop-Transcript | Out-Null } }
|
|
} while ($true)
|
|
}
|