openstamanager/cron.php

191 lines
6.5 KiB
PHP
Raw Normal View History

<?php
2020-09-07 15:04:06 +02:00
/*
* OpenSTAManager: il software gestionale open source per l'assistenza tecnica e la fatturazione
2021-01-20 15:08:51 +01:00
* Copyright (C) DevCode s.r.l.
2020-09-07 15:04:06 +02:00
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
2020-11-06 10:46:42 +01:00
/*
* Script dedicato alla gestione delle operazioni di cron ricorrenti del gestionale.
* Una volta attivato, questo script rimane attivo in background per gestire l'esecuzione delle diverse operazioni come pianificate nella tabella zz_tasks.
*
* Il file viene richiamato in automatico al login di un utente.
* Per garantire che lo script resti attivo in ogni situazione, si consiglia di introdurre una chiamata nel relativo crontab di sistema secondo il seguente schema:
2020-09-07 15:04:06 +02:00
*/
// Schema crontab: "*/5 * * * * php <percorso_root>/cron.php"
use Carbon\Carbon;
use Models\Cache;
use Monolog\Handler\RotatingFileHandler;
use Monolog\Logger;
use Tasks\Task;
// Rimozione delle limitazioni sull'esecuzione
2020-08-11 09:54:43 +02:00
set_time_limit(0);
ignore_user_abort(true);
// Chiusura della richiesta alla pagina
2020-08-11 09:54:43 +02:00
flush();
$skip_permissions = true;
include_once __DIR__.'/core.php';
2020-08-11 09:54:43 +02:00
// Controllo su possibili aggiornamenti per bloccare il sistema
$database_online = $database->isInstalled() && !Update::isUpdateAvailable();
if (!$database_online) {
return;
}
// Disabilita della sessione
session_write_close();
// Aggiunta di un logger specifico
2020-08-11 09:54:43 +02:00
$pattern = '[%datetime%] %level_name%: %message% %context%'.PHP_EOL;
$formatter = new Monolog\Formatter\LineFormatter($pattern);
$logger = new Logger('Tasks');
$handler = new RotatingFileHandler(base_dir().'/logs/cron.log', 7);
2020-08-11 09:54:43 +02:00
$handler->setFormatter($formatter);
$logger->pushHandler($handler);
// Lettura della cache
2024-03-01 13:16:58 +01:00
$ultima_esecuzione = Cache::pool('Ultima esecuzione del cron');
$data = $ultima_esecuzione->content;
2024-03-01 13:16:58 +01:00
$in_esecuzione = Cache::pool('Cron in esecuzione');
$cron_id = Cache::pool('ID del cron');
2020-08-27 17:28:53 +02:00
2024-03-01 13:16:58 +01:00
$disattiva = Cache::pool('Disabilita cron');
2023-08-04 14:54:28 +02:00
if ($disattiva->content || (in_array($_SERVER['HTTP_HOST'], ['localhost', '127.0.0.1']) && !$forza_cron_localhost)) {
2020-08-12 16:03:25 +02:00
return;
}
// Impostazioni sugli slot di esecuzione
$slot_duration = 5;
// Controllo sull'ultima esecuzione
$data = $data ? new Carbon($data) : null;
2020-08-27 17:28:53 +02:00
$minimo_esecuzione = (new Carbon())->subMinutes($slot_duration * 5);
2020-08-18 10:08:35 +02:00
if (!empty($data) && $minimo_esecuzione->lessThan($data)) {
return;
}
2020-08-27 17:28:53 +02:00
// Generazione e registrazione del cron
$current_id = random_string();
$cron_id->set($current_id);
2020-08-11 09:54:43 +02:00
// Registrazione dell'esecuzione
$adesso = new Carbon();
$ultima_esecuzione->set($adesso->__toString());
2020-08-12 16:03:25 +02:00
// Prima esecuzione immediata
$slot_minimo = $adesso->copy();
// Esecuzione ricorrente
$number = 1;
while (true) {
2020-08-12 16:03:25 +02:00
$disattiva->refresh();
2020-08-27 17:28:53 +02:00
$cron_id->refresh();
$in_esecuzione->refresh();
2020-08-11 09:54:43 +02:00
// Controllo su possibili aggiornamenti per bloccare il sistema
$database_online = $database->isInstalled() && !Update::isUpdateAvailable();
if (!$database_online || !empty($disattiva->content) || $cron_id->content != $current_id) {
2020-08-11 09:54:43 +02:00
return;
}
2020-08-28 13:51:15 +02:00
// Rimozione dei log più vecchi
$database->query('DELETE FROM zz_tasks_logs WHERE DATE_ADD(created_at, INTERVAL :interval DAY) <= NOW()', [
':interval' => 7,
]);
2020-08-12 16:03:25 +02:00
// Risveglio programmato tramite slot
$timestamp = $slot_minimo->getTimestamp();
time_sleep_until($timestamp);
$in_esecuzione->set(true);
2020-08-12 16:03:25 +02:00
// Registrazione dell'iterazione nei log
$logger->info('Cron #'.$number.' iniziato', [
'slot' => $slot_minimo->toDateTimeString(),
'slot-unix' => $timestamp,
]);
// Calcolo del primo slot disponibile per l'esecuzione successiva
2020-08-27 17:28:53 +02:00
$inizio_iterazione = $slot_minimo->copy();
2020-08-12 16:03:25 +02:00
$slot_minimo = $inizio_iterazione->copy()->startOfHour();
while ($inizio_iterazione->greaterThanOrEqualTo($slot_minimo)) {
$slot_minimo->addMinutes($slot_duration);
}
// Aggiornamento dei cron disponibili
$tasks = Task::all();
foreach ($tasks as $task) {
2020-08-12 16:03:25 +02:00
$adesso = new Carbon();
2020-08-27 17:28:53 +02:00
// Registrazione della data per l'esecuzione se non indicata
if (empty($task->next_execution_at)) {
$task->registerNextExecution($inizio_iterazione);
$task->save();
$logger->info($task->name.': data mancante', [
'timestamp' => $task->next_execution_at->toDateTimeString(),
]);
2020-08-27 17:28:53 +02:00
}
// Esecuzione diretta solo nel caso in cui sia prevista
if ($task->next_execution_at->copy()->addSeconds(20)->greaterThanOrEqualTo($inizio_iterazione) && $task->next_execution_at->lessThanOrEqualTo($adesso->copy()->addseconds(20))) {
2020-08-12 16:03:25 +02:00
// Registrazione dell'esecuzione nei log
$logger->info($task->name.': '.$task->expression);
2020-08-27 17:28:53 +02:00
try {
$task->execute();
} catch (Exception $e) {
// Registrazione del completamento nei log
$task->log('error', 'Errore di esecuzione', [
2020-08-27 17:28:53 +02:00
'code' => $e->getCode(),
'message' => $e->getMessage(),
'trace' => $e->getTraceAsString(),
]);
$logger->error($task->name.': errore');
2020-08-27 17:28:53 +02:00
}
}
2020-08-27 17:28:53 +02:00
// Esecuzione mancata
elseif ($task->next_execution_at->lessThan($inizio_iterazione)) {
$logger->warning($task->name.': mancata', [
2020-08-27 17:28:53 +02:00
'timestamp' => $task->next_execution_at->toDateTimeString(),
]);
2020-08-12 16:03:25 +02:00
2020-08-27 17:28:53 +02:00
$task->registerMissedExecution($inizio_iterazione);
}
2020-08-18 10:08:35 +02:00
2020-08-12 16:03:25 +02:00
// Calcolo dello successivo slot
2020-08-27 17:28:53 +02:00
if ($task->next_execution_at->lessThan($slot_minimo)) {
$slot_minimo = $task->next_execution_at;
2020-08-12 16:03:25 +02:00
}
}
2020-08-12 16:03:25 +02:00
// Registrazione dello slot successivo nei log
$logger->info('Cron #'.$number.' concluso', [
'next-slot' => $slot_minimo->toDateTimeString(),
'next-slot-unix' => $timestamp,
]);
$in_esecuzione->set(false);
2020-08-12 16:03:25 +02:00
// Registrazione dell'esecuzione
$adesso = new Carbon();
$ultima_esecuzione->set($adesso->__toString());
++$number;
}