routecontrol.java

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

            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(pId);
                if (entry != null) { // ok we have a pending query
                    AccessPointAdvertisement ap = (AccessPointAdvertisement)
                            AdvertisementFactory.newAdvertisement(AccessPointAdvertisement.getAdvertisementType());

                    ap.setPeerID(pId);
                    Vector<String> eas = new Vector<String>();

                    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(pId);

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

        return OK;
    }

    /**
     * get all the know routes by the router. Return a vector of all
     * the routes known.
     * <p/>
     * 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<RouteAdvertisement> getAllRoutesInfo() {

        Vector<RouteAdvertisement> routes = new Vector<RouteAdvertisement>();
        EndpointAddress ea;

        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<String> eas = new Vector<String>();
                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<Map.Entry<ID, RouteAdvertisement>> i = router.getRoutedRouteAllDestinations(); i.hasNext();) {
                Map.Entry<ID, RouteAdvertisement> entry = i.next();

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

            for (Map.Entry<PeerID, EndpointRouter.ClearPendingQuery> entry : router.getPendingQueriesAllDestinations()) {
                PeerID pid = entry.getKey();
                AccessPointAdvertisement ap = (AccessPointAdvertisement)
                        AdvertisementFactory.newAdvertisement(AccessPointAdvertisement.getAdvertisementType());

                ap.setPeerID(pid);
                Vector<String> eas = new Vector<String>();

                eas.add("pending " + (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 (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                LOG.log(Level.WARNING, "getAllRoutesInfo error : ", ex);
            }
        }
        return routes;
    }

    /**
     * get RouteCM usage
     *
     * @return true if use route CM is set
     */
    public boolean useRouteCM() {
        return router.getRouteCM().useRouteCM();
    }

    /**
     * get RouteResolver usage
     *
     * @return true of use route resolver
     */
    public boolean useRouteResolver() {
        return router.getRouteResolver().useRouteResolver();
    }

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

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

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

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

    /**
     * Get the low level messenger for a destination.
     *
     * @param source  the source endpoint address
     * @param destination the destination endpoint address
     * @param messenger the messenger to add
     * @return true if successful
     */
    public boolean addMessengerFor(Object source, EndpointAddress destination, Messenger messenger) {
        return router.newMessenger(new MessengerEvent(source, messenger, destination));
    }

    /**
     * Get the low level messenger for a destination.
     *
     * @param destination the destination endpoint address
     * @param hint        route hint
     * @return  the messenger for the destination
     */
    public Messenger getMessengerFor(EndpointAddress destination, Object hint) {
        if (!(hint instanceof RouteAdvertisement)) {
            hint = null;
        }

        return router.ensureLocalRoute(destination, (RouteAdvertisement) hint);
    }
    /**
     * Determines whether a connection to a specific node exists, or if one can be created.
     * This method can block to ensure a usable connection exists, it does so by sending an empty
     * message.
     *
     * @param pid Node ID
     * @return true, if a connection already exists, or a new was sucessfully created
     */
    public boolean isConnected(PeerID pid) {
        Messenger messenger = getMessengerFor(new EndpointAddress("jxta", pid.getUniqueValue().toString(), null, null), null);
        if (messenger == null) {
            return false;
        }
        if ((messenger.getState() & Messenger.USABLE) != 0) {
            try {
                //ensure it can be used
                messenger.sendMessageB(new Message(), null, null);
            } catch (IOException io) {
                // determine whether it is usable
                return (messenger.getState() & Messenger.USABLE) != 0;
            }
        }
        return (messenger.getState() & Messenger.CLOSED) != Messenger.CLOSED;
    }
}