Ez\DbLinker\RetryStrategy\RetryStrategy

Complexity

Total Complexity

19

Size/Duplication

Total Lines	85
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
	errorCodeStrategies()	0	1	?
	errorCode()	0	1	?
A	__construct()	0	4	1
A	shouldRetry()	0	8	2
A	retryLimit()	0	4	2
A	canRetry()	0	4	2
A	errorCodeStrategy()	0	17	3
A	applyStrategy()	0	9	3
A	changeServer()	0	13	4
A	reconnect()	0	6	2

<?php

namespace Ez\DbLinker\RetryStrategy;

use Exception;
use Ez\DbLinker\Slave;
use stdClass;
use Ez\DbLinker\Driver\Connection\MasterSlavesConnection;
use Ez\DbLinker\Driver\Connection\RetryConnection;

trait RetryStrategy
{
    private $retryLimit;

    public function __construct($retryLimit = 8)
    {
        $this->retryLimit = $retryLimit;
    }

    /**
     * @param Exception $exception
     * @param RetryConnection $connection
     * @return bool
     */
    public function shouldRetry(Exception $exception, RetryConnection $connection): bool
    {
        if (!$this->canRetry($connection)) {
            return false;
        }
        $strategy = $this->errorCodeStrategy($this->errorCode($exception));
        return $this->applyStrategy($strategy, $connection);
    }

    public function retryLimit()
    {
        return $this->retryLimit > 0 ? (int) $this->retryLimit : 0;
    }

    private function canRetry(RetryConnection $connection)
    {
        return $this->retryLimit > 0 && $connection->transactionLevel() === 0;
    }

    private function errorCodeStrategy($errorCode)
    {
        $strategy = (object) [
            'retry' => true,
            'wait' => 0,
            'changeServer' => false,
            'reconnect' => false,
        ];
        $errorCodeStrategies = $this->errorCodeStrategies();
        if (array_key_exists($errorCode, $errorCodeStrategies)) {
            foreach ($errorCodeStrategies[$errorCode] as $behavior => $value) {
                $strategy->$behavior = $value;
            }
            return $strategy;
        }
        return (object) ['retry' => false];
    }

    private function applyStrategy(stdClass $strategy, RetryConnection $connection) {
        if ($strategy->retry === false || !$this->changeServer($strategy, $connection)) {
            return false;
        }
        sleep($strategy->wait);
        $this->reconnect($strategy, $connection);
        $this->retryLimit--;
        return true;
    }

    private function changeServer(stdClass $strategy, RetryConnection $connection): bool
    {
        if (!$strategy->changeServer) {
            return true;
        }
        /** @var MasterSlavesConnection $wrappedConnection */
        $wrappedConnection = $connection->wrappedConnection();
        if ($wrappedConnection instanceof MasterSlavesConnection && $wrappedConnection->getLastConnection() instanceOf Slave) {
            $wrappedConnection->getLastConnection()->disable();
            return true;
        }
        return false;
    }

    private function reconnect(stdClass $strategy, RetryConnection $connection): void
    {
        if ($strategy->reconnect) {
            $connection->close();
        }
    }

    protected abstract function errorCodeStrategies();
    protected abstract function errorCode(Exception $exception);
}