rendezvousserviceimpl.java

jxta_src_2.41b jxta 2.41b 最新版源码 from www.jxta.org

        synchronized (rdvProviderSwitchLock) {
            if (RdvConfigAdv.RendezVousConfiguration.AD_HOC == config) {
                provider = new AdhocPeerRdvService(group, this);
            } else if (RdvConfigAdv.RendezVousConfiguration.EDGE == config) {
                provider = new EdgePeerRdvService(group, this);
            } else if (RdvConfigAdv.RendezVousConfiguration.RENDEZVOUS == config) {
                provider = new RdvPeerRdvService(group, this);
            } else {
                throw new IllegalStateException("Unrecognized rendezvous configuration");
            }

            if (RendezvousMeterBuildSettings.RENDEZVOUS_METERING) {
                rendezvousServiceMonitor = (RendezvousServiceMonitor) MonitorManager.getServiceMonitor(group,
                                           MonitorResources.rendezvousServiceMonitorClassID);
                provider.setRendezvousServiceMonitor(rendezvousServiceMonitor);
            }

            provider.startApp(null);

            rdvProviderSwitchStatus = false;
        }

        if (autoRendezvous && !PeerGroupID.worldPeerGroupID.equals(group.getPeerGroupID())) {
            startWatchDogTimer();
        }

        if (LOG.isEnabledFor(Level.INFO)) {
            LOG.info("Rendezvous Serivce started");
        }

        return 0;
    }

    /**
     *  {@inheritDoc}
     */
    public synchronized void stopApp() {

        synchronized (rdvProviderSwitchLock) {
            // We won't ever release this lock. We are shutting down. There is
            // no reason to switch after stopping is begun.
            rdvProviderSwitchStatus = true;

            if (provider != null) {
                provider.stopApp();
                provider = null;
            }
        }

        if (rpv != null) {
            rpv.stop();
            rpv = null;
        }

        Iterator eachListener = propListeners.keySet().iterator();

        while (eachListener.hasNext()) {
            String aListener = (String) eachListener.next();

            try {
                endpoint.removeIncomingMessageListener(aListener, null);
            } catch (Exception ignored) {
                ;
            }

            eachListener.remove();
        }

        propListeners.clear();

        timer.cancel();

        msgIds.clear();
        eventListeners.clear();

        if (LOG.isEnabledFor(Level.INFO)) {
            LOG.info("Rendezvous Serivce stopped");
        }
    }

    /**
     * {@inheritDoc}
     */
    public boolean isRendezVous() {

        RendezVousStatus currentStatus = getRendezVousStatus();

        return (RendezVousStatus.AUTO_RENDEZVOUS == currentStatus) || (RendezVousStatus.RENDEZVOUS == currentStatus);
    }

    /**
     * @inheritDoc
     */
    public RendezVousStatus getRendezVousStatus() {
        RendezVousServiceProvider currentProvider = provider;

        if (null == currentProvider) {
            return RendezVousStatus.NONE;
        } else {
            if (currentProvider instanceof AdhocPeerRdvService) {
                return RendezVousStatus.ADHOC;
            } else if (currentProvider instanceof EdgePeerRdvService) {
                return autoRendezvous ? RendezVousStatus.AUTO_EDGE : RendezVousStatus.EDGE;
            } else if (currentProvider instanceof RdvPeerRdvService) {
                return autoRendezvous ? RendezVousStatus.AUTO_RENDEZVOUS : RendezVousStatus.RENDEZVOUS;
            } else {
                return RendezVousStatus.UNKNOWN;
            }
        }
    }

    /**
     *  {@inheritDoc}
     */
    public boolean setAutoStart(boolean auto) {
        return setAutoStart(auto, rdv_watchdog_interval_default);
    }

    /**
     *  {@inheritDoc}
     */
    public synchronized boolean setAutoStart(boolean auto, long period) {
        rdv_watchdog_interval = period;
        boolean old = autoRendezvous;

        autoRendezvous = auto;

        if (auto && !old) {
            startWatchDogTimer();
        } else
            if (old && !auto) {
                stopWatchDogTimer();
            }
        return old;
    }

    /**
     * Force the peerview to use the given peer as a seed peer and force the edge rendezvous
     * provider (if we're edge) to chose a rendezvous as soon as there is one (likely but not
     * necessarily the one given).
     *
     * @param addr The addres of the seed peer (raw or peer id based)
     * @param radv An optional route advertisement, which may be null.
     * @throws IOException if it failed immediately.
     */
    private void connectToRendezVous(EndpointAddress addr, RouteAdvertisement routeHint) throws IOException {

        PeerView currView = rpv;
        if (null == currView) {
            throw new IOException("No PeerView");
        }

        // In order to mimic the past behaviour as closely as possible we add that peer to the seed list automatically and we
        // change the provider choice delay (edge peer only), so that it choses a rendezvous as soon as the suggested one is added
        // to the peerview. However, another seed rendezvous might beat it to the finish line (assuming there are other seeds).

        currView.addSeed(addr.toURI());
        RendezVousServiceProvider currentProvider = provider;

        if (currentProvider != null) {
            currentProvider.setChoiceDelay(0);
        }

        if (! currView.probeAddress(addr, routeHint)) {
            throw new IOException("Could not probe:" + addr);
        }
    }

    /**
     *  {@inheritDoc}
     */
    public void connectToRendezVous(PeerAdvertisement adv) throws IOException {

        EndpointAddress addr = new EndpointAddress("jxta", adv.getPeerID().getUniqueValue().toString(), null, null);

        connectToRendezVous(addr, extractRouteAdv(adv));
    }

    /**
     *  {@inheritDoc}
     */
    public void connectToRendezVous(EndpointAddress addr) throws IOException {
        connectToRendezVous(addr, null);
    }

    /**
     *  {@inheritDoc}
     */
    public void challengeRendezVous(ID peer, long delay) {

        RendezVousServiceProvider currentProvider = provider;

        if (currentProvider != null) {
            currentProvider.challengeRendezVous(peer, delay);
        }
    }

    /**
     *  {@inheritDoc}
     */
    public void disconnectFromRendezVous(ID peerId) {

        RendezVousServiceProvider currentProvider = provider;

        if (currentProvider != null) {
            currentProvider.disconnectFromRendezVous(peerId);
        }
    }

    /**
     *  {@inheritDoc}
     */
    public Enumeration getConnectedRendezVous() {

        RendezVousServiceProvider currentProvider = provider;

        if (currentProvider != null) {
            return currentProvider.getConnectedRendezVous();
        }

        return Collections.enumeration(Collections.EMPTY_LIST);
    }

    /**
     *  {@inheritDoc}
     */
    public Enumeration getDisconnectedRendezVous() {

        RendezVousServiceProvider currentProvider = provider;

        if (currentProvider != null) {
            return currentProvider.getDisconnectedRendezVous();
        }

        return Collections.enumeration(Collections.EMPTY_LIST);
    }

    /**
     *  {@inheritDoc}
     */
    public Enumeration getConnectedPeers() {

        RendezVousServiceProvider currentProvider = provider;

        if (currentProvider != null) {
            return currentProvider.getConnectedPeers();
        }

        return Collections.enumeration(Collections.EMPTY_LIST);
    }

    /**
     *  {@inheritDoc}
     */
    public Vector getConnectedPeerIDs() {

        RendezVousServiceProvider currentProvider = provider;

        if (currentProvider != null) {
            return currentProvider.getConnectedPeerIDs();
        }

        return new Vector();
    }

    /**
     * Gets the rendezvousConnected attribute of the RendezVousServiceImpl object
     *
     * @return    true if connected to a rendezvous, false otherwise
     */
    public boolean isConnectedToRendezVous() {

        RendezVousServiceProvider currentProvider = provider;

        if (currentProvider != null) {
            return currentProvider.isConnectedToRendezVous();
        }

        return false;
    }

    /**
     *  {@inheritDoc}
     */
    public void startRendezVous() {
        try {
            if (isRendezVous() || PeerGroupID.worldPeerGroupID.equals(group.getPeerGroupID())) {
                return;
            }

            synchronized (rdvProviderSwitchLock) {
                if (rdvProviderSwitchStatus) {
                    IOException failed = new IOException("Currently switching rendezvous configuration. try again later.");

                    if (LOG.isEnabledFor(Level.ERROR)) {
                        LOG.error("Failed to start rendezvous", failed);
                    }
                    throw failed;
                }

                rdvProviderSwitchStatus = true;

                // We are at this moment an Edge Peer. First, the current implementation
                // must be stopped.
                if (provider != null) {
                    provider.stopApp();
                    provider = null;
                }

                config = RdvConfigAdv.RendezVousConfiguration.RENDEZVOUS;

                // Now, a new instance of RdvPeerRdvService must be created and initialized.
                provider = new RdvPeerRdvService(group, this);

                if (RendezvousMeterBuildSettings.RENDEZVOUS_METERING) {
                    provider.setRendezvousServiceMonitor(rendezvousServiceMonitor);
                }

                provider.startApp(savedArgs);

                rdvProviderSwitchStatus = false;
            }
        } catch (IOException failure) {
            if (LOG.isEnabledFor(Level.WARN)) {
                LOG.warn("Failed to start rendezvous", failure);
            }
        }
    }

    /**
     *  {@inheritDoc}
     */
    public void stopRendezVous() {

        if (!isRendezVous()) {
            return;
        }

        synchronized (rdvProviderSwitchLock) {
            if (rdvProviderSwitchStatus) {
                IOException failed = new IOException("Currently switching rendezvous configuration. try again later.");

                if (LOG.isEnabledFor(Level.ERROR)) {
                    LOG.error("Failed to stop rendezvous", failed);
                }
            }

            rdvProviderSwitchStatus = true;

            // If the service was already started, then it needs to be stopped,
            // and a new instance of an EdgePeerRdvService must be created and initialized and
            // started.

            if (provider != null) {
                provider.stopApp();
                provider = null;
            }

            config = RdvConfigAdv.RendezVousConfiguration.EDGE;

            provider = new EdgePeerRdvService(group, this);

            if (RendezvousMeterBuildSettings.RENDEZVOUS_METERING) {
                provider.setRendezvousServiceMonitor(rendezvousServiceMonitor);
            }

            provider.startApp(savedArgs);

            rdvProviderSwitchStatus = false;
        }
    }

    /**
     *  {@inheritDoc}