Ejemplo n.º 1
0
        /// <inheritdoc />
        public async Task <PlaceFileResult> PlaceFileAsync(
            Context context,
            ContentHash contentHash,
            AbsolutePath path,
            FileAccessMode accessMode,
            FileReplacementMode replacementMode,
            FileRealizationMode realizationMode)
        {
            var sessionContext = await CreateSessionContextAsync(context);

            if (!sessionContext)
            {
                return(new PlaceFileResult(sessionContext));
            }

            return(await PlaceFileAsync(sessionContext.Value, contentHash, path, accessMode, replacementMode, realizationMode));
        }
Ejemplo n.º 2
0
        private static FileState GetFileStateForRealizationMode(FileRealizationMode mode)
        {
            switch (mode)
            {
            case FileRealizationMode.Copy:
                return(FileState.Writeable);

            case FileRealizationMode.HardLink:
                return(FileState.ReadOnly);

            case FileRealizationMode.HardLinkOrCopy:
                return(FileState.ReadOnly);

            default:
                throw Contract.AssertFailure("Unhandled FileRealizationMode");
            }
        }
 /// <inheritdoc />
 protected override Task <PutResult> PutFileCoreAsync(
     OperationContext operationContext,
     HashType hashType,
     AbsolutePath path,
     FileRealizationMode realizationMode,
     UrgencyHint urgencyHint,
     Counter retryCounter)
 {
     return(PerformPutFileGatedOperationAsync(operationContext, () =>
     {
         return PutCoreAsync(
             operationContext,
             (decoratedStreamSession, wrapStream) => decoratedStreamSession.PutFileAsync(operationContext, path, hashType, realizationMode, operationContext.Token, urgencyHint, wrapStream),
             session => session.PutFileAsync(operationContext, hashType, path, realizationMode, operationContext.Token, urgencyHint),
             path: path.Path);
     }));
 }
Ejemplo n.º 4
0
        /// <inheritdoc />
        public async Task <Possible <Unit, Failure> > TryMaterializeAsync(
            FileRealizationMode fileRealizationModes,
            ExpandedAbsolutePath path,
            ContentHash contentHash)
        {
            // TODO: The cache should be able to do this itself, preferably sharing the same code.
            //       When placing content, we may be replacing output that has been hardlinked elsewhere.
            //       Deleting links requires some care and magic, e.g. if a process has the file mapped.
            //       Correspondingly, IArtifactContentCache prescribes that materialization always produces a 'new' file.

            var placeResult = await Helpers.RetryOnFailureAsync(
                async lastAttempt =>
            {
                return(await TryMaterializeCoreAsync(fileRealizationModes, path, contentHash));
            });

            return(placeResult);
        }
 /// <inheritdoc />
 protected override Task <PutResult> PutFileCoreAsync(
     OperationContext operationContext,
     ContentHash contentHash,
     AbsolutePath path,
     FileRealizationMode realizationMode,
     UrgencyHint urgencyHint,
     Counter retryCounter)
 {
     // We are intentionally not gating PutStream operations because we don't expect a high number of them at
     // the same time.
     return(PerformPutFileGatedOperationAsync(operationContext, () =>
     {
         return PutCoreAsync(
             operationContext,
             (decoratedStreamSession, wrapStream) => decoratedStreamSession.PutFileAsync(operationContext, path, contentHash, realizationMode, operationContext.Token, urgencyHint, wrapStream),
             session => session.PutFileAsync(operationContext, contentHash, path, realizationMode, operationContext.Token, urgencyHint));
     }));
 }
Ejemplo n.º 6
0
 /// <inheritdoc />
 Task <PutResult> IContentSession.PutFileAsync(
     Context context,
     ContentHash contentHash,
     AbsolutePath path,
     FileRealizationMode realizationMode,
     CancellationToken token,
     UrgencyHint urgencyHint)
 {
     return(WithOperationContext(
                context,
                token,
                operationContext => operationContext.PerformOperationAsync(
                    Tracer,
                    () => PutFileCoreAsync(operationContext, contentHash, path, realizationMode, urgencyHint, _counters[ContentSessionBaseCounters.PutFileRetries]),
                    extraStartMessage: $"({path},{realizationMode},{contentHash.ToShortString()}) trusted=false",
                    extraEndMessage: _ => "trusted=false",
                    counter: _counters[ContentSessionBaseCounters.PutFile])));
 }
