Java PeerDiscoveryException类代码示例

import com.google.bitcoin.net.discovery.PeerDiscoveryException; //导入依赖的package包/类
@Test
public void peerDiscoveryPolling() throws InterruptedException {
    // Check that if peer discovery fails, we keep trying until we have some nodes to talk with.
    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicBoolean result = new AtomicBoolean();
    peerGroup.addPeerDiscovery(new PeerDiscovery() {
        public InetSocketAddress[] getPeers(long unused, TimeUnit unused2) throws PeerDiscoveryException {
            if (!result.getAndSet(true)) {
                // Pretend we are not connected to the internet.
                throw new PeerDiscoveryException("test failure");
            } else {
                // Return a bogus address.
                latch.countDown();
                return new InetSocketAddress[]{new InetSocketAddress("localhost", 1)};
            }
        }
        public void shutdown() {
        }
    });
    peerGroup.startAndWait();
    latch.await();
    // Check that we did indeed throw an exception. If we got here it means we threw and then PeerGroup tried
    // again a bit later.
    assertTrue(result.get());
}
 

import com.google.bitcoin.net.discovery.PeerDiscoveryException; //导入依赖的package包/类
@Test
public void peerDiscoveryPolling() throws InterruptedException {
    // Check that if peer discovery fails, we keep trying until we have some nodes to talk with.
    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicBoolean result = new AtomicBoolean();
    peerGroup.addPeerDiscovery(new PeerDiscovery() {
        public InetSocketAddress[] getPeers(long unused, TimeUnit unused2) throws PeerDiscoveryException {
            if (!result.getAndSet(true)) {
                // Pretend we are not connected to the internet.
                throw new PeerDiscoveryException("test failure");
            } else {
                // Return a bogus address.
                latch.countDown();
                return new InetSocketAddress[]{new InetSocketAddress("localhost", 1)};
            }
        }
        public void shutdown() {
        }
    });
    peerGroup.startAsync();
    peerGroup.awaitRunning();
    latch.await();
    // Check that we did indeed throw an exception. If we got here it means we threw and then PeerGroup tried
    // again a bit later.
    assertTrue(result.get());
}
 

import com.google.bitcoin.net.discovery.PeerDiscoveryException; //导入依赖的package包/类
@Override
protected void run() throws Exception {
    while (isRunning()) {
        int numPeers;
        lock.lock();
        try {
            numPeers = peers.size() + pendingPeers.size();
        } finally {
            lock.unlock();
        }

        if (numPeers < getMaxConnections()) {
            try {
                connectToAnyPeer();
            } catch(PeerDiscoveryException e) {
                groupBackoff.trackFailure();
            }
        }
        else
            morePeersMailbox.take();
    }
}
 

import com.google.bitcoin.net.discovery.PeerDiscoveryException; //导入依赖的package包/类
private static void printDNS() throws PeerDiscoveryException {
    long start = System.currentTimeMillis();
    DnsDiscovery dns = new DnsDiscovery(MainNetParams.get());
    dnsPeers = dns.getPeers(10, TimeUnit.SECONDS);
    printPeers(dnsPeers);
    printElapsed(start);
}
 

import com.google.bitcoin.net.discovery.PeerDiscoveryException; //导入依赖的package包/类
/** Picks a peer from discovery and connects to it. If connection fails, picks another and tries again. */
protected void connectToAnyPeer() throws PeerDiscoveryException {
    final State state = state();
    if (!(state == State.STARTING || state == State.RUNNING)) return;

    final PeerAddress addr;

    long nowMillis = Utils.currentTimeMillis();

    lock.lock();
    try {
        if (!haveReadyInactivePeer(nowMillis)) {
            discoverPeers();
            groupBackoff.trackSuccess();
            nowMillis = Utils.currentTimeMillis();
        }
        if (inactives.size() == 0) {
            log.debug("Peer discovery didn't provide us any more peers, not trying to build new connection.");
            return;
        }
        addr = inactives.poll();
    } finally {
        lock.unlock();
    }

    // Delay if any backoff is required
    long retryTime = Math.max(backoffMap.get(addr).getRetryTime(), groupBackoff.getRetryTime());
    if (retryTime > nowMillis) {
        // Sleep until retry time
        Utils.sleep(retryTime - nowMillis);
    }

    // This method constructs a Peer and puts it into pendingPeers.
    connectTo(addr, false);
}
 

