public function ZeroConfigPurger::invalidateTags in Varnish purger 8.2

Invalidate a set of tag invalidations.

See also

\Drupal\purge\Plugin\Purge\Purger\PurgerInterface::invalidate()

\Drupal\purge\Plugin\Purge\Purger\PurgerInterface::routeTypeToMethod()

File

src/Plugin/Purge/Purger/ZeroConfigPurger.php, line 260

Class

ZeroConfigPurger

A purger with minimal configuration required.

Namespace

Drupal\varnish_purger\Plugin\Purge\Purger

Code

public function invalidateTags(array $invalidations) {
  $this
    ->debug(__METHOD__);

  // Set invalidation states to PROCESSING. Detect tags with spaces in them,
  // as space is the only character Drupal core explicitly forbids in tags.
  foreach ($invalidations as $invalidation) {
    $tag = $invalidation
      ->getExpression();
    if (strpos($tag, ' ') !== FALSE) {
      $invalidation
        ->setState(InvalidationInterface::FAILED);
      $this->logger
        ->error("Tag '%tag' contains a space, this is forbidden.", [
        '%tag' => $tag,
      ]);
    }
    else {
      $invalidation
        ->setState(InvalidationInterface::PROCESSING);
    }
  }

  // Create grouped sets of 15 so that we can spread out the BAN load.
  $group = 0;
  $groups = [];
  foreach ($invalidations as $invalidation) {
    if ($invalidation
      ->getState() !== InvalidationInterface::PROCESSING) {
      continue;
    }
    if (!isset($groups[$group])) {
      $groups[$group] = [
        'tags' => [],
        [
          'objects' => [],
        ],
      ];
    }
    if (count($groups[$group]['tags']) >= self::TAGS_GROUPED_BY) {
      $group++;
    }
    $groups[$group]['objects'][] = $invalidation;
    $groups[$group]['tags'][] = $invalidation
      ->getExpression();
  }

  // Test if we have at least one group of tag(s) to purge, if not, bail.
  if (!count($groups)) {
    foreach ($invalidations as $invalidation) {
      $invalidation
        ->setState(InvalidationInterface::FAILED);
    }
    return;
  }

  // Now create requests for all groups of tags.
  $ipv4_addresses = $this
    ->getReverseProxies();
  $requests = function () use ($groups, $ipv4_addresses) {
    foreach ($groups as $group_id => $group) {
      $tags = implode(' ', $group['tags']);
      foreach ($ipv4_addresses as $ipv4) {
        (yield $group_id => function ($poolopt) use ($tags, $ipv4) {
          $opt = [
            'headers' => [
              'Cache-Tags' => $tags,
              'Accept-Encoding' => 'gzip',
            ],
          ];
          if (is_array($poolopt) && count($poolopt)) {
            $opt = array_merge($poolopt, $opt);
          }
          $uri = $this
            ->baseUri($ipv4)
            ->withPath('/tags');
          return $this->client
            ->requestAsync('BAN', $uri, $opt);
        });
      }
    }
  };

  // Execute the requests generator and retrieve the results.
  $results = $this
    ->getResultsConcurrently('invalidateTags', $requests);

  // Triage the results and set all invalidation states correspondingly.
  foreach ($groups as $group_id => $group) {
    if (!isset($results[$group_id]) || !count($results[$group_id])) {
      foreach ($group['objects'] as $invalidation) {
        $invalidation
          ->setState(InvalidationInterface::FAILED);
      }
    }
    else {
      if (in_array(FALSE, $results[$group_id])) {
        foreach ($group['objects'] as $invalidation) {
          $invalidation
            ->setState(InvalidationInterface::FAILED);
        }
      }
      else {
        foreach ($group['objects'] as $invalidation) {
          $invalidation
            ->setState(InvalidationInterface::SUCCEEDED);
        }
      }
    }
  }
  $this
    ->debug(__METHOD__);
}