private async Task <RemoteHostClient?> CreateHostClientAsync()
{
try
{
var brokeredServiceContainer = await _vsServiceProvider.GetServiceAsync <SVsBrokeredServiceContainer, IBrokeredServiceContainer>().ConfigureAwait(false);
var serviceBroker = brokeredServiceContainer.GetFullAccessServiceBroker();
var configuration =
(_globalOptions.GetOption(RemoteHostOptions.OOPCoreClrFeatureFlag) ? RemoteProcessConfiguration.Core : 0) |
(_globalOptions.GetOption(RemoteHostOptions.OOPServerGCFeatureFlag) ? RemoteProcessConfiguration.ServerGC : 0);
// VS AsyncLazy does not currently support cancellation:
var client = await ServiceHubRemoteHostClient.CreateAsync(_services, configuration, _listenerProvider, serviceBroker, _callbackDispatchers, CancellationToken.None).ConfigureAwait(false);
// proffer in-proc brokered services:
_ = brokeredServiceContainer.Proffer(SolutionAssetProvider.ServiceDescriptor, (_, _, _, _) => ValueTaskFactory.FromResult <object?>(new SolutionAssetProvider(_services)));
return(client);
}
catch (Exception e) when(FatalError.ReportAndCatchUnlessCanceled(e))
{
return(null);
}
}
private async Task <RemoteHostClient> EnableAsync(CancellationToken cancellationToken)
{
await AddGlobalAssetsAsync(cancellationToken).ConfigureAwait(false);
// TODO: abstract this out so that we can have more host than service hub
var instance = await ServiceHubRemoteHostClient.CreateAsync(_workspace, cancellationToken).ConfigureAwait(false);
instance.ConnectionChanged += OnConnectionChanged;
return(instance);
}
public Task <RemoteHostClient> CreateAsync(Workspace workspace, CancellationToken cancellationToken)
{
try
{
// this is the point where we can create different kind of remote host client in future (cloud or etc)
return(ServiceHubRemoteHostClient.CreateAsync(workspace, cancellationToken));
}
catch
{
// currently there is so many moving parts that cause, in some branch/drop,
// service hub not to work. in such places (ex, Jenkins), rather than crashing VS
// right away, let VS run without service hub enabled.
return(SpecializedTasks.Default <RemoteHostClient>());
}
}
private async Task <RemoteHostClient> CreateHostClientAsync(CancellationToken cancellationToken)
{
var client = await ServiceHubRemoteHostClient.CreateAsync(_services, cancellationToken).ConfigureAwait(false);
var telemetrySessionSettings = _services.GetService <IWorkspaceTelemetryService>()?.SerializeCurrentSessionSettings();
// initialize the remote service
await client.RunRemoteAsync(
WellKnownServiceHubService.RemoteHost,
nameof(IRemoteHostService.InitializeTelemetrySession),
solution : null,
new object?[] { client.ClientId, telemetrySessionSettings },
callbackTarget : null,
cancellationToken).ConfigureAwait(false);
return(client);
}
private async Task <RemoteHostClient?> CreateHostClientAsync(CancellationToken cancellationToken)
{
try
{
var brokeredServiceContainer = await _vsServiceProvider.GetServiceAsync <SVsBrokeredServiceContainer, IBrokeredServiceContainer>().ConfigureAwait(false);
var serviceBroker = brokeredServiceContainer.GetFullAccessServiceBroker();
var client = await ServiceHubRemoteHostClient.CreateAsync(_services, serviceBroker, cancellationToken).ConfigureAwait(false);
// proffer in-proc brokered services:
_ = brokeredServiceContainer.Proffer(SolutionAssetProvider.ServiceDescriptor, (_, _, _, _) => new ValueTask <object?>(new SolutionAssetProvider(_services)));
return(client);
}
catch (Exception e) when(FatalError.ReportWithoutCrashUnlessCanceled(e))
{
return(null);
}
}
public async Task <RemoteHostClient?> CreateAsync(Workspace workspace, CancellationToken cancellationToken)
{
// this is the point where we can create different kind of remote host client in future (cloud or etc)
return(await ServiceHubRemoteHostClient.CreateAsync(workspace, cancellationToken).ConfigureAwait(false));
}
public ServiceHubRemoteHostClientProvider(HostWorkspaceServices services)
{
_services = services;
_lazyClient = new AsyncLazy <RemoteHostClient>(cancellationToken => ServiceHubRemoteHostClient.CreateAsync(_services, cancellationToken), cacheResult: true);
}
private Task <RemoteHostClient> CreateHostClientAsync(CancellationToken cancellationToken) => ServiceHubRemoteHostClient.CreateAsync(_services, cancellationToken);