422 lines
20 KiB
PL/PgSQL
422 lines
20 KiB
PL/PgSQL
-- Give existing and newly created customers the same editable starting revisions.
|
|
CREATE FUNCTION seed_standard_diagnostic_scripts(target_tenant uuid) RETURNS void
|
|
LANGUAGE plpgsql SET search_path = pg_catalog, public AS $seed$
|
|
DECLARE previous_tenant text := coalesce(current_setting('app.tenant_id', true), '');
|
|
BEGIN
|
|
PERFORM set_config('app.tenant_id', target_tenant::text, true);
|
|
INSERT INTO public.script_revisions(tenant_id, name, version, interpreter, execution_identity, created_by, script_utf8)
|
|
SELECT target_tenant, name, 1, interpreter, execution_identity, 'system:bootstrap', body
|
|
FROM (VALUES
|
|
('Linux · Agent und Updater prüfen', 'posix_sh', 'agent_service', $linux_agent$#!/bin/sh
|
|
set -eu
|
|
printf 'Ausführungskonto: %s\n' "$(id -un)"
|
|
version=$(python3 -I -c 'import json; print(json.load(open("/opt/rust-discovery-client/current/manifest.json"))["version"])' 2>/dev/null) ||
|
|
version='unbekannt (Release-Manifest nicht lesbar)'
|
|
printf 'Agent-Release auf dem Datenträger: %s\n' "$version"
|
|
systemctl show --no-pager -p Id -p LoadState -p ActiveState -p SubState rmm-discovery-agent.service
|
|
systemctl show --no-pager -p Id -p LoadState -p ActiveState -p LastTriggerUSec -p NextElapseUSecRealtime rmm-discovery-update.timer
|
|
systemctl list-timers --all --no-pager rmm-discovery-update.timer
|
|
systemctl show --no-pager -p Id -p LoadState -p Result rmm-discovery-update.service
|
|
$linux_agent$),
|
|
('Windows · Agent und Updater prüfen', 'powershell', 'agent_service', $windows_agent$$ErrorActionPreference = 'Stop'
|
|
Write-Output ('Ausfuehrungskonto: ' + [Security.Principal.WindowsIdentity]::GetCurrent().Name)
|
|
$agent = Get-CimInstance -ClassName Win32_Service -Filter "Name='RmmDiscoveryWindows'"
|
|
$updater = Get-CimInstance -ClassName Win32_Service -Filter "Name='RmmDiscoveryReleasePull'"
|
|
foreach ($entry in @(
|
|
@{ Name = 'RmmDiscoveryWindows'; Service = $agent }
|
|
@{ Name = 'RmmDiscoveryReleasePull'; Service = $updater }
|
|
)) {
|
|
$service = $entry.Service
|
|
if ($null -eq $service) {
|
|
Write-Output ($entry.Name + ': fehlt')
|
|
} else {
|
|
Write-Output ('{0}: {1}; Starttyp: {2}; Dienstkonto: {3}' -f $service.Name, $service.State, $service.StartMode, $service.StartName)
|
|
}
|
|
}
|
|
if ($agent.PathName -match '^"([^"]+)"') {
|
|
$manifest = Join-Path (Split-Path -Parent $Matches[1]) 'manifest.json'
|
|
try {
|
|
$release = Get-Content -LiteralPath $manifest -Raw | ConvertFrom-Json
|
|
if (-not $release.version) { throw 'Version fehlt.' }
|
|
Write-Output ('Agent-Release auf dem Datentraeger: ' + $release.version)
|
|
} catch {
|
|
Write-Output 'Agent-Release: unbekannt (Release-Manifest nicht lesbar)'
|
|
}
|
|
} else {
|
|
Write-Output 'Agent-Release: unbekannt (Dienstpfad fehlt oder hat ein anderes Format)'
|
|
}
|
|
$windows_agent$),
|
|
('Linux · Speicherengpässe prüfen', 'posix_sh', 'agent_service', $linux_storage$#!/bin/sh
|
|
set -eu
|
|
export LC_ALL=C
|
|
rows=$(df --local --block-size=1 --output=size,avail,pcent,itotal,iavail,ipcent,fstype,target)
|
|
printf 'Lokale Dateisysteme (Warnung ab 90 Prozent Block- oder Inode-Auslastung)\n'
|
|
printf '%s\n' "$rows" | awk '
|
|
NR > 1 && $1 > 0 && ($7 !~ /^(tmpfs|devtmpfs|ramfs|squashfs|iso9660)$/ || $8 == "/") {
|
|
blocks = $3 + 0
|
|
inodes = $6 + 0
|
|
score = blocks > inodes ? blocks : inodes
|
|
mount = $0
|
|
for (i = 1; i <= 7; i++) sub(/^[[:space:]]*[^[:space:]]+[[:space:]]+/, "", mount)
|
|
printf "%d\t%s\t%s\t%s/%s Byte frei (%s belegt)\tInodes frei: %s/%s (%s belegt)\n",
|
|
score, (score >= 90 ? "WARNUNG" : "OK"), mount, $2, $1, $3, $5, $4, $6
|
|
}
|
|
' | sort -t "$(printf '\t')" -k1,1nr | awk -F '\t' '
|
|
NR <= 40 { sub(/^[^\t]+\t/, ""); print }
|
|
END {
|
|
if (NR == 0) { print "Keine lokalen Dateisysteme gefunden"; exit 1 }
|
|
if (NR > 40) print "Weitere Dateisysteme: " NR - 40
|
|
}
|
|
'
|
|
$linux_storage$),
|
|
('Windows · Speicherengpässe prüfen', 'powershell', 'agent_service', $windows_storage$$ErrorActionPreference = 'Stop'
|
|
$volumes = @(Get-CimInstance -ClassName Win32_Volume -Filter 'DriveType=3' |
|
|
Where-Object { $_.Capacity -gt 0 -and $null -ne $_.FreeSpace } |
|
|
ForEach-Object {
|
|
[pscustomobject]@{
|
|
Volume = $_.Name
|
|
Capacity = $_.Capacity
|
|
Free = $_.FreeSpace
|
|
Used = 100.0 * ($_.Capacity - $_.FreeSpace) / $_.Capacity
|
|
}
|
|
} | Sort-Object Used -Descending)
|
|
if ($volumes.Count -eq 0) { throw 'Keine lokalen Volumes mit Kapazitaetswerten gefunden.' }
|
|
Write-Output 'Lokale Volumes (Warnung ab 90 Prozent Auslastung)'
|
|
foreach ($volume in ($volumes | Select-Object -First 40)) {
|
|
$status = if ($volume.Used -ge 90) { 'WARNUNG' } else { 'OK' }
|
|
Write-Output ('{0} {1} {2}/{3} Byte frei ({4:N1}% belegt)' -f $status, $volume.Volume, $volume.Free, $volume.Capacity, $volume.Used)
|
|
}
|
|
if ($volumes.Count -gt 40) { Write-Output ('Weitere Volumes: ' + ($volumes.Count - 40)) }
|
|
$windows_storage$),
|
|
('Linux · Discovery-Verbindung prüfen', 'posix_sh', 'agent_service', $linux_gateway$#!/bin/sh
|
|
exec python3 -I - <<'PYTHON'
|
|
import json
|
|
from pathlib import Path
|
|
import socket
|
|
import ssl
|
|
import sys
|
|
from urllib.parse import urlsplit
|
|
|
|
root = Path("/opt/rust-discovery-client")
|
|
try:
|
|
url = urlsplit(json.loads((root / "config.json").read_text())["gateway"])
|
|
host, port = url.hostname, url.port or 443
|
|
if url.scheme != "https" or not host or url.username is not None:
|
|
raise ValueError("invalid gateway origin")
|
|
context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
|
|
context.load_verify_locations(cafile=root / "gateway-ca.pem")
|
|
except (OSError, ValueError, KeyError, TypeError):
|
|
sys.exit("Gateway-Konfiguration oder CA-Datei fehlt oder ist nicht lesbar.")
|
|
|
|
print(f"Konfiguriertes Gateway: {host}:{port}", flush=True)
|
|
try:
|
|
family, kind, protocol, _, address = socket.getaddrinfo(host, port, type=socket.SOCK_STREAM)[0]
|
|
except OSError:
|
|
sys.exit("DNS: fehlgeschlagen.")
|
|
print(f"DNS: OK ({address[0]})", flush=True)
|
|
with socket.socket(family, kind, protocol) as client:
|
|
client.settimeout(8)
|
|
try:
|
|
client.connect(address)
|
|
except OSError:
|
|
sys.exit("TCP: fehlgeschlagen.")
|
|
print("TCP: OK", flush=True)
|
|
try:
|
|
with context.wrap_socket(client, server_hostname=host) as tls:
|
|
print(f"TLS: Servername und Zertifikatskette geprüft ({tls.version()})")
|
|
except ssl.SSLCertVerificationError as error:
|
|
sys.exit(f"TLS: Zertifikatsprüfung fehlgeschlagen ({error.verify_message}).")
|
|
except OSError:
|
|
sys.exit("TLS: Handshake fehlgeschlagen.")
|
|
PYTHON
|
|
$linux_gateway$),
|
|
('Windows · Discovery-Verbindung prüfen', 'powershell', 'agent_service', $windows_gateway$$ErrorActionPreference = 'Stop'
|
|
$data = Join-Path ([Environment]::GetFolderPath('CommonApplicationData')) 'RustDiscovery'
|
|
$config = Get-Content -LiteralPath (Join-Path $data 'config.json') -Raw | ConvertFrom-Json
|
|
$server = $config.server_name
|
|
if ($server -notmatch '^[a-zA-Z0-9][a-zA-Z0-9.-]{0,252}$' -or
|
|
$config.connect_address -notmatch '^(\[[0-9a-fA-F:]+\]|[0-9.]+):([0-9]{1,5})$') {
|
|
throw 'Ungueltiger Gatewayname oder TCP-Endpunkt in der Agentkonfiguration.'
|
|
}
|
|
$address = [Net.IPAddress]::Parse($Matches[1].Trim('[', ']'))
|
|
$port = [int]$Matches[2]
|
|
if ($port -notin (1..65535)) { throw 'Ungueltiger Gatewayport.' }
|
|
Write-Output ('Konfiguriertes Gateway: {0}:{1}; TCP-Ziel: {2}' -f $server, $port, $address)
|
|
$dnsOk = $true
|
|
try {
|
|
$addresses = @([Net.Dns]::GetHostAddresses($server))
|
|
if ($addresses.Count -eq 0) { throw 'Keine Adressen.' }
|
|
Write-Output ('DNS: OK ({0}); konfiguriertes TCP-Ziel im DNS: {1}' -f (($addresses | Select-Object -First 8) -join ', '), ($addresses -contains $address))
|
|
} catch {
|
|
$dnsOk = $false
|
|
Write-Output 'DNS: fehlgeschlagen.'
|
|
}
|
|
$anchors = [Security.Cryptography.X509Certificates.X509Certificate2Collection]::new()
|
|
$pem = Get-Content -LiteralPath $config.ca_file -Raw
|
|
foreach ($block in [regex]::Matches($pem, '-----BEGIN CERTIFICATE-----\s*(?<body>[A-Za-z0-9+/=\s]+)-----END CERTIFICATE-----')) {
|
|
[void]$anchors.Add([Security.Cryptography.X509Certificates.X509Certificate2]::new(
|
|
[Convert]::FromBase64String($block.Groups['body'].Value)))
|
|
}
|
|
if ($anchors.Count -eq 0) { throw 'Gateway-CA-Datei enthaelt kein Zertifikat.' }
|
|
|
|
$client = [Net.Sockets.TcpClient]::new($address.AddressFamily)
|
|
$tls = $null
|
|
try {
|
|
$connection = $client.ConnectAsync($address, $port)
|
|
if (-not $connection.Wait(8000)) { throw 'TCP-Zeitlimit' }
|
|
Write-Output 'TCP: OK'
|
|
} catch {
|
|
$client.Dispose()
|
|
throw 'TCP: fehlgeschlagen.'
|
|
}
|
|
try {
|
|
$client.ReceiveTimeout = 8000
|
|
$client.SendTimeout = 8000
|
|
$validate = [Net.Security.RemoteCertificateValidationCallback] {
|
|
param($sender, $certificate, $osChain, $errors)
|
|
# SslStream checks the name. The agent's configured CA anchors the chain.
|
|
if ($null -eq $certificate -or
|
|
($errors -band (-bnot [Net.Security.SslPolicyErrors]::RemoteCertificateChainErrors))) { return $false }
|
|
$chain = [Security.Cryptography.X509Certificates.X509Chain]::new()
|
|
$leaf = [Security.Cryptography.X509Certificates.X509Certificate2]::new($certificate)
|
|
try {
|
|
$policy = $chain.ChainPolicy
|
|
$policy.ExtraStore.AddRange($anchors)
|
|
foreach ($element in $osChain.ChainElements) { [void]$policy.ExtraStore.Add($element.Certificate) }
|
|
$policy.VerificationFlags = [Security.Cryptography.X509Certificates.X509VerificationFlags]::AllowUnknownCertificateAuthority
|
|
$policy.RevocationMode = [Security.Cryptography.X509Certificates.X509RevocationMode]::NoCheck
|
|
$policy.UrlRetrievalTimeout = [TimeSpan]::FromSeconds(2)
|
|
[void]$policy.ApplicationPolicy.Add([Security.Cryptography.Oid]::new('1.3.6.1.5.5.7.3.1'))
|
|
if (-not $chain.Build($leaf)) { return $false }
|
|
$root = $chain.ChainElements[$chain.ChainElements.Count - 1].Certificate
|
|
foreach ($anchor in $anchors) {
|
|
if ($root.Equals($anchor)) { return $true }
|
|
}
|
|
return $false
|
|
} finally {
|
|
$leaf.Dispose()
|
|
$chain.Dispose()
|
|
}
|
|
}
|
|
$tls = [Net.Security.SslStream]::new($client.GetStream(), $false, $validate)
|
|
$tls.AuthenticateAsClient($server, [Security.Cryptography.X509Certificates.X509CertificateCollection]::new(),
|
|
[Security.Authentication.SslProtocols]::None, $false)
|
|
Write-Output ('TLS: Servername und Zertifikatskette geprueft (' + $tls.SslProtocol + ').')
|
|
} finally {
|
|
if ($null -ne $tls) { $tls.Dispose() }
|
|
$client.Dispose()
|
|
foreach ($anchor in $anchors) { $anchor.Dispose() }
|
|
}
|
|
if (-not $dnsOk) { exit 1 }
|
|
$windows_gateway$),
|
|
('Linux · Neustartbedarf prüfen', 'posix_sh', 'agent_service', $linux_boot$#!/bin/sh
|
|
set -eu
|
|
export LC_ALL=C
|
|
boot=$(awk '$1 == "btime" { print $2 }' /proc/stat)
|
|
test -n "$boot"
|
|
printf 'Letzte Bootzeit (UTC): %s\n' "$(date -u -d "@$boot" +%FT%TZ)"
|
|
if [ -e /run/reboot-required ]; then
|
|
printf 'Neustart ausstehend: ja (/run/reboot-required)\n'
|
|
elif [ -d /run ] && [ -x /run ]; then
|
|
printf 'Neustartbedarf: unbekannt (kein Marker in /run; abhängig von Distribution und Paketen)\n'
|
|
else
|
|
printf 'Neustartbedarf: unbekannt (/run nicht zugänglich)\n'
|
|
fi
|
|
$linux_boot$),
|
|
('Windows · Neustartbedarf prüfen', 'powershell', 'agent_service', $windows_boot$$ErrorActionPreference = 'Stop'
|
|
$event = Get-WinEvent -FilterHashtable @{ LogName='System'; ProviderName='Microsoft-Windows-Kernel-General'; Id=12 } -MaxEvents 1
|
|
$start = ([xml]$event.ToXml()).Event.EventData.Data | Where-Object { $_.Name -ceq 'StartTime' }
|
|
$utc = [Xml.XmlConvert]::ToDateTimeOffset($start.InnerText).UtcDateTime.ToString('o')
|
|
Write-Output ('Letzte Bootzeit (UTC, Windows-Systemereignis): ' + $utc)
|
|
$sources = @(
|
|
@{ Name = 'Windows Update'; Key = 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired' }
|
|
@{ Name = 'Komponentenwartung (CBS)'; Key = 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootPending' }
|
|
)
|
|
$present = $false
|
|
$unknown = $false
|
|
foreach ($source in $sources) {
|
|
try {
|
|
$marker = Test-Path -LiteralPath $source.Key
|
|
$present = $present -or $marker
|
|
$state = if ($marker) { 'vorhanden' } else { 'fehlt' }
|
|
Write-Output ($source.Name + ': ' + $state)
|
|
} catch {
|
|
$unknown = $true
|
|
Write-Output ($source.Name + ': nicht lesbar')
|
|
}
|
|
}
|
|
if ($present) { Write-Output 'Neustart ausstehend: ja' }
|
|
elseif ($unknown) { Write-Output 'Neustartbedarf: unbekannt' }
|
|
else { Write-Output 'Neustartbedarf: keiner laut den beiden geprueften Markern' }
|
|
$windows_boot$),
|
|
('Linux · Letzte Agent- und Updatefehler', 'posix_sh', 'agent_service', $linux_logs$#!/bin/sh
|
|
exec python3 -I - <<'PYTHON'
|
|
from datetime import datetime, timezone
|
|
import json
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
|
|
try:
|
|
result = subprocess.run(
|
|
["journalctl", "--since=24 hours ago", "--no-pager", "--lines=400", "--output=json",
|
|
"--output-fields=PRIORITY,MESSAGE,_SYSTEMD_UNIT",
|
|
"-u", "rmm-discovery-agent.service", "-u", "rmm-discovery-update.service"],
|
|
capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=15,
|
|
)
|
|
except (OSError, subprocess.TimeoutExpired):
|
|
sys.exit("Agentjournal konnte nicht gelesen werden.")
|
|
if result.returncode != 0:
|
|
sys.exit("Agentjournal nicht lesbar (Dienstkonto oder Journal nicht verfügbar).")
|
|
partial = bool(result.stderr.strip())
|
|
if partial:
|
|
print("Agentjournal möglicherweise nur teilweise lesbar (Journalzugriff prüfen).")
|
|
|
|
print("Agent und Updater: Fehler und Warnungen aus den letzten 400 Einträgen innerhalb von 24 Stunden")
|
|
messages = []
|
|
for line in result.stdout.splitlines():
|
|
event = json.loads(line)
|
|
message = event.get("MESSAGE")
|
|
if isinstance(message, str) and (
|
|
event.get("PRIORITY") in {"0", "1", "2", "3", "4"}
|
|
or re.search(r"\b(fail(?:ed|ure)?|err(?:or)?|warn(?:ing)?|timed?\s*out|denied|panic)\b", message, re.I)
|
|
):
|
|
when = datetime.fromtimestamp(int(event["__REALTIME_TIMESTAMP"]) / 1e6, timezone.utc)
|
|
messages.append(f"{when.isoformat(timespec='seconds')} {' '.join(message.split())[:300]}")
|
|
for message in messages[-20:]:
|
|
print(message)
|
|
if not messages and not partial:
|
|
print("Keine passenden Einträge gefunden.")
|
|
PYTHON
|
|
$linux_logs$),
|
|
('Windows · Letzte Agent- und Updatefehler', 'powershell', 'agent_service', $windows_logs$$ErrorActionPreference = 'Stop'
|
|
function Read-Events($filter, $limit) {
|
|
try {
|
|
Get-WinEvent -FilterHashtable $filter -MaxEvents $limit
|
|
} catch {
|
|
if ($_.FullyQualifiedErrorId -notlike 'NoMatchingEventsFound,*') { throw }
|
|
}
|
|
}
|
|
$since = (Get-Date).AddHours(-24)
|
|
$names = @('RmmDiscoveryWindows', 'RmmDiscoveryReleasePull')
|
|
$names += @(Get-Service -Name $names -ErrorAction SilentlyContinue | Select-Object -ExpandProperty DisplayName)
|
|
$data = Join-Path ([Environment]::GetFolderPath('CommonApplicationData')) 'RustDiscovery'
|
|
$releaseStatus = Join-Path $data 'release-state\release-status.json'
|
|
try {
|
|
if (-not (Test-Path -LiteralPath $releaseStatus -PathType Leaf)) {
|
|
$releaseStatus = Join-Path $data 'release-status.json'
|
|
}
|
|
$last = Get-Content -LiteralPath $releaseStatus -Raw | ConvertFrom-Json
|
|
if ($last.status -notin 'ok', 'error') { throw 'Unbekannter Updaterstatus.' }
|
|
$checked = [DateTimeOffset]::Parse($last.observed_at).UtcDateTime
|
|
Write-Output ('Agent-Updater: letzter protokollierter Lauf {0:o}, Status {1}' -f $checked, $last.status)
|
|
} catch {
|
|
Write-Output 'Agent-Updater: letzter Lauf unbekannt (Statusdatei fehlt oder ist nicht lesbar).'
|
|
}
|
|
$failed = $false
|
|
$events = @()
|
|
try {
|
|
$scm = @{ LogName='System'; ProviderName='Service Control Manager'; StartTime=$since; Id=7000,7001,7009,7011,7023,7024,7031,7034 }
|
|
$events += @(Read-Events $scm 250 | Where-Object {
|
|
$event = $_
|
|
$names | Where-Object { $_ -in $event.Properties.Value }
|
|
})
|
|
} catch {
|
|
Write-Warning 'Service-Control-Manager-Ereignisse nicht lesbar.'
|
|
$failed = $true
|
|
}
|
|
try {
|
|
$updates = @{ LogName='Microsoft-Windows-WindowsUpdateClient/Operational'; ProviderName='Microsoft-Windows-WindowsUpdateClient'; StartTime=$since; Level=2,3 }
|
|
$events += @(Read-Events $updates 20)
|
|
} catch {
|
|
Write-Warning 'Windows-Update-Ereignisse nicht lesbar.'
|
|
$failed = $true
|
|
}
|
|
Write-Output 'Agentdienste und Windows Update: letzte 24 Stunden, hoechstens 20 Ereignisse'
|
|
foreach ($event in ($events | Sort-Object TimeCreated -Descending | Select-Object -First 20)) {
|
|
$line = ([string]$event.Message -replace '\s+', ' ').Trim()
|
|
if ($line.Length -gt 300) { $line = $line.Substring(0, 300) }
|
|
Write-Output ('{0:o} {1} #{2} {3}' -f $event.TimeCreated.ToUniversalTime(), $event.ProviderName, $event.Id, $line)
|
|
}
|
|
if ($events.Count -eq 0 -and -not $failed) { Write-Output 'Keine passenden Ereignisse gefunden.' }
|
|
if ($failed) { exit 1 }
|
|
$windows_logs$),
|
|
('Linux · Betriebssystem-Updatebedarf anzeigen', 'posix_sh', 'agent_service', $linux_updates$#!/bin/sh
|
|
set -eu
|
|
export LC_ALL=C
|
|
if ! grep -Eq '^ID=(debian|ubuntu|"debian"|"ubuntu")$' /etc/os-release ||
|
|
! command -v apt >/dev/null; then
|
|
printf 'Diese Vorlage benötigt Debian oder Ubuntu mit APT.\n' >&2
|
|
exit 1
|
|
fi
|
|
cutoff=$(date +%s)
|
|
count=0
|
|
oldest=
|
|
for index in /var/lib/apt/lists/*_Packages /var/lib/apt/lists/*_Packages.*; do
|
|
[ -f "$index" ] || continue
|
|
modified=$(stat -c %Y -- "$index")
|
|
if [ -z "$oldest" ] || [ "$modified" -lt "$oldest" ]; then oldest=$modified; fi
|
|
count=$((count + 1))
|
|
done
|
|
if [ "$count" -eq 0 ]; then
|
|
printf 'Keine lokalen APT-Paketlisten gefunden. Updatebedarf unbekannt.\n' >&2
|
|
exit 1
|
|
fi
|
|
printf 'APT-Paketlisten: %s; ältester Zeitstempel (UTC): %s; Alter: %s Tage\n' \
|
|
"$count" "$(date -u -d "@$oldest" +%FT%TZ)" "$(((cutoff - oldest) / 86400))"
|
|
list=$(apt list --upgradable 2>/dev/null) || {
|
|
printf 'APT-Paketlisten konnten nicht ausgewertet werden.\n' >&2
|
|
exit 1
|
|
}
|
|
printf '%s\n' "$list" | awk '
|
|
/^[^[:space:]\/]+\// { if (++found <= 50) print }
|
|
END { print "Aktualisierbare installierte Pakete laut lokalem Stand: " (found + 0) }
|
|
'
|
|
$linux_updates$),
|
|
('Windows · Betriebssystem-Updatebedarf anzeigen', 'powershell', 'system', $windows_updates$$ErrorActionPreference = 'Stop'
|
|
$session = New-Object -ComObject Microsoft.Update.Session
|
|
$searcher = $session.CreateUpdateSearcher()
|
|
$searcher.ServerSelection = 0
|
|
$searcher.Online = $true
|
|
$searcher.CanAutomaticallyUpgradeService = $false
|
|
Write-Output 'Suche nach fehlenden Softwareupdates ueber die konfigurierte Windows-Updatequelle.'
|
|
$result = $searcher.Search("IsInstalled=0 and IsHidden=0 and Type='Software'")
|
|
if ($result.ResultCode -ne 2) {
|
|
throw ('Windows-Update-Suche nicht vollstaendig erfolgreich (WUA-Ergebnis ' + $result.ResultCode + ').')
|
|
}
|
|
Write-Output ('Verfuegbare Softwareupdates: ' + $result.Updates.Count)
|
|
for ($i = 0; $i -lt [Math]::Min($result.Updates.Count, 50); $i++) {
|
|
$update = $result.Updates.Item($i)
|
|
$title = $update.Title -replace '\s+', ' '
|
|
if ($title.Length -gt 300) { $title = $title.Substring(0, 300) }
|
|
Write-Output $title
|
|
}
|
|
$windows_updates$)
|
|
) AS scripts(name, interpreter, execution_identity, body)
|
|
ON CONFLICT (tenant_id, name, version) DO NOTHING;
|
|
PERFORM set_config('app.tenant_id', previous_tenant, true);
|
|
END
|
|
$seed$;
|
|
REVOKE ALL ON FUNCTION seed_standard_diagnostic_scripts(uuid) FROM PUBLIC;
|
|
|
|
CREATE OR REPLACE FUNCTION seed_tenant_script_library() RETURNS trigger
|
|
LANGUAGE plpgsql SECURITY DEFINER
|
|
SET search_path = pg_catalog, public AS $$
|
|
DECLARE previous_tenant text := coalesce(current_setting('app.tenant_id', true), '');
|
|
BEGIN
|
|
PERFORM set_config('app.tenant_id', NEW.tenant_id::text, true);
|
|
PERFORM public.seed_windows_update_script(NEW.tenant_id);
|
|
PERFORM public.seed_standard_diagnostic_scripts(NEW.tenant_id);
|
|
PERFORM set_config('app.tenant_id', previous_tenant, true);
|
|
RETURN NEW;
|
|
END
|
|
$$;
|
|
REVOKE ALL ON FUNCTION seed_tenant_script_library() FROM PUBLIC;
|
|
|
|
DO $backfill$
|
|
BEGIN
|
|
LOCK TABLE tenants IN SHARE ROW EXCLUSIVE MODE;
|
|
PERFORM public.seed_standard_diagnostic_scripts(tenant_id) FROM tenants;
|
|
END
|
|
$backfill$;
|