Ejemplo n.º 7
0
        private async Task <PlaceFileResult> PlaceFileAsync(
            Context context,
            ContentHash contentHash,
            AbsolutePath path,
            FileAccessMode accessMode,
            FileReplacementMode replacementMode,
            FileRealizationMode realizationMode,
            int sessionId)
        {
            var startTime = DateTime.UtcNow;
            PlaceFileResponse response = await RunClientActionAndThrowIfFailedAsync(context, async() => await _client.PlaceFileAsync(
                                                                                        new PlaceFileRequest
            {
                Header              = new RequestHeader(context.Id, sessionId),
                HashType            = (int)contentHash.HashType,
                ContentHash         = contentHash.ToByteString(),
                Path                = path.Path,
                FileAccessMode      = (int)accessMode,
                FileRealizationMode = (int)realizationMode,
                FileReplacementMode = (int)replacementMode
            }));

            long ticksWaited = response.Header.ServerReceiptTimeUtcTicks - startTime.Ticks;

            _tracer.TrackClientWaitForServerTicks(ticksWaited);

            // Workaround: Handle the service returning negative result codes in error cases
            PlaceFileResult.ResultCode resultCode = response.Header.Result < 0
                ? PlaceFileResult.ResultCode.Error
                : (PlaceFileResult.ResultCode)response.Header.Result;
            if (!response.Header.Succeeded)
            {
                await ResetOnUnknownSessionAsync(context, response.Header, sessionId);

                var message = string.IsNullOrEmpty(response.Header.ErrorMessage)
                    ? resultCode.ToString()
                    : response.Header.ErrorMessage;
                return(new PlaceFileResult(resultCode, message, response.Header.Diagnostics));
            }
            else
            {
                return(new PlaceFileResult(resultCode, response.ContentSize));
            }
        }
Ejemplo n.º 8
0
        private Task ParallelPutsGets(bool useRandomContent, FileRealizationMode realizationModes)
        {
            var context = new Context(Logger);

            return(TestStore(context, _clock, async store =>
            {
                using (var tempDirectory = new DisposableDirectory(FileSystem))
                {
                    IReadOnlyList <AbsolutePath> pathsToContent = Enumerable.Range(1, ParallelFileCount)
                                                                  .Select(i => tempDirectory.Path / ("tempContent" + i + ".txt")).ToList();

                    using (var hasher = HashInfoLookup.Find(ContentHashType).CreateContentHasher())
                    {
                        IReadOnlyList <ContentHash> contentHashes = pathsToContent.Select(pathToContent =>
                        {
                            var bytes = useRandomContent
                                ? ThreadSafeRandom.GetBytes(ParallelRandomContentBytes)
                                : new byte[0];
                            FileSystem.WriteAllBytes(pathToContent, bytes);
                            return hasher.GetContentHash(bytes);
                        }).ToList();
                        IReadOnlyList <AbsolutePath> outPathsToContent =
                            pathsToContent.Select(pathToContent => tempDirectory.Path / ("out" + pathToContent.FileName))
                            .ToList();

                        var puts = Enumerable.Range(0, pathsToContent.Count).Select(i => Task.Run(async() =>
                                                                                                  await store.PutFileAsync(context, pathsToContent[i], realizationModes, ContentHashType, null)
                                                                                                  ));
                        var gets = Enumerable.Range(0, outPathsToContent.Count).Select(i =>
                                                                                       Task.Run(async() => await store.PlaceFileAsync(
                                                                                                    context,
                                                                                                    contentHashes[i],
                                                                                                    outPathsToContent[i],
                                                                                                    FileAccessMode.ReadOnly,
                                                                                                    FileReplacementMode.FailIfExists,
                                                                                                    realizationModes,
                                                                                                    null)));

                        await TaskUtilities.SafeWhenAll(puts);
                        await TaskUtilities.SafeWhenAll(gets);
                    }
                }
            }));
        }
