Fassung 1.6.0: der Aufgabenplan wird veroeffentlicht
Wiederkehrende Aufgaben ohne Cronjob (ADR 073): Sicherung, Statistik kuerzen, geplante Veroeffentlichung, Updatepruefung und Aufraeumen laufen als Plan in der Tabelle scheduled_task - eine Zeile je Aufgabe mit Faelligkeit, Sperre und letztem Ergebnis. Auf geteiltem Hosting gibt es oft keinen Cronjob; der Plan haengt stattdessen an Anfragen und an einem Takt aus dem geoeffneten Backend. Diese Arbeit entstand in einer parallel laufenden Sitzung und lag bis hierher unveroeffentlicht im Arbeitsverzeichnis: die Releases 1.5.0 bis 1.5.5 wurden bewusst aus dem jeweiligen Tag gebaut und enthielten sie deshalb nicht. Vor der Veroeffentlichung geprueft, nicht bloss eingepackt: - phpunit 452/452, npm test 28/28, npm run test:editor vollstaendig. - Die Migration 20260914000100 legt nur die Tabelle scheduled_task an und nimmt sie beim Zurueckrollen wieder weg. Sie fasst keine bestehenden Daten an. - Seit einer Stunde keine Schreibzugriffe der anderen Sitzung mehr. Dabei zwei Fehler behoben: - config/services.yaml verwendet !tagged_iterator. Das ist gueltiges Symfony, aber "lint:yaml config" kennt eigene Tags nur mit --parse-tags und gab 1 zurueck - der CI-Lauf waere daran gescheitert. Flag ergaenzt. - AdminHeadersSubscriber.php (aus 1.5.3) entsprach nicht dem Stil von php-cs-fixer; composer lint gab 8 zurueck. Behoben. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
kantarciandClaude Opus 5 committed
1 parent
d1ac9d760b
commit
05ea703655
35 files changed
+2229
-13
No files matched your search
@@ -36,7 +36,7 @@ final class ArchiveUpdate
|
||||
* ersetzt" und „Migrationen" aus - Zeitüberschreitung, anderer Browser, anderer Rechner -,
|
||||
* bliebe die Website sonst im Wartungszustand und der Knopf, der sie herausholt, wäre weg.
|
||||
*/
|
||||
private const MARKE = 'var/update/offen.json';
|
||||
public const MARKE = 'var/update/offen.json';
|
||||
|
||||
/** Das Protokoll - dieselbe Datei, in die auch der Updater über Git schreibt. */
|
||||
private const PROTOKOLL = 'var/updates.log';
|
||||
|
||||
@@ -0,0 +1,498 @@
|
||||
<?php
|
||||
|
||||
namespace App\Ops;
|
||||
|
||||
use App\Ops\Tasks\Task;
|
||||
use Doctrine\DBAL\Connection;
|
||||
use Doctrine\DBAL\Exception\TableNotFoundException;
|
||||
|
||||
/**
|
||||
* Wiederkehrende Aufgaben auf einem Hosting, das keinen Cronjob hat.
|
||||
*
|
||||
* Das Problem ist nicht, *was* zu tun ist, sondern *wer es anstoesst*. Auf geteiltem Webhosting
|
||||
* gibt es oft weder SSH noch Cron; es gibt nur Anfragen. Also uebernehmen die Anfragen die
|
||||
* Arbeit - nach der Antwort, in `kernel.terminate`, damit kein Besucher darauf wartet. Vier
|
||||
* Ausloeser, dieselbe Mechanik:
|
||||
*
|
||||
* - **Besuch:** jeder Seitenaufruf schaut nach, ob etwas faellig ist (`TaskWorkerSubscriber`).
|
||||
* - **Verwaltung:** das geoeffnete Backend fragt im Takt nach, auch ohne Besucher.
|
||||
* - **URL-Cron:** ein Aufruf von `/cms-cron/<Schluessel>`, wenn der Hoster das anbietet.
|
||||
* - **Konsole:** `cms:tasks:run`, auch als Dauerlaeufer mit `--loop`.
|
||||
*
|
||||
* Was das *nicht* kann, und das gehoert an diese Stelle und nicht ins Kleingedruckte: **ohne
|
||||
* Anfrage passiert nichts.** Eine Aufgabe fuer 03:00 Uhr laeuft beim ersten Aufruf danach, auf
|
||||
* einer stillen Website also vielleicht um 07:15 Uhr. Fuer Sitemap, Aufraeumen, Updatepruefung
|
||||
* und Sicherung ist das brauchbar; fuer etwas, das minutengenau sein muss, ist es das nicht.
|
||||
*
|
||||
* Zwei Eigenschaften machen das im Betrieb tragfaehig:
|
||||
*
|
||||
* 1. **Der Normalfall kostet keine Datenbankabfrage.** In `var/scheduler.json` steht, wann das
|
||||
* naechste Mal ueberhaupt etwas ansteht. Solange dieser Zeitpunkt in der Zukunft liegt, ist
|
||||
* ein Seitenaufruf mit einem `file_get_contents` fertig.
|
||||
* 2. **Zwei Besucher fuehren eine Aufgabe nicht zweimal aus.** Wer sie ausfuehren darf, wird mit
|
||||
* einem bedingten UPDATE entschieden - das ist auf MySQL wie auf SQLite atomar. Wer keine
|
||||
* Zeile veraendert hat, war zu spaet und geht weiter.
|
||||
*/
|
||||
final class Scheduler
|
||||
{
|
||||
public const STATE_FILE = 'var/scheduler.json';
|
||||
public const LOG_FILE = 'var/tasks.log';
|
||||
|
||||
/**
|
||||
* Wie lange eine begonnene Aufgabe als laufend gilt.
|
||||
*
|
||||
* Es gibt keinen Weg, das Ende eines Prozesses zu erfahren, den das Hosting mitten im Lauf
|
||||
* abgeschossen hat. Also verfaellt die Sperre von selbst. Fuenfzehn Minuten sind lang genug
|
||||
* fuer eine Sicherung und kurz genug, dass eine haengengebliebene Aufgabe denselben Tag
|
||||
* wieder mitmacht.
|
||||
*/
|
||||
public const LOCK_SECONDS = 900;
|
||||
|
||||
/** Obergrenze fuer den wachsenden Abstand nach Fehlschlaegen: sechs Stunden. */
|
||||
private const MAX_BACKOFF = 21600;
|
||||
|
||||
/** So viele Zeilen behaelt das Protokoll beim Kuerzen. */
|
||||
private const LOG_LINES = 200;
|
||||
|
||||
/** @var array<string, Task>|null */
|
||||
private ?array $registry = null;
|
||||
|
||||
/** @param iterable<Task> $tasks */
|
||||
public function __construct(
|
||||
private Connection $db,
|
||||
private iterable $tasks,
|
||||
private string $projectDir,
|
||||
) {
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Ausfuehren
|
||||
|
||||
/**
|
||||
* Fuehrt aus, was faellig ist - hoechstens `$limit` Aufgaben und hoechstens `$budget` Sekunden.
|
||||
*
|
||||
* Beide Grenzen sind da, weil dieser Aufruf in einer Webanfrage stecken kann. Sie werden
|
||||
* *zwischen* zwei Aufgaben geprueft, nicht innerhalb einer: eine laufende Sicherung
|
||||
* abzubrechen waere schlimmer, als sie zu Ende laufen zu lassen.
|
||||
*
|
||||
* @return list<array{name: string, label: string, status: string, message: string, ms: int}>
|
||||
*/
|
||||
public function runDue(string $trigger, int $limit = 3, int $budget = 20, ?\DateTimeImmutable $now = null): array
|
||||
{
|
||||
$now ??= self::now();
|
||||
$registry = $this->registry();
|
||||
$rows = $this->rows();
|
||||
// Nach einem Update kennt der Code eine Aufgabe mehr oder eine weniger als die Datenbank.
|
||||
// Das faellt hier auf, und zwar ohne eine zusaetzliche Abfrage.
|
||||
if (array_keys($rows) !== array_keys($registry)) {
|
||||
if (!$this->sync($now)) {
|
||||
return [];
|
||||
}
|
||||
$rows = $this->rows();
|
||||
}
|
||||
$started = microtime(true);
|
||||
$results = [];
|
||||
foreach ($this->due($rows, $now) as $row) {
|
||||
if (count($results) >= $limit || microtime(true) - $started > $budget) {
|
||||
break;
|
||||
}
|
||||
if (!$this->claim((string) $row['name'], $now)) {
|
||||
// Ein anderer Prozess war schneller. Das ist kein Fehler, das ist der Zweck.
|
||||
continue;
|
||||
}
|
||||
$results[] = $this->execute($registry[(string) $row['name']], $row, $trigger, self::now());
|
||||
}
|
||||
$this->refreshState();
|
||||
|
||||
return $results;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fuehrt eine Aufgabe sofort aus, unabhaengig von ihrem Zeitplan.
|
||||
*
|
||||
* Der Knopf "Jetzt ausfuehren" in der Verwaltung. Abgeschaltete Aufgaben laufen so trotzdem -
|
||||
* wer sie von Hand startet, meint sie auch. Die Sperre gilt aber weiter: zweimal derselbe
|
||||
* Klick soll nicht zwei Sicherungen anlegen.
|
||||
*
|
||||
* Gibt null zurueck, wenn es die Aufgabe nicht gibt oder sie gerade schon laeuft.
|
||||
*
|
||||
* @return array{name: string, label: string, status: string, message: string, ms: int}|null
|
||||
*/
|
||||
public function runNow(string $name, string $trigger = 'hand'): ?array
|
||||
{
|
||||
$now = self::now();
|
||||
$registry = $this->registry();
|
||||
if (!isset($registry[$name])) {
|
||||
return null;
|
||||
}
|
||||
$this->sync($now);
|
||||
$rows = $this->rows();
|
||||
if (!isset($rows[$name]) || !$this->claim($name, $now, false)) {
|
||||
return null;
|
||||
}
|
||||
$result = $this->execute($registry[$name], $rows[$name], $trigger, self::now());
|
||||
$this->refreshState();
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sichert sich eine Aufgabe.
|
||||
*
|
||||
* Der ganze Schutz gegen doppelte Ausfuehrung steckt in dieser einen Anweisung: die
|
||||
* Bedingungen stehen im WHERE, nicht in PHP. Zwischen einem `SELECT ... WHERE faellig` und
|
||||
* einem `UPDATE` liegt ein Moment, in dem ein zweiter Prozess dasselbe liest - hier nicht.
|
||||
* Wer 1 zurueckbekommt, hat sie; wer 0 zurueckbekommt, war zu spaet.
|
||||
*/
|
||||
private function claim(string $name, \DateTimeImmutable $now, bool $onlyWhenDue = true): bool
|
||||
{
|
||||
$stamp = $now->format('Y-m-d H:i:s');
|
||||
$until = $now->modify('+'.self::LOCK_SECONDS.' seconds')->format('Y-m-d H:i:s');
|
||||
$sql = 'UPDATE scheduled_task SET locked_until = ?, last_run_at = ? WHERE name = ? AND (locked_until IS NULL OR locked_until <= ?)';
|
||||
$parameters = [$until, $stamp, $name, $stamp];
|
||||
if ($onlyWhenDue) {
|
||||
$sql .= ' AND next_run_at <= ?';
|
||||
$parameters[] = $stamp;
|
||||
}
|
||||
|
||||
try {
|
||||
return 1 === $this->db->executeStatement($sql, $parameters);
|
||||
} catch (\Throwable) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param array<string, mixed> $row
|
||||
*
|
||||
* @return array{name: string, label: string, status: string, message: string, ms: int}
|
||||
*/
|
||||
private function execute(Task $task, array $row, string $trigger, \DateTimeImmutable $now): array
|
||||
{
|
||||
$begin = microtime(true);
|
||||
try {
|
||||
$message = trim($task->run());
|
||||
$status = 'ok';
|
||||
$failures = 0;
|
||||
} catch (\Throwable $error) {
|
||||
// Auch ein Fehler ist ein Ergebnis. Er steht in der Zeile, im Protokoll und auf dem
|
||||
// Bildschirm "Aufgaben" - und er verlaengert den Abstand bis zum naechsten Versuch,
|
||||
// damit eine Aufgabe, die nicht laufen *kann*, nicht bei jedem Aufruf neu anfaengt.
|
||||
$status = 'fehler';
|
||||
$message = sprintf('%s (%s:%d)', $error->getMessage(), basename($error->getFile()), $error->getLine());
|
||||
$failures = (int) $row['failures'] + 1;
|
||||
}
|
||||
$ms = (int) round((microtime(true) - $begin) * 1000);
|
||||
$interval = max(60, (int) $row['interval_seconds']);
|
||||
$delay = 'ok' === $status
|
||||
? $interval
|
||||
: (int) min(self::MAX_BACKOFF, $interval * 2 ** min($failures, 6));
|
||||
$message = '' === $message ? 'Erledigt.' : mb_substr($message, 0, 480);
|
||||
|
||||
try {
|
||||
$this->db->executeStatement(
|
||||
'UPDATE scheduled_task SET next_run_at = ?, last_status = ?, last_message = ?, last_duration_ms = ?, last_trigger = ?, failures = ?, locked_until = NULL WHERE name = ?',
|
||||
[
|
||||
$now->modify('+'.$delay.' seconds')->format('Y-m-d H:i:s'),
|
||||
$status, $message, $ms, $trigger, $failures, $task->name(),
|
||||
],
|
||||
);
|
||||
} catch (\Throwable) {
|
||||
// Die Aufgabe ist gelaufen; nur das Nachtragen ging schief. Die Sperre verfaellt von
|
||||
// selbst, und das Protokoll unten haelt fest, was passiert ist.
|
||||
}
|
||||
$this->append(sprintf(
|
||||
'[%s] %-14s %-7s %6d ms %-11s %s',
|
||||
$now->format('Y-m-d H:i:s'),
|
||||
$task->name(),
|
||||
$status,
|
||||
$ms,
|
||||
$trigger,
|
||||
str_replace(["\r", "\n"], ' ', $message),
|
||||
));
|
||||
|
||||
return ['name' => $task->name(), 'label' => $task->label(), 'status' => $status, 'message' => $message, 'ms' => $ms];
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Zustand und Verwaltung
|
||||
|
||||
/**
|
||||
* Der schnelle Blick, ohne Datenbank: darf der Besuchs- beziehungsweise Backend-Ausloeser
|
||||
* arbeiten, und wann steht ueberhaupt das naechste Mal etwas an?
|
||||
*
|
||||
* Fehlt die Datei - frische Installation, geleertes `var/`, kein Schreibrecht -, ist die
|
||||
* Antwort "ja, und der Zeitpunkt ist unbekannt". Dann fragt der naechste Aufruf die
|
||||
* Datenbank und schreibt sie neu. Der teure Weg ist der Ausnahmefall, nicht der Normalfall.
|
||||
*
|
||||
* @return array{traffic: bool, admin: bool, next: ?int}
|
||||
*/
|
||||
public function fastState(): array
|
||||
{
|
||||
$raw = @file_get_contents($this->projectDir.'/'.self::STATE_FILE);
|
||||
$data = is_string($raw) ? json_decode($raw, true) : null;
|
||||
if (!is_array($data)) {
|
||||
return ['traffic' => true, 'admin' => true, 'next' => null];
|
||||
}
|
||||
|
||||
return [
|
||||
'traffic' => (bool) ($data['traffic'] ?? true),
|
||||
'admin' => (bool) ($data['admin'] ?? true),
|
||||
'next' => isset($data['next']) ? (int) $data['next'] : null,
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Der Schluessel fuer den URL-Cronjob, abgeleitet aus dem Anwendungsgeheimnis.
|
||||
*
|
||||
* Nicht in der Datenbank, weil er dann eine Migration, eine Oberflaeche zum Wechseln und
|
||||
* einen Weg braeuchte, ihn nach einem Restore wiederzufinden. So ist er auf jeder
|
||||
* Installation ein anderer, ueberlebt jedes Update und wechselt genau dann, wenn das
|
||||
* Geheimnis wechselt - also dann, wenn man ihn wechseln will.
|
||||
*/
|
||||
public static function cronToken(string $secret): string
|
||||
{
|
||||
return substr(hash_hmac('sha256', 'cms-cron', $secret), 0, 40);
|
||||
}
|
||||
|
||||
/** Schaltet die beiden Ausloeser, die in Anfragen stecken. Konsole und URL-Cron laufen unabhaengig davon weiter. */
|
||||
public function setWorkers(bool $traffic, bool $admin): void
|
||||
{
|
||||
$this->writeState(['traffic' => $traffic, 'admin' => $admin, 'next' => $this->fastState()['next']]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Legt fehlende Zeilen an und entfernt Zeilen ohne Aufgabe im Code.
|
||||
*
|
||||
* Neue Aufgaben starten mit einem Abstand von zwei Minuten und nicht sofort: sonst faellt
|
||||
* direkt nach einem Update alles gleichzeitig an, und zwar im ersten Seitenaufruf danach.
|
||||
*
|
||||
* @return bool false, wenn die Tabelle (noch) nicht da ist - vor der Installation und
|
||||
* zwischen hochgeladenem Code und ausgefuehrter Migration
|
||||
*/
|
||||
public function sync(?\DateTimeImmutable $now = null): bool
|
||||
{
|
||||
$now ??= self::now();
|
||||
$registry = $this->registry();
|
||||
|
||||
try {
|
||||
$existing = $this->rows();
|
||||
foreach ($registry as $name => $task) {
|
||||
if (isset($existing[$name])) {
|
||||
continue;
|
||||
}
|
||||
$this->db->insert('scheduled_task', [
|
||||
'name' => $name,
|
||||
'interval_seconds' => $task->interval(),
|
||||
'enabled' => true,
|
||||
'next_run_at' => $now->modify('+120 seconds')->format('Y-m-d H:i:s'),
|
||||
'last_message' => '',
|
||||
'last_duration_ms' => 0,
|
||||
'last_trigger' => '',
|
||||
'failures' => 0,
|
||||
]);
|
||||
}
|
||||
foreach (array_keys($existing) as $name) {
|
||||
if (!isset($registry[$name])) {
|
||||
$this->db->executeStatement('DELETE FROM scheduled_task WHERE name = ?', [$name]);
|
||||
}
|
||||
}
|
||||
} catch (TableNotFoundException) {
|
||||
// Vor der Installation und zwischen hochgeladenem Code und ausgefuehrter Migration.
|
||||
return false;
|
||||
} catch (\Throwable) {
|
||||
return false;
|
||||
}
|
||||
$this->refreshState();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Alles, was der Bildschirm "Aufgaben" zeigt.
|
||||
*
|
||||
* @return list<array{name: string, label: string, explanation: string, interval: int,
|
||||
* enabled: bool, next: string, last: ?string, status: ?string, message: string,
|
||||
* ms: int, trigger: string, failures: int, running: bool, due: bool}>
|
||||
*/
|
||||
public function overview(?\DateTimeImmutable $now = null): array
|
||||
{
|
||||
$now ??= self::now();
|
||||
$this->sync($now);
|
||||
$stamp = $now->format('Y-m-d H:i:s');
|
||||
$overview = [];
|
||||
foreach ($this->rows() as $name => $row) {
|
||||
$task = $this->registry()[$name] ?? null;
|
||||
if (null === $task) {
|
||||
continue;
|
||||
}
|
||||
$locked = (string) ($row['locked_until'] ?? '');
|
||||
$overview[] = [
|
||||
'name' => $name,
|
||||
'label' => $task->label(),
|
||||
'explanation' => $task->explanation(),
|
||||
'interval' => (int) $row['interval_seconds'],
|
||||
'enabled' => (bool) $row['enabled'],
|
||||
'next' => (string) $row['next_run_at'],
|
||||
'last' => null !== $row['last_run_at'] ? (string) $row['last_run_at'] : null,
|
||||
'status' => null !== $row['last_status'] ? (string) $row['last_status'] : null,
|
||||
'message' => (string) $row['last_message'],
|
||||
'ms' => (int) $row['last_duration_ms'],
|
||||
'trigger' => (string) $row['last_trigger'],
|
||||
'failures' => (int) $row['failures'],
|
||||
'running' => '' !== $locked && $locked > $stamp,
|
||||
'due' => (bool) $row['enabled'] && (string) $row['next_run_at'] <= $stamp,
|
||||
];
|
||||
}
|
||||
|
||||
return $overview;
|
||||
}
|
||||
|
||||
public function enable(string $name, bool $on): void
|
||||
{
|
||||
$this->db->executeStatement('UPDATE scheduled_task SET enabled = ? WHERE name = ?', [$on, $name]);
|
||||
$this->refreshState();
|
||||
}
|
||||
|
||||
/** Der Abstand, in Sekunden. Unter einer Minute ergibt er keinen Sinn, ueber einem Monat auch nicht. */
|
||||
public function setInterval(string $name, int $seconds): void
|
||||
{
|
||||
$this->db->executeStatement(
|
||||
'UPDATE scheduled_task SET interval_seconds = ? WHERE name = ?',
|
||||
[max(60, min(2592000, $seconds)), $name],
|
||||
);
|
||||
$this->refreshState();
|
||||
}
|
||||
|
||||
/** Gibt eine haengende Sperre frei - fuer den Fall, dass ein Prozess mitten im Lauf abgebrochen wurde. */
|
||||
public function release(string $name): void
|
||||
{
|
||||
$this->db->executeStatement('UPDATE scheduled_task SET locked_until = NULL WHERE name = ?', [$name]);
|
||||
$this->refreshState();
|
||||
}
|
||||
|
||||
/**
|
||||
* Die letzten Zeilen des Protokolls, neueste zuerst.
|
||||
*
|
||||
* @return list<string>
|
||||
*/
|
||||
public function protocol(int $lines = 40): array
|
||||
{
|
||||
$raw = @file_get_contents($this->projectDir.'/'.self::LOG_FILE);
|
||||
if (!is_string($raw) || '' === trim($raw)) {
|
||||
return [];
|
||||
}
|
||||
|
||||
return array_slice(array_reverse(array_values(array_filter(explode("\n", trim($raw))))), 0, $lines);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Innenleben
|
||||
|
||||
/** @return array<string, Task> */
|
||||
private function registry(): array
|
||||
{
|
||||
if (null !== $this->registry) {
|
||||
return $this->registry;
|
||||
}
|
||||
$registry = [];
|
||||
foreach ($this->tasks as $task) {
|
||||
$registry[$task->name()] = $task;
|
||||
}
|
||||
ksort($registry);
|
||||
|
||||
return $this->registry = $registry;
|
||||
}
|
||||
|
||||
/** @return array<string, array<string, mixed>> */
|
||||
private function rows(): array
|
||||
{
|
||||
try {
|
||||
$rows = $this->db->fetchAllAssociative('SELECT * FROM scheduled_task');
|
||||
} catch (\Throwable) {
|
||||
return [];
|
||||
}
|
||||
$indexed = [];
|
||||
foreach ($rows as $row) {
|
||||
$indexed[(string) $row['name']] = $row;
|
||||
}
|
||||
ksort($indexed);
|
||||
|
||||
return $indexed;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param array<string, array<string, mixed>> $rows
|
||||
*
|
||||
* @return list<array<string, mixed>>
|
||||
*/
|
||||
private function due(array $rows, \DateTimeImmutable $now): array
|
||||
{
|
||||
$stamp = $now->format('Y-m-d H:i:s');
|
||||
$due = [];
|
||||
foreach ($rows as $row) {
|
||||
$locked = (string) ($row['locked_until'] ?? '');
|
||||
if ((bool) $row['enabled'] && (string) $row['next_run_at'] <= $stamp && ('' === $locked || $locked <= $stamp)) {
|
||||
$due[] = $row;
|
||||
}
|
||||
}
|
||||
// Die am laengsten ueberfaellige zuerst - sonst kommt eine Aufgabe mit kurzem Abstand
|
||||
// immer wieder dran und eine mit langem nie.
|
||||
usort($due, static fn (array $a, array $b): int => strcmp((string) $a['next_run_at'], (string) $b['next_run_at']));
|
||||
|
||||
return $due;
|
||||
}
|
||||
|
||||
/**
|
||||
* Schreibt in die Zustandsdatei, wann das naechste Mal etwas ansteht.
|
||||
*
|
||||
* Eine laufende Aufgabe zaehlt dabei erst ab dem Ende ihrer Sperre. Ohne das waere waehrend
|
||||
* einer langen Sicherung jeder Seitenaufruf wieder bei der Datenbank: faellig ist sie ja,
|
||||
* sie ist nur schon vergeben. Mit dem Ende der Sperre steht in der Datei ein Zeitpunkt in
|
||||
* der Zukunft, und die uebrigen Anfragen sind nach einem Dateizugriff fertig.
|
||||
*/
|
||||
private function refreshState(): void
|
||||
{
|
||||
$next = null;
|
||||
foreach ($this->rows() as $row) {
|
||||
if (!(bool) $row['enabled']) {
|
||||
continue;
|
||||
}
|
||||
$when = max((string) $row['next_run_at'], (string) ($row['locked_until'] ?? ''));
|
||||
$stamp = strtotime($when.' UTC');
|
||||
if (false !== $stamp && (null === $next || $stamp < $next)) {
|
||||
$next = $stamp;
|
||||
}
|
||||
}
|
||||
$state = $this->fastState();
|
||||
$this->writeState(['traffic' => $state['traffic'], 'admin' => $state['admin'], 'next' => $next]);
|
||||
}
|
||||
|
||||
/** @param array{traffic: bool, admin: bool, next: ?int} $state */
|
||||
private function writeState(array $state): void
|
||||
{
|
||||
$file = $this->projectDir.'/'.self::STATE_FILE;
|
||||
if (!is_dir(dirname($file))) {
|
||||
@mkdir(dirname($file), 0o775, true);
|
||||
}
|
||||
// Schlaegt das fehl - schreibgeschuetztes var/ -, fragt jeder Aufruf wieder die
|
||||
// Datenbank. Langsamer, aber richtig; ein Fehler ist es nicht.
|
||||
@file_put_contents($file, json_encode($state, JSON_PRETTY_PRINT), LOCK_EX);
|
||||
}
|
||||
|
||||
private function append(string $line): void
|
||||
{
|
||||
$file = $this->projectDir.'/'.self::LOG_FILE;
|
||||
if (!is_dir(dirname($file))) {
|
||||
@mkdir(dirname($file), 0o775, true);
|
||||
}
|
||||
@file_put_contents($file, $line."\n", FILE_APPEND | LOCK_EX);
|
||||
// Selbst begrenzend, damit das Protokoll auch ohne die Aufraeumaufgabe nie gross wird.
|
||||
if ((int) @filesize($file) > 100000) {
|
||||
$lines = array_values(array_filter(explode("\n", (string) @file_get_contents($file))));
|
||||
@file_put_contents($file, implode("\n", array_slice($lines, -self::LOG_LINES))."\n", LOCK_EX);
|
||||
}
|
||||
}
|
||||
|
||||
private static function now(): \DateTimeImmutable
|
||||
{
|
||||
return new \DateTimeImmutable('now', new \DateTimeZone('UTC'));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
<?php
|
||||
|
||||
namespace App\Ops\Tasks;
|
||||
|
||||
use App\Ops\Backup;
|
||||
|
||||
/**
|
||||
* Die tägliche Sicherung von Datenbank und Medien.
|
||||
*
|
||||
* Die schwerste Aufgabe im Plan, und die einzige, bei der das Ausführen in einer Webanfrage
|
||||
* wirklich etwas kostet: sie kopiert die Datenbank und den Medienordner. Der Besucher wartet
|
||||
* trotzdem nicht darauf – sie läuft nach der ausgelieferten Antwort. Was sie belegt, ist ein
|
||||
* PHP-Prozess des Hostings, einmal am Tag, für die Dauer einer Kopie.
|
||||
*
|
||||
* Wer einen echten Cronjob hat, sollte sie dort laufen lassen und hier abschalten. Wer keinen
|
||||
* hat, hat mit dieser Aufgabe eine tägliche Sicherung statt gar keiner – und das ist der Grund,
|
||||
* warum sie trotz ihres Gewichts im Plan steht.
|
||||
*/
|
||||
final class BackupTask implements Task
|
||||
{
|
||||
public function __construct(private Backup $backup)
|
||||
{
|
||||
}
|
||||
|
||||
public function name(): string
|
||||
{
|
||||
return 'backup';
|
||||
}
|
||||
|
||||
public function label(): string
|
||||
{
|
||||
return 'Sicherung anlegen';
|
||||
}
|
||||
|
||||
public function explanation(): string
|
||||
{
|
||||
return 'Ohne sie gibt es keinen Rückweg außer der von Hand angelegten Sicherung. Sie rotiert selbst und enthält Datenbank und Medien, aber weder .env noch vendor/.';
|
||||
}
|
||||
|
||||
public function interval(): int
|
||||
{
|
||||
return 86400;
|
||||
}
|
||||
|
||||
public function run(): string
|
||||
{
|
||||
$result = $this->backup->create('automatisch');
|
||||
$removed = $this->backup->rotate();
|
||||
|
||||
return sprintf(
|
||||
'%s angelegt: %d Seite(n), %d Mediendatei(en).%s',
|
||||
$result['name'],
|
||||
$result['manifest']['inhalt']['seiten'],
|
||||
$result['manifest']['medien']['dateien'],
|
||||
[] === $removed ? '' : sprintf(' %d alte entfernt.', count($removed)),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,142 @@
|
||||
<?php
|
||||
|
||||
namespace App\Ops\Tasks;
|
||||
|
||||
use App\Ops\ArchiveUpdate;
|
||||
use App\Ops\Scheduler;
|
||||
use App\Ops\Updater;
|
||||
|
||||
/**
|
||||
* Räumt in `var/` auf, was mit der Zeit liegen bleibt.
|
||||
*
|
||||
* Drei Dinge, und ausdrücklich nur diese drei: abgelaufene Sitzungsdateien, alte Arbeitsordner
|
||||
* eines Updates und zu lang gewordene Protokolle. Nichts davon ist Inhalt, nichts davon lässt
|
||||
* sich vermissen.
|
||||
*
|
||||
* Was diese Aufgabe **nicht** anfasst: Sicherungen (die rotiert `cms:backup` selbst und nach
|
||||
* einer anderen Regel), den Cache (den baut Symfony auf, wenn er fehlt, aber ihn mitten im
|
||||
* Betrieb zu löschen macht die nächste Anfrage langsam ohne Grund) und den Ordner eines Updates,
|
||||
* das noch auf seinen zweiten Schritt wartet.
|
||||
*/
|
||||
final class CleanupTask implements Task
|
||||
{
|
||||
/** Sitzungen und Update-Arbeitsordner, die älter sind, werden entfernt. */
|
||||
private const KEEP_DAYS = 30;
|
||||
|
||||
/** So viele Zeilen bleiben in den Protokollen stehen. */
|
||||
private const KEEP_LINES = 200;
|
||||
|
||||
public function __construct(private string $projectDir)
|
||||
{
|
||||
}
|
||||
|
||||
public function name(): string
|
||||
{
|
||||
return 'cleanup';
|
||||
}
|
||||
|
||||
public function label(): string
|
||||
{
|
||||
return 'Aufräumen';
|
||||
}
|
||||
|
||||
public function explanation(): string
|
||||
{
|
||||
return sprintf(
|
||||
'Entfernt Sitzungsdateien und Update-Arbeitsordner, die älter als %d Tage sind, und kürzt die Protokolle. Sicherungen und Inhalte bleiben unberührt.',
|
||||
self::KEEP_DAYS,
|
||||
);
|
||||
}
|
||||
|
||||
public function interval(): int
|
||||
{
|
||||
return 86400;
|
||||
}
|
||||
|
||||
public function run(): string
|
||||
{
|
||||
$limit = time() - self::KEEP_DAYS * 86400;
|
||||
|
||||
return sprintf(
|
||||
'%d Sitzungsdatei(en), %d Update-Ordner entfernt, %d Protokoll(e) gekürzt.',
|
||||
$this->sessions($limit),
|
||||
$this->updateFolders($limit),
|
||||
$this->logs(),
|
||||
);
|
||||
}
|
||||
|
||||
/** Sitzungsdateien. Der Garbage Collector von PHP ist auf vielen Hostings abgeschaltet. */
|
||||
private function sessions(int $limit): int
|
||||
{
|
||||
$removed = 0;
|
||||
foreach (glob($this->projectDir.'/var/sessions/*/sess_*') ?: [] as $file) {
|
||||
if (is_file($file) && (int) @filemtime($file) < $limit && @unlink($file)) {
|
||||
++$removed;
|
||||
}
|
||||
}
|
||||
|
||||
return $removed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Die Arbeitsordner des Archiv-Updates.
|
||||
*
|
||||
* Der jüngste ist der Rückweg aus dem letzten Update, und den lässt diese Aufgabe einen
|
||||
* Monat lang stehen. Wartet ein Update noch auf seinen zweiten Schritt, wird gar nichts
|
||||
* angefasst: dann ist einer dieser Ordner der Stand, auf den zurückgegangen wird.
|
||||
*/
|
||||
private function updateFolders(int $limit): int
|
||||
{
|
||||
if (is_file($this->projectDir.'/'.ArchiveUpdate::MARKE)) {
|
||||
return 0;
|
||||
}
|
||||
$removed = 0;
|
||||
foreach (glob($this->projectDir.'/var/update/*', GLOB_ONLYDIR) ?: [] as $folder) {
|
||||
if ((int) @filemtime($folder) < $limit && $this->removeDirectory($folder)) {
|
||||
++$removed;
|
||||
}
|
||||
}
|
||||
|
||||
return $removed;
|
||||
}
|
||||
|
||||
private function logs(): int
|
||||
{
|
||||
$shortened = 0;
|
||||
foreach ([Updater::LOG_FILE, Scheduler::LOG_FILE] as $relative) {
|
||||
$file = $this->projectDir.'/'.$relative;
|
||||
$raw = @file_get_contents($file);
|
||||
if (!is_string($raw)) {
|
||||
continue;
|
||||
}
|
||||
$lines = array_values(array_filter(explode("\n", $raw)));
|
||||
if (count($lines) <= self::KEEP_LINES) {
|
||||
continue;
|
||||
}
|
||||
if (false !== @file_put_contents($file, implode("\n", array_slice($lines, -self::KEEP_LINES))."\n", LOCK_EX)) {
|
||||
++$shortened;
|
||||
}
|
||||
}
|
||||
|
||||
return $shortened;
|
||||
}
|
||||
|
||||
/** Rekursiv löschen, aber nur unterhalb von `var/` – geprüft, nicht angenommen. */
|
||||
private function removeDirectory(string $path): bool
|
||||
{
|
||||
$real = realpath($path);
|
||||
$var = realpath($this->projectDir.'/var');
|
||||
if (false === $real || false === $var || !str_starts_with($real, $var.DIRECTORY_SEPARATOR)) {
|
||||
return false;
|
||||
}
|
||||
$items = new \RecursiveIteratorIterator(
|
||||
new \RecursiveDirectoryIterator($real, \FilesystemIterator::SKIP_DOTS),
|
||||
\RecursiveIteratorIterator::CHILD_FIRST,
|
||||
);
|
||||
foreach ($items as $item) {
|
||||
$item->isDir() ? @rmdir($item->getPathname()) : @unlink($item->getPathname());
|
||||
}
|
||||
|
||||
return @rmdir($real);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
<?php
|
||||
|
||||
namespace App\Ops\Tasks;
|
||||
|
||||
use App\Content\Statistics;
|
||||
|
||||
/**
|
||||
* Verdichtet und löscht die Zähler der Statistik.
|
||||
*
|
||||
* Einmal täglich reicht: die Tabelle wächst mit Seiten und Stunden, nicht mit Besuchen, und ein
|
||||
* Tag Verzug ändert an ihrer Größe nichts.
|
||||
*/
|
||||
final class PruneStatisticsTask implements Task
|
||||
{
|
||||
public function __construct(private Statistics $statistics)
|
||||
{
|
||||
}
|
||||
|
||||
public function name(): string
|
||||
{
|
||||
return 'stats-prune';
|
||||
}
|
||||
|
||||
public function label(): string
|
||||
{
|
||||
return 'Statistik verdichten';
|
||||
}
|
||||
|
||||
public function explanation(): string
|
||||
{
|
||||
return sprintf(
|
||||
'Ohne sie behält die Statistik jede Stunde einzeln, für immer. Verdichtet wird nach %d Tagen, gelöscht nach %d.',
|
||||
Statistics::COMPACT_AFTER_DAYS,
|
||||
Statistics::KEEP_DAYS,
|
||||
);
|
||||
}
|
||||
|
||||
public function interval(): int
|
||||
{
|
||||
return 86400;
|
||||
}
|
||||
|
||||
public function run(): string
|
||||
{
|
||||
$result = $this->statistics->prune();
|
||||
|
||||
return sprintf(
|
||||
'%d Tag(e) zusammengefasst, %d Zeile(n) jenseits von %d Tagen entfernt.',
|
||||
$result['compacted'],
|
||||
$result['removed'],
|
||||
Statistics::KEEP_DAYS,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
<?php
|
||||
|
||||
namespace App\Ops\Tasks;
|
||||
|
||||
use App\Content\PageRepository;
|
||||
|
||||
/**
|
||||
* Veröffentlicht Seiten, deren geplanter Zeitpunkt vergangen ist.
|
||||
*
|
||||
* Die Aufgabe mit dem kürzesten Abstand, weil sie die einzige ist, die jemand *bemerkt*: wer eine
|
||||
* Seite für Montag 9 Uhr plant, schaut Montag um 9 Uhr nach. Fünf Minuten sind der Kompromiss
|
||||
* zwischen „wirkt sofort" und „fällt bei jedem zweiten Seitenaufruf an".
|
||||
*/
|
||||
final class PublishDueTask implements Task
|
||||
{
|
||||
public function __construct(private PageRepository $pages)
|
||||
{
|
||||
}
|
||||
|
||||
public function name(): string
|
||||
{
|
||||
return 'publish-due';
|
||||
}
|
||||
|
||||
public function label(): string
|
||||
{
|
||||
return 'Geplante Veröffentlichungen';
|
||||
}
|
||||
|
||||
public function explanation(): string
|
||||
{
|
||||
return 'Ohne sie bleibt eine geplante Seite ein Entwurf – die sichere Richtung, aber nicht die gewollte.';
|
||||
}
|
||||
|
||||
public function interval(): int
|
||||
{
|
||||
return 300;
|
||||
}
|
||||
|
||||
public function run(): string
|
||||
{
|
||||
$published = $this->pages->publishDue();
|
||||
|
||||
return [] === $published
|
||||
? 'Nichts fällig.'
|
||||
: sprintf('%d Seite(n) veröffentlicht: /%s', count($published), implode(', /', $published));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
<?php
|
||||
|
||||
namespace App\Ops\Tasks;
|
||||
|
||||
/**
|
||||
* Eine wiederkehrende Aufgabe.
|
||||
*
|
||||
* Der Vertrag ist absichtlich winzig, weil der Ausloeser nicht feststeht: dieselbe Aufgabe laeuft
|
||||
* je nach Hosting im Seitenaufruf eines Besuchers, im geoeffneten Backend, ueber einen
|
||||
* URL-Cronjob oder auf der Konsole. Was sie tut, darf davon nicht abhaengen.
|
||||
*
|
||||
* Drei Regeln, die aus dem Ausfuehrungsort folgen:
|
||||
*
|
||||
* 1. **Kurz sein oder unterbrechbar.** Ein Lauf haengt an einem PHP-Prozess, den das Hosting
|
||||
* nach seiner eigenen Zeit abbricht. Wer viel zu tun hat, arbeitet portionsweise und
|
||||
* berichtet, was offen blieb - der naechste Lauf macht weiter.
|
||||
* 2. **Fehler werfen, nicht schlucken.** Eine geworfene Ausnahme wird zum sichtbaren Fehler mit
|
||||
* wachsendem Abstand bis zum naechsten Versuch. Ein stilles `return` sieht aus wie Erfolg.
|
||||
* 3. **Nichts ausgeben.** Es gibt keine Konsole; die Rueckgabe ist der ganze Bericht.
|
||||
*/
|
||||
interface Task
|
||||
{
|
||||
/** Technischer, gleichbleibender Name, zum Beispiel `publish-due`. Er ist der Schluessel in der Datenbank. */
|
||||
public function name(): string;
|
||||
|
||||
/** Die Bezeichnung in der Verwaltung. */
|
||||
public function label(): string;
|
||||
|
||||
/** Ein Satz darueber, was ausbleibt, wenn diese Aufgabe nicht laeuft. */
|
||||
public function explanation(): string;
|
||||
|
||||
/** Vorgabe fuer den Abstand zwischen zwei Laeufen, in Sekunden. In der Verwaltung aenderbar. */
|
||||
public function interval(): int;
|
||||
|
||||
/**
|
||||
* Fuehrt die Aufgabe aus.
|
||||
*
|
||||
* @return string eine kurze Meldung fuer den Betreiber, die auch dann etwas sagt, wenn nichts
|
||||
* zu tun war ("Nichts faellig." ist eine Antwort, "" ist keine)
|
||||
*
|
||||
* @throws \Throwable wenn die Aufgabe ihr Ziel nicht erreicht hat
|
||||
*/
|
||||
public function run(): string;
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
<?php
|
||||
|
||||
namespace App\Ops\Tasks;
|
||||
|
||||
use App\Ops\ArchiveUpdate;
|
||||
use App\Ops\Updater;
|
||||
|
||||
/**
|
||||
* Fragt einmal täglich, ob es eine neuere Fassung gibt.
|
||||
*
|
||||
* Sie prüft nur und installiert nichts. Ein Update tauscht Dateien und führt Migrationen aus;
|
||||
* das gehört an einen Knopf, den ein Mensch drückt, und nicht in den Seitenaufruf eines
|
||||
* Besuchers.
|
||||
*
|
||||
* Ist die Fassungsliste nicht erreichbar, ist das ein Fehler und keine Entwarnung: „keine
|
||||
* Antwort" und „kein Update" sehen sonst gleich aus, und das eine ist eine Nachricht, das andere
|
||||
* eine ausgefallene Prüfung.
|
||||
*/
|
||||
final class UpdateCheckTask implements Task
|
||||
{
|
||||
public function __construct(private ArchiveUpdate $archive, private Updater $updater)
|
||||
{
|
||||
}
|
||||
|
||||
public function name(): string
|
||||
{
|
||||
return 'update-check';
|
||||
}
|
||||
|
||||
public function label(): string
|
||||
{
|
||||
return 'Nach Updates sehen';
|
||||
}
|
||||
|
||||
public function explanation(): string
|
||||
{
|
||||
return 'Fragt beim Repository nach der neuesten Fassung. Sie installiert nichts – das Ergebnis steht hier und auf dem Bildschirm „System".';
|
||||
}
|
||||
|
||||
public function interval(): int
|
||||
{
|
||||
return 86400;
|
||||
}
|
||||
|
||||
public function run(): string
|
||||
{
|
||||
$latest = $this->archive->latest();
|
||||
if (null === $latest) {
|
||||
throw new \RuntimeException('Die Fassungsliste war nicht erreichbar. Erlaubt dieses Hosting ausgehende Verbindungen?');
|
||||
}
|
||||
$installed = $this->updater->version();
|
||||
|
||||
return version_compare($latest['version'], $installed, '>')
|
||||
? sprintf('Fassung %s ist verfügbar; installiert ist %s.', $latest['version'], $installed)
|
||||
: sprintf('Aktuell: Fassung %s.', $installed);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user