internal override CacheEventDescriptor RegisterCacheNotification(CacheDataNotificationCallback cacheDataNotificationCallback, Runtime.Events.EventType eventType, Runtime.Events.EventDataFilter datafilter)
{
CacheEventDescriptor result = null;
string exceptionMessage = null;
try
{
result = _webCache.RegisterCacheNotification(cacheDataNotificationCallback, eventType, datafilter);
}
catch (Exception e)
{
exceptionMessage = e.Message;
throw;
}
finally
{
try
{
if (_debugConfigurations.IsInLoggingInterval())
{
APILogItem logItem = new APILogItem();
logItem.Signature = "RegisterCacheNotification(string key, CacheDataNotificationCallback selectiveCacheDataNotificationCallback, Runtime.Events.EventType eventType, Runtime.Events.EventDataFilter datafilter)";
logItem.ExceptionMessage = exceptionMessage;
_apiLogger.Log(logItem);
}
}
catch (Exception)
{ }
}
return(result);
}
internal CacheEventDescriptor RegisterGeneralEvents(CacheDataNotificationCallback callback, EventType eventType,
EventDataFilter datafilter)
{
if (callback != null)
{
if (_addEventPool == null)
{
_addEventPool = new ResourcePool();
}
if (_removeEventPool == null)
{
_removeEventPool = new ResourcePool();
}
if (_updateEventPool == null)
{
_updateEventPool = new ResourcePool();
}
CacheEventDescriptor discriptor =
CacheEventDescriptor.CreateCacheDiscriptor(eventType, _cacheName, callback, datafilter);
if (!RegisterGeneralDiscriptor(discriptor, eventType))
{
return(null);
}
return(discriptor);
}
else
{
return(null);
}
}
internal CacheEventArg(string key, string cachename, EventType eventType, EventCacheItem item,
CacheEventDescriptor discriptor, CacheItemRemovedReason reason)
: base(cachename, eventType, item)
{
_reason = reason;
_descriptor = discriptor;
}
//Creation is CacheDesriptor's responsiblity
static internal CacheEventDescriptor CreateCacheDiscriptor(EventType eventType, string cacheName, CacheDataNotificationCallback callback, EventDataFilter datafilter)
{
CacheEventDescriptor descriptor = new CacheEventDescriptor();
descriptor.RegisteredAgainst = eventType;
descriptor.CacheName = cacheName;
descriptor.CacheDataNotificationCallback = callback;
descriptor.IsRegistered = true;
descriptor.DataFilter = datafilter;
return(descriptor);
}
/// <summary>
/// TheadSafe and no locks internally
/// </summary>
/// <param name="key"></param>
/// <param name="eventType">Should contain one type i.e. should not be used as a flag.
/// Every EventType should be executed from another thread</param>
/// <param name="item"></param>
/// <param name="oldItem"></param>
/// <param name="reason"></param>
/// <param name="notifyAsync"></param>
internal void RaiseGeneralCacheNotification(string key, EventType eventType, EventCacheItem item,
EventCacheItem oldItem, CacheItemRemovedReason reason, bool notifyAsync)
{
try
{
object[] registeredDiscriptors = null;
ResourcePool eventPool = GetEventPool(eventType);
if (eventPool != null)
{
registeredDiscriptors = eventPool.GetAllResourceKeys();
}
if (registeredDiscriptors != null && registeredDiscriptors.Length > 0)
{
for (int i = 0; i < registeredDiscriptors.Length; i++)
{
CacheEventDescriptor discriptor = registeredDiscriptors[i] as CacheEventDescriptor;
if (discriptor == null)
{
continue;
}
var arg = CreateCacheEventArgument(discriptor.DataFilter, key, _cacheName, eventType, item, oldItem,
reason);
arg.Descriptor = discriptor;
if (notifyAsync)
{
#if !NETCORE
discriptor.CacheDataNotificationCallback.BeginInvoke(key, arg, asyn, null);
#elif NETCORE
TaskFactory factory = new TaskFactory();
Task task = factory.StartNew(() => discriptor.CacheDataNotificationCallback(key, arg));
#endif
}
else
{
discriptor.CacheDataNotificationCallback.Invoke(key, arg);
}
}
}
}
catch (Exception ex)
{
if (_logger != null && _logger.IsErrorEnabled)
{
_logger.CriticalInfo(ex.ToString());
}
}
}
internal CacheEventArg(string key, string cachename, EventType eventType, EventCacheItem item, CacheEventDescriptor discriptor, EventCacheItem olditem)
: base(cachename, eventType, item, olditem)
{
_descriptor = discriptor;
}
//Creation is CacheDesriptor's responsiblity
internal static CacheEventDescriptor CreateCacheDiscriptor(EventType eventType, string cacheName, CacheDataNotificationCallback callback, EventDataFilter datafilter)
{
CacheEventDescriptor descriptor = new CacheEventDescriptor();
descriptor.RegisteredAgainst = eventType;
descriptor.CacheName = cacheName;
descriptor.CacheDataNotificationCallback = callback;
descriptor.IsRegistered = true;
descriptor.DataFilter = datafilter;
return descriptor;
}
internal CacheEventArg(string key, string cachename, EventType eventType, EventCacheItem item, CacheEventDescriptor discriptor, CacheItemRemovedReason reason)
: base(cachename, eventType, item)
{
_reason = reason;
_descriptor = discriptor;
}
internal CacheEventArg(string key, string cachename, EventType eventType, EventCacheItem item, CacheEventDescriptor discriptor, EventCacheItem olditem)
: base(cachename, eventType, item, olditem)
{
_descriptor = discriptor;
}
internal EventHandle UnregisterDiscriptor(CacheEventDescriptor discriptor)
{
if (discriptor == null || !discriptor.IsRegistered)
{
return(null);
}
foreach (EventType type in Enum.GetValues(typeof(EventType)))
{
ResourcePool pool = null;
#region Pool selection
if ((type & discriptor.RegisteredAgainst) != 0)
{
pool = GetEventPool(type);
}
if (pool == null)
{
continue;
}
#endregion
short registrationSequenceId = -1;
bool unregisterNotification = false;
EventDataFilter maxDataFilter = EventDataFilter.None;
lock (SyncLockGeneral)
{
object retVal = pool.RemoveResource(discriptor);
if (retVal == null)
{
continue;
}
unregisterNotification = pool.Count == 0;
if (!unregisterNotification)
{
object[] pooledDescriptors = pool.GetAllResourceKeys();
if (pooledDescriptors != null)
{
for (int i = 0; i < pooledDescriptors.Length; i++)
{
CacheEventDescriptor pooledDescriptor = pooledDescriptors[i] as CacheEventDescriptor;
if (pooledDescriptor.DataFilter > maxDataFilter)
{
maxDataFilter = pooledDescriptor.DataFilter;
}
if (maxDataFilter == EventDataFilter.DataWithMetadata)
{
break;
}
}
}
}
discriptor.IsRegistered = false;
//keeps a sequence number
switch (type)
{
case EventType.ItemAdded:
//Data filter is being updated
if (maxDataFilter != _generalAddDataFilter)
{
_generalAddDataFilter = maxDataFilter;
registrationSequenceId = ++_addEventRegistrationSequence;
}
if (unregisterNotification)
{
_generalAddDataFilter = EventDataFilter.None;
}
break;
case EventType.ItemRemoved:
if (maxDataFilter != _generalRemoveDataFilter)
{
_generalRemoveDataFilter = maxDataFilter;
registrationSequenceId = ++_removeEventRegistrationSequenceId;
}
if (unregisterNotification)
{
_generalAddDataFilter = EventDataFilter.None;
}
break;
case EventType.ItemUpdated:
if (maxDataFilter != _generalUpdateDataFilter)
{
_generalUpdateDataFilter = maxDataFilter;
registrationSequenceId = ++_updateEventRegisrationSequenceId;
}
if (unregisterNotification)
{
_generalAddDataFilter = EventDataFilter.None;
}
break;
}
}
if (_cache != null)
{
if (unregisterNotification)
{
//client is no more interested in event, therefore unregister it from server
_cache.UnregiserGeneralCacheNotification(type);
}
else if (registrationSequenceId != -1)
{
//only caused update of data filter either upgrade or downgrade
_cache.RegisterCacheNotificationDataFilter(type, maxDataFilter, registrationSequenceId);
}
}
}
return(null);
}
private bool RegisterGeneralDiscriptor(CacheEventDescriptor discriptor, EventType eventType)
{
if (discriptor == null)
{
return(false); //FAIL CONDITION
}
EventHandle handle = null;
foreach (EventType type in Enum.GetValues(typeof(EventType)))
{
ResourcePool pool = null;
bool registrationUpdated = false;
#region Pool selection
if ((type & eventType) != 0)
{
pool = GetEventPool(type);
}
if (pool == null)
{
continue;
}
#endregion
short registrationSequenceId = -1;
lock (SyncLockGeneral)
{
pool.AddResource(discriptor, 1); // Everytime a new Discriptor is forcefully created
//Keeps a sequence number
switch (type)
{
case EventType.ItemAdded:
if (discriptor.DataFilter > _generalAddDataFilter ||
_addEventRegistrationSequence == REFSTART)
{
registrationUpdated = true;
registrationSequenceId = ++_addEventRegistrationSequence;
_generalAddDataFilter = discriptor.DataFilter;
}
else
{
registrationSequenceId = _addEventRegistrationSequence;
}
break;
case EventType.ItemRemoved:
if (discriptor.DataFilter > _generalRemoveDataFilter ||
_removeEventRegistrationSequenceId == REFSTART)
{
registrationUpdated = true;
registrationSequenceId = ++_removeEventRegistrationSequenceId;
_generalRemoveDataFilter = discriptor.DataFilter;
}
else
{
registrationSequenceId = _removeEventRegistrationSequenceId;
}
break;
case EventType.ItemUpdated:
if (discriptor.DataFilter > _generalUpdateDataFilter ||
_updateEventRegisrationSequenceId == REFSTART)
{
registrationUpdated = true;
registrationSequenceId = ++_updateEventRegisrationSequenceId;
_generalUpdateDataFilter = discriptor.DataFilter;
}
else
{
registrationSequenceId = _updateEventRegisrationSequenceId;
}
break;
}
//Although the handle doesnt matter in general events
if (handle == null)
{
handle = new EventHandle(registrationSequenceId);
}
}
if (_cache != null && registrationSequenceId != -1)
{
_cache.RegisterCacheNotificationDataFilter(type, discriptor.DataFilter, registrationSequenceId);
}
}
discriptor.IsRegistered = true;
discriptor.Handle = handle;
return(true);
}