Ejemplo n.º 9
0
 /// <inheritdoc />
 public Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(
     Context context,
     IReadOnlyList <ContentHashWithPath> hashesWithPaths,
     FileAccessMode accessMode,
     FileReplacementMode replacementMode,
     FileRealizationMode realizationMode,
     CancellationToken token,
     UrgencyHint urgencyHint = UrgencyHint.Nominal)
 {
     return(WithOperationContext(
                context,
                token,
                operationContext => operationContext.PerformNonResultOperationAsync(
                    Tracer,
                    () => PlaceFileCoreAsync(operationContext, hashesWithPaths, accessMode, replacementMode, realizationMode, urgencyHint, _counters[ContentSessionBaseCounters.PlaceFileBulkRetries]),
                    traceOperationStarted: false,
                    traceOperationFinished: false,
                    counter: _counters[ContentSessionBaseCounters.PlaceFileBulk])));
 }
Ejemplo n.º 10
0
        /// <inheritdoc />
        public async Task <PlaceFileResult> PlaceFileAsync(
            Context context,
            ContentHash contentHash,
            AbsolutePath path,
            FileAccessMode accessMode,
            FileReplacementMode replacementMode,
            FileRealizationMode realizationMode)
        {
            StructResult <int> sessionResult = await _sessionState.GetIdAsync();

            if (!sessionResult.Succeeded)
            {
                return(new PlaceFileResult(sessionResult));
            }

            int sessionId = sessionResult.Data;

            return(await PlaceFileAsync(context, contentHash, path, accessMode, replacementMode, realizationMode, sessionId));
        }
Ejemplo n.º 11
0
        /// <inheritdoc />
        public async Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(
            Context context,
            IReadOnlyList <ContentHashWithPath> hashesWithPaths,
            FileAccessMode accessMode,
            FileReplacementMode replacementMode,
            FileRealizationMode realizationMode,
            CancellationToken token,
            UrgencyHint urgencyHint = UrgencyHint.Nominal)
        {
            // TODO: add support for PerformOperation with Task<IEnumerable<Task<Indexed<ResultBase>>>>

            using (var cancellableContext = TrackShutdown(context, token))
            {
                using (_counters[ContentSessionBaseCounters.PlaceFileBulk].Start())
                {
                    return(await PlaceFileCoreAsync(cancellableContext, hashesWithPaths, accessMode, replacementMode, realizationMode, urgencyHint, _counters[ContentSessionBaseCounters.PlaceFileBulkRetries]));
                }
            }
        }
        /// <summary>
        /// This function is only used by Nuget package download which is going to be replaced soon by not using 1-phase cache lookup anymore.
        /// </summary>
        public override Task<Possible<ContentMaterializationResult, Failure>> TryMaterializeContentAsync(
            IArtifactContentCache cache,
            FileRealizationMode fileRealizationModes,
            AbsolutePath path,
            ContentHash contentHash,
            bool trackPath = true,
            bool recordPathInFileContentTable = true)
        {
            var request = new MaterializeFileRequest(
                cache,
                fileRealizationModes,
                path,
                contentHash,
                trackPath,
                recordPathInFileContentTable);
            m_localDiskContentStoreConcurrencyLimiter.Post(request);

            return request.CompletionSource.Task;
        }
