<?php
// $Id: poormanscron.module,v 1.7 2006/05/07 18:36:07 me Exp me $ $Name:  $
/** 
* NOTE: This version of poormanscron is a refactoring of the version
* dated Oct 22, 2005.  I made the following changes:
*
* - I refactored poormanscron_exit() into several smaller functions
* - I added log messages which tell how long it took to execute a crontab
* - I added debugging support to print each crontab as its run
* - There is a race condition where two copies of poormanscron can be
*	executed at once, as reported here: http://drupal.org/node/43511
*	I've actually seen this happen in production, with disasterous
*	results.  So I fixed this by using MySQL's GET_LOCK() function
*	to ensure that only one copy of poormanscron runs at any one time.
*	Unfortunately, this fix is MySQL-specific, but it's the only
*	way I could figure out to fix the problem.
*
* -- Douglas Muth (www.claws-and-paws.com)
*
*/

/**
 * @file
 * A module which runs Drupal cron jobs without the cron application.
 */

/**
 * Implementation of hook_help().
 */
function poormanscron_help($section = 'admin/help#poormanscron') {
  switch ($section) {
    case 'admin/help#poormanscron':
    case 'admin/modules#description':
    case 'admin/settings/poormanscron':
      $output = t('Runs Drupal cron jobs without the cron application.');
      break;
  }
  return $output;
}


/**
* Wrapper for the watchdog function call.
*
* @param string $message The message to write to watchdog.
*/
function poormanscron_log($message) {
	watchdog('cron_debug', $message, WATCHDOG_NOTICE);
}


/**
* Try to get a lock for executing the crontabs.  This ensures that only
* one copy of poormanscron is running at a time.
*
* @return boolean True if we get the lock, false otherwise.
*/
function _poormanscron_get_lock() {

	//
	// Set a lock based on the name of the config file 
	// that we loaded.  The lock is used in case this code 
	// is run in two seperate scripts before the 
	// poormanscron_lastrun value gets updated.  Otherwise, 
	// we would have a race condition where multiple 
	// instances of the crontabs can run at the same time.  
	//
	$data = conf_init();
	$lock = "lock_".$data;
	$query = "SELECT GET_LOCK('poormanscron_$lock', 3) AS get_lock";
	$cursor = db_query($query);
	$result = db_fetch_array($cursor);
	if (empty($result['get_lock'])) {
		$message = "Lock timed out.  Will try again later.";
		watchdog('cron', $message, WATCHDOG_WARNING);
		return(false);
	}

	// Assume success
	return(true);

} // End of _poormanscron_get_lock()


/**
* This function checks our start time versus the lastrun time and 
* determines if another crontab was being run while this one was
* waiting for the lock or on the system.
*
* @param integer $time_t The time this script was started.
*
* @return boolean True if there was no parallelism happening
*	and we can keep going.  False if another script was
*	running in parallell and we should stop this one.
*/
function _poormanscron_check_parallel($time_t) {

	//
	// Since the variables are cached, reload them and then run the timestamp
	// check again.  If we were blocking on the previous lock while another
	// crontab was running, we'll fail this check and stop.
	//
	global $conf;
	$conf = variable_init();

	$lastrun = variable_get('poormanscron_lastrun', 0);
	$interval = variable_get('poormanscron_interval', 60);
	$nextrun = $lastrun + 60 * $interval;

	if ($time_t <= $nextrun) {
		$message = "Whoops!  Looks like this crontab was run in a "
			. "parallel process. (Nextrun is now: $nextrun)  Stopping.";
		watchdog('cron', $message, WATCHDOG_WARNING);
		return(false);
	}

	// Assume success
	return(true);

} // End of _poormanscron_check_parallel()


