BOINC / boinc

drupal/sites/default/boinc/modules/contrib/elysia_cron/elysia_cron.module

Indentation +514 added lines, -514 removed lines

@@ -29,22 +29,22 @@ 
 require_once('elysia_cron_scheduler.inc');
 require_once('elysia_cron.admin.inc');
 if (EC_DRUPAL_VERSION >= 6) {
-  require_once('elysia_cron.ctools.inc');
+    require_once('elysia_cron.ctools.inc');
 }
 
 
 $GLOBALS['elysia_cron_default_rules'] = array(
-  '*/15 * * * *' => 'Every 15 minutes',
-  '*/30 * * * *' => 'Every 30 minutes',
-  '0 * * * *' => 'Every hour',
-  '0 */6 * * *' => 'Every 6 hours',
-  '4 0 * * *' => 'Once a day',
-  '4 0 * * 0' => 'Once a week',
-  '4 0 1 * *' => 'Once a month',
+    '*/15 * * * *' => 'Every 15 minutes',
+    '*/30 * * * *' => 'Every 30 minutes',
+    '0 * * * *' => 'Every hour',
+    '0 */6 * * *' => 'Every 6 hours',
+    '4 0 * * *' => 'Once a day',
+    '4 0 * * 0' => 'Once a week',
+    '4 0 1 * *' => 'Once a month',
 );
 
 function elysia_cron_version() {
-  return 20111020;
+    return 20111020;
 }
 
 /*******************************************************************************
@@ -52,84 +52,84 @@ 
  ******************************************************************************/
 
 function elysia_cron_menu($_dcr_maycache = true) {
-  $items = array();
-  $items['admin/config/system/cron'] = array(
+    $items = array();
+    $items['admin/config/system/cron'] = array(
     'title' => _dcf_t('Cron Settings'),
     'description' => _dcf_t('View and manage cron table'),
     'page callback' => 'elysia_cron_admin_page',
     'access arguments' => array('administer elysia_cron'),
-  );
-  $items['admin/config/system/cron/status'] = array(
+    );
+    $items['admin/config/system/cron/status'] = array(
     'type' => MENU_DEFAULT_LOCAL_TASK,
     'title' => _dcf_t('Status'),
     'weight' => 1,
-  );
-  $items['admin/config/system/cron/settings'] = array(
+    );
+    $items['admin/config/system/cron/settings'] = array(
     'type' => MENU_LOCAL_TASK,
     'title' => _dcf_t('Settings'),
     'page callback' => 'drupal_get_form',
     'page arguments' => array('elysia_cron_settings_form'),
     'access arguments' => array('administer elysia_cron'),
     'weight' => 2,
-  );
-  $items['admin/config/system/cron/maintenance'] = array(
+    );
+    $items['admin/config/system/cron/maintenance'] = array(
     'type' => MENU_LOCAL_TASK,
     'title' => _dcf_t('Maintenance'),
     'page callback' => 'elysia_cron_maintenance_page',
     'access arguments' => array('administer elysia_cron'),
     'weight' => 3,
-  );
-  $items['admin/config/system/cron/execute'] = array(
+    );
+    $items['admin/config/system/cron/execute'] = array(
     'type' => MENU_CALLBACK,
     'page callback' => 'elysia_cron_execute_page',
     'access arguments' => array('administer elysia_cron'),
-  );
-  $items['admin/build/cron/ping'] = array(
+    );
+    $items['admin/build/cron/ping'] = array(
     'type' => MENU_CALLBACK,
     'page callback' => 'elysia_cron_ping_page',
     'access callback' => TRUE,
-  );
-  return _dcf_hook_menu($items, $_dcr_maycache);
+    );
+    return _dcf_hook_menu($items, $_dcr_maycache);
 }
 
 if (EC_DRUPAL_VERSION >= 7) {
-  // Override standard cron page
-  function elysia_cron_menu_alter(&$items) {
+    // Override standard cron page
+    function elysia_cron_menu_alter(&$items) {
     $items['admin/config/system/cron'] = array(
-      'title' => _dcf_t('Cron Settings'),
-      'description' => 'View and manage cron table',
-      'page callback' => 'elysia_cron_admin_page',
-      'access arguments' => array('administer elysia_cron'),
+        'title' => _dcf_t('Cron Settings'),
+        'description' => 'View and manage cron table',
+        'page callback' => 'elysia_cron_admin_page',
+        'access arguments' => array('administer elysia_cron'),
     );
-  }
+    }
 }
 
 function elysia_cron_perm() { // For D5-D6
-  return array('administer elysia_cron');
+    return array('administer elysia_cron');
 }
 function elysia_cron_permission() { // For D7
-  return array(
+    return array(
     'administer elysia_cron' => array('title' => t('Administer elysia cron'), 'description' => t('Perform changes to cron jobs timings, disable cron or single jobs and access cron execution statistics')),
-  );
+    );
 }
 
 function elysia_cron_boot() {
-  if (!_dcf_hook_boot('elysia_cron')) {
+    if (!_dcf_hook_boot('elysia_cron')) {
     return;
-  }
+    }
 
-  if (EC_DRUPAL_VERSION < 7) {
+    if (EC_DRUPAL_VERSION < 7) {
     global $conf;
 
     // I need to set cron_semaphore always to false. That way standard drupal cron is always bypassed
     $conf['cron_semaphore'] = false;
-  }
+    }
 }
 
 function elysia_cron_init() {
-  if (!_dcf_hook_init('elysia_cron')) {
+    if (!_dcf_hook_init('elysia_cron')) {
     return;
-  }
+    }
 }
 
 /**
@@ -137,35 +137,35 @@ 
  * It's used to replace drupal cron.
  */
 function elysia_cron_cron() {
-  // First cron run is executed in standard drupal way. This is to enable the use of install profiles
-  if (variable_get('cron_last', 0) == 0) {
+    // First cron run is executed in standard drupal way. This is to enable the use of install profiles
+    if (variable_get('cron_last', 0) == 0) {
     return;
-  }
-  // If the path is 'admin/*' this is a manual cron run (probably by admin/logs/status)
-  $manual_run = (arg(0) == 'admin');
+    }
+    // If the path is 'admin/*' this is a manual cron run (probably by admin/logs/status)
+    $manual_run = (arg(0) == 'admin');
 
-  $result = elysia_cron_run($manual_run);
+    $result = elysia_cron_run($manual_run);
 
-  if (EC_DRUPAL_VERSION < 7) {
+    if (EC_DRUPAL_VERSION < 7) {
     // I must check for cron_semaphore and delete it if set (is not always deleted by elysia_cron_run, and this situation is only when called by drupal cron, so a check here is right)
     if (variable_get('cron_semaphore', false)) {
-      global $conf;
-      _ec_variable_del('cron_semaphore');
-      $conf['cron_semaphore'] = false;
+        global $conf;
+        _ec_variable_del('cron_semaphore');
+        $conf['cron_semaphore'] = false;
+    }
     }
-  }
 
-  if ($manual_run) {
+    if ($manual_run) {
     if ($result) {
-      drupal_set_message(t('Cron ran successfully'));
+        drupal_set_message(t('Cron ran successfully'));
     }
     else {
-      drupal_set_message(t('Cron run failed, disabled or nothing to do'));
+        drupal_set_message(t('Cron run failed, disabled or nothing to do'));
     }
     drupal_goto(_dcf_internal_path('admin/reports/status'));
-  }
+    }
 
-  exit();
+    exit();
 }
 
 /**
@@ -174,14 +174,14 @@ 
  * If it's not i'll set it and print a message
  */
 function elysia_cron_help($section, $arg = false) {
-  if ($section == _dcf_internal_path('admin/modules')) {
+    if ($section == _dcf_internal_path('admin/modules')) {
     $min = drupal_module_get_min_weight('elysia_cron');
     $weight = drupal_module_get_weight('elysia_cron');
     if ($min <= $weight) {
-      drupal_set_message(t('Elysia cron module is not the module with the smallest weight (and it must be). Updating weight...'));
-      drupal_module_set_weight('elysia_cron', $min - 1);
+        drupal_set_message(t('Elysia cron module is not the module with the smallest weight (and it must be). Updating weight...'));
+        drupal_module_set_weight('elysia_cron', $min - 1);
+    }
     }
-  }
 }
 
 /*******************************************************************************
@@ -192,30 +192,30 @@ 
 
 // Variables managed by _ec_variable method, because are setted during cron execution handling (with standard variable_set this will invalidate variable cache in EVERY cron clock)
 $GLOBALS['_ec_variables_allowed'] = array(
-  'elysia_cron_version', // Just for compatibility purpose during elysia_cron_update phase
-  'elysia_cron_semaphore', 
-  'elysia_cron_last_run',
-  'elysia_cron_last_context', 
-  'cron_semaphore', 
-  'cron_last',
+    'elysia_cron_version', // Just for compatibility purpose during elysia_cron_update phase
+    'elysia_cron_semaphore', 
+    'elysia_cron_last_run',
+    'elysia_cron_last_context', 
+    'cron_semaphore', 
+    'cron_last',
 );
 
 $GLOBALS['_ec_columns'] = array(
-  'name', ' disable', ' rule', ' weight', ' context', ' running', ' last_run', ' last_aborted', ' abort_count', ' last_abort_function', ' last_execution_time', ' execution_count', ' avg_execution_time', ' max_execution_time', ' last_shutdown_time'
+    'name', ' disable', ' rule', ' weight', ' context', ' running', ' last_run', ' last_aborted', ' abort_count', ' last_abort_function', ' last_execution_time', ' execution_count', ' avg_execution_time', ' max_execution_time', ' last_shutdown_time'
 );
  
 function _ec_variable_init() {
-  global $_ec_variables, $_ec_variables_allowed;
-  $_ec_variables = array();
-  if (EC_DRUPAL_VERSION >= 7) {
+    global $_ec_variables, $_ec_variables_allowed;
+    $_ec_variables = array();
+    if (EC_DRUPAL_VERSION >= 7) {
     $_ec_variables = array_map('unserialize', db_query("SELECT name, value FROM {variable} where name like '" . implode("' or name like '", $_ec_variables_allowed) . "'")->fetchAllKeyed());
-  }
-  else {
+    }
+    else {
     $result = db_query("select * from {variable} where name like '" . implode("' or name like '", $_ec_variables_allowed) . "'");
     while ($variable = db_fetch_object($result)) {
-      $_ec_variables[$variable->name] = unserialize($variable->value);
+        $_ec_variables[$variable->name] = unserialize($variable->value);
+    }
     }
-  }
 }
 
 /**
@@ -224,27 +224,27 @@ 
  * WARN_UPGRADE
  */
 function _ec_variable_get($name, $default) {
-  global $_ec_variables, $_ec_variables_allowed;
-  if (!in_array($name, $_ec_variables_allowed)) {
+    global $_ec_variables, $_ec_variables_allowed;
+    if (!in_array($name, $_ec_variables_allowed)) {
     _dco_watchdog('cron', 'Wrong variable passed to _ec_variable_get: !var', array('!var' => $name), WATCHDOG_ERROR);
     return variable_get($name, $default);
-  }
+    }
 
-  if (!is_array($_ec_variables)) {
+    if (!is_array($_ec_variables)) {
     _ec_variable_init();
-  }
+    }
 
-  // If there is a $GLOBALS['original_conf'] = $conf; at the end of  settings.php i consider it.
-  global $original_conf;
+    // If there is a $GLOBALS['original_conf'] = $conf; at the end of  settings.php i consider it.
+    global $original_conf;
 
-  if (isset($original_conf[$name])) {
+    if (isset($original_conf[$name])) {
     return $original_conf[$name];
-  }
-  if (isset($_ec_variables[$name])) {
+    }
+    if (isset($_ec_variables[$name])) {
     return $_ec_variables[$name];
-  }
+    }
 
-  return $default;
+    return $default;
 }
 
 /**
@@ -253,33 +253,33 @@ 
  * WARN_UPGRADE
  */
 function _ec_variable_set($name, $value) {
-  global $_ec_variables, $_ec_variables_allowed;
-  if (!in_array($name, $_ec_variables_allowed)) {
+    global $_ec_variables, $_ec_variables_allowed;
+    if (!in_array($name, $_ec_variables_allowed)) {
     _dco_watchdog('cron', 'Wrong variable passed to _ec_variable_set: !var', array('!var' => $name), WATCHDOG_ERROR);
     return variable_set($name, $value);
-  }
+    }
 
-  if (!is_array($_ec_variables)) {
+    if (!is_array($_ec_variables)) {
     _ec_variable_init();
-  }
+    }
 
-  if (EC_DRUPAL_VERSION >= 7) {
+    if (EC_DRUPAL_VERSION >= 7) {
     db_merge('variable')->key(array('name' => $name))->fields(array('value' => serialize($value)))->execute();
 
-  }
-  else {
+    }
+    else {
     if (!variable_get('elysia_cron_alternate_var_handler', false)) {
-      db_lock_table('variable');
-      db_query("DELETE FROM {variable} WHERE name = '%s'", $name);
-      db_query("INSERT INTO {variable} (name, value) VALUES ('%s', '%s')", $name, serialize($value));
-      db_unlock_tables();
+        db_lock_table('variable');
+        db_query("DELETE FROM {variable} WHERE name = '%s'", $name);
+        db_query("INSERT INTO {variable} (name, value) VALUES ('%s', '%s')", $name, serialize($value));
+        db_unlock_tables();
     }
     else {
-      db_query("REPLACE INTO {variable} (name, value) VALUES ('%s', '%s')", $name, serialize($value));
+        db_query("REPLACE INTO {variable} (name, value) VALUES ('%s', '%s')", $name, serialize($value));
+    }
     }
-  }
 
-  $_ec_variables[$name] = $value;
+    $_ec_variables[$name] = $value;
 }
 
 /**
@@ -288,38 +288,38 @@ 
  * WARN_UPGRADE
  */
 function _ec_variable_del($name) {
-  global $_ec_variables, $_ec_variables_allowed;
-  if (!in_array($name, $_ec_variables_allowed)) {
+    global $_ec_variables, $_ec_variables_allowed;
+    if (!in_array($name, $_ec_variables_allowed)) {
     _dco_watchdog('cron', 'Wrong variable passed to _ec_variable_del: !var', array('!var' => $name), WATCHDOG_ERROR);
     return variable_del($name);
-  }
+    }
 
-  if (!is_array($_ec_variables)) {
+    if (!is_array($_ec_variables)) {
     _ec_variable_init();
-  }
+    }
 
-  if (EC_DRUPAL_VERSION >= 7) {
+    if (EC_DRUPAL_VERSION >= 7) {
     db_delete('variable')->condition('name', $name)->execute();
 
-  }
-  else {
+    }
+    else {
     if (!variable_get('elysia_cron_alternate_var_handler', false)) {
-      db_lock_table('variable');
-      db_query("DELETE FROM {variable} WHERE name = '%s'", $name);
-      db_unlock_tables();
+        db_lock_table('variable');
+        db_query("DELETE FROM {variable} WHERE name = '%s'", $name);
+        db_unlock_tables();
     }
     else {
-      db_query("DELETE FROM {variable} WHERE name = '%s'", $name);
+        db_query("DELETE FROM {variable} WHERE name = '%s'", $name);
+    }
     }
-  }
 
-  unset($_ec_variables[$name]);
+    unset($_ec_variables[$name]);
 }
 
 if (EC_DRUPAL_VERSION < 7) {
-  function _ec_semaphore_get($name = 'elysia_cron_semaphore', $timeout = 120) {
+    function _ec_semaphore_get($name = 'elysia_cron_semaphore', $timeout = 120) {
     if (function_exists('elysia_cron_semaphore_get_alternative')) {
-      return elysia_cron_semaphore_get_alternative($name, $timeout);
+        return elysia_cron_semaphore_get_alternative($name, $timeout);
     }
 
     db_lock_table('variable');
@@ -328,194 +328,194 @@ 
 
     $stuck = $semglob && (time() - $semglob > $timeout);
     if ($stuck || !$semglob) {
-      db_query("DELETE FROM {variable} WHERE name = '%s'", 'elysia_cron_semaphore');
-      db_query("INSERT INTO {variable} (name, value) VALUES ('%s', '%s')", 'elysia_cron_semaphore', serialize(time()));
-      $semglob = false; // We must return TRUE
+        db_query("DELETE FROM {variable} WHERE name = '%s'", 'elysia_cron_semaphore');
+        db_query("INSERT INTO {variable} (name, value) VALUES ('%s', '%s')", 'elysia_cron_semaphore', serialize(time()));
+        $semglob = false; // We must return TRUE
     }
     db_unlock_tables();
 
     if ($stuck) {
-      _dco_watchdog('cron', 'Global semaphore has been active for more than 2 minutes, probably stuck, reset.', array(), WATCHDOG_ERROR);
+        _dco_watchdog('cron', 'Global semaphore has been active for more than 2 minutes, probably stuck, reset.', array(), WATCHDOG_ERROR);
     }
 
     return !$semglob;
-  }
+    }
 }
 
 function _ec_get_name($name) {
-  $maxlen = EC_DRUPAL_VERSION >= 6 ? 120 : 40;
-  if (strlen($name) < $maxlen) {
+    $maxlen = EC_DRUPAL_VERSION >= 6 ? 120 : 40;
+    if (strlen($name) < $maxlen) {
     return $name;
-  }
-  $border = ($maxlen - 32) / 2;
-  return substr($name, 0, $border) . md5($name) . substr($name, -$border);
+    }
+    $border = ($maxlen - 32) / 2;
+    return substr($name, 0, $border) . md5($name) . substr($name, -$border);
 }
 
 function elysia_cron_set($name, $channel = false, $values = array()) {
-  if ($channel) {
+    if ($channel) {
     $name = ':' . $name;
-  }
+    }
 
-  if (EC_DRUPAL_VERSION >= 7) {
+    if (EC_DRUPAL_VERSION >= 7) {
     db_merge('elysia_cron')->key(array('name' => $name))->fields($values)->execute();
     
-  } else {
+    } else {
     $fields = array("name" => "'%s'", "disable" => "%d", "rule" => "'%s'", "weight" => "%d", "context" => "'%s'", "running" => "%d", "last_run" => "%d", "last_aborted" => "%d", "abort_count" => "%d", "last_abort_function" => "'%s'", "last_execution_time" => "%d", "execution_count" => "%d", "avg_execution_time" => "%f", "max_execution_time" => "%d", "last_shutdown_time" => "%d");
     $ifields = array('disable', 'running', 'last_run', 'last_aborted', 'abort_count', 'last_execution_time', 'execution_count', 'avg_execution_time', 'max_execution_time', 'last_shutdown_time');
     
     if (db_result(db_query('SELECT 1 FROM {elysia_cron} WHERE name = "%s"', $name))) {
-      $uquery = array();
-      $uvalues = array();
-      foreach ($values as $k => $v) {
+        $uquery = array();
+        $uvalues = array();
+        foreach ($values as $k => $v) {
         if (is_null($v) && !in_array($k, $ifields)) {
-          $uquery[] =  $k . ' = NULL';
+            $uquery[] =  $k . ' = NULL';
         }
         else {
-          $uquery[] =  $k . ' = ' . $fields[$k];
-          $uvalues[] = $v;
+            $uquery[] =  $k . ' = ' . $fields[$k];
+            $uvalues[] = $v;
         }
-      }
-      $uvalues[] = $name;
+        }
+        $uvalues[] = $name;
   
-      db_query("update {elysia_cron} set " . implode(', ', $uquery) . " where name = '%s'", $uvalues);
+        db_query("update {elysia_cron} set " . implode(', ', $uquery) . " where name = '%s'", $uvalues);
       
     } else {
-      foreach ($ifields as $f) {
+        foreach ($ifields as $f) {
         if (empty($values[$f])) {
-          $values[$f] = 0;
+            $values[$f] = 0;
+        }
         }
-      }
-      $values['name'] = $name;
+        $values['name'] = $name;
 
-      $iquery1 = array();
-      $iquery2 = array();
-      $ivalues = array();
-      foreach ($values as $k => $v) {
+        $iquery1 = array();
+        $iquery2 = array();
+        $ivalues = array();
+        foreach ($values as $k => $v) {
         if (!is_null($v)) {
-          $iquery1[] = $k;
-          $iquery2[] = $fields[$k];
-          $ivalues[] = $v;
+            $iquery1[] = $k;
+            $iquery2[] = $fields[$k];
+            $ivalues[] = $v;
+        }
         }
-      }
 
-      db_query("insert into {elysia_cron} (" . implode(', ', $iquery1) . ") values (" . implode(', ', $iquery2) . ")", $ivalues);
+        db_query("insert into {elysia_cron} (" . implode(', ', $iquery1) . ") values (" . implode(', ', $iquery2) . ")", $ivalues);
+    }
     }
-  }
 
-  global $elysia_cron_db_cache;
+    global $elysia_cron_db_cache;
 
-  unset($elysia_cron_db_cache[$name]);
+    unset($elysia_cron_db_cache[$name]);
 }
 
 function elysia_cron_get($name, $channel = false, $key, $default, $refresh = false) {
-  global $elysia_cron_db_cache;
-  static $elysia_cron_defaults;
+    global $elysia_cron_db_cache;
+    static $elysia_cron_defaults;
   
-  if (!isset($elysia_cron_defaults)) {
+    if (!isset($elysia_cron_defaults)) {
     $elysia_cron_defaults = function_exists('elysia_cron_get_ctools_defaults') ? elysia_cron_get_ctools_defaults() : array();
-  }
+    }
 
-  if ($channel) {
+    if ($channel) {
     $name = ':' . $name;
-  }
+    }
   
-  if ($refresh || !isset($elysia_cron_db_cache[$name])) {
+    if ($refresh || !isset($elysia_cron_db_cache[$name])) {
     if (EC_DRUPAL_VERSION >= 7) {
-      $elysia_cron_db_cache[$name] = db_query("select " . implode(", ", $GLOBALS['_ec_columns']) . " from {elysia_cron} where name = :name", array(':name' => $name))->fetchAssoc();
+        $elysia_cron_db_cache[$name] = db_query("select " . implode(", ", $GLOBALS['_ec_columns']) . " from {elysia_cron} where name = :name", array(':name' => $name))->fetchAssoc();
     }
     else {
-      $elysia_cron_db_cache[$name] = db_fetch_array(db_query("select " . implode(", ", $GLOBALS['_ec_columns']) . " from {elysia_cron} where name = '%s'", $name));
+        $elysia_cron_db_cache[$name] = db_fetch_array(db_query("select " . implode(", ", $GLOBALS['_ec_columns']) . " from {elysia_cron} where name = '%s'", $name));
     }
     
     if (!$elysia_cron_db_cache[$name] && isset($elysia_cron_defaults[$name])) {
-      $elysia_cron_db_cache[$name] = (array)$elysia_cron_defaults[$name];
+        $elysia_cron_db_cache[$name] = (array)$elysia_cron_defaults[$name];
     }
     elseif ($elysia_cron_db_cache[$name] && isset($elysia_cron_defaults[$name])) {
-      foreach($elysia_cron_defaults[$name] as $k => $v) {
+        foreach($elysia_cron_defaults[$name] as $k => $v) {
         if (!isset($elysia_cron_db_cache[$name][$k]) || is_null($elysia_cron_db_cache[$name][$k])) {
-          $elysia_cron_db_cache[$name][$k] = $v;
+            $elysia_cron_db_cache[$name][$k] = $v;
+        }
         }
-      }
     }
-  }
+    }
 
-  return !$elysia_cron_db_cache[$name] || !isset($elysia_cron_db_cache[$name][$key]) || is_null($elysia_cron_db_cache[$name][$key]) ? $default : $elysia_cron_db_cache[$name][$key];
+    return !$elysia_cron_db_cache[$name] || !isset($elysia_cron_db_cache[$name][$key]) || is_null($elysia_cron_db_cache[$name][$key]) ? $default : $elysia_cron_db_cache[$name][$key];
 }
 
 function elysia_cron_is_channel_disabled($channel, $default = false, $refresh = false) {
-  // May be overriden by a static conf
-  if (isset($GLOBALS['conf'][$n = 'ecc_' . _ec_get_name($channel) . '_d'])) {
+    // May be overriden by a static conf
+    if (isset($GLOBALS['conf'][$n = 'ecc_' . _ec_get_name($channel) . '_d'])) {
     return $GLOBALS['conf'][$n];
-  }
-  return elysia_cron_get($channel, true, 'disable', $default, $refresh);
+    }
+    return elysia_cron_get($channel, true, 'disable', $default, $refresh);
 }
 
 function elysia_cron_set_channel_disabled($channel, $v) {
-  return elysia_cron_set($channel, true, array('disable' => $v ? 1 : 0));
+    return elysia_cron_set($channel, true, array('disable' => $v ? 1 : 0));
 }
 
 function elysia_cron_reset_channel_disabled($channel) {
-  return elysia_cron_set($channel, true, array('disable' => 0));
+    return elysia_cron_set($channel, true, array('disable' => 0));
 }
 
 function elysia_cron_get_channel_rule($channel, $default = '', $refresh = false) {
-  // May be overriden by a static conf
-  if (isset($GLOBALS['conf'][$n = 'ecc_' . _ec_get_name($channel) . '_rul'])) {
+    // May be overriden by a static conf
+    if (isset($GLOBALS['conf'][$n = 'ecc_' . _ec_get_name($channel) . '_rul'])) {
     return $GLOBALS['conf'][$n];
-  }
-  return elysia_cron_get($channel, true, 'rule', $default, $refresh);
+    }
+    return elysia_cron_get($channel, true, 'rule', $default, $refresh);
 }
 
 function elysia_cron_set_channel_rule($channel, $v) {
-  return elysia_cron_set($channel, true, array('rule' => $v));
+    return elysia_cron_set($channel, true, array('rule' => $v));
 }
 
 function elysia_cron_reset_channel_rule($channel) {
-  return elysia_cron_set($channel, true, array('rule' => NULL));
+    return elysia_cron_set($channel, true, array('rule' => NULL));
 }
 
 function elysia_cron_is_channel_running($channel, $default = 0, $refresh = false) {
-  return elysia_cron_get($channel, true, 'running', $default, $refresh);
+    return elysia_cron_get($channel, true, 'running', $default, $refresh);
 }
 
 function elysia_cron_set_channel_running($channel, $v) {
-  return elysia_cron_set($channel, true, array('running' => $v));
+    return elysia_cron_set($channel, true, array('running' => $v));
 }
 
 function elysia_cron_get_channel_last_run($channel, $default = false, $refresh = false) {
-  return elysia_cron_get($channel, true, 'last_run', $default, $refresh);
+    return elysia_cron_get($channel, true, 'last_run', $default, $refresh);
 }
 
 function elysia_cron_set_channel_last_run($channel, $v) {
-  return elysia_cron_set($channel, true, array('last_run' => $v));
+    return elysia_cron_set($channel, true, array('last_run' => $v));
 }
 
 function elysia_cron_get_channel_last_aborted($channel, $default = 0, $refresh = false) {
-  return elysia_cron_get($channel, true, 'last_aborted', $default, $refresh);
+    return elysia_cron_get($channel, true, 'last_aborted', $default, $refresh);
 }
 
 function elysia_cron_set_channel_last_aborted($channel, $v) {
-  return elysia_cron_set($channel, true, array('last_aborted' => $v ? 1 : 0));
+    return elysia_cron_set($channel, true, array('last_aborted' => $v ? 1 : 0));
 }
 
 function elysia_cron_get_channel_abort_count($channel, $default = 0, $refresh = false) {
-  return elysia_cron_get($channel, true, 'abort_count', $default, $refresh);
+    return elysia_cron_get($channel, true, 'abort_count', $default, $refresh);
 }
 
 function elysia_cron_set_channel_abort_count($channel, $v) {
-  return elysia_cron_set($channel, true, array('abort_count' => $v));
+    return elysia_cron_set($channel, true, array('abort_count' => $v));
 }
 
 function elysia_cron_get_channel_last_abort_function($channel, $default = '', $refresh = false) {
-  return elysia_cron_get($channel, true, 'last_abort_function', $default, $refresh);
+    return elysia_cron_get($channel, true, 'last_abort_function', $default, $refresh);
 }
 
 function elysia_cron_set_channel_last_abort_function($channel, $job) {
-  return elysia_cron_set($channel, true, array('last_abort_function' => $v));
+    return elysia_cron_set($channel, true, array('last_abort_function' => $v));
 }
 
 function elysia_cron_get_channel_stats($channel, $refresh = false) {
-  return array(
+    return array(
     'last_run' => elysia_cron_get($channel, true, 'last_run', 0, $refresh),
     'last_execution_time' => elysia_cron_get($channel, true, 'last_execution_time', 0, $refresh),
     'execution_count' => elysia_cron_get($channel, true, 'execution_count', 0, $refresh),
@@ -525,174 +525,174 @@ 
     'last_aborted' => elysia_cron_get($channel, true, 'last_aborted', 0, $refresh),
     'abort_count' => elysia_cron_get($channel, true, 'abort_count', 0, $refresh),
     'last_abort_function' => elysia_cron_get($channel, true, 'last_abort_function', 0, ''),
-  );
+    );
 }
 
 function elysia_cron_set_channel_stats($channel, $last_run = -1, $last_execution_time = -1, $execution_count = -1,
     $avg_execution_time = -1, $max_execution_time = -1, $last_shutdown_time = -1, $last_aborted = -1,
     $abort_count = -1, $last_abort_function = -1, $data = array()) {
-  if ($last_run != -1) {
+    if ($last_run != -1) {
     $data['last_run'] = $last_run;
-  }
-  if ($last_execution_time != -1) {
+    }
+    if ($last_execution_time != -1) {
     $data['last_execution_time'] = $last_execution_time;
-  }
-  if ($execution_count != -1) {
+    }
+    if ($execution_count != -1) {
     $data['execution_count'] = $execution_count;
-  }
-  if ($avg_execution_time != -1) {
+    }
+    if ($avg_execution_time != -1) {
     $data['avg_execution_time'] = $avg_execution_time;
-  }
-  if ($max_execution_time != -1) {
+    }
+    if ($max_execution_time != -1) {
     $data['max_execution_time'] = $max_execution_time;
-  }
-  if ($last_shutdown_time != -1) {
+    }
+    if ($last_shutdown_time != -1) {
     $data['last_shutdown_time'] = $last_shutdown_time;
-  }
-  if ($last_aborted != -1) {
+    }
+    if ($last_aborted != -1) {
     $data['last_aborted'] = $last_aborted;
-  }
-  if ($abort_count != -1) {
+    }
+    if ($abort_count != -1) {
     $data['abort_count'] = $abort_count;
-  }
-  if ($last_abort_function != -1) {
+    }
+    if ($last_abort_function != -1) {
     $data['last_abort_function'] = $last_abort_function;
-  }
-  elysia_cron_set($channel, true, $data);
+    }
+    elysia_cron_set($channel, true, $data);
 }
 
 function elysia_cron_get_job_rule($job, $default = '', $refresh = false) {
-  // May be overriden by a static conf
-  if (isset($GLOBALS['conf'][$n = 'ec_' . _ec_get_name($job) . '_rul'])) {
+    // May be overriden by a static conf
+    if (isset($GLOBALS['conf'][$n = 'ec_' . _ec_get_name($job) . '_rul'])) {
     return $GLOBALS['conf'][$n];
-  }
-  return elysia_cron_get($job, false, 'rule', $default, $refresh);
+    }
+    return elysia_cron_get($job, false, 'rule', $default, $refresh);
 }
 
 function elysia_cron_set_job_rule($job, $v) {
-  return elysia_cron_set($job, false, array('rule' => $v));
+    return elysia_cron_set($job, false, array('rule' => $v));
 }
 
 function elysia_cron_reset_job_rule($job) {
-  return elysia_cron_set($job, false, array('rule' => null));
+    return elysia_cron_set($job, false, array('rule' => null));
 }
 
 function elysia_cron_get_job_weight($job, $default = '', $refresh = false) {
-  // May be overriden by a static conf
-  if (isset($GLOBALS['conf'][$n = 'ec_' . _ec_get_name($job) . '_w'])) {
+    // May be overriden by a static conf
+    if (isset($GLOBALS['conf'][$n = 'ec_' . _ec_get_name($job) . '_w'])) {
     return $GLOBALS['conf'][$n];
-  }
-  return elysia_cron_get($job, false, 'weight', $default, $refresh);
+    }
+    return elysia_cron_get($job, false, 'weight', $default, $refresh);
 }
 
 function elysia_cron_set_job_weight($job, $v) {
-  return elysia_cron_set($job, false, array('weight' => $v));
+    return elysia_cron_set($job, false, array('weight' => $v));
 }
 
 function elysia_cron_reset_job_weight($job) {
-  return elysia_cron_set($job, false, array('weight' => null));
+    return elysia_cron_set($job, false, array('weight' => null));
 }
 
 function elysia_cron_is_job_disabled($job, $default = false, $refresh = false) {
-  // May be overriden by a static conf
-  if (isset($GLOBALS['conf'][$n = 'ec_' . _ec_get_name($job) . '_d'])) {
+    // May be overriden by a static conf
+    if (isset($GLOBALS['conf'][$n = 'ec_' . _ec_get_name($job) . '_d'])) {
     return $GLOBALS['conf'][$n];
-  }
-  return elysia_cron_get($job, false, 'disable', $default, $refresh);
+    }
+    return elysia_cron_get($job, false, 'disable', $default, $refresh);
 }
 
 function elysia_cron_set_job_disabled($job, $v) {
-  return elysia_cron_set($job, false, array('disable' => $v ? 1 : 0));
+    return elysia_cron_set($job, false, array('disable' => $v ? 1 : 0));
 }
 
 function elysia_cron_reset_job_disabled($job) {
-  return elysia_cron_set($job, false, array('disable' => null));
+    return elysia_cron_set($job, false, array('disable' => null));
 }
 
 function elysia_cron_get_job_channel($job, $default = '', $refresh = false) {
-  // May be overriden by a static conf
-  if (isset($GLOBALS['conf'][$n = 'ec_' . _ec_get_name($job) . '_c'])) {
+    // May be overriden by a static conf
+    if (isset($GLOBALS['conf'][$n = 'ec_' . _ec_get_name($job) . '_c'])) {
     $c = $GLOBALS['conf'][$n];
-  }
-  else {
+    }
+    else {
     $c = elysia_cron_get($job, false, 'context', $default, $refresh);
-  }
-  return !$c ? $default : $c;
+    }
+    return !$c ? $default : $c;
 }
 
 function elysia_cron_set_job_channel($job, $v) {
-  return elysia_cron_set($job, false, array('context' => $v));
+    return elysia_cron_set($job, false, array('context' => $v));
 }
 
 function elysia_cron_reset_job_channel($job) {
-  return elysia_cron_set($job, false, array('context' => null));
+    return elysia_cron_set($job, false, array('context' => null));
 }
 
 function elysia_cron_is_job_running($job, $default = 0, $refresh = false) {
-  return elysia_cron_get($job, false, 'running', $default, $refresh);
+    return elysia_cron_get($job, false, 'running', $default, $refresh);
 }
 
 function elysia_cron_set_job_running($job, $v) {
-  return elysia_cron_set($job, false, array('running' => $v));
+    return elysia_cron_set($job, false, array('running' => $v));
 }
 
 function elysia_cron_get_job_last_run($job, $default = 0, $refresh = false) {
-  return elysia_cron_get($job, false, 'last_run', $default, $refresh);
+    return elysia_cron_get($job, false, 'last_run', $default, $refresh);
 }
 
 function elysia_cron_set_job_last_run($job, $v) {
-  return elysia_cron_set($job, false, array('last_run' => $v));
+    return elysia_cron_set($job, false, array('last_run' => $v));
 }
 
 function elysia_cron_get_job_stats($job, $refresh = false) {
-  return array(
+    return array(
     'last_run' => elysia_cron_get($job, false, 'last_run', 0, $refresh),
     'last_execution_time' => elysia_cron_get($job, false, 'last_execution_time', 0, $refresh),
     'execution_count' => elysia_cron_get($job, false, 'execution_count', 0, $refresh),
     'avg_execution_time' => elysia_cron_get($job, false, 'avg_execution_time', 0, $refresh),
     'max_execution_time' => elysia_cron_get($job, false, 'max_execution_time', 0, $refresh),
-  );
+    );
 }
 
 function elysia_cron_set_job_stats($job, $last_run = -1, $last_execution_time = -1, $execution_count = -1,
-  $avg_execution_time = -1, $max_execution_time = -1, $data = array()) {
-  if ($last_run != -1) {
+    $avg_execution_time = -1, $max_execution_time = -1, $data = array()) {
+    if ($last_run != -1) {
     $data['last_run'] = $last_run;
-  }
-  if ($last_execution_time != -1) {
+    }
+    if ($last_execution_time != -1) {
     $data['last_execution_time'] = $last_execution_time;
-  }
-  if ($execution_count != -1) {
+    }
+    if ($execution_count != -1) {
     $data['execution_count'] = $execution_count;
-  }
-  if ($avg_execution_time != -1) {
+    }
+    if ($avg_execution_time != -1) {
     $data['avg_execution_time'] = $avg_execution_time;
-  }
-  if ($max_execution_time != -1) {
+    }
+    if ($max_execution_time != -1) {
     $data['max_execution_time'] = $max_execution_time;
-  }
-  elysia_cron_set($job, false, $data);
+    }
+    elysia_cron_set($job, false, $data);
 }
 
 function elysia_cron_last_channel() {
-  return _ec_variable_get('elysia_cron_last_context', '');
+    return _ec_variable_get('elysia_cron_last_context', '');
 }
 
 function elysia_cron_set_last_channel($channel) {
-  _ec_variable_set('elysia_cron_last_context', $channel);
+    _ec_variable_set('elysia_cron_last_context', $channel);
 }
 
 function elysia_cron_reset_stats() {
-  global $elysia_cron_settings, $elysia_cron_settings_by_channel;
-  elysia_cron_initialize();
+    global $elysia_cron_settings, $elysia_cron_settings_by_channel;
+    elysia_cron_initialize();
 
-  foreach ($elysia_cron_settings as $job => $conf) {
+    foreach ($elysia_cron_settings as $job => $conf) {
     elysia_cron_set_job_stats($job, -1, 0, 0, 0, 0);
-  }
+    }
 
-  foreach ($elysia_cron_settings_by_channel as $channel => $conf) {
+    foreach ($elysia_cron_settings_by_channel as $channel => $conf) {
     elysia_cron_set_channel_stats($channel, -1, 0, 0, 0, 0, 0, 0, 0, 0);
-  }
+    }
 }
 
 /*******************************************************************************
@@ -704,236 +704,236 @@ 
  *******************************************************************************/
 
 function elysia_cron_decode_script($text, $apply = true) {
-  global $elysia_cron_settings;
+    global $elysia_cron_settings;
 
-  $lines = explode("\n", $text);
-  $lastcomment = '';
-  $errors = array();
-  $conf = array();
-  foreach ($lines as $line) {
+    $lines = explode("\n", $text);
+    $lastcomment = '';
+    $errors = array();
+    $conf = array();
+    foreach ($lines as $line) {
     $line = trim($line);
     if (!empty($line)) {
-      if ($line{0} == '#') {
+        if ($line{0} == '#') {
         $lastcomment = trim(substr($line, 1));
 
-      }
-      else if (preg_match('/^(-[ ]*|)([0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+)[ ]+((?:ctx|ch):([a-zA-Z0-9_-]+)[ ]+|)([^(:]+)(\(.*\);|)$/', $line, $r)) {
+        }
+        else if (preg_match('/^(-[ ]*|)([0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+)[ ]+((?:ctx|ch):([a-zA-Z0-9_-]+)[ ]+|)([^(:]+)(\(.*\);|)$/', $line, $r)) {
         $c = array(
-          'disabled' => !empty($r[1]),
-          'rule' => $r[2],
-          'description' => $lastcomment,
-          'channel' => $r[4] ? $r[4] : 'default',
+            'disabled' => !empty($r[1]),
+            'rule' => $r[2],
+            'description' => $lastcomment,
+            'channel' => $r[4] ? $r[4] : 'default',
         );
         $lastcomment = '';
         if (empty($r[6])) {
-          if (!isset($elysia_cron_settings[$r[5]])) {
+            if (!isset($elysia_cron_settings[$r[5]])) {
             // Referring a module function that not exists
             $errors[] = $line;
             continue;
-          }
-          $name = $r[5];
+            }
+            $name = $r[5];
         }
         else {
-          // custom expression, generate a unique name
-          $postfix = '';
-          while (isset($elysia_cron_settings[$r[5] . $postfix])) {
+            // custom expression, generate a unique name
+            $postfix = '';
+            while (isset($elysia_cron_settings[$r[5] . $postfix])) {
             $postfix = ($postfix ? $postfix : 0) + 1;
-          }
-          $name = $r[5] . $postfix;
-          $c['expression'] = $r[5] . $r[6];
+            }
+            $name = $r[5] . $postfix;
+            $c['expression'] = $r[5] . $r[6];
         }
         if ($apply) {
-          $elysia_cron_settings[$name] = isset($elysia_cron_settings[$name]) ? array_merge($elysia_cron_settings[$name], $c) : $c;
+            $elysia_cron_settings[$name] = isset($elysia_cron_settings[$name]) ? array_merge($elysia_cron_settings[$name], $c) : $c;
         }
 
-      }
-      else {
+        }
+        else {
         $errors[] = $line;
-      }
+        }
     }
     else {
-      $lastcomment = '';
+        $lastcomment = '';
+    }
     }
-  }
 
-  return count($errors) ? $errors : false;
+    return count($errors) ? $errors : false;
 }
 
 function elysia_cron_module_jobs() {
-  static $jobs;
-  if (!isset($jobs)) {
+    static $jobs;
+    if (!isset($jobs)) {
     $jobs = array();
     foreach (module_implements('cron') as $module) {
-      if ($module != 'elysia_cron') {
+        if ($module != 'elysia_cron') {
         $jobs[$module . '_cron'] = array(
-          'module' => $module,
-          'callback' => $module . '_cron',
-          'arguments' => array(),
+            'module' => $module,
+            'callback' => $module . '_cron',
+            'arguments' => array(),
         );
-      }
+        }
     }
   
     foreach (module_implements('cronapi') as $module) {
-      $fn = $module . '_cronapi';
-      $l = $fn('list');
-      if (is_array($l)) {
+        $fn = $module . '_cronapi';
+        $l = $fn('list');
+        if (is_array($l)) {
         foreach ($l as $job => $data) {
-          if (is_array($data)) {
+            if (is_array($data)) {
             $jobs[$job] = $data;
-          } else {
+            } else {
             // Compatibility with v1.x settings
             $jobs[$job] = array(
-              'description' => $data,
-              'rule' => ($d = $fn('rule', $job)) ? $d : false,
-              'weight' => ($d = $fn('weight', $job)) ? $d : 0,
+                'description' => $data,
+                'rule' => ($d = $fn('rule', $job)) ? $d : false,
+                'weight' => ($d = $fn('weight', $job)) ? $d : 0,
             );
-          }
-          $jobs[$job] = $jobs[$job] + array(
+            }
+            $jobs[$job] = $jobs[$job] + array(
             'module' => $module,
             'callback' => function_exists($job) ? $job : $fn,
             'arguments' => function_exists($job) ? array() : array('execute', $job),
-          );
+            );
+        }
         }
-      }
     }
     if (function_exists('drupal_alter'))
-      drupal_alter('cron', $jobs);
-  }
+        drupal_alter('cron', $jobs);
+    }
 
-  return $jobs;
+    return $jobs;
 }
 
 function elysia_cron_initialize($skipscript = false) {
-  elysia_cron_check_version_update();
+    elysia_cron_check_version_update();
 
-  global $elysia_cron_settings, $elysia_cron_settings_by_channel;
-  $elysia_cron_settings = array();
-  $elysia_cron_settings_by_channel = array();
+    global $elysia_cron_settings, $elysia_cron_settings_by_channel;
+    $elysia_cron_settings = array();
+    $elysia_cron_settings_by_channel = array();
 
-  foreach (elysia_cron_module_jobs() as $job => $jobpars) {
+    foreach (elysia_cron_module_jobs() as $job => $jobpars) {
     $channel = elysia_cron_get_job_channel($job, 'default');
 
     $defrule = !empty($jobpars['rule']) ? $jobpars['rule'] : elysia_cron_get_channel_rule($channel);
     if (!$defrule) {
-      $defrule = variable_get('elysia_cron_default_rule', '0 * * * *');
+        $defrule = variable_get('elysia_cron_default_rule', '0 * * * *');
     }
     
     $defweight = !empty($jobpars['weight']) ? $jobpars['weight'] : 0;
     if (!is_numeric($defweight)) {
-      $defweight = 0;
+        $defweight = 0;
     }
 
     $elysia_cron_settings[$job] = array(
-      'key' => $job,
-      'channel' => $channel,
-      'rule' => elysia_cron_get_job_rule($job, $defrule),
-      'default_rule' => $defrule,
-      'weight' => elysia_cron_get_job_weight($job, $defweight),
-      'default_weight' => $defweight,
-      'disabled' => elysia_cron_is_job_disabled($job),
-      'running' => elysia_cron_is_job_running($job),
+        'key' => $job,
+        'channel' => $channel,
+        'rule' => elysia_cron_get_job_rule($job, $defrule),
+        'default_rule' => $defrule,
+        'weight' => elysia_cron_get_job_weight($job, $defweight),
+        'default_weight' => $defweight,
+        'disabled' => elysia_cron_is_job_disabled($job),
+        'running' => elysia_cron_is_job_running($job),
     ) + $jobpars;
-  }
-  if (!$skipscript) {
+    }
+    if (!$skipscript) {
     $script = variable_get('elysia_cron_script', false);
     if ($script) {
-      elysia_cron_decode_script($script);
+        elysia_cron_decode_script($script);
+    }
     }
-  }
 
-  uasort($elysia_cron_settings, '_elysia_cron_sort');
-  foreach ($elysia_cron_settings as $job => &$conf) {
+    uasort($elysia_cron_settings, '_elysia_cron_sort');
+    foreach ($elysia_cron_settings as $job => &$conf) {
     $stats = elysia_cron_get_job_stats($job);
     foreach ($stats as $sk => $sv) {
-      $conf[$sk] = $sv;
+        $conf[$sk] = $sv;
     }
     $elysia_cron_settings_by_channel[$conf['channel']][$job] = &$elysia_cron_settings[$job];
-  }
+    }
 
-  foreach ($elysia_cron_settings_by_channel as $channel => $data) {
+    foreach ($elysia_cron_settings_by_channel as $channel => $data) {
     uasort($elysia_cron_settings_by_channel[$channel], '_elysia_cron_sort');
     $elysia_cron_settings_by_channel[$channel]['#data'] = elysia_cron_get_channel_stats($channel);
     $elysia_cron_settings_by_channel[$channel]['#data']['disabled'] = elysia_cron_is_channel_disabled($channel);
-  }
+    }
 }
 
 function _elysia_cron_sort($a, $b) {
-  if ((isset($a['weight']) ? $a['weight'] : 0) == (isset($b['weight']) ? $b['weight'] : 0)) {
+    if ((isset($a['weight']) ? $a['weight'] : 0) == (isset($b['weight']) ? $b['weight'] : 0)) {
     return strcmp((isset($a['key']) ? $a['key'] : ''), (isset($b['key']) ? $b['key'] : ''));
-  }
-  return (isset($a['weight']) ? $a['weight'] : 0) - (isset($b['weight']) ? $b['weight'] : 0);
+    }
+    return (isset($a['weight']) ? $a['weight'] : 0) - (isset($b['weight']) ? $b['weight'] : 0);
 }
 
 function elysia_cron_run($manual_run = false) {
-  global $conf;
+    global $conf;
 
-  // Allow execution to continue even if the request gets canceled.
-  @ignore_user_abort(true);
+    // Allow execution to continue even if the request gets canceled.
+    @ignore_user_abort(true);
 
-  // Try to allocate enough time to run all the hook_cron implementations.
-  if (!ini_get('safe_mode')) {
+    // Try to allocate enough time to run all the hook_cron implementations.
+    if (!ini_get('safe_mode')) {
     set_time_limit(variable_get('elysia_cron_time_limit', 240));
-  }
+    }
 
-  // Prevent session information from being saved while cron is running.
-  if (EC_DRUPAL_VERSION >= 7) {
+    // Prevent session information from being saved while cron is running.
+    if (EC_DRUPAL_VERSION >= 7) {
     drupal_save_session(FALSE);
-  }
+    }
 
-  // If DISABLED block the execution
-  if (variable_get('elysia_cron_disabled', false)) {
+    // If DISABLED block the execution
+    if (variable_get('elysia_cron_disabled', false)) {
     return;
-  }
+    }
 
-  // Check for CRON_KEY or ALLOWED_HOSTS
-  if (!$manual_run) {
+    // Check for CRON_KEY or ALLOWED_HOSTS
+    if (!$manual_run) {
     $cron_key = variable_get('cron_key', '');
     if ($cron_key && !user_access('administer elysia_cron') && (empty($_GET['cron_key']) || $_GET['cron_key'] != $cron_key)) {
-      return;
+        return;
     }
     $allowed_hosts = variable_get('elysia_cron_allowed_hosts', false);
     if ($allowed_hosts && !user_access('administer elysia_cron') && !in_array(ip_address(), explode(",", $allowed_hosts))) {
-      return;
+        return;
+    }
     }
-  }
 
-  _ec_variable_set('elysia_cron_last_run', time());
-  _ec_variable_set('cron_last', time());
+    _ec_variable_set('elysia_cron_last_run', time());
+    _ec_variable_set('cron_last', time());
 
-  $execute = true;
-  if (EC_DRUPAL_VERSION >= 7) {
+    $execute = true;
+    if (EC_DRUPAL_VERSION >= 7) {
     if (!lock_acquire('cron', 240.0)) {
-      _dco_watchdog('cron', 'Attempting to re-run cron while it is already running.', array(), WATCHDOG_WARNING);
-      $execute = false;
+        _dco_watchdog('cron', 'Attempting to re-run cron while it is already running.', array(), WATCHDOG_WARNING);
+        $execute = false;
     }
-  }
-  else {
+    }
+    else {
     // Global Semaphore to avoid concurrent execution of cron preparation code
     $execute = _ec_semaphore_get('elysia_cron_semaphore', 120);
-  }
+    }
 
-  // Force the current user to anonymous to ensure consistent permissions on
-  // cron runs (only if run by interface)
-  if ($manual_run) {
+    // Force the current user to anonymous to ensure consistent permissions on
+    // cron runs (only if run by interface)
+    if ($manual_run) {
     $original_user = $GLOBALS['user'];
     $GLOBALS['user'] = drupal_anonymous_user();
-  }
+    }
 
-  if (EC_DRUPAL_VERSION >= 7) {
+    if (EC_DRUPAL_VERSION >= 7) {
     // D7 Queue processing
     // Grab the defined cron queues (even if execute = false)
     $queues = module_invoke_all('cron_queue_info');
     drupal_alter('cron_queue_info', $queues);
-  }
+    }
 
-  if ($execute) {
+    if ($execute) {
     if (EC_DRUPAL_VERSION >= 7) {
-      // D7 Queue processing
-      // Make sure every queue exists. There is no harm in trying to recreate an
-      // existing queue.
-      foreach ($queues as $queue_name => $info) {
+        // D7 Queue processing
+        // Make sure every queue exists. There is no harm in trying to recreate an
+        // existing queue.
+        foreach ($queues as $queue_name => $info) {
         DrupalQueue::get($queue_name)->createQueue();
-      }
+        }
     }
 
     elysia_cron_initialize();
@@ -944,48 +944,48 @@ 
 
     $i = array_search($channel, $channels);
     if ($i === FALSE) {
-      $i = -1;
+        $i = -1;
     }
     $k = 0;
     $jobs = false;
     $stuck_time = variable_get('elysia_cron_stuck_time', 3600);
     for ($j = ($i + 1) % count($channels); $k < count($channels); $j = ($j + 1) % count($channels)) {
-      $sem = elysia_cron_is_channel_running($channels[$j]);
-      if ($sem && (time() - $sem > $stuck_time)) {
+        $sem = elysia_cron_is_channel_running($channels[$j]);
+        if ($sem && (time() - $sem > $stuck_time)) {
         elysia_cron_set_channel_running($channels[$j], 0);
         $last_job = elysia_cron_execute_aborted($channels[$j]);
         unset($sem);
         _dco_watchdog('cron', 'Cron channel (%channel) has been running for more than an %stuck_time secs and is most likely stuck. Last job executed: %job', array('%channel' => $channels[$j], '%stuck_time' => $stuck_time, '%job' => $last_job), WATCHDOG_ERROR);
-      }
-      if (empty($sem) && !$elysia_cron_settings_by_channel[$channels[$j]]['#data']['disabled']) {
+        }
+        if (empty($sem) && !$elysia_cron_settings_by_channel[$channels[$j]]['#data']['disabled']) {
         $jobs = elysia_cron_active_jobs($channels[$j]);
         if (count($jobs)) {
-          break;
+            break;
+        }
         }
-      }
-      $k++;
+        $k++;
     }
 
     if ($jobs && count($jobs)) {
-      // There are jobs ready to be executed
+        // There are jobs ready to be executed
 
-      $elysia_cron_current_channel = $channels[$j];
-      elysia_cron_set_last_channel($elysia_cron_current_channel);
+        $elysia_cron_current_channel = $channels[$j];
+        elysia_cron_set_last_channel($elysia_cron_current_channel);
 
-      if (variable_get('elysia_cron_debug_messages', 0)) {
+        if (variable_get('elysia_cron_debug_messages', 0)) {
         _dco_watchdog('cron', 'Cron channel %channel run started.', array('%channel' => $elysia_cron_current_channel), WATCHDOG_NOTICE);
-      }
+        }
 
-      // Register shutdown callback
-      register_shutdown_function('elysia_cron_cleanup');
+        // Register shutdown callback
+        register_shutdown_function('elysia_cron_cleanup');
 
-      elysia_cron_set($elysia_cron_current_channel, true, array(
+        elysia_cron_set($elysia_cron_current_channel, true, array(
         'running' => time(),
         'last_run' => time(),
-      ));
+        ));
 
-      // Now I can unlock cron semaphore
-      if (EC_DRUPAL_VERSION < 7) {
+        // Now I can unlock cron semaphore
+        if (EC_DRUPAL_VERSION < 7) {
         _ec_variable_del('elysia_cron_semaphore');
 
         // Some modules (feedapi, ipaper...) uses the internal "cron_semaphore" variable to detect
@@ -993,149 +993,149 @@ 
         // (In normal drupal cron execution that is done by a variable_set just before this call,
         // but i need to set this manually if drupal cron is bypassed)
         $conf['cron_semaphore'] = time();
-      }
+        }
 
-      foreach ($jobs as $job) {
+        foreach ($jobs as $job) {
         $job_running = false;
         if (elysia_cron_is_job_running($job)) {
-          if (time() - elysia_cron_get_job_last_run($job, 0) > variable_get('elysia_cron_stuck_time', 3600)) {
+            if (time() - elysia_cron_get_job_last_run($job, 0) > variable_get('elysia_cron_stuck_time', 3600)) {
             _dco_watchdog('cron', 'Job %job is already running, but is probably stuck, so i consider it as terminated', array('%job' => $job), WATCHDOG_NOTICE);
-          }
-          else {
+            }
+            else {
             _dco_watchdog('cron', 'Job %job is already running', array('%job' => $job), WATCHDOG_NOTICE);
             $job_running = true;
-          }
+            }
         }
 
         if (!$job_running) {
-          elysia_cron_execute($job);
+            elysia_cron_execute($job);
+        }
         }
-      }
 
-      $cron_completed = true;
-      $cron_completed_time = time();
+        $cron_completed = true;
+        $cron_completed_time = time();
 
-      // Cron is really completed after shutdown functions
-      register_shutdown_function('elysia_cron_completed');
+        // Cron is really completed after shutdown functions
+        register_shutdown_function('elysia_cron_completed');
 
     }
     else {
-      // No jobs should be executed, i must unlock cron semaphore
-      if (EC_DRUPAL_VERSION < 7) {
+        // No jobs should be executed, i must unlock cron semaphore
+        if (EC_DRUPAL_VERSION < 7) {
         _ec_variable_del('elysia_cron_semaphore');
-      }
+        }
 
-      if (variable_get('elysia_cron_debug_messages', 0)) {
+        if (variable_get('elysia_cron_debug_messages', 0)) {
         _dco_watchdog('cron', 'No channels ready to be executed, skipping cron.', array(), WATCHDOG_NOTICE);
-      }
+        }
     }
 
     // Release cron lock.
     if (EC_DRUPAL_VERSION >= 7) {
-      lock_release('cron');
+        lock_release('cron');
 
     }
     else {
-      _ec_variable_del('cron_semaphore');
-      $conf['cron_semaphore'] = false;
+        _ec_variable_del('cron_semaphore');
+        $conf['cron_semaphore'] = false;
+    }
     }
-  }
 
-  if (EC_DRUPAL_VERSION >= 7) {
+    if (EC_DRUPAL_VERSION >= 7) {
     // D7 Queue processing
     foreach ($queues as $queue_name => $info) {
-      $function = $info['worker callback'];
-      $end = time() + (isset($info['time']) ? $info['time'] : 15);
-      $queue = DrupalQueue::get($queue_name);
-      while (time() < $end && ($item = $queue->claimItem())) {
+        $function = $info['worker callback'];
+        $end = time() + (isset($info['time']) ? $info['time'] : 15);
+        $queue = DrupalQueue::get($queue_name);
+        while (time() < $end && ($item = $queue->claimItem())) {
         $function($item->data);
         $queue->deleteItem($item);
-      }
+        }
+    }
     }
-  }
 
-  if ($manual_run) {
+    if ($manual_run) {
     // Restore the user.
     $GLOBALS['user'] = $original_user;
     /*if (EC_DRUPAL_VERSION >= 7) {
       drupal_save_session(TRUE);
     }*/
-  }
+    }
 
-  // Return TRUE so other functions can check if it did run successfully
-  return $execute;
+    // Return TRUE so other functions can check if it did run successfully
+    return $execute;
 }
 
 function elysia_cron_execute($job) {
-  global $elysia_cron_settings;
+    global $elysia_cron_settings;
 
-  if (variable_get('elysia_cron_debug_messages', 0)) {
+    if (variable_get('elysia_cron_debug_messages', 0)) {
     _dco_watchdog('cron', 'Cron job %job started.', array('%job' => $job), WATCHDOG_NOTICE);
-  }
+    }
 
-  $time = time();
-  elysia_cron_set($job, false, array(
+    $time = time();
+    elysia_cron_set($job, false, array(
     'running' => $time,
     'last_run' => $time,
-  ));
+    ));
 
-  try {
+    try {
     if (!empty($elysia_cron_settings[$job]['file'])) {
-      include_once((!empty($elysia_cron_settings[$job]['file path']) ? $elysia_cron_settings[$job]['file path'] : drupal_get_path('module', $elysia_cron_settings[$job]['module'])) . DIRECTORY_SEPARATOR . $elysia_cron_settings[$job]['file']);
+        include_once((!empty($elysia_cron_settings[$job]['file path']) ? $elysia_cron_settings[$job]['file path'] : drupal_get_path('module', $elysia_cron_settings[$job]['module'])) . DIRECTORY_SEPARATOR . $elysia_cron_settings[$job]['file']);
     }
     if (!empty($elysia_cron_settings[$job]['expression'])) {
-      eval($elysia_cron_settings[$job]['expression']);
+        eval($elysia_cron_settings[$job]['expression']);
     }
     elseif (!empty($elysia_cron_settings[$job]['callback']) && function_exists($elysia_cron_settings[$job]['callback'])) {
-      call_user_func_array($elysia_cron_settings[$job]['callback'], $elysia_cron_settings[$job]['arguments']);
+        call_user_func_array($elysia_cron_settings[$job]['callback'], $elysia_cron_settings[$job]['arguments']);
     }
     else {
-      _dco_watchdog('cron', 'Execution of ' . $job . ' failed, can\'t find function!', array(), WATCHDOG_ERROR);
+        _dco_watchdog('cron', 'Execution of ' . $job . ' failed, can\'t find function!', array(), WATCHDOG_ERROR);
+    }
     }
-  }
-  catch (Exception $e) {
+    catch (Exception $e) {
     _dco_watchdog('cron', 'Exception: ' . $e, array(), WATCHDOG_ERROR);
     $exception = true;
     //TODO Manage it
-  }
+    }
 
-  $stats = elysia_cron_get_job_stats($job);
-  $time = time() - $time;
-  elysia_cron_set_job_stats($job,
+    $stats = elysia_cron_get_job_stats($job);
+    $time = time() - $time;
+    elysia_cron_set_job_stats($job,
     -1,
     $time,
     ($c = $stats['execution_count'] + 1),
     round((($stats['avg_execution_time'] * ($c - 1)) + $time) / $c, 2),
     $time > $stats['max_execution_time'] ? $time : -1,
     array('running' => 0)
-  );
+    );
 
-  if (variable_get('elysia_cron_debug_messages', 0)) {
+    if (variable_get('elysia_cron_debug_messages', 0)) {
     _dco_watchdog('cron', 'Cron job %job ended.', array('%job' => $job), WATCHDOG_NOTICE);
-  }
+    }
 }
 
 function elysia_cron_execute_aborted($channel) {
-  global $elysia_cron_settings_by_channel;
+    global $elysia_cron_settings_by_channel;
 
-  $last_job = '';
-  foreach ($elysia_cron_settings_by_channel[$channel] as $job => $conf) {
+    $last_job = '';
+    foreach ($elysia_cron_settings_by_channel[$channel] as $job => $conf) {
     if ($job != '#data') {
-      if (elysia_cron_is_job_running($job)) {
+        if (elysia_cron_is_job_running($job)) {
         $last_job .= ' ' . $job;
         elysia_cron_set_job_running($job, 0);
-      }
+        }
+    }
     }
-  }
 
-  elysia_cron_set($channel, true, array(
+    elysia_cron_set($channel, true, array(
     'running' => 0, //time(),
     'last_aborted' => 1,
     'abort_count' => elysia_cron_get_channel_abort_count($channel) + 1,
     'last_abort_function' => $last_job,
-  ));
+    ));
 
-  return trim($last_job);
+    return trim($last_job);
 }
 
 /**
@@ -1144,36 +1144,36 @@ 
  * Used for unexpected termination of code.
  */
 function elysia_cron_cleanup() {
-  global $elysia_cron_settings, $elysia_cron_current_channel, $cron_completed, $cron_completed_time;
+    global $elysia_cron_settings, $elysia_cron_current_channel, $cron_completed, $cron_completed_time;
 
-  if ($cron_completed) {
+    if ($cron_completed) {
     return;
-  }
+    }
 
-  // See if the semaphore is still locked.
-  if (elysia_cron_is_channel_running($elysia_cron_current_channel)) {
+    // See if the semaphore is still locked.
+    if (elysia_cron_is_channel_running($elysia_cron_current_channel)) {
     $last_job = elysia_cron_execute_aborted($elysia_cron_current_channel);
     _dco_watchdog('cron', 'Unexpected termination of cron channel %channel, aborted. Last job executed: %job', array('%channel' => $elysia_cron_current_channel, '%job' => $last_job), WATCHDOG_WARNING);
-  }
+    }
 }
 
 /**
  * Successful termination (after all shutdown hooks invoked by cron functions).
  */
 function elysia_cron_completed() {
-  global $elysia_cron_settings, $elysia_cron_current_channel, $cron_completed, $cron_completed_time;
-  //dprint("completed ".$elysia_cron_current_channel);
+    global $elysia_cron_settings, $elysia_cron_current_channel, $cron_completed, $cron_completed_time;
+    //dprint("completed ".$elysia_cron_current_channel);
 
-  // Record cron time
-  _ec_variable_set('cron_last', time());
+    // Record cron time
+    _ec_variable_set('cron_last', time());
 
-  if (variable_get('elysia_cron_debug_messages', 0)) {
+    if (variable_get('elysia_cron_debug_messages', 0)) {
     _dco_watchdog('cron', 'Cron channel %channel run completed.', array('%channel' => $elysia_cron_current_channel), WATCHDOG_NOTICE);
-  }
+    }
 
-  $stats = elysia_cron_get_channel_stats($elysia_cron_current_channel);
-  $time = time() - $stats['last_run'];
-  elysia_cron_set_channel_stats($elysia_cron_current_channel,
+    $stats = elysia_cron_get_channel_stats($elysia_cron_current_channel);
+    $time = time() - $stats['last_run'];
+    elysia_cron_set_channel_stats($elysia_cron_current_channel,
     -1, // last_run
     $time, // last_execution_time
     ($c = $stats['execution_count'] + 1), // execution_count
@@ -1182,24 +1182,24 @@ 
     time() - $cron_completed_time, // last_shutdown_time
     0, -1, -1, // last_aborted, abort_count, last_abort_function
     array('running' => 0)
-  );
+    );
 }
 
 /**
  * Get all jobs that needs to be executed in a channel
  */
 function elysia_cron_active_jobs($channel) {
-  global $elysia_cron_settings_by_channel;
+    global $elysia_cron_settings_by_channel;
 
-  $jobs = array();
-  foreach ($elysia_cron_settings_by_channel[$channel] as $job => $conf) {
+    $jobs = array();
+    foreach ($elysia_cron_settings_by_channel[$channel] as $job => $conf) {
     if ($job != '#data') {
-      if (elysia_cron_should_run($conf)) {
+        if (elysia_cron_should_run($conf)) {
         $jobs[] = $job;
-      }
+        }
     }
-  }
-  return $jobs;
+    }
+    return $jobs;
 }
 
 /**
@@ -1207,32 +1207,32 @@ 
  * (Not used by elysia_cron, can be used by external modules)
  */
 function elysia_cron_is_running() {
-  global $elysia_cron_settings_by_channel;
-  elysia_cron_initialize();
+    global $elysia_cron_settings_by_channel;
+    elysia_cron_initialize();
 
-  $running = array();
-  foreach ($elysia_cron_settings_by_channel as $channel => $data) {
+    $running = array();
+    foreach ($elysia_cron_settings_by_channel as $channel => $data) {
     if (elysia_cron_is_channel_running($channel)) {
-      $running[] = $channel;
+        $running[] = $channel;
+    }
     }
-  }
 
-  return $running;
+    return $running;
 }
 
 /**
  * Obtain job description (translated)
  */
 function elysia_cron_description($job) {
-  global $elysia_cron_settings;
+    global $elysia_cron_settings;
 
-  if (!empty($elysia_cron_settings[$job]['description'])) {
+    if (!empty($elysia_cron_settings[$job]['description'])) {
     $desc = $elysia_cron_settings[$job]['description'];
-  }
-  else {
+    }
+    else {
     $desc = _dco_theme('elysia_cron_description', array('job' => $job));
-  }
-  return t($desc);
+    }
+    return t($desc);
 }
 
 /*******************************************************************************
@@ -1243,22 +1243,22 @@ 
  * Implementation of hook_theme(). [Only D6+D7]
  */
 function elysia_cron_theme() {
-  return _dcr_hook_theme(array(
+    return _dcr_hook_theme(array(
     'elysia_cron_description' => array(
-      'variables' => array('job' => NULL),
+        'variables' => array('job' => NULL),
     ),
     'elysia_cron_settings_form' => array(
-      'render element' => 'form',
+        'render element' => 'form',
     ),
-  ));
+    ));
 }
 
 /**
  * You can theme this function to provide your (untranslated) descriptions for cron functions, if they do not provide one.
  */
 function theme_elysia_cron_description($variables) {
-  extract(_dcf_theme_signature(array('job' => $variables)));
-  switch ($variables['job']) {
+    extract(_dcf_theme_signature(array('job' => $variables)));
+    switch ($variables['job']) {
     case 'search_cron':
       return 'Update search database index';
     case 'activitystream_cron':
@@ -1313,7 +1313,7 @@ 
       return 'Checks for available updates of Drupal core, contributed modules and themes';
     default:
       return '-';
-  }
+    }
 }
 
 /*******************************************************************************
@@ -1324,19 +1324,19 @@ 
  * Page callback for ping page.  Throws 404 if cron hasn't been called within configured time period.
  */
 function elysia_cron_ping_page() {
-  $last_run = _ec_variable_get('elysia_cron_last_run', 0);
-  $diff = time() - $last_run;
-  $max_interval = variable_get('elysia_cron_alert_interval', 60) * 60;
+    $last_run = _ec_variable_get('elysia_cron_last_run', 0);
+    $diff = time() - $last_run;
+    $max_interval = variable_get('elysia_cron_alert_interval', 60) * 60;
 
-  if ($diff > $max_interval) {
+    if ($diff > $max_interval) {
     return drupal_not_found();
-  }
-  else {
+    }
+    else {
     $aoutput = array();
     $aoutput[] = array(
-      '#type' => 'markup',
-      '#markup' => t('Cron has been called within maximum lapse time.'),
+        '#type' => 'markup',
+        '#markup' => t('Cron has been called within maximum lapse time.'),
     );
     return _dcr_render_array($aoutput);
-  }
+    }
 }

