public Task <Possible <string, Failure>[]> PinToCasAsync(CasEntries hashes, UrgencyHint urgencyHint, Guid activityId) { var callback = PinToCasMultipleAsyncCallback; if (callback != null) { return(callback(hashes, urgencyHint, activityId, m_realSession)); } else { return(m_realSession.PinToCasAsync(hashes, urgencyHint, activityId)); } }
/// <summary> /// Check the fake build via the session given /// </summary> /// <param name="session">Session to use for the check</param> /// <param name="index">The "index" CasHash</param> /// <param name="entries">The CasHash entries that should match the index</param> /// <param name="accessMethod">Method (File or stream) for how files are materialized from the cache</param> /// <returns>An Async Task</returns> public static async Task CheckContentsAsync(ICacheReadOnlySession session, CasHash index, CasEntries entries, CasAccessMethod accessMethod = CasAccessMethod.Stream) { string cacheId = await session.PinToCasAsync(index, CancellationToken.None).SuccessAsync("Cannot pin entry {0} to cache {1}", index.ToString(), session.CacheId); string[] expected = (await GetStreamAsync(index, accessMethod, session)).Success().Stream.AsString().Split(s_splitLines, StringSplitOptions.RemoveEmptyEntries); XAssert.AreEqual(expected.Length, entries.Count, "Counts did not match from cache {0}: {1} != {2}", cacheId, expected.Length, entries.Count); for (int i = 0; i < expected.Length; i++) { string casCacheId = await session.PinToCasAsync(entries[i], CancellationToken.None).SuccessAsync(); string entry = (await GetStreamAsync(entries[i], accessMethod, session)).Success().Stream.AsString(); XAssert.AreEqual(expected[i], entry, "CasEntry {0} mismatch from cache {1}: [{2}] != [{3}]", i, casCacheId, expected[i], entry); } }
public async Task <Possible <string, Failure>[]> PinToCasAsync(CasEntries hashes, UrgencyHint urgencyHint, Guid activityId) { using (var eventing = new PinToCasMultipleActivity(CompositingCache.EventSource, activityId, this)) { eventing.Start(hashes, urgencyHint); var results = await m_casSession.PinToCasAsync(hashes, urgencyHint, eventing.Id); for (int i = 0; i < results.Length; i++) { if (results[i].Succeeded) { PinnedToCas.TryAdd(hashes[i], 0); } } return(eventing.Returns(results)); } }
/// <summary> /// Attempts to pin the specified CasHash. Returns true if the /// pinning succeeds. /// </summary> /// <param name="casHash">CasHash value to attempt to pin</param> private async Task <bool> AttemptToPinAsync(CasHash casHash) { if (casHash.Equals(CasHash.NoItem)) { return(true); } Possible <string, Failure> pinAttempt = await m_readOnlySession.PinToCasAsync(casHash); return(pinAttempt.Succeeded); }
private async Task <long> PinAndGetStreamSize(ICacheReadOnlySession session, CasHash hash) { long result; await session.PinToCasAsync(hash, CancellationToken.None).SuccessAsync(); using (var stream = await session.GetStreamAsync(hash).SuccessAsync()) { result = stream.Length; } return(result); }
internal static async Task <Tuple <CasHash, long> > GetContentSizeAsync(this ICacheReadOnlySession session, CasHash casHash) { var possibleString = await session.PinToCasAsync(casHash); if (!possibleString.Succeeded) { return(new Tuple <CasHash, long>(casHash, (long)ContentError.UnableToPin)); } var possibleStream = await session.GetStreamAsync(casHash); if (!possibleStream.Succeeded) { return(new Tuple <CasHash, long>(casHash, (long)ContentError.UnableToStream)); } long length = possibleStream.Result.Length; possibleStream.Result.Dispose(); return(new Tuple <CasHash, long>(casHash, length)); }
public Task <Possible <string, Failure>[]> PinToCasAsync(CasEntries hashes, UrgencyHint urgencyHint, Guid activityId) { return(m_session.PinToCasAsync(hashes, urgencyHint, activityId)); }
/// <summary> /// Takes a strong fingerprint and returns the deserialized contents of /// the input assertion list file that corresponds to it /// </summary> /// <param name="sfp">The strong fingerprint to get the input assertion /// list file contents for</param> /// <param name="cacheErrors">Any cache errors that are found will be /// added to this collection</param> /// <returns>Deserialized contents of the input assertion list file /// corresponding to the specified strong fingerprint</returns> private async Task <string> GetInputAssertionListFileContentsAsync(StrongFingerprint sfp, ConcurrentDictionary <CacheError, int> cacheErrors) { // Check for the NoItem if (sfp.CasElement.Equals(CasHash.NoItem)) { return(string.Empty); } // Pin the input assertion list file Possible <string, Failure> possibleString = await m_readOnlySession.PinToCasAsync(sfp.CasElement).ConfigureAwait(false); if (!possibleString.Succeeded) { return(string.Empty); } // Get the stream for the input assertion list file Possible <Stream, Failure> possibleStream = await m_readOnlySession.GetStreamAsync(sfp.CasElement).ConfigureAwait(false); if (!possibleStream.Succeeded) { cacheErrors.TryAdd( new CacheError( CacheErrorType.CasHashError, "The input assertion list for SFP " + sfp.ToString() + " was not found in CAS"), 0); return(string.Empty); } // Read the stream contents while hashing return(await Task.Run(() => { using (var hasher = ContentHashingUtilities.HashInfo.CreateContentHasher()) { using (var hashingStream = hasher.CreateReadHashingStream(possibleStream.Result)) { using (var reader = new BuildXLReader(false, hashingStream, false)) { var maybePathSet = ObservedPathSet.TryDeserialize(s_pathTable, reader); // Check if deserialization was successful if (!maybePathSet.Succeeded) { // Deserialization failed cacheErrors.TryAdd( new CacheError( CacheErrorType.CasHashError, "The input assertion list for SFP " + sfp.ToString() + " could not be deserialized"), 0); return string.Empty; } CasHash newCasHash = new CasHash(hashingStream.GetContentHash()); // Check if the hashes match if (!sfp.CasElement.Equals(newCasHash)) { cacheErrors.TryAdd( new CacheError( CacheErrorType.CasHashError, "The input assertion list for SFP " + sfp.ToString() + " has been altered in the CAS"), 0); return string.Empty; } // Deserialization was successful and file was unaltered StringBuilder fileContents = new StringBuilder(); foreach (ObservedPathEntry entry in maybePathSet.Result.Paths) { fileContents.Append(entry.Path.ToString(s_pathTable)).Append(Environment.NewLine); } return fileContents.ToString(); } } } }).ConfigureAwait(false)); }