/// <inheritdoc /> public Task <BoolResult> ShutdownAsync(Context context) { ShutdownStarted = true; return(ShutdownCall <ContentSessionTracer> .RunAsync(_tracer, context, () => { ShutdownCompleted = true; return Task.FromResult(BoolResult.Success); })); }
/// <inheritdoc /> public Task <BoolResult> ShutdownAsync(Context context) { ShutdownStarted = true; return(ShutdownCall <BuildCacheCacheTracer> .RunAsync(_tracer, context, async() => { var statsResult = await GetStatsInternalAsync(context).ConfigureAwait(false); if (statsResult.Succeeded) { context.Debug("BuildCacheCache Stats:"); statsResult.CounterSet.LogOrderedNameValuePairs(s => _tracer.Debug(context, s)); } else { context.Debug($"Getting stats failed: [{statsResult}]"); } var backingContentStoreTask = Task.Run(async() => await _backingContentStore.ShutdownAsync(context).ConfigureAwait(false)); var writeThroughContentStoreResult = _writeThroughContentStore != null ? await _writeThroughContentStore.ShutdownAsync(context) : BoolResult.Success; var backingContentStoreResult = await backingContentStoreTask.ConfigureAwait(false); BoolResult result; if (backingContentStoreResult.Succeeded && writeThroughContentStoreResult.Succeeded) { result = BoolResult.Success; } else { var sb = new StringBuilder(); if (!backingContentStoreResult.Succeeded) { sb.Append($"Backing content store shutdown failed, error=[{backingContentStoreResult}]"); } if (!writeThroughContentStoreResult.Succeeded) { sb.Append($"Write-through content store shutdown failed, error=[{writeThroughContentStoreResult}]"); } result = new BoolResult(sb.ToString()); } ShutdownCompleted = true; return result; })); }
/// <inheritdoc /> public Task <BoolResult> ShutdownAsync(Context context) { ShutdownStarted = true; return(ShutdownCall <CacheTracer> .RunAsync(_tracer, context, async() => { var statsResult = await StatsAsync(context).ConfigureAwait(false); var contentStoreTask = Task.Run(() => ContentStore.ShutdownAsync(context)); var memoizationStoreResult = await MemoizationStore.ShutdownAsync(context).ConfigureAwait(false); var contentStoreResult = await contentStoreTask.ConfigureAwait(false); BoolResult result; if (contentStoreResult.Succeeded && memoizationStoreResult.Succeeded) { result = BoolResult.Success; } else { var sb = new StringBuilder(); if (!contentStoreResult.Succeeded) { sb.AppendFormat($"Content store shutdown failed, error=[{contentStoreResult}]"); } if (!memoizationStoreResult.Succeeded) { sb.Append(sb.Length > 0 ? ", " : string.Empty); sb.AppendFormat($"Memoization store shutdown failed, error=[{memoizationStoreResult}]"); } result = new BoolResult(sb.ToString()); } if (statsResult.Succeeded) { #if !FEATURE_CORECLR LocalCacheStatsEventSource.Instance.Stats(statsResult.CounterSet); #endif statsResult.CounterSet.LogOrderedNameValuePairs(s => _tracer.Debug(context, s)); } ShutdownCompleted = true; return result; })); }
/// <inheritdoc /> public virtual Task <BoolResult> ShutdownAsync(Context context) { ShutdownStarted = true; return(ShutdownCall <TTracer> .RunAsync(Tracer, context, async() => { await PreShutdownAsync(context); Messages.Add(ShutdownMessage.Instance); _backgroundThread?.Join(); DeleteMarkerFile(context); await PostShutdownAsync(context).ThrowIfFailure(); ShutdownCompleted = true; return BoolResult.Success; })); }
/// <inheritdoc /> public Task <BoolResult> ShutdownAsync(Context context) { return(ShutdownCall <ContentSessionTracer> .RunAsync( Tracer, context, async() => { ShutdownStarted = true; var finalResult = BoolResult.Success; foreach (var session in SessionsByCacheRoot.Values) { var result = await session.ShutdownAsync(context).ConfigureAwait(false); if (!result.Succeeded) { finalResult = new BoolResult(finalResult, result.ErrorMessage); } } ShutdownCompleted = true; return finalResult; })); }
/// <inheritdoc /> public Task <BoolResult> ShutdownAsync(Context context) { ShutdownStarted = true; return(ShutdownCall <ContentSessionTracer> .RunAsync(_tracer, context, async() => { var shutdownResults = await Task.WhenAll(_sessionForStream.ShutdownAsync(context), _sessionForPath.ShutdownAsync(context)); Contract.Assert(shutdownResults.Length == 2); var shutdownResultForStream = shutdownResults[0]; var shutdownResultForPath = shutdownResults[1]; var result = shutdownResultForStream & shutdownResultForPath; if (!result.Succeeded) { var sb = new StringBuilder(); if (!shutdownResultForStream.Succeeded) { sb.Concat($"{SessionForStreamText} shutdown failed, error=[{shutdownResultForStream}]", "; "); } if (!shutdownResultForPath.Succeeded) { sb.Concat($"{SessionForPathText} shutdown failed, error=[{shutdownResultForPath}]", "; "); } result = new BoolResult(sb.ToString()); } ShutdownCompleted = true; return result; })); }
/// <inheritdoc /> public Task <BoolResult> ShutdownAsync(Context context) { ShutdownStarted = true; return(ShutdownCall <MemoizationStoreTracer> .RunAsync(_tracer, context, async() => { GetStatsResult stats = GetStatsInternal(); if (!stats) { context.Debug($"Get stats failed with error {stats.ErrorMessage}; Diagnostics {stats.Diagnostics}"); } else { context.Debug("DistributedCache Stats:"); stats.CounterSet.LogOrderedNameValuePairs(s => _tracer.Debug(context, s)); } var innerCacheShutdown = await _innerICache.ShutdownAsync(context); var metadataCacheShutdown = await _metadataCache.ShutdownAsync(context); if (!innerCacheShutdown) { // TODO: should print errors as well. context.Error("Shutdown call on inner cache failed."); return new BoolResult(innerCacheShutdown); } if (!metadataCacheShutdown) { context.Error("Shutdown call on metadata cache failed."); return new BoolResult(metadataCacheShutdown); } ShutdownCompleted = true; return BoolResult.Success; })); }
/// <inheritdoc /> public Task <BoolResult> ShutdownAsync(Context context) { return(ShutdownCall <ContentStoreTracer> .RunAsync(Tracer, context, async() => { ShutdownStarted = true; var finalResult = BoolResult.Success; foreach (var store in _drivesWithContentStore.Values) { if (store.StartupCompleted && !store.ShutdownCompleted) { // Shutdown is available only when the store started up successfully and wasn't shut down yet. var result = await store.ShutdownAsync(context).ConfigureAwait(false); if (!result) { finalResult = new BoolResult(finalResult, result.ErrorMessage); } } } ShutdownCompleted = true; return finalResult; })); }
/// <inheritdoc /> public Task <BoolResult> ShutdownAsync(Context context) { ShutdownStarted = true; return(ShutdownCall <MemoizationStoreTracer> .RunAsync(Tracer.MemoizationStoreTracer, context, async() => { Tracer.Debug(context, "IncorporateOnShutdown start"); Tracer.Debug(context, $"Incorporate fingerprints feature enabled:[{_fingerprintIncorporationEnabled}]"); Tracer.Debug(context, $"Total fingerprints to be incorporated:[{FingerprintTracker.Count}]"); Tracer.Debug(context, $"Max fingerprints per incorporate request(=chunk size):[{_maxFingerprintsPerIncorporateRequest}]"); Tracer.Debug(context, $"Max incorporate requests allowed in parallel:[{_maxDegreeOfParallelismForIncorporateRequests}]"); if (_fingerprintIncorporationEnabled) { // Incorporating all of the fingerprints for a build, in one request, to a single endpoint causes pain. Incorporation involves // extending the lifetime of all fingerprints *and* content/s mapped to each fingerprint. Processing a large request payload // results in, potentially, fanning out a massive number of "lifetime extend" requests to itemstore and blobstore, which can // bring down the endpoint. Break this down into chunks so that multiple, load-balanced endpoints can share the burden. List <StrongFingerprint> fingerprintsToBump = FingerprintTracker.StaleFingerprints.ToList(); Tracer.Debug(context, $"Total fingerprints to be sent in incorporation requeststo the service: {fingerprintsToBump.Count}"); List <List <StrongFingerprintAndExpiration> > chunks = fingerprintsToBump.Select( strongFingerprint => new StrongFingerprintAndExpiration(strongFingerprint, FingerprintTracker.GenerateNewExpiration()) ).GetPages(_maxFingerprintsPerIncorporateRequest).ToList(); Tracer.Debug(context, $"Total fingerprint incorporation requests to be issued(=number of fingerprint chunks):[{chunks.Count}]"); var incorporateBlock = new ActionBlock <IEnumerable <StrongFingerprintAndExpiration> >( async chunk => { await ContentHashListAdapter.IncorporateStrongFingerprints( context, CacheNamespace, new IncorporateStrongFingerprintsRequest(chunk.ToList().AsReadOnly()) ).ConfigureAwait(false); }, new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = _maxDegreeOfParallelismForIncorporateRequests }); foreach (var chunk in chunks) { await incorporateBlock.SendAsync(chunk); } incorporateBlock.Complete(); await incorporateBlock.Completion.ConfigureAwait(false); // TODO: Gracefully handle exceptions so that the rest of shutdown can happen (bug 1365340) Tracer.Debug(context, "IncorporateOnShutdown stop"); } if (_taskTracker != null) { await _taskTracker.Synchronize().ConfigureAwait(false); await _taskTracker.ShutdownAsync(context).ConfigureAwait(false); } var backingContentSessionTask = Task.Run(async() => await BackingContentSession.ShutdownAsync(context).ConfigureAwait(false)); var writeThroughContentSessionResult = WriteThroughContentSession != null ? await WriteThroughContentSession.ShutdownAsync(context).ConfigureAwait(false) : BoolResult.Success; var backingContentSessionResult = await backingContentSessionTask.ConfigureAwait(false); BoolResult result; if (backingContentSessionResult.Succeeded && writeThroughContentSessionResult.Succeeded) { if (_sealingErrorsToPrintOnShutdown.Any()) { var sb = new StringBuilder(); sb.AppendLine("Error(s) during background sealing:"); foreach (var sealingError in _sealingErrorsToPrintOnShutdown) { sb.AppendLine($"[{sealingError}]"); } if (_sealingErrorCount > MaxSealingErrorsToPrintOnShutdown) { sb.AppendLine($"See log for the other {MaxSealingErrorsToPrintOnShutdown - _sealingErrorCount} error(s)."); } result = new BoolResult(sb.ToString()); } else { result = BoolResult.Success; } } else { var sb = new StringBuilder(); if (!backingContentSessionResult.Succeeded) { sb.Append($"Backing content session shutdown failed, error=[{backingContentSessionResult}]"); } if (!writeThroughContentSessionResult.Succeeded) { sb.Append(sb.Length > 0 ? ", " : string.Empty); sb.Append($"Write-through content session shutdown failed, error=[{writeThroughContentSessionResult}]"); } result = new BoolResult(sb.ToString()); } ShutdownCompleted = true; return result; })); }