2246 references to Token
aspire (65)
Backchannel\AuxiliaryBackchannelMonitor.cs (2)
240using var combined = CancellationTokenSource.CreateLinkedTokenSource(stoppingToken, timeout.Token); 242var command = await executionContext.CommandSelected.Task.WaitAsync(combined.Token).ConfigureAwait(false);
Backchannel\ResourceSnapshotWatcher.cs (1)
25_watchTask = WatchAsync(_cts.Token);
Commands\AppHostLauncher.cs (2)
584var readinessTask = WaitForAppHostReadyAsync(connection, readinessCts.Token); 765probeTask = connection.GetResourceSnapshotsAsync(includeHidden: false, probeCts.Token);
Commands\BaseCommand.cs (1)
289await extensionInteractionService.FlushAsync(flushCancellationTokenSource.Token).ConfigureAwait(false);
Commands\DashboardRunCommand.cs (2)
442using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 446return await readyOrFailed.WaitAsync(linkedCts.Token).ConfigureAwait(false);
Commands\InstallationInfoOutput.cs (2)
37() => DiscoverAllCoreAsync(discovery, wingetFirstRunProbe, logger, timeoutCts.Token), 42return await discoveryTask.WaitAsync(timeoutCts.Token).ConfigureAwait(false);
Commands\LsCommand.cs (1)
200var refreshTask = RefreshStatusLoopAsync(updateStatus, statusCancellation.Token);
Commands\PsCommand.cs (1)
185var followCancellationToken = followCancellationTokenSource.Token;
Commands\RenderCommand.cs (2)
415while (!cts.Token.IsCancellationRequested) 419await Task.Delay(200, cts.Token).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
Commands\RunCommand.cs (5)
368runTask = project.RunAsync(context, runCts.Token); 583catch (OperationCanceledException ex) when (ex.CancellationToken == runCts.Token && cancellationToken.IsCancellationRequested) 791var happyPathTask = RunStartupHappyPathAsync(backchannelCompletionSource, onBackchannelEstablished, logCaptureCancellationSource, pendingRun, startupStartTimestamp, startupTimeout, startupCts.Token); 821catch (OperationCanceledException ex) when (ex.CancellationToken == startupCts.Token && cancellationToken.IsCancellationRequested) 894var pendingLogCapture = CaptureAppHostLogsAsync(_fileLoggerProvider, backchannel, InteractionService, logCaptureCancellationSource.Token);
ConsoleCancellationManager.cs (2)
114_token = _cts.Token; 115_gracefulToken = _gracefulCts.Token;
DotNet\ProcessExecution.cs (2)
348await process.WaitForExitAsync(killDrain.Token).ConfigureAwait(false); 377await signalTask.WaitAsync(drainCts.Token).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
Interaction\ExtensionInteractionService.cs (1)
52_cancellationToken = _cts.Token;
Profiling\ProfileCaptureService.cs (6)
274using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 291using var response = await client.GetAsync(_options.DashboardUrl, linkedCts.Token).ConfigureAwait(false); 310await Task.Delay(pollInterval, _timeProvider, linkedCts.Token).ConfigureAwait(false); 391using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 400lastResult = await GetTracesAsync(linkedCts.Token).ConfigureAwait(false); 436await Task.Delay(_profileDataPollInterval, _timeProvider, linkedCts.Token).ConfigureAwait(false);
Projects\AppHostServerSession.cs (2)
238_runTask = DriveAsync(result.Execution, completion, _stopCts.Token); 313var connectTask = AppHostRpcClient.ConnectAsync(socketPath, _authenticationToken, _environment, _profilingTelemetry, connectCts.Token);
Projects\GuestAppHostProject.cs (3)
495serverStopCts.Token); 553var appHostSystemToken = appHostSystemCts.Token; 1106serverStopCts.Token);
Projects\ProjectLocator.cs (2)
200var discoveryTask = CompleteFindAppHostProjectsStreamAsync(searchDirectory, scope, channel.Writer, onDirectoryEnumerated, discoveryCancellationTokenSource.Token); 317var validationCancellationToken = validationCancellationTokenSource?.Token ?? cancellationToken;
src\Shared\ContainerRuntimeDetector.cs (4)
171await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false); 273await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false); 351output = await process.StandardOutput.ReadToEndAsync(timeoutCts.Token).ConfigureAwait(false); 352await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false);
src\Shared\ParentProcessLivenessMonitor.cs (1)
26_monitorTask = MonitorAsync(parentPid, parentStartedUnix, onParentExited, timeProvider, useRuntimeStartTime, _stopCts.Token);
Telemetry\InternalMicrosoftDetector.cs (6)
230var probeTasks = probes.Select(probe => RunProbeAsync(probe, stageCancellation.Token)).ToList(); 619using var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutSource.Token); 621.Select(candidate => CheckGitHubMembershipCandidateAsync(candidate, linkedSource.Token)) 628var completedTask = await Task.WhenAny(candidateTasks).WaitAsync(linkedSource.Token).ConfigureAwait(false); 777if (!await execution.StartAsync(timeoutCts.Token).ConfigureAwait(false)) 782var exitCode = await execution.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false);
Tui\TerminalViewerApp.cs (2)
208var embeddedTask = _embedded.RunAsync(_embeddedCts.Token); 240await outer.RunAsync(_outerCts.Token).ConfigureAwait(false);
Utils\CliDownloader.cs (2)
199using var response = await s_httpClient.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cts.Token); 203await response.Content.CopyToAsync(fileStream, cts.Token);
Utils\EnvironmentChecker\DcpConnectionChecker.cs (5)
48timeoutCts.Token).ConfigureAwait(false); 50using var kubeconfig = await session.ReadKubeconfigAsync(timeoutCts.Token).ConfigureAwait(false); 63using var response = await client.GetAsync(new Uri(kubeconfig.Server, "/version"), timeoutCts.Token).ConfigureAwait(false); 75await session.StopDcpAsync(client, kubeconfig, timeoutCts.Token).ConfigureAwait(false); 359await _process.WaitForExitAsync(exitCts.Token).ConfigureAwait(false);
Utils\EnvironmentChecker\DeprecatedWorkloadCheck.cs (2)
60output = await process.StandardOutput.ReadToEndAsync(timeoutCts.Token); 61await process.WaitForExitAsync(timeoutCts.Token);
Utils\EnvironmentChecker\EnvironmentChecker.cs (3)
54using var checkTimeoutCts = CancellationTokenSource.CreateLinkedTokenSource(totalTimeoutCts.Token); 64var checkTask = Task.Run(() => check.CheckAsync(checkTimeoutCts.Token), CancellationToken.None); 73var checkResults = await checkTask.WaitAsync(checkTimeoutCts.Token).ConfigureAwait(false);
Utils\ProcessCaptureRunner.cs (3)
78captureTask = captureAsync(process, timeoutCts.Token); 97await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false); 194await process.WaitForExitAsync(cts.Token).ConfigureAwait(false);
aspire-managed (3)
Program.cs (2)
51return await app.RunAsync(shutdownCts.Token).ConfigureAwait(false); 82return await rootCommand.Parse(args).InvokeAsync(cancellationToken: operationCts.Token).ConfigureAwait(false);
src\Shared\ParentProcessLivenessMonitor.cs (1)
26_monitorTask = MonitorAsync(parentPid, parentStartedUnix, onParentExited, timeProvider, useRuntimeStartTime, _stopCts.Token);
Aspire.Acquisition.Tests (2)
Scripts\Common\ScriptHostFixture.cs (1)
75_serverTask = Task.Run(() => ServeAsync(_cts!.Token));
tests\Shared\TemplatesTesting\ToolCommand.cs (1)
91return await ExecuteAsyncInternal(resolvedCommand, fullArgs, cts.Token);
Aspire.Azure.Messaging.WebPubSub.Tests (1)
AspireWebPubSubExtensionsTests.cs (1)
296var healthCheckReport = await healthCheckService.CheckHealthAsync(cts.Token);
Aspire.Azure.Search.Documents.Tests (1)
AspireAzureSearchExtensionsTests.cs (1)
136var healthCheckReport = await healthCheckService.CheckHealthAsync(cts.Token);
Aspire.Cli.Tests (105)
Acquisition\PeerInstallProbeTests.cs (1)
397var probeTask = probe.ProbeAsync(fakePeer.Path, cts.Token);
Agents\AgentEnvironmentApplicatorTests.cs (2)
41await applicator.ApplyAsync(cts.Token).DefaultTimeout(); 43Assert.Equal(cts.Token, receivedToken);
Agents\AspireSkillsInstallerTests.cs (4)
923var installTask = installer.InstallAsync(cancellationTokenSource.Token); 1163throw new OperationCanceledException(cancellationTokenSource.Token); 1169() => installer.InstallAsync(cancellationTokenSource.Token)); 1544cancellationTokenSource.Token));
Agents\TelemetryHookScriptTests.cs (1)
528process.WaitForExitAsync(timeout.Token).GetAwaiter().GetResult();
Backchannel\AppHostAuxiliaryBackchannelTests.cs (1)
39await using var enumerator = backchannel.WatchResourceSnapshotsAsync(includeHidden: true, watchCancellation.Token).GetAsyncEnumerator();
Backchannel\AppHostCliBackchannelTests.cs (1)
77() => backchannel.UploadFileAsync(tempFile, "small.bin", 1, "File", cts.Token));
Backchannel\ExtensionBackchannelTests.cs (1)
128var firstConnectTask = backchannel.ConnectAsync(firstConnectorCts.Token);
Certificates\CertificateServiceTests.cs (2)
318throw new OperationCanceledException(cancellationTokenSource.Token); 328() => certificateService.ExportDevCertificatePem(cancellationTokenSource.Token));
Certificates\UnixCertificateManagerTests.cs (1)
47var trustTask = Task.Run(() => manager.GetTrustLevel(certificate, cancellationTokenSource.Token));
Commands\AgentMcpCommandTests.cs (20)
82await agentMcpCommand.ExecuteCommandAsync(parseResult, cts.Token); 87}, cts.Token); 89var mcpClient = await testTransport.CreateClientAsync(loggerFactory, cts.Token); 102var tools = await ctx.Client.ListToolsAsync(cancellationToken: ctx.Cts.Token).DefaultTimeout(); 175await ctx.Client.CallToolAsync(KnownMcpTools.RefreshTools, cancellationToken: ctx.Cts.Token).DefaultTimeout(); 177var tools = await ctx.Client.ListToolsAsync(cancellationToken: ctx.Cts.Token).DefaultTimeout(); 248await ctx.Client.CallToolAsync(KnownMcpTools.RefreshTools, cancellationToken: ctx.Cts.Token).DefaultTimeout(); 252cancellationToken: ctx.Cts.Token).DefaultTimeout(); 321await ctx.Client.CallToolAsync(KnownMcpTools.RefreshTools, cancellationToken: ctx.Cts.Token).DefaultTimeout(); 323var result = await ctx.Client.CallToolAsync("db1_mcp_list_schemas", cancellationToken: ctx.Cts.Token).DefaultTimeout(); 339cancellationToken: ctx.Cts.Token).DefaultTimeout(); 368cancellationToken: ctx.Cts.Token).DefaultTimeout(); 383var notification = await notificationChannel.Reader.ReadAsync(ctx.Cts.Token).AsTask().DefaultTimeout(); 437var tools = await ctx.Client.ListToolsAsync(cancellationToken: ctx.Cts.Token).DefaultTimeout(); 457await notificationChannel.Reader.ReadAsync(timeoutCts.Token); 514var tools1 = await ctx.Client.ListToolsAsync(cancellationToken: ctx.Cts.Token).DefaultTimeout(); 515var tools2 = await ctx.Client.ListToolsAsync(cancellationToken: ctx.Cts.Token).DefaultTimeout(); 537cancellationToken: ctx.Cts.Token).DefaultTimeout()); 547var tools = await ctx.Client.ListToolsAsync(cancellationToken: ctx.Cts.Token).DefaultTimeout(); 565cancellationToken: ctx.Cts.Token).DefaultTimeout());
Commands\AppHostLauncherTests.cs (4)
730cts.Token).DefaultTimeout(); 733Assert.Equal(cts.Token, observedToken); 784cts.Token); 826cts.Token).DefaultTimeout();
Commands\BaseCommandTests.cs (2)
459var invokeTask = result.InvokeAsync(cancellationToken: cts.Token); 501var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout();
Commands\DashboardRunCommandTests.cs (1)
463var pendingRun = result.InvokeAsync(cancellationToken: cts.Token);
Commands\DescribeCommandTests.cs (1)
410var pendingRun = result.InvokeAsync(cancellationToken: cts.Token);
Commands\LogsCommandTests.cs (1)
963var pendingRun = result.InvokeAsync(cancellationToken: cts.Token);
Commands\LsCommandTests.cs (2)
487var exitCode = await result.InvokeAsync(new InvocationConfiguration(), cancellationTokenSource.Token).DefaultTimeout(); 691var exitCode = await result.InvokeAsync(new InvocationConfiguration(), cancellationTokenSource.Token).DefaultTimeout();
Commands\PsCommandTests.cs (1)
621var exitCode = await result.InvokeAsync(cancellationToken: cancellationTokenSource.Token).DefaultTimeout();
Commands\RunCommandTests.cs (20)
407var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 688var pendingCommand = result.InvokeAsync(cancellationToken: cts.Token); 1582var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout(); 1623return Task.FromCanceled<DashboardUrlsState>(unrelatedCts.Token); 1645var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout(); 2053var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 2125var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 2376var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 2487var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 2593var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 2663var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 2732var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 2925var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout(); 2984var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout(); 3096var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout(); 3155var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout(); 3562var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout(); 3641var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 4099var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 4172var pendingRun = result.InvokeAsync(cancellationToken: cts.Token);
DotNet\ProcessExecutionDetachedTests.cs (1)
168var startTask = detachedExecution.StartAsync(cts.Token);
DotNet\ProcessExecutionTests.cs (4)
173await Assert.ThrowsAsync<OperationCanceledException>(() => execution.WaitForExitAsync(cts.Token)); 201await Assert.ThrowsAsync<OperationCanceledException>(() => execution.WaitForExitAsync(cts.Token)); 232var waitTask = Assert.ThrowsAsync<OperationCanceledException>(() => execution.WaitForExitAsync(cts.Token)); 263await Assert.ThrowsAsync<OperationCanceledException>(() => execution.WaitForExitAsync(cts.Token));
DotNetSdkInstallerTests.cs (1)
65var checkTask = installer.CheckAsync(cancellationTokenSource.Token);
Mcp\Docs\DocsFetcherTests.cs (1)
217await Assert.ThrowsAnyAsync<OperationCanceledException>(() => fetcher.FetchDocsAsync(cts.Token));
Mcp\Docs\DocsIndexServiceTests.cs (1)
830() => service.EnsureIndexedAsync(cts.Token).AsTask());
Mcp\Docs\LlmsTxtParserTests.cs (1)
517async () => await LlmsTxtParser.ParseAsync(content, cts.Token));
Npm\AspireJsLauncherTests.cs (1)
384process.WaitForExitAsync(timeout.Token).GetAwaiter().GetResult();
NuGet\NuGetPackagePrefetcherTests.cs (3)
135await AsyncTestHelpers.WaitForCancellationAsync(stoppingCts.Token); 145await AsyncTestHelpers.WaitForCancellationAsync(stoppingCts.Token); 172await prefetcher.StartAsync(stoppingCts.Token).DefaultTimeout();
Processes\LauncherLivenessMonitorTests.cs (1)
36await using var registration = runCts.Token.Register(() => cancelTcs.TrySetResult());
Projects\AppHostCandidateFinderTests.cs (2)
498finder.FindCandidateFilesAsync(workspace.WorkspaceRoot, ["AppHost.csproj"], nugetCachePath: null, AppHostDiscoveryScope.DefaultFiltered, cancellationTokenSource.Token)); 511finder.FindCandidateFilesAsync(workspace.WorkspaceRoot, ["AppHost.csproj"], nugetCachePath: null, AppHostDiscoveryScope.AllFiles, cancellationTokenSource.Token));
Projects\AppHostInfoResolverTests.cs (1)
157var canceledWaiter = resolver.GetAppHostInfoAsync(projectFile, cancellationTokenSource.Token);
Projects\AppHostServerSessionTests.cs (5)
192stopCts.Token); 239stopCts.Token, 283stopCts.Token, 323stopCts.Token, 355stopCts.Token,
Projects\GuestAppHostProjectTests.cs (1)
1124cancellationSource.Token);
Projects\GuestRuntimeTests.cs (2)
864cancellationToken: cts.Token); 916cts.Token);
Projects\PrebuiltAppHostServerTests.cs (1)
1466cancellationToken: cancellation.Token));
Projects\ProcessGuestLauncherTests.cs (5)
71cts.Token); 129cts.Token); 182cts.Token); 236cts.Token); 296cts.Token);
Projects\RunningInstanceManagerTests.cs (1)
90var serverSocket = await _listener.AcceptAsync(_cts.Token).ConfigureAwait(false);
Telemetry\InternalMicrosoftDetectorTests.cs (3)
542var checkTask = detector.CheckCopilotCliAsync(safetyTimeout.Token); 548await allCandidatesEntered.Task.WaitAsync(safetyTimeout.Token); 555var result = await checkTask.WaitAsync(safetyTimeout.Token);
TestServices\TestGracefulShutdownWindow.cs (1)
25public CancellationToken GracefulShutdownToken => _cts.Token;
Utils\DcpConnectionHealthCheckTests.cs (1)
94() => checker.TestConnectionAsync(dcpDirectory.FullName, useDeveloperCertificate: false, cancellation.Token));
Utils\DevCertsCheckTests.cs (1)
642await Assert.ThrowsAnyAsync<OperationCanceledException>(() => check.CheckAsync(cancellationTokenSource.Token));
Utils\EnvironmentCheckerTests.cs (1)
106() => checker.CheckAllAsync(cancellationTokenSource.Token));
Aspire.Components.Common.TestUtilities (1)
ActivityNotifier.cs (1)
22await foreach (var activity in WaitAsync(cts.Token))
Aspire.Dashboard (71)
Components\Controls\ApplicationName.razor.cs (2)
37using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(_disposalCts.Token); 42await DashboardClient.WhenConnected.WaitAsync(timeoutCts.Token);
Components\Controls\Chart\ChartBase.cs (1)
74CancellationToken = _cts.Token;
Components\Controls\Chart\ChartContainer.razor.cs (3)
86var cancellationToken = _disposeCts.Token; 168var result = await GetInstrumentAsync(useIncrementalCache: false, _disposeCts.Token).ConfigureAwait(false); 221var result = await GetInstrumentAsync(useIncrementalCache: false, _disposeCts.Token).ConfigureAwait(false);
Components\Controls\SpanDetails.razor.cs (1)
214_cts.Token).ConfigureAwait(false);
Components\Dialogs\ExemplarsDialog.razor.cs (1)
47_cts.Token).ConfigureAwait(false);
Components\Dialogs\FilterDialog.razor.cs (2)
119var propertyKeys = await Content.GetPropertyKeysAsync(_disposeCts.Token); 220var fieldValues = await Content.GetFieldValuesAsync(parameterName, _disposeCts.Token);
Components\Dialogs\GenAIVisualizerDialog.razor.cs (1)
264var dialogViewModel = await GenAIVisualizerDialogViewModel.CreateAsync(spanDetailsViewModel, selectedLogEntryId: null, ErrorRecorder, TelemetryRepository, getContextGenAISpans, _cts.Token);
Components\Dialogs\InteractionsInputDialog.razor.cs (1)
243var fileId = await Content.DashboardClient.UploadFileAsync(stream, file.Name, file.Size, Content.Interaction.InteractionId, inputModel.Input.Name, _disposalCts.Token);
Components\Dialogs\ManageDataDialog.razor.cs (3)
158var (snapshot, subscription) = await DataSource.ResourceRepository.SubscribeResourcesAsync(_cts.Token); 173await foreach (var changes in subscription.WithCancellation(_cts.Token).ConfigureAwait(false)) 648using var memoryStream = await TelemetryExportService.ExportSelectedAsync(selectedResources, _cts.Token);
Components\Interactions\InteractionsProvider.cs (13)
57await _semaphore.WaitAsync(_cts.Token).ConfigureAwait(false); 140await waitForInteractionAvailableTask.WaitAsync(_cts.Token).ConfigureAwait(false); 144await _semaphore.WaitAsync(_cts.Token).ConfigureAwait(false); 191await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false); 245await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false); 266await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false); 304await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false); 338await currentDialogReference.Result.WaitAsync(_cts.Token); 340await _semaphore.WaitAsync(_cts.Token).ConfigureAwait(false); 381await DashboardClient.WhenConnected.WaitAsync(_cts.Token).ConfigureAwait(false); 383var interactions = DashboardClient.SubscribeInteractionsAsync(_cts.Token); 386await _semaphore.WaitAsync(_cts.Token).ConfigureAwait(false); 513await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false);
Components\Pages\ConsoleLogs.razor.cs (4)
45public CancellationToken CancellationToken => _cts.Token; 54_cts.Token.Register(static state => 211_resourceSubscriptionToken = _resourceSubscriptionCts.Token; 935_showNoLogsMessageDelayTask = ShowNoLogsMessageAfterDelayAsync(_showNoLogsMessageCts.Token);
Components\Pages\Resources.razor.cs (3)
261var (snapshot, subscription) = await DataSource.ResourceRepository.SubscribeResourcesAsync(_cts.Token); 276await foreach (var changes in subscription.WithCancellation(_cts.Token).ConfigureAwait(false)) 593await Task.Delay(200, _cts.Token);
Components\Pages\StructuredLogs.razor.cs (3)
250await Task.Delay(200, _cts.Token); 538_cts.Token).ConfigureAwait(false); 570_cts.Token);
Components\Pages\TraceDetail.razor.cs (3)
217await Task.Delay(200, _cts.Token); 292}, _cts.Token)).Items; 554_cts.Token);
Components\Pages\Traces.razor.cs (1)
451_cts.Token);
Model\DashboardCommandExecutor.cs (2)
155closeToastCts.Token.Register(() => 168executeCommandCts.Token).ConfigureAwait(false);
Model\ResourceOutgoingPeerResolver.cs (1)
43_watchContainersToken = _watchContainersTokenSource.Token;
Model\TraceLinkHelpers.cs (2)
80await Task.Delay(TimeSpan.FromSeconds(0.5), cts.Token).ConfigureAwait(false); 83}, cts.Token);
ServiceClient\DashboardClient.cs (21)
113_clientCancellationToken = _cts.Token; 402await Task.Delay(delay, delayCts.Token).ConfigureAwait(false); 493await Task.Delay(delay, delayCts.Token).ConfigureAwait(false); 697using var call = _client!.WatchInteractions(headers: _headers, cancellationToken: cts.Token); 712await foreach (var update in _incomingInteractionChannel.Reader.ReadAllAsync(cts.Token).ConfigureAwait(false)) 727}, cts.Token); 732await foreach (var response in call.ResponseStream.ReadAllAsync(cancellationToken: cts.Token).ConfigureAwait(false)) 850await _initialDataReceivedTcs.Task.WaitAsync(cts.Token).ConfigureAwait(false); 864Subscription: StreamUpdatesAsync(cts.Token)); 907return StreamUpdatesAsync(_pendingInteractionCollection.ToList(), cts.Token); 948cancellationToken: combinedTokens.Token); 959await foreach (var response in call.ResponseStream.ReadAllAsync(cancellationToken: combinedTokens.Token).ConfigureAwait(false)) 970}, combinedTokens.Token); 972await foreach (var batch in channel.Reader.ReadAllAsync(combinedTokens.Token).ConfigureAwait(false)) 991cancellationToken: combinedTokens.Token); 993await foreach (var response in call.ResponseStream.ReadAllAsync(cancellationToken: combinedTokens.Token).ConfigureAwait(false)) 1055var response = await _client!.ExecuteResourceCommandAsync(request, headers: _headers, cancellationToken: combinedTokens.Token); 1109using var call = _client!.UploadFile(headers: _headers, cancellationToken: combinedTokens.Token); 1117while ((bytesRead = await fileStream.ReadAsync(buffer, combinedTokens.Token).ConfigureAwait(false)) > 0) 1137await call.RequestStream.WriteAsync(chunk, combinedTokens.Token).ConfigureAwait(false); 1144await call.RequestStream.WriteAsync(new UploadFileChunk { FileName = fileName, InteractionId = interactionId, InputName = inputName }, combinedTokens.Token).ConfigureAwait(false);
Terminal\TerminalWebSocketProxy.cs (1)
265var token = linkedCts.Token;
Utils\CallbackThrottler.cs (1)
25_cancellationToken = _cts.Token;
Utils\CancellationSeries.cs (1)
38var nextToken = nextCts.Token;
Aspire.Dashboard.Tests (35)
ChannelExtensionsTests.cs (6)
40await foreach (var batch in EnumerateUntilCancelledAsync(cts.Token).GetBatchesAsync(maxBatchSize: 1, cts.Token)) 66await foreach (var batch in channel.GetBatchesAsync(cancellationToken: cts.Token)) 90await foreach (var batch in channel.GetBatchesAsync().WithCancellation(cts.Token)) 117await foreach (var batch in channel.GetBatchesAsync(minReadInterval).WithCancellation(cts.Token)) 161await foreach (var batch in channel.GetBatchesAsync(minReadInterval).WithCancellation(cts.Token))
Integration\StartupTests.cs (1)
110var runTask = app.RunAsync(cts.Token);
Integration\TelemetryApiTests.cs (2)
357using var response = await httpClient.GetAsync("/api/telemetry/spans?follow=true", HttpCompletionOption.ResponseHeadersRead, cts.Token).DefaultTimeout(); 388var response = await httpClient.GetAsync("/api/telemetry/logs?follow=true", HttpCompletionOption.ResponseHeadersRead, cts.Token).DefaultTimeout();
Model\DashboardClientTests.cs (2)
50await foreach (var item in subscription.WithCancellation(cts.Token)) 194await foreach (var item in subscription.WithCancellation(cts.Token))
Model\SqliteResourceRepositoryTests.cs (2)
49await using var enumerator = subscription.Subscription.GetAsyncEnumerator(cts.Token); 73await using var enumerator = subscription.Subscription.GetAsyncEnumerator(cts.Token);
Shared\TestHostApplicationLifetime.cs (3)
14public CancellationToken ApplicationStarted => _started.Token; 15public CancellationToken ApplicationStopping => _stopping.Token; 16public CancellationToken ApplicationStopped => _stopped.Token;
TelemetryRepositoryTests\SqliteTelemetryPersistenceTests.cs (1)
60}, cancellationSource.Token);
TelemetryRepositoryTests\TelemetryRepositoryTests.cs (18)
394await foreach (var span in repositoryContext.Repository.WatchSpansAsync(new WatchSpansRequest { ResourceKeys = [], Filters = [] }, cts.Token)) 456await foreach (var span in repositoryContext.Repository.WatchSpansAsync(new WatchSpansRequest { ResourceKeys = [], Filters = [] }, cts.Token)) 512await foreach (var log in repositoryContext.Repository.WatchLogsAsync(new WatchLogsRequest { ResourceKeys = [], Filters = [] }, cts.Token)) 573await foreach (var log in repositoryContext.Repository.WatchLogsAsync(new WatchLogsRequest { ResourceKeys = [], Filters = [] }, cts.Token)) 659using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cts.Token, doneCts.Token); 665await foreach (var span in repositoryContext.Repository.WatchSpansAsync(new WatchSpansRequest { ResourceKeys = [], Filters = [] }, linkedCts.Token)) 737using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cts.Token, doneCts.Token); 743await foreach (var span in repositoryContext.Repository.WatchSpansAsync(new WatchSpansRequest { ResourceKeys = [], Filters = [] }, linkedCts.Token)) 812await foreach (var span in repositoryContext.Repository.WatchSpansAsync(new WatchSpansRequest { ResourceKeys = [new ResourceKey("service1", "inst1")], Filters = [] }, cts.Token)) 887await foreach (var span in repositoryContext.Repository.WatchSpansAsync(new WatchSpansRequest { ResourceKeys = [new ResourceKey("service1", "inst1"), new ResourceKey("service2", "inst2")], Filters = [] }, cts.Token)) 918await foreach (var log in repositoryContext.Repository.WatchLogsAsync(new WatchLogsRequest { ResourceKeys = [new ResourceKey("service1", "inst1"), new ResourceKey("service2", "inst2")], Filters = [] }, cts.Token)) 978await foreach (var log in repositoryContext.Repository.WatchLogsAsync(new WatchLogsRequest { ResourceKeys = [], Filters = filters }, cts.Token)) 1069await foreach (var log in repositoryContext.Repository.WatchLogsAsync(new WatchLogsRequest { ResourceKeys = [], Filters = filters }, cts.Token)) 1157}, cts.Token)) 1254await foreach (var log in repositoryContext.Repository.WatchLogsAsync(new WatchLogsRequest { ResourceKeys = [], Filters = filters }, cts.Token)) 1351await foreach (var span in repositoryContext.Repository.WatchSpansAsync(new WatchSpansRequest { ResourceKeys = [], Filters = filters }, cts.Token))
Aspire.Deployment.EndToEnd.Tests (109)
AcaCompactNamingDeploymentTests.cs (4)
29cts.Token, TestContext.Current.CancellationToken); 31await DeployWithCompactNamingFixesStorageCollisionCore(linkedCts.Token); 43cts.Token, TestContext.Current.CancellationToken); 45await DeployWithMultipleContainerAppEnvironmentsCreatesDistinctManagedEnvironmentsCore(linkedCts.Token);
AcaCompactNamingUpgradeDeploymentTests.cs (2)
29cts.Token, TestContext.Current.CancellationToken); 31await UpgradeFromGaToDevDoesNotDuplicateStorageAccountsCore(linkedCts.Token);
AcaCustomRegistryDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AcaDeploymentErrorOutputTests.cs (2)
32cts.Token, TestContext.Current.CancellationToken); 34await DeployWithInvalidLocation_ErrorOutputIsCleanCore(linkedCts.Token);
AcaExistingRegistryDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
AcaManagedRedisDeploymentTests.cs (2)
26cts.Token, TestContext.Current.CancellationToken); 27var cancellationToken = linkedCts.Token;
AcaStarterDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
AcrPurgeTaskDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AksAzureKubernetesEnvironmentCertManagerDeploymentTests.cs (2)
36cts.Token, TestContext.Current.CancellationToken); 37var cancellationToken = linkedCts.Token;
AksAzureKubernetesEnvironmentCertManagerTypeScriptDeploymentTests.cs (2)
39cts.Token, TestContext.Current.CancellationToken); 40var cancellationToken = linkedCts.Token;
AksAzureKubernetesEnvironmentGatewayDeploymentTests.cs (2)
30cts.Token, TestContext.Current.CancellationToken); 31var cancellationToken = linkedCts.Token;
AksBlazorRedisDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AksMultipleNodePoolsDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AksPersistentVolumeDeploymentTests.cs (2)
21cts.Token, TestContext.Current.CancellationToken); 23await DeployAksPersistentVolumeSurvivesRedeployCore(linkedCts.Token);
AksStarterDeploymentTests.cs (2)
23cts.Token, TestContext.Current.CancellationToken); 24var cancellationToken = linkedCts.Token;
AksStarterWithRedisHelmDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AksVnetInfraDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
AksVnetWithAzureResourcesDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AksWithAzureResourcesDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AksWithHelmChartDeploymentTests.cs (2)
31cts.Token, TestContext.Current.CancellationToken); 32var cancellationToken = linkedCts.Token;
AppServicePythonDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AppServiceReactDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AppServiceStoragePrivateEndpointDeploymentTests.cs (2)
22cts.Token, TestContext.Current.CancellationToken); 24await DeployReactTemplateWithAppServiceVnetAndStoragePrivateEndpointCore(linkedCts.Token);
AzureAppConfigDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
AzureContainerRegistryDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
AzureEventHubsDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
AzureKeyVaultDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
AzureLogAnalyticsDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
AzureResourceScopeDeploymentTests.cs (2)
22cts.Token, TestContext.Current.CancellationToken); 23var cancellationToken = linkedCts.Token;
AzureRoleAssignmentRunModeTests.cs (2)
35cts.Token, TestContext.Current.CancellationToken); 36var cancellationToken = linkedCts.Token;
AzureServiceBusDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
AzureStorageDeploymentTests.cs (4)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token; 35cts.Token, TestContext.Current.CancellationToken); 36var cancellationToken = linkedCts.Token;
AzureStorageRunModeTests.cs (2)
23cts.Token, TestContext.Current.CancellationToken); 24var cancellationToken = linkedCts.Token;
FoundryHostedAgentDeploymentTests.cs (2)
26cts.Token, TestContext.Current.CancellationToken); 27var cancellationToken = linkedCts.Token;
FrontDoorDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
Helpers\DeploymentE2ETestHelpers.cs (1)
165await process.WaitForExitAsync(timeout.Token);
KubernetesGatewayTlsDeploymentTests.cs (2)
30cts.Token, TestContext.Current.CancellationToken); 31var cancellationToken = linkedCts.Token;
KubernetesHelmChartDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
NspStorageKeyVaultDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
PythonFastApiDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
RadiusAzureResourcesDeploymentTests.cs (2)
41cts.Token, TestContext.Current.CancellationToken); 42var cancellationToken = linkedCts.Token;
RadiusStarterDeploymentTests.cs (4)
38cts.Token, TestContext.Current.CancellationToken); 39var cancellationToken = linkedCts.Token; 653await process.WaitForExitAsync(waitCts.Token); 667await process.WaitForExitAsync(killCts.Token);
TypeScriptAzureContainerAppJobDeploymentTests.cs (2)
22cts.Token, TestContext.Current.CancellationToken); 23var cancellationToken = linkedCts.Token;
TypeScriptExpressDeploymentTests.cs (2)
23cts.Token, TestContext.Current.CancellationToken); 24var cancellationToken = linkedCts.Token;
TypeScriptJavaScriptHostingDeploymentTests.cs (2)
22cts.Token, TestContext.Current.CancellationToken); 23var cancellationToken = linkedCts.Token;
TypeScriptVnetSqlServerInfraDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
VnetKeyVaultConnectivityDeploymentTests.cs (2)
23cts.Token, TestContext.Current.CancellationToken); 24var cancellationToken = linkedCts.Token;
VnetKeyVaultInfraDeploymentTests.cs (2)
23cts.Token, TestContext.Current.CancellationToken); 24var cancellationToken = linkedCts.Token;
VnetSqlServerConnectivityDeploymentTests.cs (2)
28cts.Token, TestContext.Current.CancellationToken); 29var cancellationToken = linkedCts.Token;
VnetSqlServerInfraDeploymentTests.cs (2)
23cts.Token, TestContext.Current.CancellationToken); 24var cancellationToken = linkedCts.Token;
VnetStorageBlobConnectivityDeploymentTests.cs (2)
23cts.Token, TestContext.Current.CancellationToken); 24var cancellationToken = linkedCts.Token;
VnetStorageBlobInfraDeploymentTests.cs (2)
23cts.Token, TestContext.Current.CancellationToken); 24var cancellationToken = linkedCts.Token;
Aspire.EndToEnd.Tests (3)
tests\Shared\TemplatesTesting\AspireProject.cs (2)
369await WaitForDashboardToBeAvailableAsync(dashboardUrlToUse, _testOutput, cts.Token).ConfigureAwait(false); 394}, cts.Token).ConfigureAwait(false);
tests\Shared\TemplatesTesting\ToolCommand.cs (1)
91return await ExecuteAsyncInternal(resolvedCommand, fullArgs, cts.Token);
Aspire.Hosting (86)
ApplicationModel\CommandsConfigurationExtensions.cs (2)
251var logForwardTask = ForwardLogsAsync(loggerService, rebuilderInstanceName, mainLogger, buildOutput, logCts.Token); 278await foreach (var evt in resourceNotificationService.WatchAsync(buildTimeoutCts.Token).ConfigureAwait(false))
ApplicationModel\ResourceCommandService.cs (1)
444CancellationToken = linkedCts.Token,
ApplicationModel\ResourceLoggerService.cs (3)
232using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_disposing.Token, cancellationToken); 251await foreach (var entry in channel.Reader.ReadAllAsync(linkedCts.Token).ConfigureAwait(false)) 462using var _ = _logStreamCts.Token.Register(() => channel.Writer.TryComplete());
ApplicationModel\ResourceNotificationService.cs (2)
670using var watchCts = CancellationTokenSource.CreateLinkedTokenSource(_disposing.Token, cancellationToken); 671var watchToken = watchCts.Token;
Backchannel\AppHostRpcTarget.cs (6)
39using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _shutdownCts.Token); 40var linkedToken = linkedCts.Token; 81using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _shutdownCts.Token); 82var linkedToken = linkedCts.Token; 118using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _shutdownCts.Token); 119var linkedToken = linkedCts.Token;
Backchannel\AuxiliaryBackchannelRpcTarget.cs (8)
647using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 653"healthy" => await WaitForHealthyAsync(notificationService, targetResource, linkedCts.Token).ConfigureAwait(false), 654"up" => await WaitForRunningAsync(notificationService, targetResource, linkedCts.Token).ConfigureAwait(false), 655"down" => await WaitForTerminalAsync(notificationService, targetResource, linkedCts.Token).ConfigureAwait(false), 1578var logStreamCancellationToken = logStreamCts.Token; 1884using var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 1888var mcpClient = await McpClient.CreateAsync(transport, cancellationToken: linked.Token).ConfigureAwait(false); 1891var toolsList = await mcpClient.ListToolsAsync(cancellationToken: linked.Token).ConfigureAwait(false);
Backchannel\TerminalHostControlClient.cs (2)
46using var rpc = await ConnectWithRetryAsync(socketPath, timeoutCts.Token).ConfigureAwait(false); 51timeoutCts.Token).ConfigureAwait(false);
Dashboard\DashboardEventHandlers.cs (1)
83_dashboardLogsTask = WatchDashboardLogsAsync(_dashboardLogsCts.Token);
Dashboard\DashboardService.cs (8)
85await foreach (var interaction in updates.WithCancellation(cts.Token).ConfigureAwait(false)) 147await responseStream.WriteAsync(change, cts.Token).ConfigureAwait(false); 158}, cts.Token); 163await foreach (var request in requestStream.ReadAllAsync(cts.Token).ConfigureAwait(false)) 165await serviceData.SendInteractionRequestAsync(request, cts.Token).ConfigureAwait(false); 483await execute(cts.Token).ConfigureAwait(false); 485catch (OperationCanceledException) when (cts.Token.IsCancellationRequested) 489catch (IOException) when (cts.Token.IsCancellationRequested)
Dashboard\DashboardServiceData.cs (6)
34_resourcePublisher = new ResourcePublisher(_cts.Token); 39var cancellationToken = _cts.Token; 172using var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _cts.Token); 174await foreach (var item in sequence.WithCancellation(linked.Token).ConfigureAwait(false)) 189using var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _cts.Token); 191await foreach (var item in sequence.WithCancellation(linked.Token).ConfigureAwait(false))
Dashboard\ResourcePublisher.cs (1)
64await foreach (var batch in channel.GetBatchesAsync(cancellationToken: linked.Token, minReadInterval: TimeSpan.FromMilliseconds(100)).ConfigureAwait(false))
Dcp\DcpExecutor.cs (3)
123_resourceWatcher = new DcpResourceWatcher(logger, kubernetesService, loggerService, executorEvents, model, _appResources, profilingTelemetry, _shutdownCancellation.Token); 327await StopAsync(disposeCts.Token).ConfigureAwait(false); 946_shutdownCancellation.Token, resourceType, modelResource,
Dcp\DcpHost.cs (8)
113await Task.Delay(TimeSpan.FromSeconds(2), timeoutCancellation.Token).ConfigureAwait(false); 114dcpInfo = await _dependencyCheckService.GetDcpInfoAsync(force: true, cancellationToken: timeoutCancellation.Token).ConfigureAwait(false); 446var acceptedSocket = await socket.AcceptAsync(_shutdownCts.Token).ConfigureAwait(false); 447outputLoggers.Add(Task.Run(() => LogSocketOutputAsync(acceptedSocket, _shutdownCts.Token))); 585var notificationCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _shutdownCts.Token); 593var notificationTask = _interactionService.PromptNotificationAsync(title, message, options, notificationCts.Token); 597while (await timer.WaitForNextTickAsync(notificationCts.Token).ConfigureAwait(false)) 601var dcpInfo = await _dependencyCheckService.GetDcpInfoAsync(force: true, cancellationToken: notificationCts.Token).ConfigureAwait(false);
Dcp\DcpKubernetesClient.cs (3)
54cancellationToken = cts.Token; 94cancellationToken = cts.Token; 120cancellationToken = cts.Token;
Dcp\DcpResourceWatcher.cs (4)
268await StopAsync(cts.Token).ConfigureAwait(false); 455await foreach (var batch in logSource.WithCancellation(timeoutCts.Token).ConfigureAwait(false)) 462timeoutCts.Token.ThrowIfCancellationRequested(); 1029return _cancellation.Token;
Dcp\ResourceLogSource.cs (1)
45cancellationToken = ownedCts.Token;
Devcontainers\DevcontainerSettingsWriter.cs (3)
63_processingTask = Task.Run(ProcessPortUpdatesAsync, _processingCancellation.Token); 72while (await reader.WaitToReadAsync(_processingCancellation.Token).ConfigureAwait(false)) 83await WriteSettingsAsync(batch, _processingCancellation.Token).ConfigureAwait(false);
ExternalServiceBuilderExtensions.cs (2)
350using var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(timeoutSource.Token, cancellationToken); 351using var response = await httpClientFactory().GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, linkedSource.Token).ConfigureAwait(false);
Health\ResourceHealthCheckService.cs (1)
340public CancellationToken CancellationToken => _cts.Token;
IInteractionService.cs (1)
190var currentToken = _currentCts.Token;
InteractionService.cs (6)
121var newState = new Interaction(title, message, options, new Interaction.MessageBoxInteractionInfo(intent: options.Intent ?? MessageIntent.None), interactionCts.Token); 195var newState = new Interaction(title, message, options, new Interaction.InputsInteractionInfo(inputCollection), interactionCts.Token); 243var refreshOptions = new QueueLoadOptions(_logger, interactionCts.Token, input, inputCollection, _serviceProvider); 274var newState = new Interaction(title, message, options, new Interaction.NotificationInteractionInfo(intent: options.Intent ?? MessageIntent.None, linkText: options.LinkText, linkUrl: options.LinkUrl), interactionCts.Token); 302var newState = new Interaction(options.Title ?? string.Empty, message, options, new Interaction.ProgressInteractionInfo(), interactionCts.Token); 332await work(new ProgressContext { CancellationToken = interactionCts.Token }).ConfigureAwait(false);
Orchestrator\ApplicationOrchestrator.cs (2)
170cts.Token); 174var waitForDependenciesTask = _notificationService.WaitForDependenciesAsync(@event.Resource, cts.Token);
Orchestrator\ParameterProcessor.cs (1)
89await HandleUnresolvedParametersAsync(_unresolvedParameters, cts.Token).ConfigureAwait(false);
Pipelines\DistributedApplicationPipeline.cs (2)
198while (!await containerRuntime.CheckIfRunningAsync(waitCts.Token).ConfigureAwait(false)) 200await Task.Delay(TimeSpan.FromSeconds(2), timeProvider, waitCts.Token).ConfigureAwait(false);
Pipelines\PipelineActivityReporter.cs (1)
31_interactionServiceSubscriber = Task.Run(() => SubscribeToInteractionsAsync(_cancellationTokenSource.Token));
src\Shared\ContainerRuntimeDetector.cs (4)
171await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false); 273await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false); 351output = await process.StandardOutput.ReadToEndAsync(timeoutCts.Token).ConfigureAwait(false); 352await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false);
Utils\PeriodicRestartAsyncEnumerable.cs (4)
29var enumerable = await enumerableFactory(lastValue, cts.Token).ConfigureAwait(false); 30var enumerator = enumerable.GetAsyncEnumerator(cts.Token); 85var enumerable = await enumerableFactory(lastValue, cts.Token).ConfigureAwait(false); 86var enumerator = enumerable.GetAsyncEnumerator(cts.Token);
Aspire.Hosting.Azure (8)
AzureProvisioningController.cs (1)
4245public CancellationToken CancellationToken => _cancellationTokenSource.Token;
Provisioning\Internal\DefaultArmClientProvider.cs (6)
272using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 278await keyVault.GetAsync(linkedCts.Token).ConfigureAwait(false); 291await Task.Delay(s_keyVaultDeletePollInterval, timeProvider, linkedCts.Token).ConfigureAwait(false); 303using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 309await deletedVault.GetAsync(linkedCts.Token).ConfigureAwait(false); 322await Task.Delay(s_keyVaultPurgePollInterval, timeProvider, linkedCts.Token).ConfigureAwait(false);
Provisioning\Provisioners\BicepProvisioner.cs (1)
706? TrackDeploymentOperationsAsync(resource, context, deploymentId, effectiveLocation, deploymentOperationTracker, deploymentOperationTrackingCts.Token)
Aspire.Hosting.Azure.Kusto.Tests (24)
KustoFunctionalTests.cs (24)
47using var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, TestContext.Current.CancellationToken); 53await app.StartAsync(cts.Token); 56await rns.WaitForResourceHealthyAsync(kusto.Resource.Name, cancellationToken: cts.Token); 60hb.Configuration["ConnectionStrings:KustoConnection"] = await kusto.Resource.ConnectionStringExpression.GetValueAsync(cts.Token); 70await host.StartAsync(cts.Token); 74var result = await _resiliencePipeline.ExecuteAsync(async cancellationToken => await ExecuteQueryAsync(client, cancellationToken), cts.Token); 98using var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, TestContext.Current.CancellationToken); 106await app.StartAsync(cts.Token); 109await rns.WaitForResourceHealthyAsync(kustoDb.Resource.Name, cancellationToken: cts.Token); 113hb.Configuration["ConnectionStrings:KustoTestDbConnection"] = await kustoDb.Resource.ConnectionStringExpression.GetValueAsync(cts.Token); 129await host.StartAsync(cts.Token); 132await _resiliencePipeline.ExecuteAsync(async cancellationToken => await SeedDataAsync(admin), cts.Token); 136var results = await _resiliencePipeline.ExecuteAsync(async cancellationToken => await ReadDataAsync(client, cancellationToken), cts.Token); 176using var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, TestContext.Current.CancellationToken); 186await app.StartAsync(cts.Token); 189await rns.WaitForResourceHealthyAsync(kusto.Resource.Name, cts.Token); 204using var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, TestContext.Current.CancellationToken); 214await app.StartAsync(cts.Token); 217await rns.WaitForResourceHealthyAsync(kusto.Resource.Name, cts.Token); 220await rns.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token); 221await rns.WaitForResourceAsync(db2.Resource.Name, KnownResourceStates.FailedToStart, cts.Token); 237using var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, TestContext.Current.CancellationToken); 255await app.StartAsync(cts.Token); 258await rns.WaitForResourceHealthyAsync(kustoDb.Resource.Name, cts.Token);
Aspire.Hosting.Azure.Tests (82)
AzureBicepProvisionerTests.cs (4)
73await app.StartAsync(cts.Token); 76await foreach (var resourceEvent in rns.WatchAsync(cts.Token).WithCancellation(cts.Token)) 1751await using var logEnumerator = loggerService.WatchAsync(resource).GetAsyncEnumerator(cts.Token);
AzureCosmosDBEmulatorFunctionalTests.cs (19)
46var pendingStart = app.StartAsync(cts.Token); 48await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 50await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 54await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 56await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 92await app.StartAsync(cts.Token); 94await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 130}, cts.Token); 172await app.StartAsync(cts.Token); 175await rns.WaitForResourceHealthyAsync(cosmos1.Resource.Name, cts.Token); 202}, cts.Token); 220await app.StartAsync(cts.Token); 223await rns.WaitForResourceHealthyAsync(cosmos2.Resource.Name, cts.Token); 257}, cts.Token); 290await app.StartAsync(cts.Token); 293await rns.WaitForResourceHealthyAsync(cosmos.Resource.Name, cts.Token); 302await host.StartAsync(cts.Token); 307var result1 = await database.ReadAsync(cancellationToken: cts.Token); 310var result2 = await container.ReadContainerAsync(cancellationToken: cts.Token);
AzureDeployerTests.cs (1)
1902var runTask = Task.Run(() => app.RunAsync(cts.Token));
AzureEnvironmentResourceExtensionsTests.cs (4)
2338var queuedOperation = AzureProvisioningController.CreateEnsureProvisionedQueuedOperationForTesting(model, completion, cts.Token); 4289CancellationToken = cts.Token, 5131completedTask = await Task.WhenAny(signalTask, operationTask).WaitAsync(watchdog.Token).ConfigureAwait(false); 5166await Task.Delay(TimeSpan.FromMilliseconds(20), watchdog.Token).ConfigureAwait(false);
AzureEventHubsExtensionsTests.cs (7)
46var pendingStart = app.StartAsync(cts.Token); 48await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 49await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 53await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 55await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 78await app.ResourceNotifications.WaitForResourceHealthyAsync(eventHubns.Resource.Name, cts.Token); 130await app.ResourceNotifications.WaitForResourceHealthyAsync(eventHubns.Resource.Name, cts.Token);
AzureServiceBusExtensionsTests.cs (13)
96var pendingStart = app.StartAsync(cts.Token); 98await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 100await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 104await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 106await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 139await rns.WaitForResourceAsync(serviceBus.Resource.Name, KnownResourceStates.Running, cts.Token); 140await rns.WaitForResourceHealthyAsync(serviceBus.Resource.Name, cts.Token); 145await sender.SendMessageAsync(new ServiceBusMessage("Hello, World!"), cts.Token); 148var message = await receiver.ReceiveMessageAsync(cancellationToken: cts.Token); 848await app.ResourceNotifications.WaitForResourceAsync(serviceBus.Resource.Name, KnownResourceStates.Running, cts.Token); 849await app.ResourceNotifications.WaitForResourceHealthyAsync(serviceBus.Resource.Name, cts.Token); 857await sender.SendMessageAsync(new ServiceBusMessage("Hello, World!"), cts.Token); 860var message = await receiver.ReceiveMessageAsync(cancellationToken: cts.Token);
AzureSignalREmulatorFunctionalTest.cs (6)
59var pendingStart = app.StartAsync(cts.Token); 60await app.ResourceNotifications.WaitForResourceAsync(signalR.Resource.Name, KnownResourceStates.Running, cts.Token); 61await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 65await app.ResourceNotifications.WaitForResourceHealthyAsync(signalR.Resource.Name, cts.Token); 67await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 124}, cts.Token);
AzureStorageEmulatorFunctionalTests.cs (20)
47var pendingStart = app.StartAsync(cts.Token); 51await rns.WaitForResourceAsync(storage.Resource.Name, KnownResourceStates.Running, cts.Token); 53await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 57await rns.WaitForResourceHealthyAsync(blobs.Resource.Name, cts.Token); 58await rns.WaitForResourceHealthyAsync(queues.Resource.Name, cts.Token); 59await rns.WaitForResourceHealthyAsync(tables.Resource.Name, cts.Token); 61await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 92var pendingStart = app.StartAsync(cts.Token); 96await rns.WaitForResourceAsync(storage.Resource.Name, KnownResourceStates.Running, cts.Token); 98await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 102await rns.WaitForResourceHealthyAsync(blobContainer.Resource.Name, cts.Token); 104await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 135var pendingStart = app.StartAsync(cts.Token); 139await rns.WaitForResourceAsync(storage.Resource.Name, KnownResourceStates.Running, cts.Token); 141await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 145await rns.WaitForResourceHealthyAsync(testQueue.Resource.Name, cts.Token); 147await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 193await rns.WaitForResourceHealthyAsync(storage.Resource.Name, cts.Token); 225await rns.WaitForResourceHealthyAsync(blobContainer.Resource.Name, cancellationToken: cts.Token); 265await rns.WaitForResourceHealthyAsync(queue.Resource.Name, cancellationToken: cts.Token);
DefaultAzurePrincipalProviderTests.cs (1)
120() => provider.GetPrincipalAsync(cts.Token));
FoundryExtensionsTests.cs (6)
89await app.StartAsync(cts.Token); 94await rns.WaitForResourceAsync(resource.Name, [KnownResourceStates.FailedToStart, KnownResourceStates.Running], cts.Token); 338cts.Token); 367cts.Token); 408cts.Token); 449cts.Token);
tests\Shared\TestInteractionService.cs (1)
83var progressContext = new ProgressContext { CancellationToken = cts.Token };
Aspire.Hosting.Blazor (1)
BrowserDebuggerHelper.cs (1)
186watcherCts.Token,
Aspire.Hosting.Blazor.Tests (2)
BrowserDebuggerHelperTests.cs (2)
108watcherCts.Token, 133watcherCts.Token,
Aspire.Hosting.Browsers (15)
BrowserEndpointDiscovery.cs (3)
213using var response = await s_probeHttpClient.GetAsync(versionEndpoint, probeCts.Token).ConfigureAwait(false); 225using var stream = await response.Content.ReadAsStreamAsync(probeCts.Token).ConfigureAwait(false); 226var version = await JsonSerializer.DeserializeAsync(stream, s_jsonContext.BrowserJsonVersionResponse, probeCts.Token).ConfigureAwait(false);
BrowserLogsCdpConnection.cs (6)
239using var sendCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _disposeCts.Token); 242using var registration = sendCts.Token.Register(static state => 250await _sendLock.WaitAsync(sendCts.Token).ConfigureAwait(false); 255await _transport.SendAsync(payload, sendCts.Token).ConfigureAwait(false); 282var frame = await _transport.ReceiveAsync(_disposeCts.Token).ConfigureAwait(false); 485await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Disposed", closeCts.Token).ConfigureAwait(false);
BrowserPageSession.cs (5)
90using var captureCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _stopCts.Token); 91return await connection.CaptureScreenshotAsync(targetSessionId, captureCts.Token).ConfigureAwait(false); 201await connection.CloseTargetAsync(_targetId, closeTargetCts.Token).ConfigureAwait(false); 404await ConnectAsync(createTarget: false, _stopCts.Token).ConfigureAwait(false); 422await Task.Delay(s_connectionRecoveryDelay, _timeProvider, _stopCts.Token).ConfigureAwait(false);
IBrowserHost.cs (1)
109await _releaseAsync(releaseCts.Token).ConfigureAwait(false);
Aspire.Hosting.Browsers.Tests (16)
src\Aspire.Hosting.Browsers\BrowserEndpointDiscovery.cs (3)
213using var response = await s_probeHttpClient.GetAsync(versionEndpoint, probeCts.Token).ConfigureAwait(false); 225using var stream = await response.Content.ReadAsStreamAsync(probeCts.Token).ConfigureAwait(false); 226var version = await JsonSerializer.DeserializeAsync(stream, s_jsonContext.BrowserJsonVersionResponse, probeCts.Token).ConfigureAwait(false);
src\Aspire.Hosting.Browsers\BrowserLogsCdpConnection.cs (6)
239using var sendCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _disposeCts.Token); 242using var registration = sendCts.Token.Register(static state => 250await _sendLock.WaitAsync(sendCts.Token).ConfigureAwait(false); 255await _transport.SendAsync(payload, sendCts.Token).ConfigureAwait(false); 282var frame = await _transport.ReceiveAsync(_disposeCts.Token).ConfigureAwait(false); 485await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Disposed", closeCts.Token).ConfigureAwait(false);
src\Aspire.Hosting.Browsers\BrowserPageSession.cs (5)
90using var captureCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _stopCts.Token); 91return await connection.CaptureScreenshotAsync(targetSessionId, captureCts.Token).ConfigureAwait(false); 201await connection.CloseTargetAsync(_targetId, closeTargetCts.Token).ConfigureAwait(false); 404await ConnectAsync(createTarget: false, _stopCts.Token).ConfigureAwait(false); 422await Task.Delay(s_connectionRecoveryDelay, _timeProvider, _stopCts.Token).ConfigureAwait(false);
src\Aspire.Hosting.Browsers\IBrowserHost.cs (1)
109await _releaseAsync(releaseCts.Token).ConfigureAwait(false);
tests\Shared\TestInteractionService.cs (1)
83var progressContext = new ProgressContext { CancellationToken = cts.Token };
Aspire.Hosting.CodeGeneration.TypeScript.Tests (1)
AtsTypeScriptCodeGeneratorTests.cs (1)
2532cancellation.Token));
Aspire.Hosting.Containers.Tests (9)
DockerSocketBindMountTests.cs (1)
44cts.Token);
ResourceFailureLoggingTests.cs (8)
33await app.StartAsync(cts.Token).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 34await app.ResourceNotifications.WaitForResourceAsync(container.Resource.Name, KnownResourceStates.FailedToStart, cts.Token).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 57await app.StartAsync(cts.Token).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 58await app.ResourceNotifications.WaitForResourceAsync(container.Resource.Name, KnownResourceStates.FailedToStart, cts.Token).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 81await app.StartAsync(cts.Token).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 82await app.ResourceNotifications.WaitForResourceAsync(container.Resource.Name, KnownResourceStates.FailedToStart, cts.Token).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 104await app.StartAsync(cts.Token).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 105await app.ResourceNotifications.WaitForResourceAsync(container.Resource.Name, [KnownResourceStates.Exited, KnownResourceStates.FailedToStart], cts.Token).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout);
Aspire.Hosting.DevTunnels (1)
src\Shared\CoalescingAsyncOperation.cs (1)
45current = _runningTask = ExecuteWrapperAsync(_cts.Token);
Aspire.Hosting.DevTunnels.Tests (4)
DevTunnelResourceBuilderExtensionsTests.cs (3)
627var startTask = app.StartAsync(cts.Token); 633cts.Token); 640await app.StopAsync(cts.Token);
tests\Shared\TestInteractionService.cs (1)
83var progressContext = new ProgressContext { CancellationToken = cts.Token };
Aspire.Hosting.Dotnet.Tests (2)
DotnetProjectResourceTests.cs (2)
924cts.Token); 926await pipeline.ExecuteAsync(context).WaitAsync(cts.Token);
Aspire.Hosting.DotnetTool.Tests (6)
DotnetToolFunctionalTests.cs.cs (6)
21await app.StartAsync(cts.Token); 23await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 24var terminalState = await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.TerminalStates, cts.Token); 44await app.StartAsync(cts.Token); 46await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 47var terminalState = await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.TerminalStates, cts.Token);
Aspire.Hosting.EntityFrameworkCore (1)
EFCoreOperationExecutor.cs (1)
300var logTask = CaptureLogsAsync(loggerService.WatchAsync(_toolResource), _logger, dataBuilder, logCancellation.Token);
Aspire.Hosting.EntityFrameworkCore.Tests (7)
EFCoreOperationExecutorTests.cs (7)
25await EFCoreOperationExecutor.CaptureLogsAsync(logs, logger, dataBuilder, cts.Token); 42await EFCoreOperationExecutor.CaptureLogsAsync(logs, logger, dataBuilder, cts.Token); 59await EFCoreOperationExecutor.CaptureLogsAsync(logs, logger, dataBuilder, cts.Token); 74await EFCoreOperationExecutor.CaptureLogsAsync(logs, logger, dataBuilder, cts.Token); 94await EFCoreOperationExecutor.CaptureLogsAsync(logs, logger, dataBuilder, cts.Token); 111await EFCoreOperationExecutor.CaptureLogsAsync(logs, logger, dataBuilder, cts.Token); 129await EFCoreOperationExecutor.CaptureLogsAsync(logs, logger, dataBuilder, cts.Token);
Aspire.Hosting.Foundry (5)
FoundryLocalService.cs (4)
105await RunFoundryCommandAsync(["service", "stop"], onOutput: null, stopCancellation.Token).ConfigureAwait(false); 166using var linkedCancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, startCancellation.Token); 167using var cancellationRegistration = linkedCancellation.Token.Register(static state => 180}, (endpointSource, process, startCancellation.Token));
PromptAgent\AzurePromptAgentResource.cs (1)
312await DeployForRunModeAsync(context, linkedCts.Token).ConfigureAwait(false);
Aspire.Hosting.Foundry.Tests (1)
PromptAgentTests.cs (1)
103CancellationToken = cts.Token,
Aspire.Hosting.Garnet.Tests (7)
GarnetFunctionalTests.cs (7)
40var pendingStart = app.StartAsync(cts.Token); 42await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 44await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 48await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 50await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 97}, cts.Token); 177}, cts.Token);
Aspire.Hosting.GitHub.Models.Tests (5)
GitHubModelsFunctionalTests.cs (5)
39var pendingStart = app.StartAsync(cts.Token); 41await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 43await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 47await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 49await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.JavaScript.Tests (8)
BunAppFixture.cs (2)
47await _app.StartAsync(startCts.Token); 50await WaitReadyStateAsync(readinessCts.Token);
BunFunctionalTests.cs (2)
25var response = await bunClient.GetStringAsync("/", cts.Token); 35var response = await bunClient.GetStringAsync("/", cts.Token);
NodeAppFixture.cs (2)
43await _app.StartAsync(cts.Token); 45await WaitReadyStateAsync(cts.Token);
NodeFunctionalTests.cs (2)
25var response = await nodeClient.GetStringAsync("/", cts.Token); 35var response = await npmClient.GetStringAsync("/", cts.Token);
Aspire.Hosting.Kafka.Tests (4)
KafkaFunctionalTests.cs (4)
102}, cts.Token); 108var result = consumer.Consume(cts.Token); 189}, cts.Token); 242var result = consumer.Consume(cts.Token);
Aspire.Hosting.Maui (5)
Lifecycle\MauiBuildQueueEventSubscriber.cs (5)
90await semaphore.WaitAsync(resourceCts.Token).ConfigureAwait(false); 102await RunBuildAsync(resource, logger, resourceCts.Token).ConfigureAwait(false); 182var token = timeoutCts.Token; 306cts.Token).ConfigureAwait(false); 403cts.Token).ConfigureAwait(false);
Aspire.Hosting.Maui.Tests (7)
MauiBuildQueueTests.cs (7)
43using var _ = cts.Token.Register(() => throw new InvalidOperationException("callback failure")); 127await foreach (var evt in env.NotificationService.WatchAsync(cts.Token)) 135}, cts.Token); 161await foreach (var evt in env.NotificationService.WatchAsync(cts.Token)) 169}, cts.Token); 243cts.Token)); 789await foreach (var evt in env.NotificationService.WatchAsync(cts.Token))
Aspire.Hosting.MongoDB.Tests (10)
MongoDbFunctionalTests.cs (10)
52var pendingStart = app.StartAsync(cts.Token); 54await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 56await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 60await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 62await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 101}, cts.Token); 164}, cts.Token); 219}, cts.Token); 342}, cts.Token); 432}, cts.Token);
Aspire.Hosting.MySql.Tests (69)
MySqlFunctionalTests.cs (69)
49var pendingStart = app.StartAsync(cts.Token); 51await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 53await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 57await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 59await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 63await app.StopAsync(cts.Token); 84await app.StartAsync(cts.Token); 86await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 100await host.StartAsync(cts.Token); 111}, cts.Token); 159await app.StartAsync(cts.Token); 161await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 177await host.StartAsync(cts.Token); 185}, cts.Token); 202}, cts.Token); 208await app.StopAsync(cts.Token); 229await app.StartAsync(cts.Token); 231await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 240[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(cts.Token) 247await host.StartAsync(cts.Token); 255}, cts.Token); 267}, cts.Token); 274await app.StopAsync(cts.Token); 343await app.StartAsync(cts.Token); 345await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 351[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token) 358await host.StartAsync(cts.Token); 366}, cts.Token); 380}, cts.Token); 427await app.StartAsync(cts.Token); 429await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 435[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token) 442await host.StartAsync(cts.Token); 450}, cts.Token); 464}, cts.Token); 497await app.StartAsync(cts.Token); 499await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 506[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token) 513await host.StartAsync(cts.Token); 521}, cts.Token); 529}, cts.Token); 536}, cts.Token); 544}, cts.Token); 588await app.StartAsync(cts.Token); 592var mySqlId = await GetContainerIdAsync(rns, "resource", cts.Token); 598mySqlId2 = await GetContainerIdAsync(rns, "resource2", cts.Token); 601var phpMyAdminId = await GetContainerIdAsync(rns, "phpmyadmin", cts.Token);; 603await app.StopAsync(cts.Token).WaitAsync(cts.Token); 659await app.StartAsync(cts.Token); 672await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 679cts.Token); 696}, cts.Token); 742await app.StartAsync(cts.Token); 755await app.ResourceNotifications.WaitForResourceHealthyAsync(mysql.Resource.Name, cts.Token); 768}, cts.Token); 770await app.StopAsync(cts.Token); 800await app.StartAsync(cts.Token); 817await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 823await conn.OpenAsync(cts.Token); 846await app.StartAsync(cts.Token); 856await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 862await conn.OpenAsync(cts.Token);
Aspire.Hosting.Nats.Tests (5)
NatsFunctionalTests.cs (5)
347var pendingStart = app.StartAsync(cts.Token); 349await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 351await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 355await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 357await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.OpenAI (3)
OpenAIHealthCheck.cs (3)
72resp = await client.SendAsync(req, HttpCompletionOption.ResponseHeadersRead, cts.Token).ConfigureAwait(false); 90using var stream = await resp.Content.ReadAsStreamAsync(cts.Token).ConfigureAwait(false); 91using var doc = await JsonDocument.ParseAsync(stream, cancellationToken: cts.Token).ConfigureAwait(false);
Aspire.Hosting.OpenAI.Tests (10)
OpenAIFunctionalTests.cs (10)
41var pendingStart = app.StartAsync(cts.Token); 43await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 45await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 49await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 51await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 88var pendingStart = app.StartAsync(cts.Token); 90await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 92await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 96await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 98await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.Oracle.Tests (23)
OracleFunctionalTests.cs (23)
46await app.StartAsync(cts.Token); 48await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 62await dbContext.Database.EnsureCreatedAsync(cts.Token); 65await dbContext.SaveChangesAsync(cts.Token); 67var cars = await dbContext.Cars.ToListAsync(cts.Token); 132await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 150await dbContext.Database.EnsureCreatedAsync(cts.Token); 154await dbContext.SaveChangesAsync(cts.Token); 163}, cts.Token); 193await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 210var brands = await dbContext.Cars.ToListAsync(cancellationToken: cts.Token); 220}, cts.Token); 303await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 323}, cts.Token); 325var brands = await dbContext.Cars.ToListAsync(cancellationToken: cts.Token); 400await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 420}, cts.Token); 422var brands = await dbContext.Cars.ToListAsync(cancellationToken: cts.Token); 465var pendingStart = app.StartAsync(cts.Token); 467await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 469await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 473await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 475await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.PostgreSQL.Tests (32)
PostgresFunctionalTests.cs (32)
130await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name, cts.Token); 142}, cts.Token); 235await app.ResourceNotifications.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token); 268}, cts.Token); 298await app.ResourceNotifications.WaitForResourceHealthyAsync(db2.Resource.Name, cts.Token); 328}, cts.Token); 419await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 427}, cts.Token); 441}, cts.Token); 503await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 511}, cts.Token); 525}, cts.Token); 570await app.StartAsync(cts.Token); 574var postgresId = await GetContainerIdAsync(rns, "resource", cts.Token); 576var pgWebId = await GetContainerIdAsync(rns, "pgweb", cts.Token); 578var pgadminId = await GetContainerIdAsync(rns, "pgadmin", cts.Token); 580await app.StopAsync(cts.Token).WaitAsync(TimeSpan.FromMinutes(1), cts.Token); 617await app.StartAsync(cts.Token); 630await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 637cts.Token); 643await conn.OpenAsync(cts.Token); 666await app.StartAsync(cts.Token); 679await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 685await conn.OpenAsync(cts.Token); 736await app.StartAsync(cts.Token); 749await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name, cts.Token); 762}, cts.Token); 764await app.StopAsync(cts.Token); 794await app.StartAsync(cts.Token); 811await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 817await conn.OpenAsync(cts.Token);
Aspire.Hosting.Qdrant.Tests (8)
QdrantFunctionalTests.cs (8)
65}, cts.Token); 147}, cts.Token); 195}, cts.Token); 276var pendingStart = app.StartAsync(cts.Token); 278await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 280await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 284await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, (re => re.Snapshot.HealthStatus == HealthStatus.Healthy), cts.Token); 286await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.Radius (1)
Publishing\SealedSecretApplyStep.cs (1)
333return await probe(linkedCts.Token).ConfigureAwait(false);
Aspire.Hosting.Radius.Tests (3)
Deployment\RadCliDetectionTests.cs (1)
42() => RadiusDeploymentPipelineStep.DetectRadCliAsync(cts.Token));
Secrets\SealedSecretApplyStepTests.cs (2)
553cancellationToken: cts.Token)); 833cancellationToken: cts.Token,
Aspire.Hosting.Redis.Tests (19)
RedisFunctionalTests.cs (19)
51var pendingStart = app.StartAsync(cts.Token); 53await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 55await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 59await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 61await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 147await app.StartAsync(cts.Token); 148await app.ResourceNotifications.WaitForResourceHealthyAsync(redis.Resource.Name, cts.Token); 162await host.StartAsync(cts.Token); 189await rns.WaitForResourceAsync(redisInsightBuilder.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token); 194await AcceptRedisInsightEula(client, cts.Token); 196var response = await client.GetAsync("/api/databases", cts.Token); 199var databases = await response.Content.ReadFromJsonAsync<List<RedisInsightDatabaseModel>>(cts.Token); 227var testConnectionResponse = await client.GetAsync($"/api/databases/{db.Id}/connect", cts2.Token); 524await rns.WaitForResourceAsync(redisInsightBuilder1.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token); 529await AcceptRedisInsightEula(httpClient, cts.Token); 559await rns.WaitForResourceAsync(redisInsightBuilder2.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token); 564await EnsureRedisInsightEulaAccepted(httpClient, cts.Token); 680await app.ResourceNotifications.WaitForResourceHealthyAsync(redis.Resource.Name, cts.Token); 681await app.ResourceNotifications.WaitForResourceHealthyAsync(redisCommander.Name, cts.Token);
Aspire.Hosting.RemoteHost (6)
CancellationTokenRegistry.cs (5)
38return (id, cts.Token); 60return (id, cts.Token); 112token = cts.Token; 133return existing.Token; 147return added.Token;
JsonRpcCallbackInvoker.cs (1)
46cts.Token).ConfigureAwait(false);
Aspire.Hosting.RemoteHost.Tests (11)
AtsMarshallerTests.cs (2)
207var result = marshaller.MarshalToJson(cts.Token); 228var result = marshaller.MarshalToJson(cts.Token, typeRef);
CallbackProxyTests.cs (2)
196await proxy("test", cts.Token); 217await proxy(cts.Token);
CancellationTokenRegistryTests.cs (1)
40var (_, token) = registry.CreateLinked(cts.Token);
CapabilityDispatcherTests.cs (1)
317var context = new TestCancellationTokenContext { CancellationToken = cts.Token };
JsonRpcAuthenticationTests.cs (4)
188using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 192while (!linkedCts.Token.IsCancellationRequested) 199await pipeClient.ConnectAsync(linkedCts.Token); 204await socket.ConnectAsync(new UnixDomainSocketEndPoint(socketPath), linkedCts.Token);
tests\Shared\TestInteractionService.cs (1)
83var progressContext = new ProgressContext { CancellationToken = cts.Token };
Aspire.Hosting.Rust (1)
CargoMetadataReader.cs (1)
106await process.WaitForExitAsync(timeoutSource.Token).ConfigureAwait(false);
Aspire.Hosting.Rust.Tests (3)
RustPublicApiTests.cs (3)
217var context = new RustCargoArgsCallbackContext(new RustAppResource("api", "/src/rust-app"), [], cts.Token); 219Assert.Equal(cts.Token, context.CancellationToken); 514var callbackContext = LaunchConfigurationTestHelpers.CreateCallbackContext(app.Resource, cancellationToken: cts.Token);
Aspire.Hosting.Sdk.Tests (2)
AppHostSdkTargetsTests.cs (2)
1832await process.WaitForExitAsync(cts.Token); 1891await process.WaitForExitAsync(cts.Token);
Aspire.Hosting.SqlServer.Tests (33)
SqlServerFunctionalTests.cs (33)
44var pendingStart = app.StartAsync(cts.Token); 46await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 48await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 52await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 54await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 79await app.StartAsync(cts.Token); 109}, cts.Token); 113await dbContext.Database.EnsureCreatedAsync(cts.Token); 115await dbContext.SaveChangesAsync(cts.Token); 116var cars = await dbContext.Cars.ToListAsync(cts.Token); 182await app1.ResourceNotifications.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token); 221}, cts.Token); 241}, cts.Token); 268await app2.ResourceNotifications.WaitForResourceHealthyAsync(db2.Resource.Name, cts.Token); 295}, cts.Token); 301using var results = await command.ExecuteReaderAsync(cts.Token); 303Assert.True(await results.ReadAsync(cts.Token)); 305Assert.False(await results.ReadAsync(cts.Token)); 369await app.StartAsync(cts.Token); 382await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 389cts.Token); 407}, cts.Token); 430await app.StartAsync(cts.Token); 441await host.StartAsync(cts.Token); 443await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 457}, cts.Token); 503await app.StartAsync(cts.Token); 516await app.ResourceNotifications.WaitForResourceHealthyAsync(sqlserver.Resource.Name, cts.Token); 530}, cts.Token); 532await app.StopAsync(cts.Token); 562await app.StartAsync(cts.Token); 579await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 585await conn.OpenAsync(cts.Token);
Aspire.Hosting.Testing (13)
DistributedApplicationFactory.cs (13)
48using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _disposingCts.Token); 50return await _builderTcs.Task.WaitAsync(linkedCts.Token).ConfigureAwait(false); 58using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _disposingCts.Token); 60return await _appTcs.Task.WaitAsync(linkedCts.Token).ConfigureAwait(false); 71using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _disposingCts.Token); 73await _startedTcs.Task.WaitAsync(linkedCts.Token).ConfigureAwait(false); 409var app = await factory(_args, cts.Token).ConfigureAwait(false); 505await _exitTcs.Task.WaitAsync(shutdownTimeoutCts.Token).ConfigureAwait(false); 518await app.StopAsync().WaitAsync(shutdownTimeoutCts.Token).ConfigureAwait(false); 527await app.DisposeAsync().AsTask().WaitAsync(shutdownTimeoutCts.Token).ConfigureAwait(false); 585await asyncDisposable.DisposeAsync().AsTask().WaitAsync(appFactory._disposingCts.Token).ConfigureAwait(false); 597using var linkedToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, appFactory._disposingCts.Token); 598await innerHost.StartAsync(linkedToken.Token).ConfigureAwait(false);
Aspire.Hosting.Testing.Tests (45)
DashboardUrlTests.cs (15)
28var dashboardUri = await app.GetDashboardUrlAsync(cancellationTokenSource.Token); 47using var loginResponse = await httpClient.GetAsync(dashboardUri, cancellationTokenSource.Token); 57cancellationTokenSource.Token); 73var dashboardUri = await app.GetDashboardUrlAsync(cancellationTokenSource.Token); 99var cancellationToken = cancellationTokenSource.Token; 170var dashboardUri = await app.GetDashboardUrlAsync(cancellationTokenSource.Token); 183using var loginResponse = await httpClient.GetAsync(dashboardUri, cancellationTokenSource.Token); 204var firstUrl = await firstApp.GetDashboardUrlAsync(cancellationTokenSource.Token); 205var secondUrl = await secondApp.GetDashboardUrlAsync(cancellationTokenSource.Token); 228using var response = await httpClient.GetAsync(invalidLoginUrl, cancellationTokenSource.Token); 260var dashboardUri = await app.GetDashboardUrlAsync(cancellationTokenSource.Token); 270using var response = await httpClient.GetAsync(dashboardUri, cancellationTokenSource.Token); 314() => app.GetDashboardUrlAsync(cancellationTokenSource.Token)); 331var dashboardUri = await app.GetDashboardUrlAsync(cancellationTokenSource.Token); 341await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationTokenSource.Token);
ResourceLoggerForwarderServiceTests.cs (3)
162ApplicationStarted = _startedCts.Token; 163ApplicationStopping = _stoppingCts.Token; 164ApplicationStopped = _stoppedCts.Token;
TestingBuilderTests.cs (21)
464genericEntryPoint ? DistributedApplicationTestingBuilder.CreateAsync<Projects.TestingAppHost1_AppHost>([$"--crash-{crashArg}"], cts.Token).WaitAsync(cts.Token) 465: DistributedApplicationTestingBuilder.CreateAsync(typeof(Projects.TestingAppHost1_AppHost), [$"--crash-{crashArg}"], cts.Token).WaitAsync(cts.Token)); 472? await DistributedApplicationTestingBuilder.CreateAsync<Projects.TestingAppHost1_AppHost>([$"--crash-{crashArg}"], cts.Token).WaitAsync(cts.Token) 473: await DistributedApplicationTestingBuilder.CreateAsync(typeof(Projects.TestingAppHost1_AppHost), [$"--crash-{crashArg}"], cts.Token).WaitAsync(cts.Token); 478using var app = await builder.BuildAsync().WaitAsync(cts.Token); 483var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => app.StartAsync().WaitAsync(cts.Token)); 488await app.StartAsync().WaitAsync(cts.Token); 492await app.DisposeAsync().AsTask().WaitAsync(cts.Token); 507using var builder = await DistributedApplicationTestingBuilder.CreateAsync<Projects.TestingAppHost1_AppHost>(["--add-unknown-container"], cts.Token).WaitAsync(cts.Token); 509await using var app = await builder.BuildAsync(cts.Token).WaitAsync(cts.Token); 530cts.Token).WaitAsync(cts.Token); 547app = await builder.BuildAsync(cts.Token).WaitAsync(cts.Token); 556await app.DisposeAsync().AsTask().WaitAsync(cts.Token);
TestingFactoryCrashTests.cs (3)
27var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => factory.StartAsync().WaitAsync(cts.Token)); 32await factory.StartAsync().WaitAsync(cts.Token); 35await factory.DisposeAsync().AsTask().WaitAsync(cts.Token);
tests\Aspire.Hosting.TestUtilities\Utils\LoggerNotificationExtensions.cs (3)
84_ = Task.Run(() => WatchNotifications(app, resourceName, predicate, tcs, watchCts), watchCts.Token); 132await foreach (var resourceEvent in app.ResourceNotifications.WatchAsync(cancellationTokenSource.Token).ConfigureAwait(false)) 162await foreach (var logEvent in resourceLoggerService.WatchAsync(resourceId).WithCancellation(cancellationTokenSource.Token).ConfigureAwait(false))
Aspire.Hosting.Tests (282)
ApplicationModel\McpServerEndpointAnnotationTests.cs (1)
175() => annotation.EndpointUrlResolver(resource, cts.Token));
ApplicationModel\ResourceAnnotationCollectionTests.cs (2)
192while (!cts.Token.IsCancellationRequested) 220while (!cts.Token.IsCancellationRequested)
Backchannel\AppHostRpcTargetCancellationTests.cs (6)
34await foreach (var _ in target.GetAppHostLogEntriesAsync(cts.Token)) 55await foreach (var _ in target.GetAppHostLogEntriesAsync(cts.Token)) 108await foreach (var _ in target.GetPublishingActivitiesAsync(cts.Token)) 128await foreach (var _ in target.GetPublishingActivitiesAsync(cts.Token)) 179await foreach (var _ in target.GetResourceStatesAsync(cts.Token)) 199await foreach (var _ in target.GetResourceStatesAsync(cts.Token))
Backchannel\AppHostRpcTargetUploadTests.cs (1)
156}, cancellationTokenSource.Token));
Backchannel\AuxiliaryBackchannelRpcTargetTests.cs (6)
984await target.GetResourceSnapshotsAsync(cts.Token).DefaultTimeout(); 1092var enumerator = target.WatchResourceSnapshotsAsync(cts.Token).GetAsyncEnumerator(cts.Token); 1515}, cancellationTokenSource.Token)); 1550}, cancellationTokenSource.Token)); 2117await foreach (var logLine in target.GetResourceLogsAsync("myresource", follow: true, cts.Token))
Backchannel\AuxiliaryBackchannelTests.cs (1)
425await Task.Delay(Timeout.Infinite, lifetime.ApplicationStopping).WaitAsync(cts.Token);
Backchannel\GetTerminalInfoAsyncTests.cs (1)
399_acceptLoop = Task.Run(() => AcceptLoopAsync(_cts.Token));
Codespaces\CodespacesUrlRewriterTests.cs (6)
33await app.StartAsync(abortToken.Token); 39while (!abortToken.Token.IsCancellationRequested) 51await app.StopAsync(abortToken.Token); 69await app.StartAsync(abortToken.Token); 86abortToken.Token); 98await app.StopAsync(abortToken.Token);
Dashboard\DashboardServiceDataTerminalTests.cs (3)
216public CancellationToken ApplicationStarted { get; } = new CancellationTokenSource().Token; 217public CancellationToken ApplicationStopped { get; } = new CancellationTokenSource().Token; 218public CancellationToken ApplicationStopping { get; } = new CancellationTokenSource().Token;
Dashboard\DashboardServiceTests.cs (6)
217var context = TestServerCallContext.Create(cancellationToken: cts.Token); 479var context = TestServerCallContext.Create(cancellationToken: cts.Token); 550var context = TestServerCallContext.Create(cancellationToken: cts.Token); 598var context = TestServerCallContext.Create(cancellationToken: cts.Token); 658var context = TestServerCallContext.Create(cancellationToken: cts.Token); 696var context = TestServerCallContext.Create(cancellationToken: cts.Token);
Dashboard\ResourcePublisherTests.cs (7)
36ResourcePublisher publisher = new(cts.Token); 89ResourcePublisher publisher = new(cts.Token); 110var enumerator1 = subscription1.GetAsyncEnumerator(cts.Token); 111var enumerator2 = subscription2.GetAsyncEnumerator(cts.Token); 136ResourcePublisher publisher = new(cts.Token); 157ResourcePublisher publisher = new(cts.Token); 184await foreach (var item in subscription.WithCancellation(cts.Token).ConfigureAwait(false))
Dcp\DcpExecutorTests.cs (4)
1516var watchLogsEnumerator = watchLogs.GetAsyncEnumerator(watchCts.Token); 4637await appExecutor.RunApplicationAsync(cts.Token); 4642Assert.Equal(cts.Token, launchContext.CancellationToken); 8385() => appExecutor.StartResourceAsync(reference, restartCancellation.Token));
Dcp\DcpHostNotificationTests.cs (15)
111var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token); 155var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token); 212await interactionService.Interactions.Reader.ReadAsync(cts.Token); 271await interactionService.Interactions.Reader.ReadAsync(cts.Token); 326var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token); 381var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token); 403using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(interaction.CancellationToken, testTimeoutCts.Token)) 405await Assert.ThrowsAsync<TaskCanceledException>(() => Task.Delay(-1, linkedCts.Token)); 452var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token); 789await interactionService.Interactions.Reader.ReadAsync(cts.Token); 839await interactionService.Interactions.Reader.ReadAsync(cts.Token); 895var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token); 950await interactionService.Interactions.Reader.ReadAsync(cts.Token); 1008await interactionService.Interactions.Reader.ReadAsync(cts.Token); 1069var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token);
Dcp\KubernetesServiceTests.cs (25)
36var listTask = service.ListAsync<Container>(cancellationToken: cts.Token); 38await Task.Delay(300, cts.Token); 40await using var server = await TestDcpApiServer.StartAsync(cts.Token); 57var listTask = service.ListAsync<Container>(cancellationToken: cts.Token); 61await Task.Delay(TimeSpan.FromSeconds(2), cts.Token); 63await using var server = await TestDcpApiServer.StartAsync(cts.Token); 83await using var server = await TestDcpApiServer.StartAsync(cts.Token, successfulRequestNumber: 4); 84var listTask = service.ListAsync<Container>(cancellationToken: cts.Token); 86await Task.Delay(TimeSpan.FromSeconds(1), cts.Token); 104await using var server = await TestDcpApiServer.StartAsync(cts.Token); 107var result = await service.ListAsync<Container>(cancellationToken: cts.Token); 112() => service.ListAsync<Container>(cancellationToken: cts.Token)); 126await using var server = await TestDcpApiServer.StartAsync(cts.Token); 128Assert.Empty(await service.ListAsync<Container>(cancellationToken: cts.Token)); 132() => service.ListAsync<Container>(cancellationToken: cts.Token)); 133await server.WaitForRequestCancellationAsync(cts.Token); 140using var watchCts = CancellationTokenSource.CreateLinkedTokenSource(cts.Token); 148await using var server = await TestDcpApiServer.StartAsync(cts.Token); 152await using var watchEnumerator = service.WatchAsync<Container>(cancellationToken: watchCts.Token).GetAsyncEnumerator(); 154await server.WaitForWatchRequestAsync(cts.Token); 160Assert.Empty(await service.ListAsync<Container>(cancellationToken: cts.Token)); 165await server.WaitForRequestCancellationAsync(cts.Token); 185var listTask = service.ListAsync<Container>(cancellationToken: cts.Token); 188await Task.Delay(300, cts.Token); 190await using var server = await TestDcpApiServer.StartAsync(cts.Token);
DebugSupportExtensionsTests.cs (8)
88await executable.Resource.CreateLaunchConfigurationAsync(ExecutableLaunchMode.NoDebug, cts.Token)); 94Assert.Equal(cts.Token, observedContext.CancellationToken); 206await CreateLaunchConfigurationForTestAsync(executable.Resource, ExecutableLaunchMode.Debug, cts.Token); 208Assert.Equal(cts.Token, observedToken); 230await executable.Resource.CreateLaunchConfigurationAsync(ExecutableLaunchMode.NoDebug, cts.Token)); 238Assert.Equal(cts.Token, actualContext.CancellationToken); 273cts.Token); 282Assert.Equal(cts.Token, actualContext.CancellationToken);
DistributedApplicationTests.cs (24)
79await testProgram.RunAsync(cts.Token); 124await testProgram.RunAsync(cts.Token); 205var token = cts.Token; 250var token = cts.Token; 340var token = cts.Token; 384var token = cts.Token; 453await app.StartAsync(cts.Token); 494await app.RunAsync(cts.Token); 539var token = cts.Token; 626var token = cts.Token; 1222var token = cts.Token; 1260var token = cts.Token; 1769var token = cts.Token; 2042var token = cts.Token; 2081var token = cts.Token; 2229var token = cts.Token; 2245using var logStream = await kubernetes.GetLogStreamAsync(worker, Logs.StreamTypeStdOut, logCts.Token, follow: true, timestamps: true); 2247await EnsureLogLines(logStream, logCts.Token, minimumLines); 2258using var logStream = await kubernetes.GetLogStreamAsync(worker, Logs.StreamTypeStdOut, logCts.Token, 2263await EnsureLogLines(logStream, logCts.Token, limit, (long n) => expectedLineNumber++ == n); 2271using var logStream = await kubernetes.GetLogStreamAsync(worker, Logs.StreamTypeStdOut, logCts.Token, 2277await EnsureLogLines(logStream, logCts.Token, tail, (long n) => n >= minimumLineNumber++); 2300var token = cts.Token; 2302var startTask = app.StartAsync(cts.Token);
EndpointReferenceTests.cs (1)
174var getValueTask = endpointExpr.GetValueAsync(cts.Token);
ExecutionConfigurationGathererTests.cs (1)
660var result = await factory(metadata.Certificates, cts.Token);
Health\FriendlyHealthCheckErrorMessagesTests.cs (3)
39cts.Token).DefaultTimeout(); 79cts.Token).DefaultTimeout(); 205var message = HttpHealthCheckHelpers.GetFriendlyErrorMessage(uri, exception, cts.Token);
Health\ResourceHealthCheckServiceTests.cs (11)
227await app.StartAsync(abortTokenSource.Token).DefaultTimeout(); 233await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, abortTokenSource.Token).DefaultTimeout(); 242await app.StopAsync(abortTokenSource.Token).TimeoutAfter(TestConstants.LongTimeoutTimeSpan); 268await app.StartAsync(abortTokenSource.Token).DefaultTimeout(); 285await app.StopAsync(abortTokenSource.Token).DefaultTimeout(); 311await app.StartAsync(abortTokenSource.Token).DefaultTimeout(); 317await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, abortTokenSource.Token).DefaultTimeout(); 319var firstCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 322var secondCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 325var thirdCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 327await app.StopAsync(abortTokenSource.Token).DefaultTimeout();
InteractionServiceTests.cs (5)
52var resultTask = interactionService.PromptConfirmationAsync("Are you sure?", "Confirmation", cancellationToken: cts.Token); 1238}, cancellationToken: cts.Token); 1257var resultTask = interactionService.PromptProgressAsync("Please wait", new ProgressInteractionOptions { Title = "Working..." }, cancellationToken: cts.Token); 1298var resultTask = interactionService.PromptProgressAsync("Please wait...", cancellationToken: cts.Token); 1407var resultTask = interactionService.PromptInputAsync("Select file", "please", input, cancellationToken: cancellationTokenSource.Token);
Lifecycle\TerminalHostFailureDiagnosticServiceTests.cs (9)
30await service.StartAsync(stopCts.Token).DefaultTimeout(); 69await service.StartAsync(stopCts.Token).DefaultTimeout(); 100await service.StartAsync(stopCts.Token).DefaultTimeout(); 112await Task.Delay(200, stopCts.Token); 141await service.StartAsync(stopCts.Token).DefaultTimeout(); 178await service.StartAsync(stopCts.Token).DefaultTimeout(); 205await Task.Delay(150, stopCts.Token); 277await foreach (var batch in loggers.WatchAsync(host).WithCancellation(cts?.Token ?? CancellationToken.None)) 300await foreach (var batch in loggers.WatchAsync(host).WithCancellation(timeoutCts.Token))
Publishing\ContainerRuntimeResolverTests.cs (1)
76firstTask = resolver.ResolveAsync(cts.Token);
Publishing\PipelineActivityReporterTests.cs (1)
697var promptTask = _interactionService.PromptInputAsync("Upload", "Select a file", input, cancellationToken: cancellationTokenSource.Token);
Publishing\ResourceContainerImageManagerTests.cs (31)
39await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 71await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 104await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 141await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 175await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 205await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 243await imageBuilder.BuildImageAsync(container.Resource, cts.Token); 287await imageBuilder.BuildImageAsync(container.Resource, cts.Token); 324await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 356await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 387await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 438await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 467await imageBuilder.PushImageAsync(testResource.Resource, cts.Token); 492imageBuilder.PushImageAsync(testResource.Resource, cts.Token)); 527await imageBuilder.BuildImagesAsync([servicea.Resource], cts.Token); 558await imageBuilder.BuildImagesAsync([dockerfileResource.Resource], cts.Token); 591await imageBuilder.BuildImagesAsync([dockerfileResource.Resource], cts.Token); 630imageBuilder.BuildImagesAsync([container.Resource], cts.Token)); 669imageBuilder.BuildImageAsync(project.Resource, cts.Token)); 707imageBuilder.BuildImageAsync(project.Resource, cts.Token)); 750await imageBuilder.BuildImageAsync(container.Resource, cts.Token); 824await imageBuilder.BuildImageAsync(container.Resource, cts.Token); 920await imageBuilder.BuildImageAsync(container.Resource, cts.Token); 973await imageBuilder.BuildImageAsync(container.Resource, cts.Token); 1355await imageManager.BuildImagesAsync([servicea.Resource], cts.Token); 1399() => imageManager.BuildImagesAsync([servicea.Resource], cts.Token)); 1434() => imageManager.BuildImageAsync(container.Resource, cts.Token)); 1477() => imageManager.BuildImagesAsync([servicea.Resource, serviceb.Resource], cts.Token)); 1510() => imageManager.BuildImagesAsync([servicea.Resource], cts.Token)); 1545() => imageBuilder.BuildImageAsync(container.Resource, cts.Token)); 1552var containerRuntime = await app.Services.GetRequiredService<IContainerRuntimeResolver>().ResolveAsync(cts.Token);
ResourceCommandServiceTests.cs (1)
1650await resourceNotificationService.WaitForResourceAsync(project.Resource.Name, e => KnownResourceStates.BuildableStates.Contains(e.Snapshot.State?.Text), cts.Token).DefaultTimeout(TimeSpan.FromMinutes(2));
ResourceFailureLoggingTests.cs (4)
35await app.StartAsync(cts.Token).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 36await app.ResourceNotifications.WaitForResourceAsync(executable.Resource.Name, KnownResourceStates.Finished, cts.Token).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 58await app.StartAsync(cts.Token).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 59await app.ResourceNotifications.WaitForResourceAsync(executable.Resource.Name, KnownResourceStates.FailedToStart, cts.Token).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout);
ResourceNotificationTests.cs (35)
80await foreach (var item in notificationService.WatchAsync(cts.Token)) 120var enumerableTask = GetValuesAsync(cts.Token); 198var enumerableTask = GetValuesAsync(cts.Token); 255var waitTask = notificationService.WaitForResourceAsync("MYreSouRCe1", "sOmeSTAtE", cts.Token); 347var waitTask = notificationService.WaitForResourceAsync("myResource1", "SomeState", cts.Token); 369var waitTask = notificationService.WaitForDependenciesAsync(resource, cts.Token); 375cts.Token).DefaultTimeout(); 388cts.Token).DefaultTimeout(); 417var waitTask = notificationService.WaitForDependenciesAsync(resource, cts.Token); 423cts.Token).DefaultTimeout(); 441cts.Token).DefaultTimeout(); 473var waitTask = notificationService.WaitForDependenciesAsync(resource, cts.Token); 479cts.Token).DefaultTimeout(); 493cts.Token).DefaultTimeout(); 527var waitTask = notificationService.WaitForDependenciesAsync(resource, cts.Token); 532cts.Token).DefaultTimeout(); 567var waitTask = notificationService.WaitForDependenciesAsync(resource, cts.Token); 607var waitTask = notificationService.WaitForDependenciesAsync(resource, cts.Token); 612cts.Token).DefaultTimeout(); 645var waitTask = notificationService.WaitForDependenciesAsync(resource, cts.Token); 678var waitTask = notificationService.WaitForDependenciesAsync(resource, cts.Token); 683cts.Token).DefaultTimeout(); 717var waitTask = notificationService.WaitForDependenciesAsync(resource, cts.Token); 722cts.Token).DefaultTimeout(); 749var waitTask = notificationService.WaitForDependenciesAsync(resource, cts.Token); 755cts.Token).DefaultTimeout(); 768cts.Token).DefaultTimeout(); 826var waitTask = notificationService.WaitForResourceAsync(resource.Name, KnownResourceStates.Running, cts.Token); 853var waitTask = notificationService.WaitForDependenciesAsync(resource, cts.Token); 895var waitTask = notificationService.WaitForResourceAsync("myResource1", "SomeState", cts.Token); 1056var enumerableTask = GetValuesAsync(cts.Token); 1108var enumerableTask = GetFirstValueAsync(cts.Token); 1144var enumerableTask = GetFirstValueAsync(cts.Token); 1401var waitTask = notificationService.WaitForResourceHealthyAsync("does-not-exist", WaitBehavior.WaitOnResourceUnavailable, cts.Token); 1434ApplicationStopping = _stoppingCts.Token;
SlimTestProgramTests.cs (3)
30await EnsureServicesAreRunning(testProgram, cts.Token); 55await EnsureServicesAreRunning(testProgram, cts.Token); 74await EnsureServicesAreRunning(testProgram, cts.Token);
TestProgramFixture.cs (2)
34await _app.StartAsync(cts.Token); 36await WaitReadyStateAsync(cts.Token);
tests\Shared\TestInteractionService.cs (1)
83var progressContext = new ProgressContext { CancellationToken = cts.Token };
Utils\PeriodicRestartAsyncEnumerableTests.cs (2)
23await foreach (var _ in PeriodicRestartAsyncEnumerable.CreateAsync(innerFactory, restartInterval: TimeSpan.FromSeconds(2), cancellationToken: cts.Token).ConfigureAwait(false)) 46await foreach (var _ in PeriodicRestartAsyncEnumerable.CreateAsync(innerFactory, restartInterval: TimeSpan.FromMilliseconds(100), cancellationToken: cts.Token).ConfigureAwait(false))
ValueSnapshotTests.cs (2)
182var getTask = snapshot.GetValueAsync(cts.Token); 194var cancelledTask = snapshot.GetValueAsync(cts.Token);
WaitForTests.cs (51)
31await app.StartAsync(abortCts.Token); 33await app.ResourceNotifications.WaitForResourceAsync(throwingResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token); 34await app.ResourceNotifications.WaitForResourceAsync(dependingContainerResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token); 35await app.ResourceNotifications.WaitForResourceAsync(dependingExecutableResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token); 37await app.StopAsync(abortCts.Token); 105var startTask = app.StartAsync(startupCts.Token); 108await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 136var startTask = app.StartAsync(startupCts.Token); 139await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 169var startTask = app.StartAsync(startupCts.Token); 176await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 213var startTask = app.StartAsync(startupCts.Token); 217await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 224await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, waitingStateCts.Token); 324var startTask = app.StartAsync(startupCts.Token); 328await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 335await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, waitingStateCts.Token); 358var startTask = app.StartAsync(startupCts.Token); 362await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 369await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 377await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 405var startTask = app.StartAsync(startupCts.Token); 409await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 416await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 424await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 447var startTask = app.StartAsync(startupCts.Token); 454await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 469await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, runningStateCts.Token); 494var startTask = app.StartAsync(startupCts.Token); 501await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, "Waiting", waitingStateCts.Token); 516await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token); 549var startTask = app.StartAsync(startupCts.Token); 556await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, "Waiting", waitingStateCts.Token); 572await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token); 603var startTask = app.StartAsync(startupCts.Token); 610await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 624await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token); 654var startTask = app.StartAsync(startupCts.Token); 661await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 669await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 677await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 707var startTask = app.StartAsync(startupCts.Token); 714await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 722await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 730await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 756var startTask = app.StartAsync(startupCts.Token); 763await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 771await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 871var startTask = app.StartAsync(startupCts.Token); 875await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 885await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, runningStateCts.Token);
WithHttpCommandTests.cs (1)
482var result = await app.ResourceCommands.ExecuteCommandAsync(service.Resource, "mycommand", cts.Token).DefaultTimeout();
WithProcessCommandTests.cs (1)
1472var commandTask = app.ResourceCommands.ExecuteCommandAsync(resource.Resource, "wait", cts.Token);
Aspire.Hosting.TestUtilities (9)
Utils\DockerUtils.cs (2)
51() => runtimeDetector(configuredRuntime, cts.Token), 52cts.Token).GetAwaiter().GetResult();
Utils\LoggerNotificationExtensions.cs (3)
84_ = Task.Run(() => WatchNotifications(app, resourceName, predicate, tcs, watchCts), watchCts.Token); 132await foreach (var resourceEvent in app.ResourceNotifications.WatchAsync(cancellationTokenSource.Token).ConfigureAwait(false)) 162await foreach (var logEvent in resourceLoggerService.WatchAsync(resourceId).WithCancellation(cancellationTokenSource.Token).ConfigureAwait(false))
Utils\PersistentContainerTestHelpers.cs (4)
111await app.StartAsync(cts.Token); 115resourceNames.Select(resourceName => GetContainerIdentityAsync(resourceNotificationService, resourceName, compareUrls, cts.Token))); 117await app.StopAsync(cts.Token).WaitAsync(cts.Token);
Aspire.Hosting.Valkey.Tests (5)
ValkeyFunctionalTests.cs (5)
225var pendingStart = app.StartAsync(cts.Token); 227await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 229await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 233await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 235await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.Yarp.Tests (2)
YarpFunctionalTests.cs (2)
54await app.ResourceNotifications.WaitForResourceHealthyAsync(backend.Resource.Name, cts.Token); 55await app.ResourceNotifications.WaitForResourceHealthyAsync(yarp.Resource.Name, cts.Token);
Aspire.Managed.Tests (2)
ParentProcessWatchdogTests.cs (2)
45using var registration = operationCts.Token.Register(static () => throw new InvalidOperationException("simulated cancellation callback failure")); 64using var registration = operationCts.Token.Register(() =>
Aspire.Milvus.Client.Tests (1)
MilvusHealthCheckTests.cs (1)
44var healthCheckReport = await healthCheckService.CheckHealthAsync(cts.Token);
Aspire.MongoDB.Driver.Tests (1)
ConformanceTests.cs (1)
114service.ListDatabases(source.Token);
Aspire.MongoDB.Driver.v2.Tests (1)
tests\Aspire.MongoDB.Driver.Tests\ConformanceTests.cs (1)
114service.ListDatabases(source.Token);
Aspire.NATS.Net.Tests (1)
AspireNatsClientExtensionsTests.cs (1)
200var healthCheckReport = await healthCheckService.CheckHealthAsync(cts.Token);
Aspire.Playground.Tests (4)
ProjectSpecificTests.cs (1)
163return app.WaitForAllTextAsync(logTexts, resourceName, cts.Token);
tests\Aspire.Hosting.TestUtilities\Utils\LoggerNotificationExtensions.cs (3)
84_ = Task.Run(() => WatchNotifications(app, resourceName, predicate, tcs, watchCts), watchCts.Token); 132await foreach (var resourceEvent in app.ResourceNotifications.WatchAsync(cancellationTokenSource.Token).ConfigureAwait(false)) 162await foreach (var logEvent in resourceLoggerService.WatchAsync(resourceId).WithCancellation(cancellationTokenSource.Token).ConfigureAwait(false))
Aspire.Qdrant.Client.Tests (1)
QdrantHealthCheckTests.cs (1)
41var healthCheckReport = await healthCheckService.CheckHealthAsync(cts.Token);
Aspire.Seq.Tests (2)
SeqEndpointCanBeConfigured.cs (2)
82var serverTask = WriteResponseAsync(listener, HttpStatusCode.ServiceUnavailable, serverCts.Token); 95var healthCheckReport = await healthCheckService.CheckHealthAsync(cts.Token);
Aspire.Templates.Tests (3)
tests\Shared\TemplatesTesting\AspireProject.cs (2)
369await WaitForDashboardToBeAvailableAsync(dashboardUrlToUse, _testOutput, cts.Token).ConfigureAwait(false); 394}, cts.Token).ConfigureAwait(false);
tests\Shared\TemplatesTesting\ToolCommand.cs (1)
91return await ExecuteAsyncInternal(resolvedCommand, fullArgs, cts.Token);
Aspire.TerminalHost (19)
DcpUpstreamAdapter.cs (8)
205_connectedTcs.TrySetCanceled(_disposeCts.Token); 215stream = await _streamFactory(_disposeCts.Token).ConfigureAwait(false); 219_connectedTcs.TrySetCanceled(_disposeCts.Token); 236_readPump = Task.Run(() => ReadPumpAsync(_disposeCts.Token), _disposeCts.Token); 268await WriteFrameAsync(FrameResize, payload, _disposeCts.Token).ConfigureAwait(false); 306await stream.WriteAsync(header, _disposeCts.Token).ConfigureAwait(false); 309await stream.WriteAsync(payload, _disposeCts.Token).ConfigureAwait(false);
src\Shared\ParentProcessLivenessMonitor.cs (1)
26_monitorTask = MonitorAsync(parentPid, parentStartedUnix, onParentExited, timeProvider, useRuntimeStartTime, _stopCts.Token);
TerminalHostApp.cs (3)
107cancellationToken, _shutdownCts.Token); 108var token = linkedCts.Token; 404await host.StopAsync(stopCts.Token).ConfigureAwait(false);
TerminalHostControlListener.cs (1)
114_acceptLoop = Task.Run(() => AcceptLoopAsync(_disposeCts.Token));
TerminalHostProcessRunner.cs (2)
39forceExitCts.Token, 89return await TerminalHostApp.RunAsync(args, cts.Token).ConfigureAwait(false);
TerminalReplica.cs (4)
183_runTask = Task.Run(() => RecycleLoopAsync(_stopCts.Token), _stopCts.Token); 375_ = ApplyRestrictiveSocketPermissionsAsync(ProducerUdsPath, _stopCts.Token); 376_ = ApplyRestrictiveSocketPermissionsAsync(ConsumerUdsPath, _stopCts.Token);
Aspire.TerminalHost.Tests (14)
TerminalHostAppTests.cs (14)
54var hostTask = app.RunAsync(hostCts.Token); 77var hostTask = app.RunAsync(hostCts.Token); 109var hostTask = app.RunAsync(hostCts.Token); 137var hostTask = app.RunAsync(hostCts.Token); 196_ = await rpc.InvokeAsync<TerminalHostInfoResponse>(TerminalHostControlProtocol.GetInfoMethod).WaitAsync(cts.Token); 214var hostTask = app.RunAsync(hostCts.Token); 267var hostTask = app.RunAsync(hostCts.Token); 305var hostTask = app.RunAsync(hostCts.Token); 391var hostTask = app.RunAsync(hostCts.Token); 436var hostTask = app.RunAsync(hostCts.Token); 473var hostTask = app.RunAsync(hostCts.Token); 593var (type, payload) = await ReadFrameAsync(cts.Token).ConfigureAwait(false); 828var hostTask = app.RunAsync(hostCts.Token); 865var hostTask = app.RunAsync(hostCts.Token);
Aspire.TestTools (6)
GitHubCli.cs (6)
268var stdoutTask = process.StandardOutput.ReadToEndAsync(cts.Token); 269var stderrTask = process.StandardError.ReadToEndAsync(cts.Token); 273await process.WaitForExitAsync(cts.Token).ConfigureAwait(false); 321var stdoutTask = process.StandardOutput.BaseStream.CopyToAsync(outputStream, cts.Token); 322var stderrTask = process.StandardError.ReadToEndAsync(cts.Token); 326await Task.WhenAll(process.WaitForExitAsync(cts.Token), stdoutTask, stderrTask).ConfigureAwait(false);
csc (2)
src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (2)
314var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 315var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
CustomResources.AppHost (1)
TestResource.cs (1)
61while (await timer.WaitForNextTickAsync(_tokenSource.Token))
dotnet (17)
Commands\Test\MTP\CtrlCCancellationManager.cs (1)
56public CancellationToken Token => _cancellationTokenSource.Token;
Commands\Test\MTP\MicrosoftTestingPlatformTestCommand.cs (1)
190queueCancellation.Token);
Commands\Test\MTP\Terminal\TestProgressStateAwareTerminal.cs (1)
42while (!_cts.Token.WaitHandle.WaitOne(AnsiUpdateCadenceInMs))
Commands\Test\MTP\TestApplication.cs (4)
94var cancellationToken = _pipeCancellationTokenSource.Token; 416_pipeCancellationTokenSource.Token); 680_pipeCancellationTokenSource.Token.Register( 681() => completion.TrySetCanceled(_pipeCancellationTokenSource.Token));
Commands\Test\MTP\TestRunPolicy.cs (1)
60public CancellationToken Token => _cancellationTokenSource.Token;
NugetPackageDownloader\NuGetPackageDownloader.cs (5)
840GetPackageMetadataAsync(source, packageIdentifier, true, includeUnlisted, linkedCts.Token))]; 1012var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 1014return await autocomplete.VersionStartsWith(packageId.ToString(), versionPrefix: versionPrefix ?? "", includePrerelease: allowPrerelease, sourceCacheContext: _cacheSettings, log: NullLogger.Instance, token: linkedCts.Token); 1031var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 1033return await autocomplete.IdStartsWith(packageId.ToString(), includePrerelease: allowPrerelease, log: NullLogger.Instance, token: linkedCts.Token);
NugetSearch\NugetToolSearchApiRequest.cs (2)
30HttpResponseMessage response = await httpClient.GetAsync(queryUrl, cancellation.Token); 47return await response.Content.ReadAsStringAsync(cancellation.Token);
src\sdk\artifacts\.packages\microsoft.codeanalysis.buildclient\5.12.0-1.26426.103\contentFiles\cs\net11.0\BuildServerConnection.cs (2)
314var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 315var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
dotnet-aot (9)
src\sdk\src\Cli\dotnet\NugetPackageDownloader\NuGetPackageDownloader.cs (5)
840GetPackageMetadataAsync(source, packageIdentifier, true, includeUnlisted, linkedCts.Token))]; 1012var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 1014return await autocomplete.VersionStartsWith(packageId.ToString(), versionPrefix: versionPrefix ?? "", includePrerelease: allowPrerelease, sourceCacheContext: _cacheSettings, log: NullLogger.Instance, token: linkedCts.Token); 1031var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 1033return await autocomplete.IdStartsWith(packageId.ToString(), includePrerelease: allowPrerelease, log: NullLogger.Instance, token: linkedCts.Token);
src\sdk\src\Cli\dotnet\NugetSearch\NugetToolSearchApiRequest.cs (4)
30HttpResponseMessage response = await httpClient.GetAsync(queryUrl, cancellation.Token); 47return await response.Content.ReadAsStringAsync(cancellation.Token); 103response = await httpClient.GetAsync(serviceIndexUrl, cancellation.Token); 132var indexJson = await response.Content.ReadAsStringAsync(cancellation.Token);
dotnet-svcutil-lib (8)
FrameworkFork\System.ServiceModel\Internals\System\Runtime\TaskHelpers.cs (1)
168var completedTask = await Task.WhenAny(task, Task.Delay(timeout, cts.Token));
FrameworkFork\System.ServiceModel\Internals\System\Runtime\TimeoutHelper.cs (2)
310var token = tokenSource.Token; 326tokenTask = Task.FromResult(new CancellationTokenSource(millisecondsTimeout).Token);
FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpChannelFactory.cs (1)
937_httpResponseMessage = await _httpClient.SendAsync(_httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, _httpSendCts.Token);
FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\SslStreamSecurityUpgradeProvider.cs (3)
288SecurityToken token = _serverTokenProvider.GetTokenAsync(cts.Token).GetAwaiter().GetResult(); 527_clientToken = (X509SecurityToken)_clientCertificateProvider.GetTokenAsync(cts.Token).GetAwaiter().GetResult(); 541_clientToken = (X509SecurityToken)(await _clientCertificateProvider.GetTokenAsync(cts.Token));
Tool.cs (1)
71cancellationToken = cancellationSource.Token;
dotnet-watch (4)
Watch\DotNetWatcher.cs (4)
93using var combinedCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(shutdownCancellationToken, currentRunCancellationSource.Token); 98var processTask = context.ProcessRunner.RunAsync(processSpec, context.Logger, launchResult: null, combinedCancellationSource.Token); 107fileSetTask = fileSetWatcher.WaitForFileChangeAsync(evaluationResult.Files, startedWatching: null, combinedCancellationSource.Token); 112if (await staticFileHandler.HandleFileChangesAsync([fileSetTask.Result.Value], combinedCancellationSource.Token))
GenerateDocumentationAndConfigFiles (9)
src\roslyn\src\Dependencies\Threading\AsyncBatchingWorkQueue`2.cs (4)
127_cancellationSeries = new CancellationSeries(_entireQueueCancellationTokenSource.Token); 245await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 272_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested(); 280_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested();
src\roslyn\src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncPriorityWorkQueue.cs (2)
152await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 181await _processBatchAsync(enumerator, _entireQueueCancellationTokenSource.Token).ConfigureAwait(false);
Infrastructure.Tests (19)
CreateFailingTestIssue\CreateFailingTestIssueFixture.cs (1)
51await process.WaitForExitAsync(cancellationTokenSource.Token).ConfigureAwait(false);
CreateFailingTestIssue\CreateFailingTestIssueToolTests.cs (1)
656await process.WaitForExitAsync(cancellationTokenSource.Token).ConfigureAwait(false);
DownloadFailingJobLogs\DownloadFailingJobLogsToolTests.cs (1)
112await process.WaitForExitAsync(cancellationTokenSource.Token).ConfigureAwait(false);
ExtractTestPartitions\ExtractTestPartitionsFixture.cs (1)
39await process.WaitForExitAsync(cts.Token);
ExtractTestPartitions\ExtractTestPartitionsTests.cs (1)
340await process.WaitForExitAsync(cts.Token);
GenerateTestSummary\GenerateTestSummaryFixture.cs (1)
44await process.WaitForExitAsync(cancellationTokenSource.Token).ConfigureAwait(false);
GenerateTestSummary\GenerateTestSummaryToolTests.cs (1)
273await process.WaitForExitAsync(cancellationTokenSource.Token).ConfigureAwait(false);
Pipelines\NixCliPackageTests.cs (1)
244await process.WaitForExitAsync(cancellationTokenSource.Token);
PowerShellScripts\DownloadNativeArchivesTests.cs (1)
537_serverTask = Task.Run(() => RunAsync(_cts.Token));
PowerShellScripts\PowerShellCommand.cs (1)
66return await ExecuteAsyncInternal(cts.Token, args);
WorkflowScripts\ExtensionChangelogFinalizedWorkflowTests.cs (2)
339await process.WaitForExitAsync(timeout.Token); 503await process.WaitForExitAsync(timeout.Token);
WorkflowScripts\ExtensionReleaseWorkflowTests.cs (5)
617await process.WaitForExitAsync(timeout.Token); 666await process.WaitForExitAsync(timeout.Token); 745await process.WaitForExitAsync(timeout.Token); 782await process.WaitForExitAsync(timeout.Token); 848await process.WaitForExitAsync(timeout.Token);
WorkflowScripts\NodeCommand.cs (1)
60return await ExecuteScriptAsyncInternal(scriptPath, args, cts.Token).ConfigureAwait(false);
WorkflowScripts\PrDocsCheckWorkflowTests.cs (1)
198await process.WaitForExitAsync(timeout.Token);
Microsoft.Agents.AI.ProjectTemplates.Tests (2)
TestCommand.cs (2)
102await exitedTcs.Task.WaitAsync(timeoutCts.Token).ConfigureAwait(false); 103await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false);
Microsoft.AspNetCore.Components (2)
NavigationManager.cs (1)
430var cancellationToken = cts.Token;
Routing\Router.cs (1)
361var navigateContext = new NavigationContext(path, _onNavigateCts.Token);
Microsoft.AspNetCore.Components.AI (2)
Engine\AgentContext.cs (2)
92await StreamIntoTurnAsync(message, turn, _streamingCts.Token, cancellationToken); 114await StreamIntoTurnAsync(_lastMessage!, turn, _streamingCts.Token, cancellationToken);
Microsoft.AspNetCore.Components.Endpoints (3)
Builder\RazorComponentEndpointDataSource.cs (2)
60_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token); 174_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);
DependencyInjection\HotReloadService.cs (1)
25public IChangeToken GetChangeToken() => new CancellationChangeToken(_tokenSource.Token);
Microsoft.AspNetCore.Components.Forms (1)
EditContext.cs (1)
376task = validator(cts.Token);
Microsoft.AspNetCore.Components.Media (1)
MediaComponentBase.cs (1)
286return _loadCts.Token;
Microsoft.AspNetCore.Components.QuickGrid (1)
QuickGrid.razor.cs (1)
542startIndex, Pagination?.ItemsPerPage, _sortByColumn, _sortByAscending, thisLoadCts.Token);
Microsoft.AspNetCore.Components.Server (5)
Circuits\CircuitRegistry.cs (1)
155new CancellationChangeToken(cancellationTokenSource.Token),
Circuits\DefaultInMemoryCircuitPersistenceProvider.cs (1)
63ExpirationTokens = { new CancellationChangeToken(cancellationTokenSource.Token) },
Circuits\RemoteJSDataStream.cs (1)
259return new(linkedCts, linkedCts.Token);
Circuits\RemoteJSRuntime.cs (1)
197cancellationTokenSource.Token.Register(() =>
Circuits\RevalidatingServerAuthenticationStateProvider.cs (1)
43_ = RevalidationLoop(authenticationStateTask, _loopCancellationTokenSource.Token);
Microsoft.AspNetCore.Components.Web (4)
Forms\InputFile\BrowserFileStream.cs (2)
35OpenReadStreamTask = OpenReadStreamAsync(_openReadStreamCts.Token); 105return await stream.ReadAsync(destination, _copyFileDataCts.Token);
Virtualization\Virtualize.cs (2)
266var token = ourCts.Token; 957cancellationToken = refreshCts.Token;
Microsoft.AspNetCore.Components.WebAssembly.Server (2)
DebugProxyLauncher.cs (1)
87ctr = cts.Token.Register(() =>
TargetPickerUi.cs (1)
137var token = source.Token;
Microsoft.AspNetCore.Connections.Abstractions (1)
DefaultConnectionContext.cs (1)
55ConnectionClosed = _connectionClosedTokenSource.Token;
Microsoft.AspNetCore.DataProtection (1)
KeyManagement\XmlKeyManager.cs (1)
285return Interlocked.CompareExchange<CancellationTokenSource?>(ref _cacheExpirationTokenSource, null, null).Token;
Microsoft.AspNetCore.Diagnostics.Middleware (1)
Latency\RequestLatencyTelemetryMiddleware.cs (1)
93exports.Add(latencyDataExporter.ExportAsync(latencyData, tokenSource.Token));
Microsoft.AspNetCore.Hosting (7)
Internal\ApplicationLifetime.cs (3)
34public CancellationToken ApplicationStarted => _startedSource.Token; 40public CancellationToken ApplicationStopping => _stoppingSource.Token; 47public CancellationToken ApplicationStopped => _stoppedSource.Token;
Internal\WebHost.cs (1)
292cancellationToken = cts.Token;
WebHostExtensions.cs (3)
29await host.StopAsync(cts.Token); 56await host.WaitForTokenShutdownAsync(cts.Token); 98await host.RunAsync(cts.Token, "Application started. Press Ctrl+C to shut down.");
Microsoft.AspNetCore.Http (3)
Timeouts\CancellationTokenLinker.cs (1)
17var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(originalToken, timeoutCts.Token);
Timeouts\HttpRequestTimeoutFeature.cs (1)
15public CancellationToken RequestTimeoutToken => _timeoutCancellationTokenSource.Token;
Timeouts\RequestTimeoutsMiddleware.cs (1)
106context.RequestAborted = linkedCts.Token;
Microsoft.AspNetCore.Http.Connections (10)
Internal\HttpConnectionContext.cs (7)
123ConnectionClosed = _connectionClosedTokenSource.Token; 126ConnectionClosedRequested = _connectionCloseRequested.Token; 854var tokenSource = CancellationTokenSource.CreateLinkedTokenSource(Cancellation.Token, nonClonedContext.RequestAborted, timeoutSource.Token); 860var longPolling = new LongPollingServerTransport(timeoutSource.Token, Application.Input, loggerFactory, this); 863TransportTask = longPolling.ProcessRequestAsync(nonClonedContext, tokenSource.Token); 1021SendingToken = _sendCts.Token;
Internal\Transports\WebSocketsServerTransport.cs (3)
83var resultTask = await Task.WhenAny(sending, Task.Delay(_options.CloseTimeout, delayCts.Token)); 111var resultTask = await Task.WhenAny(receiving, Task.Delay(_options.CloseTimeout, delayCts.Token)); 133var token = _connection.Cancellation?.Token ?? default;
Microsoft.AspNetCore.Http.Connections.Client (9)
Internal\LongPollingTransport.cs (1)
76var receiving = Poll(url, _transportCts.Token);
Internal\ServerSentEventsTransport.cs (2)
93var receiving = ProcessEventStream(response, _transportCts.Token); 94var sending = SendUtils.SendMessages(url, _application, _httpClient, _logger, _inputCts.Token);
Internal\WebSocketsTransport.cs (6)
367var resultTask = await Task.WhenAny(sending, Task.Delay(_closeTimeout, _stopCts.Token)).ConfigureAwait(false); 443var result = await socket.ReceiveAsync(Memory<byte>.Empty, _stopCts.Token).ConfigureAwait(false); 461var receiveResult = await socket.ReceiveAsync(memory, _stopCts.Token).ConfigureAwait(false); 562await socket.SendAsync(buffer, _webSocketMessageType, _stopCts.Token).ConfigureAwait(false); 602await socket.CloseOutputAsync(error != null ? WebSocketCloseStatus.InternalServerError : WebSocketCloseStatus.NormalClosure, "", _stopCts.Token).ConfigureAwait(false); 608await socket.CloseAsync(error != null ? WebSocketCloseStatus.InternalServerError : WebSocketCloseStatus.NormalClosure, "", _stopCts.Token).ConfigureAwait(false);
Microsoft.AspNetCore.HttpLogging (2)
FileLoggerProcessor.cs (2)
131await WriteMessagesAsync(_currentBatch, _cancellationTokenSource.Token); 144await Task.Delay(_flushInterval, _cancellationTokenSource.Token);
Microsoft.AspNetCore.InternalTesting (2)
xunit\AspNetTestInvoker.cs (2)
44await lifecycleHook.OnTestStartAsync(context, CancellationTokenSource.Token).ConfigureAwait(false); 55await lifecycleHook.OnTestEndAsync(context, exception, CancellationTokenSource.Token).ConfigureAwait(false);
Microsoft.AspNetCore.Mvc (1)
HotReloadService.cs (1)
64IChangeToken IActionDescriptorChangeProvider.GetChangeToken() => new CancellationChangeToken(_tokenSource.Token);
Microsoft.AspNetCore.Mvc.Core (2)
Infrastructure\DefaultActionDescriptorCollectionProvider.cs (1)
165_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);
Routing\ActionEndpointDataSourceBase.cs (1)
135_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);
Microsoft.AspNetCore.Mvc.TagHelpers (1)
CacheTagHelper.cs (1)
95options.AddExpirationToken(new CancellationChangeToken(tokenSource.Token));
Microsoft.AspNetCore.OutputCaching.StackExchangeRedis (1)
RedisOutputCacheStore.cs (1)
105await ExecuteGarbageCollectionAsync(GetExpirationTimestamp(TimeSpan.Zero), _disposalCancellation.Token).ConfigureAwait(false);
Microsoft.AspNetCore.Routing (1)
CompositeEndpointDataSource.cs (1)
259_consumerChangeToken = new CancellationChangeToken(cts.Token);
Microsoft.AspNetCore.Server.HttpSys (2)
NativeInterop\DisconnectListener.cs (1)
60var returnToken = cts.Token;
RequestProcessing\RequestContext.cs (1)
61_disconnectToken = _requestAbortSource.Token;
Microsoft.AspNetCore.Server.IIS (1)
Core\IISHttpContext.IHttpRequestLifetimeFeature.cs (1)
38return _abortedCts.Token;
Microsoft.AspNetCore.Server.IntegrationTesting (3)
Deployers\SelfHostDeployer.cs (1)
201return (url: actualUrl ?? hintUrl, hostExitToken: hostExitTokenSource.Token);
src\aspnetcore\src\Shared\Process\ProcessEx.cs (2)
63_processTimeoutCts.Token.Register(() => 97public IEnumerable<string> OutputLinesAsEnumerable => _stdoutLines.GetConsumingEnumerable(_stdoutLinesCancellationSource.Token);
Microsoft.AspNetCore.Server.Kestrel.Core (11)
Internal\Http\HttpProtocol.cs (1)
321return _abortedCts.Token;
Internal\Http3\Http3Connection.cs (2)
365var streamContext = await _multiplexedContext.AcceptAsync(_acceptStreamsCts.Token); 372if (_acceptStreamsCts.Token.IsCancellationRequested)
Internal\Infrastructure\KestrelConnection.cs (1)
35ConnectionClosedRequested = _connectionClosingCts.Token;
Internal\KestrelServerImpl.cs (3)
361using var cts = CancellationTokenSource.CreateLinkedTokenSource(_stopCts.Token); 371await _transportManager.StopEndpointsAsync(configsToStop, cts.Token).ConfigureAwait(false); 392await listenOption.BindAsync(AddressBindContext!, _stopCts.Token).ConfigureAwait(false);
ListenOptionsHttpsExtensions.cs (1)
324await tlsListener.OnTlsClientHelloAsync(context, timeoutCts.Token);
Middleware\HttpsConnectionMiddleware.cs (3)
179await _tlsListener.OnTlsClientHelloAsync(context, cancellationTokenSource.Token); 183await DoOptionsBasedHandshakeAsync(context, sslStream, feature, cancellationTokenSource.Token); 188await sslStream.AuthenticateAsServerAsync(ServerOptionsCallback, state, cancellationTokenSource.Token);
Microsoft.AspNetCore.Server.Kestrel.Transport.DirectTls (2)
Connection\DirectTlsConnection.cs (1)
70ConnectionClosed = _connectionClosedTokenSource.Token;
Connection\DirectTlsConnectionListener.cs (1)
204var allPumpsExited = await _pumpPool.StopAndConfirmExitAsync(stopCts.Token);
Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes (2)
Internal\NamedPipeConnection.cs (1)
48ConnectionClosed = _connectionClosedTokenSource.Token;
Internal\NamedPipeConnectionListener.cs (1)
44_listeningToken = _listeningTokenSource.Token;
Microsoft.AspNetCore.Server.Kestrel.Transport.Quic (2)
Internal\QuicConnectionContext.cs (1)
43ConnectionClosed = _connectionClosedTokenSource.Token;
Internal\QuicStreamContext.cs (1)
128return _streamClosedTokenSource.Token;
Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets (1)
Internal\SocketConnection.cs (1)
59ConnectionClosed = _connectionClosedTokenSource.Token;
Microsoft.AspNetCore.Session (10)
DistributedSession.cs (10)
221cts.Token.ThrowIfCancellationRequested(); 222var data = await _cache.GetAsync(_sessionKey, cts.Token); 235throw new OperationCanceledException("Timed out loading the session.", oex, cts.Token); 257cts.Token.ThrowIfCancellationRequested(); 258var data = await _cache.GetAsync(_sessionKey, cts.Token); 278cts.Token.ThrowIfCancellationRequested(); 283cts.Token); 290throw new OperationCanceledException("Timed out committing the session.", oex, cts.Token); 297await _cache.RefreshAsync(_sessionKey, cts.Token); 302throw new OperationCanceledException("Timed out refreshing the session.", oex, cts.Token);
Microsoft.AspNetCore.SignalR.Client.Core (22)
HubConnection.cs (19)
315if (_state.StopCts.Token.IsCancellationRequested) 320using (CancellationTokenUtils.CreateLinkedToken(cancellationToken, _state.StopCts.Token, out var linkedToken)) 968var reader = await StreamAsChannelCoreAsync(methodName, typeof(T), args, cts.Token).ConfigureAwait(false); 972while (await reader.WaitToReadAsync(cts.Token).ConfigureAwait(false)) 1183createAndConsumeStream = () => ReadAsyncEnumeratorStream(AsyncEnumerableAdapters.MakeReflectionAsyncEnumeratorFromChannel(reader, tokenSource.Token)); 1190createAndConsumeStream = () => ReadAsyncEnumeratorStream(AsyncEnumerableAdapters.MakeReflectionAsyncEnumerator(reader, tokenSource.Token)); 1202while (await reader.WaitToReadAsync(tokenSource.Token).ConfigureAwait(false)) 1204while (!tokenSource.Token.IsCancellationRequested && reader.TryRead(out var item)) 1219await foreach (var streamValue in stream.WithCancellation(tokenSource.Token).ConfigureAwait(false)) 1230await SendWithLock(connectionState, new StreamItemMessage(streamId, item), tokenSource.Token).ConfigureAwait(false); 1824using (CancellationTokenUtils.CreateLinkedToken(cancellationToken, handshakeCts.Token, out var linkedToken)) 1918connectionState.UploadStreamToken = uploadStreamSource.Token; 2152await Task.Delay(nextRetryDelay.Value, _state.StopCts.Token).ConfigureAwait(false); 2163CompleteClose(GetOperationCanceledException("Connection stopped during reconnect delay. Done reconnecting.", ex, _state.StopCts.Token)); 2179await StartAsyncCore(_state.StopCts.Token).ConfigureAwait(false); 2200CompleteClose(GetOperationCanceledException("Connection stopped during reconnect attempt. Done reconnecting.", ex, _state.StopCts.Token)); 2257return new OperationCanceledException(message, innerException, _state.StopCts.Token); 2594var connectionToken = _hubConnection._state.StopCts.Token; 2601connectionToken = cts.Token;
src\aspnetcore\src\SignalR\common\Shared\AsyncEnumerableAdapters.cs (1)
84var enumerator = _asyncEnumerable.GetAsyncEnumerator(_cts.Token);
src\aspnetcore\src\SignalR\common\Shared\CreateLinkedToken.cs (1)
29linkedToken = cts.Token;
src\aspnetcore\src\SignalR\common\Shared\MessageBuffer.cs (1)
144using var _ = CancellationTokenUtils.CreateLinkedToken(cts.Token, cancellationToken, out var linkedToken);
Microsoft.AspNetCore.SignalR.Core (7)
HubConnectionContext.cs (2)
87ConnectionAborted = _connectionAbortedTokenSource.Token; 615using (var registration = cts.Token.UnsafeRegister(_cancelReader, input))
Internal\DefaultHubDispatcher.cs (2)
637await using var enumerator = descriptor.FromReturnedStream(result, streamCts.Token); 845arguments[parameterPointer] = cts.Token;
src\aspnetcore\src\SignalR\common\Shared\AsyncEnumerableAdapters.cs (1)
84var enumerator = _asyncEnumerable.GetAsyncEnumerator(_cts.Token);
src\aspnetcore\src\SignalR\common\Shared\CreateLinkedToken.cs (1)
29linkedToken = cts.Token;
src\aspnetcore\src\SignalR\common\Shared\MessageBuffer.cs (1)
144using var _ = CancellationTokenUtils.CreateLinkedToken(cts.Token, cancellationToken, out var linkedToken);
Microsoft.AspNetCore.SignalR.Specification.Tests (3)
HubLifetimeManagerTestBase.cs (1)
358var invoke1 = manager1.InvokeConnectionAsync<int>(connection1.ConnectionId, "Result", new object[] { "test" }, cts.Token);
Internal\TaskExtensions.cs (2)
25if (task == await Task.WhenAny(task, Task.Delay(timeout, cts.Token))) 49if (task == await Task.WhenAny(task, Task.Delay(timeout, cts.Token)))
Microsoft.AspNetCore.SignalR.StackExchangeRedis (1)
src\aspnetcore\src\SignalR\common\Shared\CreateLinkedToken.cs (1)
29linkedToken = cts.Token;
Microsoft.AspNetCore.SpaProxy (2)
SpaProxyLaunchManager.cs (2)
81var response = await httpClient.GetAsync(_options.ServerUrl, cancellationTokenSource.Token); 112var response = await httpClient.GetAsync(_options.ServerUrl, cancellationTokenSource.Token);
Microsoft.AspNetCore.SpaServices.Extensions (2)
AngularCli\AngularCliMiddleware.cs (1)
115cancellationTokenSource.Token);
Proxying\SpaProxy.cs (1)
64applicationStoppingToken).Token;
Microsoft.AspNetCore.StaticAssets (2)
StaticAssetEndpointDataSource.cs (2)
39_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token); 115_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);
Microsoft.AspNetCore.TestHost (1)
RequestLifetimeFeature.cs (1)
15RequestAborted = _cancellationTokenSource.Token;
Microsoft.Build (12)
BackEnd\BuildManager\BuildManager.cs (5)
1667_executionCancellationTokenSource!.Token); 1717_projectCacheService!.PostCacheRequest(cacheRequest, _executionCancellationTokenSource!.Token); 1797_executionCancellationTokenSource!.Token, 2314_projectCacheService!.InitializePluginsForGraph(projectGraph, submission.BuildRequestData.TargetNames, _executionCancellationTokenSource!.Token); 2826_projectCacheService.HandleBuildResultAsync(configuration, result, buildEventContext, _executionCancellationTokenSource!.Token).Wait();
BackEnd\Components\Communications\NodeProviderOutOfProcBase.cs (1)
1388await Task.Delay(100, _packetQueueDrainDelayCancellation.Token).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
BackEnd\Components\Logging\LoggingService.cs (1)
1487var completeAdding = _loggingEventProcessingCancellation.Token;
BackEnd\Components\RequestBuilder\RequestBuilder.cs (4)
679_cancellationTokenSource.Token, 699_cancellationTokenSource.Token, 711_cancellationTokenSource.Token, 1257allTargets, _requestEntry.RequestConfiguration.BaseLookup, _cancellationTokenSource.Token);
Logging\TerminalLogger\TerminalLogger.cs (1)
1476while (!_cts.Token.WaitHandle.WaitOne(1_000 / 30))
Microsoft.Build.Tasks.CodeAnalysis (4)
src\roslyn\src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (2)
575cancellationToken: _sharedCompileCts.Token); 577responseTask.Wait(_sharedCompileCts.Token);
src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (2)
314var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 315var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
Microsoft.Build.Tasks.Core (10)
AssemblyDependency\Node\OutOfProcRarNode.cs (2)
89Task nodeEndpointTasks = Task.Run(() => RunNodeEndpointsAsync(linkedCts.Token), linkedCts.Token);
DownloadFile.cs (1)
100CancellationToken cancellationToken = _cancellationTokenSource.Token;
FileIO\GetFileHash.cs (2)
85var parallelOptions = new ParallelOptions() { CancellationToken = _cancellationTokenSource.Token }; 99var hash = ComputeHash(algorithmFactory, filePath, _cancellationTokenSource.Token);
FileIO\VerifyFileHash.cs (1)
66byte[] hash = GetFileHash.ComputeHash(algorithmFactory, filePath, _cancellationTokenSource.Token);
src\msbuild\src\Shared\NodePipeServer.cs (1)
105await _pipeServer.WaitForConnectionAsync(cts.Token).ConfigureAwait(false);
TarDirectory.cs (1)
232CancellationToken cancellationToken = _cancellationTokenSource.Token;
Untar.cs (1)
364await tarEntry.ExtractToFileAsync(destinationPath.FullName, overwrite: true, _cancellationTokenSource.Token)
Unzip.cs (1)
280stream.CopyToAsync(destination, _DefaultCopyBufferSize, _cancellationToken.Token)
Microsoft.CodeAnalysis (2)
CommandLine\CommonCompiler.cs (2)
1150analyzerDriver.ApplyProgrammaticSuppressions(diagnostics, compilation, analyzerCts.Token); 1561analyzerCts.Token);
Microsoft.CodeAnalysis.Analyzers (12)
src\roslyn\src\Dependencies\Threading\AsyncBatchingWorkQueue`2.cs (4)
127_cancellationSeries = new CancellationSeries(_entireQueueCancellationTokenSource.Token); 245await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 272_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested(); 280_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested();
src\roslyn\src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\roslyn\src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncPriorityWorkQueue.cs (2)
152await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 181await _processBatchAsync(enumerator, _entireQueueCancellationTokenSource.Token).ConfigureAwait(false);
Microsoft.CodeAnalysis.AnalyzerUtilities (12)
src\roslyn\src\Dependencies\Threading\AsyncBatchingWorkQueue`2.cs (4)
127_cancellationSeries = new CancellationSeries(_entireQueueCancellationTokenSource.Token); 245await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 272_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested(); 280_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested();
src\roslyn\src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\roslyn\src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncPriorityWorkQueue.cs (2)
152await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 181await _processBatchAsync(enumerator, _entireQueueCancellationTokenSource.Token).ConfigureAwait(false);
Microsoft.CodeAnalysis.CodeStyle (12)
src\roslyn\src\Dependencies\Threading\AsyncBatchingWorkQueue`2.cs (4)
127_cancellationSeries = new CancellationSeries(_entireQueueCancellationTokenSource.Token); 245await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 272_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested(); 280_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested();
src\roslyn\src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\roslyn\src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncPriorityWorkQueue.cs (2)
152await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 181await _processBatchAsync(enumerator, _entireQueueCancellationTokenSource.Token).ConfigureAwait(false);
Microsoft.CodeAnalysis.CSharp (1)
CommandLine\CSharpCommandLineParser.cs (1)
299while (!Debugger.IsAttached && !timeoutSource.Token.IsCancellationRequested)
Microsoft.CodeAnalysis.Features (12)
AddImport\AbstractAddImportFeatureService.cs (5)
251linkedTokenSource.Token).ConfigureAwait(false); 253catch (OperationCanceledException ex) when (ex.CancellationToken == linkedTokenSource.Token) 308linkedTokenSource.Token).ConfigureAwait(false); 310catch (OperationCanceledException ex) when (ex.CancellationToken == linkedTokenSource.Token) 358linkedTokenSource.Token.ThrowIfCancellationRequested();
CodeFixes\Service\CodeFixService.cs (1)
123var linkedToken = linkedTokenSource.Token;
CodeLens\CodeLensFindReferenceProgress.cs (2)
43public CancellationToken CancellationToken => _aggregateCancellationTokenSource.Token; 97? GetPartialLocations(symbol, _aggregateCancellationTokenSource.Token)
CodeRefactorings\CodeRefactoringService.cs (2)
140if (cancellationToken.IsCancellationRequested || linkedTokenSource.Token.IsCancellationRequested) 148document, state, provider, linkedTokenSource.Token).ConfigureAwait(false);
ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.cs (1)
55_shutdownToken = _shutdownNotificationSource.Token;
ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingAsyncWorkItemQueue.cs (1)
237return source.Token;
Microsoft.CodeAnalysis.Features.ExternalAccess (2)
Copilot\Internal\SemanticSearch\CopilotSemanticSearchQueryExecutor.cs (2)
92cancellationSource.Token).ConfigureAwait(false); 121cancellationSource.Token).ConfigureAwait(false);
Microsoft.CodeAnalysis.ResxSourceGenerator (12)
src\roslyn\src\Dependencies\Threading\AsyncBatchingWorkQueue`2.cs (4)
127_cancellationSeries = new CancellationSeries(_entireQueueCancellationTokenSource.Token); 245await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 272_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested(); 280_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested();
src\roslyn\src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\roslyn\src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncPriorityWorkQueue.cs (2)
152await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 181await _processBatchAsync(enumerator, _entireQueueCancellationTokenSource.Token).ConfigureAwait(false);
Microsoft.CodeAnalysis.VisualBasic (1)
CommandLine\VisualBasicCommandLineParser.vb (1)
463While Not Debugger.IsAttached AndAlso Not timeoutSource.Token.IsCancellationRequested
Microsoft.CodeAnalysis.Workspaces (15)
Remote\IRemoteKeepAliveService.cs (4)
115session.KeepAliveTokenSource.Token).ConfigureAwait(false); 148session.KeepAliveTokenSource.Token, 155linkedTokenSource.Token).ConfigureAwait(false); 197var cancellationToken = this.KeepAliveTokenSource.Token;
Shared\TestHooks\AsynchronousOperationListener.cs (2)
48var expeditedDelayCancellationToken = _expeditedDelayCancellationTokenSource.Token; 57var delayTask = Task.Delay(delay, cancellationTokenSource.Token);
src\roslyn\src\Dependencies\Threading\AsyncBatchingWorkQueue`2.cs (4)
127_cancellationSeries = new CancellationSeries(_entireQueueCancellationTokenSource.Token); 245await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 272_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested(); 280_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested();
src\roslyn\src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncPriorityWorkQueue.cs (2)
152await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 181await _processBatchAsync(enumerator, _entireQueueCancellationTokenSource.Token).ConfigureAwait(false);
Microsoft.CodeAnalysis.Workspaces.MSBuild (1)
Rpc\RpcClient.cs (1)
58while ((line = await _receivingStreamReader.TryReadLineOrReturnNullIfCancelledAsync(_shutdownTokenSource.Token).ConfigureAwait(false)) != null)
Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (1)
Rpc\RpcServer.cs (1)
95while ((line = await _streamReader.TryReadLineOrReturnNullIfCancelledAsync(_shutdownTokenSource.Token).ConfigureAwait(false)) != null)
Microsoft.Diagnostics.NETCore.Client (34)
DiagnosticsIpc\IpcServerTransport.cs (4)
127using CancellationTokenSource linkedSource = CancellationTokenSource.CreateLinkedTokenSource(token, _cancellation.Token); 131await _stream.WaitForConnectionAsync(linkedSource.Token).ConfigureAwait(false); 199using CancellationTokenSource linkedSource = CancellationTokenSource.CreateLinkedTokenSource(token, _cancellation.Token); 203Socket socket = await _socket.AcceptAsync(linkedSource.Token).ConfigureAwait(false);
DiagnosticsServerRouter\DiagnosticsServerRouterFactory.cs (26)
229using CancellationTokenSource acceptTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, acceptTimeoutTokenSource.Token); 235NetServerEndpointInfo = await AcceptAsyncImpl(acceptTokenSource.Token).ConfigureAwait(false); 254using CancellationTokenSource connectTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, connectTimeoutTokenSource.Token); 261netServerStream = await Endpoint.ConnectAsync(connectTokenSource.Token).ConfigureAwait(false); 460using CancellationTokenSource connectTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, connectTimeoutTokenSource.Token); 471await ConnectAsyncInternal(clientSocket, clientTcpEndPoint, connectTokenSource.Token).ConfigureAwait(false); 583using CancellationTokenSource connectTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, connectTimeoutTokenSource.Token); 588ipcServerStream = await _ipcServer.AcceptAsync(connectTokenSource.Token).ConfigureAwait(false); 673using CancellationTokenSource connectTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, connectTimeoutTokenSource.Token); 795using Task<Stream> netServerStreamTask = _netServerRouterFactory.AcceptNetStreamAsync(cancelRouter.Token); 798using Task<Stream> ipcServerStreamTask = _ipcServerRouterFactory.AcceptIpcStreamAsync(cancelRouter.Token); 813using Task checkIpcStreamTask = IsStreamConnectedAsync(ipcServerStream, cancelRouter.Token); 850using Task checkTcpStreamTask = IsStreamConnectedAsync(tcpServerStream, cancelRouter.Token); 989ipcServerStream = await _ipcServerRouterFactory.AcceptIpcStreamAsync(cancelRouter.Token).ConfigureAwait(false); 992using Task<Stream> tcpClientStreamTask = _tcpClientRouterFactory.ConnectTcpStreamAsync(cancelRouter.Token); 996using Task checkIpcStreamTask = IsStreamConnectedAsync(ipcServerStream, cancelRouter.Token); 1123tcpServerStream = await _tcpServerRouterFactory.AcceptNetStreamAsync(cancelRouter.Token).ConfigureAwait(false); 1126using Task<Stream> ipcClientStreamTask = _ipcClientRouterFactory.ConnectIpcStreamAsync(cancelRouter.Token); 1130using Task checkTcpStreamTask = IsStreamConnectedAsync(tcpServerStream, cancelRouter.Token); 1268tcpClientStream = await _tcpClientRouterFactory.ConnectTcpStreamAsync(cancelRouter.Token, true).ConfigureAwait(false); 1271using Task<Stream> ipcClientStreamTask = _ipcClientRouterFactory.ConnectIpcStreamAsync(cancelRouter.Token); 1275using Task checkTcpStreamTask = IsStreamConnectedAsync(tcpClientStream, cancelRouter.Token); 1352using Task<int> readTask = ipcClientStream.ReadAsync(buffer, 0, buffer.Length, cancelReadConnect.Token); 1355using Task checkTcpStreamTask = IsStreamConnectedAsync(tcpClientStream, cancelReadConnect.Token); 1479_backendReadFrontendWriteTask = BackendReadFrontendWrite(_cancelRouterTokenSource.Token); 1480_frontendReadBackendWriteTask = FrontendReadBackendWrite(_cancelRouterTokenSource.Token);
HandleableCollection.cs (1)
144using CancellationTokenRegistration _ = cancellation.Token.Register(
ReversedServer\ReversedDiagnosticsServer.cs (3)
174_acceptTransportTask = AcceptTransportAsync(_transport, _disposalSource.Token); 274using CancellationTokenSource linkedSource = CancellationTokenSource.CreateLinkedTokenSource(token, parseCancellationSource.Token); 279advertise = await IpcAdvertise.ParseAsync(stream, linkedSource.Token).ConfigureAwait(false);
Microsoft.DotNet.Arcade.Sdk (2)
src\DownloadFile.cs (2)
180var httpResponse = await httpClient.GetAsync(uri, _cancellationSource.Token).ConfigureAwait(false); 207e is Tasks.TaskCanceledException && ((Tasks.TaskCanceledException)e).CancellationToken != _cancellationSource.Token)
Microsoft.DotNet.Build.Tasks.Installers (1)
src\ExecWithRetries.cs (1)
105Task.Delay(delay, _cancelTokenSource.Token).Wait();
Microsoft.DotNet.Cli.Telemetry (3)
Implementation\PersistentStorageTelemetryUploader.cs (1)
85var result = await _transport.TryUploadAsync(data, perBlobCts.Token).ConfigureAwait(false);
PersistentStorageLogExporter.cs (1)
109await uploader.DrainAsync(_drainCts.Token).ConfigureAwait(false);
PersistentStorageTraceExporter.cs (1)
117await uploader.DrainAsync(_drainCts.Token).ConfigureAwait(false);
Microsoft.DotNet.HotReload.Watch (27)
Build\ProjectBuildManager.cs (1)
50using var _ = buildCancellationTokenSource.Token.Register(manager.CancelAllSubmissions);
HotReload\HotReloadDotNetWatcher.cs (4)
88using var iterationCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(shutdownCancellationToken, forceRestartCancellationSource.Token); 89var iterationCancellationToken = iterationCancellationSource.Token; 516using var shutdownOrForcedRestartSource = CancellationTokenSource.CreateLinkedTokenSource(shutdownCancellationToken, forceRestartCancellationSource.Token); 522shutdownOrForcedRestartSource.Token);
HotReload\RunningProjectsManager.cs (5)
65using var processCommunicationCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(processTerminationSource.Token, processExitedSource.Token, cancellationToken); 66var processCommunicationCancellationToken = processCommunicationCancellationSource.Token; 103var processTask = processRunner.RunAsync(processSpec, clientLogger, launchResult, processTerminationSource.Token); 153applyOperationCancellationToken: processExitedSource.Token,
Process\ProcessRunner.cs (2)
272await process.WaitForExitAsync(cancellationSource.Token); 309await process.WaitForExitAsync(cancellationSource.Token);
Process\RunningProcess.cs (1)
18public readonly CancellationToken ExitedCancellationToken = exitedSource.Token;
src\sdk\src\Dotnet.Watch\AspireService\AspireServerService.cs (10)
245return app.RunAsync(_shutdownCancellationSource.Token); 276await context.Response.WriteAsJsonAsync(InfoResponse.Instance, JsonSerializerOptions, _shutdownCancellationSource.Token); 340var projectLaunchRequest = await context.GetProjectLaunchInformationAsync(_shutdownCancellationSource.Token); 350var sessionId = await _aspireServerEvents.StartProjectAsync(context.GetDcpId(), projectLaunchRequest, _shutdownCancellationSource.Token); 377await response.WriteAsJsonAsync(error, JsonSerializerOptions, _shutdownCancellationSource.Token); 384await response.WriteAsync(ex.GetMessageFromException(), _shutdownCancellationSource.Token); 398cancellationToken, _shutdownCancellationSource.Token, connection.HttpRequestAborted); 403await _webSocketAccess.WaitAsync(cancelTokenSource.Token); 406await connection.Socket.SendAsync(new ArraySegment<byte>(messageBytes), WebSocketMessageType.Text, endOfMessage: true, cancelTokenSource.Token); 438var sessionExists = await _aspireServerEvents.StopSessionAsync(context.GetDcpId(), sessionId, _shutdownCancellationSource.Token);
src\sdk\src\Dotnet.Watch\HotReloadClient\Web\AbstractBrowserRefreshServer.cs (3)
168while (!progressCancellationSource.Token.IsCancellationRequested) 170await Task.Delay(SuppressTimeouts ? TimeSpan.MaxValue : reportDelayInSeconds, progressCancellationSource.Token); 181}, progressCancellationSource.Token);
UI\ShutdownHandler.cs (1)
17CancellationToken = _cancellationSource.Token;
Microsoft.Extensions.AI.Abstractions.Tests (21)
ChatCompletion\ChatClientExtensionsTests.cs (8)
117Assert.Equal(cts.Token, cancellationToken); 123ChatResponse response = await client.GetResponseAsync("hello", expectedOptions, cts.Token); 144Assert.Equal(cts.Token, cancellationToken); 151await foreach (var update in client.GetStreamingResponseAsync("hello", expectedOptions, cts.Token)) 191Assert.Equal(cts.Token, cancellationToken); 197ChatResponse response = await client.GetResponseAsync([], expectedChatOptions, cts.Token); 231Assert.Equal(cts.Token, cancellationToken); 238await foreach (var update in client.GetStreamingResponseAsync([], expectedChatOptions, cts.Token))
ChatRouting\RoutingChatClientTests.cs (2)
48ChatResponse response = await router.GetResponseAsync(messages, options, cancellationSource.Token); 56Assert.Equal(cancellationSource.Token, observedToken);
Contents\DataContentTests.cs (3)
780await DataContent.LoadFromAsync(tempPath, cancellationToken: cts.Token)); 806await content.SaveToAsync(tempPath, cts.Token)); 829await DataContent.LoadFromAsync(ms, cancellationToken: cts.Token));
Embeddings\DelegatingEmbeddingGeneratorTests.cs (1)
26var expectedCancellationToken = cts.Token;
Image\ImageGeneratorTests.cs (2)
58Assert.Equal(cts.Token, cancellationToken); 63var result = await generator.GenerateAsync(expectedRequest, expectedOptions, cts.Token);
SpeechToText\SpeechToTextClientExtensionsTests.cs (1)
75cts.Token))
SpeechToText\SpeechToTextClientTests.cs (2)
36cts.Token); 64cts.Token))
TextToSpeech\TextToSpeechClientTests.cs (2)
29TextToSpeechResponse response = await client.GetAudioAsync("Hello, world!", expectedOptions, cts.Token); 54await foreach (var update in client.GetStreamingAudioAsync("Hello!", expectedOptions, cts.Token))
Microsoft.Extensions.AI.OpenAI.Tests (7)
OpenAIRealtimeClientSessionTests.cs (2)
72await Assert.ThrowsAsync<OperationCanceledException>(() => session.SendAsync(new RealtimeClientMessage(), cts.Token)); 91var ex = await Assert.ThrowsAnyAsync<Exception>(() => session.ConnectAsync(cts.Token));
OpenAIRealtimeClientTests.cs (1)
58var ex = await Assert.ThrowsAnyAsync<Exception>(() => client.CreateSessionAsync(cancellationToken: cts.Token));
OpenAISpeechToTextClientTests.cs (2)
115=> client.GetTextAsync(fileStream, cancellationToken: cancellationTokenSource.Token)); 130.GetStreamingTextAsync(fileStream, cancellationToken: cancellationTokenSource.Token)
OpenAITextToSpeechClientTests.cs (2)
228=> client.GetAudioAsync("Hello world", cancellationToken: cancellationTokenSource.Token)); 242.GetStreamingAudioAsync("Hello world", cancellationToken: cancellationTokenSource.Token)
Microsoft.Extensions.AI.Templates.Tests (2)
TestCommand.cs (2)
102await exitedTcs.Task.WaitAsync(timeoutCts.Token).ConfigureAwait(false); 103await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false);
Microsoft.Extensions.AI.Tests (80)
ChatCompletion\ConfigureOptionsChatClientTests.cs (4)
46Assert.Equal(cts.Token, cancellationToken); 53Assert.Equal(cts.Token, cancellationToken); 76var response = await client.GetResponseAsync(Array.Empty<ChatMessage>(), providedOptions, cts.Token); 80await using var e = client.GetStreamingResponseAsync(Array.Empty<ChatMessage>(), providedOptions, cts.Token).GetAsyncEnumerator();
ChatCompletion\FunctionInvokingChatClientApprovalsTests.cs (8)
1477Assert.Equal(cts.Token, actualCancellationToken); 1496var updates = service.GetStreamingResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(input), options, cts.Token); 1553Assert.Equal(cts.Token, actualCancellationToken); 1577var updates = service.GetStreamingResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(input), options, cts.Token); 1968Assert.Equal(cts.Token, actualCancellationToken); 1987var result = await service.GetResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(CloneInput(input)), options, cts.Token); 2055Assert.Equal(cts.Token, actualCancellationToken); 2069var result = await service.GetStreamingResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(CloneInput(input)), options, cts.Token).ToChatResponseAsync();
ChatCompletion\FunctionInvokingChatClientTests.cs (4)
2217Assert.Equal(cts.Token, actualCancellationToken); 2234var result = await service.GetResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(chat), options, cts.Token); 2286Assert.Equal(cts.Token, actualCancellationToken); 2298var result = await service.GetStreamingResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(chat), options, cts.Token).ToChatResponseAsync();
ChatCompletion\UseDelegateChatClientTests.cs (19)
40Assert.Equal(expectedCts.Token, cancellationToken); 49Assert.Equal(expectedCts.Token, cancellationToken); 60Assert.Equal(expectedCts.Token, cancellationToken); 67ChatResponse response = await client.GetResponseAsync(expectedMessages, expectedOptions, expectedCts.Token); 71response = await client.GetStreamingResponseAsync(expectedMessages, expectedOptions, expectedCts.Token).ToChatResponseAsync(); 89Assert.Equal(expectedCts.Token, cancellationToken); 100Assert.Equal(expectedCts.Token, cancellationToken); 110ChatResponse response = await client.GetResponseAsync(expectedMessages, expectedOptions, expectedCts.Token); 113response = await client.GetStreamingResponseAsync(expectedMessages, expectedOptions, expectedCts.Token).ToChatResponseAsync(); 131Assert.Equal(expectedCts.Token, cancellationToken); 142Assert.Equal(expectedCts.Token, cancellationToken); 161ChatResponse response = await client.GetResponseAsync(expectedMessages, expectedOptions, expectedCts.Token); 164response = await client.GetStreamingResponseAsync(expectedMessages, expectedOptions, expectedCts.Token).ToChatResponseAsync(); 182Assert.Equal(expectedCts.Token, cancellationToken); 191Assert.Equal(expectedCts.Token, cancellationToken); 203Assert.Equal(expectedCts.Token, cancellationToken); 213Assert.Equal(expectedCts.Token, cancellationToken); 232ChatResponse response = await client.GetResponseAsync(expectedMessages, expectedOptions, expectedCts.Token); 235response = await client.GetStreamingResponseAsync(expectedMessages, expectedOptions, expectedCts.Token).ToChatResponseAsync();
ChatReduction\SummarizingChatReducerTests.cs (1)
291reducer.ReduceAsync(messages, cts.Token));
ChatRouting\FailoverChatClientTests.cs (8)
84cancellationToken: cancellationSource.Token).ToChatResponseAsync() 87cancellationToken: cancellationSource.Token); 530cancellationToken: cancellationSource.Token)); 558cancellationToken: cancellationSource.Token)); 591cancellationToken: cancellationSource.Token)); 687cancellationToken: cancellationSource.Token))); 731cancellationToken: cancellationSource.Token))); 956cancellationToken: cancellationSource.Token)));
ChatRouting\OrderedFailoverChatClientTests.cs (1)
316cancellationToken: cancellationSource.Token));
Embeddings\ConfigureOptionsEmbeddingGeneratorTests.cs (2)
43Assert.Equal(cts.Token, cancellationToken); 66var embeddings = await generator.GenerateAsync([], providedOptions, cts.Token);
Embeddings\UseDelegateEmbeddingGeneratorTests.cs (3)
39Assert.Equal(expectedCts.Token, cancellationToken); 50Assert.Equal(expectedCts.Token, cancellationToken); 60GeneratedEmbeddings<Embedding<float>> actual = await generator.GenerateAsync(expectedValues, expectedOptions, expectedCts.Token);
Functions\AIFunctionFactoryTest.cs (17)
198foreach (CancellationToken ctArg in new[] { cts.Token, default }) 986Assert.Equal(cts.Token, cancellationToken); 991object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 1009Assert.Equal(cts.Token, cancellationToken); 1014object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 1032Assert.Equal(cts.Token, cancellationToken); 1037object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 1055Assert.Equal(cts.Token, cancellationToken); 1060object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 1078Assert.Equal(cts.Token, cancellationToken); 1083object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 1101Assert.Equal(cts.Token, cancellationToken); 1106object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 1124Assert.Equal(cts.Token, cancellationToken); 1129object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 1147Assert.Equal(cts.Token, cancellationToken); 1153object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token);
Image\ConfigureOptionsImageGeneratorTests.cs (2)
43Assert.Equal(cts.Token, cancellationToken); 67var response1 = await generator.GenerateImagesAsync("test prompt", providedOptions, cts.Token);
Realtime\LoggingRealtimeClientTests.cs (3)
229await Assert.ThrowsAsync<OperationCanceledException>(() => session.SendAsync(new SessionUpdateRealtimeClientMessage(new RealtimeSessionOptions()), cts.Token)); 298await foreach (var message in session.GetStreamingResponseAsync(cts.Token)) 394session.SendAsync(new RealtimeClientMessage { MessageId = "evt_cancel" }, cts.Token));
SpeechToText\ConfigureOptionsSpeechToTextClientTests.cs (4)
47Assert.Equal(cts.Token, cancellationToken); 54Assert.Equal(cts.Token, cancellationToken); 78var response = await client.GetTextAsync(audioSpeechStream, providedOptions, cts.Token); 83await using var e = client.GetStreamingTextAsync(audioSpeechStream2, providedOptions, cts.Token).GetAsyncEnumerator();
TextToSpeech\ConfigureOptionsTextToSpeechClientTests.cs (4)
46Assert.Equal(cts.Token, cancellationToken); 53Assert.Equal(cts.Token, cancellationToken); 76var response = await client.GetAudioAsync("Hello, world!", providedOptions, cts.Token); 80await using var e = client.GetStreamingAudioAsync("Hello, world!", providedOptions, cts.Token).GetAsyncEnumerator();
Microsoft.Extensions.Caching.Hybrid (2)
Internal\DefaultHybridCache.L2.cs (1)
144BufferChunk buffer = await GetFromL2DirectAsync(TagKeyPrefix + tag, cts.Token).ConfigureAwait(false);
Internal\DefaultHybridCache.StampedeState.cs (1)
50SharedToken = _sharedCancellation.Token;
Microsoft.Extensions.Caching.Hybrid.Tests (8)
StampedeTests.cs (8)
92var token = cts?.Token ?? CancellationToken.None; 206}, cancellationToken: cancels[i].Token).AsTask(); 229Assert.Equal(cancels[i].Token, ex.CancellationToken); // each gets the correct blame 287}, cancellationToken: cancels[i].Token).AsTask(); 315Assert.Equal(cancels[i].Token, ex.CancellationToken); // each gets the correct blame 340var token = cts?.Token ?? CancellationToken.None; 380var token = cts?.Token ?? CancellationToken.None; 424var token = cts?.Token ?? CancellationToken.None;
Microsoft.Extensions.Configuration (1)
ConfigurationReloadToken.cs (1)
42_cts.Token,
Microsoft.Extensions.DataIngestion.Tests (2)
Readers\DocumentReaderConformanceTests.cs (2)
42await Assert.ThrowsAsync<TaskCanceledException>(async () => await reader.ReadAsync(stream, "id", "mediaType", cts.Token)); 61await Assert.ThrowsAsync<TaskCanceledException>(async () => await reader.ReadAsync(new FileInfo(filePath), cts.Token));
Microsoft.Extensions.Diagnostics.ExceptionSummarization.Tests (2)
ExceptionSummarizerTests.cs (1)
214var task = Task.Run(() => { }, tokenSource.Token);
HttpExceptionSummaryProviderTests.cs (1)
122var task = Task.Run(() => { }, tokenSource.Token);
Microsoft.Extensions.Diagnostics.HealthChecks (3)
DefaultHealthCheckService.cs (1)
103checkCancellationToken = timeoutCancellationTokenSource.Token;
HealthCheckPublisherHostedService.cs (2)
154cancellation = CancellationTokenSource.CreateLinkedTokenSource(_stopping.Token); 158await RunAsyncCore(timerOptions, cancellation.Token).ConfigureAwait(false);
Microsoft.Extensions.Diagnostics.HealthChecks.Common.Tests (3)
MockHostApplicationLifetime.cs (3)
24ApplicationStarted = _started.Token; 25ApplicationStopping = _stopping.Token; 26ApplicationStopped = _stopped.Token;
Microsoft.Extensions.Diagnostics.Probes.Tests (5)
TcpEndpointProbesServiceTests.cs (5)
42await tcpEndpointProbesService.StartAsync(cts.Token); 43await tcpEndpointProbesService.UpdateHealthStatusAsync(cts.Token); 52await tcpEndpointProbesService.UpdateHealthStatusAsync(cts.Token); 61await tcpEndpointProbesService.UpdateHealthStatusAsync(cts.Token); 92await tcpEndpointProbesService.StartAsync(cts.Token);
Microsoft.Extensions.Diagnostics.Testing (2)
Logging\FakeLogCollector.LogEnumeration.cs (1)
114var mainCancellationToken = _mainCts.Token;
Metrics\MetricCollector.cs (1)
258await WaitForMeasurementsAsync(minCount, cancellationTokenSource.Token).ConfigureAwait(false);
Microsoft.Extensions.Diagnostics.Testing.Tests (2)
Logging\FakeLogCollectorTests.LogEnumeration.cs (1)
33var cancellationToken = cts.Token;
Metrics\MetricCollectorTests.cs (1)
284var wait = collector.WaitForMeasurementsAsync(1, cts.Token);
Microsoft.Extensions.DotNetDeltaApplier (1)
src\sdk\src\Dotnet.Watch\HotReloadAgent.Host\WebSocketTransport.cs (1)
61await _webSocket.ConnectAsync(new Uri(serverUrl), connectCts.Token).ConfigureAwait(false);
Microsoft.Extensions.FileProviders.Physical (5)
PhysicalFilesWatcher.cs (3)
212var cancellationChangeToken = new CancellationChangeToken(cancellationTokenSource.Token); 256var cancellationChangeToken = new CancellationChangeToken(cancellationTokenSource.Token); 917Token = _cts.Token;
PollingFileChangeToken.cs (1)
83_changeToken = new CancellationChangeToken(_tokenSource.Token);
PollingWildCardChangeToken.cs (1)
80_changeToken = new CancellationChangeToken(_tokenSource.Token);
Microsoft.Extensions.Hosting (5)
Internal\ApplicationLifetime.cs (3)
36public CancellationToken ApplicationStarted => _startedSource.Token; 39public CancellationToken ApplicationStopping => _stoppingSource.Token; 42public CancellationToken ApplicationStopped => _stoppedSource.Token;
Internal\Host.cs (2)
83cancellationToken = cts.Token; 326cancellationToken = cts.Token;
Microsoft.Extensions.Hosting.Abstractions (2)
BackgroundService.cs (1)
44CancellationToken stoppingToken = _stoppingCts.Token;
HostingAbstractionsHostExtensions.cs (1)
35await host.StopAsync(cts.Token).ConfigureAwait(false);
Microsoft.Extensions.Hosting.Testing (8)
FakeHost.cs (6)
74await _host.StartAsync(cancellationTokenSource.Token).ConfigureAwait(false); 80cancellationTokenSource.Token); 81await _host.StartAsync(linkedTokenSource.Token).ConfigureAwait(false); 97await _host.StopAsync(cancellationTokenSource.Token).ConfigureAwait(false); 103cancellationTokenSource.Token); 104await _host.StopAsync(linkedTokenSource.Token).ConfigureAwait(false);
HostTerminatorService.cs (2)
56timeoutTokenSource.Token); 59await _host.StopAsync(combinedTokenSource.Token).ConfigureAwait(false);
Microsoft.Extensions.Hosting.Testing.Tests (11)
FakeHostTests.cs (8)
84.Setup(x => x.StartAsync(It.Is<CancellationToken>(y => y != tokenSource.Token))) 90await sut.StartAsync(tokenSource.Token); 103.Setup(x => x.StartAsync(It.Is<CancellationToken>(y => y != cancellationTokenSource.Token))) 110_ = sut.StartAsync(cancellationTokenSource.Token); 143.Setup(x => x.StopAsync(It.Is<CancellationToken>(y => y != tokenSource.Token))) 149await sut.StopAsync(tokenSource.Token); 163.Setup(x => x.StopAsync(It.Is<CancellationToken>(y => y != cancellationTokenSource.Token))) 170_ = sut.StopAsync(cancellationTokenSource.Token);
HostingFakesExtensionsTests.cs (3)
31serviceMock.Setup(x => x.StartAsync(tokenSource.Token)).Returns(Task.CompletedTask); 32serviceMock.Setup(x => x.StopAsync(tokenSource.Token)).Returns(Task.CompletedTask); 34await serviceMock.Object.StartAndStopAsync(tokenSource.Token);
Microsoft.Extensions.Http.Diagnostics (2)
Logging\Internal\HttpRequestBodyReader.cs (1)
66return await ReadFromStreamAsync(request, readSizeLimit, joinedTokenSource.Token).ConfigureAwait(false);
Logging\Internal\HttpResponseBodyReader.cs (1)
83return await ReadFromStreamAsync(response, readSizeLimit, joinedTokenSource.Token).ConfigureAwait(false);
Microsoft.Extensions.Http.Diagnostics.Tests (2)
Logging\HttpResponseBodyReaderTest.cs (2)
188var responseBody = await httpResponseBodyReader.ReadAsync(httpResponse, cts.Token); 199var act = async () => await responseStream.ReadAsync(buffer, 0, BodySize, cts.Token);
Microsoft.Extensions.Http.Resilience.PerformanceTests (2)
RetryBenchmark.cs (1)
30_cancellationToken = new CancellationTokenSource().Token;
StandardResilienceBenchmark.cs (1)
30_cancellationToken = new CancellationTokenSource().Token;
Microsoft.Extensions.Http.Resilience.Tests (11)
Hedging\HedgingTests.cs (9)
107using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 127using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 152async () => await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token)); 174async () => await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token)); 200using var result = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 224using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 250using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 277using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 300using var result = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token);
Resilience\ResilienceHandlerTest.cs (2)
135cancellationToken.Should().Be(source.Token); 140var response = await InvokeHandler(invoker, request, asynchronous, source.Token);
Microsoft.Extensions.Logging.AzureAppServices (3)
BatchingLoggerProvider.cs (3)
110await WriteMessagesAsync(_currentBatch, _cancellationTokenSource.Token).ConfigureAwait(false); 121await IntervalAsync(_interval, _cancellationTokenSource.Token).ConfigureAwait(false); 143if (!_messageQueue.TryAdd(new LogMessage(timestamp, message), millisecondsTimeout: 0, cancellationToken: _cancellationTokenSource.Token))
Microsoft.Extensions.Logging.EventSource (1)
LoggingEventSource.cs (1)
402return new CancellationChangeToken(cts.Token);
Microsoft.Extensions.ML (2)
ModelLoaders\UriModelLoader.cs (1)
77cancellation = CancellationTokenSource.CreateLinkedTokenSource(_stopping.Token);
ModelReloadToken.cs (1)
42public IDisposable RegisterChangeCallback(Action<object> callback, object state) => _cts.Token.Register(callback, state);
Microsoft.Extensions.Primitives (2)
CompositeChangeToken.cs (2)
60return _cancellationTokenSource.Token.Register(callback, state); 68if (_cancellationTokenSource != null && _cancellationTokenSource.Token.IsCancellationRequested)
Microsoft.Extensions.ServiceDiscovery (2)
ServiceEndpointWatcher.cs (2)
80var disposalToken = _disposalCancellation.Token; 132var cancellationToken = _disposalCancellation.Token;
Microsoft.Extensions.ServiceDiscovery.Dns (6)
DnsServiceEndpointProviderBase.cs (3)
43_lastChangeToken = new CancellationChangeToken(cancellation.Token); 58protected CancellationToken ShutdownToken => _disposeCancellation.Token; 130_lastChangeToken = new CancellationChangeToken(cancellation.Token);
Resolver\DnsResolver.cs (3)
486return await SendQueryToServerAsync(serverEndPoint, name, dnsSafeName, queryType, attempt, cts.Token).ConfigureAwait(false); 493Debug.Assert(cts.Token.IsCancellationRequested); 896CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, pendingRequestsCts.Token);
Microsoft.Extensions.ServiceDiscovery.Dns.Tests (4)
Resolver\CancellationTests.cs (4)
21var ex = await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await Resolver.ResolveIPAddressesAsync("example.com", AddressFamily.InterNetwork, cts.Token)); 23Assert.Equal(cts.Token, ex.CancellationToken); 31var task = Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await Resolver.ResolveIPAddressesAsync("example.com", AddressFamily.InterNetwork, cts.Token)); 40Assert.Equal(cts.Token, ex.CancellationToken);
Microsoft.Extensions.ServiceDiscovery.Tests (7)
ServiceEndpointResolverTests.cs (7)
92collection.AddChangeToken(new CancellationChangeToken(cts[0].Token)); 95if (cts[0].Token.IsCancellationRequested) 144collection.AddChangeToken(new CancellationChangeToken(cts[0].Token)); 147if (cts[0].Token.IsCancellationRequested) 180collection.AddChangeToken(new CancellationChangeToken(cts[0].Token)); 183if (cts[0].Token.IsCancellationRequested) 232collection.AddChangeToken(new CancellationChangeToken(cts[0].Token));
Microsoft.Extensions.TimeProvider.Testing.Tests (5)
FakeTimeProviderTests.cs (5)
318var delay = timeProvider.Delay(_infiniteTimeout, cs.Token); 334var task = fakeTimeProvider.Delay(TimeSpan.FromMilliseconds(10000), cancellationTokenSource.Token); 340Assert.False(cancellationTokenSource.Token.IsCancellationRequested); 351await Assert.ThrowsAsync<TaskCanceledException>(() => timeProvider.Delay(TimeSpan.FromTicks(1), cts.Token)); 433var t = source.Task.WaitAsync(_infiniteTimeout, timeProvider, cts.Token);
Microsoft.JSInterop (11)
JSObjectReferenceExtensions.cs (5)
98var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 116var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 166var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 184var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 203var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None;
JSRuntime.cs (1)
128return await InvokeAsync<TValue>(targetInstanceId, identifier, callType, cts.Token, args);
JSRuntimeExtensions.cs (5)
98var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 116var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 166var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 184var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 203var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None;
Microsoft.Maui (1)
ImageSources\ImageSourceServiceResultManager.cs (1)
30 _sourceCancellation?.Token ?? default;
Microsoft.Maui.Controls (2)
StreamImageSource.cs (1)
43 stream = await Stream(CancellationTokenSource.Token);
UriImageSource.cs (1)
65 stream = await GetStreamAsync(Uri, CancellationTokenSource.Token);
Microsoft.Maui.Essentials (1)
Types\Shared\Utils.shared.cs (1)
31 return cancelTokenSrc.Token;
Microsoft.Maui.Resizetizer (1)
AsyncTask.cs (1)
41 public CancellationToken CancellationToken => cts.Token;
Microsoft.ML.AutoML (3)
AutoMLExperiment\AutoMLExperiment.cs (2)
254var stopTrialManager = new CancellationTokenStopTrainingManager(trialCancellationTokenSource.Token, null); 273var trialResult = await runner.RunAsync(trialSettings, trialCancellationTokenSource.Token);
AutoMLExperiment\IStopTrainingManager.cs (1)
68_cancellationTokenTrainingStopManager = new CancellationTokenStopTrainingManager(_cts.Token, channel);
Microsoft.ML.AutoML.Tests (5)
AutoMLExperimentTests.cs (3)
57var runExperimentAction = async () => await experiment.RunAsync(cts.Token); 143var res = await experiment.RunAsync(cts.Token); 176var res = await experiment.RunAsync(cts.Token);
StopTrainingManagerTests.cs (2)
29var manager = new CancellationTokenStopTrainingManager(cts.Token, null); 74var cancellationManager = new CancellationTokenStopTrainingManager(cts.Token, null);
Microsoft.ML.Core (2)
Utilities\ResourceManagerUtils.cs (1)
160var t = Task.Run(() => DownloadResource(env, ch, client, new Uri(url), filePath, fileName, downloadCancel.Token));
Utilities\ThreadUtils.cs (1)
192public CancellationToken Token => _ctSource.Token;
Microsoft.ML.Maml (1)
MAML.cs (1)
65var progressTrackerTask = Task.Run(() => TrackProgress(env, progressCancel.Token));
Microsoft.ML.Sweeper (1)
AsyncSweeper.cs (1)
282return await _paramChannel.Reader.ReadAsync(_cts.Token);
Microsoft.ML.TestFrameworkCommon (2)
TestDownloadUtils.cs (2)
31using (var response = client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cancellationSource.Token).GetAwaiter().GetResult()) 38contentStream.CopyToAsync(fileStream, 81920, cancellationSource.Token).GetAwaiter().GetResult();
Microsoft.NET.Build.Containers (4)
LocalDaemons\ContainerRuntime.cs (1)
197return await runtime.ProbeAsync(timeout.Token).ConfigureAwait(false);
LocalDaemons\ContainerRuntimeOperations.cs (1)
61Task<ProcessTextOutput> loadTask = Process.RunAndCaptureTextAsync(loadInfo, processCancellation.Token);
Tasks\CreateImageIndex.cs (1)
32Task.Run(() => ExecuteAsync(_cancellationTokenSource.Token)).GetAwaiter().GetResult();
Tasks\CreateNewImage.cs (1)
42Task.Run(() => ExecuteAsync(_cancellationTokenSource.Token)).GetAwaiter().GetResult();
Microsoft.NET.Sdk.Publish.Tasks (3)
Tasks\OneDeploy\OneDeployStatusService.cs (2)
41var retryTokenSource = CancellationTokenSource.CreateLinkedTokenSource(maxWaitForResultTokenSource.Token, cancellationToken); 42var retryToken = retryTokenSource.Token;
Tasks\ZipDeploy\ZipDeploymentStatus.cs (1)
79response = await _client.GetRequestAsync(new Uri(url, UriKind.RelativeOrAbsolute), userName, password, _userAgent, cts.Token);
Microsoft.NET.Sdk.Razor.Tasks (4)
DotnetToolTask.cs (2)
164var responseTask = ServerConnection.RunOnServer(PipeName, arguments, serverPaths, _razorServerCts.Token, debug: DebugTool); 165responseTask.Wait(_razorServerCts.Token);
src\sdk\src\RazorSdk\Tool\ServerProtocol\ServerConnection.cs (2)
247var responseTask = ServerResponse.ReadAsync(client.Stream, serverCts.Token); 248var monitorTask = client.WaitForDisconnectAsync(serverCts.Token);
Microsoft.TemplateEngine.Cli (6)
Commands\create\InstantiateCommand.TabCompletion.cs (4)
145Task<IEnumerable<CliTemplateInfo>> constraintEvaluationTask = templateGroup.GetAllowedTemplatesAsync(constraintManager, cancellationTokenSource.Token); 150await constraintEvaluationTask.WaitAsync(cancellationTokenSource.Token).ConfigureAwait(false); 180tasksToWait.Add((group, group.GetAllowedTemplatesAsync(constraintManager, cancellationTokenSource.Token))); 197await Task.WhenAll(tasksToWait.Select(t => t.Task)).WaitAsync(cancellationTokenSource.Token).ConfigureAwait(false);
Commands\create\TemplateCommand.cs (2)
174Task<IReadOnlyList<TemplateConstraintResult>> constraintsEvaluation = ValidateConstraintsAsync(constraintManager, args.Template, args.IsForceFlagSpecified ? cancellationTokenSource.Token : cancellationToken); 221IReadOnlyList<TemplateConstraintResult> constraintResults = await constraintsEvaluation.WaitAsync(cancellationTokenSource.Token).ConfigureAwait(false);
Microsoft.TemplateEngine.Edge (3)
BuiltInManagedProvider\GlobalSettings.cs (1)
211using (await LockAsync(cts.Token).ConfigureAwait(false))
Installers\NuGet\NugetApiPackageManager.cs (1)
328sources.Select(source => GetPackageMetadataAsync(source, packageIdentifier, includePrerelease: true, linkedCts.Token)).ToList();
TemplateConstraintManager.cs (1)
27_templateConstrains[constraintFactory.Type] = Task.Run(() => constraintFactory.CreateTemplateConstraintAsync(engineEnvironmentSettings, _cancellationTokenSource.Token));
Microsoft.TestPlatform.CommunicationUtilities (4)
DataCollectionRequestHandler.cs (2)
366_cancellationTokenSource.Token); 388_testCaseEventMonitorTask?.Wait(_cancellationTokenSource.Token);
SocketClient.cs (1)
110_cancellation.Token))
SocketServer.cs (1)
180_ = Task.Run(() => client.MessageLoopAsync(_channel, error => StopOnError(error), _cancellation.Token));
Microsoft.TestPlatform.CrossPlatEngine (9)
Client\ProxyExecutionManager.cs (1)
152_proxyOperationManager.CancellationTokenSource.Token.ThrowTestPlatformExceptionIfCancellationRequested();
Client\ProxyExecutionManagerWithDataCollection.cs (2)
87internal CancellationToken CancellationToken => CancellationTokenSource.Token; 131currentEventHandler = new DataCollectionTestRunEventsHandler(eventHandler, ProxyDataCollectionManager, CancellationTokenSource.Token);
Client\ProxyOperationManager.cs (5)
186CancellationTokenSource.Token.ThrowTestPlatformExceptionIfCancellationRequested(); 241CancellationTokenSource.Token).Result; 253CancellationTokenSource.Token.ThrowTestPlatformExceptionIfCancellationRequested(); 287CancellationTokenSource.Token)) 291CancellationTokenSource.Token.ThrowTestPlatformExceptionIfCancellationRequested();
Discovery\DiscoveryManager.cs (1)
128var discovererEnumerator = new DiscovererEnumerator(_requestData, discoveryResultCache, _cancellationTokenSource.Token);
Microsoft.TestPlatform.Extensions.BlameDataCollector (1)
NetClientHangDumper.cs (1)
99}, timeout.Token));
Microsoft.TestPlatform.PlatformAbstractions (1)
common\System\ProcessHelper.cs (1)
146await p.WaitForExitAsync(cts.Token);
Microsoft.TestPlatform.VsTestConsole.TranslationLayer (4)
VsTestConsoleRequestSender.cs (4)
136_communicationManager.AcceptClientAsync(), timeoutSource.Token).ConfigureAwait(false); 522_processExitCancellationTokenSource.Token).ConfigureAwait(false); 537_processExitCancellationTokenSource.Token).ConfigureAwait(false); 1033Message? message = await _communicationManager.ReceiveMessageAsync(_processExitCancellationTokenSource!.Token)
Microsoft.VisualBasic.Forms (2)
Microsoft\VisualBasic\ApplicationServices\WindowsFormsApplicationBase.vb (2)
1102cancellationToken:=tokenSource.Token) 1116cancellationToken:=tokenSource.Token).ConfigureAwait(continueOnCapturedContext:=False)
Microsoft.VisualStudio.TestPlatform.Common (4)
DataCollection\DataCollectionAttachmentManager.cs (4)
259if (_cancellationTokenSource.Token.IsCancellationRequested) 261_cancellationTokenSource.Token.ThrowIfCancellationRequested(); 295_cancellationTokenSource.Token); 320_cancellationTokenSource.Token);
MSBuild (3)
XMake.cs (3)
345exitCode = ((s_initialized && MSBuildClientApp.Execute(args, multiThreaded, shutdownServerAfterBuild, s_buildCancellationSource.Token) == ExitType.Success) ? 0 : 1); 3418RarNodeShutdownReason rarShutdownReason = rarNode.Run(out nodeException, s_buildCancellationSource.Token); 4558replayEventSource.Replay(binaryLogFilePath, s_buildCancellationSource.Token);
MSBuild.Coordinator (3)
CoordinatorServer.cs (2)
56using CancellationTokenSource linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _cts.Token); 57CancellationToken token = linked.Token;
Program.cs (1)
40await server.RunAsync(cts.Token);
Nats.Backend (1)
Program.cs (1)
25await foreach (var msg in nats.SubscribeAsync<AppEvent>("events.>", cancellationToken: _cts.Token).ConfigureAwait(false))
NuGet.Build.Tasks (3)
RestoreTask.cs (2)
159catch (AggregateException ex) when (_cts.Token.IsCancellationRequested && ex.InnerException is OperationCanceledException) 253cancellationToken: _cts.Token);
StaticGraphRestoreTaskBase.cs (1)
189semaphore.Wait(_cancellationTokenSource.Token);
NuGet.CommandLine.XPlat (2)
Commands\PackageReferenceCommands\ListPackage\ListPackageCommandRunner.cs (2)
489tasks[itemIndex] = taskFactory(items[itemIndex], faultCancelationTokenSource.Token); 503tasks[i] = taskFactory(items[itemIndex++], faultCancelationTokenSource.Token);
NuGet.PackageManagement (5)
NuGetPackageManager.cs (3)
2068var task = Task.Run(() => metadataResource.Exists(packageIdentity, sourceCacheContext, logger, tokenSource.Token), tokenSource.Token); 2579downloadTokenSource.Token);
PackageDownloader.cs (1)
147linkedTokenSource.Token);
Resolution\ResolverGather.cs (1)
436linkedTokenSource.Token);
NuGet.Protocol (14)
Plugins\AutomaticProgressReporter.cs (1)
32_cancellationToken = _cancellationTokenSource.Token;
Plugins\InboundRequestContext.cs (1)
94_cancellationToken = _cancellationTokenSource.Token;
Plugins\OutboundRequestContext`1.cs (2)
124_cancellationTokenSource.Token.Register(TryCancel); 128CancellationToken = _cancellationTokenSource.Token;
Plugins\PluginFactory.cs (2)
268await connection.ConnectAsync(combinedCancellationTokenSource.Token); 458plugin.Connection.SendAsync(message, cancellationTokenSource.Token).Wait();
Plugins\RequestHandlers\SymmetricHandshake.cs (2)
78_timeoutCancellationTokenSource.Token.Register(() => 83CancellationToken = _timeoutCancellationTokenSource.Token;
Plugins\StandardInputReceiver.cs (2)
104_receiveCancellationTokenSource.Token, 105_receiveCancellationTokenSource.Token,
Resources\PackageUpdateResource.cs (2)
109allowSnupkg, allowInsecureConnections, requestTimeout, log, tokenSource.Token); 122requestTimeout, log, tokenSource.Token);
Utility\TimeoutUtility.cs (2)
39var timeoutTask = Task.Delay(timeout, timeoutTcs.Token); 40var responseTask = getTask(taskTcs.Token);
Roslyn.Diagnostics.Analyzers (12)
src\roslyn\src\Dependencies\Threading\AsyncBatchingWorkQueue`2.cs (4)
127_cancellationSeries = new CancellationSeries(_entireQueueCancellationTokenSource.Token); 245await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 272_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested(); 280_entireQueueCancellationTokenSource.Token.ThrowIfCancellationRequested();
src\roslyn\src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\roslyn\src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncPriorityWorkQueue.cs (2)
152await _asyncListener.Delay(_delay, _entireQueueCancellationTokenSource.Token).NoThrowAwaitableInternal(false); 181await _processBatchAsync(enumerator, _entireQueueCancellationTokenSource.Token).ConfigureAwait(false);
rzc (6)
DefaultRequestDispatcher.cs (3)
167_listenTask = _connectionHost.WaitForConnectionAsync(_listenCancellationTokenSource.Token); 363var watcher = connection.WaitForDisconnectAsync(buildCancelled.Token); 364var worker = ExecuteRequestAsync(request, buildCancelled.Token);
Program.cs (1)
38cancel.Token,
ServerProtocol\ServerConnection.cs (2)
247var responseTask = ServerResponse.ReadAsync(client.Stream, serverCts.Token); 248var monitorTask = client.WaitForDisconnectAsync(serverCts.Token);
Stress.AppHost (2)
InteractionCommands.cs (1)
860cancellationToken: cts.Token);
TestResource.cs (1)
175while (await timer.WaitForNextTickAsync(_tokenSource.Token))
System.Collections.Concurrent (9)
System\Collections\Concurrent\BlockingCollection.cs (9)
418cancellationToken, _producersCancellationTokenSource.Token); 419waitForSemaphoreWasSuccessful = _freeNodes.Wait(millisecondsTimeout, linkedTokenSource.Token); 667linkedTokenSource ??= CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _consumersCancellationTokenSource.Token); 668waitForSemaphoreWasSuccessful = _occupiedNodes.Wait(millisecondsTimeout, linkedTokenSource.Token); 984handles.Add(linkedTokenSource.Token.WaitHandle); // add the combined token to the handles list 1064tokensList.Add(c._producersCancellationTokenSource.Token); 1076tokensList.Add(collections[i]._consumersCancellationTokenSource.Token); 1387handles.Add(linkedTokenSource.Token.WaitHandle); // add the combined token to the handles list 1620using CancellationTokenSource linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _consumersCancellationTokenSource.Token);
System.CommandLine (2)
Invocation\InvocationPipeline.cs (2)
34result = await asyncAction.InvokeAsync(parseResult, cts.Token); 65var startedInvocation = asyncAction.InvokeAsync(parseResult, cts.Token);
System.ComponentModel.Annotations (2)
System\ComponentModel\DataAnnotations\Validator.cs (2)
731breakOnFirstError, linkedCts.Token)); 872tasks.Add(RunAsyncValidation(asyncAttr, value, validationContext, linkedCts.Token));
System.Data.Odbc (1)
Common\System\Data\ProviderBase\DbConnectionFactory.cs (1)
89}, cancellationTokenSource.Token, TaskContinuationOptions.LongRunning, TaskScheduler.Default)!;
System.Data.OleDb (1)
System\Data\ProviderBase\DbConnectionFactory.cs (1)
205}, cancellationTokenSource.Token, TaskContinuationOptions.LongRunning, TaskScheduler.Default)!;
System.Diagnostics.DiagnosticSource (3)
System\Diagnostics\Metrics\AggregationManager.cs (3)
257cancelToken = _cts.Token; 263while (!_cts.Token.IsCancellationRequested) 291CancellationToken cancelToken = _cts.Token;
System.Diagnostics.Process (4)
System\Diagnostics\AsyncStreamReader.cs (1)
97int bytesRead = await _stream.ReadAsync(new Memory<byte>(_byteBuffer), _cts.Token).ConfigureAwait(false);
System\Diagnostics\Process.Multiplexing.cs (2)
546Task outputTask = ReadToChannelAsync(outputReader, standardError: false, linkedCts.Token); 547Task errorTask = ReadToChannelAsync(errorReader, standardError: true, linkedCts.Token);
System\Diagnostics\ProcessWaitState.Unix.cs (1)
481(cts = new CancellationTokenSource(remainingTimeout)).Token;
System.IO.Pipelines (7)
System\IO\Pipelines\StreamPipeReader.cs (6)
260await reader.InnerStream.ReadAsync(Memory<byte>.Empty, tokenSource.Token).ConfigureAwait(false); 269int length = await reader.InnerStream.ReadAsync(buffer, tokenSource.Token).ConfigureAwait(false); 337FlushResult flushResult = await destination.WriteAsync(segment.Memory.Slice(segmentIndex), tokenSource.Token).ConfigureAwait(false); 368await InnerStream.CopyToAsync(destination, tokenSource.Token).ConfigureAwait(false); 408await destination.WriteAsync(segment.Memory.Slice(segmentIndex), tokenSource.Token).ConfigureAwait(false); 429await InnerStream.CopyToAsync(destination, tokenSource.Token).ConfigureAwait(false);
System\IO\Pipelines\StreamPipeWriter.cs (1)
314CancellationToken localToken = InternalTokenSource.Token;
System.IO.Pipes (2)
System\IO\Pipes\NamedPipeServerStream.Unix.cs (2)
83CancellationTokenSource linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_internalTokenSource.Token, cancellationToken); 86acceptedSocket = await _instance!.ListeningSocket.AcceptAsync(linkedTokenSource.Token).ConfigureAwait(false);
System.IO.Ports (2)
System\IO\Ports\SerialStream.Unix.cs (2)
426Task<int> t = ReadAsync(array, offset, count, cts?.Token ?? CancellationToken.None); 563Task t = WriteAsync(array, offset, count, cts?.Token ?? CancellationToken.None);
System.Linq.Parallel (2)
System\Linq\Parallel\QueryOperators\QuerySettings.cs (1)
154CancellationTokenSource.CreateLinkedTokenSource(settings.CancellationState.InternalCancellationTokenSource.Token, settings.CancellationState.ExternalCancellationToken);
System\Linq\Parallel\Scheduling\CancellationState.cs (1)
37return MergedCancellationTokenSource.Token;
System.Net.Http (39)
System\Net\Http\HttpClient.cs (13)
194response = await base.SendAsync(request, cts.Token).ConfigureAwait(false); 213using Stream responseStream = c.TryReadAsStream() ?? await c.ReadAsStreamAsync(cts.Token).ConfigureAwait(false); 216await responseStream.CopyToAsync(buffer, cts.Token).ConfigureAwait(false); 268response = await base.SendAsync(request, cts.Token).ConfigureAwait(false); 291using Stream responseStream = c.TryReadAsStream() ?? await c.ReadAsStreamAsync(cts.Token).ConfigureAwait(false); 294await responseStream.CopyToAsync(buffer, cts.Token).ConfigureAwait(false); 343response = await base.SendAsync(request, cts.Token).ConfigureAwait(false); 489response = base.Send(request, cts.Token); 501response.Content.LoadIntoBuffer(_maxResponseContentBufferSize, cts.Token); 544response = await base.SendAsync(request, cts.Token).ConfigureAwait(false); 556await response.Content.LoadIntoBufferAsync(_maxResponseContentBufferSize, cts.Token).ConfigureAwait(false); 635e = toThrow = CancellationHelper.CreateOperationCanceledException(e, cancellationToken.IsCancellationRequested ? cancellationToken : cts.Token); 819CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, pendingRequestsCts.Token);
System\Net\Http\SocketsHttpHandler\ChunkedEncodingReadStream.cs (1)
512ctr = cts.Token.Register(static s => ((HttpConnection)s!).Dispose(), _connection);
System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http1.cs (2)
265connection = await CreateHttp11ConnectionAsync(queueItem.Request, true, cts.Token).ConfigureAwait(false); 269connectionException = e is OperationCanceledException oce && oce.CancellationToken == cts.Token && !waiter.CancelledByOriginatingRequestCompletion ?
System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http2.cs (5)
196(Stream stream, TransportContext? transportContext, Activity? activity, IPEndPoint? remoteEndPoint, long connectionId) = await ConnectAsync(queueItem.Request, true, isForHttp2: true, cts.Token).ConfigureAwait(false); 213connection = await ConstructHttp2ConnectionAsync(stream, queueItem.Request, activity, remoteEndPoint, connectionId, cts.Token).ConfigureAwait(false); 219await HandleHttp11Downgrade(queueItem.Request, stream, transportContext, activity, remoteEndPoint, connectionId, cts.Token).ConfigureAwait(false); 225connection = await ConstructHttp2ConnectionAsync(stream, queueItem.Request, activity, remoteEndPoint, connectionId, cts.Token).ConfigureAwait(false); 230connectionException = e is OperationCanceledException oce && oce.CancellationToken == cts.Token && !waiter.CancelledByOriginatingRequestCompletion ?
System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http3.cs (3)
271QuicConnection quicConnection = await ConnectHelper.ConnectQuicAsync(queueItem.Request, connectEndPoint, _poolManager.Settings._pooledConnectionIdleTimeout, _sslOptionsHttp3!, connection.StreamCapacityCallback, cts.Token).ConfigureAwait(false); 287connectionException = e is OperationCanceledException oce && oce.CancellationToken == cts.Token && !waiter.CancelledByOriginatingRequestCompletion ? 866altSvcBlocklistTimerCt = _altSvcBlocklistTimerCancellation.Token;
System\Net\Http\SocketsHttpHandler\ContentLengthReadStream.cs (1)
224ctr = cts.Token.Register(static s => ((HttpConnection)s!).Dispose(), _connection);
System\Net\Http\SocketsHttpHandler\Http2Stream.cs (7)
205sendRequestContent = await WaitFor100ContinueAsync(_requestBodyCancellationSource.Token).ConfigureAwait(false); 214ValueTask vt = _request.Content.InternalCopyToAsync(writeStream, context: null, _requestBodyCancellationSource.Token); 1271CancellationTokenRegistration linkedRegistration = cancellationToken.CanBeCanceled && cancellationToken != _requestBodyCancellationSource.Token ? 1298_creditWaiter = new CreditWaiter(_requestBodyCancellationSource.Token); 1302_creditWaiter.ResetForAwait(_requestBodyCancellationSource.Token); 1329await _connection.SendStreamDataAsync(StreamId, current, flush, _requestBodyCancellationSource.Token).ConfigureAwait(false); 1332catch (OperationCanceledException e) when (e.CancellationToken == _requestBodyCancellationSource.Token)
System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (6)
184await FlushSendBufferAsync(endStream: _request.Content == null, _requestBodyCancellationSource.Token).ConfigureAwait(false); 188? SendContentAsync(_request.Content, _requestBodyCancellationSource.Token) 193Task readResponseTask = ReadResponseAsync(_requestBodyCancellationSource.Token); 245await writesClosed.WaitAsync(_requestBodyCancellationSource.Token).ConfigureAwait(false); 264await DrainContentLength0Frames(_requestBodyCancellationSource.Token).ConfigureAwait(false); 345catch (OperationCanceledException ex) when (ex.CancellationToken == _requestBodyCancellationSource.Token || ex.CancellationToken == cancellationToken)
System\Net\Http\SocketsHttpHandler\HttpConnectionBase.cs (1)
273if (await _pool.Settings._shouldEvictConnection(_evictionContext, _connectionDisposalCts.Token).ConfigureAwait(false))
System.Net.Http.Json (2)
System\Net\Http\Json\HttpClientJsonExtensions.cs (2)
91return await deserializeMethod(readStream, jsonOptions, linkedCTS?.Token ?? cancellationToken).ConfigureAwait(false); 93catch (OperationCanceledException oce) when ((linkedCTS?.Token.IsCancellationRequested == true) && !cancellationToken.IsCancellationRequested)
System.Net.Mail (3)
System\Net\Mail\SmtpClient.cs (3)
428cts = CancellationTokenSource.CreateLinkedTokenSource(_pendingSendCts.Token, cancellationToken); 429cancellationToken = cts.Token; 433cancellationToken = _pendingSendCts.Token;
System.Net.NameResolution (8)
System\Net\DnsResolverPal.Managed.cs (8)
639await socket.ConnectAsync(server, timeoutCts.Token).ConfigureAwait(false); 640await socket.SendAsync(query, timeoutCts.Token).ConfigureAwait(false); 641return await socket.ReceiveAsync(responseBuffer, timeoutCts.Token).ConfigureAwait(false); 699await socket.ConnectAsync(server, timeoutCts.Token).ConfigureAwait(false); 705await SendExactAsync(socket, buffer.AsMemory(0, 2), timeoutCts.Token).ConfigureAwait(false); 706await SendExactAsync(socket, query, timeoutCts.Token).ConfigureAwait(false); 708await ReceiveExactAsync(socket, buffer.AsMemory(0, 2), timeoutCts.Token).ConfigureAwait(false); 717await ReceiveExactAsync(socket, buffer.AsMemory(0, responseLength), timeoutCts.Token).ConfigureAwait(false);
System.Net.Ping (3)
System\Net\NetworkInformation\Ping.cs (1)
719IPAddress address = await getAddress(getAddressArg, _timeoutOrCancellationSource.Token).ConfigureAwait(false);
System\Net\NetworkInformation\Ping.PingUtility.cs (1)
76CancellationToken timeoutOrCancellationToken = _timeoutOrCancellationSource!.Token;
System\Net\NetworkInformation\Ping.RawSocket.cs (1)
327CancellationToken timeoutOrCancellationToken = _timeoutOrCancellationSource!.Token;
System.Net.Quic (6)
System\Net\Quic\QuicConnection.cs (2)
86await connection.FinishConnectAsync(options, linkedCts.Token).ConfigureAwait(false); 148internal CancellationToken ConnectionShutdownToken => _shutdownTokenSource.Token;
System\Net\Quic\QuicListener.cs (2)
232using CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_disposeCts.Token, connection.ConnectionShutdownToken); 233cancellationToken = linkedCts.Token;
System\Net\Quic\QuicStream.Stream.cs (2)
126int readLength = ReadAsync(new Memory<byte>(rentedBuffer, 0, buffer.Length), cts?.Token ?? default).AsTask().GetAwaiter().GetResult(); 187WriteAsync(buffer.ToArray(), cts?.Token ?? default).AsTask().GetAwaiter().GetResult();
System.Net.Requests (2)
System\Net\HttpWebRequest.cs (2)
1256_httpClient.SendAsync(_sendRequestMessage, completionOption, _sendRequestCts.Token) : 1257Task.FromResult(_httpClient.Send(_sendRequestMessage, completionOption, _sendRequestCts.Token));
System.Net.Security (1)
src\runtime\src\libraries\Common\src\System\Net\Http\X509ResourceClient.cs (1)
66Task<byte[]?> task = s_downloadBytes(uri, cts?.Token ?? default, async);
System.Net.Sockets (1)
System\Net\Sockets\SocketAsyncEventArgs.cs (1)
696cancellationToken = _multipleConnectCancellation.Token;
System.Net.WebSockets (1)
System\Net\WebSockets\WebSocketStream.cs (1)
269ct = cts.Token;
System.Private.CoreLib (4)
src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipeEventDispatcher.Threads.cs (1)
18m_dispatchTask = Task.Factory.StartNew(() => DispatchEventsToEventListeners(sessionID, syncTimeUtc, syncTimeQPC, timeQPCFrequency, previousDispatchTask, m_dispatchTaskCancellationSource.Token), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\File.cs (1)
1692while ((line = await sr.ReadLineAsync(cts.Token).ConfigureAwait(false)) is not null)
src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\CancellationToken.cs (1)
19/// <see cref="CancellationTokenSource.Token">Token</see> property.
src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\CancellationTokenSource.cs (1)
16/// the source's <see cref="Token">Token</see> property) that can be handed to operations that wish to be
System.Security.Cryptography (1)
src\runtime\src\libraries\Common\src\System\Net\Http\X509ResourceClient.cs (1)
66Task<byte[]?> task = s_downloadBytes(uri, cts?.Token ?? default, async);
System.ServiceModel.Http (1)
System\ServiceModel\Channels\HttpChannelFactory.cs (1)
1056_httpResponseMessage = await _httpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, _httpSendCts.Token);
System.ServiceModel.Primitives (3)
Internals\System\Runtime\TaskHelpers.cs (1)
234var completedTask = await Task.WhenAny(task, Task.Delay(timeout, cts.Token));
Internals\System\Runtime\TimeoutHelper.cs (2)
321var token = tokenSource.Token; 337tokenTask = Task.FromResult(new CancellationTokenSource(millisecondsTimeout).Token);
System.Threading.Tasks.Dataflow (5)
Base\DataflowBlock.cs (5)
1070if (target._cts.Token.CanBeCanceled) 1072target._cts.Token.Register( 2009return Common.CreateTaskFromCancellation<int>(cts.Token); 2014var target = new ChooseTarget<T>(boxedCompleted, cts.Token); 2402}, this, Canceler.Token, Common.GetContinuationOptions(TaskContinuationOptions.ExecuteSynchronously), TaskScheduler.Default);
System.Threading.Tasks.Parallel (4)
System\Threading\Tasks\Parallel.ForEachAsync.cs (4)
156await state.LoopBody(element, state.Cancellation.Token); 301await state.LoopBody(element, state.Cancellation.Token); 456await state.LoopBody(element, state.Cancellation.Token); 718Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException(SR.Parallel_ForEach_NullEnumerator);
System.Windows.Extensions (1)
System\Media\SoundPlayer.cs (1)
328_copyTask = CopyStreamAsync(cts.Token);
System.Windows.Forms.Primitives (1)
System\Windows\Forms\Animation\HighPrecisionTimer.cs (1)
698Token = CancellationSource.Token;
Testing.Tests (29)
WaitFailures.cs (29)
32await app.StartAsync(cts.Token); 34await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, cancellationToken: cts.Token); 47await app.StartAsync(cts.Token); 49await app.ResourceNotifications.WaitForResourceAsync(pwsh.Resource.Name, cancellationToken: cts.Token); 64await app.StartAsync(cts.Token); 68await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, cancellationToken: cts.Token); 72await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.TerminalStates, cancellationToken: cts.Token); 84await app.StartAsync(cts.Token); 87await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, "StateThatIsNeverUsed", cts.Token); 99await app.StartAsync(cts.Token); 102await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, ["States", "That", "Are", "Never", "Used"], cts.Token); 114await app.StartAsync(cts.Token); 117await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, x => false, cts.Token); 133await app.StartAsync(cts.Token); 136await app.ResourceNotifications.WaitForResourceHealthyAsync(nginx.Resource.Name, cts.Token); 152await app.StartAsync(cts.Token); 156await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, x => x.Snapshot.HealthReports.All(x => x.Status.HasValue), cts.Token); 159await app.ResourceNotifications.WaitForResourceHealthyAsync(nginx.Resource.Name, cts.Token); 172await app.StartAsync(cts.Token); 176await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, x => x.Snapshot.HealthStatus == HealthStatus.Healthy, cts.Token); 180await app.ResourceNotifications.WaitForResourceHealthyAsync(nginx.Resource.Name, cts.Token); 203_ = app.StartAsync(cts.Token); 206await app.ResourceNotifications.WaitForDependenciesAsync(consumer.Resource, cts.Token); 224_ = app.StartAsync(cts.Token); 228await app.ResourceNotifications.WaitForResourceAsync(dependency.Resource.Name, cancellationToken: cts.Token); 232await app.ResourceNotifications.WaitForDependenciesAsync(consumer.Resource, cts.Token); 248_ = app.StartAsync(cts.Token); 252await app.ResourceNotifications.WaitForResourceAsync(dependency.Resource.Name, cancellationToken: cts.Token); 256await app.ResourceNotifications.WaitForDependenciesAsync(consumer.Resource, cancellationToken: cts.Token);
vbc (2)
src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (2)
314var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 315var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
VBCSCompiler (8)
src\roslyn\src\Compilers\Server\VBCSCompiler\BuildServerController.cs (2)
40return RunShutdown(options.PipeName, cancellationToken: cancellationTokenSource.Token); 45return RunServer(options.PipeName, keepAlive: options.KeepAlive, cancellationToken: cancellationTokenSource.Token);
src\roslyn\src\Compilers\Server\VBCSCompiler\ClientConnectionHandler.cs (1)
117var compilationTask = ProcessCompilationRequestCoreAsync(CompilerServerHost, request, buildCancellationTokenSource.Token);
src\roslyn\src\Compilers\Server\VBCSCompiler\NamedPipeClientConnection.cs (1)
74await BuildServerConnection.MonitorDisconnectAsync(Stream, request.RequestId, Logger, DisconnectCancellationTokenSource.Token).ConfigureAwait(false);
src\roslyn\src\Compilers\Server\VBCSCompiler\NamedPipeClientConnectionHost.cs (2)
73var task = Task.Run(() => ListenCoreAsync(PipeName, Logger, _queue, _cancellationTokenSource.Token)); 145var listenResult = await _queue.DequeueAsync(_cancellationTokenSource.Token).ConfigureAwait(false);
src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (2)
314var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 315var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
vstest.console (1)
TestPlatformHelpers\TestRequestManager.cs (1)
464_currentAttachmentsProcessingCancellationTokenSource.Token);
vstest.console.arm64 (1)
src\vstest\src\vstest.console\TestPlatformHelpers\TestRequestManager.cs (1)
464_currentAttachmentsProcessingCancellationTokenSource.Token);