Pingback.php

Go to the documentation of this file.

<?php
use Psr\Log\LoggerInterface;
use MediaWiki\Logger\LoggerFactory;
 
class Pingback {
 
    const SCHEMA_REV = 15781718;
 
    protected $logger;
 
    protected $config;
 
    protected $key;
 
    protected $id;
 
    public function __construct( Config $config = null, LoggerInterface $logger = null ) {
        $this->config = $config ?: RequestContext::getMain()->getConfig();
        $this->logger = $logger ?: LoggerFactory::getInstance( __CLASS__ );
        $this->key = 'Pingback-' . $this->config->get( 'Version' );
    }
 
    private function shouldSend() {
        return $this->config->get( 'Pingback' ) && !$this->checkIfSent();
    }
 
    private function checkIfSent() {
        $dbr = wfGetDB( DB_REPLICA );
        $timestamp = $dbr->selectField(
            'updatelog',
            'ul_value',
            [ 'ul_key' => $this->key ],
            __METHOD__
        );
        if ( $timestamp === false ) {
            return false;
        }
        // send heartbeat ping if last ping was over a month ago
        if ( time() - (int)$timestamp > 60 * 60 * 24 * 30 ) {
            return false;
        }
        return true;
    }
 
    private function markSent() {
        $dbw = wfGetDB( DB_MASTER );
        $timestamp = time();
        return $dbw->upsert(
            'updatelog',
            [ 'ul_key' => $this->key, 'ul_value' => $timestamp ],
            [ 'ul_key' ],
            [ 'ul_value' => $timestamp ],
            __METHOD__
        );
    }
 
    private function acquireLock() {
        $cache = ObjectCache::getLocalClusterInstance();
        if ( !$cache->add( $this->key, 1, 60 * 60 ) ) {
            return false;  // throttled
        }
 
        $dbw = wfGetDB( DB_MASTER );
        if ( !$dbw->lock( $this->key, __METHOD__, 0 ) ) {
            return false;  // already in progress
        }
 
        return true;
    }
 
    public function getSystemInfo() {
        $event = [
            'database'   => $this->config->get( 'DBtype' ),
            'MediaWiki'  => $this->config->get( 'Version' ),
            'PHP'        => PHP_VERSION,
            'OS'         => PHP_OS . ' ' . php_uname( 'r' ),
            'arch'       => PHP_INT_SIZE === 8 ? 64 : 32,
            'machine'    => php_uname( 'm' ),
        ];
 
        if ( isset( $_SERVER['SERVER_SOFTWARE'] ) ) {
            $event['serverSoftware'] = $_SERVER['SERVER_SOFTWARE'];
        }
 
        $limit = ini_get( 'memory_limit' );
        if ( $limit && $limit != -1 ) {
            $event['memoryLimit'] = $limit;
        }
 
        return $event;
    }
 
    private function getData() {
        return [
            'schema'           => 'MediaWikiPingback',
            'revision'         => self::SCHEMA_REV,
            'wiki'             => $this->getOrCreatePingbackId(),
            'event'            => $this->getSystemInfo(),
        ];
    }
 
    private function getOrCreatePingbackId() {
        if ( !$this->id ) {
            $id = wfGetDB( DB_REPLICA )->selectField(
                'updatelog', 'ul_value', [ 'ul_key' => 'PingBack' ] );
 
            if ( $id == false ) {
                $id = MWCryptRand::generateHex( 32 );
                $dbw = wfGetDB( DB_MASTER );
                $dbw->insert(
                    'updatelog',
                    [ 'ul_key' => 'PingBack', 'ul_value' => $id ],
                    __METHOD__,
                    'IGNORE'
                );
 
                if ( !$dbw->affectedRows() ) {
                    $id = $dbw->selectField(
                        'updatelog', 'ul_value', [ 'ul_key' => 'PingBack' ] );
                }
            }
 
            $this->id = $id;
        }
 
        return $this->id;
    }
 
    private function postPingback( array $data ) {
        $json = FormatJson::encode( $data );
        $queryString = rawurlencode( str_replace( ' ', '\u0020', $json ) ) . ';';
        $url = 'https://www.mediawiki.org/beacon/event?' . $queryString;
        return Http::post( $url ) !== false;
    }
 
    public function sendPingback() {
        if ( !$this->acquireLock() ) {
            $this->logger->debug( __METHOD__ . ": couldn't acquire lock" );
            return false;
        }
 
        $data = $this->getData();
        if ( !$this->postPingback( $data ) ) {
            $this->logger->warning( __METHOD__ . ": failed to send pingback; check 'http' log" );
            return false;
        }
 
        $this->markSent();
        $this->logger->debug( __METHOD__ . ": pingback sent OK ({$this->key})" );
        return true;
    }
 
    public static function schedulePingback() {
        DeferredUpdates::addCallableUpdate( function () {
            $instance = new Pingback;
            if ( $instance->shouldSend() ) {
                $instance->sendPingback();
            }
        } );
    }
}