CacheEventMutex.php

TLDR

The file CacheEventMutex.php is a class that implements the EventMutex interface and CacheAware interface. It provides methods for creating, checking, and clearing event mutexes using a cache store. It also has a method for specifying the cache store to be used.

Methods

create

This method attempts to obtain an event mutex for the given event. It checks if the cache store should use locks, and if so, it tries to acquire the lock on the mutex name for the specified duration. If the cache store does not use locks, it adds a new item to the cache with the mutex name as the key and true as the value for the specified duration.

exists

This method determines if an event mutex exists for the given event. It checks if the cache store should use locks, and if so, it tries to get the value of the mutex name using a callback function that returns true. If the cache store does not use locks, it checks if the cache has an item with the mutex name as the key.

forget

This method clears the event mutex for the given event. It checks if the cache store should use locks, and if so, it releases the lock on the mutex name. If the cache store does not use locks, it removes the item with the mutex name from the cache.

shouldUseLocks

This method is a protected helper method that determines if the given store should use locks for cache event mutexes. It checks if the store is an instance of LockProvider and not an instance of DynamoDbStore.

useStore

This method allows specifying the cache store that should be used. It takes a string parameter representing the store and sets the $store property of the class.

Classes

None

<?php

namespace Illuminate\Console\Scheduling;

use Illuminate\Cache\DynamoDbStore;
use Illuminate\Contracts\Cache\Factory as Cache;
use Illuminate\Contracts\Cache\LockProvider;

class CacheEventMutex implements EventMutex, CacheAware
{
    /**
     * The cache repository implementation.
     *
     * @var \Illuminate\Contracts\Cache\Factory
     */
    public $cache;

    /**
     * The cache store that should be used.
     *
     * @var string|null
     */
    public $store;

    /**
     * Create a new overlapping strategy.
     *
     * @param  \Illuminate\Contracts\Cache\Factory  $cache
     * @return void
     */
    public function __construct(Cache $cache)
    {
        $this->cache = $cache;
    }

    /**
     * Attempt to obtain an event mutex for the given event.
     *
     * @param  \Illuminate\Console\Scheduling\Event  $event
     * @return bool
     */
    public function create(Event $event)
    {
        if ($this->shouldUseLocks($this->cache->store($this->store)->getStore())) {
            return $this->cache->store($this->store)->getStore()
                ->lock($event->mutexName(), $event->expiresAt * 60)
                ->acquire();
        }

        return $this->cache->store($this->store)->add(
            $event->mutexName(), true, $event->expiresAt * 60
        );
    }

    /**
     * Determine if an event mutex exists for the given event.
     *
     * @param  \Illuminate\Console\Scheduling\Event  $event
     * @return bool
     */
    public function exists(Event $event)
    {
        if ($this->shouldUseLocks($this->cache->store($this->store)->getStore())) {
            return ! $this->cache->store($this->store)->getStore()
                ->lock($event->mutexName(), $event->expiresAt * 60)
                ->get(fn () => true);
        }

        return $this->cache->store($this->store)->has($event->mutexName());
    }

    /**
     * Clear the event mutex for the given event.
     *
     * @param  \Illuminate\Console\Scheduling\Event  $event
     * @return void
     */
    public function forget(Event $event)
    {
        if ($this->shouldUseLocks($this->cache->store($this->store)->getStore())) {
            $this->cache->store($this->store)->getStore()
                ->lock($event->mutexName(), $event->expiresAt * 60)
                ->forceRelease();

            return;
        }

        $this->cache->store($this->store)->forget($event->mutexName());
    }

    /**
     * Determine if the given store should use locks for cache event mutexes.
     *
     * @param  \Illuminate\Contracts\Cache\Store  $store
     * @return bool
     */
    protected function shouldUseLocks($store)
    {
        return $store instanceof LockProvider && ! $store instanceof DynamoDbStore;
    }

    /**
     * Specify the cache store that should be used.
     *
     * @param  string  $store
     * @return $this
     */
    public function useStore($store)
    {
        $this->store = $store;

        return $this;
    }
}