vendor/predis/predis/src/Connection/AbstractConnection.php line 120

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Predis package.
  5.  *
  6.  * (c) 2009-2020 Daniele Alessandri
  7.  * (c) 2021-2023 Till Krüss
  8.  *
  9.  * For the full copyright and license information, please view the LICENSE
  10.  * file that was distributed with this source code.
  11.  */
  13. namespace Predis\Connection;
  15. use InvalidArgumentException;
  16. use Predis\Command\CommandInterface;
  17. use Predis\Command\RawCommand;
  18. use Predis\CommunicationException;
  19. use Predis\Protocol\ProtocolException;
  21. /**
  22.  * Base class with the common logic used by connection classes to communicate
  23.  * with Redis.
  24.  */
  25. abstract class AbstractConnection implements NodeConnectionInterface
  26. {
  27.     private $resource;
  28.     private $cachedId;
  30.     protected $parameters;
  32.     /**
  33.      * @var RawCommand[]
  34.      */
  35.     protected $initCommands = [];
  37.     /**
  38.      * @param ParametersInterface $parameters Initialization parameters for the connection.
  39.      */
  40.     public function __construct(ParametersInterface $parameters)
  41.     {
  42.         $this->parameters = $this->assertParameters($parameters);
  43.     }
  45.     /**
  46.      * Disconnects from the server and destroys the underlying resource when
  47.      * PHP's garbage collector kicks in.
  48.      */
  49.     public function __destruct()
  50.     {
  51.         $this->disconnect();
  52.     }
  54.     /**
  55.      * Checks some of the parameters used to initialize the connection.
  56.      *
  57.      * @param ParametersInterface $parameters Initialization parameters for the connection.
  58.      *
  59.      * @return ParametersInterface
  60.      * @throws InvalidArgumentException
  61.      */
  62.     abstract protected function assertParameters(ParametersInterface $parameters);
  64.     /**
  65.      * Creates the underlying resource used to communicate with Redis.
  66.      *
  67.      * @return mixed
  68.      */
  69.     abstract protected function createResource();
  71.     /**
  72.      * {@inheritdoc}
  73.      */
  74.     public function isConnected()
  75.     {
  76.         return isset($this->resource);
  77.     }
  79.     /**
  80.      * {@inheritdoc}
  81.      */
  82.     public function connect()
  83.     {
  84.         if (!$this->isConnected()) {
  85.             $this->resource = $this->createResource();
  87.             return true;
  88.         }
  90.         return false;
  91.     }
  93.     /**
  94.      * {@inheritdoc}
  95.      */
  96.     public function disconnect()
  97.     {
  98.         unset($this->resource);
  99.     }
  101.     /**
  102.      * {@inheritdoc}
  103.      */
  104.     public function addConnectCommand(CommandInterface $command)
  105.     {
  106.         $this->initCommands[] = $command;
  107.     }
  109.     /**
  110.      * {@inheritdoc}
  111.      */
  112.     public function getInitCommands(): array
  113.     {
  114.         return $this->initCommands;
  115.     }
  117.     /**
  118.      * {@inheritdoc}
  119.      */
  120.     public function executeCommand(CommandInterface $command)
  121.     {
  122.         $this->writeRequest($command);
  124.         return $this->readResponse($command);
  125.     }
  127.     /**
  128.      * {@inheritdoc}
  129.      */
  130.     public function readResponse(CommandInterface $command)
  131.     {
  132.         return $this->read();
  133.     }
  135.     /**
  136.      * Helper method to handle connection errors.
  137.      *
  138.      * @param string $message Error message.
  139.      * @param int    $code    Error code.
  140.      */
  141.     protected function onConnectionError($message, $code = 0)
  142.     {
  143.         CommunicationException::handle(
  144.             new ConnectionException($this, "$message [{$this->getParameters()}]", $code)
  145.         );
  146.     }
  148.     /**
  149.      * Helper method to handle protocol errors.
  150.      *
  151.      * @param string $message Error message.
  152.      */
  153.     protected function onProtocolError($message)
  154.     {
  155.         CommunicationException::handle(
  156.             new ProtocolException($this, "$message [{$this->getParameters()}]")
  157.         );
  158.     }
  160.     /**
  161.      * {@inheritdoc}
  162.      */
  163.     public function getResource()
  164.     {
  165.         if (isset($this->resource)) {
  166.             return $this->resource;
  167.         }
  169.         $this->connect();
  171.         return $this->resource;
  172.     }
  174.     /**
  175.      * {@inheritdoc}
  176.      */
  177.     public function getParameters()
  178.     {
  179.         return $this->parameters;
  180.     }
  182.     /**
  183.      * Gets an identifier for the connection.
  184.      *
  185.      * @return string
  186.      */
  187.     protected function getIdentifier()
  188.     {
  189.         if ($this->parameters->scheme === 'unix') {
  190.             return $this->parameters->path;
  191.         }
  193.         return "{$this->parameters->host}:{$this->parameters->port}";
  194.     }
  196.     /**
  197.      * {@inheritdoc}
  198.      */
  199.     public function __toString()
  200.     {
  201.         if (!isset($this->cachedId)) {
  202.             $this->cachedId = $this->getIdentifier();
  203.         }
  205.         return $this->cachedId;
  206.     }
  208.     /**
  209.      * {@inheritdoc}
  210.      */
  211.     public function __sleep()
  212.     {
  213.         return ['parameters', 'initCommands'];
  214.     }
  215. }