internal static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
var partitionsSize = clientMessage.GetInt();
var partitions = new List <KeyValuePair <Address, IList <int> > >(partitionsSize);
for (var partitionsIndex = 0; partitionsIndex < partitionsSize; partitionsIndex++)
{
var partitionsItemKey = AddressCodec.Decode(clientMessage);
var partitionsItemValSize = clientMessage.GetInt();
var partitionsItemVal = new List <int>(partitionsItemValSize);
for (var partitionsItemValIndex = 0; partitionsItemValIndex < partitionsItemValSize; partitionsItemValIndex++)
{
var partitionsItemValItem = clientMessage.GetInt();
partitionsItemVal.Add(partitionsItemValItem);
}
var partitionsItem = new KeyValuePair <Address, IList <int> >(partitionsItemKey, partitionsItemVal);
partitions.Add(partitionsItem);
}
parameters.partitions = partitions;
if (clientMessage.IsComplete())
{
return(parameters);
}
var partitionStateVersion = clientMessage.GetInt();
parameters.partitionStateVersion = partitionStateVersion;
parameters.partitionStateVersionExist = true;
return(parameters);
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
if (clientMessage.IsComplete())
{
return(parameters);
}
var response = new List <IData>();
var responseSize = clientMessage.GetInt();
for (var responseIndex = 0; responseIndex < responseSize; responseIndex++)
{
var responseItemIsNull = clientMessage.GetBoolean();
if (!responseItemIsNull)
{
var responseItem = clientMessage.GetData();
response.Add(responseItem);
}
else
{
response.Add(null);
}
}
parameters.response = response;
return(parameters);
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
var status = clientMessage.GetByte();
parameters.status = status;
var addressIsNull = clientMessage.GetBoolean();
if (!addressIsNull)
{
var address = AddressCodec.Decode(clientMessage);
parameters.address = address;
}
var uuidIsNull = clientMessage.GetBoolean();
if (!uuidIsNull)
{
var uuid = clientMessage.GetStringUtf8();
parameters.uuid = uuid;
}
var ownerUuidIsNull = clientMessage.GetBoolean();
if (!ownerUuidIsNull)
{
var ownerUuid = clientMessage.GetStringUtf8();
parameters.ownerUuid = ownerUuid;
}
var serializationVersion = clientMessage.GetByte();
parameters.serializationVersion = serializationVersion;
if (clientMessage.IsComplete())
{
return(parameters);
}
var serverHazelcastVersion = clientMessage.GetStringUtf8();
parameters.serverHazelcastVersion = serverHazelcastVersion;
parameters.serverHazelcastVersionExist = true;
var clientUnregisteredMembersIsNull = clientMessage.GetBoolean();
if (!clientUnregisteredMembersIsNull)
{
var clientUnregisteredMembers = new List <Core.IMember>();
var clientUnregisteredMembersSize = clientMessage.GetInt();
for (var clientUnregisteredMembersIndex = 0;
clientUnregisteredMembersIndex < clientUnregisteredMembersSize;
clientUnregisteredMembersIndex++)
{
var clientUnregisteredMembersItem = MemberCodec.Decode(clientMessage);
clientUnregisteredMembers.Add(clientUnregisteredMembersItem);
}
parameters.clientUnregisteredMembers = clientUnregisteredMembers;
}
parameters.clientUnregisteredMembersExist = true;
return(parameters);
}
internal static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
var readCount = clientMessage.GetInt();
parameters.readCount = readCount;
var itemsSize = clientMessage.GetInt();
var items = new List <IData>(itemsSize);
for (var itemsIndex = 0; itemsIndex < itemsSize; itemsIndex++)
{
var itemsItem = clientMessage.GetData();
items.Add(itemsItem);
}
parameters.items = items;
if (clientMessage.IsComplete())
{
return(parameters);
}
var itemSeqsIsNull = clientMessage.GetBoolean();
if (!itemSeqsIsNull)
{
var itemSeqsSize = clientMessage.GetInt();
var itemSeqs = new long[itemSeqsSize];
for (var itemSeqsIndex = 0; itemSeqsIndex < itemSeqsSize; itemSeqsIndex++)
{
var itemSeqsItem = clientMessage.GetLong();
itemSeqs[itemSeqsIndex] = itemSeqsItem;
}
parameters.itemSeqs = itemSeqs;
}
parameters.itemSeqsExist = true;
if (clientMessage.IsComplete())
{
return(parameters);
}
var nextSeq = clientMessage.GetLong();
parameters.nextSeq = nextSeq;
parameters.nextSeqExist = true;
return(parameters);
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
if (clientMessage.IsComplete())
{
return(parameters);
}
var responseIsNull = clientMessage.GetBoolean();
if (!responseIsNull)
{
var response = clientMessage.GetData();
parameters.response = response;
}
return(parameters);
}
public static void Handle(IClientMessage clientMessage, HandleIMapInvalidation handleIMapInvalidation,
HandleIMapBatchInvalidation handleIMapBatchInvalidation)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventIMapInvalidation)
{
var IMapInvalidationMessageFinished = false;
IData key = null;
var keyIsNull = clientMessage.GetBoolean();
if (!keyIsNull)
{
key = clientMessage.GetData();
}
if (!IMapInvalidationMessageFinished)
{
IMapInvalidationMessageFinished = clientMessage.IsComplete();
}
string sourceUuid = null;
if (!IMapInvalidationMessageFinished)
{
sourceUuid = clientMessage.GetStringUtf8();
}
Guid?partitionUuid = null;
if (!IMapInvalidationMessageFinished)
{
partitionUuid = UUIDCodec.Decode(clientMessage);
}
long?sequence = null;
if (!IMapInvalidationMessageFinished)
{
sequence = clientMessage.GetLong();
}
handleIMapInvalidation(key, sourceUuid, partitionUuid, sequence);
return;
}
if (messageType == EventMessageConst.EventIMapBatchInvalidation)
{
var IMapBatchInvalidationMessageFinished = false;
var keys = new List <IData>();
var keysSize = clientMessage.GetInt();
for (var keysIndex = 0; keysIndex < keysSize; keysIndex++)
{
var keysItem = clientMessage.GetData();
keys.Add(keysItem);
}
if (!IMapBatchInvalidationMessageFinished)
{
IMapBatchInvalidationMessageFinished = clientMessage.IsComplete();
}
IList <string> sourceUuids = null;
if (!IMapBatchInvalidationMessageFinished)
{
sourceUuids = new List <string>();
var sourceUuidsSize = clientMessage.GetInt();
for (var sourceUuidsIndex = 0; sourceUuidsIndex < sourceUuidsSize; sourceUuidsIndex++)
{
var sourceUuidsItem = clientMessage.GetStringUtf8();
sourceUuids.Add(sourceUuidsItem);
}
}
IList <Guid> partitionUuids = null;
if (!IMapBatchInvalidationMessageFinished)
{
partitionUuids = new List <Guid>();
var partitionUuidsSize = clientMessage.GetInt();
for (var partitionUuidsIndex = 0;
partitionUuidsIndex < partitionUuidsSize;
partitionUuidsIndex++)
{
var partitionUuidsItem = UUIDCodec.Decode(clientMessage);
partitionUuids.Add(partitionUuidsItem);
}
}
IList <long> sequences = null;
if (!IMapBatchInvalidationMessageFinished)
{
sequences = new List <long>();
var sequencesSize = clientMessage.GetInt();
for (var sequencesIndex = 0; sequencesIndex < sequencesSize; sequencesIndex++)
{
var sequencesItem = clientMessage.GetLong();
sequences.Add(sequencesItem);
}
}
handleIMapBatchInvalidation(keys, sourceUuids, partitionUuids, sequences);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
internal static void HandleEvent(IClientMessage clientMessage,
HandleIMapInvalidationEventV10 handleIMapInvalidationEventV10,
HandleIMapInvalidationEventV14 handleIMapInvalidationEventV14,
HandleIMapBatchInvalidationEventV10 handleIMapBatchInvalidationEventV10,
HandleIMapBatchInvalidationEventV14 handleIMapBatchInvalidationEventV14)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventIMapInvalidation)
{
IData key = null;
var keyIsNull = clientMessage.GetBoolean();
if (!keyIsNull)
{
key = clientMessage.GetData();
}
if (clientMessage.IsComplete())
{
handleIMapInvalidationEventV10(key);
return;
}
var sourceUuid = clientMessage.GetStringUtf8();
var partitionUuid = GuidCodec.Decode(clientMessage);
var sequence = clientMessage.GetLong();
handleIMapInvalidationEventV14(key, sourceUuid, partitionUuid, sequence);
return;
}
if (messageType == EventMessageConst.EventIMapBatchInvalidation)
{
var keysSize = clientMessage.GetInt();
var keys = new List <IData>(keysSize);
for (var keysIndex = 0; keysIndex < keysSize; keysIndex++)
{
var keysItem = clientMessage.GetData();
keys.Add(keysItem);
}
if (clientMessage.IsComplete())
{
handleIMapBatchInvalidationEventV10(keys);
return;
}
var sourceUuidsSize = clientMessage.GetInt();
var sourceUuids = new List <string>(sourceUuidsSize);
for (var sourceUuidsIndex = 0; sourceUuidsIndex < sourceUuidsSize; sourceUuidsIndex++)
{
var sourceUuidsItem = clientMessage.GetStringUtf8();
sourceUuids.Add(sourceUuidsItem);
}
var partitionUuidsSize = clientMessage.GetInt();
var partitionUuids = new List <Guid>(partitionUuidsSize);
for (var partitionUuidsIndex = 0; partitionUuidsIndex < partitionUuidsSize; partitionUuidsIndex++)
{
var partitionUuidsItem = GuidCodec.Decode(clientMessage);
partitionUuids.Add(partitionUuidsItem);
}
var sequencesSize = clientMessage.GetInt();
var sequences = new List <long>(sequencesSize);
for (var sequencesIndex = 0; sequencesIndex < sequencesSize; sequencesIndex++)
{
var sequencesItem = clientMessage.GetLong();
sequences.Add(sequencesItem);
}
handleIMapBatchInvalidationEventV14(keys, sourceUuids, partitionUuids, sequences);
return;
}
Logger.GetLogger(typeof(EventHandler)).Warning("Unknown message type received on event handler :" + messageType);
}
