public ValueTask <T?> GetProxyAsync <T>(ServiceRpcDescriptor descriptor, ServiceActivationOptions options, CancellationToken cancellationToken) where T : class { var pipePair = FullDuplexStream.CreatePipePair(); var clientConnection = descriptor .WithTraceSource(_services.ServiceProvider.TraceSource) .ConstructRpcConnection(pipePair.Item2); Contract.ThrowIfFalse(options.ClientRpcTarget is null == descriptor.ClientInterface is null); if (descriptor.ClientInterface != null) { Contract.ThrowIfNull(options.ClientRpcTarget); clientConnection.AddLocalRpcTarget(options.ClientRpcTarget); } // Clear RPC target so that the server connection is forced to create a new proxy for the callback // instead of just invoking the callback object directly (this emulates the product that does // not serialize the callback object over). options.ClientRpcTarget = null; // Creates service instance and connects it to the pipe. // We don't need to store the instance anywhere. _ = _services.CreateBrokeredService(descriptor, pipePair.Item1, options); clientConnection.StartListening(); return(ValueTaskFactory.FromResult((T?)clientConnection.ConstructRpcClient <T>())); }
internal TService Create( IDuplexPipe pipe, IServiceProvider hostProvidedServices, ServiceActivationOptions serviceActivationOptions, IServiceBroker serviceBroker ) { var descriptor = ServiceDescriptors.Instance.GetServiceDescriptorForServiceFactory( typeof(TService) ); var serviceHubTraceSource = (TraceSource)hostProvidedServices.GetService( typeof(TraceSource) ); var serverConnection = descriptor .WithTraceSource(serviceHubTraceSource) .ConstructRpcConnection(pipe); var args = new ServiceConstructionArguments(hostProvidedServices, serviceBroker); var service = CreateService( args, descriptor, serverConnection, serviceActivationOptions.ClientRpcTarget ); serverConnection.AddLocalRpcTarget(service); serverConnection.StartListening(); return(service); }
public ValueTask <IDuplexPipe> GetPipeAsync( ServiceMoniker serviceMoniker, ServiceActivationOptions options = default, CancellationToken cancellationToken = default) { throw new NotImplementedException(); }
public Task <object> CreateAsync( Stream stream, IServiceProvider hostProvidedServices, ServiceActivationOptions serviceActivationOptions, IServiceBroker serviceBroker, AuthorizationServiceClient?authorizationServiceClient) { // Exception from IServiceHubServiceFactory.CreateAsync are not propagated to the client. // Intercept the exception here and report it to the log. // https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1410923 try { // Dispose the AuthorizationServiceClient since we won't be using it authorizationServiceClient?.Dispose(); // First request determines the default culture: // TODO: Flow culture explicitly where needed https://github.com/dotnet/roslyn/issues/43670 if (Interlocked.CompareExchange(ref s_cultureInitialized, 1, 0) == 0) { CultureInfo.DefaultThreadCurrentUICulture = serviceActivationOptions.ClientUICulture; CultureInfo.DefaultThreadCurrentCulture = serviceActivationOptions.ClientCulture; } return(Task.FromResult((object)Create( stream.UsePipe(), hostProvidedServices, serviceActivationOptions, serviceBroker))); } catch (Exception e) when(FatalError.ReportAndPropagateUnlessCanceled(e)) { throw ExceptionUtilities.Unreachable; } }
public ValueTask <T> GetProxyAsync <T>( ServiceRpcDescriptor serviceDescriptor, ServiceActivationOptions options = default, CancellationToken cancellationToken = default) where T : class { throw new NotImplementedException(); }
private ValueTask <object> CreateSourceProviderServiceAsync( ServiceMoniker moniker, ServiceActivationOptions options, IServiceBroker serviceBroker, AuthorizationServiceClient authorizationServiceClient, CancellationToken cancellationToken) { #pragma warning disable CA2000 // Dispose objects before losing scope return(new ValueTask <object>(new NuGetSourcesService(options, serviceBroker, authorizationServiceClient))); #pragma warning restore CA2000 // Dispose objects before losing scope }
public Task <object> CreateAsync( Stream stream, IServiceProvider hostProvidedServices, ServiceActivationOptions serviceActivationOptions, IServiceBroker serviceBroker, AuthorizationServiceClient?authorizationServiceClient) { // Dispose the AuthorizationServiceClient since we won't be using it authorizationServiceClient?.Dispose(); return(Task.FromResult((object)Create(stream.UsePipe(), serviceBroker))); }
private async ValueTask <object> CreateNuGetProjectServiceV1( ServiceMoniker moniker, ServiceActivationOptions options, IServiceBroker serviceBroker, CancellationToken cancellationToken) { await _lazyInitializer.InitializeAsync(cancellationToken); IVsSolutionManager solutionManager = await _lazySolutionManager.GetValueAsync(cancellationToken); ISettings settings = await _lazySettings.GetValueAsync(cancellationToken); return(new NuGetProjectService(solutionManager, settings)); }
public NuGetPackageSearchService(ServiceActivationOptions options, IServiceBroker sb, AuthorizationServiceClient ac, ISharedServiceState state) { _options = options; _serviceBroker = sb; _authorizationServiceClient = ac; _sharedServiceState = state; _packagesFolderLocalRepositoryLazy = new Microsoft.VisualStudio.Threading.AsyncLazy <SourceRepository>( GetPackagesFolderSourceRepositoryAsync, NuGetUIThreadHelper.JoinableTaskFactory); _globalPackageFolderRepositoriesLazy = new Microsoft.VisualStudio.Threading.AsyncLazy <IReadOnlyList <SourceRepository> >( GetGlobalPackageFolderRepositoriesAsync, NuGetUIThreadHelper.JoinableTaskFactory); }
public NuGetPackageFileService( ServiceActivationOptions options, IServiceBroker serviceBroker, AuthorizationServiceClient authorizationServiceClient, INuGetTelemetryProvider nuGetTelemetryProvider) { _options = options; _serviceBroker = serviceBroker; _authorizationServiceClient = authorizationServiceClient; _nuGetTelemetryProvider = nuGetTelemetryProvider; Assumes.NotNull(_serviceBroker); Assumes.NotNull(_authorizationServiceClient); Assumes.NotNull(_nuGetTelemetryProvider); }
private async ValueTask <object> CreateSolutionManagerServiceAsync( ServiceMoniker moniker, ServiceActivationOptions options, IServiceBroker serviceBroker, AuthorizationServiceClient authorizationServiceClient, CancellationToken cancellationToken) { NuGetSolutionManagerService service = await NuGetSolutionManagerService.CreateAsync( options, serviceBroker, authorizationServiceClient, cancellationToken); return(service); }
public NuGetProjectUpgraderService( ServiceActivationOptions options, IServiceBroker serviceBroker, AuthorizationServiceClient authorizationServiceClient, ISharedServiceState state) { Assumes.NotNull(serviceBroker); Assumes.NotNull(authorizationServiceClient); Assumes.NotNull(state); _options = options; _serviceBroker = serviceBroker; _authorizationServiceClient = authorizationServiceClient; _state = state; }
public NuGetSourcesService( ServiceActivationOptions options, IServiceBroker serviceBroker, AuthorizationServiceClient authorizationServiceClient, ISharedServiceState state) { Assumes.NotNull(serviceBroker); Assumes.NotNull(authorizationServiceClient); Assumes.NotNull(state); _options = options; _serviceBroker = serviceBroker; _authorizationServiceClient = authorizationServiceClient; _sharedServiceState = state; _sharedServiceState.SourceRepositoryProvider.PackageSourceProvider.PackageSourcesChanged += PackageSourceProvider_PackageSourcesChanged; }
public static async ValueTask <NuGetSolutionManagerService> CreateAsync( ServiceActivationOptions options, IServiceBroker sb, AuthorizationServiceClient ac, CancellationToken cancellationToken) { Assumes.NotNull(sb); Assumes.NotNull(ac); cancellationToken.ThrowIfCancellationRequested(); IComponentModel componentModel = await ServiceLocator.GetGlobalServiceFreeThreadedAsync <SComponentModel, IComponentModel>(); Assumes.NotNull(componentModel); return(new NuGetSolutionManagerService(options, sb, ac, componentModel)); }
private async ValueTask <Rental> RentServiceAsync(CancellationToken cancellationToken) { // Make sure we are on the thread pool to avoid UI thread dependencies if external code uses ConfigureAwait(true) await TaskScheduler.Default; var options = new ServiceActivationOptions { ClientRpcTarget = _serviceDescriptor.CallbackDispatcher }; var proxyRental = await _serviceBrokerClient.GetProxyAsync <TService>(_serviceDescriptor, options, cancellationToken).ConfigureAwait(false); var service = proxyRental.Proxy; Contract.ThrowIfNull(service); return(new Rental(proxyRental, service)); }
internal TService Create( IDuplexPipe pipe, IServiceProvider hostProvidedServices, ServiceActivationOptions serviceActivationOptions, IServiceBroker serviceBroker) { var descriptor = ServiceDescriptors.GetServiceDescriptor(typeof(TService), isRemoteHost64Bit: IntPtr.Size == 8); var serverConnection = descriptor.ConstructRpcConnection(pipe); var args = new ServiceConstructionArguments(hostProvidedServices, serviceBroker, new CancellationTokenSource()); var service = CreateService(args, descriptor, serverConnection, serviceActivationOptions.ClientRpcTarget); serverConnection.AddLocalRpcTarget(service); serverConnection.StartListening(); return(service); }
private async ValueTask <object> CreateSourceProviderServiceAsync( ServiceMoniker moniker, ServiceActivationOptions options, IServiceBroker serviceBroker, AuthorizationServiceClient authorizationServiceClient, CancellationToken cancellationToken) { await _lazyInitializer.InitializeAsync(cancellationToken); #pragma warning disable CA2000 // Dispose objects before losing scope var service = new NuGetSourcesService( options, serviceBroker, authorizationServiceClient, _sharedServiceState); #pragma warning restore CA2000 // Dispose objects before losing scope return(service); }
private NuGetSolutionManagerService( ServiceActivationOptions options, IServiceBroker sb, AuthorizationServiceClient ac, IComponentModel componentModel) { Assumes.NotNull(sb); Assumes.NotNull(ac); _options = options; _serviceBroker = sb; _authorizationServiceClient = ac; componentModel.DefaultCompositionService.SatisfyImportsOnce(this); Assumes.NotNull(SolutionManager); RegisterEventHandlers(); }
public override async ValueTask <RemoteServiceConnection <T> > CreateConnectionAsync <T>(object?callbackTarget, CancellationToken cancellationToken) { var options = new ServiceActivationOptions(); if (callbackTarget is not null) { options.ClientRpcTarget = callbackTarget; } var assetStorage = _workspaceServices.GetRequiredService <ISolutionAssetStorageProvider>().AssetStorage; var descriptor = ServiceDescriptors.GetServiceDescriptor(typeof(T), isRemoteHost64Bit: IntPtr.Size == 8); #pragma warning disable ISB001 // Dispose of proxies - caller disposes var proxy = await _inprocServices.ServiceBroker.GetProxyAsync <T>(descriptor, options, cancellationToken).ConfigureAwait(false); #pragma warning restore Contract.ThrowIfNull(proxy); return(new BrokeredServiceConnection <T>(proxy, assetStorage, errorReportingService: null)); }
private async ValueTask <object> CreatePackageFileServiceAsync( ServiceMoniker moniker, ServiceActivationOptions options, IServiceBroker serviceBroker, AuthorizationServiceClient authorizationServiceClient, CancellationToken cancellationToken) { await _lazyInitializer.InitializeAsync(cancellationToken); INuGetTelemetryProvider telemetryProvider = await _lazyTelemetryProvider.GetValueAsync(cancellationToken); #pragma warning disable CA2000 // Dispose objects before losing scope var service = new NuGetPackageFileService( options, serviceBroker, authorizationServiceClient, telemetryProvider); #pragma warning restore CA2000 // Dispose objects before losing scope return(service); }
internal TService Create( IDuplexPipe pipe, IServiceProvider hostProvidedServices, ServiceActivationOptions serviceActivationOptions, IServiceBroker serviceBroker) { // Register this service broker globally (if it's the first we encounter) so it can be used by other // global services that need it. GlobalServiceBroker.RegisterServiceBroker(serviceBroker); var descriptor = ServiceDescriptors.Instance.GetServiceDescriptorForServiceFactory(typeof(TService)); var serviceHubTraceSource = (TraceSource)hostProvidedServices.GetService(typeof(TraceSource)); var serverConnection = descriptor.WithTraceSource(serviceHubTraceSource).ConstructRpcConnection(pipe); var args = new ServiceConstructionArguments(hostProvidedServices, serviceBroker); var service = CreateService(args, descriptor, serverConnection, serviceActivationOptions.ClientRpcTarget); serverConnection.AddLocalRpcTarget(service); serverConnection.StartListening(); return(service); }
public Task <object> CreateAsync( Stream stream, IServiceProvider hostProvidedServices, ServiceActivationOptions serviceActivationOptions, IServiceBroker serviceBroker, AuthorizationServiceClient?authorizationServiceClient) { // Dispose the AuthorizationServiceClient since we won't be using it authorizationServiceClient?.Dispose(); // First request determines the default culture: // TODO: Flow culture explicitly where needed https://github.com/dotnet/roslyn/issues/43670 if (Interlocked.CompareExchange(ref s_cultureInitialized, 1, 0) == 0) { CultureInfo.DefaultThreadCurrentUICulture = serviceActivationOptions.ClientUICulture; CultureInfo.DefaultThreadCurrentCulture = serviceActivationOptions.ClientCulture; } return(Task.FromResult((object)Create( stream.UsePipe(), hostProvidedServices, serviceActivationOptions, serviceBroker))); }
object IFactory.Create(IDuplexPipe pipe, IServiceProvider hostProvidedServices, ServiceActivationOptions serviceActivationOptions, IServiceBroker serviceBroker) => Create(pipe, hostProvidedServices, serviceActivationOptions, serviceBroker);
public async ValueTask <object> CreateNuGetProjectServiceV1(ServiceMoniker moniker, ServiceActivationOptions options, IServiceBroker serviceBroker, CancellationToken cancellationToken) { var solutionManager = await _solutionManager.GetValueAsync(cancellationToken); var settings = await _settings.GetValueAsync(cancellationToken); return(new NuGetProjectService(solutionManager, settings)); }
// This method is currently not needed for our IServiceBroker usage patterns. public ValueTask <IDuplexPipe?> GetPipeAsync(ServiceMoniker serviceMoniker, ServiceActivationOptions options, CancellationToken cancellationToken) => throw ExceptionUtilities.Unreachable;
public NuGetSourcesService(ServiceActivationOptions options, IServiceBroker serviceBroker, AuthorizationServiceClient authorizationServiceClient) { _options = options; _serviceBroker = serviceBroker; _authorizationServiceClient = authorizationServiceClient; }
public async ValueTask <T?> GetProxyAsync <T>(ServiceRpcDescriptor serviceDescriptor, ServiceActivationOptions options = default, CancellationToken cancellationToken = default) where T : class { if (this.container.profferedServices.TryGetValue(serviceDescriptor.Moniker, out object?factory)) { if (factory is BrokeredServiceFactory fac1) { T?service = (T?) await fac1(serviceDescriptor.Moniker, options, this, cancellationToken).ConfigureAwait(false); if (service is object) { return(serviceDescriptor.ConstructLocalProxy <T>(service)); } } else if (factory is AuthorizingBrokeredServiceFactory fac2) { #pragma warning disable CA2000 // Dispose objects before losing scope T?service = (T?) await fac2(serviceDescriptor.Moniker, options, this, new AuthorizationServiceClient(new MockAuthorizationService()), cancellationToken).ConfigureAwait(false); #pragma warning restore CA2000 // Dispose objects before losing scope if (service is object) { return(serviceDescriptor.ConstructLocalProxy <T>(service)); } } else { throw Assumes.NotReachable(); } } return(default);