Ejemplo n.º 13
0
 private Task <PlaceFileResult> PlaceFileAsync(
     OperationContext operationContext,
     SessionContext context,
     ContentHash contentHash,
     AbsolutePath path,
     FileAccessMode accessMode,
     FileReplacementMode replacementMode,
     FileRealizationMode realizationMode)
 {
     return(PerformOperationAsync(
                context,
                _ => Client.PlaceFileAsync(
                    new PlaceFileRequest
     {
         Header = context.CreateHeader(),
         HashType = (int)contentHash.HashType,
         ContentHash = contentHash.ToByteString(),
         Path = path.Path,
         FileAccessMode = (int)accessMode,
         FileRealizationMode = (int)realizationMode,
         FileReplacementMode = (int)replacementMode
     },
                    options: GetCallOptions(Configuration.PlaceDeadline, operationContext.Token)),
                response =>
     {
         // Workaround: Handle the service returning negative result codes in error cases
         PlaceFileResult.ResultCode resultCode = response.Header.Result < 0
                 ? PlaceFileResult.ResultCode.Error
                 : (PlaceFileResult.ResultCode)response.Header.Result;
         if (!response.Header.Succeeded)
         {
             var message = string.IsNullOrEmpty(response.Header.ErrorMessage)
                     ? resultCode.ToString()
                     : response.Header.ErrorMessage;
             return new PlaceFileResult(resultCode, message, response.Header.Diagnostics);
         }
         else
         {
             return new PlaceFileResult(resultCode, response.ContentSize);
         }
     }));
 }
Ejemplo n.º 14
0
 /// <nodoc />
 public static Task <PlaceFileResult> PlaceFileAsync <TTracer>(
     this TTracer tracer,
     OperationContext context,
     ContentHash contentHash,
     AbsolutePath path,
     FileAccessMode accessMode,
     FileReplacementMode replacementMode,
     FileRealizationMode realizationMode,
     Func <Task <PlaceFileResult> > func) where TTracer : ContentSessionTracer
 {
     return(PlaceFileCall <TTracer> .RunAsync(
                tracer,
                context,
                contentHash,
                path,
                accessMode,
                replacementMode,
                realizationMode,
                func));
 }
Ejemplo n.º 15
0
        public void FileStateToMemoization()
        {
            foreach (FileState fileState in Enum.GetValues(typeof(FileState)))
            {
                FileRealizationMode fileRealizationMode = fileState.ToMemoization();
                switch (fileState)
                {
                case FileState.Writeable:
                    Assert.Equal(FileRealizationMode.CopyNoVerify, fileRealizationMode);
                    break;

                case FileState.ReadOnly:
                    Assert.Equal(FileRealizationMode.Any, fileRealizationMode);
                    break;

                default:
                    throw new NotImplementedException();
                }
            }
        }
Ejemplo n.º 16
0
 /// <inheritdoc />
 public Task <PlaceFileResult> PlaceFileAsync(
     Context context,
     ContentHash contentHash,
     AbsolutePath path,
     FileAccessMode accessMode,
     FileReplacementMode replacementMode,
     FileRealizationMode realizationMode,
     CancellationToken token,
     UrgencyHint urgencyHint = UrgencyHint.Nominal)
 {
     return(WithOperationContext(
                context,
                token,
                operationContext => operationContext.PerformOperationAsync(
                    Tracer,
                    () => PlaceFileCoreAsync(operationContext, contentHash, path, accessMode, replacementMode, realizationMode, urgencyHint, _counters[ContentSessionBaseCounters.PlaceFileRetries]),
                    extraStartMessage: $"({contentHash.ToShortString()},{path},{accessMode},{replacementMode},{realizationMode})",
                    extraEndMessage: (_) => $"input={contentHash.ToShortString()}",
                    counter: _counters[ContentSessionBaseCounters.PlaceFile])));
 }
        public Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(
            Context context,
            IReadOnlyList <ContentHashWithPath> hashesWithPaths,
            FileAccessMode accessMode,
            FileReplacementMode replacementMode,
            FileRealizationMode realizationMode,
            CancellationToken cts,
            UrgencyHint urgencyHint = UrgencyHint.Nominal)
        {
            // NOTE: this goes around the FileSystemContentStore's bulk place, rendering it useless. The reason
            // we do it this way is so that the hardlink logic stays consistent. This means that multiple place
            // operations from the same request may run at a higher rate than estipulated by the store.
            IEnumerable <Task <Indexed <PlaceFileResult> > > materializations = hashesWithPaths.Select(async(hashWithPath, index) =>
            {
                var result = await PlaceFileAsync(context, hashWithPath.Hash, hashWithPath.Path, accessMode, replacementMode, realizationMode, cts, urgencyHint);
                return(new Indexed <PlaceFileResult>(result, index));
            });

            return(Task.FromResult(materializations.ToList().AsEnumerable()));
        }
