Pheanstalk::deleteTube() - Code Metrics - Inspection of "* Remove Old Job Class" - PyRowMan/pheanstalk - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Branch — master (450f26)

by Valentin
created 2019-07-30 10:33 UTC
Pheanstalk::deleteTube() A

↳ Parent: Pheanstalk
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	2
CRAP Score	1
Importance

Changes
Metric	Value
eloc	1
c	0
b	0
f	0
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
cc	1
nc	1
nop	1
crap	1
<?php

namespace Pheanstalk;

use Doctrine\Common\Collections\ArrayCollection;
use Pheanstalk\Command\CreateCommand;
use Pheanstalk\Command\CreateScheduleCommand;
use Pheanstalk\Command\CreateTubeCommand;
use Pheanstalk\Command\GetWorkflowCommand;
use Pheanstalk\Command\GetWorkflowInstancesCommand;
use Pheanstalk\Command\GetWorkflowInstancesDetailCommand;
use Pheanstalk\Command\ListWorkflowsCommand;
use Pheanstalk\Command\ReleaseCommand;
filter:
    dependency_paths: ["lib/*"]
use Pheanstalk\Command\UpdateTubeCommand;
use Pheanstalk\Command\WorkflowExistsCommand;
use Pheanstalk\Exception\ServerDuplicateEntryException;
use Pheanstalk\Structure\Job;
use Pheanstalk\Structure\Task;
use Pheanstalk\Structure\TaskInstance;
use Pheanstalk\Structure\TimeSchedule;
use Pheanstalk\Structure\Tube;
use Pheanstalk\Structure\Workflow;
use Pheanstalk\Structure\WorkflowInstance;

/**
 * Pheanstalk is a PHP client for the beanstalkd workqueue.
 *
 * The Pheanstalk class is a simple facade for the various underlying components.
 *
 * @see http://github.com/kr/beanstalkd
 * @see http://xph.us/software/beanstalkd/
 *
 * @author  Paul Annesley
 * @package Pheanstalk
 * @license http://www.opensource.org/licenses/mit-license.php
 */
class Pheanstalk implements PheanstalkInterface
{

    /** @var Connection $connection */
    private $connection;

    /** @var $currentClass PheanstalkInterface */

    private $currentClass;

    /**
     * @param string $host
     * @param string $user
     * @param string $password
     * @param int    $port
     * @param int    $connectTimeout
     * @param bool   $connectPersistent
     */
    public function __construct($host, $user = null, $password = null, $port = PheanstalkInterface::DEFAULT_PORT, $connectTimeout = null, $connectPersistent = false)
    {
        $this->setConnection(new Connection($host, $user, $password, $port, $connectTimeout, $connectPersistent));
    }

    /**
     * {@inheritdoc}
     */
    public function setConnection(Connection $connection)
    {
        $this->connection = $connection;

        return $this;
    }

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

    /**
     * @return PheanstalkInterface
     */
    public function getCurrentClass(): PheanstalkInterface
    {
        return $this->currentClass ?? $this;
    }

    /**
     * @param PheanstalkInterface $currentClass
     *
     * @return Pheanstalk
     */
    public function setCurrentClass(PheanstalkInterface $currentClass): PheanstalkInterface
    {
        $this->currentClass = $currentClass;
        return $this;
    }

    // ----------------------------------------

    /**
     * {@inheritdoc}
     */
    public function delete(Workflow $workflow)
    {
        return $this->_dispatch(new Command\DeleteCommand($workflow));
    }

    /**
     * {@inheritdoc}
     */
    public function deleteTube(Tube $tube)
    {
        return $this->_dispatch(new Command\DeleteTubeCommand($tube));
    }

