private static RpcEndpointOptions BuildOptions(Action <RpcEndpointOptions> configuration)
{
var options = new RpcEndpointOptions();
configuration?.Invoke(options);
return(options);
}
/// <summary>
/// Given successful result, returns Http status code 200 (OK) and uses <see cref="JsonSerializer"/> for serializing the response body.
/// Otherwise, http status code 404 - NotFound is returned with an empty body.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="jsonOptions">The Json options used for serialization.</param>
/// <returns>The updated options.</returns>
public static RpcEndpointOptions UseSystemJsonForOkOrNotFoundResult(this RpcEndpointOptions options, JsonSerializerOptions?jsonOptions = null)
{
options.SerializeResponse = async(response, cancellationToken) =>
{
var(result, context) = response;
await(result switch
{
SuccessfullyProcessedRequestResult r => context
.WithStatus(HttpStatusCode.OK)
.WithContentType(JsonContentType)
.Complete(r.Response, jsonOptions, cancellationToken),
NotFoundRequestResult r => context
.WithStatus(HttpStatusCode.NotFound)
.Complete($"{r.RequestName} not found", jsonOptions, cancellationToken),
RequestNameRouteValueNotFoundResult r => context
.WithStatus(HttpStatusCode.NotFound)
.WithContentType(JsonContentType)
.Complete(),
_ => context
.WithStatus(HttpStatusCode.OK)
.Complete(result, jsonOptions, cancellationToken)
});;
};
public static IApplicationBuilder UseGrpcService(this IApplicationBuilder app, IConfiguration configuration)
{
var option = new RpcEndpointOptions();
configuration.GetSection("ServiceDiscovery").GetSection("RpcEndpoint").Bind(option);
app.UseGrpcService(option);
return(app);
}
internal static void ValidateOptions(RpcEndpointOptions options)
{
AssertHelper.ValidateIsNotNull(options.Path, nameof(options.Path));
AssertHelper.ValidateIsNotNull(options.SerializeResponse, nameof(options.SerializeResponse));
AssertHelper.ValidateIsNotNull(options.DeserializeRequest, nameof(options.DeserializeRequest));
AssertHelper.ValidateIsNotEmpty(options.Path, nameof(options.Path));
}
public RpcMiddleware(RequestDelegate next, RpcEndpointOptions options, IRpcRequestRunner rpcCaller)
{
RpcMiddlewareValidator.ValidateOptions(options);
RpcMiddlewareValidator.ValidateCaller(rpcCaller);
this.rpcCaller = rpcCaller;
this.options = options;
this.next = next;
}
private static GRpcServer InitializeGrpcServer(RpcEndpointOptions options)
{
var grpcServer = new GRpcServer
{
Ports = { new ServerPort(options.Address, options.Port, ServerCredentials.Insecure) },
Services = { MagicOnionEngine.BuildServerServiceDefinition() }
};
grpcServer.Start();
return(grpcServer);
}
/// <summary>
/// Use <see cref="JsonSerializer"/> for deserializing requests and serializing responses.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="jsonOptions">Optional custom serialization settings.</param>
/// <returns>The updated options.</returns>
public static RpcEndpointOptions UseSystemJsonForDeserializeBody(this RpcEndpointOptions options, JsonSerializerOptions?jsonOptions = null)
{
jsonOptions ??= new JsonSerializerOptions();
options.DeserializeRequest = async(request, cancellationToken) =>
{
var(requestType, context) = request;
var hasContent = context.Request.ContentLength > 0;
return(hasContent
? await DeserializeJsonBody(requestType, context.Request.Body, jsonOptions, cancellationToken)
: CreateDefault(requestType));
};
return(options);
}
/// <summary>
/// Here we use custom serialization code, in this case just use NewtonSoft's Json.NET.
/// </summary>
public static RpcEndpointOptions SerializeWithJsonNet(this RpcEndpointOptions options, JsonSerializerSettings settings)
{
options.DeserializeRequest = async(req, cancellationToken) =>
{
var(targetType, httpContext) = req;
var request = httpContext.Request;
if (request.ContentLength > 0)
{
using var reader = new StreamReader(request.Body);
var body = await reader.ReadToEndAsync();
return(JsonConvert.DeserializeObject(body, targetType, settings));
}
return(Activator.CreateInstance(targetType));
};
return(options);
}
/// <summary>
/// As we are using a custom common app response for all handlers, we can commonly handle special logic here.
/// </summary>
public static RpcEndpointOptions HandleCommonAppResponse(this RpcEndpointOptions options)
{
options.SerializeResponse = async(res, cancellationToken) =>
{
var(result, httpContext) = res;
if (result is SuccessfullyProcessedRequestResult succResult)
{
if (succResult.Response is CommonAppResponse response)
{
if (response.ValidationErrors.Any())
{
httpContext.Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
await httpContext.WriteAsJson(response.ValidationErrors, cancellationToken);
}
if (response.Response == null)
{
httpContext.Response.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
}
httpContext.Response.StatusCode = (int)System.Net.HttpStatusCode.OK;
await httpContext.WriteAsJson(response.Response, cancellationToken);
}
else
{
httpContext.Response.StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
}
}
else if (result is NotFoundRequestResult notFoundResult)
{
httpContext.Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
await httpContext.Response.WriteAsync(notFoundResult.RequestName, cancellationToken);
}
};
return(options);
}
public static IApplicationBuilder UseGrpcService(this IApplicationBuilder app, RpcEndpointOptions rpcEndpointOptions)
{
var applicationLifetime = app.ApplicationServices.GetRequiredService <IApplicationLifetime>() ??
throw new ArgumentException("Missing Dependency", nameof(IApplicationLifetime));
// 开启rpc服务
var grpcServer = InitializeGrpcServer(rpcEndpointOptions);
applicationLifetime.ApplicationStopping.Register(() =>
{
try
{
grpcServer.ShutdownAsync().Wait();
}
catch (Exception ex)
{
Console.WriteLine($"grpcServer had shutown {ex}");
}
});
return(app);
}
