kiri-core/function.php

<?php

defined('APP_PATH') or define('APP_PATH', realpath(__DIR__ . '/../../'));


use JetBrains\PhpStorm\Pure;
use Kiri\Abstracts\Kernel;
use Kiri\Application;
use Kiri\Error\StdoutLogger;
use Kiri\Config\ConfigProvider;
use Kiri\Core\ArrayAccess;
use Kiri\Di\Context;
use Kiri\Events\EventDispatch;
use Kiri\Events\EventProvider;
use Kiri\Router\Request;
use Kiri\Router\Response;
use Kiri\Server\Task\TaskExecute;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Swoole\Process;

interface Arrayable
{


	/**
	 * @return array
	 */
	public function toArray(): array;

}


if (!function_exists('json_validate')) {


	/**
	 * @param string $data
	 * @return bool
	 */
	function json_validate(string $data): bool
	{
		return is_array(json_decode($data, true));
	}

}


if (!function_exists('println')) {


	/**
	 * @param string $data
	 * @return bool
	 */
	function println(string $data): void
	{
		$logger = \Kiri::getDi()->get(StdoutLogger::class);
		$logger->println($data);
	}

}


if (!function_exists('application')) {

	/**
	 * @param Kernel $Kernel
	 * @return Application
	 */
	function application(Kernel $Kernel): Application
	{
		$application = Kiri::getDi()->get(Application::class);
		$application->commands($Kernel);
		return $application;
	}

}


if (!function_exists('task')) {
	/**
	 * @param string        $handler
	 * @param mixed         $data
	 * @param int           $dstWorkerId
	 * @param callable|null $finishFinishCallback
	 * @return void
	 * @throws Exception
	 */
	function task(string $handler, mixed $data, int $dstWorkerId = -1, ?callable $finishFinishCallback = null): void
	{
		$execute = Kiri::getDi()->get(TaskExecute::class);
		$execute->task($handler, $data, $dstWorkerId, $finishFinishCallback);
	}
}


if (!function_exists('taskWait')) {
	/**
	 * @param string $handler
	 * @param mixed  $data
	 * @param float  $timeout
	 * @param int    $dstWorkerId
	 * @return mixed
	 * @throws Exception
	 */
	function taskWait(string $handler, mixed $data, float $timeout = 0.5, int $dstWorkerId = -1): mixed
	{
		$execute = Kiri::getDi()->get(TaskExecute::class);
		return $execute->taskWait($handler, $data, $timeout, $dstWorkerId);
	}
}


if (!function_exists('taskCo')) {
	/**
	 * @param array $tasks
	 * @param float $timeout
	 * @return false|array
	 */
	function taskCo(array $tasks, float $timeout = 0.5): false|array
	{
		$execute = Kiri::getDi()->get(TaskExecute::class);
		return $execute->taskCo($tasks, $timeout);
	}
}


if (!function_exists('taskWaitMulti')) {
	/**
	 * @param array $tasks
	 * @param float $timeout
	 * @return false|array
	 */
	function taskWaitMulti(array $tasks, float $timeout = 0.5): false|array
	{
		$execute = Kiri::getDi()->get(TaskExecute::class);
		return $execute->taskWaitMulti($tasks, $timeout);
	}
}

if (!function_exists('make')) {


	/**
	 * @param $name
	 * @param $default
	 * @return mixed
	 * @throws
	 */
	function make($name, $default = NULL): mixed
	{
		if (!class_exists($name) && !interface_exists($name)) {
			return Kiri::getDi()->get($default);
		}
		return Kiri::getDi()->get($name);
	}

}


if (!function_exists('isJson')) {


	function isJson(?string $string): bool
	{
		if (is_null($string))
			return false;
		return (str_starts_with($string, '{') && str_ends_with($string, '}')) || (str_ends_with($string, '[') && str_starts_with($string, ']'));
	}

}

if (!function_exists('instance')) {


	/**
	 * @param       $class
	 * @param array $constrict
	 * @param array $config
	 * @return null|object
	 * @throws
	 */
	function instance($class, array $constrict = [], array $config = []): ?object
	{
		return Kiri::getDi()->make($class, $constrict, $config);
	}


}


