ultimate_cron.drush.inc in Ultimate Cron 8.2

Drush commands for Ultimate Cron!

File

ultimate_cron.drush.inc

<?php

/**
 * @file
 * Drush commands for Ultimate Cron!
 */
use Drupal\ultimate_cron\CronPlugin;
use Drupal\ultimate_cron\Entity\CronJob;

/**
 * Implements hook_drush_command().
 */
function ultimate_cron_drush_command() {
  $items = array();
  $items['cron-logs'] = array(
    'description' => 'Show a cron jobs logs',
    'arguments' => array(
      'name' => 'Job to show logs for',
    ),
    'options' => array(
      'limit' => 'Number of log entries to show',
      'compact' => 'Only show the first line of each log entry',
    ),
    'examples' => array(
      'drush cron-logs node_cron --limit=20' => 'Show 20 last logs for the node_cron job',
    ),
  );
  $items['cron-list'] = array(
    'description' => 'List cron jobs',
    'options' => array(
      'module' => 'Comma separated list of modules to show jobs from',
      'enabled' => 'Show enabled jobs',
      'disabled' => 'Show enabled jobs',
      'behind' => 'Show jobs that are behind schedule',
      'status' => 'Comma separated list of statuses to show jobs from',
      'extended' => 'Show extended information',
      'name' => 'Show name instead of title',
      'scheduled' => 'Show scheduled jobs',
    ),
    'examples' => array(
      'drush cron-list --status=running --module=node' => 'Show jobs from the node module that are currently running',
    ),
    'aliases' => array(
      'cl',
    ),
  );
  $items['cron-run'] = array(
    'description' => 'Run cron job',
    'arguments' => array(
      'name' => 'Job to run',
    ),
    'options' => array(
      'force' => 'Skip the schedule check for each job. Locks are still respected.',
      'options' => 'Custom options for plugins, e.g. --options=thread=1 for serial launcher',
    ),
    'examples' => array(
      'drush cron-run node_cron' => 'Run the node_cron job',
      'drush cron-run --options=thread=1' => 'Run all scheduled jobs and instruct serial launcher only to launch thread 1 jobs',
    ),
    'aliases' => array(
      'crun',
    ),
  );
  $items['cron-is-running'] = array(
    'description' => 'Tell whether cron is running. Exit status is set in concordance with the cron running status.',
    'examples' => array(
      'drush cron-is-running' => 'Check if cron is running.',
      'drush cron-is-running --quiet' => 'Check if cron is running and don\'t show an informative message.',
      'while `drush cron-is-running --quiet`; do echo "Waiting cron to finish"; sleep 1; done' => 'Bash loop to wait until cron finishes.',
    ),
    'aliases' => array(
      'cir',
    ),
  );
  $items['cron-enable'] = array(
    'description' => 'Enable cron job',
    'arguments' => array(
      'name' => 'Job to enable',
    ),
    'options' => array(
      'all' => 'Enabled all jobs',
    ),
    'examples' => array(
      'drush cron-enable node_cron' => 'Enable the node_cron job',
    ),
    'aliases' => array(
      'ce',
    ),
  );
  $items['cron-disable'] = array(
    'description' => 'Disable cron job',
    'arguments' => array(
      'name' => 'Job to disable',
    ),
    'options' => array(
      'all' => 'Enabled all jobs',
    ),
    'examples' => array(
      'drush cron-disable node_cron' => 'Disable the node_cron job',
    ),
    'aliases' => array(
      'cd',
    ),
  );
  $items['cron-unlock'] = array(
    'description' => 'Unlock cron job',
    'arguments' => array(
      'name' => 'Job to unlock',
    ),
    'options' => array(
      'all' => 'Enabled all jobs',
    ),
    'examples' => array(
      'drush cron-unlock node_cron' => 'Unlock the node_cron job',
    ),
    'aliases' => array(
      'cu',
    ),
  );
  return $items;
}

/**
 * Implements hook_drush_help().
 */
function ultimate_cron_drush_help($section) {
  switch ($section) {
    case 'drush:cron-list':
      return dt('This command will list cron jobs');
    case 'drush:cron-run':
      return dt('This command will run a cron job');
    case 'drush:cron-enable':
      return dt('This command will enable a cron job');
    case 'drush:cron-disable':
      return dt('This command will disable a cron job');
    case 'drush:cron-unlock':
      return dt('This command will unlock a cron job');
  }
}

/**
 * List cron jobs.
 */