    /**
     * {@inheritdoc}
     */
    public function workflowExists($name)
    {
        $workflow = $this->_dispatch(new Command\WorkflowExistsCommand($name));
        if ($workflow instanceof Workflow) {
            return $this->getCurrentClass()->getWorkflow($workflow);
        }
        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function getWorkflow(Workflow $workflow)
    {
        return $this->_dispatch(new Command\GetWorkflowCommand($workflow));
    }

    /**
     * {@inheritdoc}
     */
    public function getWorkflowInstances(?Workflow $workflow, string $status = null)
    {
        $status = empty($status) ? GetWorkflowInstancesDetailCommand::FILTERS : [$status];
        $instances = new ArrayCollection([]);
        foreach ($status as $stat) {
            $instances[strtolower($stat)] = $this->_dispatch(new Command\GetWorkflowInstancesCommand($workflow, $stat));
//            if ($stat === GetWorkflowInstancesCommand::FILTER_EXECUTING) {
                /** @var ArrayCollection $workflowCollection */
                $workflowCollection = $instances[strtolower($stat)]->get('workflow_instances');
                $workflowCollection = $instances[strtolower($stat)]->get('workflow_instances');
            if (!empty($workflowCollection)) {
                foreach ($workflowCollection as $instance) {
                    $this->getCurrentClass()->getWorkflowInstancesDetails($instance);
                }
            }
//            }
        }

        return $instances;
    }

    /**
     * {@inheritdoc}
     */
    public function getWorkflowInstancesDetails(WorkflowInstance $workflowInstance)
    {
        return $this->_dispatch(new Command\GetWorkflowInstancesDetailCommand($workflowInstance));
    }

    /**
     * {@inheritdoc}
     */
    public function tubeExists($name)
    {
        return $this->_dispatch(new Command\TubeExistsCommand($name));
    }

    /**
     * {@inheritdoc}
     */
    public function listTubes()
    {
        return $this->_dispatch(new Command\ListTubesCommand());
    }

    /**
     * {@inheritdoc}
     */
    public function peek()
    {
        $response = $this->_dispatch(new Command\PeekCommand());

        return $response;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**
     * {@inheritdoc}
     */
    public function put(Workflow $workflow)
    {
        $response = $this->_dispatch(new Command\PutCommand($workflow));

        return $response['workflow-instance-id'];
    }

    /**
     * {@inheritdoc}
     */
    public function statsJob($job)
    {
        return $this->_dispatch(new Command\StatsJobCommand($job));
filter:
    dependency_paths: ["lib/*"]
    }

    /**
     * {@inheritdoc}
     */
    public function statsTube($tube)
    {
        return $this->_dispatch(new Command\StatsTubeCommand($tube));
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**
     * {@inheritdoc}
     */
    public function stats()
    {
        return $this->_dispatch(new Command\StatsCommand());
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    // ----------------------------------------

    /**
     * Dispatches the specified command to the connection object.
     *
     * If a SocketException occurs, the connection is reset, and the command is
     * re-attempted once.
     *
     * @throws Exception\ClientException
     * @param Command $command
     *
     * @return mixed
     */
    private function _dispatch($command)
    {
        return $this->connection->dispatchCommand($command);
    }

    /**
     * {@inheritdoc}
     */
    public function create(Workflow $workflow, $force = false): Workflow
    {
        try {
            $tubes = [];
            /** @var Job $job */
            foreach ($workflow->getJobs() as $job) {
                /** @var Task $task */
                foreach ($job->getTasks() as $task) {
                    $tubes = array_merge($tubes, [$task->getQueue()]);
                }
            }
            foreach ($tubes as $tube) {
                if (!$this->getCurrentClass()->tubeExists($tube)) {
                    $this->getCurrentClass()->createTube(new Tube($tube, 1));
                };
            }
            $workflow = $this->_dispatch(new Command\CreateCommand($workflow));
        } catch (ServerDuplicateEntryException $e) {
            if ($force) {
                $workflows = $this->_dispatch(new Command\ListWorkflowsCommand());
                $workflowToDelete = $workflows->filter(function(Workflow $listedWorkflow) use ($workflow) {

                    return $listedWorkflow->getName() === $workflow->getName()
                        && $listedWorkflow->getGroup() === $workflow->getGroup();
                })->first();
                $this->getCurrentClass()->delete($workflowToDelete);

                return $this->getCurrentClass()->create($workflow);
            }
            throw $e;
        }

        return $workflow;
    }

    /**
     * {@inheritdoc}
     */
    public function update(Workflow $workflow): Workflow
    {
        $workflow = $this->_dispatch(new Command\UpdateCommand($workflow));
        return $workflow;
    }

    /**
     * {@inheritdoc}
     */
    public function createSchedule(Workflow $workflow, TimeSchedule $schedule, $onFailure = CreateScheduleCommand::FAILURE_TYPE_CONTINUE, $active = true, $comment = null)
    {
        $workflowSchedule = $this->_dispatch(
            new Command\CreateScheduleCommand($workflow, $schedule, $onFailure, $active, $comment)
        );
        return $workflowSchedule;
    }

    /**
     * {@inheritdoc}
     */
    public function createTask(string $name, string $group, string $path, $queue = 'default', $useAgent = false, $user = null, $host = null, $comment = null): Workflow
    {
        $task = new Task($path, $queue, $useAgent, $user, $host);
        $job = new Job(new ArrayCollection([$task]));
        $workflow = new Workflow($name, $group, new ArrayCollection([$job]), $comment);

        return $this->getCurrentClass()->create($workflow, true);
    }

    /**
     * {@inheritDoc}
     */
    public function createTube(Tube $tube): Tube
    {
        return $this->_dispatch(new Command\CreateTubeCommand($tube));
    }

    /**
     * {@inheritdoc}
     */
    public function updateTube(Tube $tube): Tube
    {
        return $this->_dispatch(new Command\UpdateTubeCommand($tube));
    }

    /**
     * {@inheritdoc}
     */
    public function cancel(WorkflowInstance $workflowInstance)
    {
        return $this->_dispatch(new Command\CancelCommand($workflowInstance));
    }

    /**
     * {@inheritdoc}
     */
    public function kill(WorkflowInstance $workflowInstance, TaskInstance $taskInstance)
    {
        return $this->_dispatch(new Command\KillCommand($workflowInstance, $taskInstance));
    }
}

PyRowMan / pheanstalk

Branch — master (450f26)

Pheanstalk::deleteTube() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
