edgepeerrdvservice.java

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

        
        if (RendezvousMeterBuildSettings.RENDEZVOUS_METERING && (rendezvousMeter != null)) {
            rendezvousMeter.stopEdge();
        }
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public Vector<ID> getConnectedPeerIDs() {
        return new Vector<ID>(rendezVous.keySet());
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isConnectedToRendezVous() {
        return !rendezVous.isEmpty();
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void connectToRendezVous(EndpointAddress addr, Object hint) {
        if (seedingManager instanceof URISeedingManager) {
            URISeedingManager uriseed = (URISeedingManager) seedingManager;
            
            if (hint instanceof RouteAdvertisement) {
                uriseed.addSeed((RouteAdvertisement) hint);
            } else {
                uriseed.addSeed(addr.toURI());
            }
        } else if (seedingManager instanceof PeerviewSeedingManager) {
            PeerviewSeedingManager pvseed = (PeerviewSeedingManager) seedingManager;
            
            if (hint instanceof RouteAdvertisement) {
                pvseed.addSeed((RouteAdvertisement) hint);
            }
        }
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void challengeRendezVous(ID peerid, long delay) {
        
        // If immediate failure is requested, just do it.
        // {@code disconnectFromRendezVous()} will at least get the peer
        // removed from the peerView, even if it is not currently a rendezvous
        // of ours. That permits to purge from the peerview rdvs that we try
        // and fail to connect to, faster than the background keep alive done
        // by PeerView itself.
        if (delay <= 0) {
            removeRdv(peerid, false);
            return;
        }
        
        RdvConnection pConn = rendezVous.get(peerid);
        
        if (null != pConn) {
            long adjusted_delay = Math.max(0, Math.min(TimeUtils.toRelativeTimeMillis(pConn.getLeaseEnd()), delay));
            
            pConn.setLease(adjusted_delay, adjusted_delay);
        }
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void disconnectFromRendezVous(ID peerId) {
        removeRdv(peerId, false);
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void propagate(Message msg, String serviceName, String serviceParam, int initialTTL) throws IOException {
        msg = msg.clone();
        int useTTL = Math.min(initialTTL, MAX_TTL);
        
        if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
            LOG.fine("Propagating " + msg + "(TTL=" + useTTL + ") to :" + "\n\tsvc name:" + serviceName + "\tsvc params:"+ serviceParam);
        }
        
        RendezVousPropagateMessage propHdr = updatePropHeader(msg, getPropHeader(msg), serviceName, serviceParam, useTTL);
        
        if (null != propHdr) {
            sendToEachConnection(msg, propHdr);
            sendToNetwork(msg, propHdr);
            
            if (RendezvousMeterBuildSettings.RENDEZVOUS_METERING && (rendezvousMeter != null)) {
                rendezvousMeter.propagateToGroup();
            }
        } else {
            if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                LOG.fine("Declining to propagate " + msg + " (No prop header)");
            }
        }
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void propagateInGroup(Message msg, String serviceName, String serviceParam, int initialTTL) throws IOException {
        msg = msg.clone();
        int useTTL = Math.min(initialTTL, MAX_TTL);
        
        if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
            LOG.fine("Propagating " + msg + "(TTL=" + useTTL + ") in group to :" + "\n\tsvc name:" + serviceName + "\tsvc params:"
                    + serviceParam);
        }
        
        RendezVousPropagateMessage propHdr = updatePropHeader(msg, getPropHeader(msg), serviceName, serviceParam, useTTL);
        
        if (null != propHdr) {
            sendToEachConnection(msg, propHdr);
            
            if (RendezvousMeterBuildSettings.RENDEZVOUS_METERING && (rendezvousMeter != null)) {
                rendezvousMeter.propagateToGroup();
            }
        } else {
            if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                LOG.fine("Declining to propagate " + msg + " (No prop header)");
            }
        }
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void walk(Message msg, String serviceName, String serviceParam, int initialTTL) throws IOException {
        
        propagateInGroup(msg, serviceName, serviceParam, initialTTL);
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void walk(Vector<? extends ID> destPeerIDs, Message msg, String serviceName, String serviceParam, int initialTTL) throws IOException {
        
        propagate(destPeerIDs.elements(), msg, serviceName, serviceParam, initialTTL);
    }
    
    /**
     * @inheritDoc
     */
    @Override
    public PeerConnection getPeerConnection(ID peer) {
        return rendezVous.get(peer);
    }
    
    /**
     * @inheritDoc
     */
    @Override
    protected PeerConnection[] getPeerConnections() {
        return rendezVous.values().toArray(new PeerConnection[0]);
    }
    
    private void disconnectFromAllRendezVous() {
        
        for (RdvConnection pConn : new ArrayList<RdvConnection>(rendezVous.values())) {
            try {
                disconnectFromRendezVous(pConn.getPeerID());
            } catch (Exception failed) {
                if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                    LOG.log(Level.WARNING, "disconnectFromRendezVous failed for " + pConn, failed);
                }
            }
        }
    }
    
    /**
     * Handle a disconnection request from a remote peer.
     *
     * @param msg Description of Parameter
     */
    private void processDisconnectRequest(Message msg) {
        
        try {
            MessageElement elem = msg.getMessageElement(RendezVousServiceProvider.RDV_MSG_NAMESPACE_NAME, DisconnectRequest);
            
            if (null != elem) {
                XMLDocument asDoc = (XMLDocument) StructuredDocumentFactory.newStructuredDocument(elem);
                
                PeerAdvertisement adv = (PeerAdvertisement) AdvertisementFactory.newAdvertisement(asDoc);
                
                RdvConnection rdvConnection = rendezVous.get(adv.getPeerID());
                
                if (null != rdvConnection) {
                    rdvConnection.setConnected(false);
                    removeRdv(adv.getPeerID(), true);
                } else {
                    if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                        LOG.fine("Ignoring disconnect request from " + adv.getPeerID());
                    }
                }
            }
        } catch (Exception failure) {
            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                LOG.log(Level.WARNING, "Failure processing disconnect request", failure);
            }
        }
    }
    
    /**
     * Add a rendezvous to our collection of rendezvous peers.
     *
     * @param padv  PeerAdvertisement for the rendezvous peer.
     * @param lease The duration of the lease in relative milliseconds.
     */
    private void addRdv(PeerAdvertisement padv, long lease) {
        
        int eventType;
        
        RdvConnection rdvConnection;
        
        synchronized (rendezVous) {
            rdvConnection = rendezVous.get(padv.getPeerID());
            
            if (null == rdvConnection) {
                rdvConnection = new RdvConnection(group, rdvService, padv.getPeerID());
                rendezVous.put(padv.getPeerID(), rdvConnection);
                eventType = RendezvousEvent.RDVCONNECT;
            } else {
                eventType = RendezvousEvent.RDVRECONNECT;
            }
        }
        
        // Check if the peer is already registered.
        if (RendezvousEvent.RDVRECONNECT == eventType) {
            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("Renewed RDV lease from " + rdvConnection);
            }
            
            // Already connected, just upgrade the lease
            
            if (RendezvousMeterBuildSettings.RENDEZVOUS_METERING && (rendezvousServiceMonitor != null)) {
                RendezvousConnectionMeter rendezvousConnectionMeter = rendezvousServiceMonitor.getRendezvousConnectionMeter(
                        padv.getPeerID());
                
                rendezvousConnectionMeter.leaseRenewed(lease);
            }
        } else {
            if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
                LOG.info("New RDV lease from " + rdvConnection);
            }
            
            if (RendezvousMeterBuildSettings.RENDEZVOUS_METERING && (rendezvousServiceMonitor != null)) {
                RendezvousConnectionMeter rendezvousConnectionMeter = rendezvousServiceMonitor.getRendezvousConnectionMeter(
                        padv.getPeerID());
                
                rendezvousConnectionMeter.connectionEstablished(lease);
            }
        }
        
        rdvConnection.connect(padv, lease, Math.min(LEASE_MARGIN, (lease / 2)));
        
        rdvService.generateEvent(eventType, padv.getPeerID());
    }
    
    /**
     * Remove the specified rendezvous from our collection of rendezvous.
     *
     * @param rdvid the id of the rendezvous to remove.
     * @param requested if true, indicates a requested operation
     */
    private void removeRdv(ID rdvid, boolean requested) {
        
        if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
            LOG.info("Disconnect from RDV " + rdvid);
        }
        
        PeerConnection rdvConnection;
        
        synchronized (this) {
            rdvConnection = rendezVous.remove(rdvid);
        }
        
        if (null != rdvConnection) {