/** * Constructs a new instance of this class to maintain sending of a single message. * * @param mbus The message bus that owns this. * @param net The network layer to transmit through. * @param resender The resender to use. */ public SendProxy(MessageBus mbus, Network net, Resender resender) { this.mbus = mbus; this.net = net; this.resender = resender; sendTime = SystemTimer.INSTANCE.milliTime(); }
/** * <p>Returns the number of milliseconds that remain right now before this message times out. This is a function of * {@link #getTimeReceived()}, {@link #getTimeRemaining()} and current time. Whenever a message is transmitted by * message bus, a new remaining time is calculated and serialized as <code>timeRemaining = timeRemaining - * (currentTime - timeReceived)</code>. This means that we are doing an over-estimate of remaining time, as we are * only factoring in the time used by the application above message bus.</p> * * @return The remaining time in milliseconds. */ public long getTimeRemainingNow() { return timeRemaining - (SystemTimer.INSTANCE.milliTime() - timeReceived); }
public void register(SendBlockedMessages sender) { blockedSenders.put(sender, SystemTimer.INSTANCE.milliTime()); }
/** * <p>This is a convenience method to call {@link #setTimeReceived(long)} passing the current time as argument.</p> * * @return This, to allow chaining. */ public Message setTimeReceivedNow() { return setTimeReceived(SystemTimer.INSTANCE.milliTime()); }
/** * Invokes {@link RoutingNode#send()} on all routing nodes that are applicable for sending at the current time. */ public void resendScheduled() { if (queue.isEmpty()) return; List<RoutingNode> sendList = new LinkedList<RoutingNode>(); long now = SystemTimer.INSTANCE.milliTime(); while (!queue.isEmpty() && queue.peek().time <= now) { sendList.add(queue.poll().node); } for (RoutingNode node : sendList) { node.getTrace().trace(TraceLevel.COMPONENT, "Resender resending message."); node.send(); } }
/** * Call the DocumentProcessor of this call. * * @param processing the Processing object to use * @return the progress of the DocumentProcessor that was called */ public DocumentProcessor.Progress call(Processing processing) { try { int numDocs = processing.getDocumentOperations().size(); schemaMapProcessing(processing); long startTime = SystemTimer.INSTANCE.milliTime(); DocumentProcessor.Progress retval = processor.process(processing); incrementProcTime(SystemTimer.INSTANCE.milliTime() - startTime); incrementDocs(numDocs); return retval; } finally { unwrapSchemaMapping(processing); } }
/** * Schedules the given node for resending, if enabled. This will invoke {@link com.yahoo.messagebus.routing.RoutingNode#prepareForRetry()} * if the node was queued. This method is NOT thread-safe, and should only be called by the messenger thread. * * @param node The node to resend. * @return True if the node was queued. */ public boolean scheduleRetry(RoutingNode node) { Message msg = node.getMessage(); if (!msg.getRetryEnabled()) { return false; } int retry = msg.getRetry() + 1; double delay = node.getReply().getRetryDelay(); if (delay < 0) { delay = retryPolicy.getRetryDelay(retry); } if (msg.getTimeRemainingNow() * 0.001 - delay <= 0) { node.addError(ErrorCode.TIMEOUT, "Timeout exceeded by resender, giving up."); return false; } node.prepareForRetry(); // consumes the reply node.getTrace().trace(TraceLevel.COMPONENT, "Message scheduled for retry " + retry + " in " + delay + " seconds."); msg.setRetry(retry); queue.add(new Entry(node, SystemTimer.INSTANCE.milliTime() + (long)(delay * 1000))); return true; }