drupal/sites/default/boinc/modules/contrib/elysia_cron/elysia_cron.admin.inc

Indentation +302 added lines, -302 removed lines

@@ -9,91 +9,91 @@ 
  ******************************************************************************/
 
 function elysia_cron_admin_page() {
-  $aoutput = array();
-  $aoutput[] = drupal_get_form('elysia_cron_run_form');
+    $aoutput = array();
+    $aoutput[] = drupal_get_form('elysia_cron_run_form');
 
-  $output = '';
+    $output = '';
 
-  elysia_cron_initialize();
+    elysia_cron_initialize();
 
-  global $elysia_cron_settings, $elysia_cron_settings_by_channel, $elysia_cron_current_channel, $cron_completed, $cron_completed_time;
+    global $elysia_cron_settings, $elysia_cron_settings_by_channel, $elysia_cron_current_channel, $cron_completed, $cron_completed_time;
 
-  $v = variable_get('elysia_cron_disabled', false);
-  $output .= '<p>' . t('Global disable') . ': <i>' . ($v ? '<span class="warn">' . t('YES') . '</span>' : 'no') . '</i></p>';
-  $output .= '<p>' . t('Last channel executed') . ': <i>' . (($c = elysia_cron_last_channel()) ? $c : t('n/a')) . '</i></p>';
+    $v = variable_get('elysia_cron_disabled', false);
+    $output .= '<p>' . t('Global disable') . ': <i>' . ($v ? '<span class="warn">' . t('YES') . '</span>' : 'no') . '</i></p>';
+    $output .= '<p>' . t('Last channel executed') . ': <i>' . (($c = elysia_cron_last_channel()) ? $c : t('n/a')) . '</i></p>';
 
-  if (EC_DRUPAL_VERSION < 7) {
+    if (EC_DRUPAL_VERSION < 7) {
     if (_ec_variable_get('elysia_cron_semaphore', 0)) {
-      $output .= '<p><span class="warn">' . t('Global semaphore active since !date', array('!date' => elysia_cron_date(_ec_variable_get('elysia_cron_semaphore', 0)))) . '</span></p>';
+        $output .= '<p><span class="warn">' . t('Global semaphore active since !date', array('!date' => elysia_cron_date(_ec_variable_get('elysia_cron_semaphore', 0)))) . '</span></p>';
+    }
     }
-  }
 
-  $running = '';
-  foreach ($elysia_cron_settings_by_channel as $channel => $data) {
+    $running = '';
+    foreach ($elysia_cron_settings_by_channel as $channel => $data) {
     if (elysia_cron_is_channel_running($channel)) {
-      $running .= $channel . ' ';
+        $running .= $channel . ' ';
     }
-  }
-  if ($running) {
+    }
+    if ($running) {
     $output .= '<p>' . t('Running channels') . ': <span class="warn">' . $running . '</span></p>';
-  }
+    }
 
-  $output .= '<p>' . t('Last run') . ': ' . elysia_cron_date(_ec_variable_get('elysia_cron_last_run', 0)) . '</p>';
+    $output .= '<p>' . t('Last run') . ': ' . elysia_cron_date(_ec_variable_get('elysia_cron_last_run', 0)) . '</p>';
 
-  foreach ($elysia_cron_settings_by_channel as $channel => $data) {
+    foreach ($elysia_cron_settings_by_channel as $channel => $data) {
     $running = elysia_cron_is_channel_running($channel);
     $output .= '<h3>' . t('Channel') . ': ' . $channel . ($running ? ' (' . t('Running since !date', array('!date' => elysia_cron_date($running))) . ')' : '') . ($data['#data']['disabled'] ? ' <span class="warn">(' . t('DISABLED') . ')</span>' : '') . '</h3>';
     $output .= '<p>' . t('Last run') . ': ' . elysia_cron_date($data['#data']['last_run']) . '</p>';
     $output .= '<p>' . t('Last execution time') . ': ' . $data['#data']['last_execution_time'] . 's ' . t('(Shutdown: !shutdown) (Avg total: !avgtotal, Max total: !maxtotal)', array('!shutdown' => $data['#data']['last_shutdown_time'] . 's', '!avgtotal' => $data['#data']['avg_execution_time'] . 's', '!maxtotal' => $data['#data']['max_execution_time'] . 's')) . '</p>';
     $output .= '<p>' . t('Execution count') . ': ' . $data['#data']['execution_count'] . '</p>';
     if ($data['#data']['last_aborted']) {
-      $output .= '<p>' . t('Last aborted') . ': <span class="warn">' . t('On function !function', array('!function' => $data['#data']['last_abort_function'])) . '</span></p>';
+        $output .= '<p>' . t('Last aborted') . ': <span class="warn">' . t('On function !function', array('!function' => $data['#data']['last_abort_function'])) . '</span></p>';
     }
     if ($data['#data']['abort_count']) {
-      $output .= '<p>' . t('Abort count') . ': <span class="warn">' . $data['#data']['abort_count'] . '</span></p>';
+        $output .= '<p>' . t('Abort count') . ': <span class="warn">' . $data['#data']['abort_count'] . '</span></p>';
     }
 
     $rows = array();
     foreach ($data as $job => $conf) {
-      if ($job != '#data') {
+        if ($job != '#data') {
         $rows[] = array(
-          (!empty($conf['disabled']) ? '<strike>' . $job . '</strike>' : (empty($conf['running']) ? '<b>' . $job . '</b>' : '<b><u>' . $job . '</u></b> <small title="' . t('Running') . '">(R)</small>')) . (elysia_cron_should_run($conf) ? ' <small title="' . t('Waiting for execution') . '">(w)</small>' : ''),
-          array(
+            (!empty($conf['disabled']) ? '<strike>' . $job . '</strike>' : (empty($conf['running']) ? '<b>' . $job . '</b>' : '<b><u>' . $job . '</u></b> <small title="' . t('Running') . '">(R)</small>')) . (elysia_cron_should_run($conf) ? ' <small title="' . t('Waiting for execution') . '">(w)</small>' : ''),
+            array(
             'data' => '<i>' . elysia_cron_description($job) . '</i> ' .
-          '[' . _dco_l(t('run'), _dcf_internal_path('admin/config/system/cron/execute/') . $job, array('attributes' => array('onclick' => 'return confirm("' . t('Force execution of !job?', array('!job' => $job)) . '");'))) . ']',
+            '[' . _dco_l(t('run'), _dcf_internal_path('admin/config/system/cron/execute/') . $job, array('attributes' => array('onclick' => 'return confirm("' . t('Force execution of !job?', array('!job' => $job)) . '");'))) . ']',
             'colspan' => 4,
-          ),
+            ),
         );
         $rows[] = array(
-          check_plain($conf['rule']) . (!empty($conf['weight']) ? ' <small>(' . t('Weight') . ': ' . $conf['weight'] . ')</small>' : ''),
-          elysia_cron_date($conf['last_run']),
-          $conf['last_execution_time'] . 's',
-          $conf['execution_count'],
-          $conf['avg_execution_time'] . 's / ' . $conf['max_execution_time'] . 's',
+            check_plain($conf['rule']) . (!empty($conf['weight']) ? ' <small>(' . t('Weight') . ': ' . $conf['weight'] . ')</small>' : ''),
+            elysia_cron_date($conf['last_run']),
+            $conf['last_execution_time'] . 's',
+            $conf['execution_count'],
+            $conf['avg_execution_time'] . 's / ' . $conf['max_execution_time'] . 's',
         );
-      }
+        }
     }
     $output .= _dco_theme('table', array('header' => array(t('Job / Rule'), t('Last run'), t('Last exec time'), t('Exec count'), t('Avg/Max Exec time')), 'rows' => $rows));
-  }
+    }
 
-  $output .= '<p>' . t('Notes: job times don\'t include shutdown times (only shown on channel times).') . '</p>';
-  $output .= '<p>' . t('If an abort occours usually the job is not properly terminated, and so job timings can be inaccurate or wrong.') . '</p>';
+    $output .= '<p>' . t('Notes: job times don\'t include shutdown times (only shown on channel times).') . '</p>';
+    $output .= '<p>' . t('If an abort occours usually the job is not properly terminated, and so job timings can be inaccurate or wrong.') . '</p>';
 
-  $aoutput[] = array(
+    $aoutput[] = array(
     '#type' => 'markup',
     '#markup' => $output,
-  );
+    );
 
-  return _dcr_render_array($aoutput);
+    return _dcr_render_array($aoutput);
 }
 
 function elysia_cron_settings_form() {
-  global $elysia_cron_settings, $elysia_cron_settings_by_channel;
-  elysia_cron_initialize();
+    global $elysia_cron_settings, $elysia_cron_settings_by_channel;
+    elysia_cron_initialize();
 
-  $form = array();
+    $form = array();
 
-  $form['prefix_1'] = array(
+    $form['prefix_1'] = array(
     '#type' => 'fieldset',
     '#title' => t('Click for help and cron rules and script syntax'),
     '#collapsible' => true,
@@ -177,164 +177,164 @@ 
 </pre>
 EOT
 ),
-  );
+    );
 
