PingParserForLinux::cleanStatisticsRecord() - Code Metrics - Inspection of "Added a method to detect host unreachable state an..." - angelcamposm/ping - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( ced321...095989 )

by Angel

created 2020-09-27 16:50 UTC

PingParserForLinux::cleanStatisticsRecord() A

↳ Parent: PingParserForLinux

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	5
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	10
rs	10

<?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);
        $this->is_unreachable = self::isUnreachable($ping);

        $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);

    }

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

        $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;
    }
}


angelcamposm / ping

Push — master ( ced321...095989 )

PingParserForLinux::cleanStatisticsRecord() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like