You are here

Home » API reference » Purge 8.3 » InvalidationBase.php

abstract class InvalidationBase in Purge 8.3

Provides base implementations for the invalidation object.

Invalidations are small value objects that describe and track invalidations on one or more external caching systems within the Purge pipeline. These objects can be directly instantiated from InvalidationsService and float freely between the QueueService and the PurgersService.

Hierarchy

Expanded class hierarchy of InvalidationBase

1 file declares its use of InvalidationBase
PluginTestBase.php in tests/src/Kernel/Invalidation/PluginTestBase.php

File

src/Plugin/Purge/Invalidation/InvalidationBase.php, line 19

Namespace

Drupal\purge\Plugin\Purge\Invalidation
View source 
abstract class InvalidationBase extends ImmutableInvalidationBase implements InvalidationInterface {

  /**
   * Constructs \Drupal\purge\Plugin\Purge\Invalidation\InvalidationBase.
   *
   * @param array $configuration
   *   A configuration array containing information about the plugin instance.
   * @param string $plugin_id
   *   The plugin_id for the plugin instance.
   * @param mixed $plugin_definition
   *   The plugin implementation definition.
   * @param int $id
   *   Unique integer ID for this object instance (during runtime).
   * @param mixed|null $expression
   *   Value - usually string - that describes the kind of invalidation, NULL
   *   when the type of invalidation doesn't require $expression. Types usually
   *   validate the given expression and throw exceptions for bad input.
   */
  public function __construct(array $configuration, $plugin_id, $plugin_definition, $id, $expression) {
    parent::__construct([], $plugin_id, $plugin_definition);
    $this->id = $id;
    $this->expression = $expression;
    $this
      ->validateExpression();
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
    return new static([], $plugin_id, $plugin_definition, $configuration['id'], $configuration['expression']);
  }