-  $form['prefix_2'] = array(
+    $form['prefix_2'] = array(
     '#markup' => '<hr>',
-  );
+    );
 
-  $form['main'] = array(
+    $form['main'] = array(
     '#title' => t('Main'),
     '#type' => 'fieldset',
     '#collapsible' => false,
     '#collapsed' => false,
-  );
-  $form['main']['elysia_cron_disabled'] = array(
+    );
+    $form['main']['elysia_cron_disabled'] = array(
     '#title' => t('Global disable'),
     '#type' => 'checkbox',
     '#default_value' => variable_get('elysia_cron_disabled', false),
-  );
+    );
 
-  $form['installation'] = array(
+    $form['installation'] = array(
     '#title' => t('Installation settings'),
     '#type' => 'fieldset',
     '#collapsible' => true,
     '#collapsed' => true,
-  );
+    );
 
-  if (EC_DRUPAL_VERSION >= 7) {
+    if (EC_DRUPAL_VERSION >= 7) {
     $form['installation']['cron_safe_threshold'] = array(
-      '#type' => 'select',
-      '#title' => t('Run cron on visitor\'s requests, every'),
-      '#default_value' => variable_get('cron_safe_threshold', DRUPAL_CRON_DEFAULT_THRESHOLD),
-      '#description' => t('Setting a time here will enable the "poormanscron" method, which runs the Drupal cron operation using normal browser/page requests instead of having to set up a crontab to request the cron.php script. This approach requires that your site gets regular traffic/visitors in order to trigger the cron request.') . '<br />' .
+        '#type' => 'select',
+        '#title' => t('Run cron on visitor\'s requests, every'),
+        '#default_value' => variable_get('cron_safe_threshold', DRUPAL_CRON_DEFAULT_THRESHOLD),
+        '#description' => t('Setting a time here will enable the "poormanscron" method, which runs the Drupal cron operation using normal browser/page requests instead of having to set up a crontab to request the cron.php script. This approach requires that your site gets regular traffic/visitors in order to trigger the cron request.') . '<br />' .
         t('This way is fine if you don\'t need a great control over job starting times and execution frequency.') . '<br />' .
         t('If you need a fine grained control over cron timings use the crontab metod, as <a href="!cron_url">described in Drupal installation guide</a>.', array('!cron_url' => url('http://drupal.org/cron'))) . '<br />' .
         t('If you have a very large site, or you need to execute some jobs very often (more than once an hour) refer to Elysia cron\'s INSTALL.TXT to improve main cron setup.'),
-      '#options' => array(0 => t('Never / Use external crontab')) + drupal_map_assoc(array(3600, 10800, 21600, 43200, 86400, 604800), 'format_interval'),
+        '#options' => array(0 => t('Never / Use external crontab')) + drupal_map_assoc(array(3600, 10800, 21600, 43200, 86400, 604800), 'format_interval'),
     );
-  }
+    }
 
