Examples of net.tomp2p.message.Message

net.tomp2p.message.Message
The message is in binary format in TomP2P. It has several header and payload fields. Since we do the serialization/encoding manually, we do not need a serialization field. @author Thomas Bocek


  public FutureResponse getFromTracker(final PeerAddress remotePeer, GetTrackerBuilder builder,
          ChannelCreator channelCreator) {


    Utils.nullCheck(remotePeer, builder.locationKey(), builder.domainKey());
    final Message message = createMessage(remotePeer, RPC.Commands.TRACKER_GET.getNr(), Type.REQUEST_1);
    if (builder.isSign()) {
      message.publicKeyAndSign(builder.keyPair());
    }
    message.key(builder.locationKey());
    message.key(builder.domainKey());
    // TODO: make this always a bloom filter
    if (builder.knownPeers() != null && (builder.knownPeers() instanceof SimpleBloomFilter)) {
      message.bloomFilter((SimpleBloomFilter<Number160>) builder.knownPeers());
    }


    FutureResponse futureResponse = new FutureResponse(message);
    addTrackerDataListener(futureResponse, new Number320(builder.locationKey(), builder.domainKey()));

View Full Code Here

      public void operationComplete(FutureResponse future) throws Exception {
        if (future.isSuccess()) {
          // Since I might become a tracker as well, we keep this
          // information
          // about those trackers.
          Message message = future.responseMessage();
          TrackerData tmp = message.trackerData(0);
          // no data found
          if (tmp == null || tmp.size() == 0) {
            return;
          }

View Full Code Here

    LOG.debug("handleResponse on {}", message.recipient());
    if (!((message.type() == Type.REQUEST_1 || message.type() == Type.REQUEST_3) && message.key(0) != null && message
            .key(1) != null)) {
      throw new IllegalArgumentException("Message content is wrong");
    }
    final Message responseMessage = createResponseMessage(message, Type.OK);


    // get data
    Number160 locationKey = message.key(0);
    Number160 domainKey = message.key(1);
    SimpleBloomFilter<Number160> knownPeers = message.bloomFilter(0);


    PublicKey publicKey = message.publicKey(0);
    //
    TrackerData meshPeers = trackerStorage.peers(new Number320(locationKey, domainKey));
    
    LOG.debug("found peers on tracker: {}", meshPeers == null ? "null " : meshPeers.peerAddresses());


    boolean couldProvideMoreData = false;
    if (meshPeers != null) {
      if (knownPeers != null) {
        meshPeers = UtilsTracker.disjunction(meshPeers, knownPeers);
      }
      int size = meshPeers.size();


      meshPeers = UtilsTracker.limit(meshPeers, TrackerRPC.MAX_MSG_SIZE_UDP);
      couldProvideMoreData = size > meshPeers.size();
      responseMessage.trackerData(meshPeers);
    }


    if (couldProvideMoreData) {
      responseMessage.type(Message.Type.PARTIALLY_OK);
    }


    if (message.command() == RPC.Commands.TRACKER_ADD.getNr()) {
      TrackerData trackerData = message.trackerData(0);
      if (trackerData.size() != 1) {
        responseMessage.type(Message.Type.EXCEPTION);
      } else {
        Map.Entry<PeerStatistic, Data> entry = trackerData.peerAddresses().entrySet().iterator().next();
        if (!trackerStorage.put(new Number320(locationKey, domainKey), entry.getKey().peerAddress(), publicKey,
                entry.getValue())) {
          responseMessage.type(Message.Type.DENIED);
          LOG.debug("tracker NOT put on({}) locationKey:{}, domainKey:{}, address:{}", peerBean()
                  .serverPeerAddress(), locationKey, domainKey, entry.getKey());
        } else {
          LOG.debug("tracker put on({}) locationKey:{}, domainKey:{}, address: {}", peerBean()
                  .serverPeerAddress(), locationKey, domainKey, entry.getKey());
        }
      }


    } else {
      LOG.debug("tracker get on({}) locationKey:{}, domainKey:{}, address:{}, returning: {}", peerBean()
              .serverPeerAddress(), locationKey, domainKey, message.sender(), (meshPeers == null ? "0"
              : meshPeers.size()));
    }
    if (sign) {
      responseMessage.publicKeyAndSign(peerBean().getKeyPair());
    }
    responder.response(responseMessage);
  }

View Full Code Here

        } else {
          sender = new InetSocketAddress(0);
        }
        
        Buffer requestBuffer = message.buffer(0);
        Message realMessage = RelayUtils.decodeRelayedMessage(requestBuffer, message.recipientSocket(), sender, signatureFactory());
        realMessage.restoreContentReferences();


        LOG.debug("Received message from relay peer: {}", realMessage);
        
        final Message envelope = createResponseMessage(message, Type.OK);
        final Responder responder = new Responder() {
          //TODO: add reply leak handler
          @Override
          public void response(Message responseMessage) {
            LOG.debug("Send reply message to relay peer: {}", responseMessage);
            try {
              if(responseMessage.sender().isRelayed() && !responseMessage.sender().peerSocketAddresses().isEmpty()) {
                responseMessage.peerSocketAddresses(responseMessage.sender().peerSocketAddresses());
              }
              envelope.buffer(RelayUtils.encodeMessage(responseMessage, signatureFactory()));
                } catch (Exception e) {
                  LOG.error("Cannot piggyback the response", e);
                  failed(Type.EXCEPTION, e.getMessage());
                }
                responderToRelay.response(envelope);

View Full Code Here

          forwarder.setPeerMap(RelayUtils.unflatten(map, message.sender()));
        } else {
            LOG.error("No forwarder for peer {} found. Need to setup relay first");
        }
        
        Message response = createResponseMessage(message, Type.OK);
        responder.response(response);
    }

View Full Code Here

    BaseRelayForwarderRPC forwarderRPC = forwarders.get(message.sender().peerId());
    if(forwarderRPC instanceof AndroidForwarderRPC) {
      AndroidForwarderRPC androidForwarder = (AndroidForwarderRPC) forwarderRPC;
      
      try {
        Message response = createResponseMessage(message, Type.OK);
        // add all buffered messages
        response.buffer(androidForwarder.getBufferedMessages());
        
        LOG.debug("Responding all buffered messages to Android device {}", message.sender());
        responder.response(response);
      } catch(Exception e) {
        LOG.error("Cannot respond with buffered messages.", e);

View Full Code Here

  private void handleLateResponse(Message message, PeerConnection peerConnection, boolean sign, Responder responder) {
    if(!message.sender().isSlow() ||  message.bufferList().isEmpty()) {
            throw new IllegalArgumentException("Late response does not come from slow peer or does not contain the buffered message");
      }
    
    Message realMessage = null;
    try {
      realMessage = RelayUtils.decodeRelayedMessage(message.buffer(0), message.recipientSocket(),
          message.senderSocket(), signatureFactory());
    } catch (Exception e) {
      LOG.error("Cannot decode the late response", e);
      responder.response(createResponseMessage(message, Type.EXCEPTION));
      return;
    }
    
    LOG.debug("Received late response from slow peer: {}", realMessage);
      // only the case when a unreachable peer makes a request to another slow, unreachable peer
      Map<Integer, FutureResponse> pendingRequests = dispatcher().getPendingRequests();
      FutureResponse pendingRequest = pendingRequests.remove(realMessage.messageId());
      if (pendingRequest != null) {
        // we waited for this response, answer it
        pendingRequest.response(realMessage);


        // send ok, not fire and forget - style
        LOG.debug("Successfully answered pending request {} with {}", pendingRequest.request(), realMessage);
        responder.response(createResponseMessage(message, Type.OK, message.recipient()));
      } else {
        // handle Relayed <--> Relayed.
        // This could be a pending message for one of the relayed peers, not for this peer
        BaseRelayForwarderRPC forwarder = forwarders.get(realMessage.recipient().peerId());
        if (forwarder == null) {
          LOG.error("Forwarder for the relayed peer not found. Cannot send late response {}", realMessage);
          responder.response(createResponseMessage(message, Type.NOT_FOUND));
        } else {
           // because buffer is re-encoded when forwarding it to unreachable

View Full Code Here

        } else {
            dataMap = new DataMap(putBuilder.locationKey(), putBuilder.domainKey(),
                    putBuilder.versionKey(), putBuilder.dataMapContent());
        }


        final Message message = createMessage(remotePeer, RPC.Commands.PUT.getNr(), type);


        if (putBuilder.isSign()) {
            message.publicKeyAndSign(putBuilder.keyPair());
        }


        message.setDataMap(dataMap);


        final FutureResponse futureResponse = new FutureResponse(message);
        final RequestHandler<FutureResponse> request = new RequestHandler<FutureResponse>(futureResponse,
                peerBean(), connectionBean(), putBuilder);

View Full Code Here

        } else {
          //change entry protection key, or set timestamp
          type = Type.REQUEST_1;
        }


        final Message message = createMessage(remotePeer, RPC.Commands.PUT_META.getNr(), type);


        if (putBuilder.isSign()) {
            message.publicKeyAndSign(putBuilder.keyPair());
        } else if (type == Type.REQUEST_2) {
          throw new IllegalAccessError("can only change public key if message is signed");
        }
        
        if (putBuilder.changePublicKey()!=null) {
          message.key(putBuilder.locationKey());
          message.key(putBuilder.domainKey());
          message.publicKey(putBuilder.changePublicKey());
        } else {
          message.setDataMap(dataMap);
        }


        final FutureResponse futureResponse = new FutureResponse(message);
        final RequestHandler<FutureResponse> request = new RequestHandler<FutureResponse>(futureResponse,
                peerBean(), connectionBean(), putBuilder);

View Full Code Here

    } else {
      dataMap = new DataMap(putBuilder.locationKey(), putBuilder.domainKey(),
          putBuilder.versionKey(), putBuilder.dataMapContent());
    }


    final Message message = createMessage(remotePeer, RPC.Commands.PUT_CONFIRM.getNr(), Type.REQUEST_1);


    if (putBuilder.isSign()) {
      message.publicKeyAndSign(putBuilder.keyPair());
    }


    message.setDataMap(dataMap);


    final FutureResponse futureResponse = new FutureResponse(message);
    final RequestHandler<FutureResponse> request = new RequestHandler<FutureResponse>(futureResponse,
        peerBean(), connectionBean(), putBuilder);

View Full Code Here

0 1 2 3 4 5 6 7

TOP

Related Classes of net.tomp2p.message.Message

net.tomp2p.connection.ChannelCreator

net.tomp2p.connection.Dispatcher

net.tomp2p.connection.Dispatcher$DirectResponder

net.tomp2p.connection.Sender

net.tomp2p.dht.StorageRPC

net.tomp2p.dht.TestStorageDHT

net.tomp2p.dht.UtilsDHT2

net.tomp2p.message.TestMessageInterop

net.tomp2p.nat.PeerNAT

net.tomp2p.p2p.builder.BroadcastBuilder

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.