/** 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;
  }
Exemple #5
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");
    }
  }
Exemple #6
0
  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);
      }
    }
  }
Exemple #10
0
  /**
   * 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;
    }
  }
Exemple #11
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);
      }
    }
  }
Exemple #12
0
  /**
   * 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();
 }
Exemple #15
0
  ///////////////////////////////////////////////////////////////////
  ////                         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());
          }
        }
      }
    }
  }