ReplicationReporter.php

Go to the documentation of this file.

<?php
namespace Wikimedia\Rdbms\Replication;
 
use BagOStuff;
use Psr\Log\LoggerInterface;
use Wikimedia\Rdbms\DBError;
use Wikimedia\Rdbms\DBPrimaryPos;
use Wikimedia\Rdbms\IDatabase;
 
class ReplicationReporter {
    protected $topologyRole;
    protected $logger;
    protected $srvCache;
    private $trxReplicaLagStatus = null;
 
    public function __construct( $topologyRole, $logger, $srvCache ) {
        $this->topologyRole = $topologyRole;
        $this->logger = $logger;
        $this->srvCache = $srvCache;
    }
 
    public function getTopologyRole() {
        return $this->topologyRole;
    }
 
    public function getLag( IDatabase $conn ) {
        if ( $this->topologyRole === IDatabase::ROLE_STREAMING_MASTER ) {
            return 0; // this is the primary DB
        } elseif ( $this->topologyRole === IDatabase::ROLE_STATIC_CLONE ) {
            return 0; // static dataset
        }
 
        return $this->doGetLag( $conn );
    }
 
    protected function doGetLag( IDatabase $conn ) {
        return 0;
    }
 
    protected function getApproximateLagStatus( IDatabase $conn ) {
        if ( $this->topologyRole === IDatabase::ROLE_STREAMING_REPLICA ) {
            // Avoid exceptions as this is used internally in critical sections
            try {
                $lag = $this->getLag( $conn );
            } catch ( DBError $e ) {
                $lag = false;
            }
        } else {
            $lag = 0;
        }
 
        return [ 'lag' => $lag, 'since' => microtime( true ) ];
    }
 
    public function primaryPosWait( IDatabase $conn, DBPrimaryPos $pos, $timeout ) {
        // Real waits are implemented in the subclass.
        return 0;
    }
 
    public function getReplicaPos( IDatabase $conn ) {
        // Stub
        return false;
    }
 
    public function getPrimaryPos( IDatabase $conn ) {
        // Stub
        return false;
    }
 
    public function getTopologyBasedReadOnlyReason() {
        if ( $this->topologyRole === IDatabase::ROLE_STREAMING_REPLICA ) {
            return [ 'Server is configured as a read-only replica database.', 'role' ];
        } elseif ( $this->topologyRole === IDatabase::ROLE_STATIC_CLONE ) {
            return [ 'Server is configured as a read-only static clone database.', 'role' ];
        }
 
        return [];
    }
 
    public function resetReplicationLagStatus( IDatabase $conn ) {
        // With REPEATABLE-READ isolation, the first SELECT establishes the read snapshot,
        // so get the replication lag estimate before any transaction SELECT queries come in.
        // This way, the lag estimate reflects what will actually be read. Also, if heartbeat
        // tables are used, this avoids counting snapshot lag as part of replication lag.
        $this->trxReplicaLagStatus = null; // clear cached value first
        $this->trxReplicaLagStatus = $this->getApproximateLagStatus( $conn );
    }
 
    final protected function getRecordedTransactionLagStatus( IDatabase $conn ) {
        return $conn->trxLevel() ? $this->trxReplicaLagStatus : null;
    }
 
    public function getSessionLagStatus( IDatabase $conn ) {
        return $this->getRecordedTransactionLagStatus( $conn ) ?: $this->getApproximateLagStatus( $conn );
    }
 
    protected function getLogContext( IDatabase $conn, array $extras = [] ) {
        return array_merge(
            [
                'db_server' => $conn->getServerName(),
                'db_name' => $conn->getDBname(),
                // TODO: Add db_user
            ],
            $extras
        );
    }
 
    public function getTopologyBasedServerId( IDatabase $conn ) {
        return null;
    }
}