Java Request.reply方法代码示例

import org.jetlang.channels.Request; //导入方法依赖的package包/类
@FiberOnly
private void doPreElectionPollMessage(Request<RpcWireRequest, RpcReply> message) {
  final RpcWireRequest request = message.getRequest();
  final PreElectionPoll msg = request.getPreElectionPollMessage();
  final long msgLastLogTerm = msg.getLastLogTerm();
  final long msgLastLogIndex = msg.getLastLogIndex();

  final boolean wouldVote =
      msg.getTerm() >= currentTerm
          && atLeastAsUpToDateAsLocalLog(msgLastLogTerm, msgLastLogIndex)
          && !rejectPollFromOldConfiguration(request.from, msgLastLogTerm, msgLastLogIndex);

  logger.debug("sending pre-election reply to {} wouldVote = {}", message.getRequest().from, wouldVote);
  PreElectionReply m = new PreElectionReply(currentTerm, wouldVote);
  RpcReply reply = new RpcReply(m);
  message.reply(reply);
}
 

import org.jetlang.channels.Request; //导入方法依赖的package包/类
@FiberOnly
private void handleWireInboundMessage(Channel channel, ReplicationWireMessage msg) {
  long messageId = msg.getMessageId();
  if (msg.getReceiverId() != nodeId) {
    LOG.debug("Got messageId {} for {} but I am {}, ignoring!", messageId, msg.getReceiverId(), nodeId);
    return;
  }

  if (msg.getInReply()) {
    Request<RpcRequest, RpcWireReply> request = outstandingRPCs.get(messageId);
    if (request == null) {
      LOG.debug("Got a reply message_id {} which we don't track", messageId);
      return;
    }

    outstandingRPCs.remove(messageId);
    outstandingRPCbySession.remove(request.getSession());
    request.reply(new RpcWireReply(msg));
  } else {
    handleWireRequestMessage(channel, msg);
  }
}
 

import org.jetlang.channels.Request; //导入方法依赖的package包/类
@FiberOnly
private void handleNodeInfoRequest(Request<NodeInfoRequest, NodeInfoReply> message) {
  NodeInfoRequest req = message.getRequest();
  NodeInfo peer = peerNodeInfoMap.get(req.nodeId);
  if (peer == null) {
    message.reply(NodeInfoReply.NO_REPLY);
    return;
  }

  Integer servicePort = peer.modules.get(req.moduleType);
  if (servicePort == null) {
    message.reply(NodeInfoReply.NO_REPLY);
    return;
  }

  List<String> peerAddresses = peer.availability.getAddressesList();
  if (peerAddresses == null || peerAddresses.isEmpty()) {
    message.reply(NodeInfoReply.NO_REPLY);
    return;
  }

  // does this module run on that peer?
  message.reply(new NodeInfoReply(true, peerAddresses, servicePort));
}
 

import org.jetlang.channels.Request; //导入方法依赖的package包/类
private void receiveWrite(Request<IncomingRpcRequest, OutgoingRpcReply> message) {
    BallotNumber k = message.getRequest().getBallotNumber();
    // If write > k or read > k THEN
    if (write.compareTo(k, info) > 0
            || read.compareTo(k, info) > 0) {
        // send nackWRITE, k
        LOG.debug("{} sending nackWRITE, rejected ballot {} because I already have (r;w) {} ; {}", getId(), k, read, write);
        message.reply(OutgoingRpcReply.getNackWriteMessage(message.getRequest(), k));
    } else {
        write = k;
        lease = message.getRequest().getLease();
        LOG.info("{} new lease value written [{}] with k {}", getId(), lease, write);

        // send ackWRITE, k
        message.reply(OutgoingRpcReply.getAckWriteMessage(message.getRequest(), k));
    }
}
 

import org.jetlang.channels.Request; //导入方法依赖的package包/类
private void receiveRead(Request<IncomingRpcRequest, OutgoingRpcReply> message) {
    BallotNumber k = message.getRequest().getBallotNumber();
    // If write >= k or read >= k
    if (write.compareTo(k, info) >= 0
            || read.compareTo(k, info) >= 0) {
        // send (nackREAD, k) to p(j)
        LOG.debug("{} Sending nackREAD, rejecting ballot {} because I already have (r;w) {} ; {}", getId(), k, read, write);
        message.reply(OutgoingRpcReply.getNackReadMessage(message.getRequest(), k));
    } else {
        LOG.debug("{} onRead, setting 'read' to : {} (was: {})", getId(), k, read);
        read = k;
        // send (ackREAD,k,write(i),v(i)) to p(j)
        message.reply(OutgoingRpcReply.getAckReadMessage(message.getRequest(),
                k, write, lease));
    }
}
 