  /**
   * {@inheritdoc}
   */
  public function deleteProperty($key) {
    if (is_null($this->context)) {
      throw new \LogicException('Call ::setStateContext() before deleting properties!');
    }
    if (isset($this->properties[$this->context][$key])) {
      unset($this->properties[$this->context][$key]);
      if (empty($this->properties[$this->context])) {
        unset($this->properties[$this->context]);
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function getId() {
    return $this->id;
  }

  /**
   * {@inheritdoc}
   */
  public function removeStateContext($purger_instance_id) {
    if (!is_null($this->context)) {
      throw new \LogicException('Cannot remove a state context in purger context.');
    }
    if (!isset($this->states[$purger_instance_id])) {
      throw new \LogicException('Parameter $purger_instance_id is invalid!');
    }
    unset($this->states[$purger_instance_id]);
    unset($this->properties[$purger_instance_id]);
  }

  /**
   * {@inheritdoc}
   */
  public function setProperty($key, $value) {
    if (is_null($this->context)) {
      throw new \LogicException('Call ::setStateContext() before setting properties!');
    }
    if (!isset($this->properties[$this->context])) {
      $this->properties[$this->context] = [];
    }
    $this->properties[$this->context][$key] = $value;
  }

  /**
   * {@inheritdoc}
   */
  public function setState($state) {
    if (!is_int($state)) {
      throw new InvalidStateException('$state not an integer!');
    }
    if ($state < 0 || $state > 4) {
      throw new InvalidStateException('$state is out of range!');
    }
    if (is_null($this->context)) {
      throw new \LogicException('State cannot be set in NULL context!');
    }
    $this->states[$this->context] = $state;
  }

  /**
   * {@inheritdoc}
   */
  public function setStateContext($purger_instance_id) {
    $new_is_string = is_string($purger_instance_id);
    $new_is_null = is_null($purger_instance_id);
    if ($new_is_string && !strlen($purger_instance_id)) {
      throw new \LogicException('Parameter $purger_instance_id is empty!');
    }
    elseif (!$new_is_string && !$new_is_null) {
      throw new \LogicException('Parameter $purger_instance_id is not NULL or a non-empty string!');
    }
    elseif ($purger_instance_id === $this->context) {
      return;
    }

    // Find out if states returning from purgers are actually valid.
    $old_is_string = is_string($this->context);
    $both_strings = $old_is_string && $new_is_string;
    $transferring = $both_strings && $this->context != $purger_instance_id;
    if ($transferring || $old_is_string && $new_is_null) {
      if (!in_array($this
        ->getState(), $this->statesAfterProcessing)) {
        throw new BadPluginBehaviorException("Only NOT_SUPPORTED, PROCESSING, SUCCEEDED and FAILED are valid outbound states.");
      }
    }
    $this->context = $purger_instance_id;
  }

  /**
   * {@inheritdoc}
   */
  public function validateExpression() {
    $d = $this
      ->getPluginDefinition();
    $type = strtolower($d['label']);
    if ($d['expression_required'] && is_null($this->expression)) {
      throw new MissingExpressionException(sprintf("Argument required for %s invalidation.", $type));
    }
    elseif ($d['expression_required'] && empty($this->expression) && !$d['expression_can_be_empty']) {
      throw new InvalidExpressionException(sprintf("Argument required for %s invalidation.", $type));
    }
    elseif (!$d['expression_required'] && !is_null($this->expression)) {
      throw new InvalidExpressionException(sprintf("Argument given for %s invalidation.", $type));
    }
    elseif (!is_null($this->expression) && !is_string($this->expression) && $d['expression_must_be_string']) {
      throw new InvalidExpressionException(sprintf("String argument required for %s invalidation.", $type));
    }
  }

}

Members

Namesort descending Modifiers Type Description Overrides
DependencySerializationTrait::$_entityStorages protected property An array of entity type IDs keyed by the property name of their storages.
DependencySerializationTrait::$_serviceIds protected property An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep public function 1
DependencySerializationTrait::__wakeup public function 2
ImmutableInvalidationBase::$context protected property The instance ID of the purger that is about to process this object.
ImmutableInvalidationBase::$expression protected property Mixed expression (or NULL) that describes what needs to be invalidated. 1
ImmutableInvalidationBase::$id protected property Unique runtime ID for this instance.
ImmutableInvalidationBase::$properties protected property Purger metadata.
ImmutableInvalidationBase::$states protected property Invalidation states per purger.
ImmutableInvalidationBase::$statesAfterProcessing protected property Valid post-processing states.
ImmutableInvalidationBase::getExpression public function Get the invalidation expression. Overrides ImmutableInvalidationInterface::getExpression 1
ImmutableInvalidationBase::getProperties public function Get all stored properties. Overrides ImmutableInvalidationInterface::getProperties
ImmutableInvalidationBase::getProperty public function Retrieve a purger specific property value. Overrides ImmutableInvalidationInterface::getProperty
ImmutableInvalidationBase::getState public function Get the current or general state of the invalidation. Overrides ImmutableInvalidationInterface::getState 1
ImmutableInvalidationBase::getStateContexts public function Get all stored state contexts. Overrides ImmutableInvalidationInterface::getStateContexts
ImmutableInvalidationBase::getStates public function Get all invalidation states. Overrides ImmutableInvalidationInterface::getStates
ImmutableInvalidationBase::getStateString public function Get the current state as string. Overrides ImmutableInvalidationInterface::getStateString 1
ImmutableInvalidationBase::getStateStringTranslated public function Get the current state as user translated string. Overrides ImmutableInvalidationInterface::getStateStringTranslated
ImmutableInvalidationBase::getType public function Get the type of invalidation. Overrides ImmutableInvalidationInterface::getType
ImmutableInvalidationBase::__toString public function Return the string expression of the invalidation. Overrides ImmutableInvalidationInterface::__toString 1
InvalidationBase::create public static function Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create
InvalidationBase::deleteProperty public function Delete a purger specific property. Overrides InvalidationInterface::deleteProperty
InvalidationBase::getId public function Get the instance ID. Overrides InvalidationInterface::getId
InvalidationBase::removeStateContext public function Remove a state context from the object because the purger no longer exists. Overrides InvalidationInterface::removeStateContext
InvalidationBase::setProperty public function Set a purger specific property. Overrides InvalidationInterface::setProperty
InvalidationBase::setState public function Set the state of the invalidation. Overrides InvalidationInterface::setState
InvalidationBase::setStateContext public function Set (or reset) state context to the purger instance next in line. Overrides InvalidationInterface::setStateContext
InvalidationBase::validateExpression public function Validate the expression given to the invalidation during instantiation. Overrides InvalidationInterface::validateExpression 3
InvalidationBase::__construct public function Constructs \Drupal\purge\Plugin\Purge\Invalidation\InvalidationBase. Overrides PluginBase::__construct
InvStatesInterface::FAILED constant The invalidation failed and will be offered again later.
InvStatesInterface::FRESH constant Invalidation is new and no processing has been attempted on it yet.
InvStatesInterface::NOT_SUPPORTED constant The type of invalidation isn't supported and will be offered again later.
InvStatesInterface::PROCESSING constant The invalidation is processing.
InvStatesInterface::SUCCEEDED constant The invalidation succeeded.
MessengerTrait::$messenger protected property The messenger. 29
MessengerTrait::messenger public function Gets the messenger. 29
MessengerTrait::setMessenger public function Sets the messenger.
PluginBase::$configuration protected property Configuration information passed into the plugin. 1
PluginBase::$pluginDefinition protected property The plugin implementation definition. 1
PluginBase::$pluginId protected property The plugin_id.
PluginBase::DERIVATIVE_SEPARATOR constant A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::getBaseId public function Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface::getBaseId
PluginBase::getDerivativeId public function Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface::getDerivativeId
PluginBase::getPluginDefinition public function Gets the definition of the plugin implementation. Overrides PluginInspectionInterface::getPluginDefinition 3
PluginBase::getPluginId public function Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
PluginBase::isConfigurable public function Determines if the plugin is configurable.
StringTranslationTrait::$stringTranslation protected property The string translation service. 1
StringTranslationTrait::formatPlural protected function Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals protected function Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation protected function Gets the string translation service.
StringTranslationTrait::setStringTranslation public function Sets the string translation service to use. 2
StringTranslationTrait::t protected function Translates a string to the current language or to a given language.