BitWasp\Bitcoin\Networking\Peer\Locator

Complexity

Total Complexity

9

Size/Duplication

Total Lines	143
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

98.11%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	querySeeds()	0	22	2
A	getPeerList()	0	9	1
B	queryDnsSeeds()	0	34	2
A	getKnownAddresses()	0	4	1
A	popAddress()	0	8	2

<?php

namespace BitWasp\Bitcoin\Networking\Peer;

use BitWasp\Bitcoin\Networking\DnsSeeds\DnsSeedList;
use BitWasp\Bitcoin\Networking\Ip\Ipv4;
use BitWasp\Bitcoin\Networking\Settings\NetworkSettings;
use BitWasp\Bitcoin\Networking\Services;
use BitWasp\Bitcoin\Networking\Structure\NetworkAddress;
use BitWasp\Bitcoin\Networking\Structure\NetworkAddressInterface;
use React\Dns\Resolver\Resolver;
use React\Promise\Deferred;

class Locator
{

    /**
     * @var Resolver
     */
    private $dns;

    /**
     * @var DnsSeedList
     */
    private $seeds;

    /**
     * @var NetworkAddressInterface[]
     */
    private $knownAddresses = [];

    /**
     * Locator constructor.
     * @param Resolver $dns
     * @param NetworkSettings $settings
     */
    public function __construct(Resolver $dns, NetworkSettings $settings)
    {
        $this->seeds = $settings->getDnsSeedList();
        $this->dns = $dns;
        $this->settings = $settings;

The property settings does not exist. Did you maybe forget to declare it?

    }

    /**
     * Takes an arbitrary list of dns seed hostnames, and attempts
     * to return a list from each. Request fails if any hosts are
     * offline or cause an error.
     *
     * @param array $seeds
     * @return \React\Promise\Promise|\React\Promise\PromiseInterface
     */
    public function querySeeds(array $seeds)
    {
        $peerList = new Deferred();

        // Connect to $numSeeds peers
        /** @var Peer[] $vNetAddr */
        $vNetAddr = [];
        $c = 0;
        foreach ($seeds as $seed) {
            $this->dns
                ->resolve($seed)
                ->then(function ($ipList) use (&$vNetAddr, $peerList, &$numSeeds, &$c) {
                    $peerList->resolve($ipList);
                }, function ($error) use ($peerList) {
                    $peerList->reject($error);
                })
            ;
        }

        // Compile the list of lists of peers into $this->knownAddresses
        return $peerList->promise();
    }

    /**
     * Given a number of DNS seeds to query, select a random few and
     * return their peers.
     *
     * @param int $numSeeds
     * @return \React\Promise\Promise|\React\Promise\PromiseInterface
     */
    private function getPeerList($numSeeds = 1)
    {
        // Take $numSeeds
        $seedHosts = $this->seeds->getHosts();
        shuffle($seedHosts);
        $seeds = array_slice($seedHosts, 0, min($numSeeds, count($seedHosts)));

        return $this->querySeeds($seeds);
    }

    /**
     * Query $numSeeds DNS seeds, returning the NetworkAddress[] result.
     * Is rejected if any of the seeds fail.
     *
     * @param int $numSeeds
     * @return \React\Promise\Promise|\React\Promise\PromiseInterface
     */
    public function queryDnsSeeds($numSeeds = 1)
    {
        $deferred = new Deferred();
        $this
            ->getPeerList($numSeeds)
            ->then(
                function (array $vPeerVAddrs) use ($deferred) {
                    shuffle($vPeerVAddrs);

                    /** @var NetworkAddressInterface[] $addresses */
                    $addresses = [];
                    foreach ($vPeerVAddrs as $ip) {
                        $addresses[] = new NetworkAddress(
                            Services::NETWORK,
                            new Ipv4($ip),
                            $this->settings->getDefaultP2PPort()
                        );
                    }

                    $this->knownAddresses = array_merge(
                        $this->knownAddresses,
                        $addresses
                    );

                    $deferred->resolve($this);
                },
                function ($error) use ($deferred) {
                    $deferred->reject($error);
                }
            )
        ;

        return $deferred->promise();
    }

    /**
     * @return NetworkAddressInterface[]
     */
    public function getKnownAddresses()
    {
        return $this->knownAddresses;
    }

    /**
     * Pop an address from the discovered peers
     *
     * @return NetworkAddressInterface
     * @throws \Exception
     */
    public function popAddress()
    {
        if (count($this->knownAddresses) < 1) {
            throw new \Exception('No peers');
        }

        return array_pop($this->knownAddresses);
    }
}