public async Task Simple_WhenCancelled_Reports_Cancelled_Async()
{
var restoreMan = Mock.Of <IPackageRestoreManager>();
_globalProvider.AddService(typeof(IPackageRestoreManager), restoreMan);
var slnMan = Mock.Of <IVsSolutionManager>();
_globalProvider.AddService(typeof(IVsSolutionManager), slnMan);
ISourceRepositoryProvider sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
_globalProvider.AddService(typeof(ISourceRepositoryProvider), sourceRepositoryProvider);
var restoreChecker = Mock.Of <ISolutionRestoreChecker>();
var eventsPublisher = Mock.Of <IRestoreEventsPublisher>();
var settings = Mock.Of <ISettings>();
var nuGetProgressReporter = Mock.Of <IVsNuGetProgressReporter>();
Mock.Get(settings)
.Setup(x => x.GetSection("packageRestore"))
.Returns(() => new VirtualSettingSection("packageRestore",
new AddItem("automatic", bool.TrueString)));
var consoleProvider = Mock.Of <IOutputConsoleProvider>();
var logger = new RestoreOperationLogger(new Lazy <IOutputConsoleProvider>(() => consoleProvider));
var job = new SolutionRestoreJob(
asyncServiceProvider: AsyncServiceProvider.GlobalProvider,
packageRestoreManager: restoreMan,
solutionManager: slnMan,
sourceRepositoryProvider: sourceRepositoryProvider,
restoreEventsPublisher: eventsPublisher,
settings: settings,
solutionRestoreChecker: restoreChecker,
nuGetProgressReporter: nuGetProgressReporter);
var restoreRequest = new SolutionRestoreRequest(
forceRestore: true,
RestoreOperationSource.OnBuild);
var restoreJobContext = new SolutionRestoreJobContext();
var cts = new CancellationTokenSource();
cts.Cancel();
await job.ExecuteAsync(
request : restoreRequest,
jobContext : restoreJobContext,
logger : logger,
trackingData : new Dictionary <string, object>(),
token : cts.Token);
Assert.Equal(NuGetOperationStatus.Cancelled, job.Status);
}
/// <summary>
/// Restore job entry point. Not re-entrant.
/// </summary>
public async Task <bool> ExecuteAsync(
SolutionRestoreRequest request,
SolutionRestoreJobContext jobContext,
RestoreOperationLogger logger,
CancellationToken token)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (jobContext == null)
{
throw new ArgumentNullException(nameof(jobContext));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
// update instance attributes with the shared context values
_dependencyGraphProjectCacheHash = jobContext.DependencyGraphProjectCacheHash;
_nuGetProjectContext = jobContext.NuGetProjectContext;
using (var ctr1 = token.Register(() => _status = NuGetOperationStatus.Cancelled))
{
try
{
await RestoreAsync(request.ForceRestore, request.RestoreSource, token);
}
catch (OperationCanceledException) when(token.IsCancellationRequested)
{
}
catch (Exception e)
{
// Log the exception to the console and activity log
await _logger.LogExceptionAsync(e);
}
finally
{
// update shared context values with instance attributes
jobContext.DependencyGraphProjectCacheHash = _dependencyGraphProjectCacheHash;
}
}
return(_status == NuGetOperationStatus.NoOp || _status == NuGetOperationStatus.Succeeded);
}
private void Reset(bool isDisposing = false)
{
// Make sure worker restore operation is cancelled
_workerCts?.Cancel();
if (_backgroundJobRunner?.IsValueCreated == true)
{
// Await completion of the background work
_joinableFactory.Run(
async() =>
{
// Do not block VS forever
// After the specified delay the task will disjoin.
await _backgroundJobRunner.GetValueAsync().WithTimeout(TimeSpan.FromSeconds(60));
},
JoinableTaskCreationOptions.LongRunning);
}
_pendingRestore?.Dispose();
_workerCts?.Dispose();
if (_pendingRequests?.IsValueCreated == true)
{
_pendingRequests.Value.Dispose();
}
if (!isDisposing)
{
_solutionLoadedEvent.Reset();
_workerCts = new CancellationTokenSource();
_backgroundJobRunner = new AsyncLazy <bool>(
() => StartBackgroundJobRunnerAsync(_workerCts.Token),
_joinableFactory);
_pendingRequests = new Lazy <BlockingCollection <SolutionRestoreRequest> >(
() => new BlockingCollection <SolutionRestoreRequest>(RequestQueueLimit));
_pendingRestore = new BackgroundRestoreOperation();
_activeRestoreTask = Task.FromResult(true);
_restoreJobContext = new SolutionRestoreJobContext();
}
}
/// <summary>
/// Restore job entry point. Not re-entrant.
/// </summary>
public async Task <bool> ExecuteAsync(
SolutionRestoreRequest request,
SolutionRestoreJobContext jobContext,
RestoreOperationLogger logger,
bool isSolutionLoadRestore,
CancellationToken token)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (jobContext == null)
{
throw new ArgumentNullException(nameof(jobContext));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
// update instance attributes with the shared context values
_nuGetProjectContext = jobContext.NuGetProjectContext;
_nuGetProjectContext.OperationId = request.OperationId;
_isSolutionLoadRestore = isSolutionLoadRestore;
try
{
await RestoreAsync(request.ForceRestore, request.RestoreSource, token);
}
catch (OperationCanceledException)
{
}
catch (Exception e)
{
// Log the exception to the console and activity log
await _logger.LogExceptionAsync(e);
}
return(_status == NuGetOperationStatus.NoOp || _status == NuGetOperationStatus.Succeeded);
}