function drush_ultimate_cron_cron_list() {
  $modules = drush_get_option('module');
  $enabled = drush_get_option('enabled');
  $disabled = drush_get_option('disabled');
  $behind = drush_get_option('behind');
  $extended = drush_get_option('extended');
  $statuses = drush_get_option('status');
  $scheduled = drush_get_option('scheduled');
  $showname = drush_get_option('name');
  $modules = $modules ? explode(',', $modules) : array();
  $statuses = $statuses ? explode(',', $statuses) : array();
  $title = $showname ? dt('Name') : dt('Title');
  $table = array();
  $table[] = array(
    '',
    dt('ID'),
    dt('Module'),
    $title,
    dt('Scheduled'),
    dt('Started'),
    dt('Duration'),
    dt('Status'),
  );
  $print_legend = FALSE;

  /** @var \Drupal\ultimate_cron\Entity\CronJob $job */
  foreach (CronJob::loadMultiple() as $name => $job) {
    if ($modules && !in_array($job
      ->getModule(), $modules)) {
      continue;
    }
    if ($enabled && FALSE === $job
      ->status()) {
      continue;
    }
    if ($disabled && TRUE === $job
      ->status()) {
      continue;
    }
    if ($scheduled && !$job
      ->isScheduled()) {
      continue;
    }
    $legend = '';
    if (FALSE === $job
      ->status()) {
      $legend .= 'D';
      $print_legend = TRUE;
    }
    $lock_id = $job
      ->isLocked();
    $log_entry = $job
      ->loadLogEntry($lock_id);
    if ($time = $job
      ->isBehindSchedule()) {
      $legend .= 'B';
      $print_legend = TRUE;
    }
    if ($behind && !$time) {
      continue;
    }
    if ($lock_id && $log_entry->lid == $lock_id) {
      $legend .= 'R';
      list(, $status) = $job
        ->getPlugin('launcher')
        ->formatRunning($job);
      $print_legend = TRUE;
    }
    elseif ($log_entry->start_time && !$log_entry->end_time) {
      list(, $status) = $job
        ->getPlugin('launcher')
        ->formatUnfinished($job);
    }
    else {
      list(, $status) = $log_entry
        ->formatSeverity();
    }
    if ($statuses && !in_array($status, $statuses)) {
      continue;
    }
    $progress = $lock_id ? $job
      ->formatProgress() : '';
    $table[$name][] = $legend;
    $table[$name][] = $job
      ->id();
    $table[$name][] = $job
      ->getModuleName();
    $table[$name][] = $showname ? $job
      ->id() : $job
      ->getTitle();
    $table[$name][] = $job
      ->getPlugin('scheduler')
      ->formatLabel($job);
    $table[$name][] = $log_entry
      ->formatStartTime();
    $table[$name][] = $log_entry
      ->formatDuration() . ' ' . $progress;
    $table[$name][] = $status;
    if ($extended) {
      $table['extended:' . $name][] = '';
      $table['extended:' . $name][] = '';
      $table['extended:' . $name][] = $job
        ->id();
      $table['extended:' . $name][] = $job
        ->getPlugin('scheduler')
        ->formatLabelVerbose($job);
      $table['extended:' . $name][] = $log_entry->init_message;
      $table['extended:' . $name][] = $log_entry->message;
    }
  }
  drush_print_table($table);
  if ($print_legend) {
    drush_print("\n" . dt('Legend: D = Disabled, R = Running, B = Behind schedule'));
  }
}

/**
 * List cron jobs.
 */
function drush_ultimate_cron_cron_logs($name = NULL) {
  if (!$name) {
    return drush_set_error(dt('No job specified?'));
  }

  /** @var CronJob $job */
  $job = Cronjob::load($name);
  if (!$job) {
    return drush_set_error(dt('@name not found', array(
      '@name' => $name,
    )));
  }
  $compact = drush_get_option('compact');
  $limit = drush_get_option('limit');
  $limit = $limit ? $limit : 10;
  $table = array();
  $table[] = array(
    '',
    dt('Started'),
    dt('Duration'),
    dt('User'),
    dt('Initial message'),
    dt('Message'),
    dt('Status'),
  );
  $lock_id = $job
    ->isLocked();
  $log_entries = $job
    ->getLogEntries(ULTIMATE_CRON_LOG_TYPE_ALL, $limit);

  /** @var \Drupal\ultimate_cron\Logger\LogEntry $log_entry */
  foreach ($log_entries as $log_entry) {
    $progress = '';
    if ($log_entry->lid && $lock_id && $log_entry->lid === $lock_id) {
      $progress = $job
        ->getProgress();
      $progress = is_numeric($progress) ? sprintf(' (%d%%)', round($progress * 100)) : '';
    }
    $legend = '';
    if ($lock_id && $log_entry->lid == $lock_id) {
      $legend .= 'R';
      list(, $status) = $job
        ->getPlugin('launcher')
        ->formatRunning($job);
    }
    elseif ($log_entry->start_time && !$log_entry->end_time) {
      list(, $status) = $job
        ->getPlugin('launcher')
        ->formatUnfinished($job);
    }
    else {
      list(, $status) = $log_entry
        ->formatSeverity();
    }
    $table[$log_entry->lid][] = $legend;
    $table[$log_entry->lid][] = $log_entry
      ->formatStartTime();
    $table[$log_entry->lid][] = $log_entry
      ->formatDuration() . $progress;
    $table[$log_entry->lid][] = $log_entry
      ->formatUser();
    if ($compact) {
      $table[$log_entry->lid][] = trim(reset(explode("\n", $log_entry->init_message)), "\n");
      $table[$log_entry->lid][] = trim(reset(explode("\n", $log_entry->message)), "\n");
    }
    else {
      $table[$log_entry->lid][] = trim($log_entry->init_message, "\n");
      $table[$log_entry->lid][] = trim($log_entry->message, "\n");
    }
    $table[$log_entry->lid][] = $status;
  }
  drush_print_table($table);
}

