includes/libs/rdbms/connectionmanager/ConnectionManager.php

   1 <?php
   2
   3 namespace Wikimedia\Rdbms;
   4
   5 use Database;
   6 use DBConnRef;
   7 use IDatabase;
   8 use InvalidArgumentException;
   9
  10 /**
  11  * Database connection manager.
  12  *
  13  * This manages access to master and replica databases.
  14  *
  15  * @since 1.29
  16  *
  17  * @license GPL-2.0+
  18  * @author Addshore
  19  */
  20 class ConnectionManager {
  21
  22         /**
  23          * @var LoadBalancer
  24          */
  25         private $loadBalancer;
  26
  27         /**
  28          * The symbolic name of the target database, or false for the local wiki's database.
  29          *
  30          * @var string|false
  31          */
  32         private $domain;
  33
  34         /**
  35          * @var string[]
  36          */
  37         private $groups = [];
  38
  39         /**
  40          * @param LoadBalancer $loadBalancer
  41          * @param string|bool $domain Optional logical DB name, defaults to current wiki.
  42          *        This follows the convention for database names used by $loadBalancer.
  43          * @param string[] $groups see LoadBalancer::getConnection
  44          *
  45          * @throws InvalidArgumentException
  46          */
  47         public function __construct( LoadBalancer $loadBalancer, $domain = false, array $groups = [] ) {
  48                 if ( !is_string( $domain ) && $domain !== false ) {
  49                         throw new InvalidArgumentException( '$dbName must be a string, or false.' );
  50                 }
  51
  52                 $this->loadBalancer = $loadBalancer;
  53                 $this->domain = $domain;
  54                 $this->groups = $groups;
  55         }
  56
  57         /**
  58          * @param int $i
  59          * @param string[]|null $groups
  60          *
  61          * @return Database
  62          */
  63         private function getConnection( $i, array $groups = null ) {
  64                 $groups = $groups === null ? $this->groups : $groups;
  65                 return $this->loadBalancer->getConnection( $i, $groups, $this->domain );
  66         }
  67
  68         /**
  69          * @param int $i
  70          * @param string[]|null $groups
  71          *
  72          * @return DBConnRef
  73          */
  74         private function getConnectionRef( $i, array $groups = null ) {
  75                 $groups = $groups === null ? $this->groups : $groups;
  76                 return $this->loadBalancer->getConnectionRef( $i, $groups, $this->domain );
  77         }
  78
  79         /**
  80          * Returns a connection to the master DB, for updating. The connection should later be released
  81          * by calling releaseConnection().
  82          *
  83          * @since 1.29
  84          *
  85          * @return Database
  86          */
  87         public function getWriteConnection() {
  88                 return $this->getConnection( DB_MASTER );
  89         }
  90
  91         /**
  92          * Returns a database connection for reading. The connection should later be released by
  93          * calling releaseConnection().
  94          *
  95          * @since 1.29
  96          *
  97          * @param string[]|null $groups
  98          *
  99          * @return Database
 100          */
 101         public function getReadConnection( array $groups = null ) {
 102                 $groups = $groups === null ? $this->groups : $groups;
 103                 return $this->getConnection( DB_REPLICA, $groups );
 104         }
 105
 106         /**
 107          * @since 1.29
 108          *
 109          * @param IDatabase $db
 110          */
 111         public function releaseConnection( IDatabase $db ) {
 112                 $this->loadBalancer->reuseConnection( $db );
 113         }
 114
 115         /**
 116          * Returns a connection ref to the master DB, for updating.
 117          *
 118          * @since 1.29
 119          *
 120          * @return DBConnRef
 121          */
 122         public function getWriteConnectionRef() {
 123                 return $this->getConnectionRef( DB_MASTER );
 124         }
 125
 126         /**
 127          * Returns a database connection ref for reading.
 128          *
 129          * @since 1.29
 130          *
 131          * @param string[]|null $groups
 132          *
 133          * @return DBConnRef
 134          */
 135         public function getReadConnectionRef( array $groups = null ) {
 136                 $groups = $groups === null ? $this->groups : $groups;
 137                 return $this->getConnectionRef( DB_REPLICA, $groups );
 138         }
 139
 140 }