public override async Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>( IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { var requestString = default(string); context.GetHttpContext().Request.EnableBuffering(); var response = default(TResponse); try { var sr = new StreamReader(context.GetHttpContext().Request.Body); requestString = await sr.ReadToEndAsync(); //目前讀出來會是亂碼,還找不到方式解 context.GetHttpContext().Request.Body.Position = 0; //因有使用了EnableBuffering()此extention所以才能操作position response = await base.ClientStreamingServerHandler(requestStream, context, continuation); LogInformation(context.Method, requestString, response); } catch (Exception e) { return(LogExceptionAndReturnResponse(context.Method, requestString, response, e)); } return(response); }
public async Task ClientStreamingServerHandler_Success_Test() { var authInterceptor = GetRequiredService <AuthInterceptor>(); var requestStream = new TestAsyncStreamReader <string>(new [] { "test1", "test2", "test3" }); var continuation = new ClientStreamingServerMethod <string, string>((s, y) => Task.FromResult(s.Current)); var metadata = new Metadata { { GrpcConstants.PubkeyMetadataKey, NetworkTestConstants.FakePubkey2 } }; var context = BuildServerCallContext(metadata); var headerCount = context.RequestHeaders.Count; await requestStream.MoveNext(); var result = await authInterceptor.ClientStreamingServerHandler(requestStream, context, continuation); result.ShouldBe("test1"); context.RequestHeaders.Count.ShouldBeGreaterThan(headerCount); await requestStream.MoveNext(); result = await authInterceptor.ClientStreamingServerHandler(requestStream, context, continuation); result.ShouldBe("test2"); await requestStream.MoveNext(); result = await authInterceptor.ClientStreamingServerHandler(requestStream, context, continuation); result.ShouldBe("test3"); }
public override Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>( IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { return(continuation(requestStream, context).ContinueWith(task => { if (task.Exception == null) { return task.Result; } if (task.Exception != null && task.Exception.InnerExceptions.All(exception => exception is RpcException)) { return task.Result; } _breadcrumber.ContextBreadcrumb(context); _breadcrumber.MethodBreadcrumb(continuation.Method); var exceptions = task.Exception.InnerExceptions.Where(e => !(e.InnerException is RpcException)); foreach (var exception in exceptions) { _sentryClient.Capture(new SentryEvent(exception)); } return task.Result; }, TaskContinuationOptions.OnlyOnFaulted)); }
/// <summary> /// Handles the <see cref="ClientStreamingServerHandler{TRequest,TResponse}"/> while capturing any errors /// </summary> /// <param name="requestStream">The request stream</param> /// <param name="context">The server call context</param> /// <param name="continuation">The continuation</param> /// <typeparam name="TRequest">The request type</typeparam> /// <typeparam name="TResponse">The response type</typeparam> public override async Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>( IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { var hub = _hubAccessor(); if (!hub.IsEnabled) { return(await continuation(requestStream, context).ConfigureAwait(false)); } using (hub.PushAndLockScope()) { hub.ConfigureScope(scope => { scope.OnEvaluating += (_, __) => scope.Populate <TRequest>(context, null, _options); }); try { return(await continuation(requestStream, context).ConfigureAwait(false)); } catch (Exception e) { CaptureException(hub, e); ExceptionDispatchInfo.Capture(e).Throw(); } } return(null); }
public MockServiceHelper(string host = null) { this.host = host ?? "localhost"; serviceDefinition = ServerServiceDefinition.CreateBuilder(ServiceName) .AddMethod(UnaryMethod, (request, context) => unaryHandler(request, context)) .AddMethod(ClientStreamingMethod, (requestStream, context) => clientStreamingHandler(requestStream, context)) .AddMethod(ServerStreamingMethod, (request, responseStream, context) => serverStreamingHandler(request, responseStream, context)) .AddMethod(DuplexStreamingMethod, (requestStream, responseStream, context) => duplexStreamingHandler(requestStream, responseStream, context)) .Build(); var defaultStatus = new Status(StatusCode.Unknown, "Default mock implementation. Please provide your own."); unaryHandler = new UnaryServerMethod <string, string>(async(request, context) => { context.Status = defaultStatus; return(""); }); clientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) => { context.Status = defaultStatus; return(""); }); serverStreamingHandler = new ServerStreamingServerMethod <string, string>(async(request, responseStream, context) => { context.Status = defaultStatus; }); duplexStreamingHandler = new DuplexStreamingServerMethod <string, string>(async(requestStream, responseStream, context) => { context.Status = defaultStatus; }); }
public override Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>( IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { return(continuation(requestStream, context)); }
/// <inheritdoc/> public override async Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>( IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { using var rpcScope = new ServerRpcScope <TRequest, TResponse>(context, this.options); try { var requestStreamReaderProxy = new AsyncStreamReaderProxy <TRequest>( requestStream, rpcScope.RecordRequest); var response = await continuation(requestStreamReaderProxy, context).ConfigureAwait(false); rpcScope.RecordResponse(response); rpcScope.Complete(); return(response); } catch (Exception e) { rpcScope.CompleteWithException(e); throw; } }
public ClientStreamingServerCallHandler( Method <TRequest, TResponse> method, ClientStreamingServerMethod <TService, TRequest, TResponse> invoker, GrpcServiceOptions serviceOptions, ILoggerFactory loggerFactory) : base(method, serviceOptions, loggerFactory) { _invoker = invoker; }
/// <summary> /// Adds a definition for a client streaming method. /// </summary> /// <typeparam name="TRequest">The request message class.</typeparam> /// <typeparam name="TResponse">The response message class.</typeparam> /// <param name="method">The method.</param> /// <param name="handler">The method handler.</param> public virtual void AddMethod <TRequest, TResponse>( Method <TRequest, TResponse> method, ClientStreamingServerMethod <TRequest, TResponse> handler) where TRequest : class where TResponse : class { throw new NotImplementedException(); }
public override Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>( IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { LogCall <TRequest, TResponse>(MethodType.ClientStreaming, context); return(base.ClientStreamingServerHandler(requestStream, context, continuation)); }
public override Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>( IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { throw new RpcException(new Status(StatusCode.Unimplemented, "secure streaming calls are not supported")); }
public override void AddMethod <TRequest, TResponse>(Method <TRequest, TResponse> method, ClientStreamingServerMethod <TRequest, TResponse> handler) { if (TryGetMethodDescriptor(method.Name, out var methodDescriptor) && ServiceDescriptorHelpers.TryGetHttpRule(methodDescriptor, out _)) { Log.StreamingMethodNotSupported(_logger, method.Name, typeof(TService)); } }
public override Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>( IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { SetCultureFromMetadata(context); return(base.ClientStreamingServerHandler(requestStream, context, continuation)); }
/// <summary> /// Adds a definitions for a client streaming method. /// </summary> /// <typeparam name="TRequest">The request message class.</typeparam> /// <typeparam name="TResponse">The response message class.</typeparam> /// <param name="method">The method.</param> /// <param name="handler">The method handler.</param> /// <returns>This builder instance.</returns> public Builder AddMethod <TRequest, TResponse>( Method <TRequest, TResponse> method, ClientStreamingServerMethod <TRequest, TResponse> handler) where TRequest : class where TResponse : class { callHandlers.Add(method.FullName, ServerCalls.ClientStreamingCall(method, handler)); return(this); }
/// <summary> /// Adds a definition for a client streaming method. /// </summary> /// <typeparam name="TRequest">The request message class.</typeparam> /// <typeparam name="TResponse">The response message class.</typeparam> /// <param name="method">The method.</param> /// <param name="handler">The method handler.</param> /// <returns>This builder instance.</returns> public Builder AddMethod <TRequest, TResponse>( Method <TRequest, TResponse> method, ClientStreamingServerMethod <TRequest, TResponse> handler) where TRequest : class where TResponse : class { duplicateDetector.Add(method.FullName, null); addMethodActions.Add((serviceBinder) => serviceBinder.AddMethod(method, handler)); return(this); }
private ClientStreamingServerMethod <TRequest, TResponse> getClientStreamingServerHandlerChain <TRequest, TResponse>(Interceptor interceptor, ClientStreamingServerMethod <TRequest, TResponse> continuation) where TRequest : class where TResponse : class { ClientStreamingServerMethod <TRequest, TResponse> fun = (fRequest, fContext) => { return(interceptor.ClientStreamingServerHandler(fRequest, fContext, continuation)); }; return(fun); }
public string AddClientStreamingMethod <TRequest, TResponse>(ClientStreamingServerMethod <TRequest, TResponse> callHandler, string?methodName = null) where TRequest : class, IMessage, new() where TResponse : class, IMessage, new() { var method = CreateMethod <TRequest, TResponse>(MethodType.ClientStreaming, methodName ?? Guid.NewGuid().ToString()); AddServiceCore(c => { c.AddClientStreamingMethod(method, new List <object>(), new ClientStreamingServerMethod <DynamicService, TRequest, TResponse>((service, stream, context) => callHandler(stream, context))); }); return(method.FullName); }
public override async Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>( IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { if (!(await IsJwtValid(context.GetAccessToken(), _logger))) { context.Status = new Status(StatusCode.Unauthenticated, "Invalid token"); return(default(TResponse)); } return(await continuation(requestStream, context)); }
public async Task Auth_ClientStreamingServerHandler_Failed_Test() { var authInterceptor = GetRequiredService <AuthInterceptor>(); var request = Mock.Of <IAsyncStreamReader <string> >(); var continuation = new ClientStreamingServerMethod <string, string>((s, y) => Task.FromResult("test")); var metadata = new Metadata { { GrpcConstants.PubkeyMetadataKey, "invalid-pubkey" } }; var context = BuildServerCallContext(metadata); var result = await authInterceptor.ClientStreamingServerHandler(request, context, continuation); result.ShouldBeNull(); }
public string AddClientStreamingMethod <TService, TRequest, TResponse>(ClientStreamingServerMethod <TRequest, TResponse> callHandler, string methodName = null) where TService : class where TRequest : class, IMessage, new() where TResponse : class, IMessage, new() { var method = CreateMethod <TService, TRequest, TResponse>(MethodType.ClientStreaming, methodName ?? Guid.NewGuid().ToString()); Mock <IGrpcMethodModelFactory <TService> > mockFactory = new Mock <IGrpcMethodModelFactory <TService> >(); mockFactory.Setup(m => m.CreateClientStreamingModel(method)).Returns(() => CreateModel(new ClientStreamingServerMethod <TService, TRequest, TResponse>((service, stream, context) => callHandler(stream, context)))); AddServiceCore((binder, _) => binder.AddMethod(method, (ClientStreamingServerMethod <TRequest, TResponse>)null), mockFactory.Object); return(method.FullName); }
public override async Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>( IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { try { return(await base.ClientStreamingServerHandler(requestStream, context, continuation).ConfigureAwait(false)); } catch (Exception ex) { _interceptor.OnError(new ServerCallInterceptorContext(context), ex); throw; } }
/// <summary> /// Creates a new instance of <see cref="ClientStreamingServerMethodInvoker{TService, TRequest, TResponse}"/>. /// </summary> /// <param name="invoker">The client streaming method to invoke.</param> /// <param name="method">The description of the gRPC method.</param> /// <param name="options">The options used to execute the method.</param> /// <param name="serviceActivator">The service activator used to create service instances.</param> public ClientStreamingServerMethodInvoker( ClientStreamingServerMethod <TService, TRequest, TResponse> invoker, Method <TRequest, TResponse> method, MethodOptions options, IGrpcServiceActivator <TService> serviceActivator) : base(method, options, serviceActivator) { _invoker = invoker; if (Options.HasInterceptors) { var interceptorPipeline = new InterceptorPipelineBuilder <TRequest, TResponse>(Options.Interceptors); _pipelineInvoker = interceptorPipeline.ClientStreamingPipeline(ResolvedInterceptorInvoker); } }
public ClientStreamingServerCallHandler( Method <TRequest, TResponse> method, ClientStreamingServerMethod <TService, TRequest, TResponse> invoker, MethodContext methodContext, ILoggerFactory loggerFactory, IGrpcServiceActivator <TService> serviceActivator, IServiceProvider serviceProvider) : base(method, methodContext, loggerFactory, serviceActivator, serviceProvider) { _invoker = invoker; if (MethodContext.HasInterceptors) { var interceptorPipeline = new InterceptorPipelineBuilder <TRequest, TResponse>(MethodContext.Interceptors, ServiceProvider); _pipelineInvoker = interceptorPipeline.ClientStreamingPipeline(ResolvedInterceptorInvoker); } }
public override void AddMethod <TRequest, TResponse>(Method <TRequest, TResponse> method, ClientStreamingServerMethod <TRequest, TResponse> handler) { _server._methodHandlers.Add(method.FullName, async ctx => { try { var response = await handler( ctx.GetMessageReader(method.RequestMarshaller), ctx.CallContext).ConfigureAwait(false); ctx.Success(SerializationHelpers.Serialize(method.ResponseMarshaller, response)); } catch (Exception ex) { ctx.Error(ex); } }); }
static ClientStreamingServerMethod<TRequest, TResponse> BuildInvoker( InterceptorActivatorHandle interceptorActivatorHandle, ClientStreamingServerMethod<TRequest, TResponse> next) { return async (requestStream, context) => { var serviceProvider = context.GetHttpContext().RequestServices; var interceptorActivator = interceptorActivatorHandle.GetActivator(serviceProvider); var interceptorHandle = CreateInterceptor(interceptorActivatorHandle, interceptorActivator, serviceProvider); try { return await interceptorHandle.Instance.ClientStreamingServerHandler(requestStream, context, next); } finally { await interceptorActivator.ReleaseAsync(interceptorHandle); } }; }
public override Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>( IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { GrpcMethodInfo method = new GrpcMethodInfo(context.Method, MethodType.ClientStreaming); metrics.RequestCounterInc(method); Stopwatch watch = new Stopwatch(); watch.Start(); Task <TResponse> result; try { result = continuation( new WrapperStreamReader <TRequest>(requestStream, () => { metrics.StreamReceivedCounterInc(method); }), context); metrics.ResponseCounterInc(method, StatusCode.OK); } catch (RpcException e) { metrics.ResponseCounterInc(method, e.Status.StatusCode); throw; } finally { watch.Stop(); if (enableLatencyMetrics) { metrics.RecordLatency(method, watch.Elapsed.TotalSeconds); } } return(result); }
public ClientStreamingServerCallHandler( Method <TRequest, TResponse> method, ClientStreamingServerMethod <TService, TRequest, TResponse> invoker, GrpcServiceOptions serviceOptions, ILoggerFactory loggerFactory, IGrpcServiceActivator <TService> serviceActivator, IServiceProvider serviceProvider) : base(method, serviceOptions, loggerFactory, serviceActivator, serviceProvider) { _invoker = invoker; if (ServiceOptions.HasInterceptors) { ClientStreamingServerMethod <TRequest, TResponse> resolvedInvoker = async(resolvedRequestStream, resolvedContext) => { var activator = ServiceProvider.GetRequiredService <IGrpcServiceActivator <TService> >(); GrpcActivatorHandle <TService> serviceHandle = default; try { serviceHandle = activator.Create(resolvedContext.GetHttpContext().RequestServices); return(await invoker( serviceHandle.Instance, resolvedRequestStream, resolvedContext)); } finally { if (serviceHandle.Instance != null) { activator.Release(serviceHandle); } } }; var interceptorPipeline = new InterceptorPipelineBuilder <TRequest, TResponse>(ServiceOptions.Interceptors, ServiceProvider); _pipelineInvoker = interceptorPipeline.ClientStreamingPipeline(resolvedInvoker); } }
public override async Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>( IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { try { return(await continuation(requestStream, context)); } catch (RpcException) { throw; } catch (Exception e) { _breadcrumber.GeneralInformationBreadcrumb(); _breadcrumber.ContextBreadcrumb(context); _breadcrumber.MethodBreadcrumb(continuation.Method); _sentryClient.Capture(new SentryEvent(e)); throw; } }
public ClientStreamingServerCallHandler( Method <TRequest, TResponse> method, ClientStreamingServerMethod <TService, TRequest, TResponse> invoker, GrpcServiceOptions serviceOptions, ILoggerFactory loggerFactory) : base(method, serviceOptions, loggerFactory) { _invoker = invoker; if (!ServiceOptions.Interceptors.IsEmpty) { ClientStreamingServerMethod <TRequest, TResponse> resolvedInvoker = async(resolvedRequestStream, resolvedContext) => { var activator = resolvedContext.GetHttpContext().RequestServices.GetRequiredService <IGrpcServiceActivator <TService> >(); TService?service = null; try { service = activator.Create(); return(await invoker( service, resolvedRequestStream, resolvedContext)); } finally { if (service != null) { activator.Release(service); } } }; var interceptorPipeline = new InterceptorPipelineBuilder <TRequest, TResponse>(ServiceOptions.Interceptors); _pipelineInvoker = interceptorPipeline.ClientStreamingPipeline(resolvedInvoker); } }
public override async Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>(IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation) { (string, string)tuple = InterceptCallContext(context); var watch = Stopwatch.StartNew(); var result = await continuation(requestStream, context); Logger.Log.GrpcTrace(m_loggingContext, string.Format(RespondedLogFormat, tuple.Item1, tuple.Item2, watch.ElapsedMilliseconds)); return(result); }
public MockServiceHelper(string host = null) { this.host = host ?? "localhost"; serviceDefinition = ServerServiceDefinition.CreateBuilder(ServiceName) .AddMethod(UnaryMethod, (request, context) => unaryHandler(request, context)) .AddMethod(ClientStreamingMethod, (requestStream, context) => clientStreamingHandler(requestStream, context)) .AddMethod(ServerStreamingMethod, (request, responseStream, context) => serverStreamingHandler(request, responseStream, context)) .AddMethod(DuplexStreamingMethod, (requestStream, responseStream, context) => duplexStreamingHandler(requestStream, responseStream, context)) .Build(); var defaultStatus = new Status(StatusCode.Unknown, "Default mock implementation. Please provide your own."); unaryHandler = new UnaryServerMethod<string, string>(async (request, context) => { context.Status = defaultStatus; return ""; }); clientStreamingHandler = new ClientStreamingServerMethod<string, string>(async (requestStream, context) => { context.Status = defaultStatus; return ""; }); serverStreamingHandler = new ServerStreamingServerMethod<string, string>(async (request, responseStream, context) => { context.Status = defaultStatus; }); duplexStreamingHandler = new DuplexStreamingServerMethod<string, string>(async (requestStream, responseStream, context) => { context.Status = defaultStatus; }); }
public MockServiceHelper(string host = null, Marshaller<string> marshaller = null, IEnumerable<ChannelOption> channelOptions = null) { this.host = host ?? "localhost"; this.channelOptions = channelOptions; marshaller = marshaller ?? Marshallers.StringMarshaller; unaryMethod = new Method<string, string>( MethodType.Unary, ServiceName, "Unary", marshaller, marshaller); clientStreamingMethod = new Method<string, string>( MethodType.ClientStreaming, ServiceName, "ClientStreaming", marshaller, marshaller); serverStreamingMethod = new Method<string, string>( MethodType.ServerStreaming, ServiceName, "ServerStreaming", marshaller, marshaller); duplexStreamingMethod = new Method<string, string>( MethodType.DuplexStreaming, ServiceName, "DuplexStreaming", marshaller, marshaller); serviceDefinition = ServerServiceDefinition.CreateBuilder() .AddMethod(unaryMethod, (request, context) => unaryHandler(request, context)) .AddMethod(clientStreamingMethod, (requestStream, context) => clientStreamingHandler(requestStream, context)) .AddMethod(serverStreamingMethod, (request, responseStream, context) => serverStreamingHandler(request, responseStream, context)) .AddMethod(duplexStreamingMethod, (requestStream, responseStream, context) => duplexStreamingHandler(requestStream, responseStream, context)) .Build(); var defaultStatus = new Status(StatusCode.Unknown, "Default mock implementation. Please provide your own."); unaryHandler = new UnaryServerMethod<string, string>(async (request, context) => { context.Status = defaultStatus; return ""; }); clientStreamingHandler = new ClientStreamingServerMethod<string, string>(async (requestStream, context) => { context.Status = defaultStatus; return ""; }); serverStreamingHandler = new ServerStreamingServerMethod<string, string>(async (request, responseStream, context) => { context.Status = defaultStatus; }); duplexStreamingHandler = new DuplexStreamingServerMethod<string, string>(async (requestStream, responseStream, context) => { context.Status = defaultStatus; }); }