/**
 * Run cron job(s).
 */
function drush_ultimate_cron_cron_run($name = NULL) {
  if ($options = drush_get_option('options')) {
    $pairs = explode(',', $options);
    foreach ($pairs as $pair) {
      list($key, $value) = explode('=', $pair);
      CronPlugin::setGlobalOption(trim($key), trim($value));
    }
  }
  $force = drush_get_option('force');
  if (!$name) {

    // Run all jobs.
    $jobs = CronJob::loadMultiple();

    /** @var CronJob $job */
    foreach ($jobs as $job) {
      if ($force || $job
        ->isScheduled()) {
        $job
          ->run(t('Launched by drush'));
      }
    }
  }
  else {

    // Run a specific job.
    $job = CronJob::load($name);
    if (!$job) {
      return drush_set_error(dt('@name not found', array(
        '@name' => $name,
      )));
    }
    if ($force || $job
      ->isScheduled()) {
      $job
        ->run(t('Launched by drush'));
    }
  }
}

/**
 * Tell whether cron is running.
 */
function drush_ultimate_cron_cron_is_running() {
  $locked = FALSE;
  foreach (CronJob::loadMultiple() as $name => $job) {
    if ($job
      ->isLocked()) {
      $locked = TRUE;
      break;
    }
  }
  if ($locked) {
    $msg = dt('Cron is running.');
    drush_set_context('DRUSH_EXIT_CODE', 0);
  }
  else {
    $msg = dt('Cron is not running.');
    drush_set_context('DRUSH_EXIT_CODE', 1);
  }
  return $msg;
}

/**
 * Enable a cron job.
 */
function drush_ultimate_cron_cron_enable($name = NULL) {
  if (!$name) {
    if (!drush_get_option('all')) {
      return drush_set_error(dt('No job specified?'));
    }

    /** @var CronJob $job */
    foreach (CronJob::loadMultiple() as $job) {
      $job
        ->enable()
        ->save();
    }
    return;
  }
  $job = CronJob::load($name);
  if ($job
    ->enable()
    ->save()) {
    drush_print(dt('@name enabled', array(
      '@name' => $name,
    )));
  }
}

/**
 * Disable a cron job.
 */
function drush_ultimate_cron_cron_disable($name = NULL) {
  if (!$name) {
    if (!drush_get_option('all')) {
      return drush_set_error(dt('No job specified?'));
    }
    foreach (CronJob::loadMultiple() as $job) {
      $job
        ->disable()
        ->save();
    }
    return;
  }
  $job = CronJob::load($name);
  if ($job
    ->disable()
    ->save()) {
    drush_print(dt('@name disabled', array(
      '@name' => $name,
    )));
  }
}

/**
 * Unlock a cron job.
 */
function drush_ultimate_cron_cron_unlock($name = NULL) {
  if (!$name) {
    if (!drush_get_option('all')) {
      return drush_set_error(dt('No job specified?'));
    }

    /** @var CronJob $job */
    foreach (CronJob::loadMultiple() as $job) {
      if ($job
        ->isLocked()) {
        $job
          ->unlock();
      }
    }
    return;
  }

  /** @var CronJob $job */
  $job = CronJob::load($name);
  if (!$job) {
    return drush_set_error(dt('@name not found', array(
      '@name' => $name,
    )));
  }
  $lock_id = $job
    ->isLocked();
  if (!$lock_id) {
    return drush_set_error(dt('@name is not running', array(
      '@name' => $name,
    )));
  }

  // Unlock the process.
  if ($job
    ->unlock($lock_id, TRUE)) {
    $log_entry = $job
      ->resumeLog($lock_id);
    global $user;
    \Drupal::logger('ultimate_cron')
      ->warning('@name manually unlocked by user @username (@uid)', array(
      '@name' => $job
        ->id(),
      '@username' => $user
        ->getDisplayName(),
      '@uid' => $user
        ->id(),
    ));
    $log_entry
      ->finish();
    drush_print(dt('Cron job @name unlocked', array(
      '@name' => $name,
    )));
  }
  else {
    drush_set_error(dt('Could not unlock cron job @name', array(
      '@name' => $name,
    )));
  }
}

Functions

Name	Description
drush_ultimate_cron_cron_disable	Disable a cron job.
drush_ultimate_cron_cron_enable	Enable a cron job.
drush_ultimate_cron_cron_is_running	Tell whether cron is running.
drush_ultimate_cron_cron_list	List cron jobs.
drush_ultimate_cron_cron_logs	List cron jobs.
drush_ultimate_cron_cron_run	Run cron job(s).
drush_ultimate_cron_cron_unlock	Unlock a cron job.
ultimate_cron_drush_command	Implements hook_drush_command().
ultimate_cron_drush_help	Implements hook_drush_help().