routeadvertisement.java

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

            
            if (hid == null) {
                continue; //may be null
            }
            
            if (pid.equals(hid)) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * check if the route has a loop
     *
     * @return boolean true or false if the route has a loop
     */
    public boolean hasALoop() {
        // Now check for any other potential loops.
        Vector peers = new Vector();
        for (int i=0; i < hops.size(); ++i) {
            try {
                PeerID pid = ((AccessPointAdvertisement)
                hops.elementAt(i)).getPeerID();
                if (pid == null)
                    return true; //bad route
                if (peers.contains(pid)) {
                    // This is a loop.
                    return true;
                } else {
                    peers.add(pid);
                }
            } catch (Exception ez1) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * return the length of the route
     *
     * @return int size of the route
     */
    public int size() {
        return hops.size();
    }
    
    /**
     * get the nexthop after the given hop
     *
     * @param pid PeerID of the current hop
     * @return ap AccessPointAdvertisement of the next Hop
     */
    public AccessPointAdvertisement nextHop(PeerID pid) {
        
        AccessPointAdvertisement nextHop = null;
        
        // check if we have a real route
        if ((hops == null) || (hops.size() == 0)) {
            // Empty vector.
            return null;
        }
        
        // find the index of the route
        int index = 0;
        boolean found = false;
        for (Enumeration e = hops.elements(); e.hasMoreElements();) {
            AccessPointAdvertisement ap =
            (AccessPointAdvertisement) e.nextElement();
            if (pid.toString().equals(ap.getPeerID().toString())) {
                found = true;
                break;
            }
            index++;
        }
        
        // check if we found the local peer within the vector
        
        if (!found) {
            // The peer is not into the vector. Since we have got that
            // message, the best we can do is to send it to the first gateway
            // in the forward path.
            try {
                nextHop =  (AccessPointAdvertisement) hops.elementAt(0);
            } catch (Exception ez1) {
                // Should not fail, but if it does, there is not much we can do
                return null;
            }
            return nextHop;
        }
        // Found the peer within the vector of hops. Get the next
        // hop
        try {
            nextHop =  (AccessPointAdvertisement) hops.elementAt(index + 1);
        } catch (Exception ez1) {
            // There is no next hop
            return null;
        }
        return nextHop;
    }
    
    /**
     * Generate a string that displays the route
     * information for logging or debugging purpose
     *
     * @return String return a string containing the route info
     */
    public String display() {
        
        StringBuffer routeBuf = new StringBuffer();
        
        routeBuf.append( "Route to PID=" );
        
        PeerID peerId = getDest().getPeerID();
        
        // XXX Sometimes the embedded APA doesn't have the peer id set.
        if (peerId == null) {
            peerId = destPeer;
        }
        
        if (peerId == null) {
            routeBuf.append("<null>");
        }
        else
            routeBuf.append(peerId.toString());
        
        Iterator each = getDest().getVectorEndpointAddresses().iterator();
        while (each.hasNext()) {
            try {
                routeBuf.append( "\n Addr=" + (String) each.next() );
            } catch (ClassCastException ex) {
                routeBuf.append( "\n Addr=bad address");
            }
        }
        
        int i = 1;
        Enumeration e = getHops();
        while( e.hasMoreElements() ) {
            if (i == 1) {
                routeBuf.append( "\n Gateways = " );
            }
            
            peerId = ((AccessPointAdvertisement) e.nextElement()).getPeerID();
            if (peerId == null)
                routeBuf.append("Null Hop");
            else
                routeBuf.append( "\n\t[" + i++ + "] " + peerId);
        }
        
        return routeBuf.toString();
    }
    
    /**
     * remove a hop from the list of hops
     *
     * @param pid peer id of the hop
     * @return boolean true or false if the hop is found in the route
     */
    public boolean removeHop(PeerID pid) {
        
        // FIXME: This is ridiculous, hops is a vector. We can remove
        // any item, we do not have to through the enum copying items 1 by 1.
        
        Vector newHops = new Vector();
        for (Enumeration e = hops.elements(); e.hasMoreElements();) {
            AccessPointAdvertisement hop = (AccessPointAdvertisement)
            e.nextElement();
            PeerID hid = hop.getPeerID();
            if (hid != null) {
                if (pid.toString().equals(hid.toString()))
                    continue;
            }
            // add the other one
            newHops.add(hop);
        }
        setHops(newHops);
        return true;
    }
    
    
    /**
     * return a hop from the list of hops
     *
     * @param pid peer id of the hop
     * @return accesspointadvertisement of the corresponding hop
     */
    public AccessPointAdvertisement getHop(PeerID pid) {
        for (Enumeration e = hops.elements(); e.hasMoreElements();) {
            AccessPointAdvertisement hop = (AccessPointAdvertisement)
            e.nextElement();
            PeerID hid = hop.getPeerID();
            if (hid != null) {
                if (pid.toString().equals(hid.toString()))
                    return (AccessPointAdvertisement) hop.clone();
            }
        }
        return null;
    }
    
    /**
     * replace a hop from the list of hops
     *
     * @param ap accesspointadvertisement of the hop to replace
     */
    public void replaceHop(AccessPointAdvertisement ap) {
        int index = 0;
        for (Enumeration e = hops.elements(); e.hasMoreElements();) {
            AccessPointAdvertisement hop = (AccessPointAdvertisement)
            e.nextElement();
            PeerID hid = hop.getPeerID();
            if (hid != null) {
                if (ap.getPeerID().toString().equals(hid.toString())) {
                    hops.setElementAt(ap, index);
                    return;
                }
            }
        }
    }
    
    /**
     * Add a new endpointaddress to a hop
     *
     * @param pid id of the hop
     * @param addr new endpoint address to add
     */
    public void addEndpointAddressToHop(PeerID pid, EndpointAddress addr) {
        Vector ea = new Vector();
        ea.add(addr.toString());
        
        AccessPointAdvertisement oldHop = getHop(pid);
        if (oldHop != null && !oldHop.contains(addr)) {
            oldHop.addEndpointAddresses(ea);
            replaceHop(oldHop);
        }
    }
    
    /**
     * remove an endpointaddress to a hop
     *
     * @param pid id of the hop
     * @param addr new endpoint address to remove
     */
    public void removeEndpointAddressToHop(PeerID pid, EndpointAddress addr) {
        Vector ea = new Vector();
        ea.add(addr.toString());
        
        AccessPointAdvertisement oldHop = getHop(pid);
        if (oldHop != null && !oldHop.contains(addr)) {
            oldHop.removeEndpointAddresses(ea);
            if (oldHop.size() > 0) // we still have some endpoint addresses
                replaceHop(oldHop);
            else
                removeHop(pid);
        }
    }
    
    /**
     * Return hop of the route at location index in the hops list
     *
     * @param index in the list of hops
     * @return hop AccessPointAdvertisement of the hops
     */
    public AccessPointAdvertisement getHop(int index) {
        
        if (index < 0)
            return null;
        
        if (index > hops.size() - 1)
            return null;
        
        return (AccessPointAdvertisement) ((AccessPointAdvertisement)hops.elementAt(index)).clone();
    }
    
    /**
     * construct a new route
     * <p/><b>WARNING hops may be MODIFIED.</b>
     **/
    public static RouteAdvertisement newRoute(PeerID destPid,
    PeerID firsthop,
    Vector hops) {
        
        RouteAdvertisement route = (RouteAdvertisement)
        AdvertisementFactory.newAdvertisement(
        RouteAdvertisement.getAdvertisementType());
        
        // set the route destination
        AccessPointAdvertisement ap = (AccessPointAdvertisement)
        AdvertisementFactory.newAdvertisement(
        AccessPointAdvertisement.getAdvertisementType());
        
        if (destPid == null)
            return null; // messed up destination
        ap.setPeerID(destPid);
        route.setDest(ap);
        
        // set the route hops
        for (Enumeration e = hops.elements(); e.hasMoreElements();) {
            ap = (AccessPointAdvertisement) e.nextElement();
            if (ap.getPeerID() == null)
                return null; // bad route
        }
        route.setHops(hops);
        
        // check if the given first hop is already in the route if not add it
        // (note: we do not expect it to be there, but it is acceptable).
        if (firsthop != null) {
            ap = route.getFirstHop();
            if (ap == null || ! ap.getPeerID().equals(firsthop)) {
                ap = (AccessPointAdvertisement)
                AdvertisementFactory.newAdvertisement(
                AccessPointAdvertisement.getAdvertisementType());
                ap.setPeerID(firsthop);
                route.setFirstHop(ap);
            }
        }
        
        return route;
    }
    
    /**
     * construct a new route, all hops are in the hops parameter.
     **/
    public static RouteAdvertisement newRoute(PeerID destPid, Vector hops) {
        return newRoute(destPid, null, hops);
    }
    
    /**
     * Alter the given newRoute (which does not start from here) by using firstLeg, a known route to whence
     * it starts from. So that the complete route goes from here to the end-destination via firstLeg.
     * public static boolean stichRoute(RouteAdvertisement newRoute,
     **/
    public static boolean stichRoute(RouteAdvertisement newRoute, RouteAdvertisement firstLeg) {
        return stichRoute(newRoute, firstLeg, null);
    }
    
    /**
     * Alter the given newRoute (which does not start from here) by using firstLeg, a known route to whence
     ** it starts from. So that the complete route goes from here to the end-destination via firstLeg
     **  also shortcut the route by removing the local peer
     **/
    public static boolean stichRoute(RouteAdvertisement newRoute,
    RouteAdvertisement firstLeg,
    PeerID localPeer) {
        
        if ( newRoute.hasALoop() )
            return false;
        
        Vector hops = newRoute.getVectorHops();
        
        // Make room
        hops.ensureCapacity(firstLeg.getVectorHops().size() + 1 + hops.size());
        
        // prepend the routing peer unless the routing peer happens to be
        // in the route already. That happens if the routing peer is the relay.
        // or if the route does not have a first leg
        PeerID routerPid = firstLeg.getDest().getPeerID();
        if (newRoute.size() == 0 || (! newRoute.getFirstHop().getPeerID().equals(routerPid))) {
            AccessPointAdvertisement ap = (AccessPointAdvertisement)
            AdvertisementFactory.newAdvertisement(
            AccessPointAdvertisement.getAdvertisementType());
            // prepend the route with the routing peer.
            ap.setPeerID(routerPid);
            hops.add(0, ap);
        }
        
        // prepend the rest of the route
        hops.addAll(0, firstLeg.getVectorHops());
        
        // remove any llop from the root
        cleanupLoop(newRoute, localPeer);
        return true;
    }
    
    /**
     * Remove loops from the route advertisement
     * by shortcuting cycle from the route
     **/
    public static void cleanupLoop(RouteAdvertisement route, PeerID localPeer) {
        
        // Note: we cleanup all enp addresses except for the last hop (which
        // we use to shorten routes often enough).
        // If we end-up removing the last hop, it means that it is the
        // local peer and thus the route ends up with a size 0.
        
        Vector hops = route.getVectorHops();
        Vector newHops = new Vector(hops.size());
        Object lastHop = null;
        
        // Replace all by PID-only entries, but keep the last hop on the side.
        if (hops.size() > 0) {
            lastHop = hops.elementAt(hops.size() - 1);
        }
        hops = ((RouteAdvertisement) route.cloneOnlyPIDs()).getVectorHops();
        
        // remove cycle from the route
        for (int i=0; i < hops.size(); i++) {
            int loopAt = newHops.indexOf(hops.elementAt(i));
            if (loopAt != -1) { // we found a cycle
                
                // remove all entries after loopAt
                for (int j = newHops.size(); --j > loopAt;) {
                    newHops.remove(j);
                }
            } else { // did not find it so we add it
                newHops.add(hops.elementAt(i));
            }
        }
        
        // Remove the local peer in the route if we were given one
        if (localPeer != null) {
            for (int i = newHops.size(); --i >= 0;) {
                if (localPeer.equals(((AccessPointAdvertisement)
                newHops.elementAt(i)).getPeerID())) {
                    // remove all the entries up to that point we
                    // need to keep the remaining of the route from that
                    // point
                    for (int j = 0; j <= i; j++) {
                        newHops.remove(0);
                    }
                    break;
                }
            }
        }
        
        if (lastHop != null && newHops.size() > 0) {
            newHops.setElementAt(lastHop, newHops.size() - 1);
        }
        
        // update the new hops in the route
        route.setHops(newHops);
    }
}