public CacheSyncDependency(string cacheId, string key, ISyncCache cache)
{
_key = key;
_cacheId = cacheId;
_cache = cache;
}
/// <summary>
/// Remove os itens de dependencia.
/// </summary>
/// <param name="cacheId">Identificador do cache.</param>
/// <param name="unregisterCallbacks">True para remove o registro dos callbacks.</param>
/// <param name="removeFromCache">True para remover do cache.</param>
public void RemoveDependentItems(string cacheId, bool unregisterCallbacks, bool removeFromCache)
{
object[] array = null;
lock (_dependenciesStatus.SyncRoot)
{
if (!unregisterCallbacks)
{
ISyncCache cache = _synCaches[cacheId.ToLower()] as ISyncCache;
if (cache != null)
{
cache.Dispose();
_synCaches.Remove(cacheId.ToLower());
}
}
if (removeFromCache && (_dependenciesStatus.Count > 0))
{
array = new object[_dependenciesStatus.Keys.Count];
_dependenciesStatus.Keys.CopyTo(array, 0);
}
}
if (array != null)
{
foreach (SyncItem item in array)
{
if (item.CacheId == cacheId.ToLower())
{
this.RemoveSyncItem(item, unregisterCallbacks);
}
}
}
}
public void AddBulkDependencies(ArrayList keys, IList <CacheSyncDependency> dependencies)
{
Hashtable dependencyList = new Hashtable();
ISyncCache syncCache = null;
SyncEventListener listener = null;
for (int i = 0; i < keys.Count; i++)
{
string key = keys[i] as string;
CacheSyncDependency dependency = dependencies[i];
if (_context.IsDbSyncCoordinator)
{
syncCache = dependency.SyncCache;
listener = null;
if (dependency != null && dependency.CacheId != null)
{
lock (_dependenciesStatus.SyncRoot)
{
if (AddDependencyInternal(key, dependency))
{
List <string> dependencyKeyList = dependencyList[dependency.CacheId] as List <string>;
if (dependencyKeyList == null)
{
dependencyKeyList = new List <string>(keys.Count);
dependencyList.Add(dependency.CacheId, dependencyKeyList);
}
dependencyKeyList.Add(dependency.Key);
}
}
}
}
else
{
SyncItem syncItem = new SyncItem(key, dependency.Key, dependency.CacheId);
lock (_inactiveDependencies.SyncRoot)
{
if (!_inactiveDependencies.Contains(syncItem))
{
_inactiveDependencies.Add(syncItem, dependency);
}
}
}
}
IDictionaryEnumerator ide = dependencyList.GetEnumerator();
while (ide.MoveNext())
{
listener = _listeners[ide.Key] as SyncEventListener;
syncCache = _synCaches[ide.Key] as ISyncCache;
List <string> depdencyKeyList = ide.Value as List <string>;
if (syncCache != null && listener != null)
{
syncCache.RegisterBulkSyncKeyNotifications(depdencyKeyList.ToArray(), listener, CallbackType.PushBasedNotification);
}
}
}
public void RemoveDependency(object key, CacheSyncDependency dependency)
{
if (_context.IsDbSyncCoordinator)
{
if (dependency == null)
{
return;
}
try
{
SyncItem item = new SyncItem(key, dependency.Key, dependency.CacheId);
lock (_dependenciesStatus.SyncRoot)
{
if (_dependenciesKeyMap.Contains(item))
{
ClusteredArrayList dependentKeys = _dependenciesKeyMap[item] as ClusteredArrayList;
if (dependentKeys != null)
{
dependentKeys.Remove(key);
if (dependentKeys.Count > 0)
{
return;
}
}
_dependenciesKeyMap.Remove(item);
}
if (_dependenciesStatus.Contains(item))
{
_dependenciesStatus.Remove(item);
}
else
{
return;
}
}
ISyncCache syncCache = _synCaches[item.CacheId] as ISyncCache;
ISyncCacheEventsListener listener = _listeners[item.CacheId] as ISyncCacheEventsListener;
if (syncCache != null && listener != null)
{
syncCache.UnRegisterSyncKeyNotifications((string)item.Key, listener);
}
}
catch (Exception e)
{
NCacheLog.Error("CacheSyncManager:", e.ToString());
}
}
else
{
lock (_inactiveDependencies.SyncRoot)
{
_inactiveDependencies.Remove(key);
}
}
}
/// <summary>
/// Remove a dependencia.
/// </summary>
/// <param name="key">Chave.</param>
/// <param name="dependency">Instancia da dependencia.</param>
public void RemoveDependency(object key, CacheSyncDependency dependency)
{
if (_context.IsDbSyncCoordinator)
{
if (dependency != null)
{
try
{
SyncItem item = new SyncItem(key, dependency.Key, dependency.CacheId);
lock (_dependenciesStatus.SyncRoot)
{
if (_dependenciesKeyMap.Contains(item))
{
ArrayList list = _dependenciesKeyMap[item] as ArrayList;
if (list != null)
{
list.Remove(key);
if (list.Count > 0)
{
return;
}
}
_dependenciesKeyMap.Remove(item);
}
if (_dependenciesStatus.Contains(item))
{
_dependenciesStatus.Remove(item);
}
else
{
return;
}
}
ISyncCache cache = _synCaches[item.CacheId] as ISyncCache;
ISyncCacheEventsListener eventListener = _listeners[item.CacheId] as ISyncCacheEventsListener;
if ((cache != null) && (eventListener != null))
{
cache.UnRegisterSyncKeyNotifications((string)item.Key, eventListener);
}
}
catch (Exception exception)
{
this.Logger.Error(("CacheSyncManager:" + exception.ToString()).GetFormatter());
}
}
}
else
{
_inactiveDependencies.Remove(key);
}
}
/// <summary>
/// Recupera o instancia associado com o item de sincronização.
/// </summary>
/// <param name="item">Item de sincronização associado.</param>
/// <param name="version">Versão do item recuperado.</param>
/// <param name="flag"></param>
/// <returns></returns>
private object GetItemFromSyncCache(SyncItem item, ref ulong version, ref BitSet flag)
{
if (item != null)
{
ISyncCache cache = _synCaches[item.CacheId] as ISyncCache;
if (cache != null)
{
try
{
return(cache.Get((string)item.Key, ref version, ref flag));
}
catch (Exception exception)
{
this.Logger.Error(("CacheSyncManager:" + exception.ToString()).GetFormatter());
}
}
}
return(null);
}
private void RemoveSyncItem(SyncItem item, bool unregisterCallbacks)
{
if (_cache != null)
{
try
{
ClusteredArrayList dependentKeys = null;
lock (_dependenciesStatus.SyncRoot)
{
_dependenciesStatus.Remove(item);
if (_dependenciesKeyMap.Contains(item))
{
dependentKeys = _dependenciesKeyMap[item] as ClusteredArrayList;
}
_dependenciesKeyMap.Remove(item);
}
ISyncCache syncCache = _synCaches[item.CacheId] as ISyncCache;
ISyncCacheEventsListener listener = _listeners[item.CacheId] as ISyncCacheEventsListener;
if (syncCache != null && listener != null && unregisterCallbacks)
{
syncCache.UnRegisterSyncKeyNotifications((string)item.Key, listener);
}
if (dependentKeys != null)
{
foreach (object key in dependentKeys)
{
OperationContext context = new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation);
_cache.Remove(key, context);
}
}
}
catch (Exception e)
{
NCacheLog.Error("CacheSyncManager:", e.ToString());
}
}
}
private object GetItemFromSyncCache(SyncItem item, ref ulong version, ref BitSet flag, ref DateTime absoluteExpiration, ref TimeSpan slidingExpiration, ref long size, ref string group, ref string subGroup, ref Hashtable queryInfo)
{
if (item != null)
{
ISyncCache cache = _synCaches[item.CacheId] as ISyncCache;
if (cache != null)
{
try
{
absoluteExpiration = DateTime.MaxValue.ToUniversalTime();
slidingExpiration = TimeSpan.Zero;
return(cache.Get((string)item.Key, ref version, ref flag, ref absoluteExpiration, ref slidingExpiration, ref size, ref group, ref subGroup, ref queryInfo));
}
catch (Exception e)
{
NCacheLog.Error("CacheSyncManager:", e.ToString());
}
}
}
return(null);
}
/// <summary>
/// Remove um item de sincronização.
/// </summary>
/// <param name="item">Instancia do item.</param>
/// <param name="unregisterCallbacks">True para remover o registro dos callbacks.</param>
private void RemoveSyncItem(SyncItem item, bool unregisterCallbacks)
{
if (_cache != null)
{
try
{
ArrayList list = null;
lock (_dependenciesStatus.SyncRoot)
{
_dependenciesStatus.Remove(item);
if (_dependenciesKeyMap.Contains(item))
{
list = _dependenciesKeyMap[item] as ArrayList;
}
_dependenciesKeyMap.Remove(item);
}
ISyncCache cache = _synCaches[item.CacheId] as ISyncCache;
ISyncCacheEventsListener eventListener = _listeners[item.CacheId] as ISyncCacheEventsListener;
if (((cache != null) && (eventListener != null)) && unregisterCallbacks)
{
cache.UnRegisterSyncKeyNotifications((string)item.Key, eventListener);
}
if (list != null)
{
foreach (object obj2 in list)
{
_cache.Remove(obj2, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation));
}
}
}
catch (Exception exception)
{
this.Logger.Error(("CacheSyncManager:" + exception.ToString()).GetFormatter());
}
}
}
/// <summary>
/// Adiciona uma dependencia para o gerenciador.
/// </summary>
/// <param name="key">Chave da entrada.</param>
/// <param name="dependency">Instancia da dependencia.</param>
public void AddDependency(object key, CacheSyncDependency dependency)
{
if (_context.IsDbSyncCoordinator)
{
ISyncCache syncCache = dependency.SyncCache;
SyncEventListener listener = null;
if ((dependency == null) || (dependency.CacheId == null))
{
return;
}
lock (_dependenciesStatus.SyncRoot)
{
SyncItem item = new SyncItem(key, dependency.Key, dependency.CacheId);
ArrayList list = null;
if (!_dependenciesKeyMap.Contains(item))
{
list = new ArrayList();
list.Add(item.ThisKey);
_dependenciesKeyMap.Add(item, list);
}
else
{
list = _dependenciesKeyMap[item] as ArrayList;
if (!list.Contains(item.ThisKey))
{
list.Add(item.ThisKey);
}
}
if (!_dependenciesStatus.Contains(item))
{
_dependenciesStatus.Add(item, DependencyStatus.Unchanged);
}
if (_synCaches.Contains(dependency.CacheId))
{
listener = _listeners[dependency.CacheId] as SyncEventListener;
syncCache = _synCaches[dependency.CacheId] as ISyncCache;
}
else
{
syncCache.Initialize();
_synCaches.Add(dependency.CacheId, syncCache);
if (_listeners.Contains(dependency.CacheId))
{
listener = _listeners[dependency.CacheId] as SyncEventListener;
}
else
{
listener = new SyncEventListener(dependency.CacheId, this);
_listeners.Add(dependency.CacheId, listener);
}
}
if ((list != null) && (list.Count < 2))
{
syncCache.RegisterSyncKeyNotifications((string)item.Key, listener);
}
return;
}
}
SyncItem item2 = new SyncItem(key, dependency.Key, dependency.CacheId);
if (!_inactiveDependencies.Contains(item2))
{
_inactiveDependencies.Add(item2, dependency);
}
}
public void Deserialize(CompactReader reader)
{
_cacheId = reader.ReadObject() as string;
_key = reader.ReadObject() as string;
_cache = reader.ReadObject() as ISyncCache;
}
public void RemoveBulkDependencies(ArrayList keys, IList <CacheSyncDependency> dependencies)
{
string key = null;
CacheSyncDependency dependency = null;
Hashtable dependencyList = new Hashtable();
ISyncCache syncCache = null;
for (int i = 0; i < keys.Count; i++)
{
key = keys[i] as string;
dependency = dependencies[i];
if (_context.IsDbSyncCoordinator)
{
if (dependency == null)
{
return;
}
try
{
if (RemoveCacheSyncDependencyInternal(key, dependency))
{
List <string> dependencyKeyList = dependencyList[dependency.CacheId] as List <string>;
syncCache = _synCaches[dependency.CacheId] as ISyncCache;
if (dependencyKeyList == null)
{
dependencyKeyList = new List <string>(keys.Count);
dependencyList.Add(dependency.CacheId, dependencyKeyList);
}
dependencyKeyList.Add(dependency.Key);
}
}
catch (Exception e)
{
NCacheLog.Error("CacheSyncManager.RemoveBulkDependencies", e.ToString());
}
}
else
{
lock (_inactiveDependencies.SyncRoot)
{
_inactiveDependencies.Remove(key);
}
}
}
if (dependencyList.Count > 0)
{
IDictionaryEnumerator ide = dependencyList.GetEnumerator();
while (ide.MoveNext())
{
try
{
SyncEventListener listener = _listeners[ide.Key] as SyncEventListener;
syncCache = _synCaches[ide.Key] as ISyncCache;
List <string> depdencyKeyList = ide.Value as List <string>;
if (syncCache != null && listener != null)
{
syncCache.UnRegisterBulkSyncKeyNotifications(depdencyKeyList.ToArray(), listener);
}
}
catch (Exception e)
{
NCacheLog.Error("CacheSyncManager.RemoveBulkDependencies", e.ToString());
}
}
}
}
public void AddDependency(object key, CacheSyncDependency dependency)
{
if (_context.IsDbSyncCoordinator)
{
ISyncCache syncCache = dependency.SyncCache;
SyncEventListener listener = null;
if (dependency != null && dependency.CacheId != null)
{
lock (_dependenciesStatus.SyncRoot)
{
SyncItem syncItem = new SyncItem(key, dependency.Key, dependency.CacheId);
ClusteredArrayList dependentKeys = null;
if (!_dependenciesKeyMap.Contains(syncItem))
{
dependentKeys = new ClusteredArrayList();
dependentKeys.Add(syncItem.ThisKey);
_dependenciesKeyMap.Add(syncItem, dependentKeys);
}
else
{
dependentKeys = _dependenciesKeyMap[syncItem] as ClusteredArrayList;
if (!dependentKeys.Contains(syncItem.ThisKey))
{
dependentKeys.Add(syncItem.ThisKey);
}
}
if (!_dependenciesStatus.Contains(syncItem))
{
_dependenciesStatus.Add(syncItem, DependencyStatus.Unchanged);
}
if (_synCaches.Contains(dependency.CacheId))
{
syncCache = _synCaches[dependency.CacheId] as ISyncCache;
listener = _listeners[dependency.CacheId] as SyncEventListener;
}
else
{
//// Only the coordinator or sub-coordinator(inacse of POR) can initialize
//// SyncCache.
syncCache.Initialize();
_synCaches.Add(dependency.CacheId, syncCache);
if (_listeners.Contains(dependency.CacheId))
{
listener = _listeners[dependency.CacheId] as SyncEventListener;
}
else
{
listener = new SyncEventListener(dependency.CacheId, this);
_listeners.Add(dependency.CacheId, listener);
}
}
if (dependentKeys != null && dependentKeys.Count < 2)
{
syncCache.RegisterSyncKeyNotifications((string)syncItem.Key, listener, CallbackType.PushBasedNotification);
}
}
}
}
else
{
SyncItem syncItem = new SyncItem(key, dependency.Key, dependency.CacheId);
lock (_inactiveDependencies.SyncRoot)
{
if (!_inactiveDependencies.Contains(syncItem))
{
_inactiveDependencies.Add(syncItem, dependency);
}
}
}
}
private bool AddDependencyInternal(string key, CacheSyncDependency dependency)
{
SyncEventListener listener = null;
ISyncCache syncCache = dependency.SyncCache;
if (dependency != null && dependency.CacheId != null)
{
lock (_dependenciesStatus.SyncRoot)
{
SyncItem syncItem = new SyncItem(key, dependency.Key, dependency.CacheId);
ClusteredArrayList dependentKeys = null;
if (!_dependenciesKeyMap.Contains(syncItem))
{
dependentKeys = new ClusteredArrayList();
dependentKeys.Add(syncItem.ThisKey);
_dependenciesKeyMap.Add(syncItem, dependentKeys);
}
else
{
dependentKeys = _dependenciesKeyMap[syncItem] as ClusteredArrayList;
if (!dependentKeys.Contains(syncItem.ThisKey))
{
dependentKeys.Add(syncItem.ThisKey);
}
}
if (!_dependenciesStatus.Contains(syncItem))
{
_dependenciesStatus.Add(syncItem, DependencyStatus.Unchanged);
}
if (_synCaches.Contains(dependency.CacheId))
{
syncCache = _synCaches[dependency.CacheId] as ISyncCache;
listener = _listeners[dependency.CacheId] as SyncEventListener;
}
else
{
_synCaches.Add(dependency.CacheId, syncCache);
if (_listeners.Contains(dependency.CacheId))
{
listener = _listeners[dependency.CacheId] as SyncEventListener;
}
else
{
listener = new SyncEventListener(dependency.CacheId, this);
_listeners.Add(dependency.CacheId, listener);
}
}
///This registering for every key needs reviewing
if (dependentKeys != null && dependentKeys.Count < 2)
{
return(true);
}
}
}
return(false);
}
