includes/libs/objectcache/RESTBagOStuff.php

   1 <?php
   2
   3 use Psr\Log\LoggerInterface;
   4
   5 /**
   6  * Interface to key-value storage behind an HTTP server.
   7  *
   8  * Uses URL of the form "baseURL/{KEY}" to store, fetch, and delete values.
   9  *
  10  * E.g., when base URL is `/v1/sessions/`, then the store would do:
  11  *
  12  * `PUT /v1/sessions/12345758`
  13  *
  14  * and fetch would do:
  15  *
  16  * `GET /v1/sessions/12345758`
  17  *
  18  * delete would do:
  19  *
  20  * `DELETE /v1/sessions/12345758`
  21  *
  22  * Configure with:
  23  *
  24  * @code
  25  * $wgObjectCaches['sessions'] = array(
  26  *      'class' => 'RESTBagOStuff',
  27  *      'url' => 'http://localhost:7231/wikimedia.org/v1/sessions/'
  28  * );
  29  * @endcode
  30  */
  31 class RESTBagOStuff extends BagOStuff {
  32         /**
  33          * Default connection timeout in seconds. The kernel retransmits the SYN
  34          * packet after 1 second, so 1.2 seconds allows for 1 retransmit without
  35          * permanent failure.
  36          */
  37         const DEFAULT_CONN_TIMEOUT = 1.2;
  38
  39         /**
  40          * Default request timeout
  41          */
  42         const DEFAULT_REQ_TIMEOUT = 3.0;
  43
  44         /**
  45          * @var MultiHttpClient
  46          */
  47         private $client;
  48
  49         /**
  50          * REST URL to use for storage.
  51          * @var string
  52          */
  53         private $url;
  54
  55         public function __construct( $params ) {
  56                 if ( empty( $params['url'] ) ) {
  57                         throw new InvalidArgumentException( 'URL parameter is required' );
  58                 }
  59                 if ( empty( $params['client'] ) ) {
  60                         // Pass through some params to the HTTP client.
  61                         $clientParams = [
  62                                 'connTimeout' => $params['connTimeout'] ?? self::DEFAULT_CONN_TIMEOUT,
  63                                 'reqTimeout' => $params['reqTimeout'] ?? self::DEFAULT_REQ_TIMEOUT,
  64                         ];
  65                         foreach ( [ 'caBundlePath', 'proxy' ] as $key ) {
  66                                 if ( isset( $params[$key] ) ) {
  67                                         $clientParams[$key] = $params[$key];
  68                                 }
  69                         }
  70                         $this->client = new MultiHttpClient( $clientParams );
  71                 } else {
  72                         $this->client = $params['client'];
  73                 }
  74                 // The parent constructor calls setLogger() which sets the logger in $this->client
  75                 parent::__construct( $params );
  76                 // Make sure URL ends with /
  77                 $this->url = rtrim( $params['url'], '/' ) . '/';
  78                 // Default config, R+W > N; no locks on reads though; writes go straight to state-machine
  79                 $this->attrMap[self::ATTR_SYNCWRITES] = self::QOS_SYNCWRITES_QC;
  80         }
  81
  82         public function setLogger( LoggerInterface $logger ) {
  83                 parent::setLogger( $logger );
  84                 $this->client->setLogger( $logger );
  85         }
  86
  87         protected function doGet( $key, $flags = 0, &$casToken = null ) {
  88                 $casToken = null;
  89
  90                 $req = [
  91                         'method' => 'GET',
  92                         'url' => $this->url . rawurlencode( $key ),
  93                 ];
  94
  95                 list( $rcode, $rdesc, $rhdrs, $rbody, $rerr ) = $this->client->run( $req );
  96                 if ( $rcode === 200 ) {
  97                         if ( is_string( $rbody ) ) {
  98                                 $value = unserialize( $rbody );
  99                                 /// @FIXME: use some kind of hash or UUID header as CAS token
 100                                 $casToken = ( $value !== false ) ? $rbody : null;
 101
 102                                 return $value;
 103                         }
 104                         return false;
 105                 }
 106                 if ( $rcode === 0 || ( $rcode >= 400 && $rcode != 404 ) ) {
 107                         return $this->handleError( "Failed to fetch $key", $rcode, $rerr );
 108                 }
 109                 return false;
 110         }
 111
 112         public function set( $key, $value, $exptime = 0, $flags = 0 ) {
 113                 // @TODO: respect WRITE_SYNC (e.g. EACH_QUORUM)
 114                 // @TODO: respect $exptime
 115                 $req = [
 116                         'method' => 'PUT',
 117                         'url' => $this->url . rawurlencode( $key ),
 118                         'body' => serialize( $value )
 119                 ];
 120                 list( $rcode, $rdesc, $rhdrs, $rbody, $rerr ) = $this->client->run( $req );
 121                 if ( $rcode === 200 || $rcode === 201 || $rcode === 204 ) {
 122                         return true;
 123                 }
 124                 return $this->handleError( "Failed to store $key", $rcode, $rerr );
 125         }
 126
 127         public function add( $key, $value, $exptime = 0, $flags = 0 ) {
 128                 // @TODO: make this atomic
 129                 if ( $this->get( $key ) === false ) {
 130                         return $this->set( $key, $value, $exptime, $flags );
 131                 }
 132
 133                 return false; // key already set
 134         }
 135
 136         public function delete( $key, $flags = 0 ) {
 137                 // @TODO: respect WRITE_SYNC (e.g. EACH_QUORUM)
 138                 $req = [
 139                         'method' => 'DELETE',
 140                         'url' => $this->url . rawurlencode( $key ),
 141                 ];
 142                 list( $rcode, $rdesc, $rhdrs, $rbody, $rerr ) = $this->client->run( $req );
 143                 if ( in_array( $rcode, [ 200, 204, 205, 404, 410 ] ) ) {
 144                         return true;
 145                 }
 146                 return $this->handleError( "Failed to delete $key", $rcode, $rerr );
 147         }
 148
 149         public function incr( $key, $value = 1 ) {
 150                 // @TODO: make this atomic
 151                 $n = $this->get( $key, self::READ_LATEST );
 152                 if ( $this->isInteger( $n ) ) { // key exists?
 153                         $n = max( $n + intval( $value ), 0 );
 154                         // @TODO: respect $exptime
 155                         return $this->set( $key, $n ) ? $n : false;
 156                 }
 157
 158                 return false;
 159         }
 160
 161         /**
 162          * Handle storage error
 163          * @param string $msg Error message
 164          * @param int $rcode Error code from client
 165          * @param string $rerr Error message from client
 166          * @return false
 167          */
 168         protected function handleError( $msg, $rcode, $rerr ) {
 169                 $this->logger->error( "$msg : ({code}) {error}", [
 170                         'code' => $rcode,
 171                         'error' => $rerr
 172                 ] );
 173                 $this->setLastError( $rcode === 0 ? self::ERR_UNREACHABLE : self::ERR_UNEXPECTED );
 174                 return false;
 175         }
 176 }