SOA::setRetry() - Code Metrics - Inspection of "Merge pull request #58 from Badcow/Version3" - Badcow/DNS - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Branch — master (8940db)

by Sam
created 2019-11-30 12:27 UTC
SOA::setRetry() A

↳ Parent: SOA
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
cc	1
eloc	1
c	0
b	0
f	0
nc	1
nop	1
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
<?php

declare(strict_types=1);

/*
 * This file is part of Badcow DNS Library.
 *
 * (c) Samuel Williams <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Badcow\DNS\Rdata;

use Badcow\DNS\Parser\Tokens;

/**
 * @see https://tools.ietf.org/html/rfc1035#section-3.3.13
 */
class SOA implements RdataInterface
{
    use RdataTrait;

    const TYPE = 'SOA';
    const TYPE_CODE = 6;

    /**
     * The <domain-name> of the name server that was the
     * original or primary source of data for this zone.
     *
     * @var string|null
     */
    private $mname;

    /**
     * A <domain-name> which specifies the mailbox of the
     * person responsible for this zone.
     *
     * @var string|null
     */
    private $rname;

    /**
     * The unsigned 32 bit version number of the original copy
     * of the zone.
     *
     * @var int|null
     */
    private $serial;

    /**
     * A 32 bit time interval before the zone should be
     * refreshed.
     *
     * @var int|null
     */
    private $refresh;

    /**
     * A 32 bit time interval that should elapse before a
     * failed refresh should be retried.
     *
     * @var int|null
     */
    private $retry;

    /**
     * A 32 bit time value that specifies the upper limit on
     * the time interval that can elapse before the zone is no
     * longer authoritative.
     *
     * @var int|null
     */
    private $expire;

    /**
     * The unsigned 32 bit minimum TTL field that should be
     * exported with any RR from this zone.
     *
     * @var int|null
     */
    private $minimum;

    /**
     * @param int $expire
     */
    public function setExpire(int $expire): void
    {
        $this->expire = $expire;
    }

    /**
     * @return int
     */
    public function getExpire(): ?int
    {
        return $this->expire;
    }

    /**
     * @param int $minimum
     */
    public function setMinimum(int $minimum): void
    {
        $this->minimum = $minimum;
    }

    /**
     * @return int
     */
    public function getMinimum(): ?int
    {
        return $this->minimum;
    }

    /**
     * @param string $mname
     */
    public function setMname(string $mname): void
    {
        $this->mname = $mname;
    }

    /**
     * @return string
     */
    public function getMname(): ?string
    {
        return $this->mname;
    }

    /**
     * @param int $refresh
     */
    public function setRefresh(int $refresh): void
    {
        $this->refresh = $refresh;
    }

    /**
     * @return int
     */
    public function getRefresh(): ?int
    {
        return $this->refresh;
    }

    /**
     * @param int $retry
     */
    public function setRetry(int $retry): void
    {
        $this->retry = (int) $retry;
    }

    /**
     * @return int
     */
    public function getRetry(): ?int
    {
        return $this->retry;
    }

    /**
     * @param string $rname
     */
    public function setRname(string $rname): void
    {
        $this->rname = $rname;
    }

    /**
     * @return string
     */
    public function getRname(): ?string
    {
        return $this->rname;
    }

    /**
     * @param int $serial
     */
    public function setSerial(int $serial): void
    {
        $this->serial = $serial;
    }

    /**
     * @return int
     */
    public function getSerial(): ?int
    {
        return $this->serial;
    }

    /**
     * {@inheritdoc}
     */
    public function toText(): string
    {
        if (!isset($this->mname) ||
            !isset($this->rname) ||
            !isset($this->serial) ||
            !isset($this->refresh) ||
            !isset($this->retry) ||
            !isset($this->expire) ||
            !isset($this->minimum)) {
            throw new \InvalidArgumentException('All parameters of SOA must be set.');
        }

        return sprintf(
            '%s %s %s %s %s %s %s',
            $this->mname,
            $this->rname,
            $this->serial,
            $this->refresh,
            $this->retry,
            $this->expire,
            $this->minimum
        );
    }

    /**
     * {@inheritdoc}
     */
    public function toWire(): string
    {
        if (!isset($this->mname) ||
            !isset($this->rname) ||
            !isset($this->serial) ||
            !isset($this->refresh) ||
            !isset($this->retry) ||
            !isset($this->expire) ||
            !isset($this->minimum)) {
            throw new \InvalidArgumentException('All parameters of SOA must be set.');
        }

        return
            self::encodeName($this->mname).
            self::encodeName(/** @scrutinizer ignore-type */ $this->mname).
            self::encodeName($this->rname).
            pack(
                'NNNNN',
                $this->serial,
                $this->refresh,
                $this->retry,
                $this->expire,
                $this->minimum
            );
    }

    /**
     * {@inheritdoc}
     */
    public static function fromText(string $text): RdataInterface
    {
        $rdata = explode(Tokens::SPACE, $text);
        $soa = new self();
        $soa->setMname($rdata[0]);
        $soa->setRname($rdata[1]);
        $soa->setSerial((int) $rdata[2]);
        $soa->setRefresh((int) $rdata[3]);
        $soa->setRetry((int) $rdata[4]);
        $soa->setExpire((int) $rdata[5]);
        $soa->setMinimum((int) $rdata[6]);

        return $soa;
    }

    /**
     * {@inheritdoc}
     */
    public static function fromWire(string $string): RdataInterface
    {
        $offset = 0;
        $rdata = array_merge(
            [
                'mname' => self::decodeName($string, $offset),
                'rname' => self::decodeName($string, $offset),
            ],
            unpack('Nserial/Nrefresh/Nretry/Nexpire/Nminimum', substr($string, $offset))
            /** @scrutinizer ignore-type */ unpack('Nserial/Nrefresh/Nretry/Nexpire/Nminimum', substr($string, $offset))
        );

        $soa = new self();
        $soa->setMname($rdata['mname']);
        $soa->setRname($rdata['rname']);
        $soa->setSerial((int) $rdata['serial']);
        $soa->setRefresh((int) $rdata['refresh']);
        $soa->setRetry((int) $rdata['retry']);
        $soa->setExpire((int) $rdata['expire']);
        $soa->setMinimum((int) $rdata['minimum']);

        return $soa;
    }
}

Badcow / DNS

Branch — master (8940db)

SOA::setRetry() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
