/// <summary>
/// Constructor
/// </summary>
/// <param name="listener"></param>
/// <param name="data"></param>
public AsyncCQUpdateCallback(ICacheEventsListener listener, object key, QueryChangeType changeType, List <CQCallbackInfo> queries, OperationContext operationContext, EventContext eventContext)
{
_listener = listener;
_key = key;
_changeType = changeType;
_queries = queries;
_operationContext = operationContext;
_eventContext = eventContext;
}
internal CQCallbackTask(string queryId, string key, QueryChangeType changeType, string clientId, EventContext eventContext, EventDataFilter datafilter)
{
_queryId = queryId;
_key = key;
_changeType = changeType;
_clientID = clientId;
_eventContext = eventContext;
_datafilter = datafilter;
}
public EventDataFilter GetDataFilter(string serverUID, string clientID, QueryChangeType type)
{
HashVector clientDF = null;
EventDataFilter datafilter = EventDataFilter.None;
if (type == QueryChangeType.Add)
{
if (maxAddDFAgainstCID.ContainsKey(serverUID))
{
clientDF = maxAddDFAgainstCID[serverUID] as HashVector;
if (clientDF.ContainsKey(clientID))
{
datafilter = (EventDataFilter)clientDF[clientID];
}
return(datafilter);
}
else
{
return(EventDataFilter.None);
}
}
else if (type == QueryChangeType.Update)
{
if (maxUpdateDFAgainstCID.ContainsKey(serverUID))
{
clientDF = maxUpdateDFAgainstCID[serverUID] as HashVector;
if (clientDF.ContainsKey(clientID))
{
datafilter = (EventDataFilter)clientDF[clientID];
}
return(datafilter);
}
else
{
return(EventDataFilter.None);
}
}
else
{
if (maxRemoveDFAgainstCID.ContainsKey(serverUID))
{
clientDF = maxRemoveDFAgainstCID[serverUID] as HashVector;
if (clientDF.ContainsKey(clientID))
{
datafilter = (EventDataFilter)clientDF[clientID];
}
return(datafilter);
}
else
{
return(EventDataFilter.None);
}
}
}
public void Deserialize(Runtime.Serialization.IO.CompactReader reader)
{
_eventCounter = reader.ReadInt32();
_eventUniqueId = (string)reader.ReadObject();
_operationCounter = reader.ReadInt64();
_eventType = (EventType)reader.ReadInt32();
_queryChangeType = (Queries.QueryChangeType)reader.ReadInt32();
_queryId = (string)reader.ReadObject();
}
public CQCallBackTask(Broker parent, string key, string queryId, QueryChangeType changeType, bool notifyAsync,
EventCacheItem item, EventCacheItem oldItem, BitSet flag, EventDataFilter datafilter)
{
this._key = key;
this._parent = parent;
this._notifyAsync = notifyAsync;
this._queryId = queryId;
this._changeType = changeType;
this._item = item;
this._oldItem = oldItem;
this._flag = flag;
this._datafilter = datafilter;
}
public void OnActiveQueryChanged(string queryId, QueryChangeType changeType, string key, bool notifyAsync,
EventCacheItem item, EventCacheItem oldItem, BitSet flag, EventDataFilter datafilter)
{
try
{
if (_listener != null)
{
_listener.OnActiveQueryChanged(queryId, changeType, key, notifyAsync, item, oldItem, flag,
datafilter);
}
}
catch
{
}
}
public virtual void OnActiveQueryChanged(string queryId, QueryChangeType changeType, string key,
bool notifyAsync, EventCacheItem item, EventCacheItem oldItem, BitSet flag, EventDataFilter datafilter)
{
if (item != null && item.Value != null)
{
item.Value = GetObject(item.Value, flag);
}
if (oldItem != null && oldItem.Value != null)
{
oldItem.Value = GetObject(oldItem.Value, flag);
}
ContinuousQueryManager.Notify(queryId, changeType, key, notifyAsync, item, oldItem, flag,
this._parent.CacheImpl.Name, datafilter);
if (_parent._perfStatsCollector != null)
{
_parent._perfStatsCollector.IncrementEventsProcessedPerSec();
}
}
public static void Notify(string queryId, QueryChangeType changeType, string key, bool notifyAsync,
EventCacheItem item, EventCacheItem oldItem, BitSet flag, string cacheName, EventDataFilter datafilter)
{
ContinuousQuery[] registeredQueries = null;
lock (sync)
{
if (queries.Count == 0)
{
return;
}
registeredQueries = new ContinuousQuery[queries.Count];
queries.CopyTo(registeredQueries);
}
foreach (ContinuousQuery query in registeredQueries)
{
try
{
if (query.ServerUniqueID.Equals(queryId))
{
if (changeType == QueryChangeType.Add)
{
query.FireCQEvents(key, Runtime.Events.EventType.ItemAdded, item, oldItem, notifyAsync,
cacheName, flag, datafilter);
}
else if (changeType == QueryChangeType.Remove)
{
query.FireCQEvents(key, Runtime.Events.EventType.ItemRemoved, item, oldItem, notifyAsync,
cacheName, flag, datafilter);
}
else
{
query.FireCQEvents(key, Runtime.Events.EventType.ItemUpdated, item, oldItem, notifyAsync,
cacheName, flag, datafilter);
}
}
}
catch (Exception e)
{
}
}
}
public bool AllowNotification(string queryId, string clientId, QueryChangeType changeType)
{
lock (this)
{
if (changeType == QueryChangeType.Add)
{
if (addNotifications.ContainsKey(queryId))
{
HashVector clients = (HashVector)addNotifications[queryId];
if (clients != null && clients.ContainsKey(clientId))
{
return(true);
}
}
}
else if (changeType == QueryChangeType.Update)
{
if (updateNotifications.ContainsKey(queryId))
{
HashVector clients = updateNotifications[queryId] as HashVector;
if (clients != null && clients.ContainsKey(clientId))
{
return(true);
}
}
}
else
{
if (removeNotifications.ContainsKey(queryId))
{
HashVector clients = removeNotifications[queryId] as HashVector;
if (clients != null && clients.ContainsKey(clientId))
{
return(true);
}
}
}
return(false);
}
}
public void OnActiveQueryChanged(object key, QueryChangeType changeType, System.Collections.Generic.List <CQCallbackInfo> activeQueries, OperationContext operationContext, EventContext eventContext)
{
}
internal static CQCallbackResponse GetCQCallbackResponse(EventContext eventContext, string key, string queryId, QueryChangeType changeType, EventDataFilter datafilter)
{
Alachisoft.NCache.Common.Protobuf.CQCallbackResponse CQCallbackResponse = new Alachisoft.NCache.Common.Protobuf.CQCallbackResponse();
CQCallbackResponse.key = key;
CQCallbackResponse.queryId = queryId;
CQCallbackResponse.changeType = Convert.ToInt32(changeType);
CQCallbackResponse.eventId = new Common.Protobuf.EventId();
if (eventContext != null)
{
CQCallbackResponse.eventId.eventUniqueId = eventContext.EventID.EventUniqueID;
CQCallbackResponse.eventId.operationCounter = eventContext.EventID.OperationCounter;
CQCallbackResponse.eventId.eventCounter = eventContext.EventID.EventCounter;
CQCallbackResponse.eventId.item = ConvertToEventItem(eventContext.Item, datafilter);
CQCallbackResponse.eventId.oldItem = ConvertToEventItem(eventContext.OldItem, datafilter);
CQCallbackResponse.datafilter = (int)datafilter;
}
return(CQCallbackResponse);
}
