d2d6b1bdce
users.password_temporanea distingue la password provvisoria data dall'amministratore (creazione del gruppo, "Nuova password temporanea") dal ripristino da backup. Migrazione 000040; si spegne a password cambiata, il ripristino e l'import XML la spengono per tutti. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
262 lines
11 KiB
PHP
262 lines
11 KiB
PHP
<?php
|
|
|
|
namespace App\Jobs;
|
|
|
|
use App\Livewire\Settings\XmlExchange;
|
|
use App\Models\Setting;
|
|
use App\Services\BackupArchive;
|
|
use App\Services\BackupOperationState;
|
|
use App\Services\Piantine\PiantineBackup;
|
|
use Illuminate\Bus\Queueable;
|
|
use Illuminate\Contracts\Queue\ShouldQueue;
|
|
use Illuminate\Foundation\Bus\Dispatchable;
|
|
use Illuminate\Queue\InteractsWithQueue;
|
|
use Illuminate\Queue\SerializesModels;
|
|
use Illuminate\Support\Facades\Auth;
|
|
use Illuminate\Support\Facades\Cache;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Support\Facades\Log;
|
|
use RuntimeException;
|
|
use Spatie\Permission\PermissionRegistrar;
|
|
|
|
/**
|
|
* Ripristina un pacchetto di backup in coda, riportando l'avanzamento fase per
|
|
* fase (estrazione, database, file).
|
|
*/
|
|
class RestoreBackupArchive implements ShouldQueue
|
|
{
|
|
use Dispatchable;
|
|
use InteractsWithQueue;
|
|
use Queueable;
|
|
use SerializesModels;
|
|
|
|
public int $tries = 1;
|
|
|
|
public int $timeout = 570;
|
|
|
|
/** Chiave con cui la schermata di cambio password ritrova l'esito. */
|
|
public const CHIAVE_ESITO = 'restore-esito:';
|
|
|
|
public function __construct(
|
|
public string $operationId,
|
|
public string $zipPath,
|
|
public int $actorId,
|
|
) {
|
|
}
|
|
|
|
/**
|
|
* Il ripristino e' tutto o niente. Tre tempi:
|
|
*
|
|
* 1. estrazione e verifica dell'archivio nello staging, piantine.json
|
|
* compreso: un archivio rotto si ferma qui, a installazione intatta;
|
|
* 2. un'unica transazione con l'import XML, le tabelle delle piantine, il
|
|
* blocco degli account e — per ultimo, ancora dentro — lo scambio dei
|
|
* file. Se lo scambio fallisce si disfa da solo e la transazione si
|
|
* annulla; se fallisce il commit, i file si rimettono a posto qui;
|
|
* 3. a commit avvenuto, si buttano i file precedenti.
|
|
*
|
|
* Prima import, blocco account e file erano tre passi separati: un errore
|
|
* sui file lasciava il database gia' riscritto con il disco a meta', e un
|
|
* errore sul blocco lasciava attive le password del backup.
|
|
*
|
|
* Niente TRUNCATE in nessuno dei passi: su MariaDB e' DDL e fa commit
|
|
* implicito, chiudendo la transazione a meta'. L'import XML e
|
|
* PiantineBackup cancellano con DELETE.
|
|
*/
|
|
public function handle(BackupOperationState $stato, BackupArchive $archivio, XmlExchange $exchange, PiantineBackup $piantine): void
|
|
{
|
|
$stato->markRunning($this->operationId);
|
|
|
|
$staging = null;
|
|
$scambio = null;
|
|
$confermato = false;
|
|
|
|
try {
|
|
$stato->fase($this->operationId, 'Estrazione e verifica dell\'archivio');
|
|
|
|
$estratto = $archivio->extract(
|
|
$this->zipPath,
|
|
fn (int $fatti, int $totale) => $stato->avanza($this->operationId, $fatti, $totale)
|
|
);
|
|
$staging = $estratto['staging'];
|
|
|
|
$piantine->valida($estratto['piantine']);
|
|
|
|
$stato->fase($this->operationId, 'Riscrittura del database', 1);
|
|
|
|
// importXmlFromContent() attribuisce a auth()->id() le assegnazioni
|
|
// il cui autore non e' nel file. Qui non c'e' sessione, quindi
|
|
// l'utente va reimpostato a mano: senza, l'audit finirebbe sul
|
|
// primo id disponibile invece che su chi ha avviato il ripristino.
|
|
//
|
|
// E' anche cio' che tiene dentro chi ripristina: l'import riconosce
|
|
// l'attore e ne conserva hash della password, remember_token e
|
|
// ruolo di amministratore. Con AuthenticateSession attivo, un hash
|
|
// cambiato chiuderebbe la sua sessione e lo costringerebbe a
|
|
// rientrare con la password dell'epoca del backup, che puo' non
|
|
// ricordare. Se il suo account nel backup non c'e', l'import (che
|
|
// fa upsert per email, senza cancellare nessuno) non lo tocca
|
|
// affatto: resta con password e ruoli attuali.
|
|
Auth::onceUsingId($this->actorId);
|
|
|
|
DB::transaction(function () use ($stato, $archivio, $exchange, $piantine, $estratto, &$result, &$esitoPiantine, &$utenti, &$scambio) {
|
|
// La transazione dell'import diventa un savepoint di questa:
|
|
// il suo commit non e' piu' definitivo.
|
|
$result = $exchange->importXmlFromContent($estratto['xml']);
|
|
|
|
if (isset($result['error'])) {
|
|
throw new RuntimeException($result['error']);
|
|
}
|
|
|
|
$esitoPiantine = $piantine->ripristina($estratto['piantine']);
|
|
|
|
$utenti = $this->richiediCambioPasswordATutti();
|
|
|
|
$stato->avanza($this->operationId, 1, 1);
|
|
$stato->fase($this->operationId, 'Sostituzione dei file', 1);
|
|
|
|
$scambio = $archivio->scambiaFile($estratto);
|
|
});
|
|
|
|
$confermato = true;
|
|
$archivio->confermaScambio($scambio);
|
|
|
|
// L'import ricrea ruoli e assegnazioni, ma Spatie tiene in cache la
|
|
// mappa permessi-ruoli: senza questo, i processi che l'hanno gia'
|
|
// caricata continuano a decidere gli accessi con quella di prima
|
|
// del ripristino, finche' la cache non scade da sola.
|
|
app(PermissionRegistrar::class)->forgetCachedPermissions();
|
|
|
|
$stato->avanza($this->operationId, 1, 1);
|
|
} catch (\Throwable $e) {
|
|
$messaggio = $e->getMessage();
|
|
|
|
// Lo scambio era riuscito ma il commit no: il database e' tornato
|
|
// indietro, i file devono seguirlo.
|
|
if ($scambio !== null && ! $confermato) {
|
|
try {
|
|
$archivio->annullaScambio($scambio, $e);
|
|
} catch (\Throwable $annullamento) {
|
|
$messaggio = $annullamento->getMessage();
|
|
}
|
|
}
|
|
|
|
// La transazione annullata non svuota le cache in memoria del
|
|
// processo: Setting terrebbe l'istanza creata dall'import (una
|
|
// riga che non esiste piu') e Spatie i ruoli letti durante l'import.
|
|
Setting::flushCache();
|
|
app(PermissionRegistrar::class)->forgetCachedPermissions();
|
|
|
|
Log::error('Ripristino del backup non riuscito.', ['exception' => $e]);
|
|
$stato->markFailed($this->operationId, $messaggio);
|
|
|
|
return;
|
|
} finally {
|
|
Auth::forgetUser();
|
|
|
|
if ($staging !== null) {
|
|
$archivio->deleteDirectory($staging);
|
|
}
|
|
|
|
@unlink($this->zipPath);
|
|
}
|
|
|
|
$stats = $result['stats'];
|
|
$stats['piantine_ripristinate'] = $esitoPiantine['mappe'];
|
|
$stats['versioni_pdf_ripristinate'] = $esitoPiantine['versioni'];
|
|
$fileRipristinati = $scambio['file'];
|
|
|
|
$messaggio = sprintf(
|
|
'Ripristino completato: %d territori, %d proclamatori, %d assegnazioni, %d piantine e %d file ripristinati. '
|
|
. 'Per sicurezza %s impostare una nuova password.',
|
|
$stats['territori_importati'] ?? 0,
|
|
$stats['proclamatori_importati'] ?? 0,
|
|
$stats['assegnazioni_importate'] ?? 0,
|
|
$esitoPiantine['mappe'],
|
|
$fileRipristinati,
|
|
$utenti === 1 ? 'l\'unico account deve' : 'tutti i ' . $utenti . ' account devono'
|
|
);
|
|
|
|
// Un archivio di formato 1 non conteneva le piantine: va detto, o
|
|
// l'amministratore le cercherebbe senza sapere perche' sono sparite.
|
|
if ($estratto['piantine'] === null) {
|
|
$stato->log(
|
|
$this->operationId,
|
|
'Archivio di un formato precedente: non contiene piantine e storico dei PDF, che restano vuoti. '
|
|
. 'L\'area KML in uso non e\' stata toccata.'
|
|
);
|
|
}
|
|
|
|
// Il messaggio non puo' viaggiare in sessione (qui non ce n'e' una) e la
|
|
// pagina che dovra' mostrarlo non e' questa: appena il flag e' acceso,
|
|
// il middleware dirotta l'amministratore sul cambio password. Lo si
|
|
// lascia in cache a suo nome, e quella schermata lo consuma.
|
|
Cache::put(self::CHIAVE_ESITO . $this->actorId, $messaggio, 3600);
|
|
|
|
$stato->log($this->operationId, $messaggio);
|
|
$stato->markCompleted($this->operationId, [
|
|
'stats' => $stats,
|
|
'issues' => array_slice(array_merge($result['issues'], $esitoPiantine['issues']), 0, 50),
|
|
'file_ripristinati' => $fileRipristinati,
|
|
'messaggio' => $messaggio,
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Vedi CreateBackupArchive::failed(): chiude l'operazione quando il job
|
|
* muore per cause che handle() non intercetta, cosi' il posto unico si
|
|
* libera subito invece di restare occupato fino alla scadenza.
|
|
*
|
|
* Qui il messaggio dice anche in che stato si e' rimasti. Un processo
|
|
* ucciso a meta' non arriva al commit, e il database annulla da se' la
|
|
* transazione rimasta aperta: i dati restano quelli di prima. L'unica
|
|
* finestra scoperta e' quella, di pochi millisecondi, fra lo scambio dei
|
|
* file e il commit — in quel caso i file precedenti sono ancora in
|
|
* storage/app/backup-precedenti/. La strada resta rilanciare il
|
|
* ripristino, non ignorare l'errore.
|
|
*/
|
|
public function failed(?\Throwable $e): void
|
|
{
|
|
app(BackupOperationState::class)->markFailed(
|
|
$this->operationId,
|
|
($e?->getMessage() ?: 'Ripristino interrotto (timeout o errore del worker).')
|
|
. ' Un ripristino interrotto prima della conferma non modifica il database: rilancialo con lo stesso pacchetto. '
|
|
. 'Se i file risultano diversi, quelli precedenti sono in storage/app/backup-precedenti/.'
|
|
);
|
|
|
|
@unlink($this->zipPath);
|
|
}
|
|
|
|
/**
|
|
* Blocca ogni account finche' non sceglie una password nuova,
|
|
* l'amministratore che sta ripristinando compreso.
|
|
*
|
|
* Il pacchetto contiene gli hash bcrypt di tutti gli utenti: chi ha avuto
|
|
* il file fra le mani ha potuto tentarne il crack con calma, quindi dopo un
|
|
* ripristino nessuna delle vecchie password si puo' considerare segreta.
|
|
* Anche i remember_token vengono azzerati: sono credenziali persistenti a
|
|
* tutti gli effetti e stanno pure loro nel backup.
|
|
*
|
|
* Scritto con il query builder di proposito — un update di massa su
|
|
* Eloquent qui non aggiungerebbe nulla e toccherebbe updated_at su tutte le
|
|
* righe appena importate con i loro timestamp originali.
|
|
*
|
|
* @return int Account bloccati. Non e' il valore di ritorno dell'update:
|
|
* MariaDB conta le righe *cambiate*, quindi un utente gia'
|
|
* marcato da un ripristino precedente non comparirebbe e il
|
|
* riepilogo direbbe meno account di quanti ne sono bloccati.
|
|
*/
|
|
private function richiediCambioPasswordATutti(): int
|
|
{
|
|
DB::table('users')->update([
|
|
'password_change_required' => true,
|
|
// Il motivo ora è il ripristino, anche per chi aveva una
|
|
// password temporanea (pagina del cambio password).
|
|
'password_temporanea' => false,
|
|
'remember_token' => null,
|
|
]);
|
|
|
|
return (int) DB::table('users')->count();
|
|
}
|
|
}
|