Stu\Module\Control\SemaphoreUtil

Complexity

Total Complexity

22

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Test Coverage

Coverage

26.53%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	releaseSemaphore()	0	8	3
A	acquireSemaphore()	0	17	3
A	getSemaphore()	0	14	2
A	__construct()	0	1	1
A	reset()	0	3	1
A	isSemaphoreUsageActive()	0	3	1
A	release()	0	18	5
A	isSemaphoreAlreadyAcquired()	0	4	1
A	acquire()	0	4	2
A	releaseAllSemaphores()	0	9	3

<?php

namespace Stu\Module\Control;

use Override;

The type Override was not found. Maybe you did not declare it correctly or list all dependencies?

use Stu\Component\Game\SemaphoreConstants;

The type Stu\Component\Game\SemaphoreConstants was not found. Maybe you did not declare it correctly or list all dependencies?

use Stu\Exception\SemaphoreException;
use Stu\Module\Config\StuConfigInterface;
use Stu\Module\Logging\LogTypeEnum;
use Stu\Module\Logging\StuLogger;
use SysvSemaphore;

final class SemaphoreUtil implements SemaphoreUtilInterface
{
    /** @var array<int, SysvSemaphore> */
    public static array $semaphores = [];

    public function __construct(private readonly StuConfigInterface $stuConfig) {}

    #[Override]
    public function isSemaphoreAlreadyAcquired(int $key): bool
    {
        return array_key_exists($key, self::$semaphores);
    }

    #[Override]
    public function acquireSemaphore(int $key): null|int|SysvSemaphore
    {
        if (!$this->isSemaphoreUsageActive()) {
            return null;
        }

        $semaphore = $this->getSemaphore($key);

        if ($this->isSemaphoreAlreadyAcquired($key)) {
            return null;
        }

        $this->acquire($semaphore);
        self::$semaphores[$key] = $semaphore;

        return $semaphore;
    }

    private function getSemaphore(int $key): SysvSemaphore
    {
        $semaphore = sem_get(
            $key,
            1,
            0o666,
            SemaphoreConstants::AUTO_RELEASE_SEMAPHORES
        );

        if ($semaphore === false) {
            throw new SemaphoreException('Error getting semaphore');
        }

        return $semaphore;

The expression return $semaphore could return the type resource which is incompatible with the type-hinted return SysvSemaphore. Consider adding an additional type-check to rule them out.

    }

    private function acquire(SysvSemaphore $semaphore): void
    {
        if (!sem_acquire($semaphore)) {
            throw new SemaphoreException("Error acquiring Semaphore!");
        }
    }

    #[Override]
    public function releaseSemaphore(null|int|SysvSemaphore $semaphore, bool $doRemove = false): void
    {
        if (!$this->isSemaphoreUsageActive() || !$semaphore instanceof SysvSemaphore) {
            return;
        }

        $this->release($semaphore, $doRemove);
    }

    #[Override]
    public function releaseAllSemaphores(bool $doRemove = false): void
    {
        if (!$this->isSemaphoreUsageActive()) {
            return;
        }

        foreach (self::$semaphores as $semaphore) {
            $this->release($semaphore, $doRemove);
        }
    }

    private function release(SysvSemaphore $semaphore, bool $doRemove): void
    {
        $key = array_search($semaphore, self::$semaphores, true);
        if ($key === false) {
            return;
        }
        unset(self::$semaphores[$key]);

        if (!sem_release($semaphore)) {
            StuLogger::log(sprintf("Error releasing Semaphore with key %d!", $key), LogTypeEnum::SEMAPHORE);
            return;
            //throw new SemaphoreException("Error releasing Semaphore!");
        } else {
            StuLogger::log(sprintf('  Released semaphore %d', $key), LogTypeEnum::SEMAPHORE);
        }

        if ($doRemove && !sem_remove($semaphore)) {
            StuLogger::log(sprintf("Error removing Semaphore with key %d!", $key), LogTypeEnum::SEMAPHORE);
            //throw new SemaphoreException("Error removing Semaphore!");
        }
    }

    private function isSemaphoreUsageActive(): bool
    {
        return $this->stuConfig->getGameSettings()->useSemaphores();
    }

    public static function reset(): void
    {
        self::$semaphores = [];
    }
}