Acamposm\Ping\Parsers\PingParserForLinux

Complexity

Total Complexity

26

Size/Duplication

Total Lines	212
Duplicated Lines	0 %

Importance

Changes	3
Bugs	1	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	cleanStatisticsRecord()	0	10	1
A	__construct()	0	14	2
A	parse()	0	21	4
A	parseStatistics()	0	25	5
A	setStatistics()	0	3	1
A	getSequence()	0	26	3
A	parseRoundTripTime()	0	15	2
A	getHostStatus()	0	3	2
A	setRoundTripTime()	0	3	1
A	setSequence()	0	3	1
A	setHostStatus()	0	3	1
A	isUnreachable()	0	11	3

<?php

namespace Acamposm\Ping\Parsers;

use Acamposm\Ping\Interfaces\PingParserInterface;

final class PingParserForLinux extends PingParser implements PingParserInterface
{
    protected bool $is_unreachable;

    /**
     * PingParserForLinux constructor.
     *
     * @param array $ping
     */
    public function __construct(array $ping)
    {
        parent::__construct($ping);

        $this->is_unreachable = self::isUnreachable($ping);

The method Acamposm\Ping\Parsers\PingParserForLinux::isUnreachable() is not static, but was called statically.

        $this->host_status = 'Unreachable';

        $this->setStatistics($ping[count($ping) - 2]);

        if ($this->is_unreachable === false) {
            $this->setRoundTripTime($ping[count($ping) - 1]);
            $this->setSequence();
            $this->setHostStatus();
        }
    }

    private function cleanStatisticsRecord(string $row): array
    {
        $search = explode(
            '|',
            'packets|transmitted|received|+|errors|%|packet|loss|time|ms'
        );

        $row = trim(str_replace($search, null, $row));

        return array_map('trim', explode(', ', $row));
    }

    private function isUnreachable($ping)
    {
        $unreachable = false;

        foreach($ping as $row) {
            if ($unreachable = strpos($row, '100% packet loss')) {
                break;
            }
        }

        return $unreachable !== false;
    }

    /**
     * Get the host status.
     *
     * @return string
     */
    private function getHostStatus(): string
    {
        return ($this->statistics['packet_loss'] < 100) ? 'Ok' : 'Unreachable';
    }

    /**
     * Return an array with the Ping sequence and latency.
     *
     * @return array
     */
    private function getSequence(): array
    {
        $ping = $this->raw;

        // Remove unnecessary index
        unset($ping[0]);
        unset($ping[count($ping) - 4]);
        unset($ping[count($ping) - 3]);
        unset($ping[count($ping) - 2]);
        unset($ping[count($ping) - 1]);

        $sequence = [];

        foreach ($ping as $row) {
            if (strpos('Unreachable', $row) !== false) {
                $data = explode(': ', str_replace(' ms', '', $row));
                $items = explode(' ', $data[1]);

                $key = (int) explode('=', $items[0])[1];
                $value = (float) explode('=', $items[2])[1];

                $sequence[$key] = $value;
            }
        }

        return $sequence;
    }

    /**
     * Return an object with Ping Round Trip Time.
     *
     * @param string $row
     * @return array
     */
    private function parseRoundTripTime(string $row): array
    {
        if (strpos($row, 'rtt') === false) {
            return [];
        }

        $row = trim(str_replace(['ms', 'rtt'], null, $row));

        $rtt = explode(' = ', $row);

        $keys = explode('/', $rtt[0]);

        $values = array_map('floatval', explode('/', $rtt[1]));

        return array_combine($keys, $values);

The expression return array_combine($keys, $values) could return the type false which is incompatible with the type-hinted return array. Consider adding an additional type-check to rule them out.

    }

    /**
     * Return an object with Ping Statistics.
     *
     * @param string $row
     * @return array
     */
    private function parseStatistics(string $row): array
    {
        $statistics = self::cleanStatisticsRecord($row);

The method Acamposm\Ping\Parsers\PingParserForLinux::cleanStatisticsRecord() is not static, but was called statically.

        $results = [
            'packets_transmitted' => (int) $statistics[0],
            'packets_received' => (int) $statistics[1],
            'packets_lost' => (int) ($statistics[0] - $statistics[1]),
        ];

        if (count($statistics) === 5 && $this->is_unreachable) {
            $results['errors'] = (int) $statistics[2];
        }

        if (count($statistics) === 5) {
            $results['packet_loss'] = (float) $statistics[3];
            $results['time'] = (int) $statistics[4];
        }

        if (count($statistics) === 4) {
            $results['packet_loss'] = (float) $statistics[2];
            $results['time'] = (int) $statistics[3];
        }

        return $results;
    }

    /**
     * Set the host status.
     */
    private function setHostStatus(): void
    {
        $this->host_status = $this->getHostStatus();
    }

    /**
     * Set the Round Trip Time statistics.
     *
     * @param string $rtt
     */
    private function setRoundTripTime(string $rtt): void
    {
        $this->round_trip_time = $this->parseRoundTripTime($rtt);
    }

    /**
     * Set the Ping sequence.
     */
    private function setSequence(): void
    {
        $this->sequence = $this->getSequence();
    }

    /**
     * Set the Statistics.
     *
     * @param string $statistics
     */
    private function setStatistics(string $statistics): void
    {
        $this->statistics = $this->parseStatistics($statistics);
    }

    /**
     * Return the Ping execution result parsed as object.
     *
     * @return object
     */
    public function parse(): object
    {
        $parsed = [
            'host_status' => $this->host_status,
            'raw' => (object) $this->raw,
        ];

        if (count($this->round_trip_time) > 0) {
            $parsed['latency'] = $this->round_trip_time['avg'];
            $parsed['rtt'] = (object) $this->round_trip_time;
        }

        if (count($this->sequence) > 0) {
            $parsed['sequence'] = (object) $this->sequence;
        }

        if (count($this->statistics) > 0) {
            $parsed['statistics'] = (object) $this->statistics;
        }

        return (object) $parsed;
    }
}