rendezvousserviceimpl.java

JXTA&#8482 is a set of open, generalized peer-to-peer (P2P) protocols that allow any networked devi

        // MessageTransport router = endpoint.getMessageTransport( "jxta" );
        //
        // if( null == router ) {
        // if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
        // LOG.warning("Stalled until there is a router ");
        // }
        //
        // return START_AGAIN_STALLED;
        // }
        // }
        //

        timer = new Timer("RendezVousServiceImpl Timer for " + group.getPeerGroupID(), true);

        if (!rdvProviderSwitchStatus.compareAndSet(true, true)) {
            if (Logging.SHOW_SEVERE && LOG.isLoggable(Level.SEVERE)) {
                LOG.severe("Unable to start rendezvous provider.");
            }

            return -1;
        }

        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.set(false);

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

        if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
            LOG.info("Rendezvous Serivce started");
        }

        return Module.START_OK;
    }

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

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

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

        timer.cancel();
        timer = null;

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

        if (Logging.SHOW_INFO && LOG.isLoggable(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;
    }

    /**
     * Attempt to connect to the specified rendezvous peer.
     *
     * @param addr The endpoint address of the rendezvous peer.
     * @param hint An optional hint which may be {@code null}.
     * @throws IOException If no connection could be made to the specified
     *                     peer.
     */
    private void connectToRendezVous(EndpointAddress addr, RouteAdvertisement hint) throws IOException {
        RendezVousServiceProvider currentProvider = provider;

        if (currentProvider != null) {
            currentProvider.connectToRendezVous(addr, hint);
        } else {
            throw new IOException("Currently switching rendezvous roles.");
        }
    }

    /**
     * {@inheritDoc}
     */
    public void connectToRendezVous(PeerAdvertisement adv) throws IOException {
        EndpointAddress addr = new EndpointAddress("jxta", adv.getPeerID().getUniqueValue().toString(), null, null);
        connectToRendezVous(addr, EndpointUtils.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<ID> getConnectedRendezVous() {
        throw new UnsupportedOperationException("Deprecated opertaion. Use interface if you want to use this operation.");
    }

    /**
     * {@inheritDoc}
     */
    public Enumeration<ID> getDisconnectedRendezVous() {
        throw new UnsupportedOperationException("Deprecated opertaion. Use interface if you want to use this operation.");
    }

    /**
     * {@inheritDoc}
     */
    public Enumeration<ID> getConnectedPeers() {
        throw new UnsupportedOperationException("Deprecated opertaion. Use interface if you want to use this operation.");
    }

    /**
     * {@inheritDoc}
     */
    public Vector<ID> getConnectedPeerIDs() {
        RendezVousServiceProvider currentProvider = provider;

        if (currentProvider != null) {
            return currentProvider.getConnectedPeerIDs();
        }
        return new Vector<ID>();
    }

    /**
     * Gets the rendezvousConnected attribute of the RendezVousServiceImpl object
     *
     * @return true if connected to a rendezvous, false otherwise
     */
    public boolean isConnectedToRendezVous() {
        RendezVousServiceProvider currentProvider = provider;
        return currentProvider != null && currentProvider.isConnectedToRendezVous();
    }

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

            if (!rdvProviderSwitchStatus.compareAndSet(false, true)) {
                IOException failed = new IOException("Currently switching rendezvous configuration. try again later.");

                if (Logging.SHOW_SEVERE && LOG.isLoggable(Level.SEVERE)) {
                    LOG.log(Level.SEVERE, "Failed to start rendezvous", failed);
                }
                throw failed;
            }

            // 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.set(false);
        } catch (IOException failure) {
            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                LOG.log(Level.WARNING, "Failed to start rendezvous", failure);
            }
        }
    }

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

        if (!isRendezVous()) {
            return;
        }

        if (!rdvProviderSwitchStatus.compareAndSet(false, true)) {
            IOException failed = new IOException("Currently switching rendezvous configuration. try again later.");

            if (Logging.SHOW_SEVERE && LOG.isLoggable(Level.SEVERE)) {
                LOG.log(Level.SEVERE, "Failed to stop rendezvous", failed);
            }
        }

        // 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.set(false);
    }

    /**
     * {@inheritDoc}
     */