internal void RemoveCallbackInfo(CallbackInfo updateCallback, CallbackInfo removeCallback)
{
lock (this)
{
if (updateCallback != null || removeCallback != null)
{
CallbackEntry cbEntry = null;
if (Value is CallbackEntry)
{
cbEntry = Value as CallbackEntry;
if (updateCallback != null && updateCallback.CallbackType == CallbackType.PushBasedNotification)
{
cbEntry.RemoveItemUpdateCallback(updateCallback);
}
if (removeCallback != null && removeCallback.CallbackType == CallbackType.PushBasedNotification)
{
cbEntry.RemoveItemRemoveCallback(removeCallback);
}
}
}
//dont use else as currently both pull and push can be confiured simoultaneously
//if pullbased notifications
{
if (updateCallback != null)
{
RemoveItemUpdateCallback(updateCallback);
}
if (removeCallback != null)
{
RemoveItemRemoveCallback(removeCallback);
}
}
}
}
/// <summary>
/// Compares on Callback and DataFilter
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
if (obj is CallbackInfo)
{
CallbackInfo other = obj as CallbackInfo;
if (other.Client != theClient)
{
return(false);
}
if (other.Callback is short && theCallback is short)
{
if ((short)other.Callback == (short)theCallback)
{
return(true);
}
else
{
return(false);
}
}
else if (other.Callback == theCallback)
{
return(true);
}
else
{
return(true);
}
}
return(false);
}
private void RemoveItemUpdateCallback(CallbackInfo cbInfo)
{
if (_itemUpdateListener != null && _itemUpdateListener.Contains(cbInfo))
{
_itemUpdateListener.Remove(cbInfo);
}
}
internal void AddCallbackInfo(CallbackInfo updateCallback, CallbackInfo removeCallback)
{
lock (this)
{
CallbackEntry cbEntry;
if (Value is CallbackEntry)
{
cbEntry = Value as CallbackEntry;
}
else
{
cbEntry = new CallbackEntry();
cbEntry.Value = Value;
cbEntry.Flag = Flag;
Value = cbEntry;
}
if (updateCallback != null)
{
cbEntry.AddItemUpdateCallback(updateCallback);
}
if (removeCallback != null)
{
cbEntry.AddItemRemoveCallback(removeCallback);
}
}
}
public void RemoveItemRemoveCallback(CallbackInfo cbInfo)
{
if (_itemRemovedListener != null && _itemRemovedListener.Contains(cbInfo))
{
_itemRemovedListener.Remove(cbInfo);
}
}
//PROTOBUF
public override void ExecuteCommand(ClientManager clientManager, Alachisoft.NCache.Common.Protobuf.Command command)
{
CommandInfo cmdInfo;
try
{
cmdInfo = ParseCommand(command, clientManager);
}
catch (Exception exc)
{
if (!base.immatureId.Equals("-2"))
{
//PROTOBUF:RESPONSE
_serializedResponsePackets.Add(Alachisoft.NCache.Common.Util.ResponseHelper.SerializeExceptionResponse(exc, command.requestID));
}
return;
}
try
{
CallbackInfo cbUpdate = null;
CallbackInfo cbRemove = null;
if(cmdInfo.dataFilter != -1) //Default value in protbuf set to -1
{
EventDataFilter datafilter = (EventDataFilter)cmdInfo.dataFilter;
cbUpdate = new CallbackInfo(clientManager.ClientID, cmdInfo.UpdateCallbackId, datafilter);
cbRemove = new CallbackInfo(clientManager.ClientID, cmdInfo.RemoveCallbackId, datafilter, cmdInfo.NotifyOnExpiration);
}
else
{
cbUpdate = new CallbackInfo(clientManager.ClientID, cmdInfo.UpdateCallbackId, EventDataFilter.None);
cbRemove = new CallbackInfo(clientManager.ClientID, cmdInfo.RemoveCallbackId,EventDataFilter.DataWithMetadata, cmdInfo.NotifyOnExpiration);
}
NCache nCache = clientManager.CmdExecuter as NCache;
nCache.Cache.RegisterKeyNotificationCallback(cmdInfo.Key, cbUpdate, cbRemove
, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation));
//PROTOBUF:RESPONSE
Alachisoft.NCache.Common.Protobuf.Response response = new Alachisoft.NCache.Common.Protobuf.Response();
Alachisoft.NCache.Common.Protobuf.RegisterKeyNotifResponse registerKeyNotifResponse = new Alachisoft.NCache.Common.Protobuf.RegisterKeyNotifResponse();
response.responseType = Alachisoft.NCache.Common.Protobuf.Response.Type.REGISTER_KEY_NOTIF;
response.registerKeyNotifResponse = registerKeyNotifResponse;
response.requestId = command.registerKeyNotifCommand.requestId;
_serializedResponsePackets.Add(Alachisoft.NCache.Common.Util.ResponseHelper.SerializeResponse(response));
}
catch (Exception exc)
{
//PROTOBUF:RESPONSE
_serializedResponsePackets.Add(Alachisoft.NCache.Common.Util.ResponseHelper.SerializeExceptionResponse(exc, command.requestID));
}
}
/// <summary>
/// Creates a CallBackEntry.
/// </summary>
/// <param name="callerid">Caller id i.e. Clietn application id</param>
/// <param name="value">Actual data</param>
/// <param name="onCacheItemRemovedCallback">OnCacheItemRemovedCallback</param>
/// <param name="onCacheItemUpdateCallback">OnCacheItemUpdateCallback</param>
public Notifications(CallbackInfo onCacheItemRemovedCallback, CallbackInfo onCacheItemUpdateCallback, AsyncCallbackInfo onAsyncOperationCompleteCallback, AsyncCallbackInfo onWriteBehindOperationCompletedCallback)
{
if (onCacheItemRemovedCallback != null)
{
_itemRemovedListener.Add(onCacheItemRemovedCallback);
}
if (onCacheItemUpdateCallback != null)
{
_itemUpdateListener.Add(onCacheItemUpdateCallback);
}
_onAsyncOperationCompleteCallback = onAsyncOperationCompleteCallback;
_onWriteBehindOperationCompletedCallback = onWriteBehindOperationCompletedCallback;
}
/// <summary>
/// Creates a CallBackEntry.
/// </summary>
/// <param name="callerid">Caller id i.e. Client application id</param>
/// <param name="value">Actual data</param>
/// <param name="onCacheItemRemovedCallback">OnCacheItemRemovedCallback</param>
/// <param name="onCacheItemUpdateCallback">OnCacheItemUpdateCallback</param>
public CallbackEntry(object value, CallbackInfo onCacheItemRemovedCallback, CallbackInfo onCacheItemUpdateCallback, AsyncCallbackInfo onAsyncOperationCompleteCallback, AsyncCallbackInfo onWriteBehindOperationCompletedCallback)
{
_value = value;
if (onCacheItemRemovedCallback != null)
{
_itemRemovedListener.Add(onCacheItemRemovedCallback);
}
if (onCacheItemUpdateCallback != null)
{
_itemUpdateListener.Add(onCacheItemUpdateCallback);
}
_onAsyncOperationCompleteCallback = onAsyncOperationCompleteCallback;
_onWriteBehindOperationCompletedCallback = onWriteBehindOperationCompletedCallback;
}
public void AddItemRemoveCallback(CallbackInfo cbInfo)
{
if (_itemRemovedListener != null)
{
int indexOfCallback = _itemRemovedListener.IndexOf(cbInfo);
if (indexOfCallback != -1)
{
//update the data filter only
CallbackInfo oldCallback = _itemRemovedListener[indexOfCallback] as CallbackInfo;
oldCallback.DataFilter = cbInfo.DataFilter;
}
else
{
_itemRemovedListener.Add(cbInfo);
}
}
}
internal void AddCallbackInfo(CallbackInfo updateCallback, CallbackInfo removeCallback)
{
lock (this)
{
CallbackEntry cbEntry;
bool isPullBasedCallback = false;
//pullbasedNotification
if (updateCallback != null && updateCallback.CallbackType == CallbackType.PullBasedCallback)
{
AddItemUpdateCallback(updateCallback);
isPullBasedCallback = true;
}
if (removeCallback != null && removeCallback.CallbackType == CallbackType.PullBasedCallback)
{
AddItemRemoveCallback(removeCallback);
isPullBasedCallback = true;
}
if (!isPullBasedCallback)
{
if (Value is CallbackEntry)
{
cbEntry = Value as CallbackEntry;
}
else
{
cbEntry = new CallbackEntry();
cbEntry.Value = Value;
cbEntry.Flag = Flag;
Value = cbEntry;
}
if (updateCallback != null)
{
cbEntry.AddItemUpdateCallback(updateCallback);
}
if (removeCallback != null)
{
cbEntry.AddItemRemoveCallback(removeCallback);
}
}
}
}
public void AddItemUpdateCallback(CallbackInfo cbInfo, bool keepOldFilter = false)
{
if (_itemUpdateListener != null)
{
int indexOfCallback = _itemUpdateListener.IndexOf(cbInfo);
if (indexOfCallback != -1)
{
//update the data filter only
CallbackInfo oldCallback = _itemUpdateListener[indexOfCallback] as CallbackInfo;
if (!keepOldFilter)
{
oldCallback.DataFilter = cbInfo.DataFilter;
}
}
else
{
_itemUpdateListener.Add(cbInfo);
}
}
}
private void AddItemRemoveCallback(CallbackInfo cbInfo)
{
if (_itemRemovedListener == null)
{
_itemRemovedListener = ArrayList.Synchronized(new ArrayList(2));
}
int indexOfCallback = _itemRemovedListener.IndexOf(cbInfo);
if (indexOfCallback != -1)
{
//update the data filter only
CallbackInfo oldCallback = _itemRemovedListener[indexOfCallback] as CallbackInfo;
oldCallback.DataFilter = cbInfo.DataFilter;
}
else
{
_itemRemovedListener.Add(cbInfo);
}
}
internal void RemoveCallbackInfo(CallbackInfo updateCallback, CallbackInfo removeCallback)
{
lock (this)
{
if (updateCallback != null || removeCallback != null)
{
CallbackEntry cbEntry = null;
if (Value is CallbackEntry)
{
cbEntry = Value as CallbackEntry;
if (updateCallback != null)
{
cbEntry.RemoveItemUpdateCallback(updateCallback);
}
if (removeCallback != null)
{
cbEntry.RemoveItemRemoveCallback(removeCallback);
}
}
}
}
}
public void AddItemRemoveCallback(CallbackInfo cbInfo)
{
if (_itemRemovedListener != null)
{
int indexOfCallback = _itemRemovedListener.IndexOf(cbInfo);
if (indexOfCallback != -1)
{
//update the data filter only
CallbackInfo oldCallback = _itemRemovedListener[indexOfCallback] as CallbackInfo;
oldCallback.DataFilter = cbInfo.DataFilter;
}
else
{
_itemRemovedListener.Add(cbInfo);
}
}
}
public void RemoveItemUpdateCallback(CallbackInfo cbInfo)
{
if (_itemUpdateListener != null && _itemUpdateListener.Contains(cbInfo))
{
_itemUpdateListener.Remove(cbInfo);
}
}
internal void UnregisterKeyNotificationCallback(string[] keys, CallbackInfo updateCallback, CallbackInfo removeCallback, OperationContext operationContext)
{
if (!IsRunning) return;
if (keys == null) throw new ArgumentNullException("keys");
if (keys.Length == 0) throw new ArgumentException("Keys count can not be zero");
if (updateCallback == null && removeCallback == null) throw new ArgumentNullException();
try
{
_context.CacheImpl.UnregisterKeyNotification(keys, updateCallback, removeCallback, operationContext);
}
catch (OperationFailedException inner)
{
if (inner.IsTracable) _context.NCacheLog.Error("Cache.UnregisterKeyNotificationCallback() ", inner.ToString());
throw;
}
catch (Exception inner)
{
_context.NCacheLog.Error("Cache.UnregisterKeyNotificationCallback()", inner.ToString());
throw new OperationFailedException("UnregisterKeyNotification failed. Error : " + inner.Message, inner);
}
}
public void OnCustomUpdateCallback(short callbackId, string key, bool notifyAsync, EventCacheItem item, EventCacheItem oldItem, BitSet flag,EventDataFilter dataFilter)
{
CallbackInfo cbInfo = new CallbackInfo(null, callbackId,dataFilter);
_listener.OnCustomUpdateCallback(key, cbInfo, notifyAsync, item, oldItem, flag);
}
/// <summary>
/// Registers the item update/remove or both callbacks with the specified key.
/// Keys should exist before the registration.
/// </summary>
/// <param name="key"></param>
/// <param name="updateCallback"></param>
/// <param name="removeCallback"></param>
public void RegisterKeyNotificationCallback(string key, CallbackInfo updateCallback, CallbackInfo removeCallback, OperationContext operationContext)
{
if (!IsRunning) return;
if (key == null) throw new ArgumentNullException("key");
if (updateCallback == null && removeCallback == null) throw new ArgumentNullException();
try
{
_context.CacheImpl.RegisterKeyNotification(key, updateCallback, removeCallback, operationContext);
}
catch (OperationFailedException inner)
{
if (inner.IsTracable) _context.NCacheLog.Error("Cache.RegisterKeyNotificationCallback() ", inner.ToString());
throw;
}
catch (Exception inner)
{
_context.NCacheLog.Error("Cache.RegisterKeyNotificationCallback() ", inner.ToString());
throw new OperationFailedException("RegisterKeyNotification failed. Error : " + inner.Message, inner);
}
}
internal void AddCallbackInfo(CallbackInfo updateCallback, CallbackInfo removeCallback)
{
lock (this)
{
CallbackEntry cbEntry;
if (Value is CallbackEntry)
{
cbEntry = Value as CallbackEntry;
}
else
{
cbEntry = new CallbackEntry();
cbEntry.Value = Value;
cbEntry.Flag = Flag;
Value = cbEntry;
}
if (updateCallback != null)
cbEntry.AddItemUpdateCallback(updateCallback);
if (removeCallback != null)
cbEntry.AddItemRemoveCallback(removeCallback);
}
}
internal void RemoveCallbackInfo(CallbackInfo updateCallback, CallbackInfo removeCallback)
{
lock (this)
{
if (updateCallback != null || removeCallback != null)
{
CallbackEntry cbEntry = null;
if (Value is CallbackEntry)
{
cbEntry = Value as CallbackEntry;
if (updateCallback != null)
cbEntry.RemoveItemUpdateCallback(updateCallback);
if (removeCallback != null)
cbEntry.RemoveItemRemoveCallback(removeCallback);
}
}
}
}
public override void UnregisterKeyNotification(string[] keys, CallbackInfo updateCallback, CallbackInfo removeCallback, OperationContext operationContext)
{
Internal.UnregisterKeyNotification(keys, updateCallback, removeCallback, operationContext);
}
