public ClientListenerInvocation(IClientMessage message, DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder, ClientConnection connection)
: base(message, connection)
{
_responseDecoder = responseDecoder;
_handler = handler;
}
public ClientListenerInvocation(IClientMessage message, DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder, string memberUuid)
: base(message, memberUuid)
{
_responseDecoder = responseDecoder;
_handler = handler;
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
ResponseParameters parameters = new ResponseParameters();
byte status;
status = clientMessage.GetByte();
parameters.status = status;
Address address = null;
bool address_isNull = clientMessage.GetBoolean();
if (!address_isNull)
{
address = AddressCodec.Decode(clientMessage);
parameters.address = address;
}
string uuid = null;
bool uuid_isNull = clientMessage.GetBoolean();
if (!uuid_isNull)
{
uuid = clientMessage.GetStringUtf8();
parameters.uuid = uuid;
}
string ownerUuid = null;
bool ownerUuid_isNull = clientMessage.GetBoolean();
if (!ownerUuid_isNull)
{
ownerUuid = clientMessage.GetStringUtf8();
parameters.ownerUuid = ownerUuid;
}
byte serializationVersion;
serializationVersion = clientMessage.GetByte();
parameters.serializationVersion = serializationVersion;
return parameters;
}
public string StartListening(IClientMessage request, DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder, object key = null)
{
try
{
IFuture<IClientMessage> task;
if (key == null)
{
task = _client.GetInvocationService()
.InvokeListenerOnRandomTarget(request, handler, responseDecoder);
}
else
{
task = _client.GetInvocationService()
.InvokeListenerOnKeyOwner(request, key, handler, responseDecoder);
}
var clientMessage = ThreadUtil.GetResult(task);
var registrationId = responseDecoder(clientMessage);
RegisterListener(registrationId, request.GetCorrelationId());
return registrationId;
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
}
public override IFuture<IClientMessage> InvokeOnKeyOwner(IClientMessage request, object key)
{
var partitionService = (ClientPartitionService) Client.GetClientPartitionService();
var partitionId = partitionService.GetPartitionId(key);
var owner = partitionService.GetPartitionOwner(partitionId);
return Invoke(new ClientInvocation(request, partitionId), owner);
}
public ClientListenerInvocation(IClientMessage message, DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder, Address address)
: base(message, address)
{
_responseDecoder = responseDecoder;
_handler = handler;
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
long response;
response = clientMessage.GetLong();
parameters.response = response;
return parameters;
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
ResponseParameters parameters = new ResponseParameters();
bool response ;
response = clientMessage.GetBoolean();
parameters.response = response;
return parameters;
}
public override IFuture<IClientMessage> InvokeListenerOnPartition(IClientMessage request, int partitionId,
DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder)
{
var partitionService = (ClientPartitionService) Client.GetClientPartitionService();
var owner = partitionService.GetPartitionOwner(partitionId);
return Invoke(new ClientListenerInvocation(request, handler, responseDecoder, partitionId), owner);
}
public override IFuture<IClientMessage> InvokeListenerOnKeyOwner(IClientMessage request, object key, DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder)
{
var partitionService = (ClientPartitionService)Client.GetClientPartitionService();
var partitionId = partitionService.GetPartitionId(key);
return SendToOwner(new ClientListenerInvocation(request, handler, responseDecoder, partitionId));
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
ResponseParameters parameters = new ResponseParameters();
string response = null;
response = clientMessage.GetStringUtf8();
parameters.response = response;
return parameters;
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
IData response = null;
var response_isNull = clientMessage.GetBoolean();
if (!response_isNull)
{
response = clientMessage.GetData();
parameters.response = response;
}
return parameters;
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
SimpleEntryView<IData, IData> dataEntryView = null;
var dataEntryView_isNull = clientMessage.GetBoolean();
if (!dataEntryView_isNull)
{
dataEntryView = EntryViewCodec.Decode(clientMessage);
parameters.dataEntryView = dataEntryView;
}
return parameters;
}
public static Address Decode(IClientMessage clientMessage)
{
var host = clientMessage.GetStringUtf8();
var port = clientMessage.GetInt();
try
{
return new Address(host, port);
}
catch (SocketException)
{
return null;
}
}
public static StackTraceElement Decode(IClientMessage clientMessage)
{
var declaringClass = clientMessage.GetStringUtf8();
var methodName = clientMessage.GetStringUtf8();
var fileName_notNull = clientMessage.GetBoolean();
string fileName = null;
if (fileName_notNull)
{
fileName = clientMessage.GetStringUtf8();
}
var lineNumber = clientMessage.GetInt();
return new StackTraceElement(declaringClass, methodName, fileName, lineNumber);
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
ResponseParameters parameters = new ResponseParameters();
ISet<IData> set = null;
int set_size = clientMessage.GetInt();
set = new HashSet<IData>();
for (int set_index = 0; set_index<set_size; set_index++) {
IData set_item;
set_item = clientMessage.GetData();
set.Add(set_item);
}
parameters.set = set;
return parameters;
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
ResponseParameters parameters = new ResponseParameters();
IList<IData> list = null;
int list_size = clientMessage.GetInt();
list = new List<IData>();
for (int list_index = 0; list_index<list_size; list_index++) {
IData list_item;
list_item = clientMessage.GetData();
list.Add(list_item);
}
parameters.list = list;
return parameters;
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
ResponseParameters parameters = new ResponseParameters();
ISet<KeyValuePair<IData,IData>> entrySet = null;
int entrySet_size = clientMessage.GetInt();
entrySet = new HashSet<KeyValuePair<IData,IData>>();
for (int entrySet_index = 0; entrySet_index<entrySet_size; entrySet_index++) {
KeyValuePair<IData,IData> entrySet_item;
entrySet_item = clientMessage.GetMapEntry();
entrySet.Add(entrySet_item);
}
parameters.entrySet = entrySet;
return parameters;
}
public static Member Decode(IClientMessage clientMessage)
{
Address address = AddressCodec.Decode(clientMessage);
string uuid = clientMessage.GetStringUtf8();
bool liteMember = clientMessage.GetBoolean();
int attributeSize = clientMessage.GetInt();
IDictionary<string, string> attributes = new Dictionary<string, string>();
for (int i = 0; i < attributeSize; i++)
{
string key = clientMessage.GetStringUtf8();
string value = clientMessage.GetStringUtf8();
attributes[key] = value;
}
return new Member(address, uuid, attributes, liteMember);
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
IList<DistributedObjectInfo> infoCollection = null;
var infoCollection_size = clientMessage.GetInt();
infoCollection = new List<DistributedObjectInfo>();
for (var infoCollection_index = 0; infoCollection_index < infoCollection_size; infoCollection_index++)
{
DistributedObjectInfo infoCollection_item;
infoCollection_item = DistributedObjectInfoCodec.Decode(clientMessage);
infoCollection.Add(infoCollection_item);
}
parameters.infoCollection = infoCollection;
return parameters;
}
public static void Handle(IClientMessage clientMessage, HandleDistributedObject handleDistributedObject)
{
int messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventDistributedObject)
{
string name = null;
name = clientMessage.GetStringUtf8();
string serviceName = null;
serviceName = clientMessage.GetStringUtf8();
string eventType = null;
eventType = clientMessage.GetStringUtf8();
handleDistributedObject(name, serviceName, eventType);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler)).Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleMember handleMember,
HandleMemberSet handleMemberSet, HandleMemberAttributeChange handleMemberAttributeChange)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventMember)
{
IMember member = null;
member = MemberCodec.Decode(clientMessage);
int eventType;
eventType = clientMessage.GetInt();
handleMember(member, eventType);
return;
}
if (messageType == EventMessageConst.EventMemberSet)
{
IList<IMember> members = null;
var members_size = clientMessage.GetInt();
members = new List<IMember>();
for (var members_index = 0; members_index < members_size; members_index++)
{
IMember members_item;
members_item = MemberCodec.Decode(clientMessage);
members.Add(members_item);
}
handleMemberSet(members);
return;
}
if (messageType == EventMessageConst.EventMemberAttributeChange)
{
string uuid = null;
uuid = clientMessage.GetStringUtf8();
string key = null;
key = clientMessage.GetStringUtf8();
int operationType;
operationType = clientMessage.GetInt();
string value = null;
var value_isNull = clientMessage.GetBoolean();
if (!value_isNull)
{
value = clientMessage.GetStringUtf8();
}
handleMemberAttributeChange(uuid, key, operationType, value);
return;
}
Logger.GetLogger(typeof (AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
ResponseParameters parameters = new ResponseParameters();
int readCount ;
readCount = clientMessage.GetInt();
parameters.readCount = readCount;
IList<IData> items = null;
int items_size = clientMessage.GetInt();
items = new List<IData>();
for (int items_index = 0; items_index<items_size; items_index++) {
IData items_item;
items_item = clientMessage.GetData();
items.Add(items_item);
}
parameters.items = items;
return parameters;
}
public static void Handle(IClientMessage clientMessage, HandleTopic handleTopic)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventTopic)
{
IData item = null;
item = clientMessage.GetData();
long publishTime;
publishTime = clientMessage.GetLong();
string uuid = null;
uuid = clientMessage.GetStringUtf8();
handleTopic(item, publishTime, uuid);
return;
}
Logger.GetLogger(typeof (AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static SimpleEntryView<IData, IData> Decode(IClientMessage clientMessage)
{
var dataEntryView = new SimpleEntryView<IData, IData>();
dataEntryView.SetKey(clientMessage.GetData());
dataEntryView.SetValue(clientMessage.GetData());
dataEntryView.SetCost(clientMessage.GetLong());
dataEntryView.SetCreationTime(clientMessage.GetLong());
dataEntryView.SetExpirationTime(clientMessage.GetLong());
dataEntryView.SetHits(clientMessage.GetLong());
dataEntryView.SetLastAccessTime(clientMessage.GetLong());
dataEntryView.SetLastStoredTime(clientMessage.GetLong());
dataEntryView.SetLastUpdateTime(clientMessage.GetLong());
dataEntryView.SetVersion(clientMessage.GetLong());
dataEntryView.SetEvictionCriteriaNumber(clientMessage.GetLong());
dataEntryView.SetTtl(clientMessage.GetLong());
return dataEntryView;
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
ResponseParameters parameters = new ResponseParameters();
IList<KeyValuePair<IData, IData>> response = null;
int response_size = clientMessage.GetInt();
response = new List<KeyValuePair<IData, IData>>();
for (int response_index = 0; response_index < response_size; response_index++)
{
KeyValuePair<IData, IData> response_item;
IData response_item_key;
IData response_item_val;
response_item_key = clientMessage.GetData();
response_item_val = clientMessage.GetData();
response_item = new KeyValuePair<IData, IData>(response_item_key, response_item_val);
response.Add(response_item);
}
parameters.response = response;
return parameters;
}
internal static void HandleEvent(IClientMessage clientMessage, HandleItemEventV10 handleItemEventV10)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventItem)
{
IData item = null;
var itemIsNull = clientMessage.GetBoolean();
if (!itemIsNull)
{
item = clientMessage.GetData();
}
var uuid = clientMessage.GetStringUtf8();
var eventType = clientMessage.GetInt();
handleItemEventV10(item, uuid, eventType);
return;
}
Logger.GetLogger(typeof(EventHandler)).Warning("Unknown message type received on event handler :" + messageType);
}
private void HandleResponseMessage(IClientMessage response)
{
var correlationId = response.GetCorrelationId();
ClientInvocation invocation;
if (_invocations.TryRemove(correlationId, out invocation))
{
if (response.GetMessageType() == Error.Type)
{
var error = Error.Decode(response);
var exception = ExceptionUtil.ToException(error);
// retry only specific exceptions
HandleException(invocation, exception);
}
// if this was a re-registration operation, then we will throw away the response and just store the alias
else if (invocation is ClientListenerInvocation && invocation.Future.IsComplete &&
invocation.Future.Result != null)
{
var listenerInvocation = (ClientListenerInvocation)invocation;
var originalRegistrationId = GetRegistrationIdFromResponse(listenerInvocation);
var newRegistrationId = listenerInvocation.ResponseDecoder(response);
_client.GetListenerService()
.ReregisterListener(originalRegistrationId, newRegistrationId,
invocation.Message.GetCorrelationId());
if (Logger.IsFinestEnabled())
{
Logger.Finest(string.Format("Re-registered listener for {0} of type {1:X}",
originalRegistrationId,
listenerInvocation.Message.GetMessageType()));
}
}
else
{
invocation.Future.Result = response;
}
}
else
{
Logger.Warning("No call for correlationId: " + correlationId + ", response: " + response);
}
}
public static void Handle(IClientMessage clientMessage, HandleEntry handleEntry)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventEntry)
{
IData key = null;
var key_isNull = clientMessage.GetBoolean();
if (!key_isNull)
{
key = clientMessage.GetData();
}
IData value = null;
var value_isNull = clientMessage.GetBoolean();
if (!value_isNull)
{
value = clientMessage.GetData();
}
IData oldValue = null;
var oldValue_isNull = clientMessage.GetBoolean();
if (!oldValue_isNull)
{
oldValue = clientMessage.GetData();
}
IData mergingValue = null;
var mergingValue_isNull = clientMessage.GetBoolean();
if (!mergingValue_isNull)
{
mergingValue = clientMessage.GetData();
}
int eventType;
eventType = clientMessage.GetInt();
string uuid = null;
uuid = clientMessage.GetStringUtf8();
int numberOfAffectedEntries;
numberOfAffectedEntries = clientMessage.GetInt();
handleEntry(key, value, oldValue, mergingValue, eventType, uuid, numberOfAffectedEntries);
return;
}
Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleItem handleItem)
{
int messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventItem)
{
IData item = null;
bool item_isNull = clientMessage.GetBoolean();
if (!item_isNull)
{
item = clientMessage.GetData();
}
string uuid = null;
uuid = clientMessage.GetStringUtf8();
int eventType;
eventType = clientMessage.GetInt();
handleItem(item, uuid, eventType);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler)).Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleItem handleItem)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventItem)
{
IData item = null;
var itemIsNull = clientMessage.GetBoolean();
if (!itemIsNull)
{
item = clientMessage.GetData();
}
var uuid = clientMessage.GetStringUtf8();
var eventType = clientMessage.GetInt();
handleItem(item, uuid, eventType);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
int readCount;
readCount = clientMessage.GetInt();
parameters.readCount = readCount;
IList <IData> items = null;
var items_size = clientMessage.GetInt();
items = new List <IData>();
for (var items_index = 0; items_index < items_size; items_index++)
{
IData items_item;
items_item = clientMessage.GetData();
items.Add(items_item);
}
parameters.items = items;
return(parameters);
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
ResponseParameters parameters = new ResponseParameters();
IList <KeyValuePair <IData, IData> > response = null;
int response_size = clientMessage.GetInt();
response = new List <KeyValuePair <IData, IData> >();
for (int response_index = 0; response_index < response_size; response_index++)
{
KeyValuePair <IData, IData> response_item;
IData response_item_key;
IData response_item_val;
response_item_key = clientMessage.GetData();
response_item_val = clientMessage.GetData();
response_item = new KeyValuePair <IData, IData>(response_item_key, response_item_val);
response.Add(response_item);
}
parameters.response = response;
return(parameters);
}
internal static void HandleEvent(IClientMessage clientMessage, HandleMemberEventV10 handleMemberEventV10,
HandleMemberListEventV10 handleMemberListEventV10,
HandleMemberAttributeChangeEventV10 handleMemberAttributeChangeEventV10)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventMember)
{
var member = MemberCodec.Decode(clientMessage);
var eventType = clientMessage.GetInt();
handleMemberEventV10(member, eventType);
return;
}
if (messageType == EventMessageConst.EventMemberList)
{
var membersSize = clientMessage.GetInt();
var members = new List <IMember>(membersSize);
for (var membersIndex = 0; membersIndex < membersSize; membersIndex++)
{
var membersItem = MemberCodec.Decode(clientMessage);
members.Add(membersItem);
}
handleMemberListEventV10(members);
return;
}
if (messageType == EventMessageConst.EventMemberAttributeChange)
{
var uuid = clientMessage.GetStringUtf8();
var key = clientMessage.GetStringUtf8();
var operationType = clientMessage.GetInt();
string value = null;
var valueIsNull = clientMessage.GetBoolean();
if (!valueIsNull)
{
value = clientMessage.GetStringUtf8();
}
handleMemberAttributeChangeEventV10(uuid, key, operationType, value);
return;
}
Logger.GetLogger(typeof(EventHandler)).Warning("Unknown message type received on event handler :" + messageType);
}
public static void Handle(IClientMessage clientMessage, HandleMember handleMember,
HandleMemberList handleMemberList, HandleMemberAttributeChange handleMemberAttributeChange)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventMember)
{
var member = MemberCodec.Decode(clientMessage);
var eventType = clientMessage.GetInt();
handleMember(member, eventType);
return;
}
if (messageType == EventMessageConst.EventMemberList)
{
var members = new List <Core.IMember>();
var membersSize = clientMessage.GetInt();
for (var membersIndex = 0; membersIndex < membersSize; membersIndex++)
{
var membersItem = MemberCodec.Decode(clientMessage);
members.Add(membersItem);
}
handleMemberList(members);
return;
}
if (messageType == EventMessageConst.EventMemberAttributeChange)
{
var uuid = clientMessage.GetStringUtf8();
var key = clientMessage.GetStringUtf8();
var operationType = clientMessage.GetInt();
string value = null;
var valueIsNull = clientMessage.GetBoolean();
if (!valueIsNull)
{
value = clientMessage.GetStringUtf8();
}
handleMemberAttributeChange(uuid, key, operationType, value);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleEntry handleEntry)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventEntry)
{
IData key = null;
var key_isNull = clientMessage.GetBoolean();
if (!key_isNull)
{
key = clientMessage.GetData();
}
IData value = null;
var value_isNull = clientMessage.GetBoolean();
if (!value_isNull)
{
value = clientMessage.GetData();
}
IData oldValue = null;
var oldValue_isNull = clientMessage.GetBoolean();
if (!oldValue_isNull)
{
oldValue = clientMessage.GetData();
}
IData mergingValue = null;
var mergingValue_isNull = clientMessage.GetBoolean();
if (!mergingValue_isNull)
{
mergingValue = clientMessage.GetData();
}
int eventType;
eventType = clientMessage.GetInt();
string uuid = null;
uuid = clientMessage.GetStringUtf8();
int numberOfAffectedEntries;
numberOfAffectedEntries = clientMessage.GetInt();
handleEntry(key, value, oldValue, mergingValue, eventType, uuid, numberOfAffectedEntries);
return;
}
Logger.GetLogger(typeof (AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
private void HandleResponseMessage(IClientMessage response)
{
var correlationId = response.GetCorrelationId();
ClientInvocation invocation;
if (_invocations.TryRemove(correlationId, out invocation))
{
if (response.GetMessageType() == Error.Type)
{
var error = Error.Decode(response);
if (Logger.IsFinestEnabled())
{
Logger.Finest("Error received from server: " + error);
}
var exception = ExceptionUtil.ToException(error);
// retry only specific exceptions
HandleInvocationException(invocation, exception);
}
else
{
try
{
invocation.Future.Result = response;
}
catch (InvalidOperationException e)
{
if (Logger.IsFinestEnabled())
{
Logger.Finest("Invocation already completed:", e);
}
}
}
}
else
{
Logger.Warning("No call for correlationId: " + correlationId + ", response: " + response);
}
}
internal static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
var responseSize = clientMessage.GetInt();
var response = new List <IData>(responseSize);
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 Error(IClientMessage message)
{
ErrorCode = message.GetInt();
ClassName = message.GetStringUtf8();
var message_isNull = message.GetBoolean();
if (!message_isNull)
{
Message = message.GetStringUtf8();
}
var stackTraceCount = message.GetInt();
StackTrace = new StackTraceElement[stackTraceCount];
for (var i = 0; i < stackTraceCount; i++)
{
StackTrace[i] = StackTraceElementCodec.Decode(message);
}
CauseErrorCode = message.GetInt();
var causeClassName_isNull = message.GetBoolean();
if (!causeClassName_isNull)
{
CauseClassName = message.GetStringUtf8();
}
}
internal static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
var value = clientMessage.GetLong();
parameters.value = value;
var replicaTimestampsSize = clientMessage.GetInt();
var replicaTimestamps = new List <KeyValuePair <string, long> >(replicaTimestampsSize);
for (var replicaTimestampsIndex = 0; replicaTimestampsIndex < replicaTimestampsSize; replicaTimestampsIndex++)
{
var replicaTimestampsItemKey = clientMessage.GetStringUtf8();
var replicaTimestampsItemVal = clientMessage.GetLong();
var replicaTimestampsItem = new KeyValuePair <string, long>(replicaTimestampsItemKey, replicaTimestampsItemVal);
replicaTimestamps.Add(replicaTimestampsItem);
}
parameters.replicaTimestamps = replicaTimestamps;
var replicaCount = clientMessage.GetInt();
parameters.replicaCount = replicaCount;
return(parameters);
}
internal static void HandleEvent(IClientMessage clientMessage, HandleEntryEventV10 handleEntryEventV10)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventEntry)
{
IData key = null;
var keyIsNull = clientMessage.GetBoolean();
if (!keyIsNull)
{
key = clientMessage.GetData();
}
IData value = null;
var valueIsNull = clientMessage.GetBoolean();
if (!valueIsNull)
{
value = clientMessage.GetData();
}
IData oldValue = null;
var oldValueIsNull = clientMessage.GetBoolean();
if (!oldValueIsNull)
{
oldValue = clientMessage.GetData();
}
IData mergingValue = null;
var mergingValueIsNull = clientMessage.GetBoolean();
if (!mergingValueIsNull)
{
mergingValue = clientMessage.GetData();
}
var eventType = clientMessage.GetInt();
var uuid = clientMessage.GetStringUtf8();
var numberOfAffectedEntries = clientMessage.GetInt();
handleEntryEventV10(key, value, oldValue, mergingValue, eventType, uuid, numberOfAffectedEntries);
return;
}
Logger.GetLogger(typeof(EventHandler)).Warning("Unknown message type received on event handler :" + messageType);
}
private void SendResponse(IClientMessage response)
{
if (!_socket.Connected)
{
Debug.WriteLine("Socket disconnected when sending response!");
return;
}
Debug.WriteLine(response);
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.RemoteEndPoint = _socket.RemoteEndPoint;
args.UserToken = _socket;
MemoryStream ms = new MemoryStream();
response.Serialize(ms);
byte[] data = ms.GetBuffer();
args.SetBuffer(data, 0, data.Length);
_socket.SendAsync(args);
}
public string StartListening(IClientMessage request, DistributedEventHandler handler, DecodeStartListenerResponse responseDecoder, object key = null)
{
try
{
IFuture <IClientMessage> task;
if (key == null)
{
task = _client.GetInvocationService().InvokeListenerOnRandomTarget(request, handler, responseDecoder);
}
else
{
task = _client.GetInvocationService().InvokeListenerOnKeyOwner(request, key, handler, responseDecoder);
}
var clientMessage = ThreadUtil.GetResult(task);
var registrationId = responseDecoder(clientMessage);
RegisterListener(registrationId, request.GetCorrelationId());
return(registrationId);
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
}
private static void ProcessClientMessage(IClientMessage message)
{
switch (message)
{
case ClientMessages.ClientMessage m:
{
Console.WriteLine($"Received Message From: '{m.Client.Client.RemoteEndPoint}'='{m.Message}'");
SendMessage(message.Client, $"Responding to: {m.Message}");
break;
}
case ClientMessages.ClientConnected m:
{
break;
}
case ClientMessages.ClientDisconnected m:
{
Console.WriteLine($"Client: '{m.Client.Client.RemoteEndPoint}' has disconnected");
break;
}
}
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
byte status;
status = clientMessage.GetByte();
parameters.status = status;
Address address = null;
var address_isNull = clientMessage.GetBoolean();
if (!address_isNull)
{
address = AddressCodec.Decode(clientMessage);
parameters.address = address;
}
string uuid = null;
var uuid_isNull = clientMessage.GetBoolean();
if (!uuid_isNull)
{
uuid = clientMessage.GetStringUtf8();
parameters.uuid = uuid;
}
string ownerUuid = null;
var ownerUuid_isNull = clientMessage.GetBoolean();
if (!ownerUuid_isNull)
{
ownerUuid = clientMessage.GetStringUtf8();
parameters.ownerUuid = ownerUuid;
}
byte serializationVersion;
serializationVersion = clientMessage.GetByte();
parameters.serializationVersion = serializationVersion;
return(parameters);
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
IDictionary<Address, IList<int>> partitions = null;
var partitions_size = clientMessage.GetInt();
partitions = new Dictionary<Address, IList<int>>(partitions_size);
for (var partitions_index = 0; partitions_index < partitions_size; partitions_index++)
{
Address partitions_key;
IList<int> partitions_val;
partitions_key = AddressCodec.Decode(clientMessage);
var partitions_val_size = clientMessage.GetInt();
partitions_val = new List<int>();
for (var partitions_val_index = 0; partitions_val_index < partitions_val_size; partitions_val_index++)
{
int partitions_val_item;
partitions_val_item = clientMessage.GetInt();
partitions_val.Add(partitions_val_item);
}
partitions.Add(partitions_key, partitions_val);
}
parameters.partitions = partitions;
return parameters;
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
var partitions = new List <KeyValuePair <Address, IList <int> > >();
var partitionsSize = clientMessage.GetInt();
for (var partitionsIndex = 0; partitionsIndex < partitionsSize; partitionsIndex++)
{
var partitionsItemKey = AddressCodec.Decode(clientMessage);
var partitionsItemVal = new List <int>();
var partitionsItemValSize = clientMessage.GetInt();
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;
return(parameters);
}
public abstract IFuture <IClientMessage> InvokeListenerOnTarget(IClientMessage request, Address target,
DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder);
public abstract IFuture <IClientMessage> InvokeListenerOnKeyOwner(IClientMessage request, object key,
DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder);
protected override IClientMessage Invoke(IClientMessage request)
{
return(base.Invoke(request, GetPartitionKey()));
}
public abstract IFuture <IClientMessage> InvokeOnPartition(IClientMessage request, int partitionId);
public abstract IFuture <IClientMessage> InvokeOnTarget(IClientMessage request, Address target);
public abstract IFuture <IClientMessage> InvokeOnRandomTarget(IClientMessage request);
protected override IClientMessage Invoke(IClientMessage request)
{
return(base.Invoke(request, GetKeyData()));
}
public abstract IFuture <IClientMessage> InvokeOnKeyOwner(IClientMessage request, object key);
public abstract IFuture <IClientMessage> InvokeListenerOnPartition(IClientMessage request, int partitionId,
DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder);
protected virtual T Invoke <T>(IClientMessage request, Func <IClientMessage, T> decodeResponse)
{
var response = Invoke(request);
return(decodeResponse(response));
}
public abstract IFuture <IClientMessage> InvokeOnMember(IClientMessage request, IMember member);
public static Error Decode(IClientMessage flyweight)
{
return(new Error(flyweight));
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
return(parameters);
}
