459 lines
20 KiB
PowerShell
459 lines
20 KiB
PowerShell
<# =====================================================================
|
||
install-AdHoc-Backup.ps1
|
||
- Menù interattivo:
|
||
1) Installa lo script e l'ambiente
|
||
2) Crea pianificazione (Scheduled Task)
|
||
3) Modifica configurazione (backup.conf) con guida in italiano
|
||
|
||
Requisiti:
|
||
- Eseguire come Amministratore per creare la pianificazione con SYSTEM.
|
||
- Tenere nella stessa cartella:
|
||
- AdHoc-Backup.ps1
|
||
- backup.conf
|
||
|
||
Note:
|
||
- Rispettate le chiavi del tuo backup.conf e il suo "manuale" (liste con |,
|
||
commenti con #, ecc.). Alcune spiegazioni sono riportate nei prompt.
|
||
- Rclone: viene posizionato in $BackupRoot\RClone\rclone.exe. Se non presente,
|
||
lo script prova a copiarlo da installazioni esistenti o può scaricarlo.
|
||
===================================================================== #>
|
||
|
||
[CmdletBinding()]
|
||
param(
|
||
[string]$ConfigPath, # Facoltativo: percorso a backup.conf (default: .\backup.conf)
|
||
[string]$BackupRootOverride # Facoltativo: forza BackupRoot (altrimenti legge da backup.conf)
|
||
)
|
||
|
||
$ErrorActionPreference = 'Stop'
|
||
Set-StrictMode -Version Latest
|
||
|
||
function Write-Title($text) {
|
||
Write-Host ""
|
||
Write-Host "=== $text ===" -ForegroundColor Cyan
|
||
}
|
||
|
||
function Pause-Enter($msg="Premi INVIO per continuare...") {
|
||
Write-Host ""
|
||
Read-Host $msg | Out-Null
|
||
}
|
||
|
||
function Read-Default($prompt, $default) {
|
||
if ([string]::IsNullOrEmpty($default)) {
|
||
return Read-Host "$prompt"
|
||
} else {
|
||
$ans = Read-Host "$prompt [$default]"
|
||
if ([string]::IsNullOrEmpty($ans)) { return $default }
|
||
return $ans
|
||
}
|
||
}
|
||
|
||
function Read-YesNo($prompt, [bool]$default=$true) {
|
||
$defTxt = if ($default) { "S/n" } else { "s/N" }
|
||
while ($true) {
|
||
$ans = Read-Host "$prompt ($defTxt)"
|
||
if ([string]::IsNullOrWhiteSpace($ans)) { return $default }
|
||
switch ($ans.ToLower()) {
|
||
's' { return $true }
|
||
'si' { return $true }
|
||
'y' { return $true }
|
||
'n' { return $false }
|
||
'no' { return $false }
|
||
default { Write-Host "Inserisci 's' o 'n'." -ForegroundColor Yellow }
|
||
}
|
||
}
|
||
}
|
||
|
||
function Test-Admin {
|
||
$id = [Security.Principal.WindowsIdentity]::GetCurrent()
|
||
$p = New-Object Security.Principal.WindowsPrincipal($id)
|
||
return $p.IsInRole([Security.Principal.WindowsBuiltinRole]::Administrator)
|
||
}
|
||
|
||
# ---------- Config I/O (preserva commenti e ordine) ----------
|
||
class ConfigDoc {
|
||
[System.Collections.Generic.List[string]]$Lines
|
||
[hashtable]$Map
|
||
[hashtable]$Index
|
||
ConfigDoc() {
|
||
$this.Lines = [System.Collections.Generic.List[string]]::new()
|
||
$this.Map = @{}
|
||
$this.Index = @{}
|
||
}
|
||
}
|
||
|
||
function Load-Config([string]$path) {
|
||
if (-not (Test-Path -LiteralPath $path)) {
|
||
throw "File di configurazione non trovato: $path"
|
||
}
|
||
$doc = [ConfigDoc]::new()
|
||
$raw = Get-Content -LiteralPath $path -Raw -Encoding UTF8 -ErrorAction Stop
|
||
foreach ($ln in ($raw -split "`r?`n", [System.StringSplitOptions]::None)) {
|
||
$doc.Lines.Add($ln)
|
||
}
|
||
for ($i=0; $i -lt $doc.Lines.Count; $i++) {
|
||
$line = $doc.Lines[$i]
|
||
if ($line -match '^\s*#') { continue }
|
||
if ($line -match '^\s*([A-Za-z0-9_]+)\s*=(.*)$') {
|
||
$k = $matches[1]
|
||
$v = ($matches[2]).Trim()
|
||
$doc.Map[$k] = $v
|
||
$doc.Index[$k] = $i
|
||
}
|
||
}
|
||
return $doc
|
||
}
|
||
|
||
function Save-Config([ConfigDoc]$doc, [string]$path) {
|
||
$backup = "$path.bak_$(Get-Date -Format 'yyyyMMdd_HHmmss')"
|
||
Copy-Item -LiteralPath $path -Destination $backup -Force -ErrorAction Stop
|
||
|
||
# Riscrivo solo le linee delle chiavi (preservo commenti/righe vuote)
|
||
foreach ($k in $doc.Map.Keys) {
|
||
$v = [string]$doc.Map[$k]
|
||
if ($doc.Index.ContainsKey($k)) {
|
||
$idx = [int]$doc.Index[$k]
|
||
$doc.Lines[$idx] = "$k=$v"
|
||
} else {
|
||
# Aggiungo nuove chiavi alla fine
|
||
if (-not $doc.Lines[$doc.Lines.Count-1].StartsWith('# AGGIUNTE AUTO')) {
|
||
$doc.Lines.Add("")
|
||
$doc.Lines.Add("# AGGIUNTE AUTO (create da install-AdHoc-Backup.ps1)")
|
||
}
|
||
$doc.Lines.Add("$k=$v")
|
||
}
|
||
}
|
||
[IO.File]::WriteAllLines($path, $doc.Lines, [Text.UTF8Encoding]::new($false))
|
||
return $backup
|
||
}
|
||
|
||
function Set-ConfigValue([ConfigDoc]$doc, [string]$key, [string]$value) {
|
||
$doc.Map[$key] = $value
|
||
}
|
||
|
||
# ---------- Validatori ----------
|
||
function Validate-IntNonNeg($valText, [int]$min=0, [int]$max=[int]::MaxValue) {
|
||
if ([string]::IsNullOrWhiteSpace($valText)) { return $null } # mantieni
|
||
[int]$n = 0
|
||
if (-not [int]::TryParse($valText, [ref]$n)) { throw "Numero non valido." }
|
||
if ($n -lt $min -or $n -gt $max) { throw "Valore fuori range ($min..$max)." }
|
||
return $n
|
||
}
|
||
function Validate-Port($valText) { return (Validate-IntNonNeg $valText 1 65535) }
|
||
|
||
function Normalize-BoolText($text, [bool]$current) {
|
||
if ([string]::IsNullOrWhiteSpace($text)) { return $current }
|
||
switch ($text.Trim().ToLower()) {
|
||
'true' { return $true }
|
||
'false' { return $false }
|
||
's' { return $true }
|
||
'si' { return $true }
|
||
'y' { return $true }
|
||
'n' { return $false }
|
||
'no' { return $false }
|
||
default { throw "Valore non valido. Usa: true/false oppure s/n" }
|
||
}
|
||
}
|
||
|
||
function Read-Secret($prompt, $currentPlain) {
|
||
Write-Host "$prompt (lascia vuoto per mantenere l'attuale)" -ForegroundColor Yellow
|
||
$sec = Read-Host -AsSecureString
|
||
if ($sec.Length -eq 0) { return $currentPlain }
|
||
return [Runtime.InteropServices.Marshal]::PtrToStringAuto([Runtime.InteropServices.Marshal]::SecureStringToBSTR($sec))
|
||
}
|
||
|
||
# ---------- Editor guidato backup.conf ----------
|
||
function Edit-BackupConfig {
|
||
param([string]$cfgPath)
|
||
|
||
Write-Title "Modifica configurazione (backup.conf)"
|
||
$doc = Load-Config $cfgPath
|
||
|
||
# Mappa variabili -> descrizione & validazione
|
||
$vars = @(
|
||
@{Key='BackupRoot'; Desc='Cartella radice dei backup (archivi, log, tool).'; Example='C:\Backups_AdHoc' },
|
||
@{Key='LocalRetentionDaysFiles'; Desc='Giorni di retention dei file in locale (\Files). 0=disabilita.'; Validate='int' },
|
||
@{Key='LocalRetentionDaysDb'; Desc='Giorni di retention dei database in locale (\Databases). 0=disabilita.'; Validate='int' },
|
||
@{Key='RemoteRetentionDays'; Desc='Giorni di retention su remoto (rclone).'; Validate='int' },
|
||
@{Key='KeepLocalArchives'; Desc='true=mantiene copie locali, false=le rimuove dopo upload.'; Validate='bool' },
|
||
@{Key='EnableFileBackup'; Desc='true=abilita backup di cartelle/sorgenti in .7z.'; Validate='bool' },
|
||
@{Key='EnableRcloneUpload'; Desc='true=abilita upload dei backup con rclone.'; Validate='bool' },
|
||
@{Key='ArchiveSources'; Desc='Sorgenti da archiviare, separa con | (es.: C:\Dati|D:\Export|\\nas\share).'; Example='C:\Zucchetti\ahr90|C:\Zucchetti\NetSetup' },
|
||
|
||
@{Key='EnableSqlBackup'; Desc='true=abilita backup dei DB SQL Server.'; Validate='bool' },
|
||
@{Key='SqlInstance'; Desc='Istanza SQL (es.: localhost, .\SQLEXPRESS, 192.168.1.10,1433, nome\istanza).'},
|
||
@{Key='SqlUseWindowsAuth'; Desc='true=Windows Authentication; false=SQL Auth (usa SqlUser/SqlPassword).'; Validate='bool' },
|
||
@{Key='SqlUser'; Desc='Utente SQL (usato solo se SqlUseWindowsAuth=false).'},
|
||
@{Key='SqlPassword'; Desc='Password SQL (usata solo se SqlUseWindowsAuth=false).'; Secret=$true },
|
||
@{Key='DbInclude'; Desc='Elenco DB da includere (|). Vuoto = auto-detect dei DB utente online.'; Example='DBProduzione|DBCRM|DBContabilita' },
|
||
@{Key='DbExclude'; Desc='DB da escludere se DbInclude è vuoto (default: master|model|msdb|tempdb).', Example='master|model|msdb|tempdb' },
|
||
@{Key='SqlCompressStage'; Desc='true= comprime la cartella _sql_stage in .7z dopo il backup.'; Validate='bool' },
|
||
@{Key='SqlDropBakAfterZip'; Desc='true= elimina i .bak dopo la compressione.'; Validate='bool' },
|
||
|
||
@{Key='SevenZipCompressionLevel'; Desc='Livello compressione 7-Zip (0..9). 1–3 spesso è il miglior compromesso.'; Validate='int' },
|
||
|
||
@{Key='RcloneRemoteDest'; Desc='Destinazione rclone in formato REMOTE:percorso (usa %COMPUTERNAME% se utile).'; Example='dropbox:/Backups_AdHoc/%COMPUTERNAME%' },
|
||
@{Key='RcloneBwl'; Desc='Limitazione di banda (es: 10M). Vuoto = nessun limite.'},
|
||
@{Key='RcloneExtraArgs'; Desc='Argomenti extra rclone separati da | (es: --fast-list|--s3-chunk-size=64M).'},
|
||
|
||
@{Key='MailEnabled'; Desc='true= invia una mail di report a fine job.'; Validate='bool' },
|
||
@{Key='MailSmtpHost'; Desc='Host SMTP (relay).'},
|
||
@{Key='MailSmtpPort'; Desc='Porta SMTP (tipico 587).'; Validate='port' },
|
||
@{Key='MailUseAuth'; Desc='true= il relay richiede autenticazione (compila utente/password).'; Validate='bool' },
|
||
@{Key='MailUser'; Desc='Utente SMTP (se richiesto).'},
|
||
@{Key='MailPassword'; Desc='Password SMTP (se richiesta).'; Secret=$true },
|
||
@{Key='MailFrom'; Desc='Indirizzo mittente.'},
|
||
@{Key='MailTo'; Desc='Destinatari separati da |.'; Example='it@azienda.it|sysadmin@azienda.it' },
|
||
@{Key='MailSubjectPref'; Desc='Prefisso oggetto (puoi lasciare spazio finale).' }
|
||
)
|
||
|
||
$changes = @{}
|
||
|
||
foreach ($v in $vars) {
|
||
$key = $v.Key
|
||
$cur = $doc.Map[$key]
|
||
|
||
Write-Host ""
|
||
Write-Host ">> $key" -ForegroundColor Green
|
||
Write-Host " $($v.Desc)"
|
||
if ($v.ContainsKey('Example') -and $v.Example) { Write-Host " Esempio: $($v.Example)" -ForegroundColor DarkGray }
|
||
|
||
if ($v.ContainsKey('Secret') -and $v.Secret) {
|
||
$newVal = Read-Secret "Nuovo valore per $key" $cur
|
||
} else {
|
||
$newValRaw = Read-Default "Inserisci un nuovo valore per $key (INVIO = mantieni)" $cur
|
||
# Validazione
|
||
if ($v.ContainsKey('Validate')) {
|
||
switch ($v.Validate) {
|
||
'int' { $n = Validate-IntNonNeg $newValRaw | Out-Null; if ($null -ne $n) { $newValRaw = [string]$n } }
|
||
'bool' { $b = Normalize-BoolText $newValRaw ($cur -eq 'true'); $newValRaw = if ($b) { 'true' } else { 'false' } }
|
||
'port' { $p = Validate-Port $newValRaw | Out-Null; if ($null -ne $p) { $newValRaw = [string]$p } }
|
||
}
|
||
}
|
||
$newVal = $newValRaw
|
||
}
|
||
|
||
if ($newVal -ne $cur) {
|
||
$changes[$key] = @{Old=$cur; New=$newVal}
|
||
Set-ConfigValue -doc $doc -key $key -value $newVal
|
||
}
|
||
}
|
||
|
||
if ($changes.Count -gt 0) {
|
||
Write-Host ""
|
||
Write-Title "Riepilogo modifiche"
|
||
$changes.GetEnumerator() | ForEach-Object {
|
||
"{0} : '{1}' -> '{2}'" -f $_.Key, $_.Value.Old, $_.Value.New
|
||
} | Write-Host
|
||
|
||
if (Read-YesNo "Confermi il salvataggio delle modifiche?") {
|
||
$bk = Save-Config -doc $doc -path $cfgPath
|
||
Write-Host "Configurazione salvata: $cfgPath" -ForegroundColor Cyan
|
||
Write-Host "Backup creato: $bk" -ForegroundColor DarkCyan
|
||
} else {
|
||
Write-Host "Annullato. Nessuna modifica scritta." -ForegroundColor Yellow
|
||
}
|
||
} else {
|
||
Write-Host "Nessuna modifica apportata." -ForegroundColor Yellow
|
||
}
|
||
|
||
Pause-Enter
|
||
}
|
||
|
||
# ---------- Installazione ambiente ----------
|
||
function Ensure-Folder($path) {
|
||
if (-not (Test-Path -LiteralPath $path)) {
|
||
New-Item -ItemType Directory -Path $path -Force | Out-Null
|
||
}
|
||
}
|
||
|
||
function Install-Environment {
|
||
param([string]$cfgPath)
|
||
|
||
Write-Title "Installazione ambiente"
|
||
$doc = Load-Config $cfgPath
|
||
|
||
# Determina BackupRoot
|
||
$backupRoot = if ($BackupRootOverride) { $BackupRootOverride } elseif ($doc.Map['BackupRoot']) { $doc.Map['BackupRoot'] } else { 'C:\Backups_AdHoc' }
|
||
$backupRoot = Read-Default "BackupRoot di destinazione" $backupRoot
|
||
Set-ConfigValue -doc $doc -key 'BackupRoot' -value $backupRoot
|
||
$null = Save-Config -doc $doc -path $cfgPath
|
||
|
||
# Struttura cartelle
|
||
$folders = @(
|
||
$backupRoot,
|
||
Join-Path $backupRoot 'Logs',
|
||
Join-Path $backupRoot 'Out',
|
||
Join-Path $backupRoot 'Files',
|
||
Join-Path $backupRoot 'Databases',
|
||
Join-Path $backupRoot '_sql_stage',
|
||
Join-Path $backupRoot 'Bin',
|
||
Join-Path $backupRoot 'RClone'
|
||
)
|
||
foreach ($f in $folders) { Ensure-Folder $f }
|
||
|
||
# Copia script principali
|
||
$srcScript = Join-Path $PSScriptRoot 'AdHoc-Backup.ps1'
|
||
if (-not (Test-Path -LiteralPath $srcScript)) {
|
||
throw "AdHoc-Backup.ps1 non trovato in $PSScriptRoot"
|
||
}
|
||
Copy-Item -LiteralPath $srcScript -Destination (Join-Path $backupRoot 'AdHoc-Backup.ps1') -Force
|
||
|
||
# Copia backup.conf
|
||
Copy-Item -LiteralPath $cfgPath -Destination (Join-Path $backupRoot 'backup.conf') -Force
|
||
|
||
# Rclone: binario + config locale nello stesso folder ($BackupRoot\RClone)
|
||
Ensure-Rclone -TargetRoot $backupRoot
|
||
|
||
Write-Host "Installazione completata in: $backupRoot" -ForegroundColor Cyan
|
||
Pause-Enter
|
||
}
|
||
|
||
function Ensure-Rclone {
|
||
param([string]$TargetRoot)
|
||
|
||
$rcloneDir = Join-Path $TargetRoot 'RClone'
|
||
$rcloneExe = Join-Path $rcloneDir 'rclone.exe'
|
||
$rcloneConf = Join-Path $rcloneDir 'rclone.conf'
|
||
|
||
Ensure-Folder $rcloneDir
|
||
|
||
if (-not (Test-Path -LiteralPath $rcloneExe)) {
|
||
Write-Host "rclone.exe non trovato in $rcloneDir, provo a reperirlo..." -ForegroundColor Yellow
|
||
$candidates = @(
|
||
"$env:ProgramFiles\rclone\rclone.exe",
|
||
"$env:ProgramFiles\Rclone\rclone.exe",
|
||
"$env:ProgramFiles(x86)\rclone\rclone.exe",
|
||
"$env:ProgramFiles(x86)\Rclone\rclone.exe",
|
||
"$env:SystemRoot\System32\rclone.exe"
|
||
) | Where-Object { Test-Path -LiteralPath $_ }
|
||
|
||
if ($candidates.Count -gt 0) {
|
||
Copy-Item -LiteralPath $candidates[0] -Destination $rcloneExe -Force
|
||
Write-Host "Copiato rclone da: $($candidates[0])" -ForegroundColor Green
|
||
}
|
||
else {
|
||
# Tentativo di download (puoi saltarlo se non vuoi traffico Internet)
|
||
try {
|
||
$zipUrl = "https://downloads.rclone.org/rclone-current-windows-amd64.zip"
|
||
$tmpZip = Join-Path $env:TEMP "rclone-current.zip"
|
||
Write-Host "Scarico rclone da $zipUrl ..." -ForegroundColor Yellow
|
||
Invoke-WebRequest -Uri $zipUrl -OutFile $tmpZip -UseBasicParsing
|
||
$tmpDir = Join-Path $env:TEMP "rclone_unzip_$([guid]::NewGuid().ToString('N'))"
|
||
Expand-Archive -LiteralPath $tmpZip -DestinationPath $tmpDir -Force
|
||
$found = Get-ChildItem -Path $tmpDir -Filter rclone.exe -Recurse | Select-Object -First 1
|
||
if ($null -ne $found) {
|
||
Copy-Item -LiteralPath $found.FullName -Destination $rcloneExe -Force
|
||
Write-Host "rclone scaricato e installato." -ForegroundColor Green
|
||
} else {
|
||
Write-Host "Impossibile trovare rclone.exe nello ZIP. Mettilo manualmente in $rcloneDir" -ForegroundColor Red
|
||
}
|
||
} catch {
|
||
Write-Host "Download rclone fallito: $($_.Exception.Message)" -ForegroundColor Red
|
||
Write-Host "Puoi copiare manualmente rclone.exe in $rcloneDir" -ForegroundColor Yellow
|
||
}
|
||
}
|
||
}
|
||
|
||
# Config rclone: importa quella utente se esiste, altrimenti crea skeleton
|
||
if (-not (Test-Path -LiteralPath $rcloneConf)) {
|
||
$userConf = Join-Path $env:APPDATA 'rclone\rclone.conf'
|
||
if (Test-Path -LiteralPath $userConf) {
|
||
Copy-Item -LiteralPath $userConf -Destination $rcloneConf -Force
|
||
Write-Host "Importata configurazione rclone da $userConf" -ForegroundColor Green
|
||
} else {
|
||
@"
|
||
# rclone.conf (skeleton) — definisci qui il REMOTE usato in backup.conf (RcloneRemoteDest)
|
||
# Esempio dropbox:
|
||
# [dropbox]
|
||
# type = dropbox
|
||
"@ | Set-Content -LiteralPath $rcloneConf -Encoding UTF8 -NoNewline
|
||
Write-Host "Creato skeleton rclone.conf in $rcloneConf" -ForegroundColor Yellow
|
||
}
|
||
}
|
||
|
||
# NB: il nostro backup script userà --config "$BackupRoot\RClone\rclone.conf" come da linea guida.
|
||
}
|
||
|
||
# ---------- Pianificazione ----------
|
||
function Create-Schedule {
|
||
param([string]$cfgPath)
|
||
|
||
if (-not (Test-Admin)) {
|
||
throw "Per creare la pianificazione occorrono privilegi di Amministratore."
|
||
}
|
||
|
||
$doc = Load-Config $cfgPath
|
||
$backupRoot = if ($BackupRootOverride) { $BackupRootOverride } elseif ($doc.Map['BackupRoot']) { $doc.Map['BackupRoot'] } else { 'C:\Backups_AdHoc' }
|
||
|
||
$scriptPath = Join-Path $backupRoot 'AdHoc-Backup.ps1'
|
||
$confPath = Join-Path $backupRoot 'backup.conf'
|
||
if (-not (Test-Path -LiteralPath $scriptPath)) { throw "Script backup non trovato in $scriptPath (esegui prima l'installazione)." }
|
||
if (-not (Test-Path -LiteralPath $confPath)) { throw "Configurazione non trovata in $confPath (esegui prima l'installazione)." }
|
||
|
||
Write-Title "Crea pianificazione (Scheduled Task)"
|
||
$taskName = Read-Default "Nome attività" "AdHoc Backup Giornaliero"
|
||
|
||
# Ora (HH:mm)
|
||
while ($true) {
|
||
$timeTxt = Read-Default "Orario giornaliero (HH:mm)" "22:30"
|
||
if ([TimeSpan]::TryParse($timeTxt, [ref]([TimeSpan]$null))) { break }
|
||
try { [DateTime]::ParseExact($timeTxt, 'HH:mm', $null) | Out-Null; break } catch { Write-Host "Formato non valido. Usa HH:mm (es. 22:30)" -ForegroundColor Yellow }
|
||
}
|
||
|
||
$atTime = [DateTime]::ParseExact($timeTxt, 'HH:mm', $null).TimeOfDay
|
||
$trigger = New-ScheduledTaskTrigger -Daily -At $atTime
|
||
|
||
$psArgs = "-NoProfile -ExecutionPolicy Bypass -File `"$scriptPath`" -Conf `"$confPath`""
|
||
$action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument $psArgs
|
||
|
||
$principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount -RunLevel Highest
|
||
$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable `
|
||
-RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 5) `
|
||
-MultipleInstances IgnoreNew
|
||
|
||
Register-ScheduledTask -TaskName $taskName -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Force | Out-Null
|
||
|
||
Write-Host "Attività pianificata creata: $taskName, orario $timeTxt (account SYSTEM)." -ForegroundColor Cyan
|
||
Pause-Enter
|
||
}
|
||
|
||
# ---------- Menù ----------
|
||
function Show-Menu {
|
||
Clear-Host
|
||
Write-Host ""
|
||
Write-Host "==========================" -ForegroundColor DarkCyan
|
||
Write-Host " INSTALL AZIENDALE BACKUP" -ForegroundColor DarkCyan
|
||
Write-Host "==========================" -ForegroundColor DarkCyan
|
||
Write-Host "1) Installa lo script e l'ambiente"
|
||
Write-Host "2) Crea pianificazione (Scheduled Task)"
|
||
Write-Host "3) Modifica configurazione (backup.conf)"
|
||
Write-Host "4) Esci"
|
||
Write-Host ""
|
||
}
|
||
|
||
# Percorso di default per backup.conf
|
||
if (-not $ConfigPath) { $ConfigPath = Join-Path $PSScriptRoot 'backup.conf' }
|
||
|
||
while ($true) {
|
||
Show-Menu
|
||
$choice = Read-Default "Seleziona un'opzione" "1"
|
||
switch ($choice) {
|
||
'1' {
|
||
Install-Environment -cfgPath $ConfigPath
|
||
}
|
||
'2' {
|
||
Create-Schedule -cfgPath $ConfigPath
|
||
}
|
||
'3' {
|
||
Edit-BackupConfig -cfgPath $ConfigPath
|
||
}
|
||
'4' { break }
|
||
default {
|
||
Write-Host "Opzione non valida." -ForegroundColor Yellow
|
||
Pause-Enter
|
||
}
|
||
}
|
||
}
|
||
|
||
Write-Host "Uscita." -ForegroundColor DarkGray
|