*/
namespace Friendica\Core;
-use Friendica\Core\Addon;
-use Friendica\Core\Config;
-use Friendica\Core\System;
+use dba;
use Friendica\Database\DBM;
use Friendica\Model\Process;
use Friendica\Util\DateTimeFormat;
-use Friendica\Util\Lock;
use Friendica\Util\Network;
-use dba;
require_once 'include/dba.php';
self::startProcess();
// Kill stale processes every 5 minutes
- $last_cleanup = Config::get('system', 'poller_last_cleaned', 0);
+ $last_cleanup = Config::get('system', 'worker_last_cleaned', 0);
if (time() > ($last_cleanup + 300)) {
- Config::set('system', 'poller_last_cleaned', time());
+ Config::set('system', 'worker_last_cleaned', time());
self::killStaleWorkers();
}
}
// If possible we will fetch new jobs for this worker
- if (!$refetched && Lock::set('poller_worker_process', 0)) {
+ if (!$refetched && Lock::acquire('worker_process', 0)) {
$stamp = (float)microtime(true);
$refetched = self::findWorkerProcesses($passing_slow);
self::$db_duration += (microtime(true) - $stamp);
- Lock::remove('poller_worker_process');
+ Lock::release('worker_process');
}
}
// To avoid the quitting of multiple workers only one worker at a time will execute the check
- if (Lock::set('poller_worker', 0)) {
+ if (Lock::acquire('worker', 0)) {
$stamp = (float)microtime(true);
// Count active workers and compare them with a maximum value that depends on the load
if (self::tooMuchWorkers()) {
logger('Memory limit reached, quitting.', LOGGER_DEBUG);
return;
}
- Lock::remove('poller_worker');
+ Lock::release('worker');
self::$db_duration += (microtime(true) - $stamp);
}
return;
}
}
- logger("Couldn't select a workerqueue entry, quitting.", LOGGER_DEBUG);
+
+ // Cleaning up. Possibly not needed, but it doesn't harm anything.
+ if (Config::get('system', 'worker_daemon_mode', false)) {
+ self::IPCSetJobState(false);
+ }
+ logger("Couldn't select a workerqueue entry, quitting process " . getmypid() . ".", LOGGER_DEBUG);
}
/**
*/
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"];
- } else {
- return 0;
- }
+ return dba::count('workerqueue', ["`executed` <= ? AND NOT `done`", NULL_DATE]);
}
/**
$stamp = (float)microtime(true);
if (dba::update('workerqueue', ['done' => true], ['id' => $queue["id"]])) {
- Config::set('system', 'last_poller_execution', DateTimeFormat::utcNow());
+ Config::set('system', 'last_worker_execution', DateTimeFormat::utcNow());
}
self::$db_duration = (microtime(true) - $stamp);
$stamp = (float)microtime(true);
if (dba::update('workerqueue', ['done' => true], ['id' => $queue["id"]])) {
- Config::set('system', 'last_poller_execution', DateTimeFormat::utcNow());
+ Config::set('system', 'last_worker_execution', DateTimeFormat::utcNow());
}
self::$db_duration = (microtime(true) - $stamp);
} else {
$argc = count($argv);
- $new_process_id = uniqid("wrk", true);
+ $new_process_id = System::processID("wrk");
logger("Process ".$mypid." - Prio ".$queue["priority"]." - ID ".$queue["id"].": ".$funcname." ".$queue["parameter"]." - Process PID: ".$new_process_id);
if ($load) {
$maxsysload = intval(Config::get("system", "maxloadavg", 50));
- $maxworkers = $queues;
+ /* Default exponent 3 causes queues to rapidly decrease as load increases.
+ * If you have 20 max queues at idle, then you get only 5 queues at 37.1% of $maxsysload.
+ * For some environments, this rapid decrease is not needed.
+ * With exponent 1, you could have 20 max queues at idle and 13 at 37% of $maxsysload.
+ */
+ $exponent = intval(Config::get('system', 'worker_load_exponent', 3));
+ $slope = pow(max(0, $maxsysload - $load) / $maxsysload, $exponent);
+ $queues = intval(ceil($slope * $maxqueues));
- // Some magical mathemathics to reduce the workers
- $exponent = 3;
- $slope = $maxworkers / pow($maxsysload, $exponent);
- $queues = ceil($slope * pow(max(0, $maxsysload - $load), $exponent));
$processlist = '';
if (Config::get('system', 'worker_debug')) {
logger("Load: ".$load."/".$maxsysload." - processes: ".$active."/".$entries.$processlist." - maximum: ".$queues."/".$maxqueues, LOGGER_DEBUG);
// Are there fewer workers running as possible? Then fork a new one.
- if (!Config::get("system", "worker_dont_fork") && ($queues > ($active + 1)) && ($entries > 1)) {
+ if (!Config::get("system", "worker_dont_fork", false) && ($queues > ($active + 1)) && ($entries > 1)) {
logger("Active workers: ".$active."/".$queues." Fork a new worker.", LOGGER_DEBUG);
- self::spawnWorker();
+ if (Config::get('system', 'worker_daemon_mode', false)) {
+ self::IPCSetJobState(true);
+ } else {
+ self::spawnWorker();
+ }
}
}
- return $active >= $queues;
+ // if there are too much worker, we don't spawn a new one.
+ if (Config::get('system', 'worker_daemon_mode', false) && ($active > $queues)) {
+ self::IPCSetJobState(false);
+ }
+
+ return $active > $queues;
}
/**
*/
private static function activeWorkers()
{
- $workers = dba::fetch_first("SELECT COUNT(*) AS `processes` FROM `process` WHERE `command` = 'Worker.php'");
-
- return $workers["processes"];
+ return dba::count('process', ['command' => 'Worker.php']);
}
/**
dba::close($r);
$stamp = (float)microtime(true);
- if (!Lock::set('poller_worker_process')) {
+ if (!Lock::acquire('worker_process')) {
return false;
}
self::$lock_duration = (microtime(true) - $stamp);
$found = self::findWorkerProcesses($passing_slow);
self::$db_duration += (microtime(true) - $stamp);
- Lock::remove('poller_worker_process');
+ Lock::release('worker_process');
if ($found) {
$r = dba::select('workerqueue', [], ['pid' => getmypid(), 'done' => false]);
self::clearProcesses();
- $workers = dba::fetch_first("SELECT COUNT(*) AS `processes` FROM `process` WHERE `command` = 'worker.php'");
+ $workers = self::activeWorkers();
- if ($workers["processes"] == 0) {
+ if ($workers == 0) {
self::callWorker();
}
}
}
/**
+ * @brief Spawns a new worker
* @return void
*/
- public static function spawnWorker()
+ public static function spawnWorker($do_cron = false)
{
- $args = ["bin/worker.php", "no_cron"];
+ $args = ["bin/worker.php"];
+
+ if (!$do_cron) {
+ $args[] = "no_cron";
+ }
+
get_app()->proc_run($args);
+
+ // after spawning we have to remove the flag.
+ if (Config::get('system', 'worker_daemon_mode', false)) {
+ self::IPCSetJobState(false);
+ }
}
/**
}
$priority = PRIORITY_MEDIUM;
- $dont_fork = Config::get("system", "worker_dont_fork");
+ $dont_fork = Config::get("system", "worker_dont_fork", false);
$created = DateTimeFormat::utcNow();
$run_parameter = array_shift($args);
}
// If there is a lock then we don't have to check for too much worker
- if (!Lock::set('poller_worker', 0)) {
+ if (!Lock::acquire('worker', 0)) {
return true;
}
// If there are already enough workers running, don't fork another one
$quit = self::tooMuchWorkers();
- Lock::remove('poller_worker');
+ Lock::release('worker');
if ($quit) {
return true;
}
+ // We tell the daemon that a new job entry exists
+ if (Config::get('system', 'worker_daemon_mode', false)) {
+ // We don't have to set the IPC flag - this is done in "tooMuchWorkers"
+ return true;
+ }
+
// Now call the worker to execute the jobs that we just added to the queue
self::spawnWorker();
{
return Process::deleteByPid();
}
+
+ /**
+ * Set the flag if some job is waiting
+ *
+ * @brief Set the flag if some job is waiting
+ * @param boolean $jobs Is there a waiting job?
+ */
+ public static function IPCSetJobState($jobs)
+ {
+ dba::update('worker-ipc', ['jobs' => $jobs], ['key' => 1], true);
+ }
+
+ /**
+ * Checks if some worker job waits to be executed
+ *
+ * @brief Checks if some worker job waits to be executed
+ * @return bool
+ */
+ public static function IPCJobsExists()
+ {
+ $row = dba::selectFirst('worker-ipc', ['jobs'], ['key' => 1]);
+
+ // When we don't have a row, no job is running
+ if (!DBM::is_result($row)) {
+ return false;
+ }
+
+ return (bool)$row['jobs'];
+ }
}
projects / friendica.git / blobdiff