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); }