/** initialize routeResolver */
public void init(PeerGroup group, ID assignedID, Advertisement impl, EndpointRouter router)
throws PeerGroupException {
// extract Router service configuration properties
PlatformConfig confAdv = (PlatformConfig) group.getConfigAdvertisement();
Element paramBlock = null;
if (confAdv != null) {
paramBlock = confAdv.getServiceParam(assignedID);
}
if (paramBlock != null) {
// get our tunable router parameter
Enumeration param;
param = paramBlock.getChildren("useRouteResolver");
if (param.hasMoreElements()) {
useRouteResolver = Boolean.getBoolean(((TextElement) param.nextElement()).getTextValue());
}
}
this.group = group;
this.router = router;
localPeerId = group.getPeerID();
localPeerAddr =
new EndpointAddress("jxta", localPeerId.getUniqueValue().toString(), null, null);
}
/** {@inheritDoc} */
public boolean send(Message message) throws IOException {
if (closed) {
throw new IOException("Pipe closed");
}
Message msg = message.clone();
WireHeader header = new WireHeader();
header.setPipeID(getPipeID());
header.setSrcPeer(group.getPeerID());
header.setTTL(1);
header.setMsgId(WirePipe.createMsgId());
XMLDocument asDoc = (XMLDocument) header.getDocument(MimeMediaType.XMLUTF8);
MessageElement elem =
new TextDocumentMessageElement(WirePipeImpl.WIRE_HEADER_ELEMENT_NAME, asDoc, null);
msg.replaceMessageElement(WirePipeImpl.WIRE_HEADER_ELEMENT_NAMESPACE, elem);
checkMessenger();
try {
destMessenger.sendMessageB(msg, null, null);
} catch (IOException io) {
checkMessenger();
destMessenger.sendMessageB(msg, null, null);
}
return true;
}
/**
* 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);
}
}
}
/**
* Make this transport as up and running.
*
* <p>When this method is called, all the services are already registered with the peergroup. So
* we do not need to delay binding any further. All the public methods, which could be called
* between init and startApp are defensive regarding the services possibly not being there.
*/
public int startApp(String[] arg) {
resolver = group.getResolverService();
membership = group.getMembershipService();
if (null == resolver) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("Endpoint Router start stalled until resolver service available");
}
return Module.START_AGAIN_STALLED;
}
if (null == membership) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("Endpoint Router start stalled until membership service available");
}
return Module.START_AGAIN_STALLED;
}
resolver.registerHandler(routerSName, this);
// create and register the srdi service
srdiIndex = new SrdiIndex(group, srdiIndexerFileName);
// Srdi is a thread but we are not going to start,
// since the service is reactive.
srdi = new Srdi(group, routerSName, this, srdiIndex, 0, 0);
resolver.registerSrdiHandler(routerSName, this);
// obtain credential for resolver messages
try {
// FIXME 20041008 bondolo this needs to be converted to dynamically managing credentials.
// get the only credential "nobody"
credential = (Credential) membership.getDefaultCredential();
if (null != credential) {
credentialDoc = credential.getDocument(MimeMediaType.XMLUTF8);
}
} catch (Exception e) {
if (LOG.isEnabledFor(Level.ERROR)) {
LOG.error("failed to get credential", e);
}
}
// get the RouteCM cache service
routeCM = router.getRouteCM();
return 0;
}
/**
* Compat's (compatibility statements) serve to narrow the search for a ModuleImplAdvertisement.
* Basically you want something compatible with your group's implementation. Use this form for
* compatibilty with the current StdPeerGroup.
*
* @return -- boilerplate compat for StdPeerGroup
*/
public static XMLDocument buildCompat() {
try {
PeerGroup wpg = PeerGroup.globalRegistry.lookupInstance(PeerGroupID.worldPeerGroupID);
ModuleImplAdvertisement implAdv = wpg.getAllPurposePeerGroupImplAdvertisement();
wpg.unref();
XMLDocument compat = (XMLDocument) implAdv.getCompat();
return compat;
} catch (Exception e) {
// but if it doesn't work default to what was current on Feb 22 2006.
return buildCompat("JDK1.4.1", "V2.0 Ref Impl");
}
}
public static ModuleImplAdvertisement buildPeerGroupImplAdvertisement(
PeerGroup parent,
ModuleSpecID newGroupModuleSpecID,
String newDescription,
Map newServices,
Map newApps,
Map newProtos)
throws Exception {
// illegal types will cause an IllegalArgumentException
typeCheckKeys(newServices);
typeCheckValues(newServices);
typeCheckKeys(newApps);
typeCheckValues(newApps);
typeCheckKeys(newProtos);
typeCheckValues(newProtos);
// get a copy of parent's general purpose advert as a template
ModuleImplAdvertisement implAdv = parent.getAllPurposePeerGroupImplAdvertisement();
implAdv.setDescription(newDescription);
implAdv.setModuleSpecID(newGroupModuleSpecID);
// extract embedded ad for standard modules
TextElement paramElement = (TextElement) implAdv.getParam();
StdPeerGroupParamAdv paramAdv = new StdPeerGroupParamAdv(paramElement);
// alter services
Map services = paramAdv.getServices();
typeCheckKeys(services);
// mergeTables will override old services with new if base classes are the same
services = mergeTables(services, newServices);
paramAdv.setServices(services);
// alter apps
Map apps = paramAdv.getApps();
typeCheckKeys(apps);
apps = mergeTables(apps, newApps);
paramAdv.setApps(newApps);
// alter protos
Map protos = paramAdv.getProtos();
typeCheckKeys(protos);
apps = mergeTables(protos, newProtos);
paramAdv.setProtos(newProtos);
paramElement = (TextElement) paramAdv.getDocument(MimeMediaType.XMLUTF8);
implAdv.setParam(paramElement);
return implAdv;
}
/*
* push all srdi entries to the rednezvous SRDI cache (new connection)
*@param all if true push all entries, otherwise just deltas
*/
protected void pushSrdi(String peer, boolean all) {
SrdiMessage srdiMsg;
Vector routeIx = new Vector();
// 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.
// We cannot support concurrent modification of the map while we
// do that: we must synchronize...
for (Iterator each = router.getAllRoutedRouteAddresses(); each.hasNext(); ) {
PeerID pid = router.addr2pid((EndpointAddress) each.next());
SrdiMessage.Entry entry = new SrdiMessage.Entry(pid.toString(), "", Long.MAX_VALUE);
routeIx.addElement(entry);
}
try {
// check if we have anything to send
if (routeIx.size() == 0) {
return;
}
srdiMsg =
new SrdiMessageImpl(
group.getPeerID(),
1, // one hop
"route",
routeIx);
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("Sending a SRDI messsage of [All=" + all + "] routes");
}
// this will replicate entry to the SRDI replica peers
srdi.replicateEntries(srdiMsg);
} catch (Exception e) {
if (LOG.isEnabledFor(Level.WARN)) {
LOG.warn("SRDI Push failed", e);
}
}
}
/**
* Create a new blocking output pipe
*
* @param group The peergroup context.
* @param pAdv advertisement for the pipe we are supporting.
* @param peerID the destination <code>PeerID</code>.
* @param route the destination route.
* @throws IOException for failures creating a pipe to the destination peer.
*/
public BlockingWireOutputPipe(
PeerGroup group, PipeAdvertisement pAdv, PeerID peerID, RouteAdvertisement route)
throws IOException {
this.pAdv = pAdv;
this.group = group;
this.endpoint = group.getEndpointService();
destination =
new EndpointAddress(
"jxta", peerID.getUniqueValue().toString(), "PipeService", pAdv.getID().toString());
this.route = route;
checkMessenger();
if (Logging.SHOW_INFO && LOG.isLoggable(Level.INFO)) {
LOG.info("Created output pipe for " + getPipeID());
}
}
/*
* 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);
}
}
}
/**
* Process the Query, and generate response
*
* @param query the query to process
*/
public int processQuery(ResolverQueryMsg query) {
if (!useRouteResolver) { // Route resolver disabled
return ResolverService.OK;
}
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("processQuery starts");
}
RouteQuery routeQuery = null;
Reader ip = null;
try {
ip = new StringReader(query.getQuery());
StructuredTextDocument asDoc =
(StructuredTextDocument)
StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8, ip);
routeQuery = new RouteQuery(asDoc);
} catch (Throwable e) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("Malformed Route query ", e);
}
return ResolverService.OK;
} finally {
try {
if (null != ip) {
ip.close();
ip = null;
}
} catch (Throwable ignored) {;
}
}
PeerID pId = routeQuery.getDestPeerID();
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("processQuery: looking for route to " + pId);
}
RouteAdvertisement srcRoute = routeQuery.getSrcRoute();
List badHops = routeQuery.getBadHops();
if (LOG.isEnabledFor(Level.DEBUG)) {
if (badHops != null) {
LOG.debug("processQuery: bad Hops");
for (int i = 0; i < badHops.size(); i++) {
LOG.debug("processQuery: :" + ((PeerID) badHops.get(i)).toString());
}
}
}
// if our source route is not null, then publish it
if (srcRoute != null) {
if (!(srcRoute.getDestPeerID()).equals(localPeerId)) {
// This is not our own peer adv so we must not keep it
// longer than its expiration time.
try {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("processQuery: publishing sender route info " + srcRoute.getDestPeerID());
}
// we only need to publish this route if
// we don't know about it yet
// XXX: here is where we could be more conservative and use isNormallyReachable() instead,
// thus excluding
// incoming messengers.
if ((!router.isLocalRoute(router.pid2addr(srcRoute.getDestPeerID())))
&& (!router.isRoutedRoute(router.pid2addr(srcRoute.getDestPeerID())))) {
routeCM.publishRoute(srcRoute);
}
} catch (Exception e) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("Could not publish Route Adv from query - discard", e);
}
return ResolverService.OK;
}
}
} else {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("No src Route in route query - discard ");
}
return ResolverService.OK;
}
if (pId == null) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("Malformed route query request, no PeerId - discard");
}
return ResolverService.OK;
}
// We have more luck with that one because, since it is part of OUR
// message, and not part of the resolver protocol, it is in OUR
// format.
EndpointAddress qReqAddr = router.pid2addr(pId);
RouteAdvertisement route = null;
// check if this peer has a route to the destination
// requested
boolean found = false;
if (qReqAddr.equals(localPeerAddr)) {
found = true;
// return the route that is my local route
route = router.getMyLocalRoute();
} else {
// only rendezvous can respond to route requests
// if not we are generating too much traffic
// XXX: here is where we could be more conservative and use isNormallyReachable() instead,
// thus excluding
// incoming messengers.
if (router.isLocalRoute(qReqAddr)) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("processQuery: peer has direct route to destination ");
}
// we should set the route to something :-)
found = true;
// this peer has a direct route to the destination
// return the short route advertisement we know for this peer
// (For us it is zero hop, and we advertise ourself as the routing
// peer in the response. The stiching is done by whoever gets that
// response). May be there are more than one hop advertised in-there...
// alternate routing peers...should we leave them ?
// For now, we keep the full dest, but wack the hops.
route =
(RouteAdvertisement)
AdvertisementFactory.newAdvertisement(RouteAdvertisement.getAdvertisementType());
AccessPointAdvertisement ap =
(AccessPointAdvertisement)
AdvertisementFactory.newAdvertisement(
AccessPointAdvertisement.getAdvertisementType());
ap.setPeerID(pId);
route.setDest(ap);
} else {
route = router.getRoute(qReqAddr, false);
if (route != null) {
found = true;
// check if we were given some bad hops info
// and see if the found route contains
// any of these bad hops. In that case, we need
// to mark this route as bad
for (int i = 0; i < badHops.size(); i++) {
// destination is known to be bad
if (router.addr2pid(qReqAddr).equals(((PeerID) badHops.get(i)))) {
processBadRoute((PeerID) badHops.get(i), route);
found = false;
break;
}
if (route.containsHop((PeerID) badHops.get(i))) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug(
"processQuery: peer has bad route due to "
+ ((PeerID) badHops.get(i)).toString());
}
processBadRoute((PeerID) badHops.get(i), route);
found = false;
break;
}
}
}
}
}
if (!found) {
// discard the request if we are not a rendezvous
// else forward to the next peers
if (!group.isRendezvous()) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("discard query forwarding as not a rendezvous");
}
return ResolverService.OK;
}
// did not find a route, check our srdi cache
// make sure we protect against out of sync
// SRDI index
// srdi forwarding is only involved once the Index entry has
// been found and we forwarded the resolver query. Afterward a
// normal walk proceeds from the initial SRDI index pointing
// rdv. This is done to protect against potential loopback
// entries in the SRDI cache index due to out of sync peerview
// and index.
if (query.getHopCount() < 2) {
// check local SRDI cache to see if we have the entry
// we look for 10 entries, will pickup one randomly
Vector results = srdiIndex.query("route", "DstPID", pId.toString(), 10);
if (results.size() > 0) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("processQuery srdiIndex lookup match :" + results.size());
}
// remove any non-rdv peers to avoid sending
// to a non-rdv peers and garbage collect the SRDI
// index in the process
Vector clean = cleanupAnyEdges(query.getSrc(), results);
if (clean.size() > 0) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("found an srdi entry forwarding query to SRDI peer");
}
// 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();
// Note: this forwards the query to 1 peer randomly
// selected from the result
srdi.forwardQuery(clean, query, 1);
// tell the resolver no further action is needed.
return ResolverService.OK;
}
}
}
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("did not find a route or SRDI index");
}
// force a walk
return ResolverService.Repropagate;
}
// we found a route send the response
try {
if (route == null) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("we should have had a route at this point");
}
return ResolverService.OK;
}
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("processQuery: we have a route build route response" + route.display());
}
RouteAdvertisement myRoute = router.getMyLocalRoute();
// make sure we initialized our local
// route info as we will need it to respond. We may
// not have our route if we are still
// waiting for a relay connection.
if (myRoute == null) {
return ResolverService.OK;
}
RouteResponse routeResponse = new RouteResponse();
routeResponse.setDestRoute(route);
routeResponse.setSrcRoute(myRoute);
if (routeResponse == null) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("error creating route response");
}
return ResolverService.OK;
}
// construct a response from the query
ResolverResponseMsg res = query.makeResponse();
res.setCredential(credentialDoc);
res.setResponse(routeResponse.toString());
resolver.sendResponse(query.getSrc(), res);
return ResolverService.OK;
} catch (Exception ee) {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("processQuery: error while processing query ", ee);
}
return ResolverService.OK;
}
}
/**
* 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);
}
}
}
/**
* process an SRDI message request
*
* @param message SRDI resolver message
*/
public boolean processSrdi(ResolverSrdiMsg message) {
String value;
SrdiMessage srdiMsg;
try {
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug("Received a SRDI messsage in group" + group.getPeerGroupName());
}
XMLDocument asDoc =
(XMLDocument)
StructuredDocumentFactory.newStructuredDocument(
MimeMediaType.XMLUTF8, new StringReader(message.getPayload()));
srdiMsg = new SrdiMessageImpl(asDoc);
} catch (Exception e) {
// we don't understand this msg, let's skip it
if (LOG.isEnabledFor(Level.WARN)) {
LOG.warn("corrupted SRDI message", e);
}
return false;
}
PeerID pid = srdiMsg.getPeerID();
// filter messages that contain messages
// about the local peer, so we don't enter
// self-reference
if (pid.equals(localPeerId)) {
return false;
}
Iterator eachEntry = srdiMsg.getEntries().iterator();
while (eachEntry.hasNext()) {
SrdiMessage.Entry entry = (SrdiMessage.Entry) eachEntry.next();
// drop any information about ourself
if (entry.key.equals(localPeerId.toString())) {
continue;
}
value = entry.value;
if (value == null) {
value = "";
}
// Expiration of entries is taken care of by SrdiIdex, so we always add
// FIXME hamada 03142003
// All routes are added under the secondary key 'DstPID', it would be more correct to
// Specify it in the message, but since versioning is not yet supported the following is
// acceptable, since it is localized
srdiIndex.add(srdiMsg.getPrimaryKey(), "DstPID", entry.key, pid, entry.expiration);
if (LOG.isEnabledFor(Level.DEBUG)) {
LOG.debug(
"Primary Key ["
+ srdiMsg.getPrimaryKey()
+ "] key [DstPID]"
+ " value ["
+ entry.key
+ "] exp ["
+ entry.expiration
+ "]");
}
}
return true;
}
public static void main(String[] args) {
try {
// Removing any existing configuration?
Tools.CheckForExistingConfigurationDeletion(Name, ConfigurationFile);
// Creation of network manager
NetworkManager MyNetworkManager =
new NetworkManager(NetworkManager.ConfigMode.EDGE, Name, ConfigurationFile.toURI());
// Retrieving the network configurator
NetworkConfigurator MyNetworkConfigurator = MyNetworkManager.getConfigurator();
// Checking if RendezVous_Adelaide_At_One_End should be a seed
MyNetworkConfigurator.clearRendezvousSeeds();
String TheSeed =
"tcp://"
+ InetAddress.getLocalHost().getHostAddress()
+ ":"
+ RendezVous_Adelaide_At_One_End.TcpPort;
Tools.CheckForRendezVousSeedAddition(Name, TheSeed, MyNetworkConfigurator);
// Setting Configuration
MyNetworkConfigurator.setTcpPort(TcpPort);
MyNetworkConfigurator.setTcpEnabled(true);
MyNetworkConfigurator.setTcpIncoming(true);
MyNetworkConfigurator.setTcpOutgoing(true);
// Setting the Peer ID
Tools.PopInformationMessage(Name, "Setting the peer ID to :\n\n" + PID.toString());
MyNetworkConfigurator.setPeerID(PID);
// Starting the JXTA network
Tools.PopInformationMessage(
Name,
"Start the JXTA network and to wait for a rendezvous connection with\n"
+ RendezVous_Adelaide_At_One_End.Name
+ " for maximum 2 minutes");
PeerGroup NetPeerGroup = MyNetworkManager.startNetwork();
// Disabling any rendezvous autostart
NetPeerGroup.getRendezVousService().setAutoStart(false);
if (MyNetworkManager.waitForRendezvousConnection(120000)) {
Tools.popConnectedRendezvous(NetPeerGroup.getRendezVousService(), Name);
} else {
Tools.PopInformationMessage(Name, "Did not connect to a rendezvous");
}
// Preparing the listener and Creating the BiDiPipe
PipeMsgListener MyListener = new Edge_Quinisela_At_The_Other_End();
JxtaBiDiPipe MyBiDiPipe =
new JxtaBiDiPipe(
NetPeerGroup,
RendezVous_Adelaide_At_One_End.GetPipeAdvertisement(),
30000,
MyListener);
if (MyBiDiPipe.isBound()) {
Tools.PopInformationMessage(Name, "Bidirectional pipe created!");
// Sending a hello message !!!
Message MyMessage = new Message();
StringMessageElement MyStringMessageElement =
new StringMessageElement("HelloElement", "Hello from " + Name, null);
MyMessage.addMessageElement("DummyNameSpace", MyStringMessageElement);
MyBiDiPipe.sendMessage(MyMessage);
// Sleeping for 10 seconds
Tools.GoToSleep(10000);
// Sending a goodbye message !!!
MyMessage = new Message();
MyStringMessageElement =
new StringMessageElement("HelloElement", "Goodbye from " + Name, null);
MyMessage.addMessageElement("DummyNameSpace", MyStringMessageElement);
MyBiDiPipe.sendMessage(MyMessage);
// Sleeping for 10 seconds
Tools.GoToSleep(10000);
}
// Closing the bidipipe
MyBiDiPipe.close();
// Stopping the network
Tools.PopInformationMessage(Name, "Stop the JXTA network");
MyNetworkManager.stopNetwork();
} catch (IOException Ex) {
// Raised when access to local file and directories caused an error
Tools.PopErrorMessage(Name, Ex.toString());
} catch (PeerGroupException Ex) {
// Raised when the net peer group could not be created
Tools.PopErrorMessage(Name, Ex.toString());
}
}
/** {@inheritDoc} */
public ID getPeerID() {
return peergroup.getPeerID();
}
///////////////////////////////////////////////////////////////////
//// public methods ////
public void preinitialize() throws IllegalActionException {
super.preinitialize();
PropertyConfigurator.configure(System.getProperties());
// if (configDir.hasToken()) {
// String Dir = ((StringToken)configDir.getToken()).stringValue();
// } else {
String Dir = "c:/Cygwin/home/ellen_zh/ptII/ptolemy/actor/lib/jxta";
// }
// if (actorList.hasToken()) {
// String _actorListFileName = ((StringToken)actorList.getToken()).stringValue();
// } else {
String _actorListFileName = "c:/Cygwin/home/ellen_zh/ptII/ptolemy/actor/lib/jxta/actors.xml";
// }
_properties = new Properties(System.getProperties());
InputStream configProperties = null;
try {
configProperties = new FileInputStream(_CONFIG_FILE);
_properties.load(configProperties);
} catch (IOException e) {
System.out.println(
"Warning: Can't find configuration propertiees file. ' " + e.getMessage() + "'");
} finally {
if (configProperties != null) {
try {
configProperties.close();
} catch (Throwable throwable) {
System.out.println("Ignoring failure to close stream " + "on '" + _CONFIG_FILE + "'");
throwable.printStackTrace();
}
}
}
PeerGroup netPeerGroup = null;
try {
netPeerGroup = PeerGroupFactory.newNetPeerGroup();
} catch (PeerGroupException ex) {
System.out.println("Error: cannot locate net peer group.\n" + ex.getMessage());
}
// load the peer group adv for actor exchange
String groupAdvFileName = _properties.getProperty("GroupAdvFileName");
if (groupAdvFileName == null) {
System.out.println("Error: property undefined - GroupAdvFileName.\n");
}
PeerGroupAdvertisement groupAdv = null;
try {
groupAdv =
(PeerGroupAdvertisement)
AdvertisementFactory.newAdvertisement(
XML_MIME_TYPE, new FileInputStream(Dir + "/" + groupAdvFileName));
} catch (FileNotFoundException ex) {
System.out.println("Error: cannot find group adv file.\n" + ex.getMessage());
} catch (IOException ex) {
System.out.println("Error: reading group adv file.\n" + ex.getMessage());
}
System.out.println("peer groupAdv: " + groupAdvFileName);
System.out.println("success before instantiate peer group");
// instantiate the peer group for actor exchange
try {
_group = netPeerGroup.newGroup(groupAdv);
} catch (PeerGroupException ex) {
System.out.println("Error: cannot instantiate peer group.\n" + ex.getMessage());
}
// join the peer group for actor exchange
// no authentication is done here
// modeled after JoinDemo from JXTA Examples
StructuredDocument identityInfo = null;
try {
AuthenticationCredential authCred = new AuthenticationCredential(_group, null, identityInfo);
MembershipService membershipService = _group.getMembershipService();
_authenticator = membershipService.apply(authCred);
if (_authenticator.isReadyForJoin()) {
_credential = membershipService.join(_authenticator);
System.out.println("Info: join group successful.");
_credential.getDocument(XML_MIME_TYPE).sendToStream(System.out);
} else {
System.out.println("Error: unable to join group.");
}
} catch (Exception ex) {
System.out.println("Error: failure in authentication.\n" + ex.getMessage());
}
_discoveryService = _group.getDiscoveryService();
_discoveryService.addDiscoveryListener(this);
_resolverService = _group.getResolverService();
// register this as a query handler
_resolverService.registerHandler(_ACTOR_QUERY_HANDLER_NAME, this);
// construct the actor query message
StringBuffer queryTextBuffer = new StringBuffer("<?xml version=\"1.0\"?>\n\n");
queryTextBuffer = queryTextBuffer.append("<ActorQuery>\n");
queryTextBuffer = queryTextBuffer.append("What actors do you have?");
queryTextBuffer = queryTextBuffer.append("\n</ActorQuery>\n");
_actorQueryMessage =
new ResolverQuery(_ACTOR_QUERY_HANDLER_NAME, null, null, queryTextBuffer.toString(), 0);
_actorQueryMessage.setSrc(_group.getPeerID().toString());
// construct the actor query response message
if (_actorListFileName != null) {
StringBuffer actorListText = new StringBuffer();
BufferedReader fileReader = null;
try {
fileReader = new BufferedReader(new FileReader(_actorListFileName));
String newline = System.getProperty("line.separator");
while (true) {
String line = fileReader.readLine();
if (line == null) {
break;
}
actorListText = actorListText.append(line);
actorListText = actorListText.append(newline);
}
_actorQueryResponse =
new ResolverResponse(_ACTOR_QUERY_HANDLER_NAME, null, 0, actorListText.toString());
} catch (IOException ex) {
System.out.println("Warning: error reading actor list file.\n" + ex.getMessage());
} finally {
if (fileReader != null) {
try {
fileReader.close();
} catch (Exception ex) {
System.out.println("Failed to close: " + ex.getMessage());
}
}
}
}
}