Ejemplo n.º 18
0
        /// <inheritdoc />
        public async Task <Possible <ContentHash, Failure> > TryStoreAsync(
            FileRealizationMode fileRealizationModes,
            ExpandedAbsolutePath path)
        {
            string expandedPath = GetExpandedPathForCache(path);

            Possible <ICacheSession, Failure> maybeOpen   = m_cache.Get(nameof(TryStoreAsync));
            Possible <CasHash, Failure>       maybeStored = await maybeOpen.ThenAsync(
                async cache =>
            {
                var result = await Helpers.RetryOnFailureAsync(
                    async lastAttempt =>
                {
                    return(await cache.AddToCasAsync(expandedPath, GetFileStateForRealizationMode(fileRealizationModes)));
                });
                return(result);
            });

            return(maybeStored.Then <ContentHash>(c => c.ToContentHash()));
        }
Ejemplo n.º 19
0
        /// <inheritdoc />
        protected override async Task <PutResult> PutFileCoreAsync(
            OperationContext context,
            ContentHash contentHash,
            AbsolutePath path,
            FileRealizationMode realizationMode,
            UrgencyHint urgencyHint,
            Counter retryCounter)
        {
            if (contentHash.HashType != RequiredHashType)
            {
                return(new PutResult(
                           contentHash,
                           $"BuildCache client requires HashType '{RequiredHashType}'. Cannot take HashType '{contentHash.HashType}'."));
            }

            try
            {
                var fileInfo    = new FileInfo(path.Path);
                var contentSize = fileInfo.Length;

                using (var streamToPut = FileStreamUtils.OpenFileStreamForAsync(
                           path.Path, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete))
                {
                    var putResult = await PutLazyStreamAsync(context, contentHash, streamToPut, urgencyHint).ConfigureAwait(false);

                    if (!putResult.Succeeded)
                    {
                        return(new PutResult(
                                   putResult,
                                   contentHash,
                                   $"Failed to add a BlobStore reference to content with hash=[{contentHash}]"));
                    }
                }

                return(new PutResult(contentHash, contentSize));
            }
            catch (Exception e)
            {
                return(new PutResult(e, contentHash));
            }
        }
Ejemplo n.º 20
0
        private Task PutFileRecoversAsync(
            FileRealizationMode fileRealizationMode,
            Func<TestFileSystemContentStoreInternal, DisposableDirectory, Task<byte[]>> corruptFunc)
        {
            var context = new Context(Logger);
            return TestStore(context, Clock, async store =>
            {
                using (var tempDirectory = new DisposableDirectory(FileSystem))
                {
                    var bytes = await corruptFunc(store, tempDirectory);

                    var contentPath2 = tempDirectory.CreateRandomFileName();
                    FileSystem.WriteAllBytes(contentPath2, bytes);
                    await store.PutFileAsync(
                        context, contentPath2, fileRealizationMode, ContentHashType, null).ShouldBeSuccess();
                    FileSystem.GetHardLinkCount(contentPath2)
                        .Should().Be(fileRealizationMode == FileRealizationMode.Copy ? 1 : 2);
                    await store.EnsureHasContent(context, bytes.CalculateHash(ContentHashType), tempDirectory);
                }
            });
        }
        /// <summary>
        /// Gets the expanded path for the cache to use when putting/placing file. This allows
        /// the cache to pick a correct CAS root if CAS roots exist on various drives which
        /// would allow it to use a hardlink rather than copy if the appropriate CAS root is chosen.
        /// </summary>
        public string GetExpandedPathForCache(ExpandedAbsolutePath path, FileRealizationMode mode = default)
        {
            if (m_rootTranslator == null)
            {
                return(path.ExpandedPath);
            }
            else
            {
                var translatedPath = m_rootTranslator.Translate(path.ExpandedPath);
                if (translatedPath[0].ToUpperInvariantFast() == path.ExpandedPath[0].ToUpperInvariantFast() &&
                    translatedPath.Length > path.ExpandedPath.Length)
                {
                    // The path root did not change as a result of path translation and its longer
                    // so , just return the original path since the cache only cares about the root
                    // when deciding a particular CAS to hardlink from to avoid MAX_PATH issues
                    return(path.ExpandedPath);
                }

                return(translatedPath);
            }
        }
