改名

kiri-engine/Cache/Base/Redis.php

@@ -0,0 +1,161 @@
+<?php
+
+namespace Kiri\Cache\Base;
+
+use Http\Handler\Context;
+use Kiri\Abstracts\Logger;
+use Kiri\Events\EventProvider;
+use Kiri\Exception\RedisConnectException;
+use Kiri\Kiri;
+use Kiri\Pool\StopHeartbeatCheck;
+use RedisException;
+use Server\Events\OnWorkerExit;
+use Swoole\Timer;
+
+
+/**
+ *
+ */
+class Redis implements StopHeartbeatCheck
+{
+
+	const DB_ERROR_MESSAGE = 'The system is busy, please try again later.';
+
+
+	private ?\Redis $pdo = null;
+
+
+	private int $_transaction = 0;
+
+
+	/**
+	 * @var EventProvider
+	 */
+	private EventProvider $eventProvider;
+
+	private int $_timer = -1;
+
+	private int $_last = 0;
+
+
+	/**
+	 * @param string $host
+	 * @param int $port
+	 * @param int $database
+	 * @param string $auth
+	 * @param string $prefix
+	 * @param int $timeout
+	 * @param int $read_timeout
+	 */
+	public function __construct(public string $host, public int $port, public int $database = 0,
+	                            public string $auth = '', public string $prefix = '', public int $timeout = 30,
+	                            public int    $read_timeout = 30)
+	{
+		$this->eventProvider = Kiri::getDi()->get(EventProvider::class);
+	}
+
+
+	public function init()
+	{
+		$this->heartbeat_check();
+		$this->eventProvider->on(OnWorkerExit::class, [$this, 'stopHeartbeatCheck']);
+	}
+
+
+	/**
+	 *
+	 */
+	public function heartbeat_check(): void
+	{
+		if (env('state', 'start') == 'exit') {
+			return;
+		}
+		if ($this->_timer === -1 && Context::inCoroutine()) {
+			$this->_timer = Timer::tick(1000, function () {
+				try {
+					if (env('state', 'start') == 'exit') {
+						Kiri::getDi()->get(Logger::class)->critical('timer end');
+						$this->stopHeartbeatCheck();
+					}
+					if (time() - $this->_last > 10 * 60) {
+						$this->stopHeartbeatCheck();
+						$this->pdo = null;
+					}
+				} catch (\Throwable $throwable) {
+					error($throwable);
+				}
+			});
+		}
+	}
+
+
+	/**
+	 *
+	 */
+	public function stopHeartbeatCheck(): void
+	{
+		if ($this->_timer > -1) {
+			Timer::clear($this->_timer);
+		}
+		$this->_timer = -1;
+	}
+
+
+	/**
+	 * @param string $name
+	 * @param array $arguments
+	 * @return mixed
+	 * @throws RedisConnectException|RedisException
+	 */
+	public function __call(string $name, array $arguments)
+	{
+		if (!method_exists($this, $name)) {
+			return $this->_pdo()->{$name}(...$arguments);
+		}
+		return $this->{$name}(...$arguments);
+	}
+
+
+	/**
+	 * @return \Redis
+	 * @throws RedisConnectException
+	 * @throws RedisException
+	 */
+	public function _pdo(): \Redis
+	{
+		if ($this->_timer === -1) {
+			$this->heartbeat_check();
+		}
+		if (!($this->pdo instanceof \Redis) || !$this->pdo->ping('isOk')) {
+			$this->pdo = $this->newClient();
+		}
+		return $this->pdo;
+	}
+
+
+	/**
+	 * @return \Redis
+	 * @throws RedisConnectException
+	 */
+	private function newClient(): \Redis
+	{
+		$redis = new \Redis();
+		if (!$redis->connect($this->host, $this->port, $this->timeout)) {
+			throw new RedisConnectException(sprintf('The Redis Connect %s::%d Fail.', $this->host, $this->port));
+		}
+		if (!empty($this->auth) && !$redis->auth($this->auth)) {
+			throw new RedisConnectException(sprintf('Redis Error: %s, Host %s, Auth %s', $redis->getLastError(), $this->host, $this->auth));
+		}
+		if ($this->read_timeout < 0) {
+			$this->read_timeout = 0;
+		}
+		$redis->select($this->database);
+		if ($this->read_timeout > 0) {
+			$redis->setOption(\Redis::OPT_READ_TIMEOUT, $this->read_timeout);
+		}
+		$redis->setOption(\Redis::OPT_PREFIX, $this->prefix);
+		return $redis;
+
+	}
+
+}

