Example #1
0
        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);
        }
Example #2
0
        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));
        }
Example #4
0
        /// <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);
        }
Example #5
0
        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;
            }
        }
Example #8
0
 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();
 }
Example #10
0
 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));
 }
Example #11
0
 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"));
 }
Example #12
0
 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);
 }
Example #15
0
 /// <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);
 }
Example #16
0
        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));
        }
Example #19
0
        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);
        }
Example #21
0
 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;
     }
 }
Example #22
0
        /// <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);
            }
        }
Example #24
0
 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);
        }
Example #27
0
        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);
            }
        }
Example #28
0
        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);
            }
        }
Example #30
0
        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;
            });
        }