static boolean sendChunk(InternalDistributedMember recipient, int processorId, int bucketId, DM dm, HeapDataOutputStream chunk, int seriesNum, int msgNum, int numSeries, boolean lastInSeries, FetchEntriesMessage sourceMessage, boolean hasRVV) { FetchEntriesReplyMessage reply = new FetchEntriesReplyMessage(recipient, processorId, bucketId, chunk, seriesNum, msgNum, numSeries, lastInSeries, sourceMessage, hasRVV); Set failures = dm.putOutgoing(reply); return (failures == null) || (failures.size() == 0); }
static boolean sendChunk(InternalDistributedMember recipient, int processorId, DM dm, HeapDataOutputStream chunk, int seriesNum, int msgNum, int numSeries, boolean lastInSeries, AbstractOperationMessage srcMessage) { FetchKeysReplyMessage reply = new FetchKeysReplyMessage(recipient, processorId, chunk, seriesNum, msgNum, numSeries, lastInSeries, srcMessage); Set failures = dm.putOutgoing(reply); return (failures == null) || (failures.size() == 0); }
static boolean sendChunk(InternalDistributedMember recipient, int processorId, int bucketId, DM dm, HeapDataOutputStream chunk, int seriesNum, int msgNum, int numSeries, boolean lastInSeries, boolean hasRVV) { FetchEntriesReplyMessage reply = new FetchEntriesReplyMessage(recipient, processorId, bucketId, chunk, seriesNum, msgNum, numSeries, lastInSeries, hasRVV); Set failures = dm.putOutgoing(reply); return (failures == null) || (failures.size() == 0); }
public static void send(DM dm, InternalDistributedMember dest, int processorId, RegionVersionVector rvv, boolean isHARegion) { RegionStateMessage msg = new RegionStateMessage(dest, processorId, rvv, isHARegion); dm.putOutgoing(msg); }
/** * Sends a message and does not wait for a response */ void sendAsync(DistributionMessage msg) { if (system != null) { system.getDistributionManager().putOutgoing(msg); } }
/** * Send profile to the provided members * @param recips The recipients of the message * @throws InterruptedException * @throws ReplyException */ public static void send(final DM dm, Set<InternalDistributedMember> recips, JmxManagerProfile profile) { JmxManagerProfileMessage r = new JmxManagerProfileMessage(recips, profile); dm.putOutgoing(r); }
public static void send(DM dm, InternalDistributedMember dest, int processorId, RegionVersionVector rvv, ReplyException ex, boolean snapshotGIIWriteLock) { RVVReplyMessage msg = new RVVReplyMessage(dest, processorId, rvv, snapshotGIIWriteLock); if (ex != null) { msg.setException(ex); } dm.putOutgoing(msg); }
public static void send(DM dm, InternalDistributedMember recipient, int keeperId) { FlowControlPermitMessage message = new FlowControlPermitMessage(keeperId); message.setRecipient(recipient); dm.putOutgoing(message); }
/** Send an ack */ public static void send(InternalDistributedMember recipient, int processorId, DM dm, long size) { Assert.assertTrue(recipient != null, "PRDistribuedGetReplyMessage NULL reply message"); BucketSizeReplyMessage m = new BucketSizeReplyMessage(processorId, size); m.setRecipient(recipient); dm.putOutgoing(m); }
/** Send an ack */ public static void send(InternalDistributedMember recipient, int processorId, EntrySnapshot value, DM dm, ReplyException re, FetchEntryMessage sourceMessage) { Assert.assertTrue(recipient != null, "FetchEntryReplyMessage NULL recipient"); FetchEntryReplyMessage m = new FetchEntryReplyMessage(processorId, value, re, sourceMessage); m.setRecipient(recipient); dm.putOutgoing(m); }
/** Send an ack */ public static void send(InternalDistributedMember recipient, int processorId, DM dm, long size) { Assert.assertTrue(recipient != null, "PRDistribuedGetReplyMessage NULL reply message"); BucketSizeReplyMessage m = new BucketSizeReplyMessage(processorId, size); m.setRecipient(recipient); dm.putOutgoing(m); }
private static void sendWithException(InternalDistributedMember recipient, int processorId, DM dm, ReplyException re) { Assert.assertTrue(recipient != null, "BecomePrimaryBucketReplyMessage NULL recipient"); BatchRemovalReplyMessage m = new BatchRemovalReplyMessage(processorId, re); m.setRecipient(recipient); dm.putOutgoing(m); }
/** Send an ack */ public static void send(InternalDistributedMember recipient, int processorId, DM dm, int size) { Assert.assertTrue(recipient != null, "SizeReplyMessage NULL reply message"); SizeReplyMessage m = new SizeReplyMessage(processorId, size); m.setRecipient(recipient); dm.putOutgoing(m); }
public void run() { DM dm = getSystem().getDistributionManager(); assertEquals("For DM " + dm.getId(), 3, dm.getOtherNormalDistributionManagerIds().size()); FirstMessage message = new FirstMessage(); dm.putOutgoing(message); } });
public static ReliableReplyProcessor21 send(Cache cache, int txUniqId,InternalDistributedMember onBehalfOfClientMember, DistributedMember recipient) { final InternalDistributedSystem system = (InternalDistributedSystem)cache.getDistributedSystem(); final Set recipients = Collections.singleton(recipient); ReliableReplyProcessor21 response = new ReliableReplyProcessor21(system, recipients); TXRemoteRollbackMessage msg = new TXRemoteRollbackMessage(txUniqId,onBehalfOfClientMember, response); msg.setRecipients(recipients); system.getDistributionManager().putOutgoing(msg); return response; }
public static void send( Set<InternalDistributedMember> recipients, DM dm, String regionPath) throws ReplyException { ReplyProcessor21 processor = new ReplyProcessor21(dm, recipients); MembershipFlushRequest msg = new MembershipFlushRequest(regionPath, processor.getProcessorId()); msg.setRecipients(recipients); dm.putOutgoing(msg); processor.waitForRepliesUninterruptibly(); }
public static PartitionResponse send(Set recipients, PartitionedRegion r, final boolean validateOnly, final boolean onlyBuckets) { PartitionResponse p = new PartitionResponse(r.getSystem(), recipients); DumpBucketsMessage m = new DumpBucketsMessage(recipients, r.getPRId(), p, validateOnly, onlyBuckets); /*Set failures =*/ r.getDistributionManager().putOutgoing(m); // if (failures != null && failures.size() > 0) { // throw new PartitionedRegionCommunicationException("Failed sending ", m); // } return p; }
public static void send( Set<InternalDistributedMember> members, DM dm, String regionPath) throws ReplyException { ReplyProcessor21 processor = new ReplyProcessor21(dm, members); ReleaseClearLockMessage msg = new ReleaseClearLockMessage(regionPath, processor.getProcessorId()); msg.setRecipients(members); dm.putOutgoing(msg); processor.waitForRepliesUninterruptibly(); }
protected static void send(Set others, DM dm, ReplyProcessor21 proc) { ElderInitMessage msg = new ElderInitMessage(); msg.processorId = proc.getProcessorId(); msg.setRecipients(others); if (DLockLogWriter.fineEnabled(dm)) { DLockLogWriter.fine(dm, "ElderInitMessage sending " + msg + " to " + others); } dm.putOutgoing(msg); }
public static IdentityUpdateResponse send(Set recipients, InternalDistributedSystem is, int currentPRId) { Assert.assertTrue(recipients != null, "IdentityUpdateMessage NULL recipients set"); IdentityRequestMessage.setLatestId(currentPRId); // set local value IdentityUpdateResponse p = new IdentityUpdateResponse(is, recipients); IdentityUpdateMessage m = new IdentityUpdateMessage(recipients, p.getProcessorId(), currentPRId); is.getDistributionManager().putOutgoing(m); // set remote values return p; }