You are here

Home » API reference » Purge 8.3 » MemoryQueue.php

class MemoryQueue in Purge 8.3

A QueueInterface compliant volatile memory buffer queue.

@warning This queue does not extend core's Memory queue on purpose, as it does not suit extending it very well nor does its lease time handling work.

Plugin annotation


@PurgeQueue(
  id = "memory",
  label = @Translation("Memory"),
  description = @Translation("A non-persistent, per-request memory queue (not useful on production systems)."),
)

Hierarchy

Expanded class hierarchy of MemoryQueue

3 files declare their use of MemoryQueue
AQueue.php in tests/modules/purge_queue_test/src/Plugin/Purge/Queue/AQueue.php
BQueue.php in tests/modules/purge_queue_test/src/Plugin/Purge/Queue/BQueue.php
CQueue.php in tests/modules/purge_queue_test/src/Plugin/Purge/Queue/CQueue.php

File

src/Plugin/Purge/Queue/MemoryQueue.php, line 18

Namespace

Drupal\purge\Plugin\Purge\Queue
View source 
class MemoryQueue extends QueueBase implements QueueInterface {

  /**
   * Whether the buffer has been initialized or not.
   *
   * @var bool
   */
  protected $bufferInitialized;

  /**
   * The internal buffer where all data is copied in.
   *
   * @var array[]
   */
  protected $buffer;

  /**
   * Define constants for the array indiced in our buffer.
   */
  const DATA = 0;
  const EXPIRE = 1;
  const CREATED = 2;

  /**
   * Initialize the buffer.
   */
  private function bufferInitialize() {
    if (!$this->bufferInitialized) {
      $this->bufferInitialized = TRUE;
      $this->buffer = [];
    }
  }

  /**
   * {@inheritdoc}
   */
  public function createItem($data) {
    $this
      ->bufferInitialize();
    end($this->buffer);
    $id = key($this->buffer) + 1;
    $this->buffer[$id] = [
      self::DATA => serialize($data),
      self::EXPIRE => 0,
      self::CREATED => time(),
    ];
    return $id;
  }

  /**
   * {@inheritdoc}
   */
  public function createItemMultiple(array $items) {
    $this
      ->bufferInitialize();
    end($this->buffer);
    $id = key($this->buffer) + 1;
    $ids = [];
    foreach ($items as $data) {
      $this->buffer[$id] = [
        self::DATA => serialize($data),
        self::EXPIRE => 0,
        self::CREATED => time(),
      ];
      $ids[] = $id;
      $id++;
    }
    return $ids;
  }

  /**
   * {@inheritdoc}
   */
  public function numberOfItems() {
    $this
      ->bufferInitialize();
    return count($this->buffer);
  }