-  $form['installation']['cron_key'] = array(
+    $form['installation']['cron_key'] = array(
     '#title' => t('Cron key'),
     '#type' => 'textfield',
     '#default_value' => variable_get('cron_key', ''),
     '#description' => t('This is used to avoid external cron calling. If you set this cron will by accessible only by calling http://site/cron.php?cron_key=XXX, so you\'ll need to modify system crontab to support this (Logged user with [administer elysia_cron] permission avoid this check).'),
-  );
+    );
 
-  $form['installation']['elysia_cron_allowed_hosts'] = array(
+    $form['installation']['elysia_cron_allowed_hosts'] = array(
     '#title' => t('Allowed hosts'),
     '#type' => 'textfield',
     '#default_value' => variable_get('elysia_cron_allowed_hosts', ''),
     '#description' => t('Insert a list of ip addresses separated by , that can run cron.php (Logged user with [administer elysia_cron] permission avoid this check).'),
-  );
+    );
 
-  $form['installation']['elysia_cron_default_rule'] = array(
+    $form['installation']['elysia_cron_default_rule'] = array(
     '#title' => t('Default schedule rule'),
     '#type' => 'textfield',
     '#default_value' => variable_get('elysia_cron_default_rule', false),
     '#description' => t('If you don\'t specify a rule for a process, and if it has not a module specified one, this rule will apply'),
-  );
+    );
 
-  if (!ini_get('safe_mode')) {
+    if (!ini_get('safe_mode')) {
     $form['installation']['elysia_cron_time_limit'] = array(
-      '#title' => t('Time limit'),
-      '#type' => 'textfield',
-      '#default_value' => variable_get('elysia_cron_time_limit', 240),
-      '#description' => t('Set the number of seconds a channel is allowed to run. If you have some jobs that needs more time to execute increase it or set to 0 to disable the limit (WARN: that way a stuck job will block the channel forever!).'),
+        '#title' => t('Time limit'),
+        '#type' => 'textfield',
+        '#default_value' => variable_get('elysia_cron_time_limit', 240),
+        '#description' => t('Set the number of seconds a channel is allowed to run. If you have some jobs that needs more time to execute increase it or set to 0 to disable the limit (WARN: that way a stuck job will block the channel forever!).'),
     );
-  }
+    }
 
-  $form['installation']['elysia_cron_stuck_time'] = array(
+    $form['installation']['elysia_cron_stuck_time'] = array(
     '#title' => t('Stuck time'),
     '#type' => 'textfield',
     '#default_value' => variable_get('elysia_cron_stuck_time', 3600),
     '#description' => t('How many seconds the process should wait to consider the job as stuck (so the channel can run again)'),
-  );
+    );
 
-  $form['installation']['elysia_cron_debug_messages'] = array(
+    $form['installation']['elysia_cron_debug_messages'] = array(
     '#title' => t('Debug'),
     '#type' => 'select',
     '#default_value' => variable_get('elysia_cron_debug_messages', 0),
     '#options' => array(
-      0 => t('Disabled'),
-      1 => t('Enabled'),
+        0 => t('Disabled'),
+        1 => t('Enabled'),
     ),
     '#description' => t('Enable extended logging (in watchdog)'),
-  );
+    );
 
-  $default_ruless = '';
-  $default_rules = variable_get('elysia_cron_default_rules', $GLOBALS['elysia_cron_default_rules']);
-  foreach ($default_rules as $dk => $dr) {
+    $default_ruless = '';
+    $default_rules = variable_get('elysia_cron_default_rules', $GLOBALS['elysia_cron_default_rules']);
+    foreach ($default_rules as $dk => $dr) {
     $default_ruless .= $dr . ' = ' . $dk . "\n";
-  }
+    }
 
-  $form['installation']['elysia_cron_default_rules'] = array(
+    $form['installation']['elysia_cron_default_rules'] = array(
     '#title' => t('Predefined rules'),
     '#type' => 'textarea',
     '#rows' => 5,
     '#default_value' => $default_ruless,
     '#description' => t('You can put here standard rules used in your system, each one with its own caption. Put each rule in a separate line, in the form "caption = rule". For example: <i>"every 15 minutes = */15 * * * *"</i>.'),
-  );
+    );
 
-  $form['installation']['elysia_cron_alert_fieldset'] = array(
+    $form['installation']['elysia_cron_alert_fieldset'] = array(
     '#title' => t('External cron tracking'),
     '#type' => 'fieldset',
     '#collapsible' => true,
     '#collapsed' => true,
     '#description' => t('This lets you use an external tracking system like <a href="http://www.host-tracker.com/">Host Tracker</a> to be used to monitor the health of cron on your site. Point the tracking service to <a href="!cron-ping-url">!cron-ping-url</a>. If Elysia cron has been called within the time interval specified below, the ping page will return HTTP 200.  If not, the ping page will throw a 404 (page not found).', array('!cron-ping-url' => url('admin/build/cron/ping'))),
-  );
-  $form['installation']['elysia_cron_alert_fieldset']['elysia_cron_alert_interval'] = array(
+    );
+    $form['installation']['elysia_cron_alert_fieldset']['elysia_cron_alert_interval'] = array(
     '#title' => t('Lapse interval (minutes)'),
     '#type' => 'textfield',
     '#size' => 20,
     '#default_value' => variable_get('elysia_cron_alert_interval', 60),
     '#description' => t('Specify the number of minutes to allow to lapse before the cron ping page returns a 404 (page not found).'),
-  );
+    );
 
-  $form['elysia_cron_script_fieldset'] = array(
+    $form['elysia_cron_script_fieldset'] = array(
     '#title' => t('Script'),
     '#type' => 'fieldset',
     '#collapsible' => true,
     '#collapsed' => !variable_get('elysia_cron_script', ''),
-  );
-  $form['elysia_cron_script_fieldset']['elysia_cron_script'] = array(
+    );
+    $form['elysia_cron_script_fieldset']['elysia_cron_script'] = array(
     '#type' => 'textarea',
     '#rows' => 20,
     '#default_value' => variable_get('elysia_cron_script', ''),
     '#description' => t('You can specify new cron jobs or modify existing schedules by adding lines to the script.<br>' .
-      '<b>Warning</b> All rules specified in the script will OVERRIDE single job settings and channel settings (sections below).'),
-  );
+        '<b>Warning</b> All rules specified in the script will OVERRIDE single job settings and channel settings (sections below).'),
+    );
   
-  $form['single_job'] = array(
+    $form['single_job'] = array(
     '#title' => t('Single job settings'),
     '#description' => 
-      '<b>'.t('Disabled').'</b>: '.t('Flag this to disable job execution').'<br />'.
-      '<b>'.t('Schedule rule').'</b>: '.t('Timing rule for the job. Leave empty to use default rule (shown after the field in parenthesis)').'<br />'.
-      '<b>'.t('Weight').'</b>: '.t('Use this to specify execution order: low weights are executed before high weights. Default value shown in parenthesis').'<br />'.
-      '<b>'.t('Channel').'</b>: '.t('Specify a channel for the job (create the channel if not exists)').'<br /><br />',
+        '<b>'.t('Disabled').'</b>: '.t('Flag this to disable job execution').'<br />'.
+        '<b>'.t('Schedule rule').'</b>: '.t('Timing rule for the job. Leave empty to use default rule (shown after the field in parenthesis)').'<br />'.
+        '<b>'.t('Weight').'</b>: '.t('Use this to specify execution order: low weights are executed before high weights. Default value shown in parenthesis').'<br />'.
+        '<b>'.t('Channel').'</b>: '.t('Specify a channel for the job (create the channel if not exists)').'<br /><br />',
     '#type' => 'fieldset',
     '#collapsible' => true,
     //'#collapsed' => true,
-  );
+    );
   
-  $jobchannels = array(
+    $jobchannels = array(
     '#title' => t('Job channel associations'),
     '#description' => t('Leave empty for default channel'),
     '#type' => 'fieldset',
     '#collapsible' => true,
     '#collapsed' => true,
-  );
+    );
 