if (!function_exists('call')) {


	/**
	 * @param       $handler
	 * @param mixed ...$params
	 * @return mixed
	 * @throws
	 */
	function call($handler, ...$params): mixed
	{
		if (is_array($handler) && is_string($handler[0])) {
			$handler[0] = di($handler[0]);
		}
		if (!is_callable($handler, true)) {
			throw new Exception('Call function not exists.');
		}
		return call_user_func($handler, ...$params);
	}

}

if (!function_exists('checkPortIsAlready')) {


	/**
	 * @param $port
	 * @return bool|string
	 */
	function checkPortIsAlready($port): bool|string
	{
		$port = (int)$port;
		if ($port <= 0) {
			return FALSE;
		}

		if (!Kiri::getPlatform()->isLinux()) {
			exec("lsof -i :" . $port . " | grep -i 'LISTEN' | awk '{print $2}'", $output);
			if (empty($output)) {
				return FALSE;
			}
			$output = explode(PHP_EOL, $output[0]);
			return $output[0];
		}

		exec('netstat -lnp 2>/dev/null | grep :' . $port . ' | grep "LISTEN" | awk \'{print $7}\'', $output);
		if (empty($output)) {
			exec('ss -ltnp 2>/dev/null | grep :' . $port . ' | sed -n \"s/.*pid=\\([0-9]*\\).*/\\1/p\"', $output);
		}
		if (empty($output)) {
			return FALSE;
		}

		$pid = trim((string)$output[0]);
		if (str_contains($pid, '/')) {
			$pid = explode('/', $pid)[0];
		}

		return $pid !== '' ? $pid : FALSE;
	}

}

if (!function_exists('set_env')) {


	/**
	 * @param $key
	 * @param $value
	 */
	function set_env($key, $value): void
	{
		putenv(sprintf('%s=%s', $key, $value));
	}

}

if (!function_exists('enable_file_modification_listening')) {


	function enable_file_modification_listening(): void
	{
		putenv('enable_file_modification_listening=on');
	}


}


if (!function_exists('is_enable_file_modification_listening')) {


	/**
	 * @return bool
	 */
	#[Pure]
	function is_enable_file_modification_listening(): bool
	{
		return env('enable_file_modification_listening', 'off') == 'on';
	}


}

if (!function_exists('disable_file_modification_listening')) {


	function disable_file_modification_listening(): void
	{
		putenv('enable_file_modification_listening=off');
	}


}


if (!function_exists('now')) {

	/**
	 * @return string
	 */
	function now(): string
	{
		return date('Y-m-d H:i:s') . '.' . str_replace(time() . '.', '', (string)microtime(TRUE));
	}
}


if (!function_exists('directory')) {

	/**
	 * @param $name
	 * @return string
	 */
	function directory($name): string
	{
		return realpath(APP_PATH . $name);
	}


}


if (!function_exists('msgpack_pack')) {


	/**
	 * @param $content
	 * @return string
	 */
	function msgpack_pack($content): string
	{
		return serialize($content);
	}

}
if (!function_exists('msgpack_unpack')) {


	/**
	 * @param $content
	 * @return mixed
	 */
	function msgpack_unpack($content): mixed
	{
		return unserialize($content);
	}

}

if (!function_exists('request')) {


	/**
	 * @return Request
	 * @throws
	 */
	function request(): RequestInterface
	{
		$request = Kiri::getDi()->get(RequestInterface::class);

		return Context::get(RequestInterface::class, $request);
	}

}

if (!function_exists('inject')) {


	/**
	 * @param object $object
	 * @return object
	 * @throws
	 */
	function inject(object $object): object
	{
		$container = Kiri::getDi();
		$reflect   = $container->getReflectionClass($object::class);
		$container->resolveProperties($reflect, $object);
		return $object;
	}
}


if (!function_exists('response')) {


	/**
	 * @return Response
	 * @throws
	 */
	function response(): ResponseInterface
	{
		$data = Kiri::getDi()->get(ResponseInterface::class);

		return Context::get(ResponseInterface::class, $data);
	}

}


if (!function_exists('redis')) {


	/**
	 * @return \Kiri\NoSql\Redis|Redis
	 * @throws
	 */
	function redis(): \Kiri\NoSql\Redis|Redis
	{
		return Kiri::getDi()->get(\Kiri\NoSql\Redis::class);
	}
}