import com.google.bitcoin.net.discovery.PeerDiscoveryException; //导入依赖的package包/类
/** Picks a peer from discovery and connects to it. If connection fails, picks another and tries again. */
protected void connectToAnyPeer() throws PeerDiscoveryException {
    final State state = state();
    if (!(state == State.STARTING || state == State.RUNNING)) return;

    PeerAddress addr = null;

    long nowMillis = Utils.currentTimeMillis();
    long retryTime = 0;
    lock.lock();
    try {
        if (!haveReadyInactivePeer(nowMillis)) {
            discoverPeers();
            groupBackoff.trackSuccess();
            nowMillis = Utils.currentTimeMillis();
        }
        if (inactives.size() == 0) {
            log.debug("Peer discovery didn't provide us any more peers, not trying to build new connection.");
            return;
        }
        addr = inactives.poll();
        retryTime = backoffMap.get(addr).getRetryTime();
    } finally {
        // discoverPeers might throw an exception if something goes wrong: we then hit this path with addr == null.
        retryTime = Math.max(retryTime, groupBackoff.getRetryTime());
        lock.unlock();
        if (retryTime > nowMillis) {
            // Sleep until retry time
            final long millis = retryTime - nowMillis;
            log.info("Waiting {} msec before next connect attempt {}", millis, addr == null ? "" : " to " + addr);
            Utils.sleep(millis);
        }
    }

    // This method constructs a Peer and puts it into pendingPeers.
    checkNotNull(addr);   // Help static analysis which can't see that addr is always set if we didn't throw above.
    connectTo(addr, false);
}
 

import com.google.bitcoin.net.discovery.PeerDiscoveryException; //导入依赖的package包/类
@Test
public void peerPriority() throws Exception {
    final List<InetSocketAddress> addresses = Lists.newArrayList(
            new InetSocketAddress("localhost", 2000),
            new InetSocketAddress("localhost", 2001),
            new InetSocketAddress("localhost", 2002)
    );
    peerGroup.addEventListener(listener);
    peerGroup.addPeerDiscovery(new PeerDiscovery() {
        public InetSocketAddress[] getPeers(long unused, TimeUnit unused2) throws PeerDiscoveryException {
            return addresses.toArray(new InetSocketAddress[addresses.size()]);
        }

        public void shutdown() {
        }
    });
    peerGroup.setMaxConnections(3);
    Utils.setMockSleep(true);
    peerGroup.startAndWait();

    handleConnectToPeer(0);
    handleConnectToPeer(1);
    handleConnectToPeer(2);
    connectedPeers.take();
    connectedPeers.take();
    connectedPeers.take();
    addresses.clear();
    addresses.addAll(Lists.newArrayList(new InetSocketAddress("localhost", 2003)));
    stopPeerServer(2);
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort()); // peer died

    // discovers, connects to new peer
    handleConnectToPeer(3);
    assertEquals(2003, connectedPeers.take().getAddress().getPort());

    stopPeerServer(1);
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort()); // peer died

    // Alternates trying two offline peers
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());

    // Peer 2 comes online
    startPeerServer(2);
    Utils.passMockSleep();
    handleConnectToPeer(2);
    assertEquals(2002, connectedPeers.take().getAddress().getPort());

    stopPeerServer(2);
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort()); // peer died

    // Peer 2 is tried twice before peer 1, since it has a lower backoff due to recent success
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
}
 

