use of org.apache.geode.distributed.internal.InternalDistributedSystem in project geode by apache.
the class AdminConsoleDisconnectMessage method process.
@Override
public void process(DistributionManager dm) {
InternalDistributedSystem sys = dm.getSystem();
// DistributionConfig config = sys.getConfig();
if (alertListenerExpected) {
if (!AlertAppender.getInstance().removeAlertListener(this.getSender()) && !this.ignoreAlertListenerRemovalFailure) {
logger.warn(LocalizedMessage.create(LocalizedStrings.ManagerLogWriter_UNABLE_TO_REMOVE_CONSOLE_WITH_ID_0_FROM_ALERT_LISTENERS, this.getSender()));
}
}
GemFireStatSampler sampler = sys.getStatSampler();
if (sampler != null) {
sampler.removeListenersByRecipient(this.getSender());
}
dm.handleConsoleShutdown(this.getSender(), crashed, LocalizedStrings.AdminConsoleDisconnectMessage_AUTOMATIC_ADMIN_DISCONNECT_0.toLocalizedString(reason));
// AppCacheSnapshotMessage.flushSnapshots(this.getSender());
}
use of org.apache.geode.distributed.internal.InternalDistributedSystem in project geode by apache.
the class FindRemoteTXMessage method send.
/**
* Asks all the peers if they host a transaction for the given txId
*
* @param txId the transaction id
* @return reply processor containing memberId of the member that hosts the transaction and a
* recently committed transactionMessage if any
*/
public static FindRemoteTXMessageReplyProcessor send(Cache cache, TXId txId) {
final InternalDistributedSystem system = (InternalDistributedSystem) cache.getDistributedSystem();
DM dm = system.getDistributionManager();
Set recipients = dm.getOtherDistributionManagerIds();
FindRemoteTXMessageReplyProcessor processor = new FindRemoteTXMessageReplyProcessor(dm, recipients, txId);
FindRemoteTXMessage msg = new FindRemoteTXMessage(txId, processor.getProcessorId(), recipients);
dm.putOutgoing(msg);
return processor;
}
use of org.apache.geode.distributed.internal.InternalDistributedSystem 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.internal.InternalDistributedSystem in project geode by apache.
the class GlobalTransaction method getId.
/**
* Read current {@link #DMid} and return it
*
* @return current DMid
*/
private static String getId() {
synchronized (DmidMutex) {
InternalDistributedSystem ids = InternalDistributedSystem.getAnyInstance();
if (ids == null) {
throw new DistributedSystemDisconnectedException("No distributed system");
}
if (ids == IdsForId) {
return DMid;
}
IdsForId = ids;
DM dm = ids.getDistributionManager();
DMid = dm.getId().toString();
return DMid;
}
}
use of org.apache.geode.distributed.internal.InternalDistributedSystem in project geode by apache.
the class AlertAppender method append.
/**
* This method is optimized with the assumption that at least one listener has set a level which
* requires that the event be sent. This is ensured by modifying the appender's configuration
* whenever a listener is added or removed.
*/
@Override
public void append(final LogEvent event) {
if (this.alertingDisabled) {
return;
}
// If already appending then don't send to avoid infinite recursion
if ((alerting.get())) {
return;
}
setIsAlerting(true);
try {
final boolean isDebugEnabled = logger.isDebugEnabled();
if (isDebugEnabled) {
logger.debug("Delivering an alert event: {}", event);
}
InternalDistributedSystem ds = this.systemRef.get();
if (ds == null) {
// Use info level to avoid triggering another alert
logger.info("Did not append alert event because the distributed system is set to null.");
return;
}
DistributionManager distMgr = (DistributionManager) ds.getDistributionManager();
final int intLevel = logLevelToAlertLevel(event.getLevel().intLevel());
final Date date = new Date(event.getTimeMillis());
final String threadName = event.getThreadName();
final String logMessage = event.getMessage().getFormattedMessage();
final String stackTrace = ThreadUtils.stackTraceToString(event.getThrown(), true);
final String connectionName = ds.getConfig().getName();
for (Listener listener : this.listeners) {
if (event.getLevel().intLevel() > listener.getLevel().intLevel()) {
break;
}
try {
AlertListenerMessage alertMessage = AlertListenerMessage.create(listener.getMember(), intLevel, date, connectionName, threadName, Thread.currentThread().getId(), logMessage, stackTrace);
if (listener.getMember().equals(distMgr.getDistributionManagerId())) {
if (isDebugEnabled) {
logger.debug("Delivering local alert message: {}, {}, {}, {}, {}, [{}], [{}].", listener.getMember(), intLevel, date, connectionName, threadName, logMessage, stackTrace);
}
alertMessage.process(distMgr);
} else {
if (isDebugEnabled) {
logger.debug("Delivering remote alert message: {}, {}, {}, {}, {}, [{}], [{}].", listener.getMember(), intLevel, date, connectionName, threadName, logMessage, stackTrace);
}
distMgr.putOutgoing(alertMessage);
}
} catch (ReenteredConnectException e) {
// OK. We can't send to this recipient because we're in the middle of
// trying to connect to it.
}
}
} finally {
setIsAlerting(false);
}
}
Aggregations