X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FCore%2FWorker.php;h=e3d8df45e40625eb2ce42b31d7328f6639f549f9;hb=ea9b4cc52319bdeb2078ff34cdb2eff90ae3aa22;hp=76bd9fd077f4698d91581ce37096b8514ba85459;hpb=9e99066fd70a9dd9a291a523afba1a390f0e3a0b;p=friendica.git diff --git a/src/Core/Worker.php b/src/Core/Worker.php index 76bd9fd077..e3d8df45e4 100644 --- a/src/Core/Worker.php +++ b/src/Core/Worker.php @@ -1,15 +1,21 @@ start_process(); + self::startProcess(); // Kill stale processes every 5 minutes $last_cleanup = Config::get('system', 'poller_last_cleaned', 0); @@ -84,12 +93,11 @@ class Worker { // We fetch the next queue entry that is about to be executed while ($r = self::workerProcess($passing_slow)) { - // When we are processing jobs with a lower priority, we don't refetch new jobs // Otherwise fast jobs could wait behind slow ones and could be blocked. $refetched = $passing_slow; - foreach ($r AS $entry) { + foreach ($r as $entry) { // Assure that the priority is an integer value $entry['priority'] = (int)$entry['priority']; @@ -108,7 +116,7 @@ class Worker { } } - // To avoid the quitting of multiple pollers only one poller at a time will execute the check + // To avoid the quitting of multiple workers only one worker at a time will execute the check if (Lock::set('poller_worker', 0)) { $stamp = (float)microtime(true); // Count active workers and compare them with a maximum value that depends on the load @@ -126,7 +134,7 @@ class Worker { self::$db_duration += (microtime(true) - $stamp); } - // Quit the poller once every 5 minutes + // Quit the worker once every 5 minutes if (time() > ($starttime + 300)) { logger('Process lifetime reached, quitting.', LOGGER_DEBUG); return; @@ -140,7 +148,8 @@ class Worker { * * @return integer Number of non executed entries in the worker queue */ - private static function totalEntries() { + private static function totalEntries() + { $s = dba::fetch_first("SELECT COUNT(*) AS `total` FROM `workerqueue` WHERE `executed` <= ? AND NOT `done`", NULL_DATE); if (DBM::is_result($s)) { return $s["total"]; @@ -152,13 +161,14 @@ class Worker { /** * @brief Returns the highest priority in the worker queue that isn't executed * - * @return integer Number of active poller processes + * @return integer Number of active worker processes */ - private static function highestPriority() { - $condition = array("`executed` <= ? AND NOT `done`", NULL_DATE); - $s = dba::select('workerqueue', array('priority'), $condition, array('limit' => 1, 'order' => array('priority'))); - if (DBM::is_result($s)) { - return $s["priority"]; + private static function highestPriority() + { + $condition = ["`executed` <= ? AND NOT `done`", NULL_DATE]; + $workerqueue = dba::selectFirst('workerqueue', ['priority'], $condition, ['order' => ['priority']]); + if (DBM::is_result($workerqueue)) { + return $workerqueue["priority"]; } else { return 0; } @@ -171,8 +181,9 @@ class Worker { * * @return integer Is there a process running with that priority? */ - private static function processWithPriorityActive($priority) { - $condition = array("`priority` <= ? AND `executed` > ? AND NOT `done`", $priority, NULL_DATE); + private static function processWithPriorityActive($priority) + { + $condition = ["`priority` <= ? AND `executed` > ? AND NOT `done`", $priority, NULL_DATE]; return dba::exists('workerqueue', $condition); } @@ -183,13 +194,14 @@ class Worker { * * @return boolean "true" if further processing should be stopped */ - public static function execute($queue) { + public static function execute($queue) + { $a = get_app(); $mypid = getmypid(); // Quit when in maintenance - if (Config::get('system', 'maintenance', true)) { + if (Config::get('system', 'maintenance', false, true)) { logger("Maintenance mode - quit process ".$mypid, LOGGER_DEBUG); return false; } @@ -206,11 +218,39 @@ class Worker { return false; } - $argv = json_decode($queue["parameter"]); + $argv = json_decode($queue["parameter"], true); // Check for existance and validity of the include file $include = $argv[0]; + if (method_exists(sprintf('Friendica\Worker\%s', $include), 'execute')) { + // We constantly update the "executed" date every minute to avoid being killed too soon + if (!isset(self::$last_update)) { + self::$last_update = strtotime($queue["executed"]); + } + + $age = (time() - self::$last_update) / 60; + self::$last_update = time(); + + if ($age > 1) { + $stamp = (float)microtime(true); + dba::update('workerqueue', ['executed' => DateTimeFormat::utcNow()], ['pid' => $mypid, 'done' => false]); + self::$db_duration += (microtime(true) - $stamp); + } + + array_shift($argv); + + self::execFunction($queue, $include, $argv, true); + + $stamp = (float)microtime(true); + if (dba::update('workerqueue', ['done' => true], ['id' => $queue["id"]])) { + Config::set('system', 'last_poller_execution', DateTimeFormat::utcNow()); + } + self::$db_duration = (microtime(true) - $stamp); + + return true; + } + // The script could be provided as full path or only with the function name if ($include == basename($include)) { $include = "include/".$include.".php"; @@ -218,16 +258,15 @@ class Worker { if (!validate_include($include)) { logger("Include file ".$argv[0]." is not valid!"); - dba::delete('workerqueue', array('id' => $queue["id"])); + dba::delete('workerqueue', ['id' => $queue["id"]]); return true; } - require_once($include); + require_once $include; $funcname = str_replace(".php", "", basename($argv[0]))."_run"; if (function_exists($funcname)) { - // We constantly update the "executed" date every minute to avoid being killed too soon if (!isset(self::$last_update)) { self::$last_update = strtotime($queue["executed"]); @@ -238,20 +277,20 @@ class Worker { if ($age > 1) { $stamp = (float)microtime(true); - dba::update('workerqueue', array('executed' => datetime_convert()), array('pid' => $mypid, 'done' => false)); + dba::update('workerqueue', ['executed' => DateTimeFormat::utcNow()], ['pid' => $mypid, 'done' => false]); self::$db_duration += (microtime(true) - $stamp); } - self::execFunction($queue, $funcname, $argv); + self::execFunction($queue, $funcname, $argv, false); $stamp = (float)microtime(true); - if (dba::update('workerqueue', array('done' => true), array('id' => $queue["id"]))) { - Config::set('system', 'last_poller_execution', datetime_convert()); + if (dba::update('workerqueue', ['done' => true], ['id' => $queue["id"]])) { + Config::set('system', 'last_poller_execution', DateTimeFormat::utcNow()); } self::$db_duration = (microtime(true) - $stamp); } else { logger("Function ".$funcname." does not exist"); - dba::delete('workerqueue', array('id' => $queue["id"])); + dba::delete('workerqueue', ['id' => $queue["id"]]); } return true; @@ -260,11 +299,14 @@ class Worker { /** * @brief Execute a function from the queue * - * @param array $queue Workerqueue entry - * @param string $funcname name of the function - * @param array $argv Array of values to be passed to the function + * @param array $queue Workerqueue entry + * @param string $funcname name of the function + * @param array $argv Array of values to be passed to the function + * @param boolean $method_call boolean + * @return void */ - private static function execFunction($queue, $funcname, $argv) { + private static function execFunction($queue, $funcname, $argv, $method_call) + { $a = get_app(); $mypid = getmypid(); @@ -283,13 +325,15 @@ class Worker { $a->performance["start"] = microtime(true); $a->performance["database"] = 0; $a->performance["database_write"] = 0; + $a->performance["cache"] = 0; + $a->performance["cache_write"] = 0; $a->performance["network"] = 0; $a->performance["file"] = 0; $a->performance["rendering"] = 0; $a->performance["parser"] = 0; $a->performance["marktime"] = 0; $a->performance["markstart"] = microtime(true); - $a->callstack = array(); + $a->callstack = []; } // For better logging create a new process id for every worker call @@ -303,7 +347,11 @@ class Worker { // Reset global data to avoid interferences unset($_SESSION); - $funcname($argv, $argc); + if ($method_call) { + call_user_func_array(sprintf('Friendica\Worker\%s::execute', $funcname), $argv); + } else { + $funcname($argv, $argc); + } $a->process_id = $old_process_id; unset($a->queue); @@ -317,10 +365,14 @@ class Worker { * The execution time is the productive time. * By changing parameters like the maximum number of workers we can check the effectivness. */ - logger('DB: '.number_format(self::$db_duration, 2). + logger( + 'DB: '.number_format(self::$db_duration, 2). ' - Lock: '.number_format(self::$lock_duration, 2). ' - Rest: '.number_format($up_duration - self::$db_duration - self::$lock_duration, 2). - ' - Execution: '.number_format($duration, 2), LOGGER_DEBUG); + ' - Execution: '.number_format($duration, 2), + LOGGER_DEBUG + ); + self::$lock_duration = 0; if ($duration > 3600) { @@ -339,10 +391,11 @@ class Worker { if (Config::get("system", "profiler")) { $duration = microtime(true)-$a->performance["start"]; + $o = ''; if (Config::get("rendertime", "callstack")) { if (isset($a->callstack["database"])) { - $o = "\nDatabase Read:\n"; - foreach ($a->callstack["database"] AS $func => $time) { + $o .= "\nDatabase Read:\n"; + foreach ($a->callstack["database"] as $func => $time) { $time = round($time, 3); if ($time > 0) { $o .= $func.": ".$time."\n"; @@ -351,7 +404,25 @@ class Worker { } if (isset($a->callstack["database_write"])) { $o .= "\nDatabase Write:\n"; - foreach ($a->callstack["database_write"] AS $func => $time) { + foreach ($a->callstack["database_write"] as $func => $time) { + $time = round($time, 3); + if ($time > 0) { + $o .= $func.": ".$time."\n"; + } + } + } + if (isset($a->callstack["dache"])) { + $o .= "\nCache Read:\n"; + foreach ($a->callstack["dache"] as $func => $time) { + $time = round($time, 3); + if ($time > 0) { + $o .= $func.": ".$time."\n"; + } + } + } + if (isset($a->callstack["dache_write"])) { + $o .= "\nCache Write:\n"; + foreach ($a->callstack["dache_write"] as $func => $time) { $time = round($time, 3); if ($time > 0) { $o .= $func.": ".$time."\n"; @@ -360,25 +431,31 @@ class Worker { } if (isset($a->callstack["network"])) { $o .= "\nNetwork:\n"; - foreach ($a->callstack["network"] AS $func => $time) { + foreach ($a->callstack["network"] as $func => $time) { $time = round($time, 3); if ($time > 0) { $o .= $func.": ".$time."\n"; } } } - } else { - $o = ''; } - logger("ID ".$queue["id"].": ".$funcname.": ".sprintf("DB: %s/%s, Net: %s, I/O: %s, Other: %s, Total: %s".$o, - number_format($a->performance["database"] - $a->performance["database_write"], 2), - number_format($a->performance["database_write"], 2), - number_format($a->performance["network"], 2), - number_format($a->performance["file"], 2), - number_format($duration - ($a->performance["database"] + $a->performance["network"] + $a->performance["file"]), 2), - number_format($duration, 2)), - LOGGER_DEBUG); + logger( + "ID ".$queue["id"].": ".$funcname.": ".sprintf( + "DB: %s/%s, Cache: %s/%s, Net: %s, I/O: %s, Other: %s, Total: %s".$o, + number_format($a->performance["database"] - $a->performance["database_write"], 2), + number_format($a->performance["database_write"], 2), + number_format($a->performance["cache"], 2), + number_format($a->performance["cache_write"], 2), + number_format($a->performance["network"], 2), + number_format($a->performance["file"], 2), + number_format($duration - ($a->performance["database"] + + $a->performance["cache"] + $a->performance["cache_write"] + + $a->performance["network"] + $a->performance["file"]), 2), + number_format($duration, 2) + ), + LOGGER_DEBUG + ); } $cooldown = Config::get("system", "worker_cooldown", 0); @@ -394,12 +471,12 @@ class Worker { * * @return bool Are more than 3/4 of the maximum connections used? */ - private static function maxConnectionsReached() { - + private static function maxConnectionsReached() + { // Fetch the max value from the config. This is needed when the system cannot detect the correct value by itself. $max = Config::get("system", "max_connections"); - // Fetch the percentage level where the poller will get active + // Fetch the percentage level where the worker will get active $maxlevel = Config::get("system", "max_connections_level", 75); if ($max == 0) { @@ -469,28 +546,36 @@ class Worker { /** * @brief fix the queue entry if the worker process died - * + * @return void */ - private static function killStaleWorkers() { - $entries = dba::select('workerqueue', array('id', 'pid', 'executed', 'priority', 'parameter'), - array('`executed` > ? AND NOT `done` AND `pid` != 0', NULL_DATE), - array('order' => array('priority', 'created'))); + private static function killStaleWorkers() + { + $entries = dba::select( + 'workerqueue', + ['id', 'pid', 'executed', 'priority', 'parameter'], + ['`executed` > ? AND NOT `done` AND `pid` != 0', NULL_DATE], + ['order' => ['priority', 'created']] + ); + while ($entry = dba::fetch($entries)) { if (!posix_kill($entry["pid"], 0)) { - dba::update('workerqueue', array('executed' => NULL_DATE, 'pid' => 0), - array('id' => $entry["id"])); + dba::update( + 'workerqueue', + ['executed' => NULL_DATE, 'pid' => 0], + ['id' => $entry["id"]] + ); } else { // Kill long running processes // Check if the priority is in a valid range - if (!in_array($entry["priority"], array(PRIORITY_CRITICAL, PRIORITY_HIGH, PRIORITY_MEDIUM, PRIORITY_LOW, PRIORITY_NEGLIGIBLE))) { + if (!in_array($entry["priority"], [PRIORITY_CRITICAL, PRIORITY_HIGH, PRIORITY_MEDIUM, PRIORITY_LOW, PRIORITY_NEGLIGIBLE])) { $entry["priority"] = PRIORITY_MEDIUM; } // Define the maximum durations - $max_duration_defaults = array(PRIORITY_CRITICAL => 720, PRIORITY_HIGH => 10, PRIORITY_MEDIUM => 60, PRIORITY_LOW => 180, PRIORITY_NEGLIGIBLE => 720); + $max_duration_defaults = [PRIORITY_CRITICAL => 720, PRIORITY_HIGH => 10, PRIORITY_MEDIUM => 60, PRIORITY_LOW => 180, PRIORITY_NEGLIGIBLE => 720]; $max_duration = $max_duration_defaults[$entry["priority"]]; - $argv = json_decode($entry["parameter"]); + $argv = json_decode($entry["parameter"], true); $argv[0] = basename($argv[0]); // How long is the process already running? @@ -502,6 +587,7 @@ class Worker { // We killed the stale process. // To avoid a blocking situation we reschedule the process at the beginning of the queue. // Additionally we are lowering the priority. (But not PRIORITY_CRITICAL) + $new_priority = $entry["priority"]; if ($entry["priority"] == PRIORITY_HIGH) { $new_priority = PRIORITY_MEDIUM; } elseif ($entry["priority"] == PRIORITY_MEDIUM) { @@ -509,9 +595,11 @@ class Worker { } elseif ($entry["priority"] != PRIORITY_CRITICAL) { $new_priority = PRIORITY_NEGLIGIBLE; } - dba::update('workerqueue', - array('executed' => NULL_DATE, 'created' => datetime_convert(), 'priority' => $new_priority, 'pid' => 0), - array('id' => $entry["id"])); + dba::update( + 'workerqueue', + ['executed' => NULL_DATE, 'created' => DateTimeFormat::utcNow(), 'priority' => $new_priority, 'pid' => 0], + ['id' => $entry["id"]] + ); } else { logger("Worker process ".$entry["pid"]." (".implode(" ", $argv).") now runs for ".round($duration)." of ".$max_duration." allowed minutes. That's okay.", LOGGER_DEBUG); } @@ -524,7 +612,8 @@ class Worker { * * @return bool Are there too much workers running? */ - public static function tooMuchWorkers() { + public static function tooMuchWorkers() + { $queues = Config::get("system", "worker_queues", 4); $maxqueues = $queues; @@ -542,15 +631,20 @@ class Worker { $exponent = 3; $slope = $maxworkers / pow($maxsysload, $exponent); $queues = ceil($slope * pow(max(0, $maxsysload - $load), $exponent)); + $processlist = ''; if (Config::get('system', 'worker_debug')) { // Create a list of queue entries grouped by their priority - $listitem = array(); + $listitem = []; // Adding all processes with no workerqueue entry - $processes = dba::p("SELECT COUNT(*) AS `running` FROM `process` WHERE NOT EXISTS + $processes = dba::p( + "SELECT COUNT(*) AS `running` FROM `process` WHERE NOT EXISTS (SELECT id FROM `workerqueue` - WHERE `workerqueue`.`pid` = `process`.`pid` AND NOT `done` AND `pid` != ?)", getmypid()); + WHERE `workerqueue`.`pid` = `process`.`pid` AND NOT `done` AND `pid` != ?)", + getmypid() + ); + if ($process = dba::fetch($processes)) { $listitem[0] = "0:".$process["running"]; } @@ -567,9 +661,9 @@ class Worker { } dba::close($entries); - $intervals = array(1, 10, 60); - $jobs_per_minute = array(); - foreach ($intervals AS $interval) { + $intervals = [1, 10, 60]; + $jobs_per_minute = []; + foreach ($intervals as $interval) { $jobs = dba::p("SELECT COUNT(*) AS `jobs` FROM `workerqueue` WHERE `done` AND `executed` > UTC_TIMESTAMP() - INTERVAL ".intval($interval)." MINUTE"); if ($job = dba::fetch($jobs)) { $jobs_per_minute[$interval] = number_format($job['jobs'] / $interval, 0); @@ -604,11 +698,12 @@ class Worker { } /** - * @brief Returns the number of active poller processes + * @brief Returns the number of active worker processes * - * @return integer Number of active poller processes + * @return integer Number of active worker processes */ - private static function activeWorkers() { + private static function activeWorkers() + { $workers = dba::fetch_first("SELECT COUNT(*) AS `processes` FROM `process` WHERE `command` = 'Worker.php'"); return $workers["processes"]; @@ -623,18 +718,21 @@ class Worker { * @param string $highest_priority Returns the currently highest priority * @return bool We let pass a slower process than $highest_priority */ - private static function passingSlow(&$highest_priority) { + private static function passingSlow(&$highest_priority) + { $highest_priority = 0; - $r = dba::p("SELECT `priority` + $r = dba::p( + "SELECT `priority` FROM `process` - INNER JOIN `workerqueue` ON `workerqueue`.`pid` = `process`.`pid` AND NOT `done`"); + INNER JOIN `workerqueue` ON `workerqueue`.`pid` = `process`.`pid` AND NOT `done`" + ); // No active processes at all? Fine if (!DBM::is_result($r)) { return false; } - $priorities = array(); + $priorities = []; while ($line = dba::fetch($r)) { $priorities[] = $line["priority"]; } @@ -652,7 +750,7 @@ class Worker { return false; } $high = 0; - foreach ($priorities AS $priority) { + foreach ($priorities as $priority) { if ($priority == $highest_priority) { ++$high; } @@ -672,7 +770,8 @@ class Worker { * @param boolean $passing_slow Returns if we had passed low priority processes * @return boolean Have we found something? */ - private static function findWorkerProcesses(&$passing_slow) { + private static function findWorkerProcesses(&$passing_slow) + { $mypid = getmypid(); // Check if we should pass some low priority process @@ -693,11 +792,15 @@ class Worker { $limit = min($queue_length, ceil($slope * pow($jobs, $exponent))); logger('Total: '.$jobs.' - Maximum: '.$queue_length.' - jobs per queue: '.$limit, LOGGER_DEBUG); - + $ids = []; if (self::passingSlow($highest_priority)) { // Are there waiting processes with a higher priority than the currently highest? - $result = dba::select('workerqueue', array('id'), array("`executed` <= ? AND `priority` < ? AND NOT `done`", NULL_DATE, $highest_priority), - array('limit' => $limit, 'order' => array('priority', 'created'), 'only_query' => true)); + $result = dba::select( + 'workerqueue', + ['id'], + ["`executed` <= ? AND `priority` < ? AND NOT `done`", NULL_DATE, $highest_priority], + ['limit' => $limit, 'order' => ['priority', 'created']] + ); while ($id = dba::fetch($result)) { $ids[] = $id["id"]; @@ -708,8 +811,12 @@ class Worker { if (!$found) { // Give slower processes some processing time - $result = dba::select('workerqueue', array('id'), array("`executed` <= ? AND `priority` > ? AND NOT `done`", NULL_DATE, $highest_priority), - array('limit' => $limit, 'order' => array('priority', 'created'), 'only_query' => true)); + $result = dba::select( + 'workerqueue', + ['id'], + ["`executed` <= ? AND `priority` > ? AND NOT `done`", NULL_DATE, $highest_priority], + ['limit' => $limit, 'order' => ['priority', 'created']] + ); while ($id = dba::fetch($result)) { $ids[] = $id["id"]; @@ -723,8 +830,12 @@ class Worker { // If there is no result (or we shouldn't pass lower processes) we check without priority limit if (!$found) { - $result = dba::select('workerqueue', array('id'), array("`executed` <= ? AND NOT `done`", NULL_DATE), - array('limit' => $limit, 'order' => array('priority', 'created'), 'only_query' => true)); + $result = dba::select( + 'workerqueue', + ['id'], + ["`executed` <= ? AND NOT `done`", NULL_DATE], + ['limit' => $limit, 'order' => ['priority', 'created']] + ); while ($id = dba::fetch($result)) { $ids[] = $id["id"]; @@ -737,7 +848,7 @@ class Worker { if ($found) { $condition = "`id` IN (".substr(str_repeat("?, ", count($ids)), 0, -2).") AND `pid` = 0 AND NOT `done`"; array_unshift($ids, $condition); - dba::update('workerqueue', array('executed' => datetime_convert(), 'pid' => $mypid), $ids); + dba::update('workerqueue', ['executed' => DateTimeFormat::utcNow(), 'pid' => $mypid], $ids); } return $found; @@ -749,11 +860,12 @@ class Worker { * @param boolean $passing_slow Returns if we had passed low priority processes * @return string SQL statement */ - public static function workerProcess(&$passing_slow) { + public static function workerProcess(&$passing_slow) + { $stamp = (float)microtime(true); // There can already be jobs for us in the queue. - $r = dba::select('workerqueue', array(), array('pid' => getmypid(), 'done' => false)); + $r = dba::select('workerqueue', [], ['pid' => getmypid(), 'done' => false]); if (DBM::is_result($r)) { self::$db_duration += (microtime(true) - $stamp); return dba::inArray($r); @@ -773,7 +885,7 @@ class Worker { Lock::remove('poller_worker_process'); if ($found) { - $r = dba::select('workerqueue', array(), array('pid' => getmypid(), 'done' => false)); + $r = dba::select('workerqueue', [], ['pid' => getmypid(), 'done' => false]); return dba::inArray($r); } return false; @@ -781,34 +893,40 @@ class Worker { /** * @brief Removes a workerqueue entry from the current process + * @return void */ - public static function unclaimProcess() { + public static function unclaimProcess() + { $mypid = getmypid(); - dba::update('workerqueue', array('executed' => NULL_DATE, 'pid' => 0), array('pid' => $mypid, 'done' => false)); + dba::update('workerqueue', ['executed' => NULL_DATE, 'pid' => 0], ['pid' => $mypid, 'done' => false]); } /** * @brief Call the front end worker + * @return void */ - public static function callWorker() { + public static function callWorker() + { if (!Config::get("system", "frontend_worker")) { return; } $url = System::baseUrl()."/worker"; - fetch_url($url, false, $redirects, 1); + Network::fetchUrl($url, false, $redirects, 1); } /** * @brief Call the front end worker if there aren't any active + * @return void */ - public static function executeIfIdle() { + public static function executeIfIdle() + { if (!Config::get("system", "frontend_worker")) { return; } - // Do we have "proc_open"? Then we can fork the poller + // Do we have "proc_open"? Then we can fork the worker if (function_exists("proc_open")) { // When was the last time that we called the worker? // Less than one minute? Then we quit @@ -822,14 +940,14 @@ class Worker { if (self::tooMuchWorkers()) { // Cleaning dead processes self::killStaleWorkers(); - get_app()->remove_inactive_processes(); + Process::deleteInactive(); return; } self::runCron(); - logger('Call poller', LOGGER_DEBUG); + logger('Call worker', LOGGER_DEBUG); self::spawnWorker(); return; } @@ -850,37 +968,42 @@ class Worker { /** * @brief Removes long running worker processes + * @return void */ - public static function clearProcesses() { + public static function clearProcesses() + { $timeout = Config::get("system", "frontend_worker_timeout", 10); /// @todo We should clean up the corresponding workerqueue entries as well - $condition = array("`created` < ? AND `command` = 'worker.php'", - datetime_convert('UTC','UTC',"now - ".$timeout." minutes")); + $condition = ["`created` < ? AND `command` = 'worker.php'", + DateTimeFormat::utc("now - ".$timeout." minutes")]; dba::delete('process', $condition); } /** * @brief Runs the cron processes + * @return void */ - private static function runCron() { + private static function runCron() + { logger('Add cron entries', LOGGER_DEBUG); // Check for spooled items - self::add(PRIORITY_HIGH, "spool_post"); + self::add(PRIORITY_HIGH, "SpoolPost"); // Run the cron job that calls all other jobs - self::add(PRIORITY_MEDIUM, "cron"); - - // Run the cronhooks job separately from cron for being able to use a different timing - self::add(PRIORITY_MEDIUM, "cronhooks"); + self::add(PRIORITY_MEDIUM, "Cron"); // Cleaning dead processes self::killStaleWorkers(); } - public static function spawnWorker() { - $args = array("include/poller.php", "no_cron"); + /** + * @return void + */ + public static function spawnWorker() + { + $args = ["bin/worker.php", "no_cron"]; get_app()->proc_run($args); } @@ -890,8 +1013,8 @@ class Worker { * @param (integer|array) priority or parameter array, strings are deprecated and are ignored * * next args are passed as $cmd command line - * or: Worker::add(PRIORITY_HIGH, "notifier", "drop", $drop_id); - * or: Worker::add(array('priority' => PRIORITY_HIGH, 'dont_fork' => true), "create_shadowentry", $post_id); + * or: Worker::add(PRIORITY_HIGH, "Notifier", "drop", $drop_id); + * or: Worker::add(array('priority' => PRIORITY_HIGH, 'dont_fork' => true), "CreateShadowEntry", $post_id); * * @note $cmd and string args are surrounded with "" * @@ -900,43 +1023,26 @@ class Worker { * * @return boolean "false" if proc_run couldn't be executed */ - public static function add($cmd) { - $proc_args = func_get_args(); + public static function add($cmd) + { + $args = func_get_args(); - $args = array(); - if (!count($proc_args)) { + if (!count($args)) { return false; } - // Preserve the first parameter - // It could contain a command, the priority or an parameter array - // If we use the parameter array we have to protect it from the following function - $run_parameter = array_shift($proc_args); + $arr = ['args' => $args, 'run_cmd' => true]; - // expand any arrays - foreach ($proc_args as $arg) { - if (is_array($arg)) { - foreach ($arg as $n) { - $args[] = $n; - } - } else { - $args[] = $arg; - } - } - - // Now we add the run parameters back to the array - array_unshift($args, $run_parameter); - - $arr = array('args' => $args, 'run_cmd' => true); - - call_hooks("proc_run", $arr); + Addon::callHooks("proc_run", $arr); if (!$arr['run_cmd'] || !count($args)) { return true; } $priority = PRIORITY_MEDIUM; $dont_fork = Config::get("system", "worker_dont_fork"); - $created = datetime_convert(); + $created = DateTimeFormat::utcNow(); + + $run_parameter = array_shift($args); if (is_int($run_parameter)) { $priority = $run_parameter; @@ -952,11 +1058,8 @@ class Worker { } } - $argv = $args; - array_shift($argv); - - $parameters = json_encode($argv); - $found = dba::exists('workerqueue', array('parameter' => $parameters, 'done' => false)); + $parameters = json_encode($args); + $found = dba::exists('workerqueue', ['parameter' => $parameters, 'done' => false]); // Quit if there was a database error - a precaution for the update process to 3.5.3 if (dba::errorNo() != 0) { @@ -964,10 +1067,10 @@ class Worker { } if (!$found) { - dba::insert('workerqueue', array('parameter' => $parameters, 'created' => $created, 'priority' => $priority)); + dba::insert('workerqueue', ['parameter' => $parameters, 'created' => $created, 'priority' => $priority]); } - // Should we quit and wait for the poller to be called as a cronjob? + // Should we quit and wait for the worker to be called as a cronjob? if ($dont_fork) { return true; } @@ -985,9 +1088,36 @@ class Worker { return true; } - // Now call the poller to execute the jobs that we just added to the queue + // Now call the worker to execute the jobs that we just added to the queue self::spawnWorker(); return true; } + + /** + * Log active processes into the "process" table + * + * @brief Log active processes into the "process" table + */ + public static function startProcess() + { + $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1); + + $command = basename($trace[0]['file']); + + Process::deleteInactive(); + + Process::insert($command); + } + + /** + * Remove the active process from the "process" table + * + * @brief Remove the active process from the "process" table + * @return bool + */ + public static function endProcess() + { + return Process::deleteByPid(); + } }