Esempio n. 1
0
  /**
   * remove a SRDI cache entry
   *
   * @param peer peer id we send the request, null for sending to all
   * @param id peer id of the SRDI route that we want to remove from the cache
   */
  protected void removeSrdi(String peer, PeerID id) {

    SrdiMessage srdiMsg;

    try {
      srdiMsg =
          new SrdiMessageImpl(
              group.getPeerID(),
              1, // only one hop
              "route",
              id.toString(),
              null, // 0 means remove
              new Long(0).longValue());
      if (LOG.isEnabledFor(Level.DEBUG)) {
        LOG.debug("sending a router SRDI message delete route " + id);
      }
      if (peer == null) {
        PeerID destPeer = srdi.getReplicaPeer(id.toString());

        // don't push anywhere if we do not have replica
        // or we are trying to push to ouself
        if (destPeer != null && (!destPeer.equals(localPeerId))) {
          srdi.pushSrdi(destPeer, srdiMsg);
        }
      }
    } catch (Exception e) {
      if (LOG.isEnabledFor(Level.DEBUG)) {
        LOG.debug("Removing srdi entry failed", e);
      }
    }
  }
Esempio n. 2
0
  /*
   * push srdi entries to the SRDI rendezvous cache
   * @param all if true push all entries, otherwise just deltas
   */
  protected void pushSrdi(ID peer, PeerID id) {

    SrdiMessage srdiMsg;

    try {
      srdiMsg =
          new SrdiMessageImpl(
              group.getPeerID(),
              1, // only one hop
              "route",
              id.toString(),
              null,
              new Long(Long.MAX_VALUE).longValue()); // maximum expiration
      // 10182002tra:Route info don't expire unless the peer disappears
      // This approach is used to limit the SRDI traffic. The key
      // point here is that SRDI is used to tell a peer that another
      // has a route to the destination it is looking for. The information
      // that SRDI cache is not so much the specific route info but rather
      // the fact that a peer has knowledge of a route to another peer
      // We don't want to update the SRDI cache on every route update.
      // The SRDI cache will be flushed when the peer disconnect from
      // the rendezvous.
      if (LOG.isEnabledFor(Level.DEBUG)) {
        LOG.debug("sending a router SRDI message add route " + id);
      }
      if (peer == null) {
        PeerID destPeer = srdi.getReplicaPeer(id.toString());

        peer = destPeer;
      }
      // don't push anywhere if we do not have a replica
      // or we are trying to send the query to ourself
      if (!localPeerId.equals(peer)) {
        srdi.pushSrdi(peer, srdiMsg);
      }
    } catch (Exception e) {
      if (LOG.isEnabledFor(Level.WARN)) {
        LOG.warn("SRDI push failed", e);
      }
    }
  }
Esempio n. 3
0
  /**
   * issue a new route discovery resolver request
   *
   * @param peer the destination as a logical enpoint address
   */
  protected void findRoute(EndpointAddress peer) {

    RouteAdvertisement myRoute = router.getMyLocalRoute();

    // No need to pursue further if we haven't
    // initialize our own route as responding
    // peers are not going to be able to respond to us.
    if (myRoute == null) {
      if (LOG.isEnabledFor(Level.DEBUG)) {
        LOG.debug("Cannot issue a find route if we don't know our own route");
      }
      return;
    }

    if (LOG.isEnabledFor(Level.DEBUG)) {
      LOG.debug("Find route for peer = " + peer);
    }

    try {
      // create a new RouteQuery message
      RouteQuery doc = null;

      // check if we have some bad route information
      // for that peer, in that case pass the bad hop count
      BadRoute badRoute;

      badRoute = (BadRoute) router.getBadRoute(peer);

      if (badRoute != null) {
        // ok we have a bad route
        // pass the bad hops info as part of the query
        if (LOG.isEnabledFor(Level.DEBUG)) {
          LOG.debug("findRoute sends query: known bad Hops" + badRoute.display());
        }
        doc = new RouteQuery(router.addr2pid(peer), myRoute, badRoute.getHops());
      } else {
        doc = new RouteQuery(router.addr2pid(peer), myRoute, null);
      }

      if (LOG.isEnabledFor(Level.DEBUG)) {
        LOG.debug("Sending query for peer : " + peer);
      }

      ResolverQuery query =
          new ResolverQuery(
              routerSName, credentialDoc, localPeerId.toString(), doc.toString(), qid++);

      // only run SRDI if we are a rendezvous
      if (group.isRendezvous()) {

        // check where to send the query via SRDI
        Vector results = null;

        if (srdiIndex != null) {
          // try to find a least 10 entries, will pick up one
          // randomly. This will protect against retry. It is
          // likely that a number of RDV will know about a route
          results = srdiIndex.query("route", "DstPID", router.addr2pid(peer).toString(), 10);

          if (results != null && results.size() > 0) {
            // use SRDI to send the query
            // remove any non rdv peers from the candidate list
            // and garbage collect the index in the process
            Vector clean = cleanupAnyEdges(query.getSrc(), results);

            if (clean.size() > 0) {
              // The purpose of incrementing the hopcount
              // when an SRDI index match is found (we got a
              // pointer to a rdv that should have the route) is to
              // restrict any further forwarding. The increment
              // count is only done when a matching SRDI index is
              // found. Not when the replica is selected as we
              // still need to forward the query.  This restriction
              // is purposelly done to avoid too many longjumps
              // within a walk.
              query.incrementHopCount();

              srdi.forwardQuery(clean, query, 1);
              if (LOG.isEnabledFor(Level.DEBUG)) {
                LOG.debug("found an srdi entry forwarding query to SRDI peer");
              }
              return;
            }
          } else {
            // it is not in our cache, look for the replica peer
            // we need to send the query
            PeerID destPeer = srdi.getReplicaPeer(router.addr2pid(peer).toString());

            if (destPeer != null && !destPeer.equals(localPeerId)) {
              // don't push anywhere if we do not have a replica
              // or we are trying to push to ourself
              if (LOG.isEnabledFor(Level.DEBUG)) {
                LOG.debug("processQuery srdiIndex DHT forward :" + destPeer);
              }

              srdi.forwardQuery(destPeer.toString(), query);
              return;
            }
          }
        }
      }

      // if we reach that point then we just use the resolver walk
      resolver = group.getResolverService();
      if (resolver != null) {
        resolver.sendQuery(null, query);
        if (LOG.isEnabledFor(Level.DEBUG)) {
          LOG.debug("find route query sent");
        }
      } else {
        if (LOG.isEnabledFor(Level.WARN)) {
          LOG.warn("cannot get the resolver service");
        }
      }

    } catch (Exception ee) {
      if (LOG.isEnabledFor(Level.WARN)) {
        LOG.warn("Exception in findRoute", ee);
      }
    }
  }