  /**
   * {@inheritdoc}
   */
  public function claimItem($lease_time = 3600, $id = NULL) {
    if ($id == NULL) {
      $this
        ->bufferInitialize();
      reset($this->buffer);
      $id = key($this->buffer);
    }
    if (empty($this->buffer)) {
      return FALSE;
    }
    if (!isset($this->buffer[$id])) {
      return FALSE;
    }
    if ($this->buffer[$id][self::EXPIRE] === 0 || $this->buffer[$id][self::EXPIRE] !== 0 && time() > $this->buffer[$id][self::EXPIRE]) {
      $this->buffer[$id][self::EXPIRE] = time() + $lease_time;
      $item = new \stdClass();
      $item->item_id = $id;
      $item->data = unserialize($this->buffer[$id][self::DATA]);
      $item->expire = $this->buffer[$id][self::EXPIRE];
      $item->created = $this->buffer[$id][self::CREATED];
      return $item;
    }
    else {
      $id++;
      return $this
        ->claimItem($lease_time, $id);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function claimItemMultiple($claims = 10, $lease_time = 3600) {
    $items = [];
    for ($i = 1; $i <= $claims; $i++) {
      if (($item = $this
        ->claimItem($lease_time, NULL)) === FALSE) {
        break;
      }
      $items[] = $item;
    }
    return $items;
  }

  /**
   * {@inheritdoc}
   */
  public function releaseItem($item) {
    $this
      ->bufferInitialize();
    if (!isset($this->buffer[$item->item_id])) {
      return FALSE;
    }
    $this->buffer[$item->item_id][self::EXPIRE] = 0;
    if ($item->data !== $this->buffer[$item->item_id][self::DATA]) {
      $this->buffer[$item->item_id][self::DATA] = serialize($item->data);
    }
    return TRUE;
  }

  /**
   * {@inheritdoc}
   */
  public function releaseItemMultiple(array $items) {
    $this
      ->bufferInitialize();
    foreach ($items as $item) {
      $this
        ->releaseItem($item);
    }
    return [];
  }

  /**
   * {@inheritdoc}
   */
  public function deleteItem($item) {
    $this
      ->bufferInitialize();
    if (!isset($this->buffer[$item->item_id])) {
      return FALSE;
    }
    unset($this->buffer[$item->item_id]);
  }

  /**
   * {@inheritdoc}
   */
  public function deleteItemMultiple(array $items) {
    $this
      ->bufferInitialize();
    foreach ($items as $item) {
      $this
        ->deleteItem($item);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function createQueue() {
    $this
      ->bufferInitialize();
  }

  /**
   * {@inheritdoc}
   */
  public function deleteQueue() {
    $this
      ->bufferInitialize();
    $this->buffer = [];
  }

  /**
   * {@inheritdoc}
   */
  public function selectPage($page = 1) {
    if ($page < 1 || !is_int($page)) {
      throw new \LogicException('Parameter $page has to be a positive integer.');
    }
    $this
      ->bufferInitialize();

    // Calculate the start and end of the IDs we're looking for and iterate.
    $items = [];
    $limit = $this
      ->selectPageLimit();
    $start = ($page - 1) * $limit + 1;
    $end = $page * $limit + 1;
    for ($id = $start; $id < $end; $id++) {
      if (!isset($this->buffer[$id])) {
        break;
      }
      $item = new \stdClass();
      $item->item_id = $id;
      $item->data = unserialize($this->buffer[$id][self::DATA]);
      $item->expire = $this->buffer[$id][self::EXPIRE];
      $item->created = $this->buffer[$id][self::CREATED];
      $items[] = $item;
    }
    return $items;
  }

}

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
MemoryQueue::$buffer protected property The internal buffer where all data is copied in.
MemoryQueue::$bufferInitialized protected property Whether the buffer has been initialized or not.
MemoryQueue::bufferInitialize private function Initialize the buffer. 1
MemoryQueue::claimItem public function Claims an item in the queue for processing. Overrides QueueInterface::claimItem
MemoryQueue::claimItemMultiple public function Claims multiple items from the queue for processing. Overrides QueueBase::claimItemMultiple
MemoryQueue::CREATED constant
MemoryQueue::createItem public function Adds a queue item and store it directly to the queue. Overrides QueueInterface::createItem
MemoryQueue::createItemMultiple public function Add multiple items to the queue and store them efficiently. Overrides QueueBase::createItemMultiple
MemoryQueue::createQueue public function Creates a queue. Overrides QueueInterface::createQueue
MemoryQueue::DATA constant Define constants for the array indiced in our buffer.
MemoryQueue::deleteItem public function Deletes a finished item from the queue. Overrides QueueInterface::deleteItem
MemoryQueue::deleteItemMultiple public function Delete multiple items from the queue at once. Overrides QueueBase::deleteItemMultiple
MemoryQueue::deleteQueue public function Deletes a queue and every item in the queue. Overrides QueueInterface::deleteQueue 1
MemoryQueue::EXPIRE constant
MemoryQueue::numberOfItems public function Retrieves the number of items in the queue. Overrides QueueInterface::numberOfItems
MemoryQueue::releaseItem public function Releases an item that the worker could not process. Overrides QueueInterface::releaseItem
MemoryQueue::releaseItemMultiple public function Release multiple items that the worker could not process. Overrides QueueBase::releaseItemMultiple
MemoryQueue::selectPage public function Select a page of queue data with a limited number of items. Overrides QueueInterface::selectPage
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.
PluginBase::__construct public function Constructs a \Drupal\Component\Plugin\PluginBase object. 92
QueueBase::create public static function Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create
QueueBasePageTrait::$selectPageLimit protected property The configured limit of items on selected data pages.
QueueBasePageTrait::selectPageLimit public function
QueueBasePageTrait::selectPageMax public function
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.