import com.google.bitcoin.net.discovery.PeerDiscoveryException; //导入依赖的package包/类
@Test
public void peerPriority() throws Exception {
    final List<InetSocketAddress> addresses = Lists.newArrayList(
            new InetSocketAddress("localhost", 2000),
            new InetSocketAddress("localhost", 2001),
            new InetSocketAddress("localhost", 2002)
    );
    peerGroup.addEventListener(listener);
    peerGroup.addPeerDiscovery(new PeerDiscovery() {
        public InetSocketAddress[] getPeers(long unused, TimeUnit unused2) throws PeerDiscoveryException {
            return addresses.toArray(new InetSocketAddress[addresses.size()]);
        }

        public void shutdown() {
        }
    });
    peerGroup.setMaxConnections(3);
    Utils.setMockSleep(true);
    peerGroup.startAndWait();

    handleConnectToPeer(0);
    handleConnectToPeer(1);
    handleConnectToPeer(2);
    connectedPeers.take();
    connectedPeers.take();
    connectedPeers.take();
    addresses.clear();
    addresses.addAll(Lists.newArrayList(new InetSocketAddress("localhost", 2003)));
    stopPeerServer(2);
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort()); // peer died

    // discovers, connects to new peer
    handleConnectToPeer(3);
    assertEquals(2003, connectedPeers.take().getAddress().getPort());

    stopPeerServer(1);
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort()); // peer died

    // Alternates trying two offline peers
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());

    // Peer 2 comes online
    startPeerServer(2);
    Utils.passMockSleep();
    handleConnectToPeer(2);
    assertEquals(2002, connectedPeers.take().getAddress().getPort());

    stopPeerServer(2);
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort()); // peer died

    // Peer 2 is tried before peer 1, since it has a lower backoff due to recent success
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
}
 

import com.google.bitcoin.net.discovery.PeerDiscoveryException; //导入依赖的package包/类
@Test
public void peerPriority() throws Exception {
    final List<InetSocketAddress> addresses = Lists.newArrayList(
            new InetSocketAddress("localhost", 2000),
            new InetSocketAddress("localhost", 2001),
            new InetSocketAddress("localhost", 2002)
    );
    peerGroup.addEventListener(listener);
    peerGroup.addPeerDiscovery(new PeerDiscovery() {
        public InetSocketAddress[] getPeers(long unused, TimeUnit unused2) throws PeerDiscoveryException {
            return addresses.toArray(new InetSocketAddress[addresses.size()]);
        }

        public void shutdown() {
        }
    });
    peerGroup.setMaxConnections(3);
    Utils.setMockSleep(true);
    peerGroup.startAsync();
    peerGroup.awaitRunning();

    handleConnectToPeer(0);
    handleConnectToPeer(1);
    handleConnectToPeer(2);
    connectedPeers.take();
    connectedPeers.take();
    connectedPeers.take();
    addresses.clear();
    addresses.addAll(Lists.newArrayList(new InetSocketAddress("localhost", 2003)));
    stopPeerServer(2);
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort()); // peer died

    // discovers, connects to new peer
    handleConnectToPeer(3);
    assertEquals(2003, connectedPeers.take().getAddress().getPort());

    stopPeerServer(1);
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort()); // peer died

    // Alternates trying two offline peers
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());

    // Peer 2 comes online
    startPeerServer(2);
    Utils.passMockSleep();
    handleConnectToPeer(2);
    assertEquals(2002, connectedPeers.take().getAddress().getPort());

    stopPeerServer(2);
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort()); // peer died

    // Peer 2 is tried before peer 1, since it has a lower backoff due to recent success
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
}
 