Ejemplo n.º 22
0
        private Task PlaceFileRecoversAsync(
            Context context,
            Func <TestFileSystemContentStoreInternal, DisposableDirectory, Task <byte[]> > corruptFunc,
            FileRealizationMode fileRealizationMode)
        {
            return(TestStore(context, _clock, async store =>
            {
                using (var tempDirectory = new DisposableDirectory(FileSystem))
                {
                    var bytes = await corruptFunc(store, tempDirectory);
                    var contentHash = bytes.CalculateHash(ContentHashType);

                    var placePath = tempDirectory.CreateRandomFileName();
                    PlaceFileResult result = null;
                    Func <Task> putFunc =
                        async() =>
                    {
                        result = await store.PlaceFileAsync(
                            context,
                            contentHash,
                            placePath,
                            FileAccessMode.ReadOnly,
                            FileReplacementMode.FailIfExists,
                            FileRealizationMode.HardLink,
                            null);
                    };
                    putFunc.Should().NotThrow();
                    Assert.NotNull(result);
                    result.Code.Should()
                    .Be(fileRealizationMode == FileRealizationMode.Copy
                            ? PlaceFileResult.ResultCode.PlacedWithCopy
                            : PlaceFileResult.ResultCode.PlacedWithHardLink);
                    FileSystem.GetHardLinkCount(placePath)
                    .Should()
                    .Be(fileRealizationMode == FileRealizationMode.Copy ? 1 : 2);
                }
            }));
        }
        /// <inheritdoc />
        public async Task <Possible <ContentHash, Failure> > TryStoreAsync(
            FileRealizationMode fileRealizationModes,
            ExpandedAbsolutePath path,
            StoreArtifactOptions options = default)
        {
            string expandedPath = GetExpandedPathForCache(path);

            Possible <ICacheSession, Failure> maybeOpen   = m_cache.Get(nameof(TryStoreAsync));
            Possible <CasHash, Failure>       maybeStored = await PerformArtifactCacheOperationAsync(
                () => maybeOpen.ThenAsync(
                    async cache =>
            {
                var result = await Helpers.RetryOnFailureAsync(
                    async lastAttempt =>
                {
                    return(await cache.AddToCasAsync(expandedPath, GetFileStateForRealizationMode(fileRealizationModes), urgencyHint: options.IsCacheEntryContent?UrgencyHint.SkipRegisterContent: default));
                });
                return(result);
            }),
                nameof(TryStoreAsync));

            return(maybeStored.Then <ContentHash>(c => c.ToContentHash()));
        }
        /// <inheritdoc />
        public Task <PlaceFileResult> PlaceFileAsync(
            Context context,
            ContentHash contentHash,
            AbsolutePath path,
            FileAccessMode accessMode,
            FileReplacementMode replacementMode,
            FileRealizationMode realizationMode,
            CancellationToken cts,
            UrgencyHint urgencyHint)
        {
            return(PlaceFileCall <ContentSessionTracer> .RunAsync(Tracer.ContentSessionTracer, new OperationContext(context), contentHash, path, accessMode, replacementMode, realizationMode, async() =>
            {
                if (WriteThroughContentSession != null)
                {
                    var result = await WriteThroughContentSession.PlaceFileAsync(context, contentHash, path, accessMode, replacementMode, realizationMode, cts, urgencyHint).ConfigureAwait(false);
                    if (result.Succeeded || result.Code != PlaceFileResult.ResultCode.NotPlacedContentNotFound)
                    {
                        return result;
                    }
                }

                return await BackingContentSession.PlaceFileAsync(context, contentHash, path, accessMode, replacementMode, realizationMode, cts, urgencyHint);
            }));
        }