import org.jetlang.channels.Request; //导入方法依赖的package包/类
/** Creates a JetlangPonger. */
public JetlangPonger(final Fiber _fiber) {
    fiber = _fiber;
    channel = new MemoryRequestChannel();
    final Callback<Request> onReq = new Callback<Request>() {
        @Override
        public void onMessage(final Request message) {
            final Object request = message.getRequest();
            if (request instanceof PingRequest) {
                final PingRequest ping = (PingRequest) request;
                message.reply(ping.processRequest(JetlangPonger.this));
            } else {
                throw new IllegalStateException(
                        "Expected PingRequest but got "
                                + request.getClass());
            }
        }
    };
    fiber.start();
    channel.subscribe(fiber, onReq);
}
 

import org.jetlang.channels.Request; //导入方法依赖的package包/类
/** Send a ping, unless we're done, in which case tell caller we are done. */
private void ping(final Request hammerRequest) throws Exception {
    final Callback<Integer> onReply = new Callback<Integer>() {
        @Override
        public void onMessage(final Integer response) {
            pongs++;
            if (response.intValue() != pongs) {
                throw new IllegalStateException("Expected " + pongs
                        + " but got " + response);
            }
            if (pongs < count) {
                try {
                    ping(hammerRequest);
                } catch (final Exception e) {
                    e.printStackTrace();
                    hammerRequest.reply(pongs);
                }
            } else {
                hammerRequest.reply(pongs);
            }
        }
    };
    ponger.ping(pongs, onReply);
}
 

import org.jetlang.channels.Request; //导入方法依赖的package包/类
/**
 * Reply true or false to a single AppendEntries request
 */
private void sendAppendEntriesReply(Request<RpcRequest, RpcWireReply> request,
                                    boolean trueIsSuccessFlag,
                                    long myNextIndex) {
  RpcRequest message = request.getRequest();
  long termFromMessage = message.getAppendMessage().getTerm();
  AppendEntriesReply replyMessage = new AppendEntriesReply(termFromMessage, trueIsSuccessFlag, myNextIndex);
  request.reply(new RpcWireReply(message.from, message.to, QUORUM_ID, replyMessage));
}
 

import org.jetlang.channels.Request; //导入方法依赖的package包/类
private void messageForwarder(final Request<OutgoingRpcRequest, IncomingRpcReply> origMsg) {

        // ok, who sent this?!!!!!
        final OutgoingRpcRequest request = origMsg.getRequest();
//        msgSize.update(request.message.getSerializedSize());
        final long dest = request.to;
        // find it:
        final FleaseLease fl = fleaseRunners.get(dest);
        if (fl == null) {
            // boo
            LOG.error("Request to non exist: " + dest);
            origMsg.reply(null);
            return;
        }

        messages.mark();
        messageTxn.inc();

        //LOG.debug("Forwarding message from {} to {}, contents: {}", request.from, request.to, request.message);
        // Construct and send a IncomingRpcRequest from the OutgoingRpcRequest.
        // There is absolutely no way to know who this is from at this point from the infrastructure.
        final IncomingRpcRequest newRequest = new IncomingRpcRequest(1, request.from, request.message);
        AsyncRequest.withOneReply(rpcFiber, fl.getIncomingChannel(), newRequest, new Callback<OutgoingRpcReply>() {
            @Override
            public void onMessage(OutgoingRpcReply msg) {
                // Translate the OutgoingRpcReply -> IncomingRpcReply.
                //LOG.debug("Forwarding reply message from {} back to {}, contents: {}", dest, request.to, msg.message);
                messages.mark();
                messageTxn.dec();
//                msgSize.update(msg.message.getSerializedSize());
                IncomingRpcReply newReply = new IncomingRpcReply(msg.message, dest);
                origMsg.reply(newReply);
            }
        });
    }
 

import org.jetlang.channels.Request; //导入方法依赖的package包/类
/** Creates a JetlangPinger. */
@SuppressWarnings({ "rawtypes", "unchecked" })
public JetlangPinger(final Fiber _fiber) {
    fiber = _fiber;
    channel = new MemoryRequestChannel();
    final Callback<Request> onReq = new Callback<Request>() {
        @Override
        public void onMessage(final Request message) {
            final Object request = message.getRequest();
            if (request instanceof HammerRequest) {
                final HammerRequest req = (HammerRequest) request;
                try {
                    req.processRequest(JetlangPinger.this);
                    ping(message);
                } catch (final Exception e) {
                    e.printStackTrace();
                    message.reply(-1);
                }
            } else {
                throw new IllegalStateException(
                        "Expected HammerRequest but got "
                                + request.getClass());
            }
        }
    };
    fiber.start();
    channel.subscribe(fiber, onReq);
}
 

import org.jetlang.channels.Request; //导入方法依赖的package包/类
@FiberOnly
private void appendReply(Request<RpcWireRequest, RpcReply> request, boolean success) {
  AppendEntriesReply m = new AppendEntriesReply(currentTerm, success, 0);
  RpcReply reply = new RpcReply(m);
  request.reply(reply);
}
 

import org.jetlang.channels.Request; //导入方法依赖的package包/类
private void handleServerRequests(Request<CommandRpcRequest<?>, CommandReply> msg) {
  System.out.println("Handle server requests: " + msg.getRequest());

  msg.reply(serverReply);
}