Package net.tomp2p.message

Examples of net.tomp2p.message.Message


            throw new IllegalArgumentException("Message content is wrong");
        }
        if (logger.isDebugEnabled()) {
            logger.debug("send Task - received " + message);
        }
        final Message responseMessage = createResponseMessage(message, Type.OK);
        if (sign) {
            responseMessage.setPublicKeyAndSign(getPeerBean().getKeyPair());
        }
        if (message.getType() == Type.REQUEST_1) {
            Number160 taskId = message.getKey();
            // request 1 is task creation
            Map<Number160, Data> dataMap = message.getDataMap();
            ChannelBuffer channelBuffer = message.getPayload1();
            Object obj = Utils.decodeJavaObject(channelBuffer);
            Worker mapper = (Worker) obj;
            int queuePosition = taskManager.submitTask(getPeerBean().getPeer(), taskId, mapper, dataMap,
                    message.getSender(), sign);
            responseMessage.setInteger(queuePosition);
        } else if (message.getType() == Type.REQUEST_2) {
            Collection<Number160> taskIDs = message.getKeys();
            Map<Number160, Data> dataMap = new HashMap<Number160, Data>();
            for (Number160 taskId : taskIDs) {
                Number320 taskKey = new Number320(taskId, message.getSender().getPeerId());
                TaskStatus taskStatus = taskManager.taskStatus(taskKey);
                Data data = new Data(taskStatus);
                dataMap.put(taskId, data);
            }
            responseMessage.setDataMap(dataMap);
            if (logger.isDebugEnabled()) {
                logger.debug("finished task status for tasks " + taskIDs);
            }
        } else if (message.getType() == Type.REQUEST_3) {
            Number160 taskId = message.getKey();
            Map<Number160, Data> dataMap = message.getDataMap();
            Number320 taskKey = new Number320(taskId, message.getSender().getPeerId());
            taskManager.notifyListeners(taskKey, dataMap);
        } else {
            responseMessage.setType(Type.NOT_FOUND);
        }
        return responseMessage;
    }
