class RuntimeMeasurementTracker in Purge 8.3

Provides the tracker that tracks RuntimeMeasurement objects for purgers.

This tracker creates RuntimeMeasurement counters for purgers that return TRUE on their ::hasRuntimeMeasurement() implementation. When the counter objects attempt to store a new measurement value, this tracker will store the values for all counters in the underlying storing mechanism.

Hierarchy

• class \Drupal\purge\Plugin\Purge\Purger\RuntimeMeasurementTracker implements RuntimeMeasurementTrackerInterface

1 string reference to 'RuntimeMeasurementTracker'

purge.services.yml in ./purge.services.yml

purge.services.yml

1 service uses RuntimeMeasurementTracker

purge.purgers.tracker.runtime_measurement in ./purge.services.yml

Drupal\purge\Plugin\Purge\Purger\RuntimeMeasurementTracker

File

src/Plugin/Purge/Purger/RuntimeMeasurementTracker.php, line 15

Namespace

Drupal\purge\Plugin\Purge\Purger

class RuntimeMeasurementTracker implements RuntimeMeasurementTrackerInterface {

  /**
   * Key-value buffer with changed state variables that need to be saved.
   *
   * @var float[]
   */
  protected $buffer = [];

  /**
   * Holds all loaded purgers plugins.
   *
   * @var \Drupal\purge\Plugin\Purge\Purger\PurgerInterface[]
   */
  protected $purgers = NULL;

  /**
   * The state key value store.
   *
   * @var \Drupal\Core\State\StateInterface
   */
  protected $state;

  /**
   * Mapping of purger IDs and state key names.
   *
   * @var string[]
   */
  protected $stateKeys = [];

  /**
   * Construct a RuntimeMeasurementTracker.
   *
   * @param \Drupal\Core\State\StateInterface $state
   *   The state key value store.
   */
  public function __construct(StateInterface $state) {
    $this->state = $state;
  }

  /**
   * Intialize or reinitialize the counter objects.
   *
   * @throws \LogicException
   *   Thrown when $this->purgers isn't initialized.
   */
  protected function initializeCounters() {
    if (is_null($this->purgers)) {
      throw new \LogicException('$this->purgers is still NULL, call ::setPurgers.');
    }

    // Generate state keys for participating purger plugins.
    $this->stateKeys = [];
    foreach ($this->purgers as $purger) {
      if ($purger
        ->hasRuntimeMeasurement()) {
        $id = $purger
          ->getId();
        $this->stateKeys[$id] = 'purge_purger_measurement_' . $id;
      }
    }

    // Prefetch counter values, instantiate and then associate counter objects.
    if (count($this->stateKeys)) {
      $values = $this->state
        ->getMultiple($this->stateKeys);
      foreach ($this->stateKeys as $id => $key) {
        if (isset($this->buffer[$key])) {
          $values[$key] = $this->buffer[$key];
        }
        if (!isset($values[$key])) {
          $values[$key] = 0.0;
        }

        // Instantiate (or overwrite) the counter objects and pass a closure as
        // write callback. The closure writes changed values to $this->buffer.
        $measurement = new RuntimeMeasurement($values[$key]);
        $measurement
          ->disableDecrement();
        $measurement
          ->disableIncrement();
        $measurement
          ->setWriteCallback(function ($value) use ($key) {
          $this->buffer[$key] = $value;
        });

        // To start and stop measurement, PurgersServiceInterface::invalidate()
        // needs to access ::start() and ::stop(), so we need to add the counter
        // to the purger. Once ::invalidate() did its work, this will lead to
        // calls to ::setDirectly() within the counter and this in fact, will
        // lead back here as that calls our write callback.
        $this->purgers[$id]
          ->setRuntimeMeasurement($measurement);
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function destruct() {

    // When the buffer contains changes, write them to the state API in one go.
    if (count($this->buffer)) {
      $this->state
        ->setMultiple($this->buffer);
      $this->buffer = [];
    }
  }

  /**
   * {@inheritdoc}
   */
  public function setPurgers(array $purgers) {
    $this->purgers = $purgers;
    $this
      ->initializeCounters();
  }

}

Members

Name	Modifiers	Type	Description	Overrides
RuntimeMeasurementTracker::$buffer	protected	property	Key-value buffer with changed state variables that need to be saved.
RuntimeMeasurementTracker::$purgers	protected	property	Holds all loaded purgers plugins.
RuntimeMeasurementTracker::$state	protected	property	The state key value store.
RuntimeMeasurementTracker::$stateKeys	protected	property	Mapping of purger IDs and state key names.
RuntimeMeasurementTracker::destruct	public	function	Performs destruct operations. Overrides DestructableInterface::destruct
RuntimeMeasurementTracker::initializeCounters	protected	function	Intialize or reinitialize the counter objects.
RuntimeMeasurementTracker::setPurgers	public	function	Set all purger plugin instances. Overrides RuntimeMeasurementTrackerInterface::setPurgers
RuntimeMeasurementTracker::__construct	public	function	Construct a RuntimeMeasurementTracker.