routecontrol.java

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

/*
 *
 * $Id: RouteControl.java,v 1.12 2006/07/24 01:01:37 hamada Exp $
 *
 * Copyright (c) 2001-2006 Sun Microsystems, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *       Sun Microsystems, Inc. for Project JXTA."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA"
 *    must not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact Project JXTA at http://www.jxta.org.
 *
 * 5. Products derived from this software may not be called "JXTA",
 *    nor may "JXTA" appear in their name, without prior written
 *    permission of Sun.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL SUN MICROSYSTEMS OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of Project JXTA.  For more
 * information on Project JXTA, please see
 * <http://www.jxta.org/>.
 *
 * This license is based on the BSD license adopted by the Apache Foundation.
 */

/**
 * This class is used to control the Router route options
 *
 */

package net.jxta.impl.endpoint.router;


import java.util.Vector;
import java.util.Iterator;
import java.util.Map;

import net.jxta.id.ID;
import net.jxta.peer.PeerID;
import net.jxta.protocol.AccessPointAdvertisement;
import net.jxta.protocol.RouteAdvertisement;
import net.jxta.endpoint.EndpointAddress;
import net.jxta.endpoint.Messenger;
import net.jxta.document.AdvertisementFactory;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;

public class RouteControl {

    /**
     *    Log4j Category
     */
    private static transient final Logger LOG = Logger.getLogger(RouteControl.class.getName());

    /**
     * return value for operation
     */
    public final static int OK = 0; // operation succeeded
    public final static int ALREADY_EXIST = 1; // failed route already exists
    public final static int FAILED = -1; // failed operation
    public final static int DIRECT_ROUTE = 2; // failed direct route
    public final static int INVALID_ROUTE = 3; // invalid route

    /**
     * Endpoint Router pointer
     */
    private final EndpointRouter router;

    /**
     * Router CM cache
     */
    private final RouteCM routeCM;

    /**
     * local Peer Id
     */
    private final ID localPeerId;

    /**
     * initialize RouteControl
     */
    public RouteControl(EndpointRouter router, ID pid) {
        this.router = router;
        this.routeCM = router.getRouteCM();
        this.localPeerId = pid;
    }

    /**
     * get my local route
     *
     * @return RoutAdvertisement of the local route
     */
    public RouteAdvertisement getMyLocalRoute() {
        return (RouteAdvertisement) router.getMyLocalRoute();
    }

    /**
     * add a new route. For the route to be useful, we actively try
     * the route by trying it
     *
     * @param newRoute route to add
     * @return Integer status (OK, FAILED, INVALID_ROUTE or ALREADY_EXIST)
     */
    public int addRoute(RouteAdvertisement newRoute) {

        RouteAdvertisement route = (RouteAdvertisement) ((RouteAdvertisement) newRoute).clone();

        // check if the destination is not ourself
        if (route.getDestPeerID().equals(localPeerId)) {
            if (LOG.isEnabledFor(Level.DEBUG)) {
                LOG.debug("Skipping Local peer addRoute");
            }
            return ALREADY_EXIST;
        }

        AccessPointAdvertisement firstHop = route.getFirstHop();
        PeerID firstHopPid = null;
        EndpointAddress firstHopAddr = null;

        // The route is not necessarily a direct route
        if (firstHop != null) {
            firstHopPid = firstHop.getPeerID();

            // The first hop is ourselves. Remove it a move to the new first
            // hop if any
            if (localPeerId.equals(firstHopPid)) {
                route.removeHop(firstHopPid);
                firstHop = route.getFirstHop();
            }
        }

        if (firstHop == null) { // It really is a direct route.

            // we only need to publish this route if
            // we don't know about it yet.
            EndpointAddress da = EndpointRouter.pid2addr(route.getDestPeerID());

            if (router.isLocalRoute(da) || router.isRoutedRoute(da)) {
                if (LOG.isEnabledFor(Level.DEBUG)) {
                    LOG.debug("addRoute: Skipping add Route "+da+" already exists");
                    LOG.debug("isLocalRoute() "+router.isLocalRoute(da)+" isRoutedRoute() : "+router.isRoutedRoute(da));
                }
                return ALREADY_EXIST;
            }

            // ok go ahead try to connect to the destination
            // using the route info
            if (router.ensureLocalRoute(da, route) == null) {
                if (LOG.isEnabledFor(Level.DEBUG)) {
                    LOG.debug("addRoute: Failed to connect to address :"+da.toString());
                }
                return FAILED;
            }

            // Use the original route for publication as we may later supply the advertisement to othe peers
            // which may make good use of ourselves as a first and only hop. (Normally routes are discovered
            // via route discovery, which automatically stiches routes to the respondant ahead of the
            // discovered route. But a discovered route adv is sometimes used as well).
            if (LOG.isEnabledFor(Level.DEBUG)) {
                LOG.debug("addRoute: Publishing route :"+newRoute.toString());
            }
            routeCM.publishRoute(newRoute);
            return OK;
        }

        // we have a long route

        // Manufacture a RA just that as just the routerPeer as a destination.
        // We only need to publish this route if we don't know about it yet.

        RouteAdvertisement firstHopRoute = null;

        firstHopPid = firstHop.getPeerID();
        firstHopAddr = EndpointRouter.pid2addr(firstHopPid);

        if (!(router.isLocalRoute(firstHopAddr) || router.isRoutedRoute(firstHopAddr))) {
            firstHopRoute = (RouteAdvertisement) AdvertisementFactory.newAdvertisement(RouteAdvertisement.getAdvertisementType());
            firstHopRoute.setDest((AccessPointAdvertisement) firstHop.clone());
            router.updateRouteAdv(firstHopRoute);
        }
        if (router.ensureLocalRoute(firstHopAddr, firstHopRoute) == null) {
            // could not find a route to the first hop, discard the route
            return FAILED;
        }

        router.setRoute((RouteAdvertisement) route.clone(), false);
        return OK;
    }