if (!function_exists('fire')) {


	/**
	 * @param object $event
	 * @throws
	 */
	function fire(object $event): void
	{
		di(EventDispatch::class)->dispatch($event);
	}
}

if (!function_exists('trim_blank')) {


	/**
	 * 空白字符替换
	 * @param string $content 内容
	 * @param int    $len     截取长度
	 * @param string $encode  编码
	 * @param bool   $htmlTags
	 * @return array|string|null
	 */
	function trim_blank(string $content, int $len = 0, string $encode = 'utf-8', bool $htmlTags = TRUE): array|string|null
	{
		$str = trim($content);
		if ($htmlTags) {
			$str = strip_tags($str);
		}
		$str = preg_replace('/[\n|\r|\t]+/', '', $str);
		$str = preg_replace("/(\s|\&nbsp\;|　|\xc2\xa0)/", '', $str);
		if ($len > 0) {
			return mb_substr($str, 0, $len, $encode);
		} else {
			return $str;
		}
	}
}

if (!function_exists('storage')) {

	/**
	 * @param string|null $fileName
	 * @param string|null $path
	 * @return string
	 * @throws
	 */
	function storage(?string $fileName = '', ?string $path = ''): string
	{
		if (!str_ends_with($path, '/')) {
			$path .= '/';
		}
		$basePath = rtrim(Kiri::getStoragePath(), '/');
		if (!empty($path)) {
			$path = ltrim($path, '/');
			if (!is_dir($basePath . '/' . $path)) {
				mkdir($basePath . '/' . $path, 0777, TRUE);
			}
		}
		if (empty($fileName)) {
			return $basePath . '/' . $path;
		}
		$fileName = $basePath . '/' . $path . $fileName;
		if (!file_exists($fileName)) {
			touch($fileName);
		}
		return $fileName;
	}
}


if (!function_exists('on')) {


	/**
	 * @param     $name
	 * @param     $callback
	 * @param int $index
	 * @throws
	 */
	function on($name, $callback, int $index = 0): void
	{
		$pro = di(EventProvider::class);
		$pro->on($name, $callback, $index);
	}

}


if (!function_exists('off')) {


	/**
	 * @param $name
	 * @param $callback
	 * @throws
	 */
	function off($name, $callback): void
	{
		$pro = di(EventProvider::class);
		$pro->off($name, $callback);
	}

}


if (!function_exists('process_name_set')) {

	/**
	 * @param int         $pid
	 * @param string|null $prefix
	 * @throws
	 */
	function process_name_set(int $pid, ?string $prefix = NULL): void
	{
		if (Kiri::getPlatform()->isMac()) {
			return;
		}

		$name = \config('site.id', 'system') . '[' . $pid . ']';
		if (!empty($prefix)) {
			$name .= '.' . $prefix;
		}
		swoole_set_process_name($name);
	}

}


if (!function_exists('zero_full')) {

	/**
	 * @param int $data
	 * @param int $length
	 * @return string
	 */
	function zero_full(int $data = 1, int $length = 10): string
	{
		return sprintf('%0' . $length . 'd', $data);
	}
}


if (!function_exists('env')) {

	/**
	 * @param      $key
	 * @param null $default
	 * @return array|string|null
	 */
	function env($key, $default = NULL): null|array|string
	{
		$env = getenv($key);
		if ($env === FALSE) {
			return $default;
		}
		return $env;
	}

}


if (!function_exists('config')) {

	/**
	 * @param      $key
	 * @param null $default
	 * @return mixed
	 */
	function config($key, mixed $default = NULL): mixed
	{
		return make(ConfigProvider::class)->get($key, $default);
	}

}


if (!function_exists('created')) {

	/**
	 * @param       $key
	 * @param array $construct
	 * @param array $config
	 * @return null|object
	 * @throws
	 */
	function created($key, array $construct = [], array $config = []): ?object
	{
		return Kiri::getDi()->make($key, $construct, $config);
	}

}


if (!function_exists('di')) {


	/**
	 * @param string|object $className
	 * @return mixed
	 * @throws
	 */
	function di(string|object $className): mixed
	{
		if (is_object($className)) {
			return $className;
		}
		return Kiri::getDi()->get($className);
	}

}


