DBLockManager.php

Go to the documentation of this file.

<?php
use Wikimedia\Rdbms\Database;
use Wikimedia\Rdbms\DBError;
use Wikimedia\Rdbms\IDatabase;
 
abstract class DBLockManager extends QuorumLockManager {
    protected $dbServers; // (DB name => server config array)
    protected $statusCache;
 
    protected $lockExpiry; // integer number of seconds
    protected $safeDelay; // integer number of seconds
    protected $conns = [];
 
    public function __construct( array $config ) {
        parent::__construct( $config );
 
        $this->dbServers = $config['dbServers'];
        // Sanitize srvsByBucket config to prevent PHP errors
        $this->srvsByBucket = array_filter( $config['dbsByBucket'], 'is_array' );
        $this->srvsByBucket = array_values( $this->srvsByBucket ); // consecutive
 
        if ( isset( $config['lockExpiry'] ) ) {
            $this->lockExpiry = $config['lockExpiry'];
        } else {
            $met = ini_get( 'max_execution_time' );
            $this->lockExpiry = $met ?: 60; // use some sane amount if 0
        }
        $this->safeDelay = ( $this->lockExpiry <= 0 )
            ? 60 // pick a safe-ish number to match DB timeout default
            : $this->lockExpiry; // cover worst case
 
        // Tracks peers that couldn't be queried recently to avoid lengthy
        // connection timeouts. This is useless if each bucket has one peer.
        $this->statusCache = $config['srvCache'] ?? new HashBagOStuff();
    }
 
    protected function getLocksOnServer( $lockSrv, array $pathsByType ) {
        $status = StatusValue::newGood();
        foreach ( $pathsByType as $type => $paths ) {
            $status->merge( $this->doGetLocksOnServer( $lockSrv, $paths, $type ) );
        }
 
        return $status;
    }
 
    abstract protected function doGetLocksOnServer( $lockSrv, array $paths, $type );
 
    protected function freeLocksOnServer( $lockSrv, array $pathsByType ) {
        return StatusValue::newGood();
    }
 
    protected function isServerUp( $lockSrv ) {
        if ( !$this->cacheCheckFailures( $lockSrv ) ) {
            return false; // recent failure to connect
        }
        try {
            $this->getConnection( $lockSrv );
        } catch ( DBError $e ) {
            $this->cacheRecordFailure( $lockSrv );
 
            return false; // failed to connect
        }
 
        return true;
    }
 
    protected function getConnection( $lockDb ) {
        if ( !isset( $this->conns[$lockDb] ) ) {
            if ( $this->dbServers[$lockDb] instanceof IDatabase ) {
                // Direct injected connection hande for $lockDB
                $db = $this->dbServers[$lockDb];
            } elseif ( is_array( $this->dbServers[$lockDb] ) ) {
                // Parameters to construct a new database connection
                $config = $this->dbServers[$lockDb];
                $config['flags'] = ( $config['flags'] ?? 0 );
                $config['flags'] &= ~( IDatabase::DBO_TRX | IDatabase::DBO_DEFAULT );
                $db = Database::factory( $config['type'], $config );
            } else {
                throw new UnexpectedValueException( "No server called '$lockDb'." );
            }
            # If the connection drops, try to avoid letting the DB rollback
            # and release the locks before the file operations are finished.
            # This won't handle the case of DB server restarts however.
            $options = [];
            if ( $this->lockExpiry > 0 ) {
                $options['connTimeout'] = $this->lockExpiry;
            }
            $db->setSessionOptions( $options );
            $this->initConnection( $lockDb, $db );
 
            $this->conns[$lockDb] = $db;
        }
 
        return $this->conns[$lockDb];
    }
 
    protected function initConnection( $lockDb, IDatabase $db ) {
    }
 
    protected function cacheCheckFailures( $lockDb ) {
        return ( $this->safeDelay > 0 )
            ? !$this->statusCache->get( $this->getMissKey( $lockDb ) )
            : true;
    }
 
    protected function cacheRecordFailure( $lockDb ) {
        return ( $this->safeDelay > 0 )
            ? $this->statusCache->set( $this->getMissKey( $lockDb ), 1, $this->safeDelay )
            : true;
    }
 
    protected function getMissKey( $lockDb ) {
        return 'dblockmanager:downservers:' . str_replace( ' ', '_', $lockDb );
    }
 
    public function __destruct() {
        $this->releaseAllLocks();
        foreach ( $this->conns as $db ) {
            $db->close( __METHOD__ );
        }
    }
}