includes/jobqueue/JobQueueFederated.php

   1 <?php
   2 /**
   3  * Job queue code for federated queues.
   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 /**
  24  * Class to handle enqueueing and running of background jobs for federated queues
  25  *
  26  * This class allows for queues to be partitioned into smaller queues.
  27  * A partition is defined by the configuration for a JobQueue instance.
  28  * For example, one can set $wgJobTypeConf['refreshLinks'] to point to a
  29  * JobQueueFederated instance, which itself would consist of three JobQueueRedis
  30  * instances, each using their own redis server. This would allow for the jobs
  31  * to be split (evenly or based on weights) across multiple servers if a single
  32  * server becomes impractical or expensive. Different JobQueue classes can be mixed.
  33  *
  34  * The basic queue configuration (e.g. "order", "claimTTL") of a federated queue
  35  * is inherited by the partition queues. Additional configuration defines what
  36  * section each wiki is in, what partition queues each section uses (and their weight),
  37  * and the JobQueue configuration for each partition. Some sections might only need a
  38  * single queue partition, like the sections for groups of small wikis.
  39  *
  40  * If used for performance, then $wgMainCacheType should be set to memcached/redis.
  41  * Note that "fifo" cannot be used for the ordering, since the data is distributed.
  42  * One can still use "timestamp" instead, as in "roughly timestamp ordered". Also,
  43  * queue classes used by this should ignore down servers (with TTL) to avoid slowness.
  44  *
  45  * @ingroup JobQueue
  46  * @since 1.22
  47  */
  48 class JobQueueFederated extends JobQueue {
  49         /** @var HashRing */
  50         protected $partitionRing;
  51         /** @var JobQueue[] (partition name => JobQueue) reverse sorted by weight */
  52         protected $partitionQueues = [];
  53
  54         /** @var int Maximum number of partitions to try */
  55         protected $maxPartitionsTry;
  56
  57         /**
  58          * @param array $params Possible keys:
  59          *  - sectionsByWiki      : A map of wiki IDs to section names.
  60          *                          Wikis will default to using the section "default".
  61          *  - partitionsBySection : Map of section names to maps of (partition name => weight).
  62          *                          A section called 'default' must be defined if not all wikis
  63          *                          have explicitly defined sections.
  64          *  - configByPartition   : Map of queue partition names to configuration arrays.
  65          *                          These configuration arrays are passed to JobQueue::factory().
  66          *                          The options set here are overridden by those passed to this
  67          *                          the federated queue itself (e.g. 'order' and 'claimTTL').
  68          *  - maxPartitionsTry    : Maximum number of times to attempt job insertion using
  69          *                          different partition queues. This improves availability
  70          *                          during failure, at the cost of added latency and somewhat
  71          *                          less reliable job de-duplication mechanisms.
  72          * @throws MWException
  73          */
  74         protected function __construct( array $params ) {
  75                 parent::__construct( $params );
  76                 $section = isset( $params['sectionsByWiki'][$this->wiki] )
  77                         ? $params['sectionsByWiki'][$this->wiki]
  78                         : 'default';
  79                 if ( !isset( $params['partitionsBySection'][$section] ) ) {
  80                         throw new MWException( "No configuration for section '$section'." );
  81                 }
  82                 $this->maxPartitionsTry = isset( $params['maxPartitionsTry'] )
  83                         ? $params['maxPartitionsTry']
  84                         : 2;
  85                 // Get the full partition map
  86                 $partitionMap = $params['partitionsBySection'][$section];
  87                 arsort( $partitionMap, SORT_NUMERIC );
  88                 // Get the config to pass to merge into each partition queue config
  89                 $baseConfig = $params;
  90                 foreach ( [ 'class', 'sectionsByWiki', 'maxPartitionsTry',
  91                         'partitionsBySection', 'configByPartition', ] as $o
  92                 ) {
  93                         unset( $baseConfig[$o] ); // partition queue doesn't care about this
  94                 }
  95                 // The class handles all aggregator calls already
  96                 unset( $baseConfig['aggregator'] );
  97                 // Get the partition queue objects
  98                 foreach ( $partitionMap as $partition => $w ) {
  99                         if ( !isset( $params['configByPartition'][$partition] ) ) {
 100                                 throw new MWException( "No configuration for partition '$partition'." );
 101                         }
 102                         $this->partitionQueues[$partition] = JobQueue::factory(
 103                                 $baseConfig + $params['configByPartition'][$partition] );
 104                 }
 105                 // Ring of all partitions
 106                 $this->partitionRing = new HashRing( $partitionMap );
 107         }
 108
 109         protected function supportedOrders() {
 110                 // No FIFO due to partitioning, though "rough timestamp order" is supported
 111                 return [ 'undefined', 'random', 'timestamp' ];
 112         }
 113
 114         protected function optimalOrder() {
 115                 return 'undefined'; // defer to the partitions
 116         }
 117
 118         protected function supportsDelayedJobs() {
 119                 foreach ( $this->partitionQueues as $queue ) {
 120                         if ( !$queue->supportsDelayedJobs() ) {
 121                                 return false;
 122                         }
 123                 }
 124
 125                 return true;
 126         }
 127
 128         protected function doIsEmpty() {
 129                 $empty = true;
 130                 $failed = 0;
 131                 foreach ( $this->partitionQueues as $queue ) {
 132                         try {
 133                                 $empty = $empty && $queue->doIsEmpty();
 134                         } catch ( JobQueueError $e ) {
 135                                 ++$failed;
 136                                 $this->logException( $e );
 137                         }
 138                 }
 139                 $this->throwErrorIfAllPartitionsDown( $failed );
 140
 141                 return $empty;
 142         }
 143
 144         protected function doGetSize() {
 145                 return $this->getCrossPartitionSum( 'size', 'doGetSize' );
 146         }
 147
 148         protected function doGetAcquiredCount() {
 149                 return $this->getCrossPartitionSum( 'acquiredcount', 'doGetAcquiredCount' );
 150         }
 151
 152         protected function doGetDelayedCount() {
 153                 return $this->getCrossPartitionSum( 'delayedcount', 'doGetDelayedCount' );
 154         }
 155
 156         protected function doGetAbandonedCount() {
 157                 return $this->getCrossPartitionSum( 'abandonedcount', 'doGetAbandonedCount' );
 158         }
 159
 160         /**
 161          * @param string $type
 162          * @param string $method
 163          * @return int
 164          */
 165         protected function getCrossPartitionSum( $type, $method ) {
 166                 $count = 0;
 167                 $failed = 0;
 168                 foreach ( $this->partitionQueues as $queue ) {
 169                         try {
 170                                 $count += $queue->$method();
 171                         } catch ( JobQueueError $e ) {
 172                                 ++$failed;
 173                                 $this->logException( $e );
 174                         }
 175                 }
 176                 $this->throwErrorIfAllPartitionsDown( $failed );
 177
 178                 return $count;
 179         }
 180
 181         protected function doBatchPush( array $jobs, $flags ) {
 182                 // Local ring variable that may be changed to point to a new ring on failure
 183                 $partitionRing = $this->partitionRing;
 184                 // Try to insert the jobs and update $partitionsTry on any failures.
 185                 // Retry to insert any remaning jobs again, ignoring the bad partitions.
 186                 $jobsLeft = $jobs;
 187                 // phpcs:ignore Generic.CodeAnalysis.ForLoopWithTestFunctionCall
 188                 for ( $i = $this->maxPartitionsTry; $i > 0 && count( $jobsLeft ); --$i ) {
 189                         try {
 190                                 $partitionRing->getLiveRing();
 191                         } catch ( UnexpectedValueException $e ) {
 192                                 break; // all servers down; nothing to insert to
 193                         }
 194                         $jobsLeft = $this->tryJobInsertions( $jobsLeft, $partitionRing, $flags );
 195                 }
 196                 if ( count( $jobsLeft ) ) {
 197                         throw new JobQueueError(
 198                                 "Could not insert job(s), {$this->maxPartitionsTry} partitions tried." );
 199                 }
 200         }
 201
 202         /**
 203          * @param array $jobs
 204          * @param HashRing &$partitionRing
 205          * @param int $flags
 206          * @throws JobQueueError
 207          * @return array List of Job object that could not be inserted
 208          */
 209         protected function tryJobInsertions( array $jobs, HashRing &$partitionRing, $flags ) {
 210                 $jobsLeft = [];
 211
 212                 // Because jobs are spread across partitions, per-job de-duplication needs
 213                 // to use a consistent hash to avoid allowing duplicate jobs per partition.
 214                 // When inserting a batch of de-duplicated jobs, QOS_ATOMIC is disregarded.
 215                 $uJobsByPartition = []; // (partition name => job list)
 216                 /** @var Job $job */
 217                 foreach ( $jobs as $key => $job ) {
 218                         if ( $job->ignoreDuplicates() ) {
 219                                 $sha1 = sha1( serialize( $job->getDeduplicationInfo() ) );
 220                                 $uJobsByPartition[$partitionRing->getLiveLocation( $sha1 )][] = $job;
 221                                 unset( $jobs[$key] );
 222                         }
 223                 }
 224                 // Get the batches of jobs that are not de-duplicated
 225                 if ( $flags & self::QOS_ATOMIC ) {
 226                         $nuJobBatches = [ $jobs ]; // all or nothing
 227                 } else {
 228                         // Split the jobs into batches and spread them out over servers if there
 229                         // are many jobs. This helps keep the partitions even. Otherwise, send all
 230                         // the jobs to a single partition queue to avoids the extra connections.
 231                         $nuJobBatches = array_chunk( $jobs, 300 );
 232                 }
 233
 234                 // Insert the de-duplicated jobs into the queues...
 235                 foreach ( $uJobsByPartition as $partition => $jobBatch ) {
 236                         /** @var JobQueue $queue */
 237                         $queue = $this->partitionQueues[$partition];
 238                         try {
 239                                 $ok = true;
 240                                 $queue->doBatchPush( $jobBatch, $flags | self::QOS_ATOMIC );
 241                         } catch ( JobQueueError $e ) {
 242                                 $ok = false;
 243                                 $this->logException( $e );
 244                         }
 245                         if ( !$ok ) {
 246                                 if ( !$partitionRing->ejectFromLiveRing( $partition, 5 ) ) { // blacklist
 247                                         throw new JobQueueError( "Could not insert job(s), no partitions available." );
 248                                 }
 249                                 $jobsLeft = array_merge( $jobsLeft, $jobBatch ); // not inserted
 250                         }
 251                 }
 252
 253                 // Insert the jobs that are not de-duplicated into the queues...
 254                 foreach ( $nuJobBatches as $jobBatch ) {
 255                         $partition = ArrayUtils::pickRandom( $partitionRing->getLiveLocationWeights() );
 256                         $queue = $this->partitionQueues[$partition];
 257                         try {
 258                                 $ok = true;
 259                                 $queue->doBatchPush( $jobBatch, $flags | self::QOS_ATOMIC );
 260                         } catch ( JobQueueError $e ) {
 261                                 $ok = false;
 262                                 $this->logException( $e );
 263                         }
 264                         if ( !$ok ) {
 265                                 if ( !$partitionRing->ejectFromLiveRing( $partition, 5 ) ) { // blacklist
 266                                         throw new JobQueueError( "Could not insert job(s), no partitions available." );
 267                                 }
 268                                 $jobsLeft = array_merge( $jobsLeft, $jobBatch ); // not inserted
 269                         }
 270                 }
 271
 272                 return $jobsLeft;
 273         }
 274
 275         protected function doPop() {
 276                 $partitionsTry = $this->partitionRing->getLiveLocationWeights(); // (partition => weight)
 277
 278                 $failed = 0;
 279                 while ( count( $partitionsTry ) ) {
 280                         $partition = ArrayUtils::pickRandom( $partitionsTry );
 281                         if ( $partition === false ) {
 282                                 break; // all partitions at 0 weight
 283                         }
 284
 285                         /** @var JobQueue $queue */
 286                         $queue = $this->partitionQueues[$partition];
 287                         try {
 288                                 $job = $queue->pop();
 289                         } catch ( JobQueueError $e ) {
 290                                 ++$failed;
 291                                 $this->logException( $e );
 292                                 $job = false;
 293                         }
 294                         if ( $job ) {
 295                                 $job->metadata['QueuePartition'] = $partition;
 296
 297                                 return $job;
 298                         } else {
 299                                 unset( $partitionsTry[$partition] ); // blacklist partition
 300                         }
 301                 }
 302                 $this->throwErrorIfAllPartitionsDown( $failed );
 303
 304                 return false;
 305         }
 306
 307         protected function doAck( Job $job ) {
 308                 if ( !isset( $job->metadata['QueuePartition'] ) ) {
 309                         throw new MWException( "The given job has no defined partition name." );
 310                 }
 311
 312                 $this->partitionQueues[$job->metadata['QueuePartition']]->ack( $job );
 313         }
 314
 315         protected function doIsRootJobOldDuplicate( Job $job ) {
 316                 $signature = $job->getRootJobParams()['rootJobSignature'];
 317                 $partition = $this->partitionRing->getLiveLocation( $signature );
 318                 try {
 319                         return $this->partitionQueues[$partition]->doIsRootJobOldDuplicate( $job );
 320                 } catch ( JobQueueError $e ) {
 321                         if ( $this->partitionRing->ejectFromLiveRing( $partition, 5 ) ) {
 322                                 $partition = $this->partitionRing->getLiveLocation( $signature );
 323                                 return $this->partitionQueues[$partition]->doIsRootJobOldDuplicate( $job );
 324                         }
 325                 }
 326
 327                 return false;
 328         }
 329
 330         protected function doDeduplicateRootJob( IJobSpecification $job ) {
 331                 $signature = $job->getRootJobParams()['rootJobSignature'];
 332                 $partition = $this->partitionRing->getLiveLocation( $signature );
 333                 try {
 334                         return $this->partitionQueues[$partition]->doDeduplicateRootJob( $job );
 335                 } catch ( JobQueueError $e ) {
 336                         if ( $this->partitionRing->ejectFromLiveRing( $partition, 5 ) ) {
 337                                 $partition = $this->partitionRing->getLiveLocation( $signature );
 338                                 return $this->partitionQueues[$partition]->doDeduplicateRootJob( $job );
 339                         }
 340                 }
 341
 342                 return false;
 343         }
 344
 345         protected function doDelete() {
 346                 $failed = 0;
 347                 /** @var JobQueue $queue */
 348                 foreach ( $this->partitionQueues as $queue ) {
 349                         try {
 350                                 $queue->doDelete();
 351                         } catch ( JobQueueError $e ) {
 352                                 ++$failed;
 353                                 $this->logException( $e );
 354                         }
 355                 }
 356                 $this->throwErrorIfAllPartitionsDown( $failed );
 357                 return true;
 358         }
 359
 360         protected function doWaitForBackups() {
 361                 $failed = 0;
 362                 /** @var JobQueue $queue */
 363                 foreach ( $this->partitionQueues as $queue ) {
 364                         try {
 365                                 $queue->waitForBackups();
 366                         } catch ( JobQueueError $e ) {
 367                                 ++$failed;
 368                                 $this->logException( $e );
 369                         }
 370                 }
 371                 $this->throwErrorIfAllPartitionsDown( $failed );
 372         }
 373
 374         protected function doFlushCaches() {
 375                 /** @var JobQueue $queue */
 376                 foreach ( $this->partitionQueues as $queue ) {
 377                         $queue->doFlushCaches();
 378                 }
 379         }
 380
 381         public function getAllQueuedJobs() {
 382                 $iterator = new AppendIterator();
 383
 384                 /** @var JobQueue $queue */
 385                 foreach ( $this->partitionQueues as $queue ) {
 386                         $iterator->append( $queue->getAllQueuedJobs() );
 387                 }
 388
 389                 return $iterator;
 390         }
 391
 392         public function getAllDelayedJobs() {
 393                 $iterator = new AppendIterator();
 394
 395                 /** @var JobQueue $queue */
 396                 foreach ( $this->partitionQueues as $queue ) {
 397                         $iterator->append( $queue->getAllDelayedJobs() );
 398                 }
 399
 400                 return $iterator;
 401         }
 402
 403         public function getAllAcquiredJobs() {
 404                 $iterator = new AppendIterator();
 405
 406                 /** @var JobQueue $queue */
 407                 foreach ( $this->partitionQueues as $queue ) {
 408                         $iterator->append( $queue->getAllAcquiredJobs() );
 409                 }
 410
 411                 return $iterator;
 412         }
 413
 414         public function getAllAbandonedJobs() {
 415                 $iterator = new AppendIterator();
 416
 417                 /** @var JobQueue $queue */
 418                 foreach ( $this->partitionQueues as $queue ) {
 419                         $iterator->append( $queue->getAllAbandonedJobs() );
 420                 }
 421
 422                 return $iterator;
 423         }
 424
 425         public function getCoalesceLocationInternal() {
 426                 return "JobQueueFederated:wiki:{$this->wiki}" .
 427                         sha1( serialize( array_keys( $this->partitionQueues ) ) );
 428         }
 429
 430         protected function doGetSiblingQueuesWithJobs( array $types ) {
 431                 $result = [];
 432
 433                 $failed = 0;
 434                 /** @var JobQueue $queue */
 435                 foreach ( $this->partitionQueues as $queue ) {
 436                         try {
 437                                 $nonEmpty = $queue->doGetSiblingQueuesWithJobs( $types );
 438                                 if ( is_array( $nonEmpty ) ) {
 439                                         $result = array_unique( array_merge( $result, $nonEmpty ) );
 440                                 } else {
 441                                         return null; // not supported on all partitions; bail
 442                                 }
 443                                 if ( count( $result ) == count( $types ) ) {
 444                                         break; // short-circuit
 445                                 }
 446                         } catch ( JobQueueError $e ) {
 447                                 ++$failed;
 448                                 $this->logException( $e );
 449                         }
 450                 }
 451                 $this->throwErrorIfAllPartitionsDown( $failed );
 452
 453                 return array_values( $result );
 454         }
 455
 456         protected function doGetSiblingQueueSizes( array $types ) {
 457                 $result = [];
 458                 $failed = 0;
 459                 /** @var JobQueue $queue */
 460                 foreach ( $this->partitionQueues as $queue ) {
 461                         try {
 462                                 $sizes = $queue->doGetSiblingQueueSizes( $types );
 463                                 if ( is_array( $sizes ) ) {
 464                                         foreach ( $sizes as $type => $size ) {
 465                                                 $result[$type] = isset( $result[$type] ) ? $result[$type] + $size : $size;
 466                                         }
 467                                 } else {
 468                                         return null; // not supported on all partitions; bail
 469                                 }
 470                         } catch ( JobQueueError $e ) {
 471                                 ++$failed;
 472                                 $this->logException( $e );
 473                         }
 474                 }
 475                 $this->throwErrorIfAllPartitionsDown( $failed );
 476
 477                 return $result;
 478         }
 479
 480         protected function logException( Exception $e ) {
 481                 wfDebugLog( 'JobQueueFederated', $e->getMessage() . "\n" . $e->getTraceAsString() );
 482         }
 483
 484         /**
 485          * Throw an error if no partitions available
 486          *
 487          * @param int $down The number of up partitions down
 488          * @return void
 489          * @throws JobQueueError
 490          */
 491         protected function throwErrorIfAllPartitionsDown( $down ) {
 492                 if ( $down >= count( $this->partitionQueues ) ) {
 493                         throw new JobQueueError( 'No queue partitions available.' );
 494                 }
 495         }
 496 }