Rebuild DEEG as a fifth installation, add stepped forms and a plugin system, and clear the review backlog

Forms gained steps, conditions, image choices, number fields with units and a
summary step; the DEEG price finder uses all of it. Plugins are manifest plus
Twig: blocks, settings, containers, routes, presets and theme packs, switched
per installation. The review backlog is done: archive pages render through the
normal page pipeline, forms and post lists work inside areas and sections,
repeated sections get their own ids, breakpoints and colours come from the
palette, backup and update work on MySQL and lock each other out.

The task worker no longer shortens a process that has no time limit:
set_time_limit() sets the limit instead of extending it, which turned an
unlimited CLI run into eighty seconds and killed the full test suite far away
from the scheduler.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/Ops/ArchiveUpdate.php

@@ -127,6 +127,23 @@ final class ArchiveUpdate
             return ['ok' => true, 'steps' => $schritte];
         }
 
+        $lock = $this->updater->lock();
+        if (null === $lock) {
+            $melden($schritte, 'Sperre', false, 'Ein anderes Update läuft gerade (var/update.lock). Bitte warten.');
+
+            return ['ok' => false, 'steps' => $schritte];
+        }
+        try {
+            return $this->apply($schritte, $melden, $ziel, $neueste);
+        } finally {
+            flock($lock, LOCK_UN);
+            fclose($lock);
+        }
+    }
+
+    /** Der Teil des Updates, der die Installation veraendert - unter der Sperre. */
+    private function apply(array &$schritte, callable $melden, string $ziel, array $neueste): array
+    {
         $arbeit = $this->root.'/var/update/'.gmdate('Ymd-His');
         if (!@mkdir($arbeit, 0o775, true) && !is_dir($arbeit)) {
             $melden($schritte, 'Arbeitsordner', false, $arbeit.' ließ sich nicht anlegen. Fehlt das Schreibrecht auf var/?');
@@ -145,14 +162,14 @@ final class ArchiveUpdate
         }
 
         $archiv = $arbeit.'/kantsites-'.$ziel.'.zip';
-        $inhalt = $this->download->get(sprintf('%s/v%s/kantsites-%s.zip', $this->releaseBase, $ziel, $ziel));
-        if (null === $inhalt || '' === $inhalt) {
+        // Direkt in die Datei, nicht erst als Zeichenkette in den Speicher: ein Archiv von einigen
+        // Megabyte passte in memory_limit, ein groesseres nicht mehr.
+        if (!$this->download->toFile(sprintf('%s/v%s/kantsites-%s.zip', $this->releaseBase, $ziel, $ziel), $archiv)) {
             $melden($schritte, 'Archiv laden', false, trim('Das Archiv ließ sich nicht herunterladen. '.$this->download->reason()));
 
             return ['ok' => false, 'steps' => $schritte];
         }
-        file_put_contents($archiv, $inhalt);
-        $melden($schritte, 'Archiv laden', true, sprintf('%d KB geladen.', (int) round(strlen($inhalt) / 1024)));
+        $melden($schritte, 'Archiv laden', true, sprintf('%d KB geladen.', (int) round((int) filesize($archiv) / 1024)));
 
         $erwartet = $ziel === $neueste['version'] ? $neueste['checksum'] : $this->checksumOf(sprintf('%s/v%s/kantsites-%s.zip.sha256', $this->releaseBase, $ziel, $ziel));
         if (null === $erwartet) {
@@ -204,6 +221,9 @@ final class ArchiveUpdate
             // public/ wird Datei für Datei aktualisiert: Schriften und erzeugte Bündel gehören dem
             // Betreiber und wären sonst weg.
             $this->mergePublic($quelle.'/public', $this->root.'/public');
+            // Ebenso plugins/: die mitgelieferten Plugins werden aktualisiert, ein vom Betreiber
+            // installiertes Plugin bleibt, weil sein Ordner im Archiv nicht vorkommt.
+            $this->mergePublic($quelle.'/plugins', $this->root.'/plugins');
         } catch (\Throwable $fehler) {
             foreach (self::ERSETZEN as $eintrag) {
                 if (is_dir($alt.'/'.$eintrag) || is_file($alt.'/'.$eintrag)) {
@@ -286,8 +306,9 @@ final class ArchiveUpdate
         @unlink($this->root.'/'.self::MARKE);
         $this->updater->maintenance(false);
         $this->protokoll('ok     Migrationen: '.$schritte[0]['detail']);
+        $schritte[] = ['step' => 'Aufräumen', 'ok' => true, 'detail' => $this->aufraeumen()];
         $schritte[] = ['step' => 'Fertig', 'ok' => true, 'detail' => sprintf(
-            'Fassung %s läuft. Der vorherige Stand liegt unter var/update/, bis du ihn löschst.',
+            'Fassung %s läuft. Der vorherige Stand liegt unter var/update/ (die zwei jüngsten bleiben).',
             $this->updater->version(),
         )];
 
@@ -327,10 +348,69 @@ final class ArchiveUpdate
 
                 continue;
             }
+            if ('.htaccess' === $eintrag && is_file($ziel)) {
+                $this->mergeHtaccess($quelle, $ziel);
+
+                continue;
+            }
             @copy($quelle, $ziel);
         }
     }
 
+    /**
+     * Die neue .htaccess uebernehmen, aber die Zeilen, die der Betreiber eingeschaltet hat,
+     * eingeschaltet lassen: HTTPS-Zwang und HSTS. Vorher kam jedes Update mit den auskommentierten
+     * Zeilen des Releases zurueck, und die Website lief nach dem Update wieder ohne Umleitung.
+     */
+    private function mergeHtaccess(string $neu, string $alt): void
+    {
+        $vorher = (string) file_get_contents($alt);
+        $inhalt = (string) file_get_contents($neu);
+        foreach (['RewriteCond %{HTTPS} !=on', 'RewriteCond %{HTTP:X-Forwarded-Proto} !=https', 'RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L]', 'Header always set Strict-Transport-Security'] as $zeile) {
+            $aktiv = 1 === preg_match('/^\s*'.preg_quote($zeile, '/').'/m', $vorher);
+            if ($aktiv) {
+                $inhalt = (string) preg_replace('/^(\s*)#\s*('.preg_quote($zeile, '/').')/m', '$1$2', $inhalt);
+            }
+        }
+        file_put_contents($alt, $inhalt);
+    }
+
+    /**
+     * Raeumt nach einem gelungenen Update auf: die Arbeitsordner unter var/update/ bis auf die
+     * zwei juengsten, und die Zwischenspeicher frueherer Fassungen unter var/cache/. Beides wuchs
+     * vorher mit jedem Update, bis der Speicherplatz des Hostings voll war.
+     */
+    private function aufraeumen(): string
+    {
+        $entfernt = 0;
+        $ordner = glob($this->root.'/var/update/*', GLOB_ONLYDIR) ?: [];
+        rsort($ordner);
+        foreach (array_slice($ordner, 2) as $pfad) {
+            $this->loeschen($pfad);
+            ++$entfernt;
+        }
+        $aktuell = 'release-'.substr(hash_file('sha256', $this->root.'/VERSION') ?: '', 0, 16);
+        foreach (glob($this->root.'/var/cache/*/release-*', GLOB_ONLYDIR) ?: [] as $pfad) {
+            if (basename($pfad) !== $aktuell) {
+                $this->loeschen($pfad);
+                ++$entfernt;
+            }
+        }
+
+        return 0 === $entfernt ? 'Nichts aufzuräumen.' : sprintf('%d alte Ordner unter var/update und var/cache entfernt.', $entfernt);
+    }
+
+    private function loeschen(string $pfad): void
+    {
+        foreach (scandir($pfad) ?: [] as $eintrag) {
+            if ('.' === $eintrag || '..' === $eintrag) {
+                continue;
+            }
+            is_dir($pfad.'/'.$eintrag) && !is_link($pfad.'/'.$eintrag) ? $this->loeschen($pfad.'/'.$eintrag) : @unlink($pfad.'/'.$eintrag);
+        }
+        @rmdir($pfad);
+    }
+
     /** Liest die Prüfsumme aus der Datei neben dem Archiv. */
     private function checksumOf(string $url): ?string
     {

src/Ops/Backup.php

@@ -172,14 +172,22 @@ final class Backup
 
         $file = $this->databaseFile();
         if (null === $file) {
-            $step($steps, 'Datenbank zurückschreiben', false, 'Diese Installation nutzt keine Dateidatenbank. Für MySQL fehlt das Einspielen noch (siehe docs/UPDATE.md).');
+            // MySQL: der Dump wird mit dem Client eingespielt - derselbe Weg, den man von Hand
+            // gehen wuerde, nur ohne Tippfehler in der Verbindung.
+            try {
+                $this->loadMysql($path.'/'.(string) ($manifest['datenbank']['datei'] ?? 'datenbank.sql'));
+                $step($steps, 'Datenbank zurückschreiben', true, 'Der Dump wurde mit dem MySQL-Client eingespielt.');
+            } catch (InvalidPage $fehler) {
+                $step($steps, 'Datenbank zurückschreiben', false, $fehler->getMessage());
 
-            return ['steps' => $steps, 'ok' => false];
-        }
-        $this->db->close();
-        $copied = @copy($path.'/'.basename($file), $file);
-        if (!$step($steps, 'Datenbank zurückschreiben', $copied, $copied ? basename($file).' ersetzt.' : 'Die Datei ließ sich nicht ersetzen.')) {
-            return ['steps' => $steps, 'ok' => false];
+                return ['steps' => $steps, 'ok' => false];
+            }
+        } else {
+            $this->db->close();
+            $copied = @copy($path.'/'.basename($file), $file);
+            if (!$step($steps, 'Datenbank zurückschreiben', $copied, $copied ? basename($file).' ersetzt.' : 'Die Datei ließ sich nicht ersetzen.')) {
+                return ['steps' => $steps, 'ok' => false];
+            }
         }
 
         // Media are added, never deleted: files uploaded after the backup would otherwise be lost
@@ -216,10 +224,7 @@ final class Backup
     {
         $file = $this->databaseFile();
         if (null === $file) {
-            if (!$this->runner->has('mysqldump', $this->root)) {
-                throw new InvalidPage('Diese Installation nutzt keine Dateidatenbank, und mysqldump ist nicht aufrufbar. Ohne eines von beiden gibt es keine Sicherung.');
-            }
-            throw new InvalidPage('Sicherung über mysqldump ist noch nicht umgesetzt (Arbeitspaket J).');
+            return $this->dumpMysql($directory);
         }
         $target = $directory.'/'.basename($file);
         // VACUUM INTO statt copy(): Eine Kopie, die waehrend eines Schreibvorgangs entsteht, kann
@@ -366,6 +371,86 @@ final class Backup
         @rmdir($path);
     }
 
+    /**
+     * Die Verbindungsdaten einer MySQL/MariaDB-Adresse, oder null bei einer Dateidatenbank.
+     *
+     * @return array{host: string, port: string, user: string, password: string, name: string}|null
+     */
+    private function mysqlConnection(): ?array
+    {
+        if (1 !== preg_match('#^(mysql|mariadb)://#', $this->databaseUrl)) {
+            return null;
+        }
+        $teile = parse_url($this->databaseUrl);
+        if (!is_array($teile) || '' === trim((string) ($teile['path'] ?? ''), '/')) {
+            return null;
+        }
+
+        return [
+            'host' => (string) ($teile['host'] ?? '127.0.0.1'), 'port' => (string) ($teile['port'] ?? 3306),
+            'user' => rawurldecode((string) ($teile['user'] ?? '')), 'password' => rawurldecode((string) ($teile['pass'] ?? '')),
+            'name' => trim((string) $teile['path'], '/'),
+        ];
+    }
+
+    /** @return list<string> die Verbindungsargumente fuer mysqldump und mysql */
+    private function mysqlArguments(array $verbindung): array
+    {
+        $args = ['--host='.$verbindung['host'], '--port='.$verbindung['port'], '--user='.$verbindung['user']];
+        if ('' !== $verbindung['password']) {
+            // Als Argument, nicht als Umgebungsvariable: der Befehlslaeufer startet mit einer
+            // festen Umgebung. Das Argument ist fuer andere Nutzer des Servers kurz sichtbar -
+            // wie bei jedem mysqldump-Aufruf von Hand.
+            $args[] = '--password='.$verbindung['password'];
+        }
+
+        return $args;
+    }
+
+    /** @return array{datei: string, bytes: int, sha256: string} */
+    private function dumpMysql(string $directory): array
+    {
+        $verbindung = $this->mysqlConnection();
+        if (null === $verbindung) {
+            throw new InvalidPage('Die Datenbankadresse ist weder eine SQLite-Datei noch eine MySQL-Verbindung.');
+        }
+        $dump = $this->runner->resolve('mysqldump', $this->root);
+        if (null === $dump) {
+            throw new InvalidPage('Diese Installation nutzt MySQL, und mysqldump ist nicht aufrufbar. Ohne den Client gibt es keine Sicherung - beim Hoster nach dem Pfad fragen.');
+        }
+        $target = $directory.'/datenbank.sql';
+        // --single-transaction: ein konsistenter Stand ohne Sperre der Tabellen; --result-file:
+        // direkt in die Datei, nicht durch den Speicher dieses Prozesses.
+        $ergebnis = $this->runner->run([...$dump, ...$this->mysqlArguments($verbindung), '--single-transaction', '--quick', '--skip-lock-tables', '--routines', '--result-file='.$target, $verbindung['name']], $this->root, 900);
+        if (!$ergebnis['ok'] || !is_readable($target) || 0 === (int) filesize($target)) {
+            @unlink($target);
+            throw new InvalidPage('mysqldump ist gescheitert: '.trim($ergebnis['output']));
+        }
+
+        return ['datei' => 'datenbank.sql', 'bytes' => (int) filesize($target), 'sha256' => (string) hash_file('sha256', $target)];
+    }
+
+    /** Spielt einen Dump mit dem MySQL-Client ein. @throws InvalidPage */
+    private function loadMysql(string $dump): void
+    {
+        $verbindung = $this->mysqlConnection();
+        if (null === $verbindung) {
+            throw new InvalidPage('Die Datenbankadresse ist keine MySQL-Verbindung.');
+        }
+        if (!is_readable($dump)) {
+            throw new InvalidPage('Der Dump fehlt in der Sicherung: '.basename($dump));
+        }
+        $client = $this->runner->resolve('mysql', $this->root);
+        if (null === $client) {
+            throw new InvalidPage('Der MySQL-Client (mysql) ist nicht aufrufbar; der Dump liegt unter '.$dump.' und lässt sich von Hand einspielen.');
+        }
+        $this->db->close();
+        $ergebnis = $this->runner->run([...$client, ...$this->mysqlArguments($verbindung), '--database='.$verbindung['name'], '--execute=source '.str_replace('\\', '/', $dump)], $this->root, 900);
+        if (!$ergebnis['ok']) {
+            throw new InvalidPage('Der MySQL-Client hat den Dump nicht eingespielt: '.trim($ergebnis['output']));
+        }
+    }
+
     private function databaseFile(): ?string
     {
         if (!str_starts_with($this->databaseUrl, 'sqlite:')) {

src/Ops/Download.php

@@ -46,6 +46,66 @@ class Download
         return $this->grund;
     }
 
+    /**
+     * Holt die Adresse direkt in eine Datei - fuer Archive, die nicht als Zeichenkette in den
+     * Speicher passen sollen. Ohne curl geht es ueber get(); dann ist der Speicher die Grenze.
+     */
+    public function toFile(string $url, string $path): bool
+    {
+        $this->grund = '';
+        if (!str_starts_with($url, 'https://')) {
+            $this->grund = 'Nur HTTPS-Adressen werden geholt.';
+
+            return false;
+        }
+        if (function_exists('curl_init')) {
+            $datei = @fopen($path, 'w');
+            if (!is_resource($datei)) {
+                $this->grund = 'Die Zieldatei ließ sich nicht anlegen: '.$path;
+
+                return false;
+            }
+            $curl = curl_init($url);
+            curl_setopt_array($curl, [
+                CURLOPT_FILE => $datei,
+                CURLOPT_FOLLOWLOCATION => true,
+                CURLOPT_MAXREDIRS => 3,
+                CURLOPT_PROTOCOLS => CURLPROTO_HTTPS,
+                CURLOPT_REDIR_PROTOCOLS => CURLPROTO_HTTPS,
+                CURLOPT_SSL_VERIFYPEER => true,
+                CURLOPT_SSL_VERIFYHOST => 2,
+                CURLOPT_CONNECTTIMEOUT => $this->connectTimeout,
+                CURLOPT_TIMEOUT => $this->timeout,
+                CURLOPT_USERAGENT => 'KantSites-Updater',
+            ]);
+            $ok = curl_exec($curl);
+            $status = curl_getinfo($curl, CURLINFO_RESPONSE_CODE);
+            $fehler = curl_errno($curl);
+            $text = curl_error($curl);
+            curl_close($curl);
+            fclose($datei);
+            if (true === $ok && 200 === $status && (int) filesize($path) > 0) {
+                return true;
+            }
+            @unlink($path);
+            if (!in_array($fehler, self::ZERTIFIKATSFEHLER, true)) {
+                $this->grund = match (true) {
+                    0 !== $fehler => 'Die Verbindung kam nicht zustande: '.$text,
+                    0 === $status => 'Der Server hat nicht geantwortet.',
+                    default => sprintf('Die Adresse antwortet mit %d statt 200.', $status),
+                };
+
+                return false;
+            }
+        }
+        $inhalt = $this->get($url);
+        if (null === $inhalt || '' === $inhalt) {
+            return false;
+        }
+
+        return false !== file_put_contents($path, $inhalt);
+    }
+
     /** Den Inhalt der Adresse, oder null wenn sie nicht mit 200 antwortet. */
     public function get(string $url): ?string
     {

src/Ops/Updater.php

@@ -24,15 +24,46 @@ final class Updater
     public const MAINTENANCE_FILE = 'var/maintenance';
     public const LOG_FILE = 'var/updates.log';
 
+    /** Eine Datei, die waehrend eines Updates gesperrt ist - Git-Weg und Archiv-Weg teilen sie sich. */
+    public const LOCK_FILE = 'var/update.lock';
+
+    /** Der Name der Sicherung, die vor dem Update entstand - der Rueckweg spielt sie ein. */
+    private ?string $backupName = null;
+
     public function __construct(
         private string $root,
         private string $databaseUrl,
         private CommandRunner $runner,
         private Connection $db,
         private ?string $php = null,
+        private ?Backup $backups = null,
     ) {
     }
 
+    /**
+     * Sperrt Updates gegeneinander. Zwei Klicks auf "Aktualisieren", ein Cronjob neben der
+     * Verwaltung, der Archiv-Weg neben dem Git-Weg: jeder zweite Lauf bekommt null und faengt
+     * nichts an. Die Sperre faellt mit dem Handle, also spaetestens mit dem Prozess.
+     *
+     * @return resource|null
+     */
+    public function lock(): mixed
+    {
+        $file = $this->root.'/'.self::LOCK_FILE;
+        @mkdir(dirname($file), 0o775, true);
+        $handle = @fopen($file, 'c');
+        if (!is_resource($handle)) {
+            return null;
+        }
+        if (!flock($handle, LOCK_EX | LOCK_NB)) {
+            fclose($handle);
+
+            return null;
+        }
+
+        return $handle;
+    }
+
     /** The version that is installed, from the file that ships inside the tag. */
     public function version(): string
     {
@@ -224,6 +255,21 @@ final class Updater
         }
 
         // ---- from here on the installation is being changed ----
+        $lock = $this->lock();
+        if (!$step($steps, 'Sperre', null !== $lock, null !== $lock ? 'Kein anderes Update läuft.' : 'Ein anderes Update läuft gerade (var/update.lock). Bitte warten.')) {
+            return ['ok' => false, 'steps' => $steps, 'target' => $target];
+        }
+        try {
+            return $this->apply($steps, $step, $target, $from, $lockBefore);
+        } finally {
+            flock($lock, LOCK_UN);
+            fclose($lock);
+        }
+    }
+
+    /** Der Teil des Updates, der die Installation veraendert - unter der Sperre. */
+    private function apply(array &$steps, callable $step, string $target, string $from, string $lockBefore): array
+    {
         $backup = $this->backup();
         if (!$step($steps, 'Sicherung', null !== $backup, $backup ?? 'Die Datenbank ließ sich nicht sichern. Ohne Sicherung wird nicht aktualisiert.')) {
             return ['ok' => false, 'steps' => $steps, 'target' => $target];
@@ -350,7 +396,19 @@ final class Updater
         }
         $step($steps, 'Zurück auf den alten Stand', $back['ok'], $back['ok'] ? 'Auf '.substr($commit, 0, 8).' zurückgesetzt.' : $back['output']);
 
-        if (null !== $backup && null !== $this->databaseFile()) {
+        if (null !== $backup && null !== $this->backupName && null !== $this->backups) {
+            // Ueber die Sicherung, nicht ueber eine rohe Kopie: derselbe konsistente Weg fuer
+            // SQLite (VACUUM INTO) und MySQL (Dump und Client).
+            $restored = $this->backups->restore($this->backupName, true)['ok'];
+            $step($steps, 'Datenbank zurückschreiben', $restored, $restored
+                ? 'Die Sicherung von vor der Migration ist wieder eingespielt.'
+                : 'Die Sicherung ließ sich nicht zurückschreiben. Sie liegt unter var/backups/'.$this->backupName.'.');
+            if (!$restored) {
+                $step($steps, 'Wartungszustand bleibt', false, 'Die Datenbank konnte nicht wiederhergestellt werden. Der Betrieb bleibt angehalten.');
+
+                return;
+            }
+        } elseif (null !== $backup && null !== $this->databaseFile()) {
             $file = $this->databaseFile();
             $copy = $this->backupDirectory.'/'.basename((string) $file);
             $restored = is_readable($copy) && @copy($copy, (string) $file);
@@ -398,6 +456,17 @@ final class Updater
     private function backup(): ?string
     {
         $this->backupDirectory = null;
+        $this->backupName = null;
+        if (null !== $this->backups) {
+            try {
+                $sicherung = $this->backups->create('vor dem Update');
+                $this->backupName = $sicherung['name'];
+
+                return sprintf('var/backups/%s (Datenbank %s, Medien %d Datei(en)).', $sicherung['name'], $this->bytes((int) ($sicherung['manifest']['datenbank']['bytes'] ?? 0)), (int) ($sicherung['manifest']['medien']['dateien'] ?? 0));
+            } catch (\Throwable) {
+                return null;
+            }
+        }
         $directory = $this->root.'/var/backups/update-'.gmdate('Ymd-His').'-'.bin2hex(random_bytes(4));
         if (!@mkdir($directory, 0o700, true)) {
             return null;