View Full Code Here


  @Test
  public void testMessageEncode() throws Exception {

    int intVal = 42;

    Message m1 = Utils2.createDummyMessage();
    m1.intValue(intVal);
   
    Encoder encoder = new Encoder(null); // TODO signaturefactory?

    AlternativeCompositeByteBuf buf = AlternativeCompositeByteBuf.compBuffer(); // TODO what buffer to use?
   
View Full Code Here

      FutureDone<Message> response = forwardToUnreachable(message);
      response.addListener(new BaseFutureAdapter<FutureDone<Message>>() {
        @Override
        public void operationComplete(FutureDone<Message> future) throws Exception {
          if (future.isSuccess()) {
            Message answerMessage = future.object();
            LOG.debug("Returing from relay to requester: {}", answerMessage);
            responder.response(answerMessage);
          } else {
            responder.failed(Type.DENIED, "Relaying message failed: " + future.failedReason());
          }
View Full Code Here

   * @param message
   * @param responder
   * @param sender
   */
  private void handlePing(Message message, Responder responder) {
    Message response = createResponseMessage(message, isAlive() ? Type.OK : Type.EXCEPTION, unreachablePeerAddress());
    responder.response(response);
  }
View Full Code Here

   * Creates a message with random content
   */
  public static Message createRandomMessage() {
    Random rnd = new Random();

    Message message = new Message();
    message.command(Commands.values()[rnd.nextInt(Commands.values().length)].getNr());
    message.type(Type.values()[rnd.nextInt(Type.values().length)]);
    message.recipientSocket(new InetSocketAddress(0));
    message.recipient(new PeerAddress(new Number160(rnd), message.recipientSocket()));
    message.senderSocket(new InetSocketAddress(0));
    message.sender(new PeerAddress(new Number160(rnd), message.senderSocket()));
    return message;
  }
View Full Code Here

    Number160 locationKey = message.key(0);

    Collection<PeerAddress> neighbors = getNeighbors(locationKey, NeighborRPC.NEIGHBOR_SIZE);
    if (neighbors == null) {
      // return empty neighbor set
      Message response = createResponseMessage(message, Type.NOT_FOUND, unreachablePeer);
      response.neighborsSet(new NeighborSet(-1, Collections.<PeerAddress> emptyList()));
      responder.response(response);
      return;
    }

    // Create response message and set neighbors
    final Message responseMessage = createResponseMessage(message, Type.OK, unreachablePeer);

    // TODO: the relayed peer must be up-to-date here
    // neighbors.add(peerConnection.remotePeer());

    LOG.debug("found the following neighbors {}", neighbors);

    NeighborSet neighborSet = new NeighborSet(NeighborRPC.NEIGHBOR_LIMIT, neighbors);
    responseMessage.neighborsSet(neighborSet);

    // we can't do fast get here, as we only send over the neighbors and not the keys stored
    responder.response(responseMessage);
  }
View Full Code Here

   *            The unreachable peer's peer map.
   */
  private void sendPeerMap(final BaseRelayConnection connection, List<Map<Number160, PeerStatistic>> map) {
    LOG.debug("Sending current routing table to relay {}", connection.relayAddress());

    final Message message = relayRPC
        .createMessage(connection.relayAddress(), RPC.Commands.RELAY.getNr(), Type.REQUEST_3);
    // TODO: neighbor size limit is 256, we might have more here
    message.neighborsSet(new NeighborSet(-1, RelayUtils.flatten(map)));

    final FutureResponse fr = connection.sendToRelay(message);
    fr.addListener(new BaseFutureAdapter<BaseFuture>() {
      public void operationComplete(BaseFuture future) throws Exception {
        if (future.isFailed()) {
View Full Code Here

 

  @Test
  public void testEncodeDecodeRelayedMessage() throws InvalidKeyException, SignatureException, IOException, NoSuchAlgorithmException,
      InvalidKeySpecException {
    Message message = UtilsNAT.createRandomMessage();

    List<PeerSocketAddress> relays = new ArrayList<PeerSocketAddress>();
    relays.add(new PeerSocketAddress(InetAddress.getLocalHost(), 8000, 9000));
    relays.add(new PeerSocketAddress(InetAddress.getLocalHost(), 8001, 9001));
    relays.add(new PeerSocketAddress(InetAddress.getLocalHost(), 8002, 9002));

    PeerAddress sender = UtilsNAT.createAddress().changeRelayed(true).changePeerSocketAddresses(relays)
        .changeFirewalledTCP(true).changeFirewalledUDP(true);
    message.sender(sender);
    message.senderSocket(sender.createSocketTCP());
   
    PeerAddress receiver = UtilsNAT.createAddress();
    message.recipient(receiver);
    message.recipientSocket(receiver.createSocketTCP());
   
    Buffer encoded = RelayUtils.encodeMessage(message, signature);
    Message decoded = RelayUtils.decodeMessage(encoded, message.recipientSocket(), message.senderSocket(), signature);
    Assert.assertEquals(message.peerSocketAddresses().size(), decoded.peerSocketAddresses().size());
  }
View Full Code Here

   */
  private void handleRconForward(final Message message, final Responder responder) {
    // get the relayForwarderRPC via Dispatcher to retrieve the existing peerConnection
    final BaseRelayForwarderRPC forwarder = extractRelayForwarder(message);
    if (forwarder != null) {
      final Message forwardMessage = createForwardMessage(message, forwarder.unreachablePeerAddress());
      forwarder.handleResponse(forwardMessage, responder);
    } else {
      handleFail(message, responder, "No RelayForwarder registered for peerId="
          + message.recipient().peerId().toString());
    }
View Full Code Here

   * @param peerConnection
   * @return forwardMessage
   */
  private Message createForwardMessage(final Message message, final PeerAddress recipient) {
    // creates the Message to forward to the unreachable peer
    Message forwardMessage = createMessage(recipient, RPC.Commands.RCON.getNr(), Message.Type.REQUEST_2);

    // transmit PeerAddress of reachablePeer
    final NeighborSet ns = new NeighborSet(1, new ArrayList<PeerAddress>(1));
    ns.add(message.sender());
    forwardMessage.neighborsSet(ns);

    if (!message.intList().isEmpty()) {
      // store the message id for new message to identify the cached message afterwards
      forwardMessage.intValue(message.intAt(0));
    }

    return forwardMessage;
  }
View Full Code Here

TOP

Related Classes of net.tomp2p.message.Message

Copyright © 2018 www.massapicom. All rights reserved.
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.