public void HandleEvent(Object eventObject, DateTime dispatchTime, long sequenceId)
{
if (!(eventObject is ClearAllCachesEvent))
{
return;
}
CommittedRootCache.Clear();
IRootCache privilegedSecondLevelCache = SecondLevelCacheManager.SelectPrivilegedSecondLevelCache(false);
if (privilegedSecondLevelCache != null && !Object.ReferenceEquals(privilegedSecondLevelCache, CommittedRootCache))
{
privilegedSecondLevelCache.Clear();
}
IRootCache nonPrivilegedSecondLevelCache = SecondLevelCacheManager.SelectNonPrivilegedSecondLevelCache(false);
if (nonPrivilegedSecondLevelCache != null && !Object.ReferenceEquals(nonPrivilegedSecondLevelCache, CommittedRootCache) &&
!Object.ReferenceEquals(nonPrivilegedSecondLevelCache, privilegedSecondLevelCache))
{
nonPrivilegedSecondLevelCache.Clear();
}
IList <IWritableCache> firstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches();
for (int a = firstLevelCaches.Count; a-- > 0;)
{
IWritableCache firstLevelCache = firstLevelCaches[a];
firstLevelCache.Clear();
}
}
protected CacheDependencyNode BuildCacheDependency()
{
IRootCache privilegedSecondLevelCache = SecondLevelCacheManager.SelectPrivilegedSecondLevelCache(true);
IRootCache nonPrivilegedSecondLevelCache = SecondLevelCacheManager.SelectNonPrivilegedSecondLevelCache(false);
IList <IWritableCache> selectedFirstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches();
IdentityHashMap <IRootCache, CacheDependencyNode> secondLevelCacheToNodeMap = new IdentityHashMap <IRootCache, CacheDependencyNode>();
if (privilegedSecondLevelCache != null)
{
CacheDependencyNodeFactory.AddRootCache(privilegedSecondLevelCache.CurrentRootCache, secondLevelCacheToNodeMap);
}
if (nonPrivilegedSecondLevelCache != null)
{
CacheDependencyNodeFactory.AddRootCache(nonPrivilegedSecondLevelCache.CurrentRootCache, secondLevelCacheToNodeMap);
}
for (int a = selectedFirstLevelCaches.Count; a-- > 0;)
{
ChildCache childCache = (ChildCache)selectedFirstLevelCaches[a];
IRootCache parent = ((IRootCache)childCache.Parent).CurrentRootCache;
CacheDependencyNode node = CacheDependencyNodeFactory.AddRootCache(parent, secondLevelCacheToNodeMap);
node.directChildCaches.Add(childCache);
}
return(CacheDependencyNodeFactory.BuildRootNode(secondLevelCacheToNodeMap));
}
protected void WaitEventToResume(IBackgroundWorkerParamDelegate <IProcessResumeItem> resumeDelegate, IBackgroundWorkerParamDelegate <Exception> errorDelegate)
{
IRootCache rootCache = RootCache;
IList <IWritableCache> selectedFirstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches();
ISet <Object> collisionSet = new IdentityHashSet <Object>();
collisionSet.Add(rootCache);
for (int a = selectedFirstLevelCaches.Count; a-- > 0;)
{
collisionSet.Add(selectedFirstLevelCaches[a]);
}
// Without the current rootcache we can not handle the event now. We have to block till the rootCache and all childCaches get valid
EventDispatcher.WaitEventToResume(collisionSet, -1, resumeDelegate, errorDelegate);
}
protected virtual void RevertChangesIntern(IRevertChangesSavepoint savepoint, IList <Object> objectsToRevert, bool globally,
RevertChangesFinishedCallback revertChangesFinishedCallback)
{
// Store the RevertChangesFinishedCallback from this thread on the stack and set the property null (for following calls):
if (objectsToRevert == null || objectsToRevert.Count == 0)
{
if (revertChangesFinishedCallback != null)
{
revertChangesFinishedCallback.Invoke(true);
}
return;
}
if (globally)
{
GuiThreadHelper.InvokeOutOfGui(delegate()
{
bool success = false;
try
{
DataChangeEvent dataChange = new DataChangeEvent();
dataChange.IsLocalSource = true;
dataChange.Inserts = new List <IDataChangeEntry>(0);
dataChange.Updates = new List <IDataChangeEntry>();
dataChange.Deletes = new List <IDataChangeEntry>();
for (int a = objectsToRevert.Count; a-- > 0;)
{
Object objectToRevert = objectsToRevert[a];
IEntityMetaData metaData = ((IEntityMetaDataHolder)objectToRevert).Get__EntityMetaData();
Object id = metaData.IdMember.GetValue(objectToRevert, false);
if (id == null)
{
dataChange.Deletes.Add(new DirectDataChangeEntry(objectToRevert));
continue;
}
dataChange.Updates.Add(new DataChangeEntry(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, id, null));
}
EventDispatcher.DispatchEvent(dataChange, DateTime.Now, -1);
success = true;
}
finally
{
if (revertChangesFinishedCallback != null)
{
revertChangesFinishedCallback.Invoke(success);
}
}
});
}
else
{
// Commented the following part from Ambeth 0.130 and use the part from Ambeth 0.129 due to a deadlock in the merge process:
//GuiThreadHelper.InvokeOutOfGui(delegate()
//{
// bool success1 = false;
// try
// {
// IList<IDataChangeEntry> directObjectDeletes = new List<IDataChangeEntry>();
// IList<Object> initializedObjects = MergeController.ScanForInitializedObjects(objectsToRevert, true, null);
// IList<IObjRef> orisToRevert = new List<IObjRef>();
// ISet<Object> persistedObjectsToRevert = new IdentityHashSet<Object>();
// for (int a = initializedObjects.Count; a-- > 0; )
// {
// Object objectToRevert = initializedObjects[a];
// IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(objectToRevert.GetType());
// Object id = metaData.IdMember.GetValue(objectToRevert, false);
// if (id == null)
// {
// directObjectDeletes.Add(new DirectDataChangeEntry(objectToRevert));
// continue;
// }
// persistedObjectsToRevert.Add(objectToRevert);
// orisToRevert.Add(new ObjRef(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, id, null));
// }
// IList<Object> hardRefsToRootCacheValues = RootCache.GetObjects(orisToRevert, CacheDirective.CacheValueResult | CacheDirective.ReturnMisses);
// for (int a = orisToRevert.Count; a-- > 0; )
// {
// if (hardRefsToRootCacheValues[a] == null)
// {
// // Object could not be loaded/retrieved any more. So the ori refers to an invalid object
// // We can not revert invalid objects and currently ignore them. They will raise exceptions if they will
// // be tried to persist in a merge process any time in the future
// orisToRevert.RemoveAt(a);
// }
// }
// // We do nothing with the hardRef-list from the RootCache. It is only necessary to keep track of the instance reference on the stack
// // To prohibit GC any potential WeakReferences in the meantime....
// GuiThreadHelper.InvokeInGuiAndWait(delegate()
// {
// IProcessResumeItem processResumeItem = WaitEventToResume();
// try
// {
// bool oldCacheModificationValue = CacheModification.IsActive;
// CacheModification.IsActive = true;
// bool oldFailEarlyModeActive = AbstractCache<Object>.FailEarlyModeActive;
// AbstractCache<Object>.FailEarlyModeActive = true;
// try
// {
// IList<IWritableCache> firstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches();
// IList<Object> hardRefsToRootCacheValuesHere = hardRefsToRootCacheValues;
// foreach (IWritableCache firstLevelCache in firstLevelCaches)
// {
// IList<Object> persistedObjectsInThisCache = firstLevelCache.GetObjects(orisToRevert, CacheDirective.FailEarly);
// for (int a = persistedObjectsInThisCache.Count; a-- > 0; )
// {
// Object persistedObjectInThisCache = persistedObjectsInThisCache[a];
// if (!persistedObjectsToRevert.Contains(persistedObjectInThisCache))
// {
// continue;
// }
// RootCache.ApplyValues(persistedObjectInThisCache, (ICacheIntern)firstLevelCache);
// }
// }
// for (int a = objectsToRevert.Count; a-- > 0; )
// {
// Object objectToRevert = objectsToRevert[a];
// if (objectToRevert is IDataObject)
// {
// // Objects which are specified to be reverted loose their delete flag
// ((IDataObject)objectToRevert).ToBeDeleted = false;
// }
// }
// }
// finally
// {
// AbstractCache<Object>.FailEarlyModeActive = oldFailEarlyModeActive;
// CacheModification.IsActive = oldCacheModificationValue;
// }
// }
// finally
// {
// if (processResumeItem != null)
// {
// processResumeItem.ResumeProcessingFinished();
// processResumeItem = null;
// }
// }
// });
// if (directObjectDeletes.Count > 0)
// {
// DataChangeEvent dataChange = DataChangeEvent.Create(0, 0, 0);
// dataChange.Deletes = directObjectDeletes;
// EventDispatcher.DispatchEvent(dataChange, DateTime.Now, -1);
// }
// success1 = true;
// }
// finally
// {
// if (revertChangesFinishedCallback != null)
// {
// revertChangesFinishedCallback.Invoke(success1);
// }
// }
//});
// Here comes the part from Ambeth 0.129:
GuiThreadHelper.InvokeOutOfGui(delegate()
{
bool success1 = false;
bool?success2 = null;
bool?success3 = null;
try
{
IList <IDataChangeEntry> directObjectDeletes = new List <IDataChangeEntry>();
List <IObjRef> objRefs = new List <IObjRef>();
List <ValueHolderRef> valueHolderKeys = new List <ValueHolderRef>();
IList <Object> initializedObjects = MergeController.ScanForInitializedObjects(objectsToRevert, true, null, objRefs, valueHolderKeys);
IList <IObjRef> orisToRevert = new List <IObjRef>();
ISet <Object> persistedObjectsToRevert = new IdentityHashSet <Object>();
for (int a = initializedObjects.Count; a-- > 0;)
{
Object objectToRevert = initializedObjects[a];
IEntityMetaData metaData = ((IEntityMetaDataHolder)objectToRevert).Get__EntityMetaData();
Object id = metaData.IdMember.GetValue(objectToRevert, false);
if (id == null)
{
directObjectDeletes.Add(new DirectDataChangeEntry(objectToRevert));
continue;
}
persistedObjectsToRevert.Add(objectToRevert);
orisToRevert.Add(new ObjRef(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, id, null));
}
IList <Object> hardRefsToRootCacheValues = RootCache.GetObjects(orisToRevert, CacheDirective.CacheValueResult | CacheDirective.ReturnMisses);
for (int a = orisToRevert.Count; a-- > 0;)
{
if (hardRefsToRootCacheValues[a] == null)
{
// Object could not be loaded/retrieved any more. So the ori refers to an invalid object
// We can not revert invalid objects and currently ignore them. They will raise exceptions if they will
// be tried to persist in a merge process any time in the future
orisToRevert.RemoveAt(a);
}
}
// We do nothing with the hardRef-list from the RootCache. It is only necessary to keep track of the instance reference on the stack
// To prohibit GC any potential WeakReferences in the meantime....
success2 = false;
GuiThreadHelper.InvokeInGui(delegate(Object state)
{
WaitEventToResume(delegate(IProcessResumeItem processResumeItem)
{
try
{
bool oldCacheModificationValue = CacheModification.Active;
CacheModification.Active = true;
bool oldFailEarlyModeActive = AbstractCache.FailInCacheHierarchyModeActive;
AbstractCache.FailInCacheHierarchyModeActive = true;
try
{
IList <IWritableCache> firstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches();
IList <Object> hardRefsToRootCacheValuesHere = hardRefsToRootCacheValues;
foreach (IWritableCache firstLevelCache in firstLevelCaches)
{
IList <Object> persistedObjectsInThisCache = firstLevelCache.GetObjects(orisToRevert, CacheDirective.FailEarly);
for (int a = persistedObjectsInThisCache.Count; a-- > 0;)
{
Object persistedObjectInThisCache = persistedObjectsInThisCache[a];
if (!persistedObjectsToRevert.Contains(persistedObjectInThisCache))
{
continue;
}
RootCache.ApplyValues(persistedObjectInThisCache, (ICacheIntern)firstLevelCache, null);
}
}
for (int a = objectsToRevert.Count; a-- > 0;)
{
Object objectToRevert = objectsToRevert[a];
if (objectToRevert is IDataObject)
{
// Objects which are specified to be reverted loose their flags
((IDataObject)objectToRevert).ToBeDeleted = false;
}
}
if (directObjectDeletes.Count == 0)
{
success2 = true;
return;
}
}
finally
{
AbstractCache.FailInCacheHierarchyModeActive = oldFailEarlyModeActive;
CacheModification.Active = oldCacheModificationValue;
}
}
finally
{
if (processResumeItem != null)
{
processResumeItem.ResumeProcessingFinished();
}
}
success3 = false;
GuiThreadHelper.InvokeOutOfGui(delegate()
{
try
{
DataChangeEvent dataChange = DataChangeEvent.Create(0, 0, 0);
dataChange.Deletes = directObjectDeletes;
EventDispatcher.DispatchEvent(dataChange, DateTime.Now, -1);
success3 = true;
}
finally
{
if (revertChangesFinishedCallback != null)
{
revertChangesFinishedCallback.Invoke(success3.Value);
}
}
});
success2 = true;
}, delegate(Exception e)
{
if (revertChangesFinishedCallback != null && success3 == null)
{
revertChangesFinishedCallback.Invoke(success2.Value);
}
});
}, null);
success1 = true;
}
finally
{
if (revertChangesFinishedCallback != null && success2 == null && success3 == null)
{
revertChangesFinishedCallback.Invoke(success1);
}
}
});
}
}
