relayclient.java

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

            if (messenger == null || messenger.isClosed()) {
                return false;
            }
            
            Message message = RelayTransport.createConnectMessage(leaseLengthToRequest, (relayAdv == null), flushNeeded);
            
            try {
                messenger.sendMessage(message, "EndpointService:" + client.groupName, client.serviceName + "/" + client.peerId);
            } catch (IOException e) {
                if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                    LOG.log(Level.WARNING, "could not send connect message", e);
                }
                
                // connection attempt failed
                return false;
            }
            
            return true;
        }
        
        protected boolean sendDisconnectMessage() {
            if (messenger == null || messenger.isClosed()) {
                return false;
            }
            
            Message message = RelayTransport.createDisconnectMessage();
            
            try {
                messenger.sendMessage(message, "EndpointService:" + client.groupName, client.serviceName + "/" + client.peerId);
            } catch (IOException e) {
                if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                    LOG.log(Level.WARNING, "could not send disconnect message", e);
                }
                
                // connection attempt failed
                return false;
            }
            
            return true;
        }
        
        /**
         *  {@inheritDoc}
         */
        @Override
        public String toString() {
            
            return
                    ((relayAddress == null) ? "(adv to " + relayAdv.getDestPeerID() + ")" : relayAddress.toString()) + " ["
                    + leaseLength + ", " + leaseObtainedAt + "] ";
        }
    }
    
    /**
     * Register an active Relay to the endpoint. This is done
     * so the Route Advertisement of the PeerAdvertisement is
     * updated
     */
    public synchronized boolean addActiveRelayListener(Object service) {
        
        boolean added = false;
        
        if (!activeRelayListeners.contains(service)) {
            if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                LOG.fine("Register group to relay connection " + ((PeerGroup) service).getPeerGroupName());
            }
            
            activeRelayListeners.add(service);
            
            added = true;
        }
        
        return added;
    }
    
    /**
     * Unregister an active Relay to the endpoint. This is done
     * so the Route Advertisement of the PeerAdvertisement is
     * updated
     */
    public synchronized boolean removeActiveRelayListener(Object service) {
        activeRelayListeners.remove(service);
        
        return true;
    }
    
    /**
     * Notify of a new relay connection
     *
     */
    public synchronized boolean addActiveRelay(EndpointAddress address, RouteAdvertisement relayRoute) {
        
        if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
            LOG.fine("notify add relay connection for " + address);
        }
        
        // need to notify all our listeners

        for (Object activeRelayListener : activeRelayListeners) {
            PeerGroup pg = (PeerGroup) activeRelayListener;
            addRelay(pg, relayRoute);
        }

        // maintain the list of active relays
        activeRelays.put(address, relayRoute);
        return true;
    }
    
    /**
     * Notify of a relay connection removal
     *
     */
    public synchronized boolean removeActiveRelay(EndpointAddress address, RouteAdvertisement relayRoute) {
        
        // need to notify all our listeners

        for (Object activeRelayListener : activeRelayListeners) {
            PeerGroup pg = (PeerGroup) activeRelayListener;
            removeRelay(pg, relayRoute);
        }

        activeRelays.remove(address);
        
        return true;
    }
    
    /**
     * Register an active Relay to the endpoint. This is done
     * so the Route Advertisement of the PeerAdvertisement is
     * updated
     *
     * @param relayRoute address of the relay to add
     */
    private void addRelay(PeerGroup pg, RouteAdvertisement relayRoute) {
        
        ID assignedID = PeerGroup.endpointClassID;
        
        try {
            // get the advertisement of the associated endpoint address as we
            // need to get the peer Id and available route
            
            // update our own peer advertisement
            PeerAdvertisement padv = pg.getPeerAdvertisement();
            XMLDocument myParam = (XMLDocument) padv.getServiceParam(assignedID);
            
            RouteAdvertisement route;
            
            if (myParam == null) {
                // we should have found a route here. This is not good
                if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                    LOG.warning("no route found in peer adv");
                }
                return;
            } else {
                Enumeration<XMLElement> paramChilds = myParam.getChildren(RouteAdvertisement.getAdvertisementType());
                XMLElement param = null;
                
                if (paramChilds.hasMoreElements()) {
                    param = paramChilds.nextElement();
                }
                
                route = (RouteAdvertisement) AdvertisementFactory.newAdvertisement(param);
            }
            
            if (route == null) { // we should have a route here
                return;
            }
            
            // ready to stich the Relay route in our route advertisement
            if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                LOG.fine("found route info for local peer \n" + route.display());
            }
            
            // update the new hops info
            if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                LOG.fine("OLD route info to local peer \n" + route.display());
            }
            
            // If we already have the relay in our list of hops, remove it.
            // The new version can only be more accurate.
            route.removeHop(relayRoute.getDestPeerID());
            
            // Get a hold of the hops list AFTER removing: removeHop
            // rebuilds the vector !
            Vector<AccessPointAdvertisement> hops = route.getVectorHops();
            
            // Create the new relay Hop
            hops.add(relayRoute.getDest());
            
            // update the new hops info
            if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                LOG.fine("NEW route info to local peer" + route.display());
            }
            
            // create the new param route
            myParam = (XMLDocument) StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8, "Parm");
            StructuredTextDocument xptDoc = (StructuredTextDocument)
                    route.getDocument(MimeMediaType.XMLUTF8);
            
            StructuredDocumentUtils.copyElements(myParam, myParam, xptDoc);
            
            padv.putServiceParam(assignedID, myParam);
            
            // publish the new peer advertisement
            DiscoveryService discovery = pg.getDiscoveryService();
            
            if (discovery != null) {
                discovery.publish(padv, DiscoveryService.DEFAULT_LIFETIME, DiscoveryService.DEFAULT_EXPIRATION);
            }
        } catch (Exception ex) {
            if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                LOG.log(Level.FINE, "exception adding relay route ", ex);
            }
        }
    }
    
    /**
     * remove relay hop from the peer advertisement
     *
     * @param group which peer advertisement needs to be updated
     * @param relayRoute address of the relay to be removed
     */
    private void removeRelay(PeerGroup group, RouteAdvertisement relayRoute) {
        
        // we can keep the advertisement for now (should remove it)
        // remove the relay from its active list
        ID assignedID = PeerGroup.endpointClassID;
        PeerID relayPid = relayRoute.getDestPeerID();
        
        try {
            // get the advertisement of the associated endpoint address as we
            // need to get the peer Id and available route
            
            PeerAdvertisement padv;
            
            // update our peer advertisement
            padv = group.getPeerAdvertisement();
            XMLDocument myParam = (XMLDocument) padv.getServiceParam(assignedID);
            
            RouteAdvertisement route = null;
            
            if (myParam == null) {
                // no route found we should really have one
                if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                    LOG.warning("no route found in peer adv");
                    return;
                }
            } else {
                Enumeration<XMLElement> paramChilds = myParam.getChildren(RouteAdvertisement.getAdvertisementType());
                XMLElement param = null;
                
                if (paramChilds.hasMoreElements()) {
                    param = paramChilds.nextElement();
                }
                
                route = (RouteAdvertisement) AdvertisementFactory.newAdvertisement( param);
            }
            
            if (route == null) {
                return;
            } // we should have a route here
            
            // update the new hops info
            route.removeHop(relayPid);
            
            if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                LOG.fine("new route info to the peer" + route.display());
            }
            
            // create the new param route
            myParam = (XMLDocument) StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8, "Parm");
            XMLDocument xptDoc = (XMLDocument) route.getDocument(MimeMediaType.XMLUTF8);
            
            StructuredDocumentUtils.copyElements(myParam, myParam, xptDoc);
            
            padv.putServiceParam(assignedID, myParam);
            
            // publish the new advertisement
            DiscoveryService discovery = group.getDiscoveryService();
            
            if (discovery != null) {
                discovery.publish(padv, DiscoveryService.DEFAULT_LIFETIME, DiscoveryService.DEFAULT_EXPIRATION);
            }
        } catch (Throwable theMatter) {
            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                LOG.log(Level.WARNING, "Failed adding relay route", theMatter);
            }
        }
    }
    
    /**
     * return the list of connected relays
     */
    public Vector<AccessPointAdvertisement> getActiveRelays(PeerGroup pg) {
        if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
            LOG.fine("get active Relays list");
        }
        
        Vector<AccessPointAdvertisement> hops = new Vector<AccessPointAdvertisement>();

        for (RouteAdvertisement route : activeRelays.values()) {
            try {
                // publish our route if pg is not null
                if (pg != null) {
                    DiscoveryService discovery = pg.getDiscoveryService();

                    if (discovery != null) {
                        if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
                            LOG.fine("publishing route to active relay " + route.display());
                        }
                        discovery.publish(route, DEFAULT_EXPIRATION, DEFAULT_EXPIRATION);
                    }
                }
            } catch (Exception ex) {
                if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                    LOG.log(Level.WARNING, "error publishing active relay", ex);
                }
                continue;
            }

            hops.add(route.getDest());
        }

        return hops;        
    }
    
    // convert an endpointRouterAddress into a PeerID
    private static PeerID addr2pid(EndpointAddress addr) {
        try {
            URI asURI = new URI(ID.URIEncodingName, ID.URNNamespace + ":" + addr.getProtocolAddress(), null);
            
            return (PeerID) IDFactory.fromURI(asURI);
        } catch (Exception ex) {
            return null;
        }
    }
}