import com.google.bitcoin.net.discovery.PeerDiscoveryException; //导入依赖的package包/类
public void startPeerGroup() throws Exception
    {
        final String lockName = context.getPackageName() + " peer connection";
        final PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
        wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, lockName);

        ConnectionDetector cd = new ConnectionDetector(context.getApplicationContext());

        if (cd.isConnectingToInternet())
        {
            Log.d(TAG, "acquiring wakelock");
            wakeLock.acquire();

            Log.d(TAG, "starting peergroup");
            peerGroup.setFastCatchupTimeSecs(application.getAhimsaWallet().getEarliestKeyCreationTime());
            peerGroup.setUserAgent(Constants.USER_AGENT, Constants.VERSION);
            Log.d(TAG, "started peergroup");


            final boolean hasTrustedPeer = !config.getTrustedPeer().isEmpty();
            peerGroup.setMaxConnections(hasTrustedPeer ? 1 : config.getMaxConnectedPeers());
            peerGroup.addPeerDiscovery(new PeerDiscovery()
            {
                private final PeerDiscovery normalPeerDiscovery = new DnsDiscovery(Constants.NETWORK_PARAMETERS);

                @Override
                public InetSocketAddress[] getPeers(final long timeoutValue, final TimeUnit timeoutUnit) throws PeerDiscoveryException
                {
                    final List<InetSocketAddress> peers = new LinkedList<InetSocketAddress>();

                    boolean needsTrimPeersWorkaround = false;

                    if (hasTrustedPeer)
                    {
                        Log.d(TAG, "trusted peer '" + config.getTrustedPeer() + "'" + (hasTrustedPeer ? " only" : ""));

                        final InetSocketAddress addr = new InetSocketAddress(config.getTrustedPeer(), Constants.NETWORK_PARAMETERS.getPort());
                        if (addr.getAddress() != null)
                        {
                            peers.add(addr);
                            needsTrimPeersWorkaround = true;
                        }
                    }

                    if (!hasTrustedPeer)
                        peers.addAll(Arrays.asList(normalPeerDiscovery.getPeers(timeoutValue, timeoutUnit)));

                    // workaround because PeerGroup will shuffle peers
                    if (needsTrimPeersWorkaround)
                        while (peers.size() >= config.getMaxConnectedPeers())
                            peers.remove(peers.size() - 1);

                    return peers.toArray(new InetSocketAddress[0]);
                }

                @Override
                public void shutdown()
                {
                    normalPeerDiscovery.shutdown();
                }
            });

            peerGroup.startAsync();

//            ListenableFuture<PeerGroup> future2 = peerGroup.waitForPeers(config.getMinConnectedPeers());
//            future2.get(config.getTimeout(), TimeUnit.SECONDS);

            Log.d(TAG, "pending peers  : " + peerGroup.getPendingPeers());
            Log.d(TAG, "connected peers: " + peerGroup.getConnectedPeers());
        }
        else
        {
            throw new RuntimeException("No internet connection present");
        }
    }
 

import com.google.bitcoin.net.discovery.PeerDiscoveryException; //导入依赖的package包/类
@Test
public void peerPriority() throws Exception {
    final List<InetSocketAddress> addresses = Lists.newArrayList(
            new InetSocketAddress("localhost", 2000),
            new InetSocketAddress("localhost", 2001),
            new InetSocketAddress("localhost", 2002)
    );
    peerGroup.addEventListener(listener);
    peerGroup.addPeerDiscovery(new PeerDiscovery() {
        public InetSocketAddress[] getPeers(long unused, TimeUnit unused2) throws PeerDiscoveryException {
            return addresses.toArray(new InetSocketAddress[0]);
        }

        public void shutdown() {
        }
    });
    peerGroup.setMaxConnections(3);
    Utils.setMockSleep(true);
    peerGroup.startAndWait();

    handleConnectToPeer(0);
    handleConnectToPeer(1);
    handleConnectToPeer(2);
    connectedPeers.take();
    connectedPeers.take();
    connectedPeers.take();
    addresses.clear();
    addresses.addAll(Lists.newArrayList(new InetSocketAddress("localhost", 2003)));
    stopPeerServer(2);
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort()); // peer died

    // discovers, connects to new peer
    handleConnectToPeer(3);
    assertEquals(2003, connectedPeers.take().getAddress().getPort());

    stopPeerServer(1);
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort()); // peer died

    // Alternates trying two offline peers
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());

    // Peer 2 comes online
    startPeerServer(2);
    Utils.passMockSleep();
    handleConnectToPeer(2);
    assertEquals(2002, connectedPeers.take().getAddress().getPort());

    stopPeerServer(2);
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort()); // peer died

    // Peer 2 is tried twice before peer 1, since it has a lower backoff due to recent success
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2002, disconnectedPeers.take().getAddress().getPort());
    Utils.passMockSleep();
    assertEquals(2001, disconnectedPeers.take().getAddress().getPort());
}