includes/Pingback.php

   1 <?php
   2 /**
   3  * Send information about this MediaWiki instance to MediaWiki.org.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  */
  22
  23 use Psr\Log\LoggerInterface;
  24 use MediaWiki\Logger\LoggerFactory;
  25
  26 /**
  27  * Send information about this MediaWiki instance to MediaWiki.org.
  28  *
  29  * @since 1.28
  30  */
  31 class Pingback {
  32
  33         /**
  34          * @var int Revision ID of the JSON schema that describes the pingback
  35          *   payload. The schema lives on MetaWiki, at
  36          *   <https://meta.wikimedia.org/wiki/Schema:MediaWikiPingback>.
  37          */
  38         const SCHEMA_REV = 15781718;
  39
  40         /** @var LoggerInterface */
  41         protected $logger;
  42
  43         /** @var Config */
  44         protected $config;
  45
  46         /** @var string updatelog key (also used as cache/db lock key) */
  47         protected $key;
  48
  49         /** @var string Randomly-generated identifier for this wiki */
  50         protected $id;
  51
  52         /**
  53          * @param Config $config
  54          * @param LoggerInterface $logger
  55          */
  56         public function __construct( Config $config = null, LoggerInterface $logger = null ) {
  57                 $this->config = $config ?: RequestContext::getMain()->getConfig();
  58                 $this->logger = $logger ?: LoggerFactory::getInstance( __CLASS__ );
  59                 $this->key = 'Pingback-' . $this->config->get( 'Version' );
  60         }
  61
  62         /**
  63          * Should a pingback be sent?
  64          * @return bool
  65          */
  66         private function shouldSend() {
  67                 return $this->config->get( 'Pingback' ) && !$this->checkIfSent();
  68         }
  69
  70         /**
  71          * Has a pingback already been sent for this MediaWiki version?
  72          * @return bool
  73          */
  74         private function checkIfSent() {
  75                 $dbr = wfGetDB( DB_SLAVE );
  76                 $sent = $dbr->selectField(
  77                         'updatelog', '1', [ 'ul_key' => $this->key ], __METHOD__ );
  78                 return $sent !== false;
  79         }
  80
  81         /**
  82          * Record the fact that we have sent a pingback for this MediaWiki version,
  83          * to ensure we don't submit data multiple times.
  84          */
  85         private function markSent() {
  86                 $dbw = wfGetDB( DB_MASTER );
  87                 return $dbw->insert(
  88                         'updatelog', [ 'ul_key' => $this->key ], __METHOD__, 'IGNORE' );
  89         }
  90
  91         /**
  92          * Acquire lock for sending a pingback
  93          *
  94          * This ensures only one thread can attempt to send a pingback at any given
  95          * time and that we wait an hour before retrying failed attempts.
  96          *
  97          * @return bool Whether lock was acquired
  98          */
  99         private function acquireLock() {
 100                 $cache = ObjectCache::getLocalClusterInstance();
 101                 if ( !$cache->add( $this->key, 1, 60 * 60 ) ) {
 102                         return false;  // throttled
 103                 }
 104
 105                 $dbw = wfGetDB( DB_MASTER );
 106                 if ( !$dbw->lock( $this->key, __METHOD__, 0 ) ) {
 107                         return false;  // already in progress
 108                 }
 109
 110                 return true;
 111         }
 112
 113         /**
 114          * Collect basic data about this MediaWiki installation and return it
 115          * as an associative array conforming to the Pingback schema on MetaWiki
 116          * (<https://meta.wikimedia.org/wiki/Schema:MediaWikiPingback>).
 117          *
 118          * @return array
 119          */
 120         private function getData() {
 121                 $event = [
 122                         'database'   => $this->config->get( 'DBtype' ),
 123                         'MediaWiki'  => $this->config->get( 'Version' ),
 124                         'PHP'        => PHP_VERSION,
 125                         'OS'         => PHP_OS . ' ' . php_uname( 'r' ),
 126                         'arch'       => PHP_INT_SIZE === 8 ? 64 : 32,
 127                         'machine'    => php_uname( 'm' ),
 128                 ];
 129
 130                 if ( isset( $_SERVER['SERVER_SOFTWARE'] ) ) {
 131                         $event['serverSoftware'] = $_SERVER['SERVER_SOFTWARE'];
 132                 }
 133
 134                 $limit = ini_get( 'memory_limit' );
 135                 if ( $limit && $limit != -1 ) {
 136                         $event['memoryLimit'] = $limit;
 137                 }
 138
 139                 return [
 140                         'schema'           => 'MediaWikiPingback',
 141                         'revision'         => self::SCHEMA_REV,
 142                         'wiki'             => $this->getOrCreatePingbackId(),
 143                         'event'            => $event,
 144                 ];
 145         }
 146
 147         /**
 148          * Get a unique, stable identifier for this wiki
 149          *
 150          * If the identifier does not already exist, create it and save it in the
 151          * database. The identifier is randomly-generated.
 152          *
 153          * @return string 32-character hex string
 154          */
 155         private function getOrCreatePingbackId() {
 156                 if ( !$this->id ) {
 157                         $id = wfGetDB( DB_SLAVE )->selectField(
 158                                 'updatelog', 'ul_value', [ 'ul_key' => 'PingBack' ] );
 159
 160                         if ( $id == false ) {
 161                                 $id = MWCryptRand::generateHex( 32 );
 162                                 $dbw = wfGetDB( DB_MASTER );
 163                                 $dbw->insert(
 164                                         'updatelog',
 165                                         [ 'ul_key' => 'PingBack', 'ul_value' => $id ],
 166                                         __METHOD__,
 167                                         'IGNORE'
 168                                 );
 169
 170                                 if ( !$dbw->affectedRows() ) {
 171                                         $id = $dbw->selectField(
 172                                                 'updatelog', 'ul_value', [ 'ul_key' => 'PingBack' ] );
 173                                 }
 174                         }
 175
 176                         $this->id = $id;
 177                 }
 178
 179                 return $this->id;
 180         }
 181
 182         /**
 183          * Serialize pingback data and send it to MediaWiki.org via a POST
 184          * to its event beacon endpoint.
 185          *
 186          * The data encoding conforms to the expectations of EventLogging,
 187          * a software suite used by the Wikimedia Foundation for logging and
 188          * processing analytic data.
 189          *
 190          * Compare:
 191          * <https://github.com/wikimedia/mediawiki-extensions-EventLogging/
 192          *   blob/7e5fe4f1ef/includes/EventLogging.php#L32-L74>
 193          *
 194          * @param data Pingback data as an associative array
 195          * @return bool true on success, false on failure
 196          */
 197         private function postPingback( array $data ) {
 198                 $json = FormatJson::encode( $data );
 199                 $queryString = rawurlencode( str_replace( ' ', '\u0020', $json ) ) . ';';
 200                 $url = 'https://www.mediawiki.org/beacon/event?' . $queryString;
 201                 return Http::post( $url ) !== false;
 202         }
 203
 204         /**
 205          * Send information about this MediaWiki instance to MediaWiki.org.
 206          *
 207          * The data is structured and serialized to match the expectations of
 208          * EventLogging, a software suite used by the Wikimedia Foundation for
 209          * logging and processing analytic data.
 210          *
 211          * Compare:
 212          * <https://github.com/wikimedia/mediawiki-extensions-EventLogging/
 213          *   blob/7e5fe4f1ef/includes/EventLogging.php#L32-L74>
 214          *
 215          * The schema for the data is located at:
 216          * <https://meta.wikimedia.org/wiki/Schema:MediaWikiPingback>
 217          */
 218         public function sendPingback() {
 219                 if ( !$this->acquireLock() ) {
 220                         $this->logger->debug( __METHOD__ . ": couldn't acquire lock" );
 221                         return false;
 222                 }
 223
 224                 $data = $this->getData();
 225                 if ( !$this->postPingback( $data ) ) {
 226                         $this->logger->warning( __METHOD__ . ": failed to send pingback; check 'http' log" );
 227                         return false;
 228                 }
 229
 230                 $this->markSent();
 231                 $this->logger->debug( __METHOD__ . ": pingback sent OK ({$this->key})" );
 232                 return true;
 233         }
 234
 235         /**
 236          * Schedule a deferred callable that will check if a pingback should be
 237          * sent and (if so) proceed to send it.
 238          */
 239         public static function schedulePingback() {
 240                 DeferredUpdates::addCallableUpdate( function () {
 241                         $instance = new Pingback;
 242                         if ( $instance->shouldSend() ) {
 243                                 $instance->sendPingback();
 244                         }
 245                 } );
 246         }
 247 }