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 void operationComplete(final FuturePeerConnection future) throws Exception {
          if (future.isSuccess() && future.peerConnection() != null) {
            // successfully created a connection from unreachable to the requester
            final PeerConnection peerConnection = future.peerConnection();
            
            final Message readyMessage = createReadyForRequestMessage(message, peerConnection.remotePeer());
            FutureResponse futureResponse = RelayUtils.send(peerConnection, peer.peerBean(),
                peer.connectionBean(), config, readyMessage);
            futureResponse.addListener(new BaseFutureAdapter<FutureResponse>() {
              @Override
              public void operationComplete(final FutureResponse future) throws Exception {

View Full Code Here

   * @param message
   * @param receiver
   * @return setupMessage
   */
  private Message createReadyForRequestMessage(final Message message, final PeerAddress receiver) {
    Message readyForRequestMessage = createMessage(receiver, RPC.Commands.RCON.getNr(), Message.Type.REQUEST_3);


    if (!message.intList().isEmpty()) {
      // forward the message id to indentify the cached message afterwards
      readyForRequestMessage.intValue(message.intAt(0));
    }


    // keep the new connection open
    readyForRequestMessage.keepAlive(true);


    return readyForRequestMessage;
  }

View Full Code Here

      storePeerConnection(message, peerConnection);
      responder.response(createResponseMessage(message, Type.OK).keepAlive(true));
    } else {
      ConcurrentHashMap<Integer, FutureResponse> cachedRequests = peer.connectionBean().sender().cachedRequests();
      final FutureResponse cachedRequest = cachedRequests.remove(message.intAt(0));
      final Message cachedMessage = cachedRequest.request();
      LOG.debug("This reverse connection is only used for sending a direct message {}", cachedMessage);


      // send the message to the unreachable peer through the open channel
      FutureResponse futureResponse = RelayUtils.send(peerConnection, peer.peerBean(), peer.connectionBean(), config,
          cachedMessage);
      futureResponse.addListener(new BaseFutureAdapter<FutureResponse>() {
        @Override
        public void operationComplete(final FutureResponse future) throws Exception {
          if (future.isSuccess()) {
            LOG.debug("Successfully transmitted request message {} to unreachablePeer {}", cachedMessage,
                peerConnection.remotePeer());
            cachedRequest.response(future.responseMessage());
            
            // we must make sure that the PeerConnection is closed, because it takes a lot of
            // resources from the running pc
            Message responseMessage = createResponseMessage(message, Type.OK).keepAlive(false);
            LOG.debug("Returning OK for delivering single message over reverse connection {}", responseMessage);
            responder.response(responseMessage);
            peerConnection.close();
          } else {
            cachedRequest.failed("Cannot send the request message", future);

View Full Code Here


    public static Message createDummyMessage(Number160 idSender, String inetSender, int tcpPortSendor,
            int udpPortSender, Number160 idRecipien, String inetRecipient, int tcpPortRecipient,
            int udpPortRecipient, byte command, Type type, boolean firewallUDP, boolean firewallTCP)
            throws UnknownHostException {
        Message message = new Message();
        PeerAddress n1 = createAddress(idSender, inetSender, tcpPortSendor, udpPortSender, firewallUDP,
                firewallTCP);
        message.sender(n1);
        //
        PeerAddress n2 = createAddress(idRecipien, inetRecipient, tcpPortRecipient, udpPortRecipient,
                firewallUDP, firewallTCP);
        message.recipient(n2);
        message.type(type);
        message.command(command);
        return message;
    }

View Full Code Here

        } else if(getBuilder.isAscending() && !getBuilder.isBloomFilterAnd()){
          type = Type.REQUEST_3;
        } else {
          type = Type.REQUEST_4;
        }
        final Message message = createMessage(remotePeer, RPC.Commands.GET.getNr(), type);


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


        if (getBuilder.to() != null && getBuilder.from() != null) {
            final Collection<Number640> keys = new ArrayList<Number640>(2);
            keys.add(getBuilder.from());
            keys.add(getBuilder.to());
            message.intValue(getBuilder.returnNr());
            message.keyCollection(new KeyCollection(keys));
        } else if (getBuilder.keys() == null) {


            if (getBuilder.locationKey() == null || getBuilder.domainKey() == null) {
                throw new IllegalArgumentException("Null not allowed in location or domain");
            }
            message.key(getBuilder.locationKey());
            message.key(getBuilder.domainKey());


            if (getBuilder.contentKeys() != null) {
                message.keyCollection(new KeyCollection(getBuilder.locationKey(), getBuilder
                        .domainKey(), getBuilder.versionKey(), getBuilder.contentKeys()));
            } else {
                message.intValue(getBuilder.returnNr());
                if (getBuilder.keyBloomFilter() != null || getBuilder.contentBloomFilter() != null) {
                    if (getBuilder.keyBloomFilter() != null) {
                        message.bloomFilter(getBuilder.keyBloomFilter());
                    }
                    if (getBuilder.contentBloomFilter() != null) {
                        message.bloomFilter(getBuilder.contentBloomFilter());
                    }
                }
            }
        } else {
            message.keyCollection(new KeyCollection(getBuilder.keys()));
        }


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

View Full Code Here

     *            The channel creator that creates connections
     * @return The future response to keep track of future events
     */
  public FutureResponse infoMessage(final PeerAddress remotePeer,
          final SyncBuilder synchronizationBuilder, final ChannelCreator channelCreator) {
    final Message message = createMessage(remotePeer, INFO_COMMAND,
            synchronizationBuilder.isSyncFromOldVersion() ? Type.REQUEST_2 : Type.REQUEST_1);


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


    KeyMap640Keys keyMap = new KeyMap640Keys(synchronizationBuilder.dataMapHash());
    message.keyMap640Keys(keyMap);


    FutureResponse futureResponse = new FutureResponse(message);
    final RequestHandler<FutureResponse> requestHandler = new RequestHandler<FutureResponse>(futureResponse,
            peerBean(), connectionBean(), synchronizationBuilder);
    LOG.debug("Info sent {}", message);

View Full Code Here

    }


  public FutureResponse getLatest(final PeerAddress remotePeer, final GetBuilder getBuilder,
      final ChannelCreator channelCreator, final RPC.Commands command) {
    final Type type = Type.REQUEST_1;
    final Message message = createMessage(remotePeer, command.getNr(), type);


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


    message.key(getBuilder.locationKey());
    message.key(getBuilder.domainKey());
    message.key(getBuilder.contentKey());


    final FutureResponse futureResponse = new FutureResponse(message);
    final RequestHandler<FutureResponse> request = new RequestHandler<FutureResponse>(futureResponse,
        peerBean(), connectionBean(), getBuilder);
    if (!getBuilder.isForceUDP()) {

View Full Code Here

     * @throws IOException
     */
    public FutureResponse syncMessage(final PeerAddress remotePeer,
            final SyncBuilder synchronizationBuilder, final ChannelCreator channelCreator)
            throws IOException {
        final Message message = createMessage(remotePeer, SYNC_COMMAND, Type.REQUEST_1);


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


        DataMap dataMap = synchronizationBuilder.dataMap();
        message.setDataMap(dataMap);


        FutureResponse futureResponse = new FutureResponse(message);
        final RequestHandler<FutureResponse> requestHandler = new RequestHandler<FutureResponse>(
                futureResponse, peerBean(), connectionBean(), synchronizationBuilder);
        LOG.debug("Sync sent {}", message);

View Full Code Here

    @Override
    public void handleResponse(final Message message, PeerConnection peerConnection, final boolean sign, Responder responder) throws Exception {
        if (!(message.command() == INFO_COMMAND || message.command() == SYNC_COMMAND)) {
            throw new IllegalArgumentException("Message content is wrong");
        }
        final Message responseMessage = createResponseMessage(message, Type.OK);
        if(message.command() == INFO_COMMAND) {
            handleInfo(message, responseMessage, responder);
        } else if (message.command() == SYNC_COMMAND) {
            handleSync(message, responseMessage, responder);
        } else {

View Full Code Here

     *            Set to true if the communication should be UDP, default is TCP
     * @return The future response to keep track of future events
     */
    public FutureResponse remove(final PeerAddress remotePeer, final RemoveBuilder removeBuilder,
            final ChannelCreator channelCreator) {
        final Message message = createMessage(remotePeer, RPC.Commands.REMOVE.getNr(),
                removeBuilder.isReturnResults() ? Type.REQUEST_2 : Type.REQUEST_1);


        if (removeBuilder.isSign()) {
            message.publicKeyAndSign(removeBuilder.keyPair());
        }
        
        if (removeBuilder.to() != null && removeBuilder.from() != null) {
            final Collection<Number640> keys = new ArrayList<Number640>(2);
            keys.add(removeBuilder.from());
            keys.add(removeBuilder.to());
            //marker
            message.intValue(0);
            message.keyCollection(new KeyCollection(keys));
        } else if (removeBuilder.keys() == null) {


            if (removeBuilder.locationKey() == null || removeBuilder.domainKey() == null) {
                throw new IllegalArgumentException("Null not allowed in location or domain");
            }
            message.key(removeBuilder.locationKey());
            message.key(removeBuilder.domainKey());


            if (removeBuilder.contentKeys() != null) {
                message.keyCollection(new KeyCollection(removeBuilder.locationKey(), removeBuilder
                        .domainKey(), removeBuilder.versionKey(), removeBuilder.contentKeys()));
            }
        } else {
            message.keyCollection(new KeyCollection(removeBuilder.keys()));
        }


        final FutureResponse futureResponse = new FutureResponse(message);


        final RequestHandler<FutureResponse> request = new RequestHandler<FutureResponse>(futureResponse,

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.