private void AddInvalidateListener()
{
try
{
IClientMessage request;
DistributedEventHandler handler;
if (_cacheType == ClientNearCacheType.Map)
{
request = MapAddNearCacheEntryListenerCodec.EncodeRequest(_mapName, (int)EntryEventType.Invalidation,
false);
handler = message
=> MapAddNearCacheEntryListenerCodec.AbstractEventHandler.Handle(message, HandleIMapInvalidation, HandleIMapBatchInvalidation);
}
else
{
throw new NotImplementedException("Near cache is not available for this type of data structure");
}
_registrationId = _context.GetListenerService()
.RegisterListener(request, message => MapAddNearCacheEntryListenerCodec.DecodeResponse(message).response,
id => MapRemoveEntryListenerCodec.EncodeRequest(_mapName, id), handler);
}
catch (Exception e)
{
Logger.Severe("-----------------\n Near Cache is not initialized!!! \n-----------------", e);
}
}
public string AddEntryListener(IEntryListener <TKey, TValue> listener, bool includeValue)
{
var listenerFlags = GetListenerFlags(listener);
var request = MapAddEntryListenerCodec.EncodeRequest(GetName(), includeValue, listenerFlags, IsSmart());
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(RegisterListener(request, message => MapAddEntryListenerCodec.DecodeResponse(message).response,
id => MapRemoveEntryListenerCodec.EncodeRequest(GetName(), id), 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));
}
/// <summary>
/// Subscribes to invalidation events.
/// </summary>
private async ValueTask <Guid> SubscribeToInvalidationEventsAsync()
{
var subscription = new ClusterSubscription(
MapAddNearCacheInvalidationListenerCodec.EncodeRequest(Name, (int)MapEventTypes.Invalidated, false),
(message, state) => MapAddNearCacheInvalidationListenerCodec.DecodeResponse(message).Response,
(id, state) => MapRemoveEntryListenerCodec.EncodeRequest(((EventState)state).Name, id),
(message, state) => MapRemoveEntryListenerCodec.DecodeResponse(message).Response,
(message, state) => MapAddNearCacheInvalidationListenerCodec.HandleEventAsync(message, HandleCodecSingleEvent, HandleCodecBatchEvent, null, LoggerFactory),
new EventState {
Name = Name
});
await Cluster.Events.InstallSubscriptionAsync(subscription, CancellationToken.None).CfAwait();
return(subscription.Id);
}
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));
}
private void RegisterInvalidateListener()
{
try
{
var request =
MapAddNearCacheEntryListenerCodec.EncodeRequest(Name, (int)EntryEventType.Invalidation, false);
DistributedEventHandler handler = message =>
MapAddNearCacheEntryListenerCodec.EventHandler.HandleEvent(message,
HandleIMapInvalidationEvent_v1_0, HandleIMapInvalidationEvent_v1_4,
HandleIMapBatchInvalidationEvent_v1_0, HandleIMapBatchInvalidationEvent_v1_4);
RegistrationId = Client.GetListenerService().RegisterListener(request,
message => MapAddNearCacheEntryListenerCodec.DecodeResponse(message).response,
id => MapRemoveEntryListenerCodec.EncodeRequest(Name, id), handler);
}
catch (Exception e)
{
Logger.Severe("-----------------\n Near Cache is not initialized!!! \n-----------------", e);
}
}
public virtual void Destroy()
{
if (registrationId != null)
{
if (cacheType == ClientNearCacheType.Map)
{
context.GetListenerService().StopListening(
s => MapRemoveEntryListenerCodec.EncodeRequest(mapName, s),
m => MapRemoveEntryListenerCodec.DecodeResponse(m).response, registrationId);
}
else if (cacheType == ClientNearCacheType.ReplicatedMap)
{
//TODO REPLICATED MAP
throw new NotImplementedException();
}
else
{
throw new NotImplementedException("Near cache is not available for this type of data structure");
}
}
cache.Clear();
}
public virtual void Destroy()
{
if (_registrationId != null)
{
if (_cacheType == ClientNearCacheType.Map)
{
_context.GetListenerService().DeregisterListener(_registrationId,
s => MapRemoveEntryListenerCodec.EncodeRequest(_mapName, s)
);
}
else if (_cacheType == ClientNearCacheType.ReplicatedMap)
{
//TODO REPLICATED MAP
throw new NotImplementedException();
}
else
{
throw new NotImplementedException("Near cache is not available for this type of data structure");
}
}
Cache.Clear();
}
public bool RemoveEntryListener(string id)
{
return(StopListening(s => MapRemoveEntryListenerCodec.EncodeRequest(GetName(), s),
message => MapRemoveEntryListenerCodec.DecodeResponse(message).response, id));
}
private static ClientMessage CreateUnsubscribeRequest(Guid subscriptionId, object state)
{
var sstate = ToSafeState <MapSubscriptionState>(state);
return(MapRemoveEntryListenerCodec.EncodeRequest(sstate.Name, subscriptionId));
}
public bool RemoveEntryListener(string registrationId)
{
return(DeregisterListener(registrationId, id => MapRemoveEntryListenerCodec.EncodeRequest(GetName(), id)));
}