-  foreach ($elysia_cron_settings_by_channel as $channel => $cconf) {
+    foreach ($elysia_cron_settings_by_channel as $channel => $cconf) {
     foreach ($cconf as $job => $conf) {
-      if ($job != '#data' && empty($conf['expression'])) {
+        if ($job != '#data' && empty($conf['expression'])) {
         $form['single_job']['elysia_cron_' . $job] = array(
-          '#title' => $job, // t('Job !job', array('!job' => $job)),
-          '#description' => elysia_cron_description($job),
-          '#type' => 'fieldset',
-          '#collapsible' => true,
-          '#collapsed' => !elysia_cron_get_job_rule($job) && !elysia_cron_get_job_weight($job) && !elysia_cron_is_job_disabled($job) && !elysia_cron_get_job_channel($job),
+            '#title' => $job, // t('Job !job', array('!job' => $job)),
+            '#description' => elysia_cron_description($job),
+            '#type' => 'fieldset',
+            '#collapsible' => true,
+            '#collapsed' => !elysia_cron_get_job_rule($job) && !elysia_cron_get_job_weight($job) && !elysia_cron_is_job_disabled($job) && !elysia_cron_get_job_channel($job),
         );
         //if (!$form['single_job']['elysia_cron_'.$job]['#collapsed'])
         //  $form['single_job']['#collapsed'] = false;
@@ -342,125 +342,125 @@ 
         $rule = elysia_cron_get_job_rule($job);
         $options = array_merge(array('default' => t('Default') . ' (' . (!empty($default_rules[$conf['default_rule']]) ? $default_rules[$conf['default_rule']] : $conf['default_rule']) . ')'), $default_rules);
         if ($rule && !isset($options[$rule])) {
-          $options[$rule] = $rule;
+            $options[$rule] = $rule;
         }
         $options['custom'] = t('Custom') . ' ...';
 
         $form['single_job']['elysia_cron_' . $job]['_elysia_cron_seljob_rule_' . $job] = array(
-          '#title' => t('Schedule rule'),
-          '#type' => 'select',
-          '#options' => $options,
-          '#default_value' => $rule ? $rule : 'default',
+            '#title' => t('Schedule rule'),
+            '#type' => 'select',
+            '#options' => $options,
+            '#default_value' => $rule ? $rule : 'default',
         );
 
         $form['single_job']['elysia_cron_' . $job]['_elysia_cron_job_rule_' . $job] = array(
-          '#title' => t('Schedule rule'),
-          '#type' => 'textfield',
-          '#size' => 20,
-          '#default_value' => $rule ? $rule : $conf['default_rule'],
+            '#title' => t('Schedule rule'),
+            '#type' => 'textfield',
+            '#size' => 20,
+            '#default_value' => $rule ? $rule : $conf['default_rule'],
         );
 
         $form['single_job']['elysia_cron_' . $job]['_elysia_cron_job_weight_' . $job] = array(
-          '#title' => t('Weight'),
-          '#type' => 'textfield',
-          '#size' => 4,
-          '#default_value' => elysia_cron_get_job_weight($job),
-          '#description' => '(' . $conf['default_weight'] . ')',
+            '#title' => t('Weight'),
+            '#type' => 'textfield',
+            '#size' => 4,
+            '#default_value' => elysia_cron_get_job_weight($job),
+            '#description' => '(' . $conf['default_weight'] . ')',
         );
 
         //$form['single_job']['elysia_cron_'.$job]['elysia_cron_'.$job.'_disabled'] = array(
         $form['single_job']['elysia_cron_' . $job]['_elysia_cron_job_disabled_' . $job] = array(
-          '#title' => t('Disabled'),
-          '#type' => 'checkbox',
-          '#default_value' => elysia_cron_is_job_disabled($job, false),
+            '#title' => t('Disabled'),
+            '#type' => 'checkbox',
+            '#default_value' => elysia_cron_is_job_disabled($job, false),
         );
 
         //$jobchannels['elysia_cron_'.$job.'_channel'] = array(
         $form['single_job']['elysia_cron_' . $job]['_elysia_cron_job_channel_' . $job] = array(
-          '#title' => t('Channel'), // t('Channel for !job', array('!job' => $job)),
-          '#type' => 'textfield',
-          '#size' => 20,
-          '#default_value' => elysia_cron_get_job_channel($job),
+            '#title' => t('Channel'), // t('Channel for !job', array('!job' => $job)),
+            '#type' => 'textfield',
+            '#size' => 20,
+            '#default_value' => elysia_cron_get_job_channel($job),
         );
 
         //if (elysia_cron_get_job_channel($job))
         //  $jobchannels['#collapsed'] = false;
-      }
+        }
+    }
     }
-  }
 
-  $form['channels'] = array(
+    $form['channels'] = array(
     '#title' => t('Channels settings'),
     '#type' => 'fieldset',
     '#collapsible' => true,
     //'#collapsed' => $jobchannels['#collapsed'],
-  );
+    );
 
-  foreach ($elysia_cron_settings_by_channel as $channel => $conf) {
+    foreach ($elysia_cron_settings_by_channel as $channel => $conf) {
     $form['channels']['elysia_cron_ch_' . $channel] = array(
-      '#title' => $channel, // t('Channel !channel', array('!channel' => $channel)),
-      '#type' => 'fieldset',
+        '#title' => $channel, // t('Channel !channel', array('!channel' => $channel)),
+        '#type' => 'fieldset',
     );
     $form['channels']['elysia_cron_ch_' . $channel]['_elysia_cron_ch_disabled_' . $channel] = array(
-      '#title' => t('Disabled'),
-      '#type' => 'checkbox',
-      '#default_value' => elysia_cron_is_channel_disabled($channel, ''),
+        '#title' => t('Disabled'),
+        '#type' => 'checkbox',
+        '#default_value' => elysia_cron_is_channel_disabled($channel, ''),
     );
     $form['channels']['elysia_cron_ch_' . $channel]['_elysia_cron_ch_rule_' . $channel] = array(
-      '#title' => t('Default schedule rule'),
-      '#type' => 'textfield',
-      '#size' => 20,
-      '#default_value' => elysia_cron_get_channel_rule($channel),
+        '#title' => t('Default schedule rule'),
+        '#type' => 'textfield',
+        '#size' => 20,
+        '#default_value' => elysia_cron_get_channel_rule($channel),
     );
     //if (elysia_cron_is_channel_disabled($channel))
     //  $form['channels']['#collapsed'] = false;
-  }
+    }
 
-  //$form['channels']['jobchannels'] = $jobchannels;
+    //$form['channels']['jobchannels'] = $jobchannels;
 
-  $form['buttons'] = array('#type' => 'actions');
-  $form['buttons']['submit'] = array(
+    $form['buttons'] = array('#type' => 'actions');
+    $form['buttons']['submit'] = array(
     '#type' => 'submit',
     '#value' => t('Save configuration'),
-  );
-  $form['buttons']['reset'] = array(
+    );
+    $form['buttons']['reset'] = array(
     '#type' => 'submit',
     '#value' => t('Reset to defaults'),
-  );
+    );
 
-  if (!empty($_POST) && form_get_errors()) {
+    if (!empty($_POST) && form_get_errors()) {
     drupal_set_message(t('The settings have not been saved because of the errors.'), 'error');
-  }
+    }
 
-  return _dcr_form($form);
+    return _dcr_form($form);
 }
 
 function theme_elysia_cron_settings_form($_dco_variables) {
-  extract(_dcf_theme_form($_dco_variables));
-  $form = &$variables['form'];
+    extract(_dcf_theme_form($_dco_variables));
+    $form = &$variables['form'];
 
-  $output = '<script type="text/javascript"><!--' . "\n" .
+    $output = '<script type="text/javascript"><!--' . "\n" .
     /*'function _ec_select(editid, select) { if (select.value == \'custom\') {'.
       '$ = jQuery; $(select).hide();$("#"+editid).show();$("#"+editid).focus();'.
     '}}'.*/
     'function _ec_select(key, select) { if (select.value == \'custom\') {' .
-      '$ = jQuery; $("#_ec_select_"+key).hide();$("#_ec_custom_"+key).show();$("#_ec_custom_"+key).focus();' .
+        '$ = jQuery; $("#_ec_select_"+key).hide();$("#_ec_custom_"+key).show();$("#_ec_custom_"+key).focus();' .
     '}}' .
     "\n" . '--></script>';
 
-  $coutput = '<table>';
+    $coutput = '<table>';
 
-  $i = 0;
-  foreach (element_children($form['single_job']) as $c) {
+    $i = 0;
+    foreach (element_children($form['single_job']) as $c) {
     $key = substr($c, 12);
     //print_r($form['single_job'][$c]);
     if ($i++ == 0) {
-      $coutput .= '<tr>' .
+        $coutput .= '<tr>' .
         '<th>' . $form['single_job'][$c]['_elysia_cron_job_disabled_' . $key]['#title'] . '</th>' .
         '<th>' . $form['single_job'][$c]['_elysia_cron_job_rule_' . $key]['#title'] . '</th>' .
         '<th colspan="2">' . $form['single_job'][$c]['_elysia_cron_job_weight_' . $key]['#title'] . '</th>' .
         '<th>' . $form['single_job'][$c]['_elysia_cron_job_channel_' . $key]['#title'] . '</th>' .
-      '</tr>';
+        '</tr>';
     }
 
     //$def_rule = $form['single_job'][$c]['_elysia_cron_job_rule_'.$key]['#description'];
@@ -492,30 +492,30 @@ 
 
     $coutput .= '<tr><td colspan="6"><b>' . $form['single_job'][$c]['#title'] . '</b>' . (($d = $form['single_job'][$c]['#description']) && $d != '-' ? ' <i>(' . $d . ')</i>' : '' ) . '</td></tr>';
     $coutput .= '<tr>' .
-      '<td align="center">' . drupal_render($form['single_job'][$c]['_elysia_cron_job_disabled_' . $key]) . '</td>' .
-      '<td>' . drupal_render($form['single_job'][$c]['_elysia_cron_seljob_rule_' . $key]) . drupal_render($form['single_job'][$c]['_elysia_cron_job_rule_' . $key]) . '</td>' .//'<td><small>'.$def_rule.'</small></td>'.
-      '<td>' . drupal_render($form['single_job'][$c]['_elysia_cron_job_weight_' . $key]) . '</td><td><small>' . $def_weight . '</small></td>' .
-      '<td>' . drupal_render($form['single_job'][$c]['_elysia_cron_job_channel_' . $key]) . '</td>' .
+        '<td align="center">' . drupal_render($form['single_job'][$c]['_elysia_cron_job_disabled_' . $key]) . '</td>' .
+        '<td>' . drupal_render($form['single_job'][$c]['_elysia_cron_seljob_rule_' . $key]) . drupal_render($form['single_job'][$c]['_elysia_cron_job_rule_' . $key]) . '</td>' .//'<td><small>'.$def_rule.'</small></td>'.
+        '<td>' . drupal_render($form['single_job'][$c]['_elysia_cron_job_weight_' . $key]) . '</td><td><small>' . $def_weight . '</small></td>' .
+        '<td>' . drupal_render($form['single_job'][$c]['_elysia_cron_job_channel_' . $key]) . '</td>' .
     '</tr>';
     drupal_render($form['single_job'][$c]);
-  }
-  $coutput .= '</table>';
+    }
+    $coutput .= '</table>';
 
-  $form['single_job']['#children'] = $coutput;
-  //$form['single_job'][] = array('#type' => 'markup', '#markup' => $output);
+    $form['single_job']['#children'] = $coutput;
+    //$form['single_job'][] = array('#type' => 'markup', '#markup' => $output);
 
-  $coutput = '<table>';
+    $coutput = '<table>';
 
-  $i = 0;
+    $i = 0;
 
-  foreach (element_children($form['channels']) as $c) {
+    foreach (element_children($form['channels']) as $c) {
     $key = substr($c, 15);
     if ($i++ == 0) {
-      $coutput .= '<tr>' .
+        $coutput .= '<tr>' .
         '<th>' . t('Name') . '</th>' .
         '<th>' . $form['channels'][$c]['_elysia_cron_ch_disabled_' . $key]['#title'] . '</th>' .
         '<th>' . $form['channels'][$c]['_elysia_cron_ch_rule_' . $key]['#title'] . '</th>' .
-      '</tr>';
+        '</tr>';
     }
 
     $form['channels'][$c]['_elysia_cron_ch_disabled_' . $key]['#title'] = NULL;
@@ -524,221 +524,221 @@ 
     $form['channels'][$c]['_elysia_cron_ch_rule_' . $key]['#attributes']['style'] = 'margin: 0';
 
     $coutput .= '<tr>' .
-      '<td><b>' . $form['channels'][$c]['#title'] . '</b></td>' .
-      '<td>' . drupal_render($form['channels'][$c]['_elysia_cron_ch_disabled_' . $key]) . '</td>' .
-      '<td>' . drupal_render($form['channels'][$c]['_elysia_cron_ch_rule_' . $key]) . '</td>' .
+        '<td><b>' . $form['channels'][$c]['#title'] . '</b></td>' .
+        '<td>' . drupal_render($form['channels'][$c]['_elysia_cron_ch_disabled_' . $key]) . '</td>' .
+        '<td>' . drupal_render($form['channels'][$c]['_elysia_cron_ch_rule_' . $key]) . '</td>' .
     '</tr>';
     drupal_render($form['channels'][$c]);
-  }
-  $coutput .= '</table>';
+    }
+    $coutput .= '</table>';
 
-  $form['channels']['#children'] = $coutput;
+    $form['channels']['#children'] = $coutput;
 
-  return $output . drupal_render_children($form);
-  //$form['channels'][] = array('#type' => 'markup', '#markup' => $output);
-  //return drupal_render(_dcr_form($form));
+    return $output . drupal_render_children($form);
+    //$form['channels'][] = array('#type' => 'markup', '#markup' => $output);
+    //return drupal_render(_dcr_form($form));
 }
 
 function elysia_cron_settings_form_validate($_dco_form, &$_dco_form_state) {
-  extract(_dcf_form_validate($_dco_form, $_dco_form_state));
-  global $elysia_cron_settings;
+    extract(_dcf_form_validate($_dco_form, $_dco_form_state));
+    global $elysia_cron_settings;
 
-  $script = $form_state['values']['elysia_cron_script'];
-  if ($script) {
+    $script = $form_state['values']['elysia_cron_script'];
+    if ($script) {
     $errors = elysia_cron_decode_script($script, false);
     if ($errors) {
-      form_set_error('elysia_cron_script', t('Invalid lines:') . implode('<br>', $errors));
+        form_set_error('elysia_cron_script', t('Invalid lines:') . implode('<br>', $errors));
+    }
     }
-  }
 
-  foreach ($form_state['values'] as $key => $value) {
+    foreach ($form_state['values'] as $key => $value) {
     if ($value && preg_match('/^_elysia_cron_([^_]+_[^_]+)_(.*)$/', $key, $r) && ($r[1] == 'job_rule' || $r[1] == 'ch_rule')) {
-      if (!preg_match('/^\\s*([0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+)\\s*$/', $value)) {
+        if (!preg_match('/^\\s*([0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+)\\s*$/', $value)) {
         form_set_error($key, t('Invalid rule: %rule', array('%rule' => $value)));
-      }
+        }
+    }
     }
-  }
 
-  if (!empty($form_state['values']['elysia_cron_default_rules'])) {
+    if (!empty($form_state['values']['elysia_cron_default_rules'])) {
     $rules = explode(PHP_EOL, $form_state['values']['elysia_cron_default_rules']);
     foreach ($rules as $rule) {
-      $rule = trim($rule);
-      if (empty($rule)) {
+        $rule = trim($rule);
+        if (empty($rule)) {
         continue;
-      }
+        }
 
-      $rule = explode('=', $rule);
-      if (empty($rule[1])) {
+        $rule = explode('=', $rule);
+        if (empty($rule[1])) {
         form_set_error('elysia_cron_default_rules', t('Invalid rule: %rule', array('%rule' => $rule[0])));
-      } 
-      elseif (!preg_match('/^\\s*([0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+)\\s*$/', trim($rule[1]))) {
+        } 
+        elseif (!preg_match('/^\\s*([0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+[ ]+[0-9*,\/-]+)\\s*$/', trim($rule[1]))) {
         form_set_error('elysia_cron_default_rules', t('Invalid rule: %rule', array('%rule' => $rule[0])));
-      }
+        }
+    }
     }
-  }
 }
 
 function elysia_cron_settings_form_submit($_dco_form, &$_dco_form_state) {
-  extract(_dcf_form_validate($_dco_form, $_dco_form_state));
-  $form_values = $form_state['values'];
+    extract(_dcf_form_validate($_dco_form, $_dco_form_state));
+    $form_values = $form_state['values'];
 
-  $op = isset($form_values['op']) ? $form_values['op'] : '';
+    $op = isset($form_values['op']) ? $form_values['op'] : '';
 
-  // Exclude unnecessary elements.
-  unset($form_values['submit'], $form_values['reset'], $form_values['form_id'], $form_values['op'], $form_values['form_token']);
+    // Exclude unnecessary elements.
+    unset($form_values['submit'], $form_values['reset'], $form_values['form_id'], $form_values['op'], $form_values['form_token']);
 
-  $elysia_cron_default_rules = array();
-  $rules = explode("\n", $form_values['elysia_cron_default_rules']);
-  foreach ($rules as $r) {
+    $elysia_cron_default_rules = array();
+    $rules = explode("\n", $form_values['elysia_cron_default_rules']);
+    foreach ($rules as $r) {
     if (trim($r)) {
-      $rr = explode("=", $r);
-      $elysia_cron_default_rules[trim($rr[1])] = trim($rr[0]);
+        $rr = explode("=", $r);
+        $elysia_cron_default_rules[trim($rr[1])] = trim($rr[0]);
+    }
     }
-  }
-  variable_set('elysia_cron_default_rules', $elysia_cron_default_rules);
+    variable_set('elysia_cron_default_rules', $elysia_cron_default_rules);
 
-  foreach ($form_values as $key => $value) {
+    foreach ($form_values as $key => $value) {
     $value = trim($value);
     if (!preg_match('/^_elysia_cron_([^_]+_[^_]+)_(.*)$/', $key, $r)) {
-      if ($op == t('Reset to defaults') || ($key != 'cron_safe_threshold' && !$value)) {
+        if ($op == t('Reset to defaults') || ($key != 'cron_safe_threshold' && !$value)) {
         variable_del($key);
-      }
-      elseif ($key != 'elysia_cron_default_rules') {
+        }
+        elseif ($key != 'elysia_cron_default_rules') {
         if (is_array($value) && isset($form_values['array_filter'])) {
-          $value = array_keys(array_filter($value));
+            $value = array_keys(array_filter($value));
         }
         variable_set($key, $value);
-      }
+        }
     }
     else {
-      $nullvalue = $r[1] != 'job_weight' ? !$value : !$value && $value !== '0';
+        $nullvalue = $r[1] != 'job_weight' ? !$value : !$value && $value !== '0';
 
-      //dprint($r[1].' '.$r[1].' '.$r[2]);
-      if ($op == t('Reset to defaults') || $nullvalue) {
+        //dprint($r[1].' '.$r[1].' '.$r[2]);
+        if ($op == t('Reset to defaults') || $nullvalue) {
         switch ($r[1]) {
-          case 'job_channel':
+            case 'job_channel':
             elysia_cron_reset_job_channel($r[2]);
             break;
-          case 'job_rule':
+            case 'job_rule':
             elysia_cron_reset_job_rule($r[2]);
             break;
-          case 'job_weight':
+            case 'job_weight':
             elysia_cron_reset_job_weight($r[2]);
             break;
-          case 'job_disabled':
+            case 'job_disabled':
             elysia_cron_reset_job_disabled($r[2]);
             break;
-          case 'ch_disabled':
+            case 'ch_disabled':
             elysia_cron_reset_channel_disabled($r[2]);
             break;
-          case 'ch_rule':
+            case 'ch_rule':
             elysia_cron_reset_channel_rule($r[2]);
             break;
         }
-      }
-      else {
+        }
+        else {
         switch ($r[1]) {
-          case 'job_channel':
+            case 'job_channel':
             elysia_cron_set_job_channel($r[2], $value);
             break;
-          case 'job_rule':
+            case 'job_rule':
             if ($form_values['_elysia_cron_seljob_rule_' . $r[2]] == 'custom') {
-              elysia_cron_set_job_rule($r[2], $value);
+                elysia_cron_set_job_rule($r[2], $value);
             }
             break;
-          case 'seljob_rule':
+            case 'seljob_rule':
             if ($value != 'custom') {
-              if ($value == 'default') {
+                if ($value == 'default') {
                 elysia_cron_reset_job_rule($r[2]);
-              }
-              else {
+                }
+                else {
                 elysia_cron_set_job_rule($r[2], $value);
-              }
+                }
             }
             break;
-          case 'job_weight':
+            case 'job_weight':
             elysia_cron_set_job_weight($r[2], $value);
             break;
-          case 'job_disabled':
+            case 'job_disabled':
             elysia_cron_set_job_disabled($r[2], $value);
             break;
-          case 'ch_disabled':
+            case 'ch_disabled':
             elysia_cron_set_channel_disabled($r[2], $value);
             break;
-          case 'ch_rule':
+            case 'ch_rule':
             elysia_cron_set_channel_rule($r[2], $value);
             break;
         }
-      }
+        }
 
     }
-  }
-  if ($op == t('Reset to defaults')) {
+    }
+    if ($op == t('Reset to defaults')) {
     drupal_set_message(t('The configuration options have been reset to their default values.'));
-  }
-  else {
+    }
+    else {
     drupal_set_message(t('The configuration options have been saved.'));
-  }
+    }
 }
 
 function elysia_cron_date($timestamp) {
-  return $timestamp > 0 ? format_date($timestamp, EC_DRUPAL_VERSION >= 7 ? 'short' : 'small') : t('n/a');
-  //return date(variable_get('date_format_short', 'm/d/Y - H:i'), $timestamp);
+    return $timestamp > 0 ? format_date($timestamp, EC_DRUPAL_VERSION >= 7 ? 'short' : 'small') : t('n/a');
+    //return date(variable_get('date_format_short', 'm/d/Y - H:i'), $timestamp);
 }
 
 function elysia_cron_run_form() {
-  $form = array();
-  $form['runf'] = array(
+    $form = array();
+    $form['runf'] = array(
     '#type' => 'fieldset',
-  );
-  $form['runf']['run'] = array(
+    );
+    $form['runf']['run'] = array(
     '#type' => 'submit',
     '#value' => t('Run cron'),
-  );
-  return $form;
+    );
+    return $form;
 }
 
 function elysia_cron_run_form_submit($_dco_form, &$_dco_form_state) {
-  // Run cron manually from Cron form.
-  if (elysia_cron_run()) {
+    // Run cron manually from Cron form.
+    if (elysia_cron_run()) {
     drupal_set_message(t('Cron run successfully.'));
-  }
-  else {
+    }
+    else {
     drupal_set_message(t('Cron run failed.'), 'error');
-  }
+    }
 
-  drupal_goto(_dcf_internal_path('admin/config/system/cron'));
+    drupal_goto(_dcf_internal_path('admin/config/system/cron'));
 }
 
 function elysia_cron_execute_page($job = false) {
-  global $cron_completed, $cron_executing_job, $conf;
+    global $cron_completed, $cron_executing_job, $conf;
 
-  if (!$job) {
+    if (!$job) {
     drupal_set_message(t('No job specified'), 'error');
     drupal_goto(_dcf_internal_path('admin/config/system/cron'));
-  }
+    }
 
-  $running = false;
-  if (elysia_cron_is_job_running($job, false)) {
+    $running = false;
+    if (elysia_cron_is_job_running($job, false)) {
     if (time() - elysia_cron_get_job_last_run($job, 0) > variable_get('elysia_cron_stuck_time', 3600)) {
-      drupal_set_message(t('Job %job already running, but is probably stuck, so i consider it as terminated', array('%job' => $job)));
+        drupal_set_message(t('Job %job already running, but is probably stuck, so i consider it as terminated', array('%job' => $job)));
     }
     else {
-      drupal_set_message(t('Job %job already running', array('%job' => $job)));
-      $running = true;
+        drupal_set_message(t('Job %job already running', array('%job' => $job)));
+        $running = true;
+    }
     }
-  }
 
-  if (!$running) {
+    if (!$running) {
     $cron_completed = false;
     $cron_executing_job = $job;
 
     if (EC_DRUPAL_VERSION < 7) {
-      // Some modules (feedapi, ipaper...) uses the internal "cron_semaphore" variable to detect
-      // start time of cron process. I'll set this only in memory for that purpose.
-      // (In normal drupal cron execution that is done by a variable_set just before this call,
-      // but i need to set this manually if drupal cron is bypassed)
-      $conf['cron_semaphore'] = time();
+        // Some modules (feedapi, ipaper...) uses the internal "cron_semaphore" variable to detect
+        // start time of cron process. I'll set this only in memory for that purpose.
+        // (In normal drupal cron execution that is done by a variable_set just before this call,
+        // but i need to set this manually if drupal cron is bypassed)
+        $conf['cron_semaphore'] = time();
     }
 
     // Register shutdown callback
@@ -748,64 +748,64 @@ 
     elysia_cron_execute($job);
 
     if (EC_DRUPAL_VERSION < 7) {
-      _ec_variable_del('cron_semaphore');
-      $conf['cron_semaphore'] = false;
+        _ec_variable_del('cron_semaphore');
+        $conf['cron_semaphore'] = false;
     }
 
     $cron_completed = true;
 
     drupal_set_message(t('Job executed'));
-  }
+    }
 
-  drupal_goto(_dcf_internal_path('admin/config/system/cron'));
+    drupal_goto(_dcf_internal_path('admin/config/system/cron'));
 }
 
 function elysia_cron_execute_page_cleanup() {
-  global $cron_completed, $cron_executing_job;
+    global $cron_completed, $cron_executing_job;
 
-  if ($cron_completed) {
+    if ($cron_completed) {
     return;
-  }
+    }
 
-  // See if the semaphore is still locked.
-  if (elysia_cron_is_job_running($cron_executing_job)) {
+    // See if the semaphore is still locked.
+    if (elysia_cron_is_job_running($cron_executing_job)) {
     _dco_watchdog('cron', 'Unexpected termination of cron job %job manually started, aborted.', array('%job' => $cron_executing_job), WATCHDOG_WARNING);
 
     elysia_cron_set_job_running($cron_executing_job, 0);
-  }
+    }
 }
 
 function elysia_cron_maintenance_page() {
-  $output = array();
-  $output[] = drupal_get_form('elysia_cron_reset_statistics_form');
+    $output = array();
+    $output[] = drupal_get_form('elysia_cron_reset_statistics_form');
   
-  return _dcr_render_array($output);
+    return _dcr_render_array($output);
 }
 
 function elysia_cron_reset_statistics_form() {
-  $form = array();
-  $form['fieldset'] = array(
+    $form = array();
+    $form['fieldset'] = array(
     '#type' => 'fieldset',
     '#title' => t('Reset statistics'),
     '#description' => t('Deletes all cron execution statitics (Last run, last exec time, exec count, avg/max exec time...). Do not touch cron settings.<br /><b>This operation could not be reverted</b><br />'),
-  );
-  $form['fieldset']['reset'] = array(
+    );
+    $form['fieldset']['reset'] = array(
     '#type' => 'submit',
     '#value' => t('Reset'),
     '#attributes' => array(
-      'onclick' => 'return confirm(\'' . htmlentities(t('Are you sure you want to reset statistics?')) . '\')',
+        'onclick' => 'return confirm(\'' . htmlentities(t('Are you sure you want to reset statistics?')) . '\')',
     ),
-  );
-  return $form;
+    );
+    return $form;
 }
 
 function elysia_cron_reset_statistics_form_submit($_dco_form, &$_dco_form_state) {
-  elysia_cron_reset_stats();
+    elysia_cron_reset_stats();
   
-  drupal_set_message(t('Reset done.'));
-  drupal_goto(_dcf_internal_path('admin/config/system/cron/maintenance'));
+    drupal_set_message(t('Reset done.'));
+    drupal_goto(_dcf_internal_path('admin/config/system/cron/maintenance'));
 }
 
 function elysia_cron_reset_page() {
-  elysia_cron_reset_statistics_form_submit(false, $res = array());
+    elysia_cron_reset_statistics_form_submit(false, $res = array());
 }