Ejemplo n.º 25
0
        public override void PutFileStop(Context context, PutResult result, bool trusted, AbsolutePath path, FileRealizationMode mode, Severity successSeverity)
        {
            if (_eventSource.IsEnabled())
            {
                _eventSource.PutFileStop(
                    context.TraceId, result.Succeeded, result.ErrorMessage, result.ContentHash.ToString());
            }

            base.PutFileStop(context, result, trusted, path, mode, successSeverity: DiagnosticLevelSeverity(result.Duration));
        }
Ejemplo n.º 26
0
        public override void PlaceFileStop(Context context, ContentHash contentHash, PlaceFileResult result, AbsolutePath path, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, Severity successSeverity)
        {
            if (_eventSource.IsEnabled())
            {
                _eventSource.PlaceFileStop(context.TraceId, (int)result.Code, result.ErrorMessage);
            }

            base.PlaceFileStop(context, contentHash, result, path, accessMode, replacementMode, realizationMode, successSeverity: DiagnosticLevelSeverity(result.Duration));
        }
Ejemplo n.º 27
0
 /// <inheritdoc />
 protected override Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileCoreAsync(OperationContext operationContext, IReadOnlyList <ContentHashWithPath> hashesWithPaths, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, UrgencyHint urgencyHint, Counter retryCounter)
 {
     throw new NotImplementedException();
 }
        private async Task PutFileAcrossDrivesAsync(
            FileRealizationMode allowedFileRealizationMode,
            bool contentAlreadyCached,
            bool contentShouldBeCached,
            Func <PutResult, bool> checkResult)
        {
            // This only works when we have multiple drives.
            if (FileSystem is not MemoryFileSystem)
            {
                return;
            }

            using (var testDirectory = new DisposableDirectory(FileSystem))
            {
                var context = new Context(Logger);

                try
                {
                    using (var store = Create(testDirectory.Path, Clock))
                    {
                        await store.StartupAsync(context).ShouldBeSuccess();

                        byte[]      bytes       = ThreadSafeRandom.GetBytes(ValueSize);
                        ContentHash contentHash = bytes.CalculateHash(ContentHashType);

                        // Verify content doesn't exist yet in store
                        Assert.False(await store.ContainsAsync(context, contentHash, null));

                        var pathToContentDifferentVolume = new AbsolutePath(PathGeneratorUtilities.GetAbsolutePath("D", "foo.txt"));

                        try
                        {
                            FileSystem.WriteAllBytes(pathToContentDifferentVolume, bytes);
                            if (contentAlreadyCached)
                            {
                                await store.PutFileAsync(
                                    context, pathToContentDifferentVolume, FileRealizationMode.Copy, ContentHashType, null).ShouldBeSuccess();
                            }

                            var result = await store.PutFileAsync(
                                context, pathToContentDifferentVolume, allowedFileRealizationMode, ContentHashType, null);

                            Assert.True(checkResult(result));

                            (await store.ContainsAsync(context, contentHash, null)).Should()
                            .Be(contentShouldBeCached);
                        }
                        finally
                        {
                            FileSystem.DeleteFile(pathToContentDifferentVolume);
                        }

                        await store.ShutdownAsync(context).ShouldBeSuccess();
                    }
                }
                finally
                {
                    FileSystem.DeleteDirectory(testDirectory.Path, DeleteOptions.All);
                }
            }
        }
Ejemplo n.º 29
0
 public Task <Possible <ContentHash, Failure> > TryStoreAsync(FileRealizationMode fileRealizationModes, ExpandedAbsolutePath path)
 {
     return(this.m_cache.TryStoreAsync(fileRealizationModes, path));
 }
Ejemplo n.º 30
0
 public Task <Possible <Unit, Failure> > TryMaterializeAsync(FileRealizationMode fileRealizationModes, ExpandedAbsolutePath path, ContentHash contentHash)
 {
     return(this.m_cache.TryMaterializeAsync(fileRealizationModes, path, contentHash));
 }