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>())); }
public async Task ProfferServicesAsync_WithAuthorizingBrokeredServiceFactoryService_ProffersService( ServiceRpcDescriptor serviceDescriptor, Type serviceType) { using (await NuGetBrokeredServiceFactory.ProfferServicesAsync(this)) { Assert.True( _authorizingServiceFactories.TryGetValue( serviceDescriptor, out AuthorizingBrokeredServiceFactory factory)); using (var authorizationServiceClient = new AuthorizationServiceClient(new MockAuthorizationService())) { object service = await factory( serviceDescriptor.Moniker, default(ServiceActivationOptions), new MockServiceBroker(), authorizationServiceClient, CancellationToken.None); using (service as IDisposable) { Assert.IsType(serviceType, service); } } } }
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);
public ValueTask <T> GetProxyAsync <T>( ServiceRpcDescriptor serviceDescriptor, ServiceActivationOptions options = default, CancellationToken cancellationToken = default) where T : class { throw new NotImplementedException(); }
/// <summary> /// Use to perform a callback from ServiceHub process to an arbitrary brokered service hosted in the original process (usually devenv). /// </summary> public static async ValueTask <TResult> InvokeServiceAsync <TResult>( ServiceBrokerClient client, ServiceRpcDescriptor serviceDescriptor, Func <RemoteCallback <T>, CancellationToken, ValueTask <TResult> > invocation, CancellationToken cancellationToken) { ServiceBrokerClient.Rental <T> rental; try { rental = await client.GetProxyAsync <T>(serviceDescriptor, cancellationToken).ConfigureAwait(false); } catch (ObjectDisposedException e) { // When a connection is dropped ServiceHub's ServiceManager disposes the brokered service, which in turn disposes the ServiceBrokerClient. cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledIgnoringCallerTokenException(e); } Contract.ThrowIfNull(rental.Proxy); var callback = new RemoteCallback <T>(rental.Proxy); return(await invocation(callback, cancellationToken).ConfigureAwait(false)); }
public IDisposable Proffer(ServiceRpcDescriptor serviceDescriptor, AuthorizingBrokeredServiceFactory factory) { _authorizingServiceFactories.Add(serviceDescriptor, factory); return(null); }
/// <inheritdoc/> public IDisposable Proffer(ServiceRpcDescriptor serviceDescriptor, AuthorizingBrokeredServiceFactory factory) { this.profferedServices.Add(serviceDescriptor.Moniker, factory); return(new DisposableAction(this, serviceDescriptor.Moniker)); }