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 = $params['sectionsByWiki'][$this->domain] ?? 'default';
  77                 if ( !isset( $params['partitionsBySection'][$section] ) ) {
  78                         throw new MWException( "No configuration for section '$section'." );
  79                 }
  80                 $this->maxPartitionsTry = $params['maxPartitionsTry'] ?? 2;
  81                 // Get the full partition map
  82                 $partitionMap = $params['partitionsBySection'][$section];
  83                 arsort( $partitionMap, SORT_NUMERIC );
  84                 // Get the config to pass to merge into each partition queue config
  85                 $baseConfig = $params;
  86                 foreach ( [ 'class', 'sectionsByWiki', 'maxPartitionsTry',
  87                         'partitionsBySection', 'configByPartition', ] as $o
  88                 ) {
  89                         unset( $baseConfig[$o] ); // partition queue doesn't care about this
  90                 }
  91                 // The class handles all aggregator calls already
  92                 unset( $baseConfig['aggregator'] );
  93                 // Get the partition queue objects
  94                 foreach ( $partitionMap as $partition => $w ) {
  95                         if ( !isset( $params['configByPartition'][$partition] ) ) {
  96                                 throw new MWException( "No configuration for partition '$partition'." );
  97                         }
  98                         $this->partitionQueues[$partition] = JobQueue::factory(
  99                                 $baseConfig + $params['configByPartition'][$partition] );
 100                 }
 101                 // Ring of all partitions
 102                 $this->partitionRing = new HashRing( $partitionMap );
 103         }
 104
 105         protected function supportedOrders() {
 106                 // No FIFO due to partitioning, though "rough timestamp order" is supported
 107                 return [ 'undefined', 'random', 'timestamp' ];
 108         }
 109
 110         protected function optimalOrder() {
 111                 return 'undefined'; // defer to the partitions
 112         }
 113
 114         protected function supportsDelayedJobs() {
 115                 foreach ( $this->partitionQueues as $queue ) {
 116                         if ( !$queue->supportsDelayedJobs() ) {
 117                                 return false;
 118                         }
 119                 }
 120
 121                 return true;
 122         }
 123
 124         protected function doIsEmpty() {
 125                 $empty = true;
 126                 $failed = 0;
 127                 foreach ( $this->partitionQueues as $queue ) {
 128                         try {
 129                                 $empty = $empty && $queue->doIsEmpty();
 130                         } catch ( JobQueueError $e ) {
 131                                 ++$failed;
 132                                 $this->logException( $e );
 133                         }
 134                 }
 135                 $this->throwErrorIfAllPartitionsDown( $failed );
 136
 137                 return $empty;
 138         }
 139
 140         protected function doGetSize() {
 141                 return $this->getCrossPartitionSum( 'size', 'doGetSize' );
 142         }
 143
 144         protected function doGetAcquiredCount() {
 145                 return $this->getCrossPartitionSum( 'acquiredcount', 'doGetAcquiredCount' );
 146         }
 147
 148         protected function doGetDelayedCount() {
 149                 return $this->getCrossPartitionSum( 'delayedcount', 'doGetDelayedCount' );
 150         }
 151
 152         protected function doGetAbandonedCount() {
 153                 return $this->getCrossPartitionSum( 'abandonedcount', 'doGetAbandonedCount' );
 154         }
 155
 156         /**
 157          * @param string $type
 158          * @param string $method
 159          * @return int
 160          */
 161         protected function getCrossPartitionSum( $type, $method ) {
 162                 $count = 0;
 163                 $failed = 0;
 164                 foreach ( $this->partitionQueues as $queue ) {
 165                         try {
 166                                 $count += $queue->$method();
 167                         } catch ( JobQueueError $e ) {
 168                                 ++$failed;
 169                                 $this->logException( $e );
 170                         }
 171                 }
 172                 $this->throwErrorIfAllPartitionsDown( $failed );
 173
 174                 return $count;
 175         }
 176
 177         protected function doBatchPush( array $jobs, $flags ) {
 178                 // Local ring variable that may be changed to point to a new ring on failure
 179                 $partitionRing = $this->partitionRing;
 180                 // Try to insert the jobs and update $partitionsTry on any failures.
 181                 // Retry to insert any remaning jobs again, ignoring the bad partitions.
 182                 $jobsLeft = $jobs;
 183                 for ( $i = $this->maxPartitionsTry; $i > 0 && count( $jobsLeft ); --$i ) {
 184                         try {
 185                                 $partitionRing->getLiveLocationWeights();
 186                         } catch ( UnexpectedValueException $e ) {
 187                                 break; // all servers down; nothing to insert to
 188                         }
 189                         $jobsLeft = $this->tryJobInsertions( $jobsLeft, $partitionRing, $flags );
 190                 }
 191                 if ( count( $jobsLeft ) ) {
 192                         throw new JobQueueError(
 193                                 "Could not insert job(s), {$this->maxPartitionsTry} partitions tried." );
 194                 }
 195         }
 196
 197         /**
 198          * @param array $jobs
 199          * @param HashRing &$partitionRing
 200          * @param int $flags
 201          * @throws JobQueueError
 202          * @return array List of Job object that could not be inserted
 203          */
 204         protected function tryJobInsertions( array $jobs, HashRing &$partitionRing, $flags ) {
 205                 $jobsLeft = [];
 206
 207                 // Because jobs are spread across partitions, per-job de-duplication needs
 208                 // to use a consistent hash to avoid allowing duplicate jobs per partition.
 209                 // When inserting a batch of de-duplicated jobs, QOS_ATOMIC is disregarded.
 210                 $uJobsByPartition = []; // (partition name => job list)
 211                 /** @var Job $job */
 212                 foreach ( $jobs as $key => $job ) {
 213                         if ( $job->ignoreDuplicates() ) {
 214                                 $sha1 = sha1( serialize( $job->getDeduplicationInfo() ) );
 215                                 $uJobsByPartition[$partitionRing->getLiveLocation( $sha1 )][] = $job;
 216                                 unset( $jobs[$key] );
 217                         }
 218                 }
 219                 // Get the batches of jobs that are not de-duplicated
 220                 if ( $flags & self::QOS_ATOMIC ) {
 221                         $nuJobBatches = [ $jobs ]; // all or nothing
 222                 } else {
 223                         // Split the jobs into batches and spread them out over servers if there
 224                         // are many jobs. This helps keep the partitions even. Otherwise, send all
 225                         // the jobs to a single partition queue to avoids the extra connections.
 226                         $nuJobBatches = array_chunk( $jobs, 300 );
 227                 }
 228
 229                 // Insert the de-duplicated jobs into the queues...
 230                 foreach ( $uJobsByPartition as $partition => $jobBatch ) {
 231                         /** @var JobQueue $queue */
 232                         $queue = $this->partitionQueues[$partition];
 233                         try {
 234                                 $ok = true;
 235                                 $queue->doBatchPush( $jobBatch, $flags | self::QOS_ATOMIC );
 236                         } catch ( JobQueueError $e ) {
 237                                 $ok = false;
 238                                 $this->logException( $e );
 239                         }
 240                         if ( !$ok ) {
 241                                 if ( !$partitionRing->ejectFromLiveRing( $partition, 5 ) ) { // blacklist
 242                                         throw new JobQueueError( "Could not insert job(s), no partitions available." );
 243                                 }
 244                                 $jobsLeft = array_merge( $jobsLeft, $jobBatch ); // not inserted
 245                         }
 246                 }
 247
 248                 // Insert the jobs that are not de-duplicated into the queues...
 249                 foreach ( $nuJobBatches as $jobBatch ) {
 250                         $partition = ArrayUtils::pickRandom( $partitionRing->getLiveLocationWeights() );
 251                         $queue = $this->partitionQueues[$partition];
 252                         try {
 253                                 $ok = true;
 254                                 $queue->doBatchPush( $jobBatch, $flags | self::QOS_ATOMIC );
 255                         } catch ( JobQueueError $e ) {
 256                                 $ok = false;
 257                                 $this->logException( $e );
 258                         }
 259                         if ( !$ok ) {
 260                                 if ( !$partitionRing->ejectFromLiveRing( $partition, 5 ) ) { // blacklist
 261                                         throw new JobQueueError( "Could not insert job(s), no partitions available." );
 262                                 }
 263                                 $jobsLeft = array_merge( $jobsLeft, $jobBatch ); // not inserted
 264                         }
 265                 }
 266
 267                 return $jobsLeft;
 268         }
 269
 270         protected function doPop() {
 271                 $partitionsTry = $this->partitionRing->getLiveLocationWeights(); // (partition => weight)
 272
 273                 $failed = 0;
 274                 while ( count( $partitionsTry ) ) {
 275                         $partition = ArrayUtils::pickRandom( $partitionsTry );
 276                         if ( $partition === false ) {
 277                                 break; // all partitions at 0 weight
 278                         }
 279
 280                         /** @var JobQueue $queue */
 281                         $queue = $this->partitionQueues[$partition];
 282                         try {
 283                                 $job = $queue->pop();
 284                         } catch ( JobQueueError $e ) {
 285                                 ++$failed;
 286                                 $this->logException( $e );
 287                                 $job = false;
 288                         }
 289                         if ( $job ) {
 290                                 $job->setMetadata( 'QueuePartition', $partition );
 291
 292                                 return $job;
 293                         } else {
 294                                 unset( $partitionsTry[$partition] ); // blacklist partition
 295                         }
 296                 }
 297                 $this->throwErrorIfAllPartitionsDown( $failed );
 298
 299                 return false;
 300         }
 301
 302         protected function doAck( Job $job ) {
 303                 $partition = $job->getMetadata( 'QueuePartition' );
 304                 if ( $partition === null ) {
 305                         throw new MWException( "The given job has no defined partition name." );
 306                 }
 307
 308                 $this->partitionQueues[$partition]->ack( $job );
 309         }
 310
 311         protected function doIsRootJobOldDuplicate( Job $job ) {
 312                 $signature = $job->getRootJobParams()['rootJobSignature'];
 313                 $partition = $this->partitionRing->getLiveLocation( $signature );
 314                 try {
 315                         return $this->partitionQueues[$partition]->doIsRootJobOldDuplicate( $job );
 316                 } catch ( JobQueueError $e ) {
 317                         if ( $this->partitionRing->ejectFromLiveRing( $partition, 5 ) ) {
 318                                 $partition = $this->partitionRing->getLiveLocation( $signature );
 319                                 return $this->partitionQueues[$partition]->doIsRootJobOldDuplicate( $job );
 320                         }
 321                 }
 322
 323                 return false;
 324         }
 325
 326         protected function doDeduplicateRootJob( IJobSpecification $job ) {
 327                 $signature = $job->getRootJobParams()['rootJobSignature'];
 328                 $partition = $this->partitionRing->getLiveLocation( $signature );
 329                 try {
 330                         return $this->partitionQueues[$partition]->doDeduplicateRootJob( $job );
 331                 } catch ( JobQueueError $e ) {
 332                         if ( $this->partitionRing->ejectFromLiveRing( $partition, 5 ) ) {
 333                                 $partition = $this->partitionRing->getLiveLocation( $signature );
 334                                 return $this->partitionQueues[$partition]->doDeduplicateRootJob( $job );
 335                         }
 336                 }
 337
 338                 return false;
 339         }
 340
 341         protected function doDelete() {
 342                 $failed = 0;
 343                 /** @var JobQueue $queue */
 344                 foreach ( $this->partitionQueues as $queue ) {
 345                         try {
 346                                 $queue->doDelete();
 347                         } catch ( JobQueueError $e ) {
 348                                 ++$failed;
 349                                 $this->logException( $e );
 350                         }
 351                 }
 352                 $this->throwErrorIfAllPartitionsDown( $failed );
 353                 return true;
 354         }
 355
 356         protected function doWaitForBackups() {
 357                 $failed = 0;
 358                 /** @var JobQueue $queue */
 359                 foreach ( $this->partitionQueues as $queue ) {
 360                         try {
 361                                 $queue->waitForBackups();
 362                         } catch ( JobQueueError $e ) {
 363                                 ++$failed;
 364                                 $this->logException( $e );
 365                         }
 366                 }
 367                 $this->throwErrorIfAllPartitionsDown( $failed );
 368         }
 369
 370         protected function doFlushCaches() {
 371                 /** @var JobQueue $queue */
 372                 foreach ( $this->partitionQueues as $queue ) {
 373                         $queue->doFlushCaches();
 374                 }
 375         }
 376
 377         public function getAllQueuedJobs() {
 378                 $iterator = new AppendIterator();
 379
 380                 /** @var JobQueue $queue */
 381                 foreach ( $this->partitionQueues as $queue ) {
 382                         $iterator->append( $queue->getAllQueuedJobs() );
 383                 }
 384
 385                 return $iterator;
 386         }
 387
 388         public function getAllDelayedJobs() {
 389                 $iterator = new AppendIterator();
 390
 391                 /** @var JobQueue $queue */
 392                 foreach ( $this->partitionQueues as $queue ) {
 393                         $iterator->append( $queue->getAllDelayedJobs() );
 394                 }
 395
 396                 return $iterator;
 397         }
 398
 399         public function getAllAcquiredJobs() {
 400                 $iterator = new AppendIterator();
 401
 402                 /** @var JobQueue $queue */
 403                 foreach ( $this->partitionQueues as $queue ) {
 404                         $iterator->append( $queue->getAllAcquiredJobs() );
 405                 }
 406
 407                 return $iterator;
 408         }
 409
 410         public function getAllAbandonedJobs() {
 411                 $iterator = new AppendIterator();
 412
 413                 /** @var JobQueue $queue */
 414                 foreach ( $this->partitionQueues as $queue ) {
 415                         $iterator->append( $queue->getAllAbandonedJobs() );
 416                 }
 417
 418                 return $iterator;
 419         }
 420
 421         public function getCoalesceLocationInternal() {
 422                 return "JobQueueFederated:wiki:{$this->domain}" .
 423                         sha1( serialize( array_keys( $this->partitionQueues ) ) );
 424         }
 425
 426         protected function doGetSiblingQueuesWithJobs( array $types ) {
 427                 $result = [];
 428
 429                 $failed = 0;
 430                 /** @var JobQueue $queue */
 431                 foreach ( $this->partitionQueues as $queue ) {
 432                         try {
 433                                 $nonEmpty = $queue->doGetSiblingQueuesWithJobs( $types );
 434                                 if ( is_array( $nonEmpty ) ) {
 435                                         $result = array_unique( array_merge( $result, $nonEmpty ) );
 436                                 } else {
 437                                         return null; // not supported on all partitions; bail
 438                                 }
 439                                 if ( count( $result ) == count( $types ) ) {
 440                                         break; // short-circuit
 441                                 }
 442                         } catch ( JobQueueError $e ) {
 443                                 ++$failed;
 444                                 $this->logException( $e );
 445                         }
 446                 }
 447                 $this->throwErrorIfAllPartitionsDown( $failed );
 448
 449                 return array_values( $result );
 450         }
 451
 452         protected function doGetSiblingQueueSizes( array $types ) {
 453                 $result = [];
 454                 $failed = 0;
 455                 /** @var JobQueue $queue */
 456                 foreach ( $this->partitionQueues as $queue ) {
 457                         try {
 458                                 $sizes = $queue->doGetSiblingQueueSizes( $types );
 459                                 if ( is_array( $sizes ) ) {
 460                                         foreach ( $sizes as $type => $size ) {
 461                                                 $result[$type] = isset( $result[$type] ) ? $result[$type] + $size : $size;
 462                                         }
 463                                 } else {
 464                                         return null; // not supported on all partitions; bail
 465                                 }
 466                         } catch ( JobQueueError $e ) {
 467                                 ++$failed;
 468                                 $this->logException( $e );
 469                         }
 470                 }
 471                 $this->throwErrorIfAllPartitionsDown( $failed );
 472
 473                 return $result;
 474         }
 475
 476         protected function logException( Exception $e ) {
 477                 wfDebugLog( 'JobQueueFederated', $e->getMessage() . "\n" . $e->getTraceAsString() );
 478         }
 479
 480         /**
 481          * Throw an error if no partitions available
 482          *
 483          * @param int $down The number of up partitions down
 484          * @return void
 485          * @throws JobQueueError
 486          */
 487         protected function throwErrorIfAllPartitionsDown( $down ) {
 488                 if ( $down >= count( $this->partitionQueues ) ) {
 489                         throw new JobQueueError( 'No queue partitions available.' );
 490                 }
 491         }
 492 }