use of org.apache.geode.distributed.DistributedSystem in project geode by apache.
the class GatewayReceiverCommand method cmdExecute.
@Override
public void cmdExecute(Message clientMessage, ServerConnection serverConnection, long start) throws IOException, InterruptedException {
Part regionNamePart = null, keyPart = null, valuePart = null, callbackArgPart = null;
String regionName = null;
Object callbackArg = null, key = null;
int partNumber = 0;
CachedRegionHelper crHelper = serverConnection.getCachedRegionHelper();
GatewayReceiverStats stats = (GatewayReceiverStats) serverConnection.getCacheServerStats();
EventID eventId = null;
LocalRegion region = null;
List<BatchException70> exceptions = new ArrayList<BatchException70>();
Throwable fatalException = null;
// requiresResponse = true;// let PROCESS_BATCH deal with this itself
{
long oldStart = start;
start = DistributionStats.getStatTime();
stats.incReadProcessBatchRequestTime(start - oldStart);
}
Part callbackArgExistsPart;
// Get early ack flag. This test should eventually be moved up above this switch
// statement so that all messages can take advantage of it.
// msg.getEarlyAck();
boolean earlyAck = false;
stats.incBatchSize(clientMessage.getPayloadLength());
// Retrieve the number of events
Part numberOfEventsPart = clientMessage.getPart(0);
int numberOfEvents = numberOfEventsPart.getInt();
stats.incEventsReceived(numberOfEvents);
// Retrieve the batch id
Part batchIdPart = clientMessage.getPart(1);
int batchId = batchIdPart.getInt();
// Instead, drop the batch and continue.
if (batchId <= serverConnection.getLatestBatchIdReplied()) {
if (GatewayReceiver.APPLY_RETRIES) {
// Do nothing!!!
logger.warn(LocalizedMessage.create(LocalizedStrings.ProcessBatch_RECEIVED_PROCESS_BATCH_REQUEST_0_THAT_HAS_ALREADY_BEEN_OR_IS_BEING_PROCESSED_GEMFIRE_GATEWAY_APPLYRETRIES_IS_SET_SO_THIS_BATCH_WILL_BE_PROCESSED_ANYWAY, batchId));
} else {
logger.warn(LocalizedMessage.create(LocalizedStrings.ProcessBatch_RECEIVED_PROCESS_BATCH_REQUEST_0_THAT_HAS_ALREADY_BEEN_OR_IS_BEING_PROCESSED__THIS_PROCESS_BATCH_REQUEST_IS_BEING_IGNORED, batchId));
writeReply(clientMessage, serverConnection, batchId, numberOfEvents);
return;
}
stats.incDuplicateBatchesReceived();
}
// Verify the batches arrive in order
if (batchId != serverConnection.getLatestBatchIdReplied() + 1) {
logger.warn(LocalizedMessage.create(LocalizedStrings.ProcessBatch_RECEIVED_PROCESS_BATCH_REQUEST_0_OUT_OF_ORDER_THE_ID_OF_THE_LAST_BATCH_PROCESSED_WAS_1_THIS_BATCH_REQUEST_WILL_BE_PROCESSED_BUT_SOME_MESSAGES_MAY_HAVE_BEEN_LOST, new Object[] { batchId, serverConnection.getLatestBatchIdReplied() }));
stats.incOutoforderBatchesReceived();
}
if (logger.isDebugEnabled()) {
logger.debug("Received process batch request {} that will be processed.", batchId);
}
// Not sure if earlyAck makes sense with sliding window
if (earlyAck) {
serverConnection.incrementLatestBatchIdReplied(batchId);
// writeReply(msg, servConn);
// servConn.setAsTrue(RESPONDED);
{
long oldStart = start;
start = DistributionStats.getStatTime();
stats.incWriteProcessBatchResponseTime(start - oldStart);
}
stats.incEarlyAcks();
}
if (logger.isDebugEnabled()) {
logger.debug("{}: Received process batch request {} containing {} events ({} bytes) with {} acknowledgement on {}", serverConnection.getName(), batchId, numberOfEvents, clientMessage.getPayloadLength(), (earlyAck ? "early" : "normal"), serverConnection.getSocketString());
if (earlyAck) {
logger.debug("{}: Sent process batch early response for batch {} containing {} events ({} bytes) with {} acknowledgement on {}", serverConnection.getName(), batchId, numberOfEvents, clientMessage.getPayloadLength(), (earlyAck ? "early" : "normal"), serverConnection.getSocketString());
}
}
// logger.warn("Received process batch request " + batchId + " containing
// " + numberOfEvents + " events (" + msg.getPayloadLength() + " bytes) with
// " + (earlyAck ? "early" : "normal") + " acknowledgement on " +
// getSocketString());
// if (earlyAck) {
// logger.warn("Sent process batch early response for batch " + batchId +
// " containing " + numberOfEvents + " events (" + msg.getPayloadLength() +
// " bytes) with " + (earlyAck ? "early" : "normal") + " acknowledgement on
// " + getSocketString());
// }
// Retrieve the events from the message parts. The '2' below
// represents the number of events (part0) and the batchId (part1)
partNumber = 2;
int dsid = clientMessage.getPart(partNumber++).getInt();
boolean removeOnException = clientMessage.getPart(partNumber++).getSerializedForm()[0] == 1 ? true : false;
// Keep track of whether a response has been written for
// exceptions
boolean wroteResponse = earlyAck;
// event received in batch also have PDX events at the start of the batch,to
// represent correct index on which the exception occurred, number of PDX
// events need to be subtratced.
//
int indexWithoutPDXEvent = -1;
for (int i = 0; i < numberOfEvents; i++) {
boolean isPdxEvent = false;
indexWithoutPDXEvent++;
// System.out.println("Processing event " + i + " in batch " + batchId + "
// starting with part number " + partNumber);
Part actionTypePart = clientMessage.getPart(partNumber);
int actionType = actionTypePart.getInt();
long versionTimeStamp = VersionTag.ILLEGAL_VERSION_TIMESTAMP;
EventIDHolder clientEvent = null;
boolean callbackArgExists = false;
try {
Part possibleDuplicatePart = clientMessage.getPart(partNumber + 1);
byte[] possibleDuplicatePartBytes;
try {
possibleDuplicatePartBytes = (byte[]) possibleDuplicatePart.getObject();
} catch (Exception e) {
logger.warn(LocalizedMessage.create(LocalizedStrings.ProcessBatch_0_CAUGHT_EXCEPTION_PROCESSING_BATCH_REQUEST_1_CONTAINING_2_EVENTS, new Object[] { serverConnection.getName(), Integer.valueOf(batchId), Integer.valueOf(numberOfEvents) }), e);
throw e;
}
boolean possibleDuplicate = possibleDuplicatePartBytes[0] == 0x01;
// Make sure instance variables are null before each iteration
regionName = null;
key = null;
callbackArg = null;
// Retrieve the region name from the message parts
regionNamePart = clientMessage.getPart(partNumber + 2);
regionName = regionNamePart.getString();
if (regionName.equals(PeerTypeRegistration.REGION_FULL_PATH)) {
indexWithoutPDXEvent--;
isPdxEvent = true;
}
// Retrieve the event id from the message parts
// This was going to be used to determine possible
// duplication of events, but it is unused now. In
// fact the event id is overridden by the FROM_GATEWAY
// token.
Part eventIdPart = clientMessage.getPart(partNumber + 3);
eventIdPart.setVersion(serverConnection.getClientVersion());
// String eventId = eventIdPart.getString();
try {
eventId = (EventID) eventIdPart.getObject();
} catch (Exception e) {
logger.warn(LocalizedMessage.create(LocalizedStrings.ProcessBatch_0_CAUGHT_EXCEPTION_PROCESSING_BATCH_REQUEST_1_CONTAINING_2_EVENTS, new Object[] { serverConnection.getName(), Integer.valueOf(batchId), Integer.valueOf(numberOfEvents) }), e);
throw e;
}
// Retrieve the key from the message parts
keyPart = clientMessage.getPart(partNumber + 4);
try {
key = keyPart.getStringOrObject();
} catch (Exception e) {
logger.warn(LocalizedMessage.create(LocalizedStrings.ProcessBatch_0_CAUGHT_EXCEPTION_PROCESSING_BATCH_REQUEST_1_CONTAINING_2_EVENTS, new Object[] { serverConnection.getName(), Integer.valueOf(batchId), Integer.valueOf(numberOfEvents) }), e);
throw e;
}
switch(actionType) {
case // Create
0:
/*
* CLIENT EXCEPTION HANDLING TESTING CODE String keySt = (String) key;
* System.out.println("Processing new key: " + key); if (keySt.startsWith("failure")) {
* throw new Exception(LocalizedStrings
* .ProcessBatch_THIS_EXCEPTION_REPRESENTS_A_FAILURE_ON_THE_SERVER
* .toLocalizedString()); }
*/
// Retrieve the value from the message parts (do not deserialize it)
valuePart = clientMessage.getPart(partNumber + 5);
// try {
// logger.warn(getName() + ": Creating key " + key + " value " +
// valuePart.getObject());
// } catch (Exception e) {}
// Retrieve the callbackArg from the message parts if necessary
int index = partNumber + 6;
callbackArgExistsPart = clientMessage.getPart(index++);
{
byte[] partBytes = (byte[]) callbackArgExistsPart.getObject();
callbackArgExists = partBytes[0] == 0x01;
}
if (callbackArgExists) {
callbackArgPart = clientMessage.getPart(index++);
try {
callbackArg = callbackArgPart.getObject();
} catch (Exception e) {
logger.warn(LocalizedMessage.create(LocalizedStrings.ProcessBatch_0_CAUGHT_EXCEPTION_PROCESSING_BATCH_CREATE_REQUEST_1_FOR_2_EVENTS, new Object[] { serverConnection.getName(), Integer.valueOf(batchId), Integer.valueOf(numberOfEvents) }), e);
throw e;
}
}
if (logger.isDebugEnabled()) {
logger.debug("{}: Processing batch create request {} on {} for region {} key {} value {} callbackArg {}, eventId={}", serverConnection.getName(), batchId, serverConnection.getSocketString(), regionName, key, valuePart, callbackArg, eventId);
}
versionTimeStamp = clientMessage.getPart(index++).getLong();
// Process the create request
if (key == null || regionName == null) {
StringId message = null;
Object[] messageArgs = new Object[] { serverConnection.getName(), Integer.valueOf(batchId) };
if (key == null) {
message = LocalizedStrings.ProcessBatch_0_THE_INPUT_REGION_NAME_FOR_THE_BATCH_CREATE_REQUEST_1_IS_NULL;
}
if (regionName == null) {
message = LocalizedStrings.ProcessBatch_0_THE_INPUT_REGION_NAME_FOR_THE_BATCH_CREATE_REQUEST_1_IS_NULL;
}
String s = message.toLocalizedString(messageArgs);
logger.warn(s);
throw new Exception(s);
}
region = (LocalRegion) crHelper.getRegion(regionName);
if (region == null) {
handleRegionNull(serverConnection, regionName, batchId);
} else {
clientEvent = new EventIDHolder(eventId);
if (versionTimeStamp > 0) {
VersionTag tag = VersionTag.create(region.getVersionMember());
tag.setIsGatewayTag(true);
tag.setVersionTimeStamp(versionTimeStamp);
tag.setDistributedSystemId(dsid);
clientEvent.setVersionTag(tag);
}
clientEvent.setPossibleDuplicate(possibleDuplicate);
handleMessageRetry(region, clientEvent);
try {
byte[] value = valuePart.getSerializedForm();
boolean isObject = valuePart.isObject();
// [sumedh] This should be done on client while sending
// since that is the WAN gateway
AuthorizeRequest authzRequest = serverConnection.getAuthzRequest();
if (authzRequest != null) {
PutOperationContext putContext = authzRequest.putAuthorize(regionName, key, value, isObject, callbackArg);
value = putContext.getSerializedValue();
isObject = putContext.isObject();
}
// Attempt to create the entry
boolean result = false;
if (isPdxEvent) {
result = addPdxType(crHelper, key, value);
} else {
result = region.basicBridgeCreate(key, value, isObject, callbackArg, serverConnection.getProxyID(), false, clientEvent, false);
// attempt to update the entry
if (!result) {
result = region.basicBridgePut(key, value, null, isObject, callbackArg, serverConnection.getProxyID(), false, clientEvent);
}
}
if (result || clientEvent.isConcurrencyConflict()) {
serverConnection.setModificationInfo(true, regionName, key);
stats.incCreateRequest();
} else {
// This exception will be logged in the catch block below
throw new Exception(LocalizedStrings.ProcessBatch_0_FAILED_TO_CREATE_OR_UPDATE_ENTRY_FOR_REGION_1_KEY_2_VALUE_3_CALLBACKARG_4.toLocalizedString(new Object[] { serverConnection.getName(), regionName, key, valuePart, callbackArg }));
}
} catch (Exception e) {
logger.warn(LocalizedMessage.create(LocalizedStrings.ProcessBatch_0_CAUGHT_EXCEPTION_PROCESSING_BATCH_CREATE_REQUEST_1_FOR_2_EVENTS, new Object[] { serverConnection.getName(), Integer.valueOf(batchId), Integer.valueOf(numberOfEvents) }), e);
throw e;
}
}
break;
case // Update
1:
/*
* CLIENT EXCEPTION HANDLING TESTING CODE keySt = (String) key;
* System.out.println("Processing updated key: " + key); if
* (keySt.startsWith("failure")) { throw new Exception(LocalizedStrings
* .ProcessBatch_THIS_EXCEPTION_REPRESENTS_A_FAILURE_ON_THE_SERVER
* .toLocalizedString()); }
*/
// Retrieve the value from the message parts (do not deserialize it)
valuePart = clientMessage.getPart(partNumber + 5);
// try {
// logger.warn(getName() + ": Updating key " + key + " value " +
// valuePart.getObject());
// } catch (Exception e) {}
// Retrieve the callbackArg from the message parts if necessary
index = partNumber + 6;
callbackArgExistsPart = clientMessage.getPart(index++);
{
byte[] partBytes = (byte[]) callbackArgExistsPart.getObject();
callbackArgExists = partBytes[0] == 0x01;
}
if (callbackArgExists) {
callbackArgPart = clientMessage.getPart(index++);
try {
callbackArg = callbackArgPart.getObject();
} catch (Exception e) {
logger.warn(LocalizedMessage.create(LocalizedStrings.ProcessBatch_0_CAUGHT_EXCEPTION_PROCESSING_BATCH_UPDATE_REQUEST_1_CONTAINING_2_EVENTS, new Object[] { serverConnection.getName(), Integer.valueOf(batchId), Integer.valueOf(numberOfEvents) }), e);
throw e;
}
}
versionTimeStamp = clientMessage.getPart(index++).getLong();
if (logger.isDebugEnabled()) {
logger.debug("{}: Processing batch update request {} on {} for region {} key {} value {} callbackArg {}", serverConnection.getName(), batchId, serverConnection.getSocketString(), regionName, key, valuePart, callbackArg);
}
// Process the update request
if (key == null || regionName == null) {
StringId message = null;
Object[] messageArgs = new Object[] { serverConnection.getName(), Integer.valueOf(batchId) };
if (key == null) {
message = LocalizedStrings.ProcessBatch_0_THE_INPUT_KEY_FOR_THE_BATCH_UPDATE_REQUEST_1_IS_NULL;
}
if (regionName == null) {
message = LocalizedStrings.ProcessBatch_0_THE_INPUT_REGION_NAME_FOR_THE_BATCH_UPDATE_REQUEST_1_IS_NULL;
}
String s = message.toLocalizedString(messageArgs);
logger.warn(s);
throw new Exception(s);
}
region = (LocalRegion) crHelper.getRegion(regionName);
if (region == null) {
handleRegionNull(serverConnection, regionName, batchId);
} else {
clientEvent = new EventIDHolder(eventId);
if (versionTimeStamp > 0) {
VersionTag tag = VersionTag.create(region.getVersionMember());
tag.setIsGatewayTag(true);
tag.setVersionTimeStamp(versionTimeStamp);
tag.setDistributedSystemId(dsid);
clientEvent.setVersionTag(tag);
}
clientEvent.setPossibleDuplicate(possibleDuplicate);
handleMessageRetry(region, clientEvent);
try {
byte[] value = valuePart.getSerializedForm();
boolean isObject = valuePart.isObject();
AuthorizeRequest authzRequest = serverConnection.getAuthzRequest();
if (authzRequest != null) {
PutOperationContext putContext = authzRequest.putAuthorize(regionName, key, value, isObject, callbackArg, PutOperationContext.UPDATE);
value = putContext.getSerializedValue();
isObject = putContext.isObject();
}
boolean result = false;
if (isPdxEvent) {
result = addPdxType(crHelper, key, value);
} else {
result = region.basicBridgePut(key, value, null, isObject, callbackArg, serverConnection.getProxyID(), false, clientEvent);
}
if (result || clientEvent.isConcurrencyConflict()) {
serverConnection.setModificationInfo(true, regionName, key);
stats.incUpdateRequest();
} else {
final Object[] msgArgs = new Object[] { serverConnection.getName(), regionName, key, valuePart, callbackArg };
final StringId message = LocalizedStrings.ProcessBatch_0_FAILED_TO_UPDATE_ENTRY_FOR_REGION_1_KEY_2_VALUE_3_AND_CALLBACKARG_4;
String s = message.toLocalizedString(msgArgs);
logger.info(s);
throw new Exception(s);
}
} catch (CancelException e) {
// FIXME better exception hierarchy would avoid this check
if (serverConnection.getCachedRegionHelper().getCache().getCancelCriterion().isCancelInProgress()) {
if (logger.isDebugEnabled()) {
logger.debug("{} ignoring message of type {} from client {} because shutdown occurred during message processing.", serverConnection.getName(), MessageType.getString(clientMessage.getMessageType()), serverConnection.getProxyID());
}
serverConnection.setFlagProcessMessagesAsFalse();
serverConnection.setClientDisconnectedException(e);
} else {
throw e;
}
return;
} catch (Exception e) {
// Preserve the connection under all circumstances
logger.warn(LocalizedMessage.create(LocalizedStrings.ProcessBatch_0_CAUGHT_EXCEPTION_PROCESSING_BATCH_UPDATE_REQUEST_1_CONTAINING_2_EVENTS, new Object[] { serverConnection.getName(), Integer.valueOf(batchId), Integer.valueOf(numberOfEvents) }), e);
throw e;
}
}
break;
case // Destroy
2:
// Retrieve the callbackArg from the message parts if necessary
index = partNumber + 5;
callbackArgExistsPart = clientMessage.getPart(index++);
{
byte[] partBytes = (byte[]) callbackArgExistsPart.getObject();
callbackArgExists = partBytes[0] == 0x01;
}
if (callbackArgExists) {
callbackArgPart = clientMessage.getPart(index++);
try {
callbackArg = callbackArgPart.getObject();
} catch (Exception e) {
logger.warn(LocalizedMessage.create(LocalizedStrings.ProcessBatch_0_CAUGHT_EXCEPTION_PROCESSING_BATCH_DESTROY_REQUEST_1_CONTAINING_2_EVENTS, new Object[] { serverConnection.getName(), Integer.valueOf(batchId), Integer.valueOf(numberOfEvents) }), e);
throw e;
}
}
versionTimeStamp = clientMessage.getPart(index++).getLong();
if (logger.isDebugEnabled()) {
logger.debug("{}: Processing batch destroy request {} on {} for region {} key {}", serverConnection.getName(), batchId, serverConnection.getSocketString(), regionName, key);
}
// Process the destroy request
if (key == null || regionName == null) {
StringId message = null;
if (key == null) {
message = LocalizedStrings.ProcessBatch_0_THE_INPUT_KEY_FOR_THE_BATCH_DESTROY_REQUEST_1_IS_NULL;
}
if (regionName == null) {
message = LocalizedStrings.ProcessBatch_0_THE_INPUT_REGION_NAME_FOR_THE_BATCH_DESTROY_REQUEST_1_IS_NULL;
}
Object[] messageArgs = new Object[] { serverConnection.getName(), Integer.valueOf(batchId) };
String s = message.toLocalizedString(messageArgs);
logger.warn(s);
throw new Exception(s);
}
region = (LocalRegion) crHelper.getRegion(regionName);
if (region == null) {
handleRegionNull(serverConnection, regionName, batchId);
} else {
clientEvent = new EventIDHolder(eventId);
if (versionTimeStamp > 0) {
VersionTag tag = VersionTag.create(region.getVersionMember());
tag.setIsGatewayTag(true);
tag.setVersionTimeStamp(versionTimeStamp);
tag.setDistributedSystemId(dsid);
clientEvent.setVersionTag(tag);
}
handleMessageRetry(region, clientEvent);
// Destroy the entry
try {
AuthorizeRequest authzRequest = serverConnection.getAuthzRequest();
if (authzRequest != null) {
DestroyOperationContext destroyContext = authzRequest.destroyAuthorize(regionName, key, callbackArg);
callbackArg = destroyContext.getCallbackArg();
}
region.basicBridgeDestroy(key, callbackArg, serverConnection.getProxyID(), false, clientEvent);
serverConnection.setModificationInfo(true, regionName, key);
stats.incDestroyRequest();
} catch (EntryNotFoundException e) {
logger.info(LocalizedMessage.create(LocalizedStrings.ProcessBatch_0_DURING_BATCH_DESTROY_NO_ENTRY_WAS_FOUND_FOR_KEY_1, new Object[] { serverConnection.getName(), key }));
// throw new Exception(e);
}
}
break;
case // Update Time-stamp for a RegionEntry
3:
try {
// Region name
regionNamePart = clientMessage.getPart(partNumber + 2);
regionName = regionNamePart.getString();
// Retrieve the event id from the message parts
eventIdPart = clientMessage.getPart(partNumber + 3);
eventId = (EventID) eventIdPart.getObject();
// Retrieve the key from the message parts
keyPart = clientMessage.getPart(partNumber + 4);
key = keyPart.getStringOrObject();
// Retrieve the callbackArg from the message parts if necessary
index = partNumber + 5;
callbackArgExistsPart = clientMessage.getPart(index++);
byte[] partBytes = (byte[]) callbackArgExistsPart.getObject();
callbackArgExists = partBytes[0] == 0x01;
if (callbackArgExists) {
callbackArgPart = clientMessage.getPart(index++);
callbackArg = callbackArgPart.getObject();
}
} catch (Exception e) {
logger.warn(LocalizedMessage.create(LocalizedStrings.ProcessBatch_0_CAUGHT_EXCEPTION_PROCESSING_BATCH_UPDATE_VERSION_REQUEST_1_CONTAINING_2_EVENTS, new Object[] { serverConnection.getName(), Integer.valueOf(batchId), Integer.valueOf(numberOfEvents) }), e);
throw e;
}
versionTimeStamp = clientMessage.getPart(index++).getLong();
if (logger.isDebugEnabled()) {
logger.debug("{}: Processing batch update-version request {} on {} for region {} key {} value {} callbackArg {}", serverConnection.getName(), batchId, serverConnection.getSocketString(), regionName, key, valuePart, callbackArg);
}
// Process the update time-stamp request
if (key == null || regionName == null) {
StringId message = LocalizedStrings.ProcessBatch_0_CAUGHT_EXCEPTION_PROCESSING_BATCH_UPDATE_VERSION_REQUEST_1_CONTAINING_2_EVENTS;
Object[] messageArgs = new Object[] { serverConnection.getName(), Integer.valueOf(batchId), Integer.valueOf(numberOfEvents) };
String s = message.toLocalizedString(messageArgs);
logger.warn(s);
throw new Exception(s);
} else {
region = (LocalRegion) crHelper.getRegion(regionName);
if (region == null) {
handleRegionNull(serverConnection, regionName, batchId);
} else {
clientEvent = new EventIDHolder(eventId);
if (versionTimeStamp > 0) {
VersionTag tag = VersionTag.create(region.getVersionMember());
tag.setIsGatewayTag(true);
tag.setVersionTimeStamp(versionTimeStamp);
tag.setDistributedSystemId(dsid);
clientEvent.setVersionTag(tag);
}
// Update the version tag
try {
region.basicBridgeUpdateVersionStamp(key, callbackArg, serverConnection.getProxyID(), false, clientEvent);
} catch (EntryNotFoundException e) {
logger.info(LocalizedMessage.create(LocalizedStrings.ProcessBatch_0_DURING_BATCH_UPDATE_VERSION_NO_ENTRY_WAS_FOUND_FOR_KEY_1, new Object[] { serverConnection.getName(), key }));
// throw new Exception(e);
}
}
}
break;
default:
logger.fatal(LocalizedMessage.create(LocalizedStrings.Processbatch_0_UNKNOWN_ACTION_TYPE_1_FOR_BATCH_FROM_2, new Object[] { serverConnection.getName(), Integer.valueOf(actionType), serverConnection.getSocketString() }));
stats.incUnknowsOperationsReceived();
}
} catch (CancelException e) {
if (logger.isDebugEnabled()) {
logger.debug("{} ignoring message of type {} from client {} because shutdown occurred during message processing.", serverConnection.getName(), MessageType.getString(clientMessage.getMessageType()), serverConnection.getProxyID());
}
serverConnection.setFlagProcessMessagesAsFalse();
serverConnection.setClientDisconnectedException(e);
return;
} catch (Exception e) {
// If an interrupted exception is thrown , rethrow it
checkForInterrupt(serverConnection, e);
// If we have an issue with the PDX registry, stop processing more data
if (e.getCause() instanceof PdxRegistryMismatchException) {
fatalException = e.getCause();
logger.fatal(LocalizedMessage.create(LocalizedStrings.GatewayReceiver_PDX_CONFIGURATION, new Object[] { serverConnection.getMembershipID() }), e.getCause());
break;
}
// write the batch exception to the caller and break
if (!wroteResponse) {
// Increment the batch id unless the received batch id is -1 (a
// failover batch)
DistributedSystem ds = crHelper.getCache().getDistributedSystem();
String exceptionMessage = LocalizedStrings.GatewayReceiver_EXCEPTION_WHILE_PROCESSING_BATCH.toLocalizedString(new Object[] { ((InternalDistributedSystem) ds).getDistributionManager().getDistributedSystemId(), ds.getDistributedMember() });
BatchException70 be = new BatchException70(exceptionMessage, e, indexWithoutPDXEvent, batchId);
exceptions.add(be);
if (!removeOnException) {
break;
}
// servConn.setAsTrue(RESPONDED);
// wroteResponse = true;
// break;
} else {
// occurred.
return;
}
} finally {
// Increment the partNumber
if (actionType == 0 || /* create */
actionType == 1) /* update */
{
if (callbackArgExists) {
partNumber += 9;
} else {
partNumber += 8;
}
} else if (actionType == 2) /* destroy */
{
if (callbackArgExists) {
partNumber += 8;
} else {
partNumber += 7;
}
} else if (actionType == 3) /* update-version */
{
if (callbackArgExists) {
partNumber += 8;
} else {
partNumber += 7;
}
}
}
}
{
long oldStart = start;
start = DistributionStats.getStatTime();
stats.incProcessBatchTime(start - oldStart);
}
if (fatalException != null) {
serverConnection.incrementLatestBatchIdReplied(batchId);
writeFatalException(clientMessage, fatalException, serverConnection, batchId);
serverConnection.setAsTrue(RESPONDED);
} else if (!exceptions.isEmpty()) {
serverConnection.incrementLatestBatchIdReplied(batchId);
writeBatchException(clientMessage, exceptions, serverConnection, batchId);
serverConnection.setAsTrue(RESPONDED);
} else if (!wroteResponse) {
// Increment the batch id unless the received batch id is -1 (a failover
// batch)
serverConnection.incrementLatestBatchIdReplied(batchId);
writeReply(clientMessage, serverConnection, batchId, numberOfEvents);
serverConnection.setAsTrue(RESPONDED);
stats.incWriteProcessBatchResponseTime(DistributionStats.getStatTime() - start);
if (logger.isDebugEnabled()) {
logger.debug("{}: Sent process batch normal response for batch {} containing {} events ({} bytes) with {} acknowledgement on {}", serverConnection.getName(), batchId, numberOfEvents, clientMessage.getPayloadLength(), (earlyAck ? "early" : "normal"), serverConnection.getSocketString());
}
// logger.warn("Sent process batch normal response for batch " +
// batchId + " containing " + numberOfEvents + " events (" +
// msg.getPayloadLength() + " bytes) with " + (earlyAck ? "early" :
// "normal") + " acknowledgement on " + getSocketString());
}
}
use of org.apache.geode.distributed.DistributedSystem in project geode by apache.
the class ExecuteFunction70 method executeFunctionOnGroups.
@Override
protected void executeFunctionOnGroups(Object function, Object args, String[] groups, boolean allMembers, Function functionObject, ServerToClientFunctionResultSender resultSender, boolean ignoreFailedMembers) {
DistributedSystem ds = InternalDistributedSystem.getConnectedInstance();
if (ds == null) {
throw new IllegalStateException(LocalizedStrings.ExecuteFunction_DS_NOT_CREATED_OR_NOT_READY.toLocalizedString());
}
Set<DistributedMember> members = new HashSet<DistributedMember>();
for (String group : groups) {
if (allMembers) {
members.addAll(ds.getGroupMembers(group));
} else {
ArrayList<DistributedMember> memberList = new ArrayList<DistributedMember>(ds.getGroupMembers(group));
if (!memberList.isEmpty()) {
if (!FunctionServiceManager.RANDOM_onMember && memberList.contains(ds.getDistributedMember())) {
members.add(ds.getDistributedMember());
} else {
Collections.shuffle(memberList);
members.add(memberList.get(0));
}
}
}
}
if (logger.isDebugEnabled()) {
logger.debug("Executing Function on Groups: {} all members: {} members are: {}", Arrays.toString(groups), allMembers, members);
}
Execution execution = new MemberFunctionExecutor(ds, members, resultSender);
if (args != null) {
execution = execution.setArguments(args);
}
if (ignoreFailedMembers) {
if (logger.isDebugEnabled()) {
logger.debug("Function will ignore failed members");
}
((AbstractExecution) execution).setIgnoreDepartedMembers(true);
}
if (!functionObject.isHA()) {
((AbstractExecution) execution).setWaitOnExceptionFlag(true);
}
if (function instanceof String) {
execution.execute(functionObject.getId()).getResult();
} else {
execution.execute(functionObject).getResult();
}
}
use of org.apache.geode.distributed.DistributedSystem in project geode by apache.
the class RestAPIsWithSSLDUnitTest method startBridgeServer.
@SuppressWarnings("deprecation")
protected int startBridgeServer(String hostName, int restServicePort, final String locators, final String[] regions, final Properties sslProperties, boolean clusterLevel) {
Properties props = new Properties();
props.setProperty(MCAST_PORT, "0");
props.setProperty(LOCATORS, locators);
props.setProperty(START_DEV_REST_API, "true");
props.setProperty(HTTP_SERVICE_BIND_ADDRESS, hostName);
props.setProperty(HTTP_SERVICE_PORT, String.valueOf(restServicePort));
System.setProperty("javax.net.debug", "ssl,handshake");
props = configureSSL(props, sslProperties, clusterLevel);
DistributedSystem ds = getSystem(props);
InternalCache cache = (InternalCache) CacheFactory.create(ds);
cache.setReadSerialized(true);
AttributesFactory factory = new AttributesFactory();
factory.setEnableBridgeConflation(true);
factory.setDataPolicy(DataPolicy.REPLICATE);
RegionAttributes attrs = factory.create();
for (int i = 0; i < regions.length; i++) {
cache.createRegion(regions[i], attrs);
}
CacheServer server = cache.addCacheServer();
server.setPort(0);
try {
server.start();
} catch (IOException e) {
e.printStackTrace();
}
remoteObjects.put(CACHE_KEY, cache);
return server.getPort();
}
use of org.apache.geode.distributed.DistributedSystem in project geode by apache.
the class RegionFactoryJUnitTest method testAfterCacheCreate.
@Test
public void testAfterCacheCreate() throws Exception {
// Assert basic region creation when a Distributed and Cache exist
DistributedSystem ds = DistributedSystem.connect(createGemFireProperties());
CacheFactory.create(ds);
RegionFactory factory = new RegionFactory();
r1 = factory.create(r1Name);
assertBasicRegionFunctionality(r1, r1Name);
}
use of org.apache.geode.distributed.DistributedSystem in project geode by apache.
the class RegionFactoryJUnitTest method tearDown.
@After
public void tearDown() throws Exception {
try {
if (this.r1 != null) {
cleanUpRegion(this.r1);
}
if (this.r2 != null) {
cleanUpRegion(this.r2);
}
if (this.r3 != null) {
cleanUpRegion(this.r3);
}
if (this.r1sr1 != null) {
cleanUpRegion(this.r1sr1);
}
Cache c = this.cache;
DistributedSystem d = this.distSys;
if (c != null && !c.isClosed()) {
d = c.getDistributedSystem();
c.close();
}
if (d != null && d.isConnected()) {
d.disconnect();
}
} finally {
this.r1 = null;
this.r2 = null;
this.r3 = null;
this.r1sr1 = null;
this.cache = null;
this.distSys = null;
}
}
Aggregations