manuelle Verteilung ohne exe

    Kurzversion

    Leider lassen sich die .exe-Installationsdateien nicht immer auf den Clients direkt ausführen. In diesen Fällen extrahieren Sie die Dateien lokal und kopieren den Inhalt manuell (oder per Batch / PowerShell) in die Zielverzeichnisse.
    Voraussetzungen: passende Berechtigungen auf Client und Netzwerkfreigaben sowie ein aktuelles Backup der betroffenen Verzeichnisse.
    Nach dem Kopiervorgang prüfen Sie mittels MMT_About in der eXs-Commandline, ob der erwartete Build geladen wurde.

    ausführliche Version

    Wenn die .exe-Datei auf Clients nicht ausgeführt werden kann, lässt sich die Installation auch durch Entpacken und gezieltes Kopieren der Dateien realisieren.

    Voraussetzungen

    • Administrator-/Schreibrechte auf dem Client und auf den Ziel-Freigaben
    • 7‑Zip (oder ein anderes Entpacktool) auf dem System, das die .exe entpacken kann
    • Backup aller Zielverzeichnisse vor dem Überschreiben

    Minimale Schritte

    1. Lade die aktuellste .exe herunter und entpacke sie (z. B. mit 7‑Zip) an einen temporären Ort.
    2. Kopiere den gesamten Inhalt des Ordners ProgramFiles in das Zielprogrammverzeichnis:
      • Ziel: C:\Program Files\MuM MT\eXs 202#\ (ersetze # durch die Versionsnummer)
    3. Kopiere die in UserData enthaltenen Unterordner Tools, Sample, Docu, Backup und Config in die gepoolte Ablage (Netzwerkfreigabe eurer Umgebung).
    4. Kopiere den Inhalt des Ordners UserData\System in das SQL-bezogene Systemverzeichnis (z. B. eXs-Systemdatenbank-Ordner auf dem SQL-Server).
    5. Kopiere UserData\startup nach %ProgramData%\MuM MT\eXs 202#\
    6. Kopiere UserData\ApplicationHome nach C:\Program Files\MuM MT\eXs 202#\Support\
    7. Startet den Client und prüft die Version mit MMT_About (direkt in der eXs-Commandline). Ein erfolgreicher Start bedeutet in der Regel, dass die Version bereits kompatibel ist.

    Wichtige Hinweise

    • Vor dem Kopieren: vollständiges Backup der Zielordner erstellen.
    • Bei Netzwerkdeployments: Schreibrechte für die jeweilige Freigabe sicherstellen.
    • Automatisierung: Die Schritte lassen sich gut per Batch- oder PowerShell-Skript abbilden — ich kann gern Vorlagen liefern.
    • Dokumentiere die angewendete Version und das Datum der manuellen Verteilung.

    PowerShell-Skript mit Berechtigungsprüfung und Logging für normale User

    param(
       [string]$SourcePath = "$env:USERPROFILE\Downloads\eXsSR-FRentpackt",
       [string]$ProgramFilesPath = "C:\Program Files\MuM MT\eXs 202#",
       [string]$NetworkSharePath = "\\server\share\eXs",
       [string]$SqlSystemPath = "\\sqlserver\sqlshare\System",
       [string]$ProgramDataPath = "$env:ProgramData\MuM MT\eXs 202#",
       [string]$SupportPath = "C:\Program Files\MuM MT\eXs 202#\Support",
       [string]$LogFilePath = "$env:USERPROFILE\eXsDeploy.log"
    )

    function Write-Log {
       param (
           [string]$Message,
           [string]$Level = "INFO"
       )
       $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
       $logEntry = "$timestamp [$Level] $Message"
       Write-Output $logEntry
       Add-Content -Path $LogFilePath -Value $logEntry
    }

    function Test-WritePermission {
       param (
           [string]$Path
       )
       try {
           $testFile = Join-Path -Path $Path -ChildPath "testfile.tmp"
           $null = New-Item -Path $testFile -ItemType File -Force -ErrorAction Stop
           Remove-Item -Path $testFile -Force -ErrorAction Stop
           return $true
       }
       catch {
           return $false
       }
    }

    function Test-ReadPermission {
       param (
           [string]$Path
       )
       try {
           Get-ChildItem -Path $Path -ErrorAction Stop | Out-Null
           return $true
       }
       catch {
           return $false
       }
    }

    function Check-PathAccess {
       param (
           [string]$Path,
           [string]$AccessType # "Read" or "Write"
       )
       if (-not (Test-Path $Path)) {
           Write-Log "Pfad existiert nicht: $Path" "ERROR"
           return $false
       }
       if ($AccessType -eq "Read") {
           if (Test-ReadPermission -Path $Path) {
               Write-Log "Lesezugriff auf '$Path' ist vorhanden."
               return $true
           }
           else {
               Write-Log "Kein Lesezugriff auf '$Path'." "ERROR"
               return $false
           }
       }
       elseif ($AccessType -eq "Write") {
           if (Test-WritePermission -Path $Path) {
               Write-Log "Schreibzugriff auf '$Path' ist vorhanden."
               return $true
           }
           else {
               Write-Log "Kein Schreibzugriff auf '$Path'." "ERROR"
               return $false
           }
       }
       else {
           Write-Log "Unbekannter Zugriffstyp: $AccessType" "ERROR"
           return $false
       }
    }

    function Copy-FolderContent {
       param (
           [string]$Source,
           [string]$Destination
       )
       try {
           Write-Log "Starte Kopieren von '$Source' nach '$Destination'."
           if (-not (Test-Path -Path $Destination)) {
               New-Item -Path $Destination -ItemType Directory -Force | Out-Null
               Write-Log "Zielordner '$Destination' wurde erstellt."
           }
           Copy-Item -Path (Join-Path $Source '*') -Destination $Destination -Recurse -Force -ErrorAction Stop
           Write-Log "Kopieren von '$Source' nach '$Destination' erfolgreich abgeschlossen."
           return $true
       }
       catch {
           Write-Log "Fehler beim Kopieren von '$Source' nach '$Destination': $_" "ERROR"
           return $false
       }
    }

    # Start Logging
    Write-Log "--------------------"
    Write-Log "Starte eXs Deployment Skript."
    Write-Log "Quellpfad: $SourcePath"
    Write-Log "ProgramFiles Ziel: $ProgramFilesPath"
    Write-Log "Netzwerkfreigabe Ziel: $NetworkSharePath"
    Write-Log "SQL System Ziel: $SqlSystemPath"
    Write-Log "ProgramData Ziel: $ProgramDataPath"
    Write-Log "Support Ziel: $SupportPath"
    Write-Log "Logdatei: $LogFilePath"

    # Prüfen der Zugriffsrechte (Lesen für Quelle, Schreiben für Ziele)
    $checks = @(
       @{Path=$SourcePath; Access="Read"},
       @{Path=$ProgramFilesPath; Access="Write"},
       @{Path=$NetworkSharePath; Access="Write"},
       @{Path=$SqlSystemPath; Access="Write"},
       @{Path=$ProgramDataPath; Access="Write"},
       @{Path=$SupportPath; Access="Write"}
    )

    $allAccessOk = $true
    foreach ($check in $checks) {
       if (-not (Check-PathAccess -Path $check.Path -AccessType $check.Access)) {
           $allAccessOk = $false
       }
    }

    if (-not $allAccessOk) {
       Write-Log "Abbruch: Nicht alle erforderlichen Zugriffsrechte sind vorhanden." "ERROR"
       exit 1
    }

    # 1. ProgramFiles kopieren
    $programFilesSource = Join-Path -Path $SourcePath -ChildPath "ProgramFiles"
    if (-not (Test-Path $programFilesSource)) {
       Write-Log "Quellordner 'ProgramFiles' nicht gefunden unter $programFilesSource." "ERROR"
       exit 1
    }
    Copy-FolderContent -Source $programFilesSource -Destination $ProgramFilesPath

    # 2. UserData Unterordner Tools, Sample, Docu, Backup, Config in Netzwerkfreigabe kopieren
    $userDataPath = Join-Path -Path $SourcePath -ChildPath "UserData"
    $networkSubfolders = @("Tools", "Sample", "Docu", "Backup", "Config")
    foreach ($folder in $networkSubfolders) {
       $src = Join-Path -Path $userDataPath -ChildPath $folder
       if (Test-Path $src) {
           $dest = Join-Path -Path $NetworkSharePath -ChildPath $folder
           Copy-FolderContent -Source $src -Destination $dest
       }
       else {
           Write-Log "Warnung: Ordner '$folder' nicht gefunden unter $src." "WARN"
       }
    }

    # 3. UserData\System in SQL Systemverzeichnis kopieren
    $sqlSystemSource = Join-Path -Path $userDataPath -ChildPath "System"
    if (Test-Path $sqlSystemSource) {
       Copy-FolderContent -Source $sqlSystemSource -Destination $SqlSystemPath
    }
    else {
       Write-Log "Warnung: Ordner 'System' nicht gefunden unter $sqlSystemSource." "WARN"
    }

    # 4. UserData\startup nach ProgramData kopieren
    $startupSource = Join-Path -Path $userDataPath -ChildPath "startup"
    if (Test-Path $startupSource) {
       Copy-FolderContent -Source $startupSource -Destination $ProgramDataPath
    }
    else {
       Write-Log "Warnung: Ordner 'startup' nicht gefunden unter $startupSource." "WARN"
    }

    # 5. UserData\ApplicationHome nach Support kopieren
    $appHomeSource = Join-Path -Path $userDataPath -ChildPath "ApplicationHome"
    if (Test-Path $appHomeSource) {
       Copy-FolderContent -Source $appHomeSource -Destination $SupportPath
    }
    else {
       Write-Log "Warnung: Ordner 'ApplicationHome' nicht gefunden unter $appHomeSource." "WARN"
    }

    Write-Log "eXs Deployment Skript erfolgreich abgeschlossen."
    Write-Log "Bitte prüfen Sie die Version mit MMT_About in der eXs-Commandline."

    exit 0

    Erläuterungen

    • Das Skript startet standardmässig im Download-Ordner des aktuellen Benutzers unter eXsEntpackt.
    • Es prüft Lesezugriff auf den Quellordner und Schreibzugriff auf alle Zielordner. Fehlende Zugriffsrechte werden im Log als Fehler gemeldet, das Skript bricht dann ab.
    • Alle Aktionen und Fehler werden in der Logdatei im Benutzerprofil protokolliert.
    • Das Skript benötigt keine Administratorrechte, sondern läuft mit normalen Benutzerrechten, sofern die Zugriffsrechte auf die Ordner vorhanden sind.
    • Pfade müssen beim Aufruf des Skripts als Parameter überschrieben werden.
    Tags
    Servicerelease Featurerelease manuell
    Veröffentlicht