/**
* Actually go through the motions of running crontabs from all of 
* our modules.
*
* @param integer $time_t The time this script was started.
*
*/
function _poormanscron_run_crontabs($time_t) {

	//
	// Are we debugging individual cron hooks?
	//
	$debug = 0;
	$debug = 1;

	//
	// Get the current Drupal messages. Use drupal_set_message() so that
	// the messages aren't deleted in case the cron run fails and
	// we don't get a chance to restore them below.
	//
	$saved_messages = drupal_set_message();

	//
	// Include this file because acidfree needs functions in it that
	// aren't always declared.
	//
	include_once("includes/common.inc");

	//
	// Invoke the cron hooks of all enabled modules.
	//
	$modules = module_list();
	foreach ($modules as $key => $value) {
		if (module_hook($key, 'cron')) {
			if ($debug) {
				$message = "Calling ${key}_cron()...";
				watchdog('cron_debug', $message, 
					WATCHDOG_NOTICE);
			}
			module_invoke($key, 'cron');
		}
	}

	// Write a message to the logs if the user wants us to do so.
	if (variable_get('poormanscron_log_cron_runs', 1) == 1) {
		$seconds = time() - $time_t;
		$message = "Cron run completed.  Time elapsed: $seconds "
			. "seconds";
		watchdog('cron', $message, WATCHDOG_NOTICE);
	}

	// Update the time of the last poormanscron run (this one).
	variable_set('poormanscron_lastrun', time());

	// Delete any messages added during the cron run (and existing prior
	// messages).
	drupal_get_messages();

	// Restore any prior messages.
	if (isset($saved_messages)) {
		foreach ($saved_messages as $type => $types_messages) {
			foreach ($types_messages as $message) {
				drupal_set_message($message, $type);
			}
		}
	}

} // End of _poormanscron_run_crontabs()


/**
 * Implementation of hook_exit().
 *
 * Checks if poormanscron needs to be run. If this is the case, it invokes
 * the cron hooks of all enabled modules, which are executed after
 * all HTML is returned to the browser. So the user who kicks off the cron
 * jobs should not notice any delay.
 */
function poormanscron_exit() {

	//
	// Uncomment these for testing
	//
	//variable_set('poormanscron_lastrun', (time()-601));
	//variable_set('poormanscron_lastrun', 0); exit();

	// Calculate when the next poormanscron run is due.
	$lastrun = variable_get('poormanscron_lastrun', 0);
	$interval = variable_get('poormanscron_interval', 60);
	$nextrun = $lastrun + 60 * $interval;
	$time_t = time();

	// If the configured time has passed, start the next poormanscron run.
	if ($time_t > $nextrun) {

		if (!_poormanscron_get_lock()) {
			return(null);
		}

		if (!_poormanscron_check_parallel($time_t)) {
			return(null);
		}

		if (variable_get('poormanscron_log_cron_runs', 1) == 1) {
			$message = "Starting cron run... ($time_t > $nextrun)";
			watchdog('cron', $message, WATCHDOG_NOTICE);
		}

		//
		// If this cron run fails to complete, wait a few minutes before retrying.
		//
		$retry_interval = variable_get('poormanscron_retry_interval', 10);
		$lastrun = variable_get('poormanscron_lastrun', 0) + 60 * $retry_interval;
		variable_set('poormanscron_lastrun', $lastrun);

		//
		// Everything is good, go run our crontabs!
		//
		_poormanscron_run_crontabs($time_t);

	}

} // End of poormanscron_exit()

/**
 * Implementation of hook_settings().
 */
function poormanscron_settings() {
  $cron_runs_interval_description = t('Minimum number of minutes between cron runs. Cron will actually execute during the first page request after the interval has elapsed.');

  $retry_interval_description = t('The number of minutes to wait after a cron run error before retrying.');

  $log_cron_runs_description = t('If you want to log successful cron runs to the Drupal watchdog, say Yes here. If those messages annoy you, disable them by selecting No.');

  $output = '';

  $group = form_textfield(t('Cron runs interval'),
                          'poormanscron_interval',
                          variable_get('poormanscron_interval', 60),
                          5, 10, $cron_runs_interval_description);
  $group .= form_textfield(t('Retry interval'), 'poormanscron_retry_interval',
                           variable_get('poormanscron_retry_interval', 10),
                           3, 10, $retry_interval_description);
  $output .= form_group(t('Time intervals'), $group);

  $group = form_select(t('Log successful cron runs'),
                       'poormanscron_log_cron_runs',
                       variable_get('poormanscron_log_cron_runs', 1),
                       array('1' => t('Yes'), '0' => t('No')),
                       $log_cron_runs_description);
  $output .= form_group(t('Logging'), $group);

  return $output;
}

?>