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, Address address)
: base(message, address)
{
_responseDecoder = responseDecoder;
_handler = handler;
}
public ClientListenerInvocation(IClientMessage message, DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder, string memberUuid)
: base(message, memberUuid)
{
_responseDecoder = responseDecoder;
_handler = handler;
}
public ClientListenerInvocation(IClientMessage message, DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder, string memberUuid)
: base(message, memberUuid)
{
_responseDecoder = responseDecoder;
_handler = handler;
}
public ClientListenerInvocation(IClientMessage message, DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder, Address address)
: base(message, address)
{
_responseDecoder = responseDecoder;
_handler = handler;
}
public ClientListenerInvocation(IClientMessage message, DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder, ClientConnection connection)
: base(message, connection)
{
_responseDecoder = responseDecoder;
_handler = handler;
}
private void AddInvalidateListener()
{
try
{
IClientMessage request = null;
DistributedEventHandler handler = null;
if (cacheType == ClientNearCacheType.Map)
{
request = MapAddNearCacheEntryListenerCodec.EncodeRequest(mapName, false, (int)EntryEventType.All, false);
handler = message =>
{
MapAddNearCacheEntryListenerCodec.AbstractEventHandler.Handle(message,
(key, value, oldValue, mergingValue, type, uuid, entries) =>
{
CacheRecord removed;
cache.TryRemove(key, out removed);
});
};
}
else
{
throw new NotImplementedException("Near cache is not available for this type of data structure");
}
registrationId = context.GetListenerService().StartListening(request,
handler, m => MapAddNearCacheEntryListenerCodec.DecodeResponse(m).response);
}
catch (Exception e)
{
Logger.Severe("-----------------\n Near Cache is not initialized!!! \n-----------------", e);
}
}
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 string AddDistributedObjectListener(IDistributedObjectListener listener)
{
var isSmart = _client.GetClientConfig().GetNetworkConfig().IsSmartRouting();
var request = ClientAddDistributedObjectListenerCodec.EncodeRequest(isSmart);
var context = new ClientContext(_client.GetSerializationService(), _client.GetClientClusterService(),
_client.GetClientPartitionService(), _client.GetInvocationService(), _client.GetClientExecutionService(),
_client.GetListenerService(), _client.GetNearCacheManager(), this, _client.GetClientConfig());
DistributedEventHandler eventHandler = delegate(IClientMessage message)
{
ClientAddDistributedObjectListenerCodec.EventHandler.HandleEvent(message, (name, serviceName, eventType) =>
{
var _event = new LazyDistributedObjectEvent(eventType, serviceName, name, this);
switch (eventType)
{
case DistributedObjectEvent.EventType.Created:
listener.DistributedObjectCreated(_event);
break;
case DistributedObjectEvent.EventType.Destroyed:
listener.DistributedObjectDestroyed(_event);
break;
default:
Logger.Warning(string.Format("Undefined DistributedObjectListener event type received: {0} !!!",
eventType));
break;
}
});
};
return(context.GetListenerService().RegisterListener(request,
m => ClientAddDistributedObjectListenerCodec.DecodeResponse(m).response,
ClientRemoveDistributedObjectListenerCodec.EncodeRequest, eventHandler));
}
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 IFuture <IClientMessage> InvokeListenerOnConnection(IClientMessage request,
DistributedEventHandler handler, DecodeStartListenerResponse responseDecoder, ClientConnection connection)
{
var clientInvocation = new ClientListenerInvocation(request, handler, responseDecoder, connection);
Send(connection, clientInvocation);
return(clientInvocation.Future);
}
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 IFuture <IClientMessage> InvokeListenerOnConnection(IClientMessage request,
DistributedEventHandler eventHandler, ClientConnection connection)
{
var clientInvocation = new ClientInvocation(request, connection, eventHandler);
InvokeInternal(clientInvocation, null, connection);
return(clientInvocation.Future);
}
public ListenerRegistrationKey(string userRegistrationId, IClientMessage registrationRequest = null,
DecodeRegistrationResponse responseDecoder = null, DistributedEventHandler eventHandler = null)
{
UserRegistrationId = userRegistrationId;
RegistrationRequest = registrationRequest;
ResponseDecoder = responseDecoder;
EventHandler = eventHandler;
}
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 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 virtual string AddMessageListener(Action <Message <T> > listener)
{
var request = TopicAddMessageListenerCodec.EncodeRequest(GetName(), false);
DistributedEventHandler handler = m => TopicAddMessageListenerCodec.AbstractEventHandler.Handle(m,
(item, time, uuid) => HandleMessageListener(item, time, uuid, listener));
return(Listen(request, m => TopicAddMessageListenerCodec.DecodeResponse(m).response,
GetKey(), handler));
}
public ListenerRegistration(Guid userRegistrationId, ClientMessage registrationRequest = null,
DecodeRegisterResponse decodeRegisterResponse = null, EncodeDeregisterRequest encodeDeregisterRequest = null,
DistributedEventHandler eventHandler = null)
{
UserRegistrationId = userRegistrationId;
RegistrationRequest = registrationRequest;
EncodeDeregisterRequest = encodeDeregisterRequest;
DecodeRegisterResponse = decodeRegisterResponse;
EventHandler = eventHandler;
}
public override string AddItemListener(IItemListener <T> listener, bool includeValue)
{
var request = ListAddListenerCodec.EncodeRequest(GetName(), includeValue, false);
DistributedEventHandler handler = message => ListAddListenerCodec.AbstractEventHandler.Handle(message,
((item, uuid, type) => { HandleItemListener(item, uuid, (ItemEventType)type, listener, includeValue); }));
return(Listen(request,
m => ListAddListenerCodec.DecodeResponse(m).response, GetPartitionKey(), handler));
}
public ListenerRegistration(string userRegistrationId, IClientMessage registrationRequest = null,
DecodeRegisterResponse decodeRegisterResponse = null, EncodeDeregisterRequest encodeDeregisterRequest = null,
DistributedEventHandler eventHandler = null)
{
UserRegistrationId = userRegistrationId;
RegistrationRequest = registrationRequest;
EncodeDeregisterRequest = encodeDeregisterRequest;
DecodeRegisterResponse = decodeRegisterResponse;
EventHandler = eventHandler;
ConnectionRegistrations = new ConcurrentDictionary <ClientConnection, EventRegistration>();
}
public virtual string AddMessageListener(Action<Message<T>> listener)
{
var request = TopicAddMessageListenerCodec.EncodeRequest(GetName(), IsSmart());
DistributedEventHandler handler = m =>
TopicAddMessageListenerCodec.EventHandler.HandleEvent(m,
(item, time, uuid) =>
{
HandleMessageListener(item, time, uuid, listener);
});
return RegisterListener(request, m => TopicAddMessageListenerCodec.DecodeResponse(m).response,
id => TopicRemoveMessageListenerCodec.EncodeRequest(GetName(), id), handler);
}
public virtual string AddEntryListener(IEntryListener <K, V> listener, bool includeValue)
{
var request = MultiMapAddEntryListenerCodec.EncodeRequest(GetName(), includeValue, false);
DistributedEventHandler handler =
eventData => MultiMapAddEntryListenerCodec.AbstractEventHandler.Handle(eventData,
(key, value, oldValue, mergingValue, type, uuid, entries) =>
OnEntryEvent(key, value, oldValue, mergingValue, (EntryEventType)type, uuid, entries, includeValue, listener)
);
return(Listen(request, message => MultiMapAddEntryListenerCodec.DecodeResponse(message).response, handler));
}
public override string AddItemListener(IItemListener <T> listener, bool includeValue)
{
var request = SetAddListenerCodec.EncodeRequest(GetName(), includeValue, IsSmart());
DistributedEventHandler handler = message => SetAddListenerCodec.EventHandler.HandleEvent(message,
(item, uuid, type) =>
{
HandleItemListener(item, uuid, (ItemEventType)type, listener, includeValue);
});
return(RegisterListener(request, m => SetAddListenerCodec.DecodeResponse(m).response,
id => SetRemoveListenerCodec.EncodeRequest(GetName(), id), handler));
}
public string AddEntryListener(IEntryListener <TKey, TValue> listener, bool includeValue)
{
var listenerFlags = GetListenerFlags(listener);
var request = MapAddEntryListenerCodec.EncodeRequest(GetName(), includeValue, listenerFlags, false);
DistributedEventHandler handler =
eventData => MapAddEntryListenerCodec.AbstractEventHandler.Handle(eventData,
(key, value, oldValue, mergingValue, type, uuid, entries) =>
{
OnEntryEvent(key, value, oldValue, mergingValue, type, uuid, entries, includeValue, listener);
});
return(Listen(request, message => MapAddEntryListenerCodec.DecodeResponse(message).response, handler));
}
internal void ListenMembershipEvents(Address ownerConnectionAddress)
{
if (Logger.IsFinestEnabled())
{
Logger.Finest("Starting to listen for membership events from " + ownerConnectionAddress);
}
_initialListFetched = new ManualResetEventSlim();
try
{
var clientMessage = ClientAddMembershipListenerCodec.EncodeRequest(false);
DistributedEventHandler handler = m => ClientAddMembershipListenerCodec.EventHandler
.HandleEvent(m, HandleMember, HandleMemberCollection, HandleMemberAttributeChange);
try
{
var connection = _connectionManager.GetConnection(ownerConnectionAddress);
if (connection == null)
{
throw new InvalidOperationException(
"Can not load initial members list because owner connection is null. Address "
+ ownerConnectionAddress);
}
var invocationService = (ClientInvocationService)_client.GetInvocationService();
var future = invocationService.InvokeListenerOnConnection(clientMessage, handler, connection);
var response = ThreadUtil.GetResult(future);
//registration id is ignored as this listener will never be removed
var registirationId = ClientAddMembershipListenerCodec.DecodeResponse(response).response;
WaitInitialMemberListFetched();
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
}
catch (Exception e)
{
if (_client.GetLifecycleService().IsRunning())
{
if (Logger.IsFinestEnabled())
{
Logger.Warning("Error while registering to cluster events! -> " + ownerConnectionAddress, e);
}
else
{
Logger.Warning("Error while registering to cluster events! -> " + ownerConnectionAddress +
", Error: " + e);
}
}
}
}
public Guid AddItemListener(IItemListener <T> listener, bool includeValue)
{
var request = QueueAddListenerCodec.EncodeRequest(Name, includeValue, IsSmart());
DistributedEventHandler handler = m =>
QueueAddListenerCodec.EventHandler.HandleEvent(m,
(item, uuid, type) =>
{
HandleItemListener(item, uuid, (ItemEventType)type, listener, includeValue);
});
return(RegisterListener(request, m => QueueAddListenerCodec.DecodeResponse(m).Response,
id => QueueRemoveListenerCodec.EncodeRequest(Name, id), handler));
}
public string AddEntryListener(IEntryListener <K, V> listener, IPredicate <K, V> predicate, bool includeValue)
{
var predicateData = ToData(predicate);
var flags = GetListenerFlags(listener);
var request = MapAddEntryListenerWithPredicateCodec.EncodeRequest(GetName(), predicateData, includeValue, flags, false);
DistributedEventHandler handler =
eventData => MapAddEntryListenerWithPredicateCodec.AbstractEventHandler.Handle(eventData,
(key, value, oldValue, mergingValue, type, uuid, entries) =>
{
OnEntryEvent(key, value, oldValue, mergingValue, type, uuid, entries, includeValue, listener);
});
return(Listen(request, message => MapAddEntryListenerWithPredicateCodec.DecodeResponse(message).response, null,
handler));
}
public Guid AddEntryListener(MapListener listener, bool includeValue)
{
var listenerAdapter = EntryListenerAdapter <TKey, TValue> .CreateAdapter(listener, Client.SerializationService);
var listenerFlags = (int)listenerAdapter.ListenerFlags;
var request = MapAddEntryListenerCodec.EncodeRequest(Name, includeValue, listenerFlags, IsSmart());
DistributedEventHandler handler = eventData => MapAddEntryListenerCodec.EventHandler.HandleEvent(eventData,
(key, value, oldValue, mergingValue, type, uuid, entries) =>
{
OnEntryEvent(key, value, oldValue, mergingValue, type, uuid, entries, listenerAdapter);
});
return(RegisterListener(request, message => MapAddEntryListenerCodec.DecodeResponse(message).Response,
id => MapRemoveEntryListenerCodec.EncodeRequest(Name, id), handler));
}
public virtual string AddEntryListener(IEntryListener <TKey, TValue> listener, TKey key, bool includeValue)
{
var keyData = ToData(key);
var request = MultiMapAddEntryListenerToKeyCodec.EncodeRequest(GetName(), keyData, includeValue, IsSmart());
DistributedEventHandler handler =
eventData => MultiMapAddEntryListenerToKeyCodec.AbstractEventHandler.Handle(eventData,
(thekey, value, oldValue, mergingValue, type, uuid, entries) =>
OnEntryEvent(thekey, value, oldValue, mergingValue, (EntryEventType)type, uuid, entries,
includeValue, listener)
);
return(RegisterListener(request, message => MultiMapAddEntryListenerToKeyCodec.DecodeResponse(message).response,
id => MultiMapRemoveEntryListenerCodec.EncodeRequest(GetName(), id), handler));
}
public Invocation(ClientMessage request, Guid?targetUuid = null, int partitionId = -1,
Connection boundConnection = null, DistributedEventHandler eventHandler = null, string objectName = null)
{
Request = request;
TargetUuid = targetUuid;
PartitionId = partitionId;
BoundConnection = boundConnection;
EventHandler = eventHandler;
ObjectName = objectName;
Future = new SettableFuture <ClientMessage>();
StartTimeMillis = Clock.CurrentTimeMillis();
if (PartitionId != -1)
{
Request.PartitionId = PartitionId;
}
}
public string AddEntryListener(MapListener listener, TKey key, bool includeValue)
{
var keyData = ToData(key);
var listenerAdapter =
EntryListenerAdapter <TKey, TValue> .CreateAdapter(listener, GetContext().GetSerializationService());
var listenerFlags = (int)listenerAdapter.ListenerFlags;
var request = MapAddEntryListenerToKeyCodec.EncodeRequest(GetName(), keyData, includeValue, listenerFlags, IsSmart());
DistributedEventHandler handler = eventData => MapAddEntryListenerToKeyCodec.EventHandler.HandleEvent(eventData,
(key_, value, oldValue, mergingValue, type, uuid, entries) =>
{
OnEntryEvent(key_, value, oldValue, mergingValue, type, uuid, entries, listenerAdapter);
});
return(RegisterListener(request, message => MapAddEntryListenerToKeyCodec.DecodeResponse(message).response,
id => MapRemoveEntryListenerCodec.EncodeRequest(GetName(), id), handler));
}
public virtual string AddEntryListener(IEntryListener <TKey, TValue> listener, bool includeValue)
{
var listenerAdapter =
EntryListenerAdapter <TKey, TValue> .CreateAdapter(listener, GetContext().GetSerializationService());
var request = MultiMapAddEntryListenerCodec.EncodeRequest(GetName(), includeValue, IsSmart());
DistributedEventHandler handler =
eventData => MultiMapAddEntryListenerCodec.EventHandler.HandleEvent(eventData,
(key, value, oldValue, mergingValue, type, uuid, entries) =>
{
OnEntryEvent(key, value, oldValue, mergingValue, type, uuid, entries, listenerAdapter);
});
return(RegisterListener(request, message => MultiMapAddEntryListenerCodec.DecodeResponse(message).response,
id => MultiMapRemoveEntryListenerCodec.EncodeRequest(GetName(), id), handler));
}
public virtual Guid AddEntryListener(IEntryListener <TKey, TValue> listener, TKey key, bool includeValue)
{
var listenerAdapter =
EntryListenerAdapter <TKey, TValue> .CreateAdapter(listener, Client.SerializationService);
var keyData = ToData(key);
var request = MultiMapAddEntryListenerToKeyCodec.EncodeRequest(Name, keyData, includeValue, IsSmart());
DistributedEventHandler handler =
eventData => MultiMapAddEntryListenerToKeyCodec.EventHandler.HandleEvent(eventData,
(k, value, oldValue, mergingValue, type, uuid, entries) =>
{
OnEntryEvent(k, value, oldValue, mergingValue, type, uuid, entries, listenerAdapter);
});
return(RegisterListener(request, message => MultiMapAddEntryListenerToKeyCodec.DecodeResponse(message).Response,
id => MultiMapRemoveEntryListenerCodec.EncodeRequest(Name, id), handler));
}
public string AddEntryListener(IEntryListener <TKey, TValue> listener, IPredicate predicate,
TKey key,
bool includeValue)
{
var keyData = ToData(key);
var predicateData = ToData(predicate);
var flags = GetListenerFlags(listener);
var request = MapAddEntryListenerToKeyWithPredicateCodec.EncodeRequest(GetName(), keyData, predicateData,
includeValue, flags, IsSmart());
DistributedEventHandler handler =
eventData => MapAddEntryListenerToKeyWithPredicateCodec.AbstractEventHandler.Handle(eventData,
(k, value, oldValue, mergingValue, type, uuid, entries) =>
{
OnEntryEvent(k, value, oldValue, mergingValue, type, uuid, entries, includeValue, listener);
});
return(RegisterListener(request, message => MapAddEntryListenerCodec.DecodeResponse(message).response,
id => MapRemoveEntryListenerCodec.EncodeRequest(GetName(), id), handler));
}
public string AddEntryListener(IEntryListener <TKey, TValue> listener, IPredicate predicate)
{
var predicateData = ToData(predicate);
var listenerAdapter =
EntryListenerAdapter <TKey, TValue> .CreateAdapter(listener, GetContext().GetSerializationService());
var request =
ReplicatedMapAddEntryListenerWithPredicateCodec.EncodeRequest(GetName(), predicateData, IsSmart());
DistributedEventHandler handler =
eventData => ReplicatedMapAddEntryListenerWithPredicateCodec.EventHandler.HandleEvent(eventData,
(k, value, oldValue, mergingValue, type, uuid, entries) =>
{
OnEntryEvent(k, value, oldValue, mergingValue, type, uuid, entries, listenerAdapter);
});
return(RegisterListener(request,
message => ReplicatedMapAddEntryListenerWithPredicateCodec.DecodeResponse(message).response,
id => ReplicatedMapRemoveEntryListenerCodec.EncodeRequest(GetName(), id), handler));
}
public abstract IFuture<IClientMessage> InvokeListenerOnKeyOwner(IClientMessage request, object key,
DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder);
public abstract IFuture<IClientMessage> InvokeListenerOnTarget(IClientMessage request, Address target,
DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder);
public IFuture<IClientMessage> InvokeListenerOnConnection(IClientMessage request,
DistributedEventHandler handler, DecodeStartListenerResponse responseDecoder, ClientConnection connection)
{
var clientInvocation = new ClientListenerInvocation(request, handler, responseDecoder, connection);
Send(connection, clientInvocation);
return clientInvocation.Future;
}
public override IFuture<IClientMessage> InvokeListenerOnTarget(IClientMessage request, Address target,
DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder)
{
return Invoke(new ClientListenerInvocation(request, handler, responseDecoder, target), target);
}
public abstract IFuture<IClientMessage> InvokeListenerOnPartition(IClientMessage request, int partitionId,
DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder);
public override IFuture<IClientMessage> InvokeListenerOnRandomTarget(IClientMessage request, DistributedEventHandler handler,
DecodeStartListenerResponse responseDecoder)
{
return SendToOwner(new ClientListenerInvocation(request, handler, responseDecoder));
}