kiri-engine/Cache/File.php

@@ -0,0 +1,143 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/5/2 0002
+ * Time: 14:51
+ */
+declare(strict_types=1);
+
+namespace Kiri\Cache;
+
+
+use Exception;
+
+use JetBrains\PhpStorm\Pure;
+use Kiri\Abstracts\Component;
+use Swoole\Coroutine\System;
+
+/**
+ * Class File
+ * @package Kiri\Kiri\Cache
+ */
+class File extends Component implements ICache
+{
+	public string $path;
+
+	/**
+	 * @param $key
+	 * @param $val
+	 * @return string|int
+	 */
+	public function set($key, $val): string|int
+	{
+		if (is_array($val) || is_object($val)) {
+			$val = swoole_serialize($val);
+		}
+		$tmpFile = $this->getCacheKey($key);
+		if (!$this->exists($tmpFile)) {
+			touch($tmpFile);
+		}
+		return System::writeFile($tmpFile, $val, LOCK_EX);
+	}
+
+	/**
+	 * @param $key
+	 * @param array $hashKeys
+	 * @return array|bool
+	 */
+	public function hMGet($key, array $hashKeys): array|bool
+	{
+		$hash = $this->get($key);
+		if (!is_array($hash)) {
+			return false;
+		}
+
+		$nowHash = [];
+		foreach ($hashKeys as $hashKey) {
+			$nowHash[$hashKey] = $hash[$hashKey] ?? null;
+		}
+		return $nowHash;
+	}
+
+	/**
+	 * @param $key
+	 * @param array $val
+	 * @return bool|int|string
+	 */
+	public function hMSet($key, array $val): bool|int|string
+	{
+		$hash = $this->get($key);
+		if (!is_array($hash)) {
+			return false;
+		}
+
+		$merge = array_merge($hash, $val);
+		return $this->set($key, $merge);
+	}
+
+	/**
+	 * @param string $key
+	 * @param string $hashKey
+	 * @return string|int|bool
+	 */
+	public function hGet(string $key, string $hashKey): string|int|bool
+	{
+		$hash = $this->get($key);
+		if (!is_array($hash)) {
+			return false;
+		}
+		return $hash[$hashKey] ?? false;
+	}
+
+	/**
+	 * @param $key
+	 * @param $hashKey
+	 * @param $hashValue
+	 * @return bool|int|string
+	 */
+	public function hSet($key, $hashKey, $hashValue): bool|int|string
+	{
+		$hash = $this->get($key);
+		if (!is_array($hash)) {
+			return false;
+		}
+
+		$hash[$hashKey] = $hashValue;
+
+		return $this->set($key, $hash);
+	}
+
+	/**
+	 * @param $key
+	 * @return bool
+	 */
+	#[Pure] public function exists($key): bool
+	{
+		return file_exists($key);
+	}
+
+	/**
+	 * @param $key
+	 * @return mixed|bool
+	 */
+	public function get($key): string|bool
+	{
+		$tmpFile = $this->getCacheKey($key);
+		if (!$this->exists($tmpFile)) {
+			return false;
+		}
+		$content = file_get_contents($tmpFile);
+		return swoole_unserialize($content);
+	}
+
+	/**
+	 * @param $key
+	 * @return string
+	 * @throws
+	 */
+	private function getCacheKey($key): string
+	{
+		return storage($key, 'cache');
+	}
+}

kiri-engine/Cache/ICache.php

@@ -0,0 +1,65 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/11/8 0008
+ * Time: 16:35
+ */
+declare(strict_types=1);
+
+namespace Kiri\Cache;
+
+/**
+ * Interface ICache
+ * @package Kiri\Kiri\Cache
+ */
+interface ICache
+{
+	/**
+	 * @param $key
+	 * @param $val
+	 * @return string|int
+	 */
+	public function set($key, $val): string|int;
+
+	/**
+	 * @param $key
+	 * @return string|int|bool
+	 */
+	public function get($key): string|int|bool;
+
+	/**
+	 * @param $key
+	 * @param array $hashKeys
+	 * @return array|bool|null
+	 */
+	public function hMGet($key, array $hashKeys): array|bool|null;
+
+	/**
+	 * @param $key
+	 * @param array $val
+	 * @return mixed
+	 */
+	public function hMSet($key, array $val): mixed;
+
+	/**
+	 * @param string $key
+	 * @param string $hashKey
+	 * @return string|int|bool
+	 */
+	public function hGet(string $key, string $hashKey): string|int|bool;
+
+	/**
+	 * @param $key
+	 * @param $hashKey
+	 * @param $hashValue
+	 * @return mixed
+	 */
+	public function hSet($key, $hashKey, $hashValue): mixed;
+
+	/**
+	 * @param $key
+	 * @return bool
+	 */
+	public function exists($key): bool;
+}