drupal/sites/default/boinc/modules/contrib/elysia_cron/elysia_drupalconv.php

Indentation +38 added lines, -38 removed lines

@@ -7,96 +7,96 @@ 
  ***************************************************************/
 
 function _dcf_hook_boot($module) {
-  return true;
+    return true;
 }
 
 function _dcf_hook_init($module) {
-  return true;
+    return true;
 }
 
 function _dcf_hook_menu($items, $maycache) {
-  $new_items = array();
-  foreach ($items as $k => $v)
+    $new_items = array();
+    foreach ($items as $k => $v)
     $new_items[_dcf_internal_path($k)] = $v;
-  return $new_items;
+    return $new_items;
 }
 
 function _dcf_convert_render_array(&$a) {
-  if (!empty($a['#markup'])) {
+    if (!empty($a['#markup'])) {
     $a['#value'] = $a['#markup'];
     unset($a['#markup']);
-  }
-  if (!empty($a['#type']) && $a['#type'] == 'actions')
+    }
+    if (!empty($a['#type']) && $a['#type'] == 'actions')
     unset($a['#type']);
-  foreach ($a as $k => &$v) 
+    foreach ($a as $k => &$v) 
     if (is_array($v))
-      _dcf_convert_render_array($v);
+        _dcf_convert_render_array($v);
 }
 
 function _dcr_render_array($output) {
-  foreach ($output as $k => &$v)
+    foreach ($output as $k => &$v)
     if ((is_numeric($k) || $k{0} != '#') && is_string($v))
-      $v = array( '#type' => 'markup', '#value' => $v, '#weight' => -1 );
-  _dcf_convert_render_array($output);
-  return drupal_render($output);
+        $v = array( '#type' => 'markup', '#value' => $v, '#weight' => -1 );
+    _dcf_convert_render_array($output);
+    return drupal_render($output);
 }
 
 function _dcr_form(&$form) {
-  foreach ($form as $k => &$v)
+    foreach ($form as $k => &$v)
     if ((is_numeric($k) || $k{0} != '#') && is_string($v))
-      $v = array( '#type' => 'markup', '#value' => $v, '#weight' => -1 );
-  _dcf_convert_render_array($form);
-  return $form;
+        $v = array( '#type' => 'markup', '#value' => $v, '#weight' => -1 );
+    _dcf_convert_render_array($form);
+    return $form;
 }
 
 function _dcf_internal_path($path) {
-  return str_replace(
+    return str_replace(
     array( 'admin/config/system/cron', 'admin/modules' ),
     array( 'admin/build/cron', 'admin/build/modules' ),
     $path
-  );
+    );
 }
   
 function _dcf_t($string) {
-  return t($string);
+    return t($string);
 }
 
 function _dco_watchdog($type, $message, $variables = array(), $severity = WATCHDOG_NOTICE, $link = NULL) { // WARN d7 changed WATCHDOG_ costants
-  return watchdog($type, $message, $variables, $severity, $link);
+    return watchdog($type, $message, $variables, $severity, $link);
 }
 
 function _dco_l($text, $path, array $options = array()) {
-  return l($text, $path, $options);
+    return l($text, $path, $options);
 }
 
 function _dcf_form_validate(&$form, &$form_state) {
-  return array('form' => &$form, 'form_state' => &$form_state);
+    return array('form' => &$form, 'form_state' => &$form_state);
 }
 
 function _dco_theme($name, $args) {
-  return call_user_func_array('theme', array_merge(array($name), array_values($args)));
+    return call_user_func_array('theme', array_merge(array($name), array_values($args)));
 }
 
 function _dcf_theme_signature($args) {
-  return array( 'variables' => $args );
+    return array( 'variables' => $args );
 }
 
 function _dcr_hook_theme($specs) {
-  foreach ($specs as $k => $v) {
+    foreach ($specs as $k => $v) {
     if (!empty($v['variables'])) {
-      $v['arguments'] = $v['variables'];
-      unset($v['variables']);
+        $v['arguments'] = $v['variables'];
+        unset($v['variables']);
     }
     if (!empty($v['render element'])) {
-      $v['arguments'] = array ( $v['render element'] => NULL );
-      unset($v['render element']);
+        $v['arguments'] = array ( $v['render element'] => NULL );
+        unset($v['render element']);
+    }
     }
-  }
-  return $specs;
+    return $specs;
 }
 
 function _dcf_theme_form(&$args) {
-  return array( 'variables' => array( 'form' => $args ) );
+    return array( 'variables' => array( 'form' => $args ) );
 }
 
 /***************************************************************
@@ -104,7 +104,7 @@ 
  ***************************************************************/
 
 function drupal_render_children($form) {
-  return drupal_render(_dcr_form($form));
+    return drupal_render(_dcr_form($form));
 }
 
 /***************************************************************
@@ -112,14 +112,14 @@ 
  ***************************************************************/
 
 function drupal_module_get_min_weight($except_module = false) {
-  return !$except_module ? db_result(db_query("select min(weight) from {system}")) :
+    return !$except_module ? db_result(db_query("select min(weight) from {system}")) :
     db_result(db_query("select min(weight) from {system} where name != '%s'", $except_module));
 }
 
 function drupal_module_get_weight($name) {
-  return db_result(db_query("select weight from {system} where name = '%s'", $name));  
+    return db_result(db_query("select weight from {system} where name = '%s'", $name));  
 }
 
 function drupal_module_set_weight($name, $weight) {
-  db_query("update {system} set weight = %d where name = '%s'", $weight, $name);
+    db_query("update {system} set weight = %d where name = '%s'", $weight, $name);
 }

drupal/sites/default/boinc/modules/contrib/elysia_cron/elysia_cron.ctools.inc

Indentation +85 added lines, -85 removed lines

@@ -4,17 +4,17 @@ 
  * EXPORTABLES
  ******************************************************************************/
 
- // WARN Features button "Revert components" will reset also statistics 
+    // WARN Features button "Revert components" will reset also statistics 
  
 function elysia_cron_get_ctools_defaults() {
-  if (module_exists('ctools') && function_exists('ctools_include')) {
+    if (module_exists('ctools') && function_exists('ctools_include')) {
     ctools_include('export');
     if (function_exists('ctools_export_get_schema') && function_exists('_ctools_export_get_defaults') && ($schema = ctools_export_get_schema('elysia_cron'))) {
-      $export = $schema['export'];
-      return _ctools_export_get_defaults('elysia_cron', $export);
+        $export = $schema['export'];
+        return _ctools_export_get_defaults('elysia_cron', $export);
     }
-  }
-  return array();
+    }
+    return array();
 }
 
 /**
@@ -22,30 +22,30 @@ 
  * Ctools does not support override of PARTIAL record, this is an elysia cron specific replacement to support it
  */
 function elysia_cron_ctools_export_load($name) {
-  $schema = ctools_export_get_schema('elysia_cron');
-  if (!empty($schema)) {
+    $schema = ctools_export_get_schema('elysia_cron');
+    if (!empty($schema)) {
     $export = $schema['export'];
     
     if (EC_DRUPAL_VERSION >= 7) {
-      $object = db_query("select " . implode(", ", $GLOBALS['_ec_columns']) . " from {elysia_cron} where name = :name", array(':name' => $name))->fetch();
+        $object = db_query("select " . implode(", ", $GLOBALS['_ec_columns']) . " from {elysia_cron} where name = :name", array(':name' => $name))->fetch();
     }
     else {
-      $object = db_fetch_object(db_query("select " . implode(", ", $GLOBALS['_ec_columns']) . " from {elysia_cron} where name = '%s'", $name));
+        $object = db_fetch_object(db_query("select " . implode(", ", $GLOBALS['_ec_columns']) . " from {elysia_cron} where name = '%s'", $name));
     }
     $default_objects = _ctools_export_get_defaults('elysia_cron', $export);
     
     if ($object) {
-      if (isset($default_objects[$name])) {
+        if (isset($default_objects[$name])) {
         return _elysia_cron_ctools_export_load_object_db_and_code($object, $default_objects[$name], $export);
-      }
-      else {
+        }
+        else {
         return _elysia_cron_ctools_export_load_object_db($object, $export);
-      }
+        }
     }
     elseif (isset($default_objects[$name])) {
-      return _elysia_cron_ctools_export_load_object_code($default_objects[$name], $export);
+        return _elysia_cron_ctools_export_load_object_code($default_objects[$name], $export);
+    }
     }
-  }
 }
 
 /**
@@ -53,75 +53,75 @@ 
  * Ctools does not support override of PARTIAL record, this is an elysia cron specific replacement to support it
  */
 function elysia_cron_ctools_export_load_all() {
-  $schema = ctools_export_get_schema('elysia_cron');
-  if (empty($schema)) {
+    $schema = ctools_export_get_schema('elysia_cron');
+    if (empty($schema)) {
     return array();
-  }
-  $export = $schema['export'];
+    }
+    $export = $schema['export'];
     
-  if (EC_DRUPAL_VERSION >= 7) {
+    if (EC_DRUPAL_VERSION >= 7) {
     $objects = db_query("select " . implode(", ", $GLOBALS['_ec_columns']) . " from {elysia_cron}")->fetchAll();
-  }
-  else {
+    }
+    else {
     $objects = array();
     $rs = db_query("select " . implode(", ", $GLOBALS['_ec_columns']) . " from {elysia_cron}");
     while ($o = db_fetch_object($rs)) {
-      $objects[] = $o;
+        $objects[] = $o;
+    }
     }
-  }
-  $default_objects = _ctools_export_get_defaults('elysia_cron', $export);
+    $default_objects = _ctools_export_get_defaults('elysia_cron', $export);
   
-  $result = array();
-  foreach ($objects as $object) {
+    $result = array();
+    foreach ($objects as $object) {
     $key = $object->{$export['key']};
     if (isset($default_objects[$key])) {
-      $result[$key] = _elysia_cron_ctools_export_load_object_db_and_code($object, $default_objects[$key], $export);
-      unset($default_objects[$key]);
+        $result[$key] = _elysia_cron_ctools_export_load_object_db_and_code($object, $default_objects[$key], $export);
+        unset($default_objects[$key]);
     } else {
-      $result[$key] = _elysia_cron_ctools_export_load_object_db($object, $export);
+        $result[$key] = _elysia_cron_ctools_export_load_object_db($object, $export);
     } 
-  }
-  foreach ($default_objects as $key => $object) {
+    }
+    foreach ($default_objects as $key => $object) {
     $result[$key] = _elysia_cron_ctools_export_load_object_code($object, $export);
-  }
-  return $result;
+    }
+    return $result;
 }
 
 function _elysia_cron_ctools_export_load_object_db_and_code($object, $code_object, $export) {
-  $overridden = false;
-  foreach ($code_object as $keyd => $value) {
+    $overridden = false;
+    foreach ($code_object as $keyd => $value) {
     if (!isset($object->$keyd) || is_null($object->$keyd)) {
-      $object->$keyd = $value;
+        $object->$keyd = $value;
     }
     else if ($object->$keyd !== $value) {
-      $overridden = true;
+        $overridden = true;
+    }
     }
-  }
-  $object->table = 'elysia_cron';
-  $object->export_type = EXPORT_IN_DATABASE | EXPORT_IN_CODE;
-  if (!empty($export['export type string'])) {
+    $object->table = 'elysia_cron';
+    $object->export_type = EXPORT_IN_DATABASE | EXPORT_IN_CODE;
+    if (!empty($export['export type string'])) {
     $object->{$export['export type string']} = $overridden ? t('Overridden') : t('Normal');
-  }
-  return $object;
+    }
+    return $object;
 }
 
 function _elysia_cron_ctools_export_load_object_db($object, $export) {
-  $object->table = 'elysia_cron';
-  $object->export_type = EXPORT_IN_DATABASE;
-  if (!empty($export['export type string'])) {
+    $object->table = 'elysia_cron';
+    $object->export_type = EXPORT_IN_DATABASE;
+    if (!empty($export['export type string'])) {
     $object->{$export['export type string']} = t('Normal');
-  }
-  return $object;
+    }
+    return $object;
 }
 
 function _elysia_cron_ctools_export_load_object_code($object, $export) {
-  $object->table = 'elysia_cron';
-  $object->export_type = EXPORT_IN_CODE;
-  if (!empty($export['export type string'])) {
+    $object->table = 'elysia_cron';
+    $object->export_type = EXPORT_IN_CODE;
+    if (!empty($export['export type string'])) {
     $object->{$export['export type string']} = t('Default');
-  }
-  $object->in_code_only = TRUE;
-  return $object;
+    }
+    $object->in_code_only = TRUE;
+    return $object;
 }
 
 /**
@@ -130,13 +130,13 @@ 
  * This function does not support $schema['join'].
  */
 function elysia_cron_ctools_export_object_factory($schema, $data) {
-  $object = new stdClass;
+    $object = new stdClass;
 
-  foreach ($schema['fields'] as $field => $info) {
+    foreach ($schema['fields'] as $field => $info) {
     $object->$field = isset($data->$field) && !is_null($data->$field) ? (empty($info['serialize']) ? $data->$field : unserialize($data->$field)) : NULL;
-  }
+    }
 
-  return $object;
+    return $object;
 }
 
 /**
@@ -144,33 +144,33 @@ 
  * Handles NULL value (it's not possible to do this with "field" export callback, because null values are rewritten before its call)
  */
 function elysia_cron_ctools_export_callback($object, $indent) {
-  $table = 'elysia_cron';
-  $schema = ctools_export_get_schema($table);
-  $identifier = $schema['export']['identifier'];
+    $table = 'elysia_cron';
+    $schema = ctools_export_get_schema($table);
+    $identifier = $schema['export']['identifier'];
 
-  $output = $indent . '$' . $identifier . ' = new ' . get_class($object) . ";\n";
+    $output = $indent . '$' . $identifier . ' = new ' . get_class($object) . ";\n";
 
-  if ($schema['export']['can disable']) {
+    if ($schema['export']['can disable']) {
     $output .= $indent . '$' . $identifier . '->disabled = FALSE; /* Edit this to true to make a default ' . $identifier . ' disabled initially */'  . "\n";
-  }
-  if (!empty($schema['export']['api']['current_version'])) {
+    }
+    if (!empty($schema['export']['api']['current_version'])) {
     $output .= $indent . '$' . $identifier . '->api_version = ' . $schema['export']['api']['current_version'] . ";\n";
-  }
+    }
 
-  $fields = $schema['fields'];
+    $fields = $schema['fields'];
 
-  foreach ($fields as $field => $info) {
+    foreach ($fields as $field => $info) {
     if (!empty($info['no export'])) {
-      continue;
+        continue;
     }
     $value = isset($object->$field) ? $object->$field : (isset($info['default']) ? $info['default'] : NULL);
     if (!is_null($value) && $info['type'] == 'int') {
-      $value = (isset($info['size']) && $info['size'] == 'tiny') ? (bool) $value : (int) $value;
+        $value = (isset($info['size']) && $info['size'] == 'tiny') ? (bool) $value : (int) $value;
     }
     $output .= $indent . '$' . $identifier . '->' . $field . ' = ' . ctools_var_export($value, $indent) . ";\n";
-  }
+    }
 
-  return $output;  
+    return $output;  
 }
 
 /**
@@ -179,25 +179,25 @@ 
  * This code is equal to the original ctools one, but uses specific load callback 
  */
 function elysia_cron_ctools_to_hook_code($names, $name) {
-  $table = 'elysia_cron';
-  $schema = ctools_export_get_schema($table);
-  $export = $schema['export'];
-  $output = '';
-  $objects = elysia_cron_ctools_export_load_all();
-  $objects = array_intersect_key($objects, array_flip($names));
-  if ($objects) {
+    $table = 'elysia_cron';
+    $schema = ctools_export_get_schema($table);
+    $export = $schema['export'];
+    $output = '';
+    $objects = elysia_cron_ctools_export_load_all();
+    $objects = array_intersect_key($objects, array_flip($names));
+    if ($objects) {
     $output = "/**\n";
     $output .= " * Implementation of hook_{$export['default hook']}()\n";
     $output .= " */\n";
     $output .= "function " . $name . "_{$export['default hook']}() {\n";
     $output .= "  \${$export['identifier']}s = array();\n\n";
     foreach ($objects as $object) {
-      $output .= ctools_export_crud_export($table, $object, '  ');
-      $output .= "  \${$export['identifier']}s['" . check_plain($object->$export['key']) . "'] = \${$export['identifier']};\n\n";
+        $output .= ctools_export_crud_export($table, $object, '  ');
+        $output .= "  \${$export['identifier']}s['" . check_plain($object->$export['key']) . "'] = \${$export['identifier']};\n\n";
     }
     $output .= "  return \${$export['identifier']}s;\n";
     $output .= "}\n";
-  }
+    }
 
-  return $output;
+    return $output;
 }

drupal/sites/default/boinc/modules/contrib/elysia_cron/elysia_cron_update.php

Indentation +115 added lines, -115 removed lines

