routecontrol.java

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

    /**
     * Get a current route info
     *
     * @param pId destination of the route
     * @return RouteAdvertisement current route info
     */
    public RouteAdvertisement getRouteInfo(PeerID pId) {

        RouteAdvertisement route = null;
        EndpointRouter.ClearPendingQuery entry = null;
        EndpointAddress addr = EndpointRouter.pid2addr(pId);

        // check if we have a direct route
        Messenger oneOfThem = router.getCachedMessenger(addr);
        EndpointAddress pcaddr = (oneOfThem == null) ? null : oneOfThem.getDestinationAddress();

        if (pcaddr != null) {
            AccessPointAdvertisement ap = (AccessPointAdvertisement)
                                          AdvertisementFactory.newAdvertisement(AccessPointAdvertisement.getAdvertisementType());

            ap.setPeerID(pId);
            Vector eas = new Vector();

            eas.add(pcaddr.getProtocolName() + "://" + pcaddr.getProtocolAddress());
            ap.setEndpointAddresses(eas);
            route = (RouteAdvertisement)
                    AdvertisementFactory.newAdvertisement(RouteAdvertisement.getAdvertisementType());
            route.setDest(ap);
            return route;

        } else { // check if we have a long route
            route = router.getRoute(addr, false);
            if (route != null) {
                return route;
            } else { // check if we have a pending query
                entry = router.getPendingRouteQuery(addr);
                if (entry != null) { // ok we have a pending query
                    AccessPointAdvertisement ap = (AccessPointAdvertisement)
                                                  AdvertisementFactory.newAdvertisement(AccessPointAdvertisement.getAdvertisementType());

                    ap.setPeerID(pId);
                    Vector eas = new Vector();

                    eas.add("pending " + (entry.isFailed() ? "(failed)" : "(new)"));
                    ap.setEndpointAddresses(eas);
                    route = (RouteAdvertisement)
                            AdvertisementFactory.newAdvertisement(RouteAdvertisement.getAdvertisementType());
                    route.setDest(ap);
                    return route;
                } else { // sorry no route found
                    AccessPointAdvertisement ap = (AccessPointAdvertisement)
                                                  AdvertisementFactory.newAdvertisement(AccessPointAdvertisement.getAdvertisementType());

                    ap.setPeerID(pId);
                    route = (RouteAdvertisement)
                            AdvertisementFactory.newAdvertisement(RouteAdvertisement.getAdvertisementType());
                    route.setDest(ap);
                    return route;
                }
            }
        }
    }

    /**
     * Delete route info
     *
     * @param pId destination route to be removed
     * @return Integer status
     */
    public int deleteRoute(PeerID pId) {

        // check if the route Id is not ourself
        if (pId.equals(localPeerId)) {
            return INVALID_ROUTE;
        }

        EndpointAddress addr = EndpointRouter.pid2addr(pId);

        // FIXME tra 20030820 We are only allowing to remove long routes.
        // Since direct routes can be used as the first hop for multiple
        // valid routes, we don't want to close the associate messenger. At some
        // point we should introduce a way to disassociate direct routes and
        // their corresponding messengers, so we can have a generic table of routes
        // and a separated table of messengers that can be manipulated
        // independently.

        // Check if we have a direct route
        if (router.isLocalRoute(addr)) {
            return DIRECT_ROUTE;
        }

        // remove routing table info
        router.removeRoute(addr);

        // flush the CM. We need to flush the CM
        // so the route will not be regenarated
        routeCM.flushRoute(addr);

        return OK;
    }

    /**
     * get all the know routes by the router. Return a vector of all
     * the routes known.
     *
     * This method which is meant for informational purposes, does not lock the maps that
     * it browses. As a result, it could in some cases generate a concurrent modification
     * exception.
     *
     * @return vector of known routes
     *
     */
    public Vector getAllRoutesInfo() {

        Vector routes = new Vector();
        EndpointAddress ea = null;

        try {
            // get the direct routes
            for (Iterator it = router.getAllCachedMessengerDestinations(); it.hasNext();) {
                ea = (EndpointAddress) it.next();
                AccessPointAdvertisement ap = (AccessPointAdvertisement)
                                              AdvertisementFactory.newAdvertisement(AccessPointAdvertisement.getAdvertisementType());

                ap.setPeerID(EndpointRouter.addr2pid(ea));
                Vector eas = new Vector();
                Messenger oneOfThem = router.getCachedMessenger(ea);
                EndpointAddress pcaddr = (oneOfThem == null) ? null : oneOfThem.getDestinationAddress();

                if (pcaddr == null) { // incomplete route
                    eas.add("unknown");
                } else {
                    eas.add(pcaddr.getProtocolName() + "://" + pcaddr.getProtocolAddress());
                }
                ap.setEndpointAddresses(eas);
                RouteAdvertisement r = (RouteAdvertisement)
                                       AdvertisementFactory.newAdvertisement(RouteAdvertisement.getAdvertisementType());

                r.setDest(ap);
                routes.add(r);
            }

            // now get the long routes
            // Use entrySet, there's no point in doing redundant lookups
            // in the map.
            for (Iterator i = router.getRoutedRouteAllDestinations(); i.hasNext();) {
                Map.Entry entry = (Map.Entry) i.next();

                routes.add((RouteAdvertisement) entry.getValue());
            }

            for (Iterator it = router.getPendingQueriesAllDestinations(); it.hasNext();) {
                Map.Entry entry = (Map.Entry) it.next();

                ea = (EndpointAddress) entry.getKey();
                AccessPointAdvertisement ap = (AccessPointAdvertisement)
                                              AdvertisementFactory.newAdvertisement(AccessPointAdvertisement.getAdvertisementType());

                ap.setPeerID(EndpointRouter.addr2pid(ea));
                Vector eas = new Vector();

                eas.add("pending " + (((EndpointRouter.ClearPendingQuery) entry.getValue()).isFailed() ? "(failed)" : "(new)"));
                ap.setEndpointAddresses(eas);
                RouteAdvertisement r = (RouteAdvertisement)
                                       AdvertisementFactory.newAdvertisement(RouteAdvertisement.getAdvertisementType());

                r.setDest(ap);
                routes.add(r);
            }
        } catch (Exception ex) {
            if (LOG.isEnabledFor(Level.WARN)) {
                LOG.warn("getAllRoutesInfo error : ", ex);
            }
        }
        return routes;
    }

    /**
     * get RouteCM usage
     */
    public boolean useRouteCM() {
        return router.getRouteCM().useRouteCM();
    }

    /**
     * get RouteResolver usage
     */
    public boolean useRouteResolver() {
        return router.getRouteResolver().useRouteResolver();
    }

    /**
     * enable usage of Route CM cache
     */
    public void enableRouteCM() {
        router.getRouteCM().enableRouteCM();
    }

    /**
     * disable usage of Route CM cache
     */
    public void disableRouteCM() {
        router.getRouteCM().disableRouteCM();
    }

    /**
     * enable usage of Route Resolver
     */
    public void enableRouteResolver() {
        router.getRouteResolver().enableRouteResolver();
    }

    /**
     * disable usage of Route resolver
     */
    public void disableRouteResolver() {
        router.getRouteResolver().disableRouteResolver();
    }
}