Create a table in the database (I'm using MySQL). By registering the tasks in the database, you can easily enable and disable a task, as well as change it as needed.
CREATE TABLE 'cron_task' (
'id' int(11) NOT NULL AUTO_INCREMENT,
'description' varchar(250) NOT NULL,
'minute' varchar(10) NOT NULL,
'hour' varchar(10) NOT NULL,
'day' varchar(10) NOT NULL,
'month' varchar(10) NOT NULL,
'year' varchar(10) NOT NULL,
'weekday' varchar(10) NOT NULL,
'type' varchar(20) NOT NULL,
'active' tinyint(1) NOT NULL,
'priority' tinyint(3) NOT NULL,
'first_execution' timestamp NULL DEFAULT NULL,
'last_execution' timestamp NULL DEFAULT NULL,
'created_at' timestamp NOT NULL DEFAULT '0000-00-00 00:00:00',
'updated_at' timestamp NULL DEFAULT NULL,
PRIMARY KEY ('id')
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
Use an interface to standardize task classes.
interface ICronTask {
public static function add( ICronTask $task );
public function activate();
public function deactivate();
public function executeTask();
public function makeLog( $content );
}
Where the add method is used to save a task, activate and deactivate to enable and disable the task, executeTask will contain the task execution context, be it email sending, url request, backup , or whatever else, and the makeLog method to generate custom logs for the execution of the tasks.
Create an abstract class to implement the basic methods for all tasks.
abstract class CronTask implements ICronTask {
public $id;
public $description;
public $minute;
public $hour;
public $day;
public $month;
public $year;
public $weekday;
public $type;
public $priority;
public $active;
public $first_execution;
public $last_execution;
public $created_at;
public $updated_at;
public $execution_start;
public $execution_end;
public function __construct( $id = null ) {
// caso o $id possua valor, busque informações no banco sobre a tarefa
// e preencha todos os atributos.
}
public final static function add( ICronTask $task ) {
// Salve no banco de dados e chame o método save()
}
public final function activate() {
// Atualize a tarefa no banco para ativar
}
public final function deactivate() {
// Atualize a tarefa no banco para desativar
}
public function makeLog( $content ) {
// Salve o log da tarefa
// Se precisar de um log personalizado para a tarefa, sobrescreva esse método.
}
public final function executeTask() {
// Executa a tarefa
$this->execution_start = round( microtime(true), 4 );
$content = $this->execute();
$this->execution_end = round( microtime(true), 4 );
$this->makeLog($content);
}
public final function isNow() {
// Faz a verificação da hora de execução, garantindo que deve ser executada
// no momento em que for chamado.
return (
$this->parserTime($this->minute, 'i') &&
$this->parserTime($this->hour, 'H') &&
$this->parserTime($this->month, 'm') &&
$this->parserTime($this->day, 'd') &&
$this->parserTime($this->weekday, 'w')
);
}
private function parserTime( $value, $element ) {
// Obtem o tempo atual
$time = date( $element );
// Verifica se o valor é igual à "*" representando toda momento.
if( $value == '*' ) {
return true;
}
// Separa os conjuntos de tempos separados por vírgula
$groups = explode( ',', $value );
foreach ( $groups as $part ) {
// Verifica se é um intervalo composto. Ex: "*/5" ou "20-40/2"
// Se é um intervalo compost, deverá retornar true se o valor atual
// estiver dentro do intervalo definido antes da barra, e na frequência
// definida após a barra.
if( strpos( $part, '/' ) ) {
$groupsInterval = explode( '/', $part );
// Verificando a frequência
$frequency = $time % $groupsInterval[1] == 0;
// Verificando o intervalo
$interval = explode( '-', $groupsInterval[0] );
$intervalResult = false;
if( $interval[0] == '*' ) {
$intervalResult = true;
} else {
$intervalResult = ( $time >= $interval[0] && $time <= $interval[1] );
}
return $frequency && $intervalResult;
}
// Verifica se é um intervalo simples. Ex: "10-50"
// Se é um intervalo, deverá retornar true se o valor atual estiver
// dentro desse intervalo.
if( strpos( $part, '-' ) ) {
$interval = explode( '-', $part );
return $time >= $interval[0] && $time <= $interval[1];
}
// Se for um número simples verifica se é o tempo certo
if( $time == $part ) {
return true;
}
}
return false;
}
abstract protected function execute();
abstract protected function save();
}
And an example implementation of a task class would be
class CronTaskTest extends CronTask {
public $type = 'Test';
public $priority = 0;
protected function execute() {
return 'Tarefa executada com sucesso';
}
protected function save() {
return true;
}
}
The main class that will be executed at all times verifying the tasks, was implemented in the following way:
class Cron {
public static function execute() {
$tasks = self::getTasks();
foreach ( $tasks as $task ) {
if( $task->isNow() ) {
$task->executeTask();
}
}
}
public static function getTasks() {
try {
$tasks = // Busque todas as tarefas ativas ordenadas por prioridade DESC;
$return = array();
foreach ( $tasks as $record ) {
$taskName = 'CronTask' . $record['type'];
require_once __DIR__ . '/tasks/' . $taskName . '.php';
$return[] = new $taskName( $record['id'] );
}
} catch ( PDOException $exception ) {
die( $exception->getMessage() );
}
return $return;
}
}
Create a PHP file to execute the tasks by calling the Cron::execute() method.
Schedule on CRON
# crontab -e
* * * * * /usr/local/bin/php /var/www/projeto/meu-script.php