@@ -5,136 +5,136 @@ 
  ******************************************************************************/
 
 function elysia_cron_check_version_update() {
-  $ver = variable_get('elysia_cron_version', 0);
-  if ($ver < 20111012) {
+    $ver = variable_get('elysia_cron_version', 0);
+    if ($ver < 20111012) {
     $ver = _ec_variable_get('elysia_cron_version', 0);
-  }
+    }
 
-  if (!$ver || $ver < 20090218) {
+    if (!$ver || $ver < 20090218) {
 
     $unchanged = array(
-      'elysia_cron_last_context',
-      'elysia_cron_last_run',
-      'elysia_cron_disabled',
-      'elysia_cron_semaphore',
-      'elysia_cron_key',
-      'elysia_cron_allowed_hosts',
-      'elysia_cron_default_rule',
-      'elysia_cron_script',
-      'elysia_cron_runtime_replacement',
-      'elysia_cron_version',
+        'elysia_cron_last_context',
+        'elysia_cron_last_run',
+        'elysia_cron_disabled',
+        'elysia_cron_semaphore',
+        'elysia_cron_key',
+        'elysia_cron_allowed_hosts',
+        'elysia_cron_default_rule',
+        'elysia_cron_script',
+        'elysia_cron_runtime_replacement',
+        'elysia_cron_version',
     );
 
     $rs = db_query('select * from {variable} where name like "elysia_cron_%%"');
     while ($v = db_fetch_object($rs)) {
-      if (!in_array($v->name, $unchanged)) {
+        if (!in_array($v->name, $unchanged)) {
         $vn = false;
         if (preg_match('/^elysia_cron_ctx_(.*)_(running|disabled|last_run|last_aborted|abort_count|execution_count|last_execution_time|avg_execution_time|max_execution_time|last_shutdown_time|last_abort_function)/', $v->name, $r)) {
-          switch ($r[2]) {
+            switch ($r[2]) {
             case 'running':
               $vn = 'ecc_' . _ec_get_name($r[1]) . '_r';
-              break;
+                break;
             case 'disabled':
               $vn = 'ecc_' . _ec_get_name($r[1]) . '_d';
-              break;
+                break;
             case 'last_run':
               $vn = 'ecc_' . _ec_get_name($r[1]) . '_lr';
-              break;
+                break;
             case 'last_aborted':
               $vn = 'ecc_' . _ec_get_name($r[1]) . '_la';
-              break;
+                break;
             case 'abort_count':
               $vn = 'ecc_' . _ec_get_name($r[1]) . '_ac';
-              break;
+                break;
             case 'execution_count':
               $vn = 'ecc_' . _ec_get_name($r[1]) . '_ec';
-              break;
+                break;
             case 'last_execution_time':
               $vn = 'ecc_' . _ec_get_name($r[1]) . '_let';
-              break;
+                break;
             case 'avg_execution_time':
               $vn = 'ecc_' . _ec_get_name($r[1]) . '_aet';
-              break;
+                break;
             case 'max_execution_time':
               $vn = 'ecc_' . _ec_get_name($r[1]) . '_met';
-              break;
+                break;
             case 'last_shutdown_time':
               $vn = 'ecc_' . _ec_get_name($r[1]) . '_lst';
-              break;
+                break;
             case 'last_abort_function':
               $vn = 'ecc_' . _ec_get_name($r[1]) . '_laf';
-              break;
-          }
+                break;
+            }
         }
         elseif (preg_match('/^elysia_cron_(.*)_(rule|disabled|context|running|last_run|last_execution_time|execution_count|avg_execution_time|max_execution_time)/', $v->name, $r)) {
-          switch ($r[2]) {
+            switch ($r[2]) {
             case 'rule':
               $vn = 'ec_' . _ec_get_name($r[1]) . '_rul';
-              break;
+                break;
             case 'disabled':
               $vn = 'ec_' . _ec_get_name($r[1]) . '_d';
-              break;
+                break;
             case 'context':
               $vn = 'ec_' . _ec_get_name($r[1]) . '_c';
-              break;
+                break;
             case 'running':
               $vn = 'ec_' . _ec_get_name($r[1]) . '_r';
-              break;
+                break;
             case 'last_run':
               $vn = 'ec_' . _ec_get_name($r[1]) . '_lr';
-              break;
+                break;
             case 'last_execution_time':
               $vn = 'ec_' . _ec_get_name($r[1]) . '_let';
-              break;
+                break;
             case 'execution_count':
               $vn = 'ec_' . _ec_get_name($r[1]) . '_ec';
-              break;
+                break;
             case 'avg_execution_time':
               $vn = 'ec_' . _ec_get_name($r[1]) . '_aet';
-              break;
+                break;
             case 'max_execution_time':
               $vn = 'ec_' . _ec_get_name($r[1]) . '_met';
-              break;
-          }
+                break;
+            }
         }
         if ($vn) {
-          variable_set($vn, unserialize($v->value));
+            variable_set($vn, unserialize($v->value));
         }
         else {
-          _dco_watchdog('cron', 'Error in update, cant convert %name (value: %value)', array('%name' => $v->name, '%value' => $v->value), WATCHDOG_ERROR);
+            _dco_watchdog('cron', 'Error in update, cant convert %name (value: %value)', array('%name' => $v->name, '%value' => $v->value), WATCHDOG_ERROR);
         }
 
         variable_del($v->name);
-      }
+        }
     }
 
     variable_set('elysia_cron_version', 20090218);
-  }
-  if ($ver < 20090920) {
+    }
+    if ($ver < 20090920) {
     variable_set('elysia_cron_version', 20090920);
 
-  }
-  if ($ver < 20100507) {
+    }
+    if ($ver < 20100507) {
     if (EC_DRUPAL_VERSION >= 6) {
-      // D6
-      drupal_install_schema('elysia_cron');
+        // D6
+        drupal_install_schema('elysia_cron');
 
-      // In ver 20111020 disabled has been renamed to disable, revert it now
-      if (EC_DRUPAL_VERSION >= 7) {
+        // In ver 20111020 disabled has been renamed to disable, revert it now
+        if (EC_DRUPAL_VERSION >= 7) {
         // D7
         // Must use "$v" for PHP5.3 running D6 version (detect the error even if it doesn't pass here)
         db_change_field($v = 'elysia_cron', 'disable', 'disabled', array('type' => 'int', 'size' => 'tiny', 'not null' => FALSE));
 
-      }
-      elseif (EC_DRUPAL_VERSION >= 6) {
+        }
+        elseif (EC_DRUPAL_VERSION >= 6) {
         // D6
         $ret = array();
         db_change_field($ret, 'elysia_cron', 'disable', 'disabled', array('type' => 'int', 'size' => 'tiny', 'not null' => FALSE));
-      }
+        }
     }
     else {
-      // D5
-      switch ($GLOBALS['db_type']) {
+        // D5
+        switch ($GLOBALS['db_type']) {
         case 'mysqli':
         case 'mysql':
           db_query("create table if not exists {elysia_cron} (
@@ -155,7 +155,7 @@ 
             last_shutdown_time int(11) not null default '0',
             primary key (name)
           )");
-          break;
+            break;
         case 'pgsql':
           db_query("create table {elysia_cron} (
             name varchar(120) not null,
@@ -175,153 +175,153 @@ 
             last_shutdown_time integer not null default '0',
             primary key (name)
           )");
-      }
+        }
     }
 
     $rs = db_query('select * from {variable} where name like "ec_%%" or name like "ecc_%%"');
     $data = array();
     $todelete = array();
     while ($v = db_fetch_object($rs)) {
-      $name = false;
-      if (preg_match('/^ecc_(.+)_(r|d|lr|la|ac|ec|let|aet|met|lst|laf)/', $v->name, $r)) {
+        $name = false;
+        if (preg_match('/^ecc_(.+)_(r|d|lr|la|ac|ec|let|aet|met|lst|laf)/', $v->name, $r)) {
         $name = ':' . $r[1];
-      }
-      elseif (preg_match('/^ec_(.+)_(rul|d|c|w|r|lr|let|ec|aet|met)/', $v->name, $r)) {
+        }
+        elseif (preg_match('/^ec_(.+)_(rul|d|c|w|r|lr|let|ec|aet|met)/', $v->name, $r)) {
         $name = $r[1];
-      }
-      if ($name) {
+        }
+        if ($name) {
         if (!isset($data[$name])) {
-          $data[$name] = array('name' => $name);
+            $data[$name] = array('name' => $name);
         }
         switch ($r[2]) {
-          case 'r':
+            case 'r':
             $f = 'running';
             break;
-          case 'd':
+            case 'd':
             $f = 'disabled';
             break;
-          case 'rul':
+            case 'rul':
             $f = 'rule';
             break;
-          case 'w':
+            case 'w':
             $f = 'weight';
             break;
-          case 'c':
+            case 'c':
             $f = 'context';
             break;
-          case 'lr':
+            case 'lr':
             $f = 'last_run';
             break;
-          case 'la':
+            case 'la':
             $f = 'last_aborted';
             break;
-          case 'ac':
+            case 'ac':
             $f = 'abort_count';
             break;
-          case 'laf':
+            case 'laf':
             $f = 'last_abort_function';
             break;
-          case 'let':
+            case 'let':
             $f = 'last_execution_time';
             break;
-          case 'ec':
+            case 'ec':
             $f = 'execution_count';
             break;
-          case 'aet':
+            case 'aet':
             $f = 'avg_execution_time';
             break;
-          case 'met':
+            case 'met':
             $f = 'max_execution_time';
             break;
-          case 'lst':
+            case 'lst':
             $f = 'last_shutdown_time';
             break;
         }
         $data[$name][$f] = unserialize($v->value);
         $todelete[] = $v->name;
-      }
+        }
     }
 
     $ifields = array('disabled', 'weight', 'running', 'last_run', 'last_aborted', 'abort_count', 'last_execution_time', 'execution_count', 'avg_execution_time', 'max_execution_time', 'last_shutdown_time');
     foreach ($data as $v) {
-      foreach ($ifields as $f) {
+        foreach ($ifields as $f) {
         if (empty($v[$f])) {
-          $v[$f] = 0;
+            $v[$f] = 0;
+        }
         }
-      }
-      db_query("insert into {elysia_cron} (name, disabled, rule, weight, context, running, last_run, last_aborted, abort_count, last_abort_function, last_execution_time, execution_count, avg_execution_time, max_execution_time, last_shutdown_time)
+        db_query("insert into {elysia_cron} (name, disabled, rule, weight, context, running, last_run, last_aborted, abort_count, last_abort_function, last_execution_time, execution_count, avg_execution_time, max_execution_time, last_shutdown_time)
         values ('%s', %d, '%s', %d, '%s', %d, %d, %d, %d, '%s', %d, %d, %f, %d, %d)",
         $v['name'], $v['disabled'], $v['rule'], $v['weight'], $v['context'], $v['running'], $v['last_run'], $v['last_aborted'], $v['abort_count'], $v['last_abort_function'], $v['last_execution_time'], $v['execution_count'], $v['avg_execution_time'], $v['max_execution_time'], $v['last_shutdown_time']
-      );
+        );
     }
 
     db_query("update {elysia_cron} set context = null where context = ''");
     db_query("update {elysia_cron} set rule = null where rule = ''");
 
     foreach ($todelete as $v) {
-      variable_del($v);
-      db_query("DELETE FROM {variable} WHERE name = '%s'", $v);
+        variable_del($v);
+        db_query("DELETE FROM {variable} WHERE name = '%s'", $v);
     }
 
     variable_set('elysia_cron_version', 20100507);
 
     unset($GLOBALS['_ec_variables']);
-  }
-  // D7 VERSION FROM NOW ON...
+    }
+    // D7 VERSION FROM NOW ON...
 
-  if ($ver < 20110323) {
+    if ($ver < 20110323) {
     if (EC_DRUPAL_VERSION >= 7) {
-      // D7
-      // Must use "$v" for PHP5.3 running D6 version (detect the error even if it doesn't pass here)
-      db_change_field($v = 'elysia_cron', 'weight', 'weight', array('type' => 'int', 'not null' => FALSE));
+        // D7
+        // Must use "$v" for PHP5.3 running D6 version (detect the error even if it doesn't pass here)
+        db_change_field($v = 'elysia_cron', 'weight', 'weight', array('type' => 'int', 'not null' => FALSE));
 
     }
     elseif (EC_DRUPAL_VERSION >= 6) {
-      // D6
-      $ret = array();
-      db_change_field($ret, 'elysia_cron', 'weight', 'weight', array('type' => 'int', 'not null' => FALSE));
+        // D6
+        $ret = array();
+        db_change_field($ret, 'elysia_cron', 'weight', 'weight', array('type' => 'int', 'not null' => FALSE));
     }
     else {
-      // D5
-      db_query("alter table {elysia_cron} change weight weight int(11)");
+        // D5
+        db_query("alter table {elysia_cron} change weight weight int(11)");
     }
 
     variable_set('elysia_cron_version', 20110323);
-  }
+    }
   
-  if ($ver < 20111007) {
+    if ($ver < 20111007) {
     $default_rules = variable_get('elysia_cron_default_rules', $GLOBALS['elysia_cron_default_rules']);
     if (!empty($default_rules['*/6 * * * *']) && $default_rules['*/6 * * * *'] == 'Every 6 hours') {
-      unset($default_rules['*/6 * * * *']);
-      $default_rules['0 */6 * * *'] = 'Every 6 hours';
-      variable_set('elysia_cron_default_rules', $default_rules);
+        unset($default_rules['*/6 * * * *']);
+        $default_rules['0 */6 * * *'] = 'Every 6 hours';
+        variable_set('elysia_cron_default_rules', $default_rules);
     }
     variable_set('elysia_cron_version', 20111007);
-  }
+    }
 
-  if ($ver < 20111012) {
+    if ($ver < 20111012) {
     // I only need to rebuild variable cache, so i just set the new version
     variable_set('elysia_cron_version', 20111012);
-  }
+    }
 
-  if ($ver < 20111020) {
+    if ($ver < 20111020) {
     if (EC_DRUPAL_VERSION >= 7) {
-      // D7
-      // Must use "$v" for PHP5.3 running D6 version (detect the error even if it doesn't pass here)
-      db_change_field($v = 'elysia_cron', 'disabled', 'disable', array('type' => 'int', 'size' => 'tiny', 'not null' => FALSE));
+        // D7
+        // Must use "$v" for PHP5.3 running D6 version (detect the error even if it doesn't pass here)
+        db_change_field($v = 'elysia_cron', 'disabled', 'disable', array('type' => 'int', 'size' => 'tiny', 'not null' => FALSE));
 
     }
     elseif (EC_DRUPAL_VERSION >= 6) {
-      // D6
-      $ret = array();
-      db_change_field($ret, 'elysia_cron', 'disabled', 'disable', array('type' => 'int', 'size' => 'tiny', 'not null' => FALSE));
+        // D6
+        $ret = array();
+        db_change_field($ret, 'elysia_cron', 'disabled', 'disable', array('type' => 'int', 'size' => 'tiny', 'not null' => FALSE));
     }
     else {
-      // D5
-      db_query("alter table {elysia_cron} change disabled disable tinyint(1)");
+        // D5
+        db_query("alter table {elysia_cron} change disabled disable tinyint(1)");
     }
     db_query("update {elysia_cron} set disable = NULL where disable = 0");
 
     variable_set('elysia_cron_version', 20111020);
-  }
+    }
 }

drupal/sites/default/boinc/modules/contrib/elysia_cron/elysia_cron_scheduler.inc

Indentation +141 added lines, -141 removed lines

