ServerService::query() - Code Metrics - Inspection of "Catch GameQ exeption for server query" - et-nik/gameap - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — develop ( cc9ef0...90d515 )

by Nikita
created 2020-05-06 23:16 UTC
ServerService::query() B

↳ Parent: ServerService
Complexity

Conditions	6
Paths	10
Size

Total Lines	37
Code Lines	24
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	18
CRAP Score	6.0359
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
eloc	24
c	2
b	0
f	0
dl	0
loc	37
ccs	18
cts	20
cp	0.9
rs	8.9137
cc	6
nc	10
nop	1
crap	6.0359
<?php

namespace Gameap\Services;

use GameQ\GameQ;
use GameQ\Exception\Server as GameqServerException;
use GameQ\Exception\Query as GameqQueryException;
use GameQ\Exception\Protocol as GameqProtocolException;
use Gameap\Models\Server;
use Knik\Gameap\GdaemonCommands;
use Html;
use Storage;
use Gameap\Exceptions\Services\InvalidCommandException;
use Gameap\Exceptions\Services\EmptyCommandException;
use Gameap\Exceptions\Services\ServerInactiveException;

class ServerService
{
    const CONSOLE_MAX_SYMBOLS = 10000;

    /**
     * @var GameQ
     */
    protected $gameq;

    /**
     * @var GdaemonCommands
     */
    protected $gdaemonCommands;

    /**
     * @var string
     */
    protected $storageDisk = 'local';

    /**
     * ServerService constructor.
     *
     * @param GameQ $gameq
     * @param GdaemonCommands $gdaemonCommands
     */
    public function __construct(GameQ $gameq, GdaemonCommands $gdaemonCommands)
    {
        $this->gameq = $gameq;
        $this->gdaemonCommands = $gdaemonCommands;
    }

    /**
     * Add default server disk
     * 
     * @param Server $server
     */
    public function registerDisk(Server $server)
    {
        foreach ($server->file_manager_disks as $diskName => $diskConfig) {
            if (empty(config("filesystems.disks.{$diskName}"))) {
                config(["filesystems.disks.{$diskName}" => $diskConfig]);
            }
        }
    }

    /**
     * @param Server $server
     * @return array|string[]
     * @throws \Exception
     */
    public function query(Server $server)
    {
        $host = "{$server->server_ip}:{$server->query_port}";

        try {
            $query = $this->gameq->setOption('timeout', 5)
                ->addServer([
                    'type' => $server->game->engine,
                    'host' => $host,
                ])
                ->process();
        } catch (GameqServerException | GameqQueryException | GameqProtocolException $exception) {
            return [
                'status' => 'query not supported for this game',
            ];
        }


        $serverResult = $query[$host] ?? null;

        if (!empty($serverResult['gq_online'])) {
            $result = [
                'status' => $serverResult['gq_online'] ? 'online' : 'offline',
                'hostname' => $serverResult['gq_hostname'],
                'map' => $serverResult['gq_mapname'],
                'players' => $serverResult['gq_numplayers'] . '/' . $serverResult['gq_maxplayers'],
                'version' => isset($serverResult['version']) ? $serverResult['version'] : null,
                'password' => $serverResult['gq_password'] ? 'yes' : 'no',
                'joinlink' => $serverResult['gq_joinlink'],
            ];
        } else {
            $result = [
                'status' => 'offline',
            ];
        }

        return $result;
    }

    /**
     * @param Server $server
     * @param string $command
     * @param array $extraData
     * @return string
     */
    public function replaceShortCodes(Server $server, string $command, array $extraData = [])
    {
        foreach ($extraData as $key => $value) {
            $command = str_replace('{' . $key . '}', $value, $command);
        }

        $replaceArray = [
            'host' => $server->server_ip,
            'port' => $server->server_port,
            'query_port' => $server->query_port,
            'rcon_port' => $server->rcon_port,
            'dir' => $server->full_path,
            'uuid' => $server->uuid,
            'uuid_short' => $server->uuid_short,
            'game' => $server->game_id,
            'user' => $server->su_user,
        ];

        foreach ($replaceArray as $key => $value) {
            $command = str_replace('{' . $key . '}', $value, $command);
        }

        return $command;
    }

    /**
     * @param Server $server
     * @param string $command
     * @param array $extraData
     * @return string
     *
     * @throws InvalidCommandException
     * @throws EmptyCommandException
     */
    public function getCommand(Server $server, string $command, array $extraData = [])
    {
        $property = 'script_' . $command;
        $attributes = $server->dedicatedServer->getAttributes();

        if (array_key_exists($property, $attributes)) {
            $script = $server->dedicatedServer->getAttribute($property);

            if (empty($script)) {
                throw new EmptyCommandException();
            }

            return $this->replaceShortCodes($server, $script, $extraData);
            return $this->replaceShortCodes($server, /** @scrutinizer ignore-type */ $script, $extraData);
        }

        throw new InvalidCommandException();
    }

    /**
     * @param Server $server
     * @return string
     */
    public function getConsoleLog(Server $server)
    {
        $this->checkServer($server);
        $this->configureGdaemon($server);

        try {
            $command = $this->getCommand($server, 'get_console');
            $result = $this->gdaemonCommands->exec($command, $exitCode);
        } catch (EmptyCommandException $e) {
            $this->registerDisk($server);
            $result = Storage::disk('server')->get('output.txt');
        }

        if (mb_strlen($result) > self::CONSOLE_MAX_SYMBOLS) {
            $result = mb_substr($result, mb_strlen($result) - self::CONSOLE_MAX_SYMBOLS, self::CONSOLE_MAX_SYMBOLS);
        }

        // Fix
        // Malformed UTF-8 characters, possibly incorrectly encoded
        $result = mb_convert_encoding($result, 'UTF-8', 'UTF-8');
        
        return $result;
    }

    /**
     * @param Server $server
     * @param string $command
     * @return bool
     */
    public function sendConsoleCommand(Server $server, string $command)
    {
        $this->checkServer($server);
        $this->configureGdaemon($server);

        try {
            $command = $this->getCommand($server, 'send_command', ['command' => $command]);
            $this->gdaemonCommands->exec($command, $exitCode);
        } catch (EmptyCommandException $e) {
            $this->registerDisk($server);
            
            if (Storage::disk('server')->put('input.txt', $command)) {
                // Success
                $exitCode = 0;
            } else {
                // Failure
                $exitCode = 1;
            }
        }

        return $exitCode === 0;
    }

    /**
     * Setting up gdaemon commands configuration
     *
     * @param Server $server
     */
    private function configureGdaemon(Server $server)
    {
        $this->gdaemonCommands->setConfig(
            $server->dedicatedServer->gdaemonSettings($this->storageDisk)
        );
    }

    /**
     * @param Server $server
     * @throws ServerInactiveException
     */
    private function checkServer(Server $server)
    {
        if ($server->processActive() === false) {
            throw new ServerInactiveException('Server is down');
        }
    }
}
et-nik / gameap

Push — develop ( cc9ef0...90d515 )

ServerService::query() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
