public static async Task <KeepAliveSession?> TryCreateKeepAliveSessionAsync(
this RemoteHostClient client, string serviceName, object?callbackTarget, CancellationToken cancellationToken)
{
var connection = await client.TryCreateConnectionAsync(serviceName, callbackTarget, cancellationToken).ConfigureAwait(false);
if (connection == null)
{
return(null);
}
return(new KeepAliveSession(client, connection, serviceName, callbackTarget));
}
public static async Task <SessionWithSolution?> TryCreateSessionAsync(
this RemoteHostClient client, string serviceName, Solution solution, object?callbackTarget, CancellationToken cancellationToken)
{
var connection = await client.TryCreateConnectionAsync(serviceName, callbackTarget, cancellationToken).ConfigureAwait(false);
if (connection == null)
{
return(null);
}
return(await SessionWithSolution.CreateAsync(connection, solution, cancellationToken).ConfigureAwait(false));
}
public static async Task <T?> TryRunRemoteValueAsync <T>(
this RemoteHostClient client, string serviceName, Solution solution, string targetName, IReadOnlyList <object> arguments, CancellationToken cancellationToken) where T : struct
{
using var session = await client.TryCreateSessionAsync(serviceName, solution, cancellationToken).ConfigureAwait(false);
if (session == null)
{
// can't create Session. RemoteHost seems not responding for some reasons such as OOP gone.
return(null);
}
return(await session.InvokeAsync <T>(targetName, arguments, cancellationToken).ConfigureAwait(false));
}
public async Task <bool> TryInvokeAsync(string targetName, Solution?solution, IReadOnlyList <object?> arguments, CancellationToken cancellationToken)
{
using var connection = await TryGetConnectionAsync(cancellationToken).ConfigureAwait(false);
if (connection == null)
{
return(false);
}
await RemoteHostClient.RunRemoteAsync(connection.Target, _remotableDataService, targetName, solution, arguments, cancellationToken).ConfigureAwait(false);
return(true);
}
/// <summary>
/// Run given service on remote host. if it fails to run on remote host, it will return default(T)
/// </summary>
public static async Task <T> RunOnRemoteHostAsync <T>(
this RemoteHostClient client, string serviceName, Solution solution, string targetName, object[] arguments, CancellationToken cancellationToken)
{
using (var session = await client.TryCreateServiceSessionAsync(serviceName, solution, cancellationToken).ConfigureAwait(false))
{
if (session == null)
{
// can't create Session. RemoteHost seems not responding for some reasons such as OOP gone.
return(default(T));
}
return(await session.InvokeAsync <T>(targetName, arguments).ConfigureAwait(false));
}
}
public void Shutdown()
{
using (_gate.DisposableWait(_cancellationToken))
{
if (_client != null)
{
_client.StatusChanged -= OnStatusChanged;
}
_connection?.Dispose();
_client = null;
_connection = null;
}
}
public static async Task<bool> TryRunRemoteAsync(
this RemoteHostClient client, string serviceName, string targetName, IReadOnlyList<object> arguments, CancellationToken cancellationToken)
{
using (var connection = await client.TryCreateConnectionAsync(serviceName, cancellationToken).ConfigureAwait(false))
{
if (connection == null)
{
// can't create Connection. RemoteHost seems not responding for some reasons such as OOP gone.
return false;
}
await connection.InvokeAsync(targetName, arguments, cancellationToken).ConfigureAwait(false);
return true;
}
}
public static async Task <bool> TryRunRemoteAsync(
this RemoteHostClient client, string serviceName, Solution solution, object?callbackTarget,
string targetName, IReadOnlyList <object> arguments, CancellationToken cancellationToken)
{
using var session = await client.TryCreateSessionAsync(serviceName, solution, callbackTarget, cancellationToken).ConfigureAwait(false);
if (session == null)
{
// can't create Session. RemoteHost seems not responding for some reasons such as OOP gone.
return(false);
}
await session.InvokeAsync(targetName, arguments, cancellationToken).ConfigureAwait(false);
return(true);
}
private async Task SynchronizePrimaryWorkspaceAsync(CancellationToken cancellationToken)
{
var solution = _workspace.CurrentSolution;
if (solution.BranchId != _workspace.PrimaryBranchId)
{
return;
}
var client = await RemoteHostClient
.TryGetClientAsync(_workspace, cancellationToken)
.ConfigureAwait(false);
if (client == null)
{
return;
}
using (
Logger.LogBlock(
FunctionId.SolutionChecksumUpdater_SynchronizePrimaryWorkspace,
cancellationToken
)
)
{
var checksum = await solution.State
.GetChecksumAsync(cancellationToken)
.ConfigureAwait(false);
await client
.TryInvokeAsync <IRemoteAssetSynchronizationService>(
solution,
(service, solution, cancellationToken) =>
service.SynchronizePrimaryWorkspaceAsync(
solution,
checksum,
solution.WorkspaceVersion,
cancellationToken
),
cancellationToken
)
.ConfigureAwait(false);
}
}
public void Shutdown(CancellationToken cancellationToken)
{
ReferenceCountedDisposable <RemoteHostClient.Connection> connection;
lock (_gate)
{
if (_client != null)
{
_client.StatusChanged -= OnStatusChanged;
}
connection = _connectionDoNotAccessDirectly;
_client = null;
_connectionDoNotAccessDirectly = null;
}
connection?.Dispose();
}
private async Task <GlobalNotificationState> SendStartNotificationAsync(Task <GlobalNotificationState> previousTask)
{
// Can only transition from NotStarted->Started. If we hear about
// anything else, do nothing.
if (previousTask.Result != GlobalNotificationState.NotStarted)
{
return(previousTask.Result);
}
var client = await RemoteHostClient.TryGetClientAsync(_services, _cancellationToken).ConfigureAwait(false);
if (client == null)
{
return(previousTask.Result);
}
_ = await client.TryInvokeAsync <IRemoteGlobalNotificationDeliveryService>(
(service, cancellationToken) => service.OnGlobalOperationStartedAsync(cancellationToken),
_cancellationToken).ConfigureAwait(false);
return(GlobalNotificationState.Started);
}
private async Task <GlobalNotificationState> SendStoppedNotificationAsync(Task <GlobalNotificationState> previousTask, GlobalOperationEventArgs e)
{
// Can only transition from Started->NotStarted. If we hear about
// anything else, do nothing.
if (previousTask.Result != GlobalNotificationState.Started)
{
return(previousTask.Result);
}
var client = await RemoteHostClient.TryGetClientAsync(_services, _cancellationToken).ConfigureAwait(false);
if (client == null)
{
return(previousTask.Result);
}
_ = await client.TryInvokeAsync <IRemoteGlobalNotificationDeliveryService>(
(service, cancellationToken) => service.OnGlobalOperationStoppedAsync(e.Operations, e.Cancelled, cancellationToken),
callbackTarget : null,
_cancellationToken).ConfigureAwait(false);
// Mark that we're stopped now.
return(GlobalNotificationState.NotStarted);
}
/// <summary>
/// Create <see cref="RemoteHostClient.Connection"/> for the <paramref name="serviceName"/> if possible.
/// otherwise, return null.
///
/// Creating connection could fail if remote host is not available. one of example will be user killing
/// remote host.
/// </summary>
public static Task <RemoteHostClient.Connection> TryCreateConnectionAsync(
this RemoteHostClient client, string serviceName, CancellationToken cancellationToken)
=> client.TryCreateConnectionAsync(serviceName, callbackTarget: null, cancellationToken: cancellationToken);
public static Task <bool> TryRunRemoteAsync(
this RemoteHostClient client, string serviceName, Solution solution, string targetName, object argument, CancellationToken cancellationToken)
=> TryRunRemoteAsync(client, serviceName, solution, targetName, new object[] { argument }, cancellationToken);
public static Task <RemoteHostClient.Session> CreateCodeAnalysisServiceSessionAsync(
this RemoteHostClient client, Solution solution, object callbackTarget, CancellationToken cancellationToken)
{
return(client.CreateServiceSessionAsync(
WellKnownServiceHubServices.CodeAnalysisService, solution, callbackTarget, cancellationToken));
}
public static Task <KeepAliveSession> TryCreateCodeAnalysisKeepAliveSessionAsync(
this RemoteHostClient client, CancellationToken cancellationToken)
=> TryCreateCodeAnalysisKeepAliveSessionAsync(client, callbackTarget: null, cancellationToken: cancellationToken);
public static Task <SessionWithSolution> TryCreateCodeAnalysisSessionAsync(
this RemoteHostClient client, Solution solution, CancellationToken cancellationToken)
=> TryCreateCodeAnalysisSessionAsync(client, solution, callbackTarget: null, cancellationToken: cancellationToken);
public static Task RunCodeAnalysisServiceOnRemoteHostAsync(
this RemoteHostClient client, Solution solution, object callbackTarget, string targetName, object argument, CancellationToken cancellationToken)
{
return(RunCodeAnalysisServiceOnRemoteHostAsync(client, solution, callbackTarget, targetName, new object[] { argument }, cancellationToken));
}
public static Task RunOnRemoteHostAsync(
this RemoteHostClient client, string serviceName, Solution solution, string targetName, object argument, CancellationToken cancellationToken)
{
return(RunOnRemoteHostAsync(client, serviceName, solution, targetName, new object[] { argument }, cancellationToken));
}
public static Task <RemoteHostClient.Session> TryCreateCodeAnalysisServiceSessionAsync(
this RemoteHostClient client, Solution solution, CancellationToken cancellationToken)
{
return(TryCreateCodeAnalysisServiceSessionAsync(
client, solution, callbackTarget: null, cancellationToken: cancellationToken));
}
/// <summary>
/// Run given service on remote host. if it fails to run on remote host, it will return default(T)
/// </summary>
public static Task <T> RunCodeAnalysisServiceOnRemoteHostAsync <T>(
this RemoteHostClient client, Solution solution, string targetName, object[] arguments, CancellationToken cancellationToken)
{
return(RunOnRemoteHostAsync <T>(client, WellKnownServiceHubServices.CodeAnalysisService, solution, targetName, arguments, cancellationToken));
}
public static Task<bool> TryRunCodeAnalysisRemoteAsync(
this RemoteHostClient client, string targetName, object[] arguments, CancellationToken cancellationToken)
=> TryRunRemoteAsync(client, WellKnownServiceHubServices.CodeAnalysisService, targetName, arguments, cancellationToken);
/// <summary>
/// Run given service on remote host. if it fails to run on remote host, it will return default(T)
/// </summary>
public static Task<T> TryRunCodeAnalysisRemoteAsync<T>(
this RemoteHostClient client, Solution solution, string targetName, object argument, CancellationToken cancellationToken)
=> TryRunCodeAnalysisRemoteAsync<T>(client, solution, targetName, new object[] { argument }, cancellationToken);
/// <summary>
/// Create <see cref="SessionWithSolution"/> for the <paramref name="serviceName"/> if possible.
/// otherwise, return null.
///
/// Creating session could fail if remote host is not available. one of example will be user killing
/// remote host.
/// </summary>
public static Task <SessionWithSolution> TryCreateSessionAsync(
this RemoteHostClient client, string serviceName, Solution solution, CancellationToken cancellationToken)
=> client.TryCreateSessionAsync(serviceName, solution, callbackTarget: null, cancellationToken: cancellationToken);
/// <summary>
/// Create <see cref="KeepAliveSession"/> for the <paramref name="serviceName"/> if possible.
/// otherwise, return null.
///
/// Creating session could fail if remote host is not available. one of example will be user killing
/// remote host.
/// </summary>
public static Task <KeepAliveSession> TryCreateKeepAliveSessionAsync(
this RemoteHostClient client, string serviceName, CancellationToken cancellationToken)
=> TryCreateKeepAliveSessionAsync(client, serviceName, callbackTarget: null, cancellationToken: cancellationToken);
private void PushTextChanges(Document oldDocument, Document newDocument)
{
// this pushes text changes to the remote side if it can.
// this is purely perf optimization. whether this pushing text change
// worked or not doesn't affect feature's functionality.
//
// this basically see whether it can cheaply find out text changes
// between 2 snapshots, if it can, it will send out that text changes to
// remote side.
//
// the remote side, once got the text change, will again see whether
// it can use that text change information without any high cost and
// create new snapshot from it.
//
// otherwise, it will do the normal behavior of getting full text from
// VS side. this optimization saves times we need to do full text
// synchronization for typing scenario.
if ((oldDocument.TryGetText(out var oldText) == false) ||
(newDocument.TryGetText(out var newText) == false))
{
// we only support case where text already exist
return;
}
// get text changes
var textChanges = newText.GetTextChanges(oldText);
if (textChanges.Count == 0)
{
// no changes
return;
}
// whole document case
if (textChanges.Count == 1 && textChanges[0].Span.Length == oldText.Length)
{
// no benefit here. pulling from remote host is more efficient
return;
}
// only cancelled when remote host gets shutdown
_textChangeQueue.ScheduleTask(nameof(PushTextChanges), async() =>
{
var client = await RemoteHostClient.TryGetClientAsync(_workspace, CancellationToken).ConfigureAwait(false);
if (client == null)
{
return;
}
var state = await oldDocument.State.GetStateChecksumsAsync(CancellationToken).ConfigureAwait(false);
await client.RunRemoteAsync(
WellKnownServiceHubService.RemoteHost,
nameof(IRemoteHostService.SynchronizeTextAsync),
solution: null,
new object[] { oldDocument.Id, state.Text, textChanges },
callbackTarget: null,
CancellationToken).ConfigureAwait(false);
}, CancellationToken);
}
public static Task <SessionWithSolution> TryCreateCodeAnalysisSessionAsync(
this RemoteHostClient client, Solution solution, object callbackTarget, CancellationToken cancellationToken)
=> client.TryCreateSessionAsync(WellKnownServiceHubServices.CodeAnalysisService, solution, callbackTarget, cancellationToken);
public static Task <T?> TryRunCodeAnalysisRemoteValueAsync <T>(
this RemoteHostClient client, Solution solution, string targetName, object[] arguments, CancellationToken cancellationToken) where T : struct
=> TryRunRemoteValueAsync <T>(client, WellKnownServiceHubServices.CodeAnalysisService, solution, targetName, arguments, cancellationToken);
public static Task <KeepAliveSession> TryCreateCodeAnalysisKeepAliveSessionAsync(
this RemoteHostClient client, object callbackTarget, CancellationToken cancellationToken)
=> client.TryCreateKeepAliveSessionAsync(WellKnownServiceHubServices.CodeAnalysisService, callbackTarget, cancellationToken);
public static Task<bool> TryRunRemoteAsync(
this RemoteHostClient client, string serviceName, Solution solution, string targetName, object[] arguments, CancellationToken cancellationToken)
{
object callbackTarget = null;
return TryRunRemoteAsync(client, serviceName, solution, callbackTarget, targetName, arguments, cancellationToken);
}
