Spike\Client\Application

Complexity

Total Complexity

18

Size/Duplication

Total Lines	195
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	15

Importance

Changes	1
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	setKernel()	0	4	1
A	getKernel()	0	4	1
A	doRun()	0	19	2
A	doRunClient()	0	10	2
A	runClient()	0	8	2
A	getEvents()	0	9	1
A	onAuthError()	0	5	1
A	onRegisterTunnelError()	0	8	1
A	onCannotConnectToServer()	0	4	1
A	onDisconnectFromServer()	0	5	1
A	getDefaultCommands()	0	8	1
A	getSubscribers()	0	7	1
A	getDefaultInputDefinition()	0	11	1

<?php
/**
 * Spike library
 * @author Tao <taosikai@yeah.net>
 */
namespace Spike\Client;

use Slince\Event\Event;
use Spike\Application as BaseApplication;
use Slince\Event\SubscriberInterface;
use Spike\Client\Command\InitCommand;
use Spike\Client\Command\SpikeCommand;
use Spike\Client\Command\ShowProxyHostsCommand;
use Spike\Client\Subscriber\LoggerSubscriber;
use Spike\Logger\Logger;
use Symfony\Component\Console\Input\InputDefinition;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

class Application extends BaseApplication implements SubscriberInterface
{
    /**
     * @var string
     */
    const NAME = 'spike-client';

    /**
     * @var string
     */
    const VERSION = '1.0.0.dev';

    /**
     * The client instance
     * @var Client
     */
    protected $client;

    /**
     * The server address
     * @var string
     */
    protected $serverAddress;

    public function __construct(Configuration $configuration)
    {
        parent::__construct($configuration,static::NAME, static::VERSION);
        $this->client = new Client(
            $configuration->getServerAddress(),
            $configuration->getTunnels(),
            $configuration->get('auth') ?: [],
            $this->loop,
            $this->dispatcher
        );
    }

    /**
     * Sets the client for the application
     * @param Client $client
     */
    public function setKernel(Client $client)
    {
        $this->client = $client;
    }

    /**
     * Gets the client instance
     * @return Client
     */
    public function getKernel()
    {
        return $this->client;
    }

    /**
     * {@inheritdoc}
     * @codeCoverageIgnore
     */
    public function doRun(InputInterface $input, OutputInterface $output)
    {
        $this->input = $input;
        $this->output = $output;
        //Logger
        $this->logger = new Logger(
            $this->getConfiguration()->getLogLevel(),
            $this->getConfiguration()->getLogFile(),
            $this->output
        );
        $this->client->setLogger($this->logger);
        $commandName = $input->getFirstArgument();
        if ($commandName) {
            $exitCode = parent::doRun($input, $output);
        } else {
            $exitCode = $this->doRunClient();
        }
        return $exitCode;
    }

    /**
     * @codeCoverageIgnore
     */
    protected function doRunClient()
    {
        if (true === $this->input->hasParameterOption(array('--help', '-h'), true)) {
            $command = $this->get('spike');
            $exitCode = $this->doRunCommand($command, $this->input, $this->output);
        } else {
            $exitCode = $this->runClient();
        }
        return $exitCode;
    }

    /**
     * Start the client
     * @codeCoverageIgnore
     */
    protected function runClient()
    {
        foreach ($this->getSubscribers() as $subscriber) {
            $this->dispatcher->addSubscriber($subscriber);
        }
        $this->client->run();
        return 0;
    }

    /**
     * {@inheritdoc}
     */
    public function getEvents()
    {
        return [
            EventStore::CANNOT_CONNECT_TO_SERVER => 'onCannotConnectToServer',
            EventStore::AUTH_ERROR => 'onAuthError',
            EventStore::REGISTER_TUNNEL_ERROR => 'onRegisterTunnelError',
            EventStore::DISCONNECT_SERVER => 'onDisconnectFromServer'
        ];
    }

    /**
     * @codeCoverageIgnore
     */
    public function onAuthError(Event $event)

The parameter $event is not used and could be removed.

    {
        $this->output->writeln('Auth error, please checks your configuration file');
        $this->client->close();
    }

    /**
     * @codeCoverageIgnore
     */
    public function onRegisterTunnelError(Event $event)
    {
        $this->output->writeln(sprintf('Registers the tunnel "%s" error, message: %s',
            $event->getArgument('tunnel'),
            $event->getArgument('errorMessage')
        ));
        $this->client->close();
    }

    /**
     * @codeCoverageIgnore
     */
    public function onCannotConnectToServer(Event $event)

The parameter $event is not used and could be removed.

    {
        $this->client->close();
    }

    /**
     * @codeCoverageIgnore
     */
    public function onDisconnectFromServer(Event $event)

The parameter $event is not used and could be removed.

    {
        $this->output->writeln('Disconnect from the server');
        $this->client->close();
    }

    /**
     * {@inheritdoc}
     */
    public function getDefaultCommands()
    {
        return array_merge(parent::getDefaultCommands(), [

The expression return array_merge(parent::getDefaultCommands(), array(new \Spike\Client\Command\SpikeCommand($this), new \Spike\Client\Command\ShowProxyHostsCommand($this), new \Spike\Client\Command\InitCommand($this))); seems to be an array, but some of its elements' types (Spike\Client\Command\SpikeCommand|Spike\Client\Command\ShowProxyHostsCommand|Spike\Client\Command\InitCommand) are incompatible with the return type of the parent method Symfony\Component\Console\Application::getDefaultCommands of type array<Symfony\Component\Console\Command\HelpCommand|Symfony\Component\Console\Command\ListCommand>.

            new SpikeCommand($this),
            new ShowProxyHostsCommand($this),
            new InitCommand($this),
        ]);
    }

    /**
     * Gets all subscribers
     * @return array
     */
    public function getSubscribers()
    {
        return [
            $this,
            new LoggerSubscriber($this)
        ];
    }

    /**
     * {@inheritdoc}
     */
    protected function getDefaultInputDefinition()
    {
        $definition = new InputDefinition([
            new InputOption('config', null, InputOption::VALUE_OPTIONAL,
                'The configuration file, support json,ini,xml and yaml format')
        ]);
        $defaultDefinition = parent::getDefaultInputDefinition();
        $definition->addArguments($defaultDefinition->getArguments());
        $definition->addOptions($defaultDefinition->getOptions());
        return $definition;
    }
}