/** Send an ack */ public static void send(InternalDistributedMember recipient, int processorId, ReplyException exception, ReplySender dm) { send(recipient, processorId, exception, dm, false); }
public static void send(InternalDistributedMember recipient, int processorId, ReplyException exception, ReplySender dm, boolean ignored, boolean closed, boolean sendViaJGroups) { send(recipient, processorId, exception, dm, ignored, false, false, false); }
@Override protected void process(ClusterDistributionManager dm) { // do nothing. We are just pinging the server. send the reply back. ReplyMessage.send(getSender(), this.processorId, null, dm); }
public void sendReply(InternalDistributedMember recipient, int pId, ReplyException rex, ReplySender dm) { if (pId == 0 && (dm instanceof DistributionManager) && !this.directAck) {// Fix for #41871 // distributed-no-ack message. Don't respond } else { ReplyMessage.send(recipient, pId, rex, dm, !this.appliedOperation, this.closed, false, isInternal()); } }
private void replyWithException(ClusterDistributionManager dm, ReplyException rex) { ReplyMessage.send(getSender(), this.processorId, rex, dm); }
private void sendReply(InternalDistributedMember recipient, int processorId2, ClusterDistributionManager dm, ReplyException rex) { ReplyMessage.send(recipient, processorId2, rex, getReplySender(dm)); }
@Override protected void process(ClusterDistributionManager dm) { ReplyMessage.send(getSender(), this.rpid, null, dm, true /* ignored */, false, false); }
private void ack() { if (this.processorId != 0) { CommitReplyException replyEx = null; if (!this.processingExceptions.isEmpty()) { replyEx = new CommitReplyException( String.format("Commit operation generated one or more exceptions from %s", this.getSender()), this.processingExceptions); } ReplyMessage.send(getSender(), this.processorId, replyEx, this.dm); } }
/** * Send a generic ReplyMessage. This is in a method so that subclasses can override the reply * message type */ protected void sendReply(InternalDistributedMember member, int procId, DistributionManager dm, ReplyException ex, InternalRegion r, long startTime) { ReplyMessage.send(member, procId, ex, getReplySender(dm), r != null && r.isInternalRegion()); }
void reply(DistributionManager dm) { ReplyMessage.send(this.getSender(), this.getProcessorId(), null, dm); }
private void replyClear(DistributionManager dm) { ReplyMessage.send(this.getSender(), this.getProcessorId(), null, dm); }
} finally { if (this.processorId != 0) { ReplyMessage.send(getSender(), this.processorId, null, dm);
@Override protected void process(ClusterDistributionManager dm) { boolean interrupted = false; try { dm.waitForViewInstallation(this.viewId); } catch (InterruptedException e) { interrupted = true; } finally { if (!interrupted) { ReplyMessage.send(getSender(), this.processorId, null, getReplySender(dm)); } } } }
@Override protected void process(ClusterDistributionManager dm) { try { if (logger.isTraceEnabled(LogMarker.DM_VERBOSE)) { logger.trace(LogMarker.DM_VERBOSE, "{}: processing message {}", getClass().getName(), this); } IdentityRequestMessage.setLatestId(this.newId); ReplyMessage.send(getSender(), getProcessorId(), null, dm); } catch (VirtualMachineError err) { SystemFailure.initiateFailure(err); // If this ever returns, rethrow the error. We're poisoned // now, so don't let this thread continue. throw err; } catch (Throwable t) { // Whenever you catch Error or Throwable, you must also // catch VirtualMachineError (see above). However, there is // _still_ a possibility that you are dealing with a cascading // error condition, so you also need to check to see if the JVM // is still usable: SystemFailure.checkFailure(); logger.debug("{} Caught throwable {}", this, t.getMessage(), t); } }
} finally { if (this.processorId != 0) { ReplyMessage.send(getSender(), this.processorId, null, dm);
private void sendFailureReply(int rpId, String exMsg, Throwable ex, boolean directAck) { ReplySender dm = null; if (directAck) { dm = new DirectReplySender(this); } else if (rpId != 0) { dm = this.owner.getDM(); } if (dm != null) { ReplyMessage.send(getRemoteAddress(), rpId, new ReplyException(exMsg, ex), dm); } }
/** * Send a generic ReplyMessage. This is in a method so that subclasses can override the reply * message type * * @param pr the Partitioned Region for the message whose statistics are incremented * @param startTime the start time of the operation in nanoseconds * @see PutMessage#sendReply */ protected void sendReply(InternalDistributedMember member, int procId, DistributionManager dm, ReplyException ex, PartitionedRegion pr, long startTime) { if (pr != null && startTime > 0) { pr.getPrStats().endPartitionMessagesProcessing(startTime); } ReplyMessage.send(member, procId, ex, getReplySender(dm), pr != null && pr.isInternalRegion()); }
@Override protected void process(ClusterDistributionManager dm) { long latestLastAccessTime = 0L; InternalDistributedRegion region = (InternalDistributedRegion) dm.getCache().getRegion(this.regionName); if (region != null) { RegionEntry entry = region.getRegionEntry(this.key); if (entry != null) { try { latestLastAccessTime = entry.getLastAccessed(); } catch (InternalStatisticsDisabledException ignored) { // last access time is not available } } } ReplyMessage.send(getSender(), this.processorId, latestLastAccessTime, dm); }
ReplyMessage.send(getSender(), processorId, null, dm, false, false, true);
@Override protected void sendReply(InternalDistributedMember member, int procId, DistributionManager dm, ReplyException ex, PartitionedRegion pr, long startTime) { if (pr != null && startTime > 0) { pr.getPrStats().endPartitionMessagesProcessing(startTime); } if (ex == null) { DestroyReplyMessage.send(getSender(), getReplySender(dm), this.processorId, this.versionTag, pr != null && pr.isInternalRegion()); } else { ReplyMessage.send(getSender(), this.processorId, ex, getReplySender(dm), pr != null && pr.isInternalRegion()); } }