@@ -1,164 +1,164 @@ 
 <?php
 
 function elysia_cron_should_run($conf, $now = -1) {  $prev_rule_run = 0; // A che ora SAREBBE dovuto essere lanciato l'ultima volta
-  if ($conf['disabled']) {
+    if ($conf['disabled']) {
     return false;
-  }
-  if ($now < 0) {
+    }
+    if ($now < 0) {
     $now = time();
-  }
-  if ((!$conf['last_run']) || ($now - $conf['last_run'] > 365 * 86400)) {
+    }
+    if ((!$conf['last_run']) || ($now - $conf['last_run'] > 365 * 86400)) {
     return true;
-  }
+    }
 
-  $next_run = _elysia_cron_next_run($conf);
-  return $now >= $next_run;
+    $next_run = _elysia_cron_next_run($conf);
+    return $now >= $next_run;
 }
 
 function _elysia_cron_next_run($conf) {
-  $ranges = array(
+    $ranges = array(
     array(0, 59),
     array(0, 23),
     array(1, 31), // TODO
     array(1, 12),
     array(0, 3000),
     array(0, 6),
-  );
+    );
 
-  if (!preg_match('/^([0-9*,\/-]+)[ ]+([0-9*,\/-]+)[ ]+([0-9*,\/-]+)[ ]+([0-9*,\/-]+)[ ]+([0-9*,\/-]+)$/', $conf['rule'], $rules)) {
+    if (!preg_match('/^([0-9*,\/-]+)[ ]+([0-9*,\/-]+)[ ]+([0-9*,\/-]+)[ ]+([0-9*,\/-]+)[ ]+([0-9*,\/-]+)$/', $conf['rule'], $rules)) {
     _dco_watchdog('cron', 'Invalid rule found: %rule', array('%rule' => $conf['rule']));
     return false;
-  }
+    }
 
-  $rule = array($rules[1], $rules[2], array($rules[3], $rules[5]), $rules[4]);
-  $ruledec = array();
-  $date = __cronDecodeDate($conf['last_run'], 1);
-  $expected_date = __cronDecodeDate(!empty($conf['last_run_expected']) ? $conf['last_run_expected'] : 0);
+    $rule = array($rules[1], $rules[2], array($rules[3], $rules[5]), $rules[4]);
+    $ruledec = array();
+    $date = __cronDecodeDate($conf['last_run'], 1);
+    $expected_date = __cronDecodeDate(!empty($conf['last_run_expected']) ? $conf['last_run_expected'] : 0);
   
-  for ($i = 0; $i < 4; $i++) {
+    for ($i = 0; $i < 4; $i++) {
     if ($i != 2) {
-      // Standard scheme for mins, hours, month
-      $ruledec[$i] = __cronDecodeRule($rule[$i], $ranges[$i][0], $ranges[$i][1]);
+        // Standard scheme for mins, hours, month
+        $ruledec[$i] = __cronDecodeRule($rule[$i], $ranges[$i][0], $ranges[$i][1]);
     } else {
-      // For mday+week we follow another scheme
-      $ruledec[$i] = __cronDecodeRuleMday($rule[2], $date[3], $date[4]);
+        // For mday+week we follow another scheme
+        $ruledec[$i] = __cronDecodeRuleMday($rule[2], $date[3], $date[4]);
     }
     $r = $ruledec[$i];
     $new = $date[$i];
     if ($r['d']) {
-      if ($expected_date[$i] > $date[$i]) {
+        if ($expected_date[$i] > $date[$i]) {
         $expected_date[$i] -= $ranges[$i][1] + 1;
-      }
-      $new = $expected_date[$i] + ceil(($date[$i] - $expected_date[$i]) / $r['d']) * $r['d'];
+        }
+        $new = $expected_date[$i] + ceil(($date[$i] - $expected_date[$i]) / $r['d']) * $r['d'];
     }
     elseif ($r['n']) {
-      $new = __cronNextOrEqual($date[$i], $r['n'], $ranges[$i][0], $ranges[$i][1]);
+        $new = __cronNextOrEqual($date[$i], $r['n'], $ranges[$i][0], $ranges[$i][1]);
     }
     if ($new != $date[$i]) {
-      $date[$i] = $new;
-      if ($date[$i] > $ranges[$i][1]) {
+        $date[$i] = $new;
+        if ($date[$i] > $ranges[$i][1]) {
         $date[$i + 1]++;
         $date[$i] = $ranges[$i][0] + $date[$i] - $ranges[$i][1] - 1;
-      }
-      for ($j = 0; $j < $i; $j++) {
+        }
+        for ($j = 0; $j < $i; $j++) {
         if ($j == 2) {
-          // For mday+week decoded rule could be changed (by month+year)
-          $ruledec[$j] = __cronDecodeRuleMday($rule[2], $date[3], $date[4]);
+            // For mday+week decoded rule could be changed (by month+year)
+            $ruledec[$j] = __cronDecodeRuleMday($rule[2], $date[3], $date[4]);
         }
         $date[$j] = $ruledec[$j]['d'] ? ($ranges[$j][0] == 0 ? 0 : $ruledec[$j]['d']) : ($ruledec[$j]['n'] ? reset($ruledec[$j]['n']) : $ranges[$j][0]);
         $expected_date[$j] = 0;
-      }
+        }
+    }
     }
-  }
 
-  return __cronEncodeDate($date);
+    return __cronEncodeDate($date);
 }
 
 function __cronDecodeDate($timestamp, $min_diff = 0) {
-  $time = floor($timestamp / 60);
-  $time += $min_diff;
+    $time = floor($timestamp / 60);
+    $time += $min_diff;
   
-  $date = $time ? getdate($time * 60) : 0;
-  $date = array(
+    $date = $time ? getdate($time * 60) : 0;
+    $date = array(
     $time ? $date['minutes'] : 0,
     $time ? $date['hours'] : 0,
     $time ? $date['mday'] : 0,
     $time ? $date['mon'] : 0,
     $time ? $date['year'] : 0,
-  );
-  return $date;
+    );
+    return $date;
 }
 function __cronEncodeDate($date) {
-  return mktime($date[1], $date[0], 0, $date[3], $date[2], $date[4]);
+    return mktime($date[1], $date[0], 0, $date[3], $date[2], $date[4]);
 }
 
 function __cronNextOrEqual($el, $arr, $range_start, $range_end) {
-  if (empty($arr)) {
+    if (empty($arr)) {
     return $el;
-  }
-  foreach ($arr as $x) {
+    }
+    foreach ($arr as $x) {
     if ($x >= $el) {
-      return $x;
+        return $x;
     }
-  }
-  return $range_end + reset($arr) + 1 - $range_start;
+    }
+    return $range_end + reset($arr) + 1 - $range_start;
 }
 
 function __cronDecodeRule($rule, $min, $max) {
-  if ($rule == '*') {
+    if ($rule == '*') {
     return array('n' => array(), 'd' => 0);
-  }
+    }
 
-  $result = array('n' => array(), 'd' => 0);
-  foreach (explode(',', $rule) as $token) {
+    $result = array('n' => array(), 'd' => 0);
+    foreach (explode(',', $rule) as $token) {
     if (preg_match('/^([0-9]+)-([0-9]+)$/', $token, $r)) {
-      $result['n'] = array_merge($result['n'], range($r[1], $r[2]));
+        $result['n'] = array_merge($result['n'], range($r[1], $r[2]));
     }
     elseif (preg_match('/^\*\/([0-9]+)$/', $token, $r)) {
-      $result['d'] = $r[1];
+        $result['d'] = $r[1];
     }
     elseif (is_numeric($token)) {
-      $result['n'][] = $token;
+        $result['n'][] = $token;
     }
-  }
-  sort($result['n']);
-  return $result;
+    }
+    sort($result['n']);
+    return $result;
 }
 
 function __cronDecodeRuleMday($rule, $month, $year) {
-  $range_from = 1;
-  $range_to = $month != 2 ? (in_array($month, array(4,6,9,11)) ? 30 : 31) : ($year % 4 == 0 ? 29 : 28);
-  $r1 = __cronDecodeRule($rule[0], $range_from, $range_to);
-  $r2 = __cronDecodeRule($rule[1], $range_from, $range_to);
-  if ($r2['d']) {
+    $range_from = 1;
+    $range_to = $month != 2 ? (in_array($month, array(4,6,9,11)) ? 30 : 31) : ($year % 4 == 0 ? 29 : 28);
+    $r1 = __cronDecodeRule($rule[0], $range_from, $range_to);
+    $r2 = __cronDecodeRule($rule[1], $range_from, $range_to);
+    if ($r2['d']) {
     for ($i = 0; $i < 7; $i++) {
-      if ($i % $r2['d'] == 0) {
+        if ($i % $r2['d'] == 0) {
         $r2['n'][] = $i;
-      }
+        }
     }
-  }
-  if ($r2['n']) {
+    }
+    if ($r2['n']) {
     $r2['n'] = array_unique($r2['n']);
     $r1['n'] = array_merge($r1['n'], __cronMonDaysFromWeekDays($year, $month, $r2['n']), __cronMonDaysFromWeekDays($year, $month + 1, $r2['n'], $range_to));
-  }
-  return $r1;
+    }
+    return $r1;
 }
 
 // Used by elysia_cron_should_run
 function __cronMonDaysFromWeekDays($year, $mon, $weekdays, $offset = 0) {
-  if ($mon > 12) {
+    if ($mon > 12) {
     $year ++;
     $mon = $mon - 12;
-  }
+    }
   
-  $result = array();
-  for ($i = 1; checkdate($mon, $i, $year); $i++) {
+    $result = array();
+    for ($i = 1; checkdate($mon, $i, $year); $i++) {
     $w = date('w', mktime(12, 00, 00, $mon, $i, $year));
     if (in_array($w, $weekdays)) {
-      $result[] = $i + $offset;
+        $result[] = $i + $offset;
+    }
     }
-  }
-  return $result;
+    return $result;
 }
 
 /*******************************************************************************
@@ -166,73 +166,73 @@ 
  ******************************************************************************/
 
 function test_elysia_cron_should_run() {
-  dprint("Start test");
-  $start = microtime(true);
+    dprint("Start test");
+    $start = microtime(true);
   
-  //mktime: hr min sec mon day yr
-  dprint(" 1." . (false == elysia_cron_should_run(array('rule' => '0 12 * * *', 'last_run' => mktime(12, 0, 0, 1, 2, 2008)), mktime(12, 01, 0, 1, 2, 2008))));
-  dprint(" 2." . (false == elysia_cron_should_run(array('rule' => '0 12 * * *', 'last_run' => mktime(12, 0, 0, 1, 2, 2008)), mktime(15, 00, 0, 1, 2, 2008))));
-  dprint(" 3." . (false == elysia_cron_should_run(array('rule' => '0 12 * * *', 'last_run' => mktime(12, 0, 0, 1, 2, 2008)), mktime(11, 59, 0, 1, 3, 2008))));
-  dprint(" 4." . (true  == elysia_cron_should_run(array('rule' => '0 12 * * *', 'last_run' => mktime(12, 0, 0, 1, 2, 2008)), mktime(12, 00, 0, 1, 3, 2008))));
-  dprint(" 5." . (false == elysia_cron_should_run(array('rule' => '59 23 * * *', 'last_run' => mktime(23, 59, 0, 1, 2, 2008)), mktime(0, 00, 0, 1, 3, 2008))));
-  dprint(" 6." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * *', 'last_run' => mktime(23, 59, 0, 1, 2, 2008)), mktime(23, 59, 0, 1, 3, 2008))));
-  dprint(" 7." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * *', 'last_run' => mktime(23, 59, 0, 1, 2, 2008)), mktime(0, 00, 0, 1, 4, 2008))));
-  dprint(" 8." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * *', 'last_run' => mktime(23, 58, 0, 1, 2, 2008)), mktime(23, 59, 0, 1, 2, 2008))));
-  dprint(" 9." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * *', 'last_run' => mktime(23, 58, 0, 1, 2, 2008)), mktime(0, 0, 0, 1, 3, 2008))));
-  dprint("10." . (false == elysia_cron_should_run(array('rule' => '59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 5, 2008))));
-  dprint("11." . (false == elysia_cron_should_run(array('rule' => '59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(0, 0, 0, 1, 6, 2008))));
-  dprint("12." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 6, 2008))));
-  dprint("13." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(00, 00, 0, 1, 7, 2008))));
-  dprint("14." . (true  == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 29, 0, 1, 6, 2008))));
-  dprint("15." . (true  == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 6, 2008))));
-  dprint("16." . (false == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 5, 2008))));
-  dprint("17." . (true  == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 58, 0, 1, 6, 2008))));
-  dprint("18." . (false == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 28, 0, 1, 6, 2008))));
-  dprint("19." . (false == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 28, 0, 1, 5, 2008)), mktime(23, 29, 0, 1, 5, 2008))));
-  dprint("20." . (false == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 28, 0, 1, 5, 2008)), mktime(23, 30, 0, 1, 5, 2008))));
-  dprint("21." . (false == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 28, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 5, 2008))));
-  dprint("22." . (true  == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 28, 0, 1, 5, 2008)), mktime(23, 29, 0, 1, 6, 2008))));
-
-  dprint("23." . (false == elysia_cron_should_run(array('rule' => '29,59 23 * * 5', 'last_run' => mktime(23, 59, 0, 2, 22, 2008)), mktime(23, 59, 0, 2, 28, 2008))));
-  dprint("24." . (true  == elysia_cron_should_run(array('rule' => '29,59 23 * * 5', 'last_run' => mktime(23, 59, 0, 2, 22, 2008)), mktime(23, 59, 0, 2, 29, 2008))));
-  dprint("25." . (true  == elysia_cron_should_run(array('rule' => '29,59 23 * * 5', 'last_run' => mktime(23, 59, 0, 2, 22, 2008)), mktime(0, 0, 0, 3, 1, 2008))));
-
-  dprint("26." . (false == elysia_cron_should_run(array('rule' => '59 23 * * 3', 'last_run' => mktime(23, 59, 0, 12, 31, 2008)), mktime(0, 0, 0, 1, 1, 2009))));
-  dprint("27." . (false == elysia_cron_should_run(array('rule' => '59 23 * * 3', 'last_run' => mktime(23, 59, 0, 12, 31, 2008)), mktime(0, 0, 0, 1, 7, 2009))));
-  dprint("28." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * 3', 'last_run' => mktime(23, 59, 0, 12, 31, 2008)), mktime(23, 59, 0, 1, 7, 2009))));
-
-  dprint("29." . (true  == elysia_cron_should_run(array('rule' => '59 23 * 2 5', 'last_run' => mktime(23, 59, 0, 2, 22, 2008)), mktime(23, 59, 0, 2, 29, 2008))));
-  dprint("30." . (true  == elysia_cron_should_run(array('rule' => '59 23 * 2 5', 'last_run' => mktime(23, 59, 0, 2, 22, 2008)), mktime(0, 0, 0, 3, 1, 2008))));
-  dprint("31." . (false == elysia_cron_should_run(array('rule' => '59 23 * 2 5', 'last_run' => mktime(23, 59, 0, 2, 29, 2008)), mktime(23, 59, 0, 3, 7, 2008))));
-  dprint("32." . (false == elysia_cron_should_run(array('rule' => '59 23 * 2 5', 'last_run' => mktime(23, 59, 0, 2, 29, 2008)), mktime(23, 58, 0, 2, 6, 2009))));
-  dprint("33." . (true  == elysia_cron_should_run(array('rule' => '59 23 * 2 5', 'last_run' => mktime(23, 59, 0, 2, 29, 2008)), mktime(23, 59, 0, 2, 6, 2009))));
-  dprint("34." . (true  == elysia_cron_should_run(array('rule' => '59 23 *' . '/10 * *', 'last_run' => mktime(23, 58, 0, 1, 10, 2008)), mktime(23, 59, 0, 1, 10, 2008))));
-  dprint("35." . (false == elysia_cron_should_run(array('rule' => '59 23 *' . '/10 * *', 'last_run' => mktime(23, 59, 0, 1, 10, 2008)), mktime(23, 59, 0, 1, 11, 2008))));
-  dprint("36." . (true  == elysia_cron_should_run(array('rule' => '59 23 *' . '/10 * *', 'last_run' => mktime(23, 59, 0, 1, 10, 2008)), mktime(23, 59, 0, 1, 20, 2008))));
-  dprint("37." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5,10-15 * *', 'last_run' => mktime(23, 59, 0, 1, 4, 2008)), mktime(23, 59, 0, 1, 5, 2008))));
-  dprint("38." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5,10-15 * *', 'last_run' => mktime(23, 59, 0, 1, 4, 2008)), mktime(23, 59, 0, 1, 6, 2008))));
-  dprint("39." . (false == elysia_cron_should_run(array('rule' => '59 23 1-5,10-15 * *', 'last_run' => mktime(23, 59, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 6, 2008))));
-  dprint("40." . (false == elysia_cron_should_run(array('rule' => '59 23 1-5,10-15 * *', 'last_run' => mktime(23, 59, 0, 1, 5, 2008)), mktime(23, 58, 0, 1, 10, 2008))));
-  dprint("41." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5,10-15 * *', 'last_run' => mktime(23, 59, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 10, 2008))));
-  dprint("42." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5,10-15 * *', 'last_run' => mktime(23, 59, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 16, 2008))));
-
-  dprint("43." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 1, 4, 2008)), mktime(23, 59, 0, 1, 5, 2008))));
-  dprint("44." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 6, 2008))));
-  dprint("45." . (false == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 1, 6, 2008)), mktime(23, 59, 0, 1, 7, 2008))));
-  dprint("46." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 1, 6, 2008)), mktime(23, 59, 0, 1, 13, 2008))));
-  dprint("47." . (false == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 2, 4, 2008)), mktime(23, 59, 0, 2, 5, 2008))));
-  dprint("48." . (false == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 2, 5, 2008)), mktime(23, 59, 0, 2, 10, 2008))));
-  dprint("49." . (false == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 2, 10, 2008)), mktime(23, 59, 0, 2, 17, 2008))));
-
-  dprint("49." . (true  == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(8, 58, 0, 2, 10, 2008)), mktime(8, 59, 0, 2, 10, 2008))));
-  dprint("50." . (false == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(8, 59, 0, 2, 10, 2008)), mktime(9, 00, 0, 2, 10, 2008))));
-  dprint("51." . (false == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(8, 59, 0, 2, 10, 2008)), mktime(17, 59, 0, 2, 10, 2008))));
-  dprint("52." . (true  == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(8, 59, 0, 2, 10, 2008)), mktime(18, 00, 0, 2, 10, 2008))));
-  dprint("53." . (true  == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(18, 00, 0, 2, 10, 2008)), mktime(18, 01, 0, 2, 10, 2008))));
-  dprint("54." . (true  == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(18, 00, 0, 2, 10, 2008)), mktime(19, 0, 0, 2, 10, 2008))));
-  dprint("55." . (true  == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(18, 00, 0, 2, 10, 2008)), mktime(9, 0, 0, 3, 10, 2008))));
-
-  dprint("End test (" . (microtime(true) - $start) . ")");
+    //mktime: hr min sec mon day yr
+    dprint(" 1." . (false == elysia_cron_should_run(array('rule' => '0 12 * * *', 'last_run' => mktime(12, 0, 0, 1, 2, 2008)), mktime(12, 01, 0, 1, 2, 2008))));
+    dprint(" 2." . (false == elysia_cron_should_run(array('rule' => '0 12 * * *', 'last_run' => mktime(12, 0, 0, 1, 2, 2008)), mktime(15, 00, 0, 1, 2, 2008))));
+    dprint(" 3." . (false == elysia_cron_should_run(array('rule' => '0 12 * * *', 'last_run' => mktime(12, 0, 0, 1, 2, 2008)), mktime(11, 59, 0, 1, 3, 2008))));
+    dprint(" 4." . (true  == elysia_cron_should_run(array('rule' => '0 12 * * *', 'last_run' => mktime(12, 0, 0, 1, 2, 2008)), mktime(12, 00, 0, 1, 3, 2008))));
+    dprint(" 5." . (false == elysia_cron_should_run(array('rule' => '59 23 * * *', 'last_run' => mktime(23, 59, 0, 1, 2, 2008)), mktime(0, 00, 0, 1, 3, 2008))));
+    dprint(" 6." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * *', 'last_run' => mktime(23, 59, 0, 1, 2, 2008)), mktime(23, 59, 0, 1, 3, 2008))));
+    dprint(" 7." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * *', 'last_run' => mktime(23, 59, 0, 1, 2, 2008)), mktime(0, 00, 0, 1, 4, 2008))));
+    dprint(" 8." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * *', 'last_run' => mktime(23, 58, 0, 1, 2, 2008)), mktime(23, 59, 0, 1, 2, 2008))));
+    dprint(" 9." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * *', 'last_run' => mktime(23, 58, 0, 1, 2, 2008)), mktime(0, 0, 0, 1, 3, 2008))));
+    dprint("10." . (false == elysia_cron_should_run(array('rule' => '59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 5, 2008))));
+    dprint("11." . (false == elysia_cron_should_run(array('rule' => '59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(0, 0, 0, 1, 6, 2008))));
+    dprint("12." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 6, 2008))));
+    dprint("13." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(00, 00, 0, 1, 7, 2008))));
+    dprint("14." . (true  == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 29, 0, 1, 6, 2008))));
+    dprint("15." . (true  == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 6, 2008))));
+    dprint("16." . (false == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 5, 2008))));
+    dprint("17." . (true  == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 58, 0, 1, 6, 2008))));
+    dprint("18." . (false == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 58, 0, 1, 5, 2008)), mktime(23, 28, 0, 1, 6, 2008))));
+    dprint("19." . (false == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 28, 0, 1, 5, 2008)), mktime(23, 29, 0, 1, 5, 2008))));
+    dprint("20." . (false == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 28, 0, 1, 5, 2008)), mktime(23, 30, 0, 1, 5, 2008))));
+    dprint("21." . (false == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 28, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 5, 2008))));
+    dprint("22." . (true  == elysia_cron_should_run(array('rule' => '29,59 23 * * 0', 'last_run' => mktime(23, 28, 0, 1, 5, 2008)), mktime(23, 29, 0, 1, 6, 2008))));
+
+    dprint("23." . (false == elysia_cron_should_run(array('rule' => '29,59 23 * * 5', 'last_run' => mktime(23, 59, 0, 2, 22, 2008)), mktime(23, 59, 0, 2, 28, 2008))));
+    dprint("24." . (true  == elysia_cron_should_run(array('rule' => '29,59 23 * * 5', 'last_run' => mktime(23, 59, 0, 2, 22, 2008)), mktime(23, 59, 0, 2, 29, 2008))));
+    dprint("25." . (true  == elysia_cron_should_run(array('rule' => '29,59 23 * * 5', 'last_run' => mktime(23, 59, 0, 2, 22, 2008)), mktime(0, 0, 0, 3, 1, 2008))));
+
+    dprint("26." . (false == elysia_cron_should_run(array('rule' => '59 23 * * 3', 'last_run' => mktime(23, 59, 0, 12, 31, 2008)), mktime(0, 0, 0, 1, 1, 2009))));
+    dprint("27." . (false == elysia_cron_should_run(array('rule' => '59 23 * * 3', 'last_run' => mktime(23, 59, 0, 12, 31, 2008)), mktime(0, 0, 0, 1, 7, 2009))));
+    dprint("28." . (true  == elysia_cron_should_run(array('rule' => '59 23 * * 3', 'last_run' => mktime(23, 59, 0, 12, 31, 2008)), mktime(23, 59, 0, 1, 7, 2009))));
+
+    dprint("29." . (true  == elysia_cron_should_run(array('rule' => '59 23 * 2 5', 'last_run' => mktime(23, 59, 0, 2, 22, 2008)), mktime(23, 59, 0, 2, 29, 2008))));
+    dprint("30." . (true  == elysia_cron_should_run(array('rule' => '59 23 * 2 5', 'last_run' => mktime(23, 59, 0, 2, 22, 2008)), mktime(0, 0, 0, 3, 1, 2008))));
+    dprint("31." . (false == elysia_cron_should_run(array('rule' => '59 23 * 2 5', 'last_run' => mktime(23, 59, 0, 2, 29, 2008)), mktime(23, 59, 0, 3, 7, 2008))));
+    dprint("32." . (false == elysia_cron_should_run(array('rule' => '59 23 * 2 5', 'last_run' => mktime(23, 59, 0, 2, 29, 2008)), mktime(23, 58, 0, 2, 6, 2009))));
+    dprint("33." . (true  == elysia_cron_should_run(array('rule' => '59 23 * 2 5', 'last_run' => mktime(23, 59, 0, 2, 29, 2008)), mktime(23, 59, 0, 2, 6, 2009))));
+    dprint("34." . (true  == elysia_cron_should_run(array('rule' => '59 23 *' . '/10 * *', 'last_run' => mktime(23, 58, 0, 1, 10, 2008)), mktime(23, 59, 0, 1, 10, 2008))));
+    dprint("35." . (false == elysia_cron_should_run(array('rule' => '59 23 *' . '/10 * *', 'last_run' => mktime(23, 59, 0, 1, 10, 2008)), mktime(23, 59, 0, 1, 11, 2008))));
+    dprint("36." . (true  == elysia_cron_should_run(array('rule' => '59 23 *' . '/10 * *', 'last_run' => mktime(23, 59, 0, 1, 10, 2008)), mktime(23, 59, 0, 1, 20, 2008))));
+    dprint("37." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5,10-15 * *', 'last_run' => mktime(23, 59, 0, 1, 4, 2008)), mktime(23, 59, 0, 1, 5, 2008))));
+    dprint("38." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5,10-15 * *', 'last_run' => mktime(23, 59, 0, 1, 4, 2008)), mktime(23, 59, 0, 1, 6, 2008))));
+    dprint("39." . (false == elysia_cron_should_run(array('rule' => '59 23 1-5,10-15 * *', 'last_run' => mktime(23, 59, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 6, 2008))));
+    dprint("40." . (false == elysia_cron_should_run(array('rule' => '59 23 1-5,10-15 * *', 'last_run' => mktime(23, 59, 0, 1, 5, 2008)), mktime(23, 58, 0, 1, 10, 2008))));
+    dprint("41." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5,10-15 * *', 'last_run' => mktime(23, 59, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 10, 2008))));
+    dprint("42." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5,10-15 * *', 'last_run' => mktime(23, 59, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 16, 2008))));
+
+    dprint("43." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 1, 4, 2008)), mktime(23, 59, 0, 1, 5, 2008))));
+    dprint("44." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 1, 5, 2008)), mktime(23, 59, 0, 1, 6, 2008))));
+    dprint("45." . (false == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 1, 6, 2008)), mktime(23, 59, 0, 1, 7, 2008))));
+    dprint("46." . (true  == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 1, 6, 2008)), mktime(23, 59, 0, 1, 13, 2008))));
+    dprint("47." . (false == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 2, 4, 2008)), mktime(23, 59, 0, 2, 5, 2008))));
+    dprint("48." . (false == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 2, 5, 2008)), mktime(23, 59, 0, 2, 10, 2008))));
+    dprint("49." . (false == elysia_cron_should_run(array('rule' => '59 23 1-5 1 0', 'last_run' => mktime(23, 59, 0, 2, 10, 2008)), mktime(23, 59, 0, 2, 17, 2008))));
+
+    dprint("49." . (true  == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(8, 58, 0, 2, 10, 2008)), mktime(8, 59, 0, 2, 10, 2008))));
+    dprint("50." . (false == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(8, 59, 0, 2, 10, 2008)), mktime(9, 00, 0, 2, 10, 2008))));
+    dprint("51." . (false == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(8, 59, 0, 2, 10, 2008)), mktime(17, 59, 0, 2, 10, 2008))));
+    dprint("52." . (true  == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(8, 59, 0, 2, 10, 2008)), mktime(18, 00, 0, 2, 10, 2008))));
+    dprint("53." . (true  == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(18, 00, 0, 2, 10, 2008)), mktime(18, 01, 0, 2, 10, 2008))));
+    dprint("54." . (true  == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(18, 00, 0, 2, 10, 2008)), mktime(19, 0, 0, 2, 10, 2008))));
+    dprint("55." . (true  == elysia_cron_should_run(array('rule' => '* 0,1,2,3,4,5,6,7,8,18,19,20,21,22,23 * * *', 'last_run' => mktime(18, 00, 0, 2, 10, 2008)), mktime(9, 0, 0, 3, 10, 2008))));
+
+    dprint("End test (" . (microtime(true) - $start) . ")");
 }
 // Remove comment to run tests
 //test_elysia_cron_should_run();die();

drupal/sites/default/boinc/modules/contrib/elysia_cron/cron.php

Indentation +6 added lines, -6 removed lines

@@ -6,13 +6,13 @@ 
  */
 
 if (!file_exists('includes/bootstrap.inc')) {
-  if (!empty($_SERVER['DOCUMENT_ROOT']) && file_exists($_SERVER['DOCUMENT_ROOT'] . '/includes/bootstrap.inc')) {
+    if (!empty($_SERVER['DOCUMENT_ROOT']) && file_exists($_SERVER['DOCUMENT_ROOT'] . '/includes/bootstrap.inc')) {
     chdir($_SERVER['DOCUMENT_ROOT']);
-  } elseif (preg_match('@^(.*)[\\\\/]sites[\\\\/][^\\\\/]+[\\\\/]modules[\\\\/]([^\\\\/]+[\\\\/])?elysia(_cron)?$@', getcwd(), $r) && file_exists($r[1] . '/includes/bootstrap.inc')) {
+    } elseif (preg_match('@^(.*)[\\\\/]sites[\\\\/][^\\\\/]+[\\\\/]modules[\\\\/]([^\\\\/]+[\\\\/])?elysia(_cron)?$@', getcwd(), $r) && file_exists($r[1] . '/includes/bootstrap.inc')) {
     chdir($r[1]);
-  } else {
+    } else {
     die("Cron Fatal Error: Can't locate bootstrap.inc. Check cron.php position.");
-  }
+    }
 }
 
 include_once './includes/bootstrap.inc';
@@ -20,8 +20,8 @@ 
 drupal_bootstrap(DRUPAL_BOOTSTRAP_FULL);
 
 if (function_exists('elysia_cron_run')) {
-  elysia_cron_run();
+    elysia_cron_run();
 }
 else {
-  drupal_cron_run();
+    drupal_cron_run();
 }

drupal/sites/default/boinc/modules/contrib/elysia_cron/elysia_cron.drush.inc

Indentation +5 added lines, -5 removed lines

@@ -8,15 +8,15 @@ 
  * Implementation of hook_drush_command().
  */
 function elysia_cron_drush_command() {
-  $items = array();
+    $items = array();
 
-  $items['elysia-cron'] = array(
+    $items['elysia-cron'] = array(
     'description' => "Run all cron hooks in all active modules for specified site using elysia cron system. Use this instead of \"core-cron\" if elysia_cron module is installed",
     'callback'    => 'drush_elysia_cron_run_wrapper',
     'arguments' => array(),
-  );
+    );
 
-  return $items;
+    return $items;
 }
 
 /**
@@ -25,5 +25,5 @@ 
  * wraps the elysia_cron_run function, passing manual = true
  */
 function drush_elysia_cron_run_wrapper() {
-  return elysia_cron_run(TRUE);
+    return elysia_cron_run(TRUE);
 }

html/ops/show_log.php

Indentation +1 added lines, -1 removed lines

@@ -60,7 +60,7 @@
 echo 'Hint: Example greps: "RESULT#106876", "26fe99aa_25636_00119.wu_1", "WU#8152", "too many errors", "2003-07-17", "CRITICAL" <br>';
 
 if (strlen($f)) {
-	$f = "../log*/". $f;
+    $f = "../log*/". $f;
 } else {
     $f = "../log*/*.log";
 }