public static async Task <PutResult> PutRandomAsync( this IContentSession session, Context context, HashType hashType, bool provideHash, long size, CancellationToken ct) { Contract.RequiresNotNull(session); Contract.RequiresNotNull(context); var c = context.CreateNested(); // TODO: Fix this to work with size > int.Max (bug 1365340) var data = ThreadSafeRandom.GetBytes((int)size); using (var stream = new MemoryStream(data)) { if (!provideHash) { return(await session.PutStreamAsync(c, hashType, stream, ct).ConfigureAwait(false)); } var hash = HashInfoLookup.Find(hashType).CreateContentHasher().GetContentHash(data); return(await session.PutStreamAsync(c, hash, stream, ct).ConfigureAwait(false)); } }
/// <inheritdoc /> public Task <PutResult> PutStreamAsync( Context context, HashType hashType, Stream stream, CancellationToken cts, UrgencyHint urgencyHint = UrgencyHint.Nominal) { return(_sessionForStream.PutStreamAsync(context, hashType, stream, cts, urgencyHint)); }
public async Task PutStreamSucceedsWithNonSeekableStream() { using (var testDirectory = new DisposableDirectory(FileSystem)) { var rootPath = testDirectory.Path; var config = CreateStoreConfiguration(); config.Write(FileSystem, rootPath); using (var store = CreateStore(testDirectory, config)) { try { var r = await store.StartupAsync(_context); r.ShouldBeSuccess(); IContentSession session1 = null; try { var createSessionResult1 = store.CreateSession(_context, "session1", ImplicitPin.None); createSessionResult1.ShouldBeSuccess(); using (createSessionResult1.Session) { var r1 = await createSessionResult1.Session.StartupAsync(_context); r1.ShouldBeSuccess(); session1 = createSessionResult1.Session; using (var memoryStream = new RestrictedMemoryStream(ThreadSafeRandom.GetBytes(RandomContentByteCount))) { var result = await session1.PutStreamAsync(_context, ContentHashType, memoryStream, Token); result.ShouldBeSuccess(); result.ContentSize.Should().Be(RandomContentByteCount); } } } finally { if (session1 != null) { await session1.ShutdownAsync(_context).ShouldBeSuccess(); } } } finally { var r = await store.ShutdownAsync(_context); r.ShouldBeSuccess(); } } } }
private async Task UploadContent( Context context, ContentHash contentHash, IContentSession fromSession, IContentSession toSession) { var openStreamResult = await fromSession.OpenStreamAsync(context, contentHash, Token).ConfigureAwait(false); openStreamResult.Succeeded.Should().BeTrue(); var putResult = await toSession.PutStreamAsync(context, contentHash, openStreamResult.Stream, Token).ConfigureAwait(false); putResult.Succeeded.Should().BeTrue(); }
private Task <PutResult> EnsureLocalAsync(OperationContext context, ContentHash hash) { return(context.PerformOperationAsync( Tracer, async() => { var streamResult = await BackingSession.OpenStreamAsync(context, hash, context.Token).ThrowIfFailure(); return await WritableLocalSession.PutStreamAsync(context, hash, streamResult.Stream, context.Token); })); }
private async Task PutStreamAsync( IContentSession session, IReadOnlyCollection <Stream> streams, List <PutResult> results) { var tasks = streams.Select(s => Task.Run(async() => await session.PutStreamAsync(_context, ContentHashType, s, CancellationToken.None))); foreach (var task in tasks.ToList()) { var result = await task; results.Add(result); } }
public static async Task <PutResult> PutContentAsync( this IContentSession session, Context context, string content) { var c = context.CreateNested(); var data = Encoding.UTF8.GetBytes(content); var hashType = HashType.SHA256; using (var stream = new MemoryStream(data)) { var hash = HashInfoLookup.Find(hashType).CreateContentHasher().GetContentHash(data); return(await session.PutStreamAsync(c, hash, stream, CancellationToken.None).ConfigureAwait(false)); } }
/// <inheritdoc /> public Task <PlaceFileResult> PlaceFileAsync( Context context, ContentHash contentHash, AbsolutePath path, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, CancellationToken cts, UrgencyHint urgencyHint = UrgencyHint.Nominal) { IContentSession hardlinkSession = null; if (realizationMode == FileRealizationMode.HardLink) { var drive = path.GetPathRoot(); if (SessionsByCacheRoot.TryGetValue(drive, out var session) && session is IContentSession writeableSession) { hardlinkSession = writeableSession; } else { return(Task.FromResult(new PlaceFileResult("Requested hardlink but there is no session on the same drive as destination path."))); } } return(PerformAggregateSessionOperationAsync <IReadOnlyContentSession, PlaceFileResult>( context, executeAsync: placeFileCore, (r1, r2) => r1.Succeeded ? r1 : r2, shouldBreak: r => r.Succeeded, pathHint: path)); async Task <PlaceFileResult> placeFileCore(IReadOnlyContentSession session) { // If we exclusively want a hardlink, we should make sure that we can copy from other drives to satisfy the request. if (realizationMode != FileRealizationMode.HardLink || session == hardlinkSession) { return(await session.PlaceFileAsync(context, contentHash, path, accessMode, replacementMode, realizationMode, cts, urgencyHint)); } // See if session has the content. var streamResult = await session.OpenStreamAsync(context, contentHash, cts, urgencyHint).ThrowIfFailure(); // Put it into correct store var putResult = await hardlinkSession.PutStreamAsync(context, contentHash, streamResult.Stream, cts, urgencyHint).ThrowIfFailure(); // Try the hardlink on the correct drive. return(await hardlinkSession.PlaceFileAsync(context, contentHash, path, accessMode, replacementMode, realizationMode, cts, urgencyHint)); } }
/// <inheritdoc /> public async Task <ObjectResult <ContentHashListWithCacheMetadata> > AddContentHashListAsync( Context context, string cacheNamespace, StrongFingerprint strongFingerprint, ContentHashListWithCacheMetadata valueToAdd) { try { Func <System.IO.Stream, System.Threading.CancellationToken, Task <StructResult <ContentHash> > > putStreamFunc = async(stream, cts) => { PutResult putResult = await _blobContentSession.PutStreamAsync(context, HashType.Vso0, stream, cts); if (putResult.Succeeded) { return(new StructResult <ContentHash>(putResult.ContentHash)); } return(new StructResult <ContentHash>(putResult)); }; StructResult <ContentHash> blobIdOfContentHashListResult = await BlobContentHashListExtensions.PackInBlob( putStreamFunc, valueToAdd.ContentHashListWithDeterminism); if (!blobIdOfContentHashListResult.Succeeded) { return(new ObjectResult <ContentHashListWithCacheMetadata>(blobIdOfContentHashListResult)); } var blobContentHashListWithDeterminism = new BlobContentHashListWithDeterminism( valueToAdd.ContentHashListWithDeterminism.Determinism.EffectiveGuid, BlobIdentifierToContentHashExtensions.ToBlobIdentifier(blobIdOfContentHashListResult.Data)); var blobContentHashListWithCacheMetadata = new BlobContentHashListWithCacheMetadata( blobContentHashListWithDeterminism, valueToAdd.GetRawExpirationTimeUtc(), valueToAdd.ContentGuarantee, valueToAdd.HashOfExistingContentHashList); BlobContentHashListResponse addResult = await ArtifactHttpClientErrorDetectionStrategy.ExecuteWithTimeoutAsync( context, "AddContentHashList", innerCts => _buildCacheHttpClient.AddContentHashListAsync( cacheNamespace, strongFingerprint, blobContentHashListWithCacheMetadata), CancellationToken.None).ConfigureAwait(false); DownloadUriCache.Instance.BulkAddDownloadUris(addResult.BlobDownloadUris); // add succeeded but returned an empty contenthashlistwith cache metadata. correct this. if (addResult.ContentHashListWithCacheMetadata == null) { return (new ObjectResult <ContentHashListWithCacheMetadata>( new ContentHashListWithCacheMetadata( new ContentHashListWithDeterminism(null, blobContentHashListWithCacheMetadata.Determinism), blobContentHashListWithCacheMetadata.GetRawExpirationTimeUtc(), blobContentHashListWithCacheMetadata.ContentGuarantee))); } else { return(await UnpackBlobContentHashListAsync(context, addResult.ContentHashListWithCacheMetadata)); } } catch (Exception ex) { return(new ObjectResult <ContentHashListWithCacheMetadata>(ex)); } }
/// <inheritdoc /> protected override Task <PutResult> PutStreamCoreAsync(OperationContext operationContext, ContentHash contentHash, Stream stream, UrgencyHint urgencyHint, Counter retryCounter) { return(_innerSession.PutStreamAsync(operationContext, contentHash, stream, operationContext.Token, urgencyHint)); }