kiri-engine/Cache/Redis.php

@@ -0,0 +1,157 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: whwyy
+ * Date: 2018/4/27 0027
+ * Time: 11:00
+ */
+declare(strict_types=1);
+
+namespace Kiri\Cache;
+
+use Annotation\Inject;
+use Exception;
+use Server\Events\OnWorkerExit;
+use Server\Events\OnWorkerStop;
+use Kiri\Abstracts\Component;
+use Kiri\Abstracts\Config;
+use Kiri\Core\Json;
+use Kiri\Events\EventProvider;
+use Kiri\Exception\ConfigException;
+use Kiri\Kiri;
+use Kiri\Pool\Redis as PoolRedis;
+
+/**
+ * Class Redis
+ * @package Kiri\Kiri\Cache
+ * @mixin \Redis
+ */
+class Redis extends Component
+{
+
+	/**
+	 * @var EventProvider
+	 */
+	#[Inject(EventProvider::class)]
+	public EventProvider $eventProvider;
+
+
+	/**
+	 * @throws ConfigException
+	 * @throws Exception
+	 */
+	public function init()
+	{
+        $connections = Kiri::getDi()->get(PoolRedis::class);
+
+		$config = $this->get_config();
+
+		$length = Config::get('connections.pool.max', 10);
+
+		$this->eventProvider->on(OnWorkerExit::class, [$this, 'destroy'], 0);
+
+		$connections->initConnections('Redis:' . $config['host'], true, $length);
+	}
+
+
+	/**
+	 * @param $name
+	 * @param $arguments
+	 * @return mixed
+	 * @throws
+	 */
+	public function __call($name, $arguments): mixed
+	{
+		$time = microtime(true);
+		if (method_exists($this, $name)) {
+			$data = $this->{$name}(...$arguments);
+		} else {
+			$data = $this->proxy()->{$name}(...$arguments);
+			$this->release();
+		}
+		if (microtime(true) - $time >= 0.02) {
+			$this->warning('Redis:' . Json::encode([$name, $arguments]) . (microtime(true) - $time));
+		}
+		return $data;
+	}
+
+
+	/**
+	 * @param $key
+	 * @param int $timeout
+	 * @return bool|int
+	 * @throws Exception
+	 */
+	public function lock($key, int $timeout = 5): bool|int
+	{
+		$script = <<<SCRIPT
+local _nx = redis.call('setnx',KEYS[1], ARGV[1])
+if (_nx ~= 0) then
+	redis.call('expire',KEYS[1], ARGV[1])
+	return 1
+end
+return 0
+SCRIPT;
+		return $this->eval($script, ['{lock}:' . $key, $timeout], 1);
+	}
+
+
+	/**
+	 * @param $key
+	 * @return int
+	 * @throws Exception
+	 */
+	public function unlock($key): int
+	{
+		return $this->del('{lock}:' . $key);
+	}
+
+
+	/**
+	 * @throws ConfigException
+	 * @throws Exception
+	 */
+	public function release()
+	{
+        $connections = Kiri::getDi()->get(PoolRedis::class);
+		$connections->release($this->get_config(), true);
+	}
+
+	/**
+	 * 销毁连接池
+	 * @throws ConfigException
+	 * @throws Exception
+	 */
+	public function destroy()
+	{
+		$connections = Kiri::getDi()->get(PoolRedis::class);
+		$connections->connection_clear($this->get_config(), true);
+	}
+
+	/**
+	 * @return Base\Redis
+	 * @throws Exception
+	 */
+	public function proxy(): Base\Redis
+	{
+        $connections = Kiri::getDi()->get(PoolRedis::class);
+
+		$config = $this->get_config();
+
+		$client = $connections->get($config, true);
+		if (!($client instanceof Base\Redis)) {
+			throw new Exception('Redis connections more.');
+		}
+		return $client;
+	}
+
+	/**
+	 * @return array
+	 * @throws ConfigException
+	 */
+	public function get_config(): array
+	{
+		return Config::get('cache.redis', null, true);
+	}
+
+}