public IEnumerable <Task <Possible <StrongFingerprint, Failure> > > EnumerateStrongFingerprints(WeakFingerprintHash weak, UrgencyHint urgencyHint, Guid activityId)
{
using (var eventing = new EnumerateStrongFingerprintsActivity(CompositingCache.EventSource, activityId, this))
{
eventing.Start(weak, urgencyHint);
var ret = m_metadataSession.EnumerateStrongFingerprints(weak, urgencyHint, eventing.Id);
eventing.Stop();
return(ret);
}
}
public IEnumerable <Task <Possible <StrongFingerprint, Failure> > > EnumerateStrongFingerprints(WeakFingerprintHash weak, UrgencyHint urgencyHint, Guid activityId)
{
var callback = EnumerateStrongFingerprintsCallback;
if (callback != null)
{
return(callback(weak, urgencyHint, activityId, m_realSession));
}
else
{
return(m_realSession.EnumerateStrongFingerprints(weak, urgencyHint, activityId));
}
}
public async Task DisconnectedCacheNotQueriedForStrongFingerprints()
{
string testCacheId = "Disconnected";
ICache testCache = await InitializeCacheAsync(NewCache(testCacheId, false)).SuccessAsync();
PoisonAllRemoteSessions(testCache);
ICacheReadOnlySession roSession = await testCache.CreateReadOnlySessionAsync().SuccessAsync();
DisconnectRemoteCache(testCache);
FakeBuild fb = new FakeBuild("test", 1);
foreach (var fingerprint in roSession.EnumerateStrongFingerprints(new WeakFingerprintHash(FingerprintUtilities.Hash("fingerprint").ToByteArray())))
{
// Just run the enumerator, should all return.
}
}
public async Task CacheDataPersistedReadOnlyCache()
{
string testName = "CacheDataPersistedReadOnly";
ICache firstInvocation = await CreateCacheAsync(testName, true);
Guid originalGuid = firstInvocation.CacheGuid;
ICacheSession session = (await firstInvocation.CreateSessionAsync("sessionName")).Success();
FullCacheRecord cacheRecord = await FakeBuild.DoPipAsync(session, "PipA");
(await session.CloseAsync()).Success();
await ShutdownCacheAsync(firstInvocation, testName);
ICache secondInvocation = await GetExistingCacheAsync(testName, true, true);
XAssert.AreEqual(originalGuid, secondInvocation.CacheGuid, "Persistent caches: GUID should not change");
XAssert.IsTrue(secondInvocation.IsReadOnly, "This should have been a read-only cache");
ICacheReadOnlySession newSession = (await secondInvocation.CreateReadOnlySessionAsync()).Success();
int fingerprintsFound = 0;
foreach (var singleFingerprint in newSession.EnumerateStrongFingerprints(cacheRecord.StrongFingerprint.WeakFingerprint))
{
var sfp = (await singleFingerprint).Success();
XAssert.AreEqual(cacheRecord.StrongFingerprint, sfp, "Fingerprints must match");
fingerprintsFound++;
}
XAssert.AreEqual(1, fingerprintsFound, "A single instance of the fingerprint should have been found after restarting the cache.");
(await newSession.CloseAsync()).Success();
await ShutdownCacheAsync(secondInvocation, testName);
}
/// <summary>
/// Enumerates input weak fingerprints and returns all strong fingerprints
/// </summary>
/// <param name="weakFingerprints">Weak fingerprints to iterate over</param>
/// <param name="readOnlySession">The read only session to use to
/// enumerate strong fingerprints</param>
/// <returns>All strong fingerprints enumerated from input weak fingerprints</returns>
public static IEnumerable <StrongFingerprint> ProduceStrongFingerprints(this IEnumerable <WeakFingerprintHash> weakFingerprints, ICacheReadOnlySession readOnlySession)
{
HashSet <StrongFingerprint> strongFingerprintsAlreadyProduced = new HashSet <StrongFingerprint>();
foreach (WeakFingerprintHash weakFingerprint in weakFingerprints)
{
IEnumerable <Task <Possible <StrongFingerprint, Failure> > > possibleStrongFingerprintTasks = readOnlySession.EnumerateStrongFingerprints(weakFingerprint);
foreach (Task <Possible <StrongFingerprint, Failure> > possibleStrongFingerprintTask in possibleStrongFingerprintTasks.OutOfOrderTasks())
{
Possible <StrongFingerprint, Failure> possibleStrongFingerprint = possibleStrongFingerprintTask.Result;
if (possibleStrongFingerprint.Succeeded && strongFingerprintsAlreadyProduced.Add(possibleStrongFingerprint.Result))
{
yield return(possibleStrongFingerprint.Result);
}
}
}
}
public IEnumerable <Task <Possible <StrongFingerprint, Failure> > > EnumerateStrongFingerprints(WeakFingerprintHash weak, UrgencyHint urgencyHint, Guid activityId)
{
return(m_session.EnumerateStrongFingerprints(weak, urgencyHint, activityId));
}
/// <summary>
/// Checks weak fingerprints for input assertion list anomalies
/// </summary>
/// <param name="weakFingerprints">The weak fingerprints to check</param>
/// <param name="cacheErrors">Any cache errors that are found will be
/// added to this collection</param>
/// <returns>All anomalies found. NOTE Many results will be null, MUST check for nulls in return values</returns>
private IEnumerable <Task <InputAssertionListAnomaly> > CheckWeakFingerprints(IEnumerable <WeakFingerprintHash> weakFingerprints, ConcurrentDictionary <CacheError, int> cacheErrors)
{
foreach (WeakFingerprintHash weakFingerprint in weakFingerprints)
{
yield return(Task.Run(() =>
{
// Enumerate strong fingerprints from weak fingerprint
IEnumerable <Task <Possible <StrongFingerprint, Failure> > > strongFingerprints = m_readOnlySession.EnumerateStrongFingerprints(weakFingerprint);
ConcurrentDictionary <StrongFingerprint, int> strongFingerprintSet = new ConcurrentDictionary <StrongFingerprint, int>();
foreach (Task <Possible <StrongFingerprint, Failure> > possibleStrongFingerprintTask in strongFingerprints.OutOfOrderTasks())
{
Possible <StrongFingerprint, Failure> possibleStrongFingerprint = possibleStrongFingerprintTask.Result;
if (!possibleStrongFingerprint.Succeeded)
{
continue;
}
StrongFingerprint strongFingerprint = possibleStrongFingerprint.Result;
strongFingerprintSet.TryAdd(strongFingerprint, 0);
}
// Check for anomaly
return CheckWeakFingerprintForAnomalyAsync(strongFingerprintSet.Keys, cacheErrors);
}));
}
}
