X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FCore%2FSystem.php;h=10fc5c7d4e335e6cdc725affb1672f93c572ea8d;hb=f6167b4cfd36ca4d7a44d501509627ca8989f6b1;hp=709864492e0c8268a04d41d051f8968b81808d84;hpb=75c74e856290a712344ad6b4042ef07ef661d584;p=friendica.git diff --git a/src/Core/System.php b/src/Core/System.php index 709864492e..10fc5c7d4e 100644 --- a/src/Core/System.php +++ b/src/Core/System.php @@ -1,53 +1,261 @@ . + * */ + namespace Friendica\Core; +use Friendica\Core\Config\Capability\IManageConfigValues; use Friendica\DI; -use Friendica\Network\HTTPException\InternalServerErrorException; +use Friendica\Module\Response; +use Friendica\Network\HTTPException\FoundException; +use Friendica\Network\HTTPException\MovedPermanentlyException; +use Friendica\Network\HTTPException\TemporaryRedirectException; +use Friendica\Util\BasePath; use Friendica\Util\XML; +use Psr\Log\LoggerInterface; /** - * @file include/Core/System.php - * - * @brief Contains the class with system relevant stuff - */ - - -/** - * @brief System methods + * Contains the class with system relevant stuff */ class System { /** - * @brief Returns a string with a callstack. Can be used for logging. - * @param integer $depth optional, default 4 + * @var LoggerInterface + */ + private $logger; + + /** + * @var IManageConfigValues + */ + private $config; + + /** + * @var string + */ + private $basePath; + + public function __construct(LoggerInterface $logger, IManageConfigValues $config, string $basepath) + { + $this->logger = $logger; + $this->config = $config; + $this->basePath = $basepath; + } + + /** + * Checks if the maximum number of database processes is reached + * + * @return bool Is the limit reached? + */ + public function isMaxProcessesReached(): bool + { + // Deactivated, needs more investigating if this check really makes sense + return false; + + /* + * Commented out to suppress static analyzer issues + * + if ($this->mode->isBackend()) { + $process = 'backend'; + $max_processes = $this->config->get('system', 'max_processes_backend'); + if (intval($max_processes) == 0) { + $max_processes = 5; + } + } else { + $process = 'frontend'; + $max_processes = $this->config->get('system', 'max_processes_frontend'); + if (intval($max_processes) == 0) { + $max_processes = 20; + } + } + + $processlist = DBA::processlist(); + if ($processlist['list'] != '') { + $this->logger->debug('Processcheck: Processes: ' . $processlist['amount'] . ' - Processlist: ' . $processlist['list']); + + if ($processlist['amount'] > $max_processes) { + $this->logger->debug('Processcheck: Maximum number of processes for ' . $process . ' tasks (' . $max_processes . ') reached.'); + return true; + } + } + return false; + */ + } + + /** + * Checks if the minimal memory is reached + * + * @return bool Is the memory limit reached? + */ + public function isMinMemoryReached(): bool + { + // Deactivated, needs more investigating if this check really makes sense + return false; + + /* + * Commented out to suppress static analyzer issues + * + $min_memory = $this->config->get('system', 'min_memory', 0); + if ($min_memory == 0) { + return false; + } + + if (!is_readable('/proc/meminfo')) { + return false; + } + + $memdata = explode("\n", file_get_contents('/proc/meminfo')); + + $meminfo = []; + foreach ($memdata as $line) { + $data = explode(':', $line); + if (count($data) != 2) { + continue; + } + [$key, $val] = $data; + $meminfo[$key] = (int)trim(str_replace('kB', '', $val)); + $meminfo[$key] = (int)($meminfo[$key] / 1024); + } + + if (!isset($meminfo['MemFree'])) { + return false; + } + + $free = $meminfo['MemFree']; + + $reached = ($free < $min_memory); + + if ($reached) { + $this->logger->warning('Minimal memory reached.', ['free' => $free, 'memtotal' => $meminfo['MemTotal'], 'limit' => $min_memory]); + } + + return $reached; + */ + } + + /** + * Checks if the maximum load is reached + * + * @return bool Is the load reached? + */ + public function isMaxLoadReached(): bool + { + $maxsysload = intval($this->config->get('system', 'maxloadavg')); + if ($maxsysload < 1) { + $maxsysload = 50; + } + + $load = System::currentLoad(); + if ($load) { + if (intval($load) > $maxsysload) { + $this->logger->warning('system load for process too high.', ['load' => $load, 'process' => 'backend', 'maxsysload' => $maxsysload]); + return true; + } + } + return false; + } + + /** + * Executes a child process with 'proc_open' + * + * @param string $command The command to execute + * @param array $args Arguments to pass to the command ( [ 'key' => value, 'key2' => value2, ... ] + */ + public function run(string $command, array $args) + { + if (!function_exists('proc_open')) { + $this->logger->warning('"proc_open" not available - quitting'); + return; + } + + $cmdline = $this->config->get('config', 'php_path', 'php') . ' ' . escapeshellarg($command); + + foreach ($args as $key => $value) { + if (!is_null($value) && is_bool($value) && !$value) { + continue; + } + + $cmdline .= ' --' . $key; + if (!is_null($value) && !is_bool($value)) { + $cmdline .= ' ' . $value; + } + } + + if ($this->isMinMemoryReached()) { + $this->logger->warning('Memory limit reached - quitting'); + return; + } + + if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') { + $resource = proc_open('cmd /c start /b ' . $cmdline, [], $foo, $this->basePath); + } else { + $resource = proc_open($cmdline . ' &', [], $foo, $this->basePath); + } + + if (!is_resource($resource)) { + $this->logger->warning('We got no resource for command.', ['command' => $cmdline]); + return; + } + + proc_close($resource); + + $this->logger->info('Executed "proc_open"', ['command' => $cmdline, 'callstack' => System::callstack(10)]); + } + + /** + * Returns a string with a callstack. Can be used for logging. + * + * @param integer $depth How many calls to include in the stacks after filtering + * @param int $offset How many calls to shave off the top of the stack, for example if + * this is called from a centralized method that isn't relevant to the callstack * @return string */ - public static function callstack($depth = 4) + public static function callstack(int $depth = 4, int $offset = 0): string { $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS); - // We remove the first two items from the list since they contain data that we don't need. - array_shift($trace); - array_shift($trace); + // We remove at least the first two items from the list since they contain data that we don't need. + $trace = array_slice($trace, 2 + $offset); $callstack = []; - $previous = ['class' => '', 'function' => '']; + $previous = ['class' => '', 'function' => '', 'database' => false]; // The ignore list contains all functions that are only wrapper functions - $ignore = ['fetchUrl', 'call_user_func_array']; + $ignore = ['call_user_func_array']; while ($func = array_pop($trace)) { if (!empty($func['class'])) { - // Don't show multiple calls from the "dba" class to show the essential parts of the callstack - if ((($previous['class'] != $func['class']) || ($func['class'] != 'Friendica\Database\DBA')) && ($previous['function'] != 'q')) { + if (in_array($previous['function'], ['insert', 'fetch', 'toArray', 'exists', 'count', 'selectFirst', 'selectToArray', + 'select', 'update', 'delete', 'selectFirstForUser', 'selectForUser']) + && (substr($previous['class'], 0, 15) === 'Friendica\Model')) { + continue; + } + + // Don't show multiple calls from the Database classes to show the essential parts of the callstack + $func['database'] = in_array($func['class'], ['Friendica\Database\DBA', 'Friendica\Database\Database']); + if (!$previous['database'] || !$func['database']) { $classparts = explode("\\", $func['class']); $callstack[] = array_pop($classparts).'::'.$func['function']; $previous = $func; } } elseif (!in_array($func['function'], $ignore)) { + $func['database'] = ($func['function'] == 'q'); $callstack[] = $func['function']; $func['class'] = ''; $previous = $func; @@ -80,55 +288,88 @@ class System } if ($st) { - Logger::log('xml_status returning non_zero: ' . $st . " message=" . $message); + Logger::notice('xml_status returning non_zero: ' . $st . " message=" . $message); } - header("Content-type: text/xml"); - - $xmldata = ["result" => $result]; - - echo XML::fromArray($xmldata, $xml); + DI::apiResponse()->setType(Response::TYPE_XML); + DI::apiResponse()->addContent(XML::fromArray(["result" => $result], $xml)); + DI::page()->exit(DI::apiResponse()->generate()); - exit(); + self::exit(); } /** - * @brief Send HTTP status header and exit. + * Send HTTP status header and exit. * * @param integer $val HTTP status result value * @param string $message Error message. Optional. * @param string $content Response body. Optional. * @throws \Exception */ - public static function httpExit($val, $message = '', $content = '') + public static function httpError($httpCode, $message = '', $content = '') { - Logger::log('http_status_exit ' . $val); - header($_SERVER["SERVER_PROTOCOL"] . ' ' . $val . ' ' . $message); + if ($httpCode >= 400) { + Logger::debug('Exit with error', ['code' => $httpCode, 'message' => $message, 'callstack' => System::callstack(20), 'method' => DI::args()->getMethod(), 'agent' => $_SERVER['HTTP_USER_AGENT'] ?? '']); + } + DI::apiResponse()->setStatus($httpCode, $message); + DI::apiResponse()->addContent($content); + DI::page()->exit(DI::apiResponse()->generate()); - echo $content; + self::exit(); + } - exit(); + /** + * This function adds the content and a content-teype HTTP header to the output. + * After finishing the process is getting killed. + * + * @param string $content + * @param [type] $responce + * @param string|null $content_type + * @return void + */ + public static function httpExit(string $content, string $responce = Response::TYPE_HTML, ?string $content_type = null) { + DI::apiResponse()->setType($responce, $content_type); + DI::apiResponse()->addContent($content); + DI::page()->exit(DI::apiResponse()->generate()); + + self::exit(); } - public static function jsonError($httpCode, $data, $content_type = 'application/json') + public static function jsonError($httpCode, $content, $content_type = 'application/json') { - header($_SERVER["SERVER_PROTOCOL"] . ' ' . $httpCode); - self::jsonExit($data, $content_type); + if ($httpCode >= 400) { + Logger::debug('Exit with error', ['code' => $httpCode, 'content_type' => $content_type, 'callstack' => System::callstack(20), 'method' => DI::args()->getMethod(), 'agent' => $_SERVER['HTTP_USER_AGENT'] ?? '']); + } + DI::apiResponse()->setStatus($httpCode); + self::jsonExit($content, $content_type); } /** - * @brief Encodes content to json. + * Encodes content to json. * * This function encodes an array to json format * and adds an application/json HTTP header to the output. * After finishing the process is getting killed. * - * @param mixed $x The input content. - * @param string $content_type Type of the input (Default: 'application/json'). + * @param mixed $content The input content + * @param string $content_type Type of the input (Default: 'application/json') + * @param integer $options JSON options + * @throws \Friendica\Network\HTTPException\InternalServerErrorException */ - public static function jsonExit($x, $content_type = 'application/json') { - header("Content-type: $content_type"); - echo json_encode($x); + public static function jsonExit($content, $content_type = 'application/json', int $options = JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT) { + DI::apiResponse()->setType(Response::TYPE_JSON, $content_type); + DI::apiResponse()->addContent(json_encode($content, $options)); + DI::page()->exit(DI::apiResponse()->generate()); + + self::exit(); + } + + /** + * Exit the program execution. + */ + public static function exit() + { + DI::page()->logRuntime(); exit(); } @@ -200,34 +441,29 @@ class System * * @param string $url The new Location to redirect * @param int $code The redirection code, which is used (Default is 302) - * - * @throws InternalServerErrorException If the URL is not fully qualified */ public static function externalRedirect($url, $code = 302) { if (empty(parse_url($url, PHP_URL_SCHEME))) { - throw new InternalServerErrorException("'$url' is not a fully qualified URL, please use App->internalRedirect() instead"); + Logger::warning('No fully qualified URL provided', ['url' => $url, 'callstack' => self::callstack(20)]); + DI::baseUrl()->redirect($url); } + header("Location: $url"); + switch ($code) { case 302: - // this is the default code for a REDIRECT - // We don't need a extra header here - break; + throw new FoundException(); case 301: - header('HTTP/1.1 301 Moved Permanently'); - break; + throw new MovedPermanentlyException(); case 307: - header('HTTP/1.1 307 Temporary Redirect'); - break; + throw new TemporaryRedirectException(); } - - header("Location: $url"); - exit(); + self::exit(); } /** - * @brief Returns the system user that is executing the script + * Returns the system user that is executing the script * * This mostly returns something like "www-data". * @@ -244,7 +480,7 @@ class System } /** - * @brief Checks if a given directory is usable for the system + * Checks if a given directory is usable for the system * * @param $directory * @param bool $check_writable @@ -254,46 +490,130 @@ class System public static function isDirectoryUsable($directory, $check_writable = true) { if ($directory == '') { - Logger::log('Directory is empty. This shouldn\'t happen.', Logger::DEBUG); + Logger::info('Directory is empty. This shouldn\'t happen.'); return false; } if (!file_exists($directory)) { - Logger::log('Path "' . $directory . '" does not exist for user ' . static::getUser(), Logger::DEBUG); + Logger::info('Path "' . $directory . '" does not exist for user ' . static::getUser()); return false; } if (is_file($directory)) { - Logger::log('Path "' . $directory . '" is a file for user ' . static::getUser(), Logger::DEBUG); + Logger::info('Path "' . $directory . '" is a file for user ' . static::getUser()); return false; } if (!is_dir($directory)) { - Logger::log('Path "' . $directory . '" is not a directory for user ' . static::getUser(), Logger::DEBUG); + Logger::info('Path "' . $directory . '" is not a directory for user ' . static::getUser()); return false; } if ($check_writable && !is_writable($directory)) { - Logger::log('Path "' . $directory . '" is not writable for user ' . static::getUser(), Logger::DEBUG); + Logger::info('Path "' . $directory . '" is not writable for user ' . static::getUser()); return false; } return true; } - /// @todo Move the following functions from boot.php - /* - function killme() - function local_user() - function public_contact() - function remote_user() - function notice($s) - function info($s) - function is_site_admin() - function get_server() - function get_temppath() - function get_cachefile($file, $writemode = true) - function get_itemcachepath() - function get_spoolpath() - */ + /** + * Exit method used by asynchronous update modules + * + * @param string $o + */ + public static function htmlUpdateExit($o) + { + DI::apiResponse()->setType(Response::TYPE_HTML); + echo "\r\n"; + // We can remove this hack once Internet Explorer recognises HTML5 natively + echo "
"; + // reportedly some versions of MSIE don't handle tabs in XMLHttpRequest documents very well + echo str_replace("\t", " ", $o); + echo "
"; + echo "\r\n"; + self::exit(); + } + + /** + * Fetch the temp path of the system + * + * @return string Path for temp files + */ + public static function getTempPath() + { + $temppath = DI::config()->get("system", "temppath"); + + if (($temppath != "") && System::isDirectoryUsable($temppath)) { + // We have a temp path and it is usable + return BasePath::getRealPath($temppath); + } + + // We don't have a working preconfigured temp path, so we take the system path. + $temppath = sys_get_temp_dir(); + + // Check if it is usable + if (($temppath != "") && System::isDirectoryUsable($temppath)) { + // Always store the real path, not the path through symlinks + $temppath = BasePath::getRealPath($temppath); + + // To avoid any interferences with other systems we create our own directory + $new_temppath = $temppath . "/" . DI::baseUrl()->getHostname(); + if (!is_dir($new_temppath)) { + /// @TODO There is a mkdir()+chmod() upwards, maybe generalize this (+ configurable) into a function/method? + mkdir($new_temppath); + } + + if (System::isDirectoryUsable($new_temppath)) { + // The new path is usable, we are happy + DI::config()->set("system", "temppath", $new_temppath); + return $new_temppath; + } else { + // We can't create a subdirectory, strange. + // But the directory seems to work, so we use it but don't store it. + return $temppath; + } + } + + // Reaching this point means that the operating system is configured badly. + return ''; + } + + /** + * Returns the path where spool files are stored + * + * @return string Spool path + */ + public static function getSpoolPath() + { + $spoolpath = DI::config()->get('system', 'spoolpath'); + if (($spoolpath != "") && System::isDirectoryUsable($spoolpath)) { + // We have a spool path and it is usable + return $spoolpath; + } + + // We don't have a working preconfigured spool path, so we take the temp path. + $temppath = self::getTempPath(); + + if ($temppath != "") { + // To avoid any interferences with other systems we create our own directory + $spoolpath = $temppath . "/spool"; + if (!is_dir($spoolpath)) { + mkdir($spoolpath); + } + + if (System::isDirectoryUsable($spoolpath)) { + // The new path is usable, we are happy + DI::config()->set("system", "spoolpath", $spoolpath); + return $spoolpath; + } else { + // We can't create a subdirectory, strange. + // But the directory seems to work, so we use it but don't store it. + return $temppath; + } + } + + // Reaching this point means that the operating system is configured badly. + return ""; + } }