public static async Task <Stream> RequestServiceAsync(
HostWorkspaceServices services,
HubClient client,
RemoteServiceName serviceName,
HostGroup hostGroup,
CancellationToken cancellationToken)
{
var is64bit = RemoteHostOptions.IsServiceHubProcess64Bit(services);
var descriptor = new ServiceDescriptor(serviceName.ToString(is64bit))
{
HostGroup = hostGroup
};
try
{
return(await client.RequestServiceAsync(descriptor, cancellationToken).ConfigureAwait(false));
}
catch (Exception e) when(ReportNonFatalWatson(e, cancellationToken))
{
// TODO: Once https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1040692.
// ServiceHub may throw non-cancellation exceptions if it is called after VS started to shut down,
// even if our cancellation token is signaled. Cancel the operation and do not report an error in these cases.
//
// If ServiceHub did not throw non-cancellation exceptions when cancellation token is signaled,
// we can assume that these exceptions indicate a failure and should be reported to the user.
cancellationToken.ThrowIfCancellationRequested();
RemoteHostCrashInfoBar.ShowInfoBar(services, e);
// TODO: Propagate the original exception (see https://github.com/dotnet/roslyn/issues/40476)
throw new SoftCrashException("Unexpected exception from HubClient", e, cancellationToken);
}
private void SetRemoteHostBitness()
{
bool x64 = RemoteHostOptions.IsServiceHubProcess64Bit(_workspace);
// log OOP bitness
Logger.Log(FunctionId.RemoteHost_Bitness, KeyValueLogMessage.Create(LogType.Trace, m => m["64bit"] = x64));
// set service bitness
WellKnownServiceHubServices.Set64bit(x64);
}
public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
{
if (!RemoteHostOptions.IsUsingServiceHubOutOfProcess(workspaceServices) ||
workspaceServices.Workspace is not VisualStudioWorkspace)
{
// Run code in the current process
return(new DefaultRemoteHostClientProvider());
}
return(new VisualStudioRemoteHostClientProvider(workspaceServices, _vsServiceProvider));
}
public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
{
// We don't want to bring up the OOP process in a VS cloud environment client instance
// Avoids proffering brokered services on the client instance.
if (!RemoteHostOptions.IsUsingServiceHubOutOfProcess(workspaceServices) ||
workspaceServices.Workspace is not VisualStudioWorkspace ||
workspaceServices.GetRequiredService <IWorkspaceContextService>().IsCloudEnvironmentClient())
{
// Run code in the current process
return(new DefaultRemoteHostClientProvider());
}
return(new VisualStudioRemoteHostClientProvider(workspaceServices, _vsServiceProvider, _threadingContext, _listenerProvider, _callbackDispatchers));
}
public static async Task <RemoteHostClient> CreateAsync(HostWorkspaceServices services, CancellationToken cancellationToken)
{
using (Logger.LogBlock(FunctionId.ServiceHubRemoteHostClient_CreateAsync, KeyValueLogMessage.NoProperty, cancellationToken))
{
Logger.Log(FunctionId.RemoteHost_Bitness, KeyValueLogMessage.Create(LogType.Trace, m => m["64bit"] = RemoteHostOptions.IsServiceHubProcess64Bit(services)));
// let each client to have unique id so that we can distinguish different clients when service is restarted
var clientId = $"VS ({Process.GetCurrentProcess().Id}) ({Guid.NewGuid()})";
var hostGroup = new HostGroup(clientId);
var hubClient = new HubClient("ManagedLanguage.IDE.RemoteHostClient");
// use the hub client logger for unexpected exceptions from devenv as well, so we have complete information in the log:
WatsonReporter.InitializeLogger(hubClient.Logger);
var remoteHostStream = await RequestServiceAsync(services, hubClient, WellKnownServiceHubService.RemoteHost, hostGroup, cancellationToken).ConfigureAwait(false);
var client = new ServiceHubRemoteHostClient(services, hubClient, hostGroup, remoteHostStream);
var uiCultureLCID = CultureInfo.CurrentUICulture.LCID;
var cultureLCID = CultureInfo.CurrentCulture.LCID;
bool success = false;
try
{
// initialize the remote service
await client._endPoint.InvokeAsync <string>(
nameof(IRemoteHostService.InitializeGlobalState),
new object[] { clientId, uiCultureLCID, cultureLCID, TelemetryService.DefaultSession.SerializeSettings() },
cancellationToken).ConfigureAwait(false);
success = true;
}
finally
{
if (!success)
{
client.Dispose();
}
}
client.Started();
return(client);
}
}
public void Enable()
{
lock (_gate)
{
if (_remoteClientTask != null)
{
// already enabled
return;
}
// We enable the remote host if either RemoteHostTest or RemoteHost are on.
var optionService = _workspace.Services.GetRequiredService <IOptionService>();
if (!optionService.GetOption(RemoteHostOptions.RemoteHostTest) &&
!optionService.GetOption(RemoteHostOptions.RemoteHost))
{
// not turned on
return;
}
// log that remote host is enabled
Logger.Log(FunctionId.RemoteHostClientService_Enabled, KeyValueLogMessage.NoProperty);
Logger.Log(FunctionId.RemoteHost_Bitness, KeyValueLogMessage.Create(LogType.Trace, m => m["64bit"] = RemoteHostOptions.IsServiceHubProcess64Bit(_workspace.Services)));
var remoteHostClientFactory = _workspace.Services.GetService <IRemoteHostClientFactory>();
if (remoteHostClientFactory == null)
{
// dev14 doesn't have remote host client factory
return;
}
// make sure we run it on background thread
_shutdownCancellationTokenSource = new CancellationTokenSource();
var token = _shutdownCancellationTokenSource.Token;
_checksumUpdater = new SolutionChecksumUpdater(Workspace, Listener, token);
_globalNotificationDelivery = new GlobalNotificationRemoteDeliveryService(Workspace.Services, token);
_remoteClientTask = Task.Run(() => EnableAsync(token), token);
}
}
