/**
* 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);
}
}
}
/*
* 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);
}
}
}
/**
* 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);
}
}
}