if (!function_exists('sweep')) {

	/**
	 * @param string $configPath
	 * @return array
	 */
	function sweep(string $configPath = APP_PATH . 'config'): array
	{
		$array = [];

		// 检查目录是否存在
		if (!is_dir($configPath)) {
			throw new InvalidArgumentException("Config directory does not exist: {$configPath}");
		}

		// 获取所有PHP配置文件
		$configFiles = glob($configPath . '/*.php');
		foreach ($configFiles as $config) {
			// 使用 pathinfo 更安全地获取文件名
			$filename = pathinfo($config, PATHINFO_FILENAME);
			$key      = strtolower($filename);

			// 验证文件是否可读
			if (!is_readable($config)) {
				throw new RuntimeException("Cannot read config file: {$config}");
			}

			// 使用 include 而不是 require_once，这样不会跳过已加载的文件
			// 在配置加载场景中，通常希望每次都重新加载
			$configData = require_once $config;

			if (!is_array($configData)) {
				continue;
			}

			$array[$key] = $configData;
		}

		return $array;
	}


}


if (!function_exists('merge')) {


	/**
	 * @param $param
	 * @param $param1
	 * @return array
	 */
	function merge($param, $param1): array
	{
		return ArrayAccess::merge($param, $param1);
	}

}

if (!function_exists('event')) {


	/**
	 * @param object $object
	 * @return void
	 * @throws
	 */
	function event(object $object): void
	{
		Kiri::getDi()->get(EventDispatch::class)->dispatch($object);
	}

}


if (!function_exists('throwable')) {


	/**
	 * 错误格式化
	 * @param Throwable|Error|string $throwable
	 * @return string
	 */
	function throwable(\Throwable|\Error|string $throwable): string
	{
		if (is_string($throwable)) {
			return $throwable;
		}
		$message = $throwable::class . ' ' . $throwable->getMessage() . PHP_EOL;
		$message .= '                File: ' . $throwable->getFile() . PHP_EOL;
		$message .= '                Line: ' . $throwable->getLine() . PHP_EOL;

		$file = $throwable->getFile();
		$line = $throwable->getLine();

		$trance  = $throwable->getTrace();
		$current = array_shift($trance);


		if (!isset($current['file'])) {
			$current['file'] = $file;
		}
		if (!isset($current['line'])) {
			$current['line'] = $line;
		}
		$message .= '              Trance: ' . $current['file'] . ' -> ' . (isset($current['class']) ? $current['class'] . '::' : '') . ($current['function'] ?? 'Closure') . ' line ' . $current['line'] . PHP_EOL;

		foreach ($trance as $value) {
			if (!isset($value['file'])) {
				$value['file'] = $file;
			}
			if (!isset($value['line'])) {
				$value['line'] = $line;
			}
			$file = $value['file'];
			$line = $value['line'];

			$message .= '                      ' . $value['file'] . ' -> ' . (isset($value['class']) ? $value['class'] . '::' : '') . ($value['function'] ?? 'Closure') . ' line ' . $line . PHP_EOL;
		}
		return $message;
	}

}

if (!function_exists('json_log')) {

	function json_log(Throwable $throwable, array $data = []): void
	{
		$param              = [];
		$param['time']      = date('Y-m-d H:i:s');
		$param['request']   = [
			'path'    => \request()->getUri()->getPath(),
			'headers' => \request()->getHeaders(),
			'method'  => \request()->getMethod(),
			'params'  => \request()->getBody()->getContents(),
		];
		$param['exception'] = [
			'message' => $throwable->getMessage(),
			'code'    => $throwable->getCode(),
			'file'    => $throwable->getFile(),
			'line'    => $throwable->getLine(),
			'trace'   => $throwable->getTrace(),
		];
		$param['data']      = $data;

		file_put_contents(storage('exception-' . date('Y-m-d') . '.log', 'exception'), json_encode($param, JSON_UNESCAPED_UNICODE) . PHP_EOL, FILE_APPEND);
	}
}


if (!function_exists('map')) {

	/**
	 * @param array   $map
	 * @param Closure $closure
	 * @return void
	 */
	function map(array $map, Closure $closure): void
	{
		foreach ($map as $key => $value) {
			$closure($key, $value);
		}
	}
}