private void CreateGrpcMethodForCqrsChannel <TRequest, TResponse, TChRequest, TChResponse, TChResponseEnvelope>(GrpcServer server, string serverId, CqrsChannelInfo info)
where TRequest : class
where TResponse : class
where TChRequest : class
where TChResponse : class
where TChResponseEnvelope : class
{
var builder = ServerServiceDefinition.CreateBuilder();
var method = GrpcMethodFactoryUtil.CreateGrpcMethod <TChRequest, TChResponseEnvelope>(info.ServiceName, info.MethodName);
var handler = new UnaryServerMethod <TChRequest, TChResponseEnvelope>(async(chReq, ctx) => {
// timeout
var cancellationToken = ctx.CancellationToken.AddTimeout(_configuration.TimeoutMs);
// execute in scope
using (Scope scope = AsyncScopedLifestyle.BeginScope(_container))
{
// execute method
var chRspEnv = await GrpcChannelHandlerUtil.HandleChannelRequest <TRequest, TResponse, TChRequest, TChResponse, TChResponseEnvelope>(
scope.Container,
_mapper,
ctx,
serverId,
info,
chReq,
cancellationToken);
return(chRspEnv);
}
});
// add method to server
builder.AddMethod(method, handler);
var service = builder.Build();
server.Services.Add(service);
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(IIFExportConfigSvcBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_GetTenancyExportConfig, serviceImpl.GetTenancyExportConfig)
.AddMethod(__Method_SetTenancyExportConfig, serviceImpl.SetTenancyExportConfig)
.AddMethod(__Method_UpdateDropboxAccessToken, serviceImpl.UpdateDropboxAccessToken).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
#pragma warning disable 0618
public static ServerServiceDefinition BindService(PingServerBase serviceImpl)
#pragma warning restore 0618
{
return(ServerServiceDefinition.CreateBuilder(__ServiceName)
.AddMethod(__Method_Hello, serviceImpl.Hello)
.AddMethod(__Method_HelloRandom, serviceImpl.HelloRandom).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(TraceServiceBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_ListTraces, serviceImpl.ListTraces)
.AddMethod(__Method_GetTrace, serviceImpl.GetTrace)
.AddMethod(__Method_PatchTraces, serviceImpl.PatchTraces).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(MessengerBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_Login, serviceImpl.Login)
.AddMethod(__Method_SendTextMessage, serviceImpl.SendTextMessage)
.AddMethod(__Method_RequestPendingMessages, serviceImpl.RequestPendingMessages).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
#pragma warning disable 0618
public static ServerServiceDefinition BindService(MetricsServiceBase serviceImpl)
#pragma warning restore 0618
{
return(ServerServiceDefinition.CreateBuilder(__ServiceName)
.AddMethod(__Method_GetAllGauges, serviceImpl.GetAllGauges)
.AddMethod(__Method_GetGauge, serviceImpl.GetGauge).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(RatingsServiceBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_RateVideo, serviceImpl.RateVideo)
.AddMethod(__Method_GetRating, serviceImpl.GetRating)
.AddMethod(__Method_GetUserRating, serviceImpl.GetUserRating).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(RPCDemoServiceBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_Add, serviceImpl.Add)
.AddMethod(__Method_GetById, serviceImpl.GetById)
.AddMethod(__Method_Get, serviceImpl.Get).Build());
}
// creates service definition that can be registered with a server
#pragma warning disable 0618
public static ServerServiceDefinition BindService(ReconnectServiceBase serviceImpl)
#pragma warning restore 0618
{
return(ServerServiceDefinition.CreateBuilder(__ServiceName)
.AddMethod(__Method_Start, serviceImpl.Start)
.AddMethod(__Method_Stop, serviceImpl.Stop).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(ErrorStatsServiceBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_ListGroupStats, serviceImpl.ListGroupStats)
.AddMethod(__Method_ListEvents, serviceImpl.ListEvents)
.AddMethod(__Method_DeleteEvents, serviceImpl.DeleteEvents).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(UploadsServiceBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_GetUploadDestination, serviceImpl.GetUploadDestination)
.AddMethod(__Method_MarkUploadComplete, serviceImpl.MarkUploadComplete)
.AddMethod(__Method_GetStatusOfVideo, serviceImpl.GetStatusOfVideo).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
/// <param name="serviceImpl">An object implementing the server-side handling logic.</param>
public static ServerServiceDefinition BindService(GameRecordServiceBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_UpsertGameRecord, serviceImpl.UpsertGameRecord)
.AddMethod(__Method_ListGameRecord, serviceImpl.ListGameRecord)
.AddMethod(__Method_GetGameRecord, serviceImpl.GetGameRecord).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(AccountingTxnSvcBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_AssignGuestOwnerToTransaction, serviceImpl.AssignGuestOwnerToTransaction)
.AddMethod(__Method_GetExportJobStatus, serviceImpl.GetExportJobStatus)
.AddMethod(__Method_UploadPropertyTransactionsInFormat, serviceImpl.UploadPropertyTransactionsInFormat).Build());
}
public void UnknownMethodHandler()
{
Server server = new Server();
server.AddServiceDefinition(
ServerServiceDefinition.CreateBuilder(serviceName).Build());
int port = server.AddListeningPort(host + ":0");
server.Start();
using (Channel channel = new Channel(host + ":" + port))
{
var call = new Call <string, string>(serviceName, unaryEchoStringMethod, channel, Metadata.Empty);
try
{
Calls.BlockingUnaryCall(call, "ABC", default(CancellationToken));
Assert.Fail();
}
catch (RpcException e)
{
Assert.AreEqual(StatusCode.Unimplemented, e.Status.StatusCode);
}
}
server.ShutdownAsync().Wait();
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(EntryDataServiceBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_GetEntryStatus, serviceImpl.GetEntryStatus)
.AddMethod(__Method_GetYDTEntryDataFrom, serviceImpl.GetYDTEntryDataFrom)
.AddMethod(__Method_GetYDTEntryDataAt, serviceImpl.GetYDTEntryDataAt).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(CheckInServiceBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_StartStay, serviceImpl.StartStay)
.AddMethod(__Method_GetPreCheckinInfo, serviceImpl.GetPreCheckinInfo)
.AddMethod(__Method_SetPreCheckinInfo, serviceImpl.SetPreCheckinInfo).Build());
}
public async Task UnaryServerHandler_NoAuth_Test(string methodName)
{
var helper = new MockServiceBuilder();
var unaryHandler = new UnaryServerMethod <string, string>((request, context) => Task.FromResult("ok"));
var method = new Method <string, string>(
MethodType.Unary,
nameof(PeerService),
methodName,
Marshallers.StringMarshaller,
Marshallers.StringMarshaller);
var serverServiceDefinition = ServerServiceDefinition.CreateBuilder()
.AddMethod(method, (request, context) => unaryHandler(request, context)).Build()
.Intercept(_authInterceptor);
helper.ServiceDefinition = serverServiceDefinition;
_server = helper.GetServer();
_server.Start();
_channel = helper.GetChannel();
var result = await Calls.AsyncUnaryCall(new CallInvocationDetails <string, string>(_channel, method, default),
"");
result.ShouldBe("ok");
}
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;
});
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(SpeechBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_SyncRecognize, serviceImpl.SyncRecognize)
.AddMethod(__Method_AsyncRecognize, serviceImpl.AsyncRecognize)
.AddMethod(__Method_StreamingRecognize, serviceImpl.StreamingRecognize).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(PricingSvcBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_QueryByRoomType, serviceImpl.QueryByRoomType)
.AddMethod(__Method_QueryByProperty, serviceImpl.QueryByProperty)
.AddMethod(__Method_Update, serviceImpl.Update).Build());
}
/// <summary>
/// 指定された型に対するサービス定義を生成します。
/// </summary>
/// <param name="serviceName">サービス名</param>
/// <param name="serviceType">サービスの型</param>
/// <param name="serviceInstance">サービスインスタンス</param>
/// <param name="settings">動作設定</param>
/// <returns></returns>
public ServerServiceDefinition BuildService(string serviceName, Type serviceType, object serviceInstance, GrpcServiceBuilderSettings settings)
{
settings = settings ?? new GrpcServiceBuilderSettings();
ServerServiceDefinition.Builder builder = ServerServiceDefinition.CreateBuilder();
Type implType = serviceInstance.GetType();
IList <IGrpcServerMethodInvokingInterceptor> classInvokingInterceptors = GetInvokingInterceptors(implType);
IList <IGrpcServerMethodInvokedInterceptor> classInvokedInterceptors = GetInvokedInterceptors(implType);
foreach (GrpcMethodHandlerInfo method in GrpcReflection.EnumerateServiceMethods(implType))
{
IList <IGrpcServerMethodInvokingInterceptor> methodInvokingInterceptors = GetInvokingInterceptors(method.Handler);
IList <IGrpcServerMethodInvokedInterceptor> methodInvokedInterceptors = GetInvokedInterceptors(method.Handler);
MethodBuildContext context = new MethodBuildContext(serviceName, serviceType, serviceInstance, method.MethodType, method.RequestType, method.ResponseType, method.Handler, settings
, Sort <IGrpcServerMethodInvokingInterceptor>(CompareInterceptor, new IEnumerable <IGrpcServerMethodInvokingInterceptor>[] { settings.InvokingInterceptors, classInvokingInterceptors, methodInvokingInterceptors })
, Sort <IGrpcServerMethodInvokedInterceptor>(CompareInterceptor, new IEnumerable <IGrpcServerMethodInvokedInterceptor>[] { settings.InvokedInterceptors, classInvokedInterceptors, methodInvokedInterceptors })
, Sort <IGrpcServerMethodExceptionHandler>(CompareInterceptor, new IEnumerable <IGrpcServerMethodExceptionHandler>[] { settings.ExceptionHandlers })
);
AddServiceMethod(builder, context);
}
return(builder.Build());
}
public GrpcHostBuilder(IServiceProvider serviceProvider, ISerializer serializer, IOptions <RpcServerOptions> options)
{
this._serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
this._builder = ServerServiceDefinition.CreateBuilder();
this._serializer = serializer;
this._options = options.Value;
}
/// <summary>Creates service definition that can be registered with a server</summary>
/// <param name="serviceImpl">An object implementing the server-side handling logic.</param>
public static ServerServiceDefinition BindService(IAMPolicyBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_SetIamPolicy, serviceImpl.SetIamPolicy)
.AddMethod(__Method_GetIamPolicy, serviceImpl.GetIamPolicy)
.AddMethod(__Method_TestIamPermissions, serviceImpl.TestIamPermissions).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(SessionSvcBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_TryStartSession, serviceImpl.TryStartSession)
.AddMethod(__Method_RefreshAccessToken, serviceImpl.RefreshAccessToken)
.AddMethod(__Method_InvalidateRefreshToken, serviceImpl.InvalidateRefreshToken).Build());
}
private static ServerServiceDefinition BuildDefinitions(MethodType methodType, Method <TRequest, TResponse> method, TServiceImpl instance)
{
var builder = ServerServiceDefinition.CreateBuilder();
switch (methodType)
{
case MethodType.Unary:
builder.AddMethod(method, CreateGrpcDelegate <UnaryServerMethod <TRequest, TResponse> >());
break;
case MethodType.ClientStreaming:
builder.AddMethod(method, CreateGrpcDelegate <ClientStreamingServerMethod <TRequest, TResponse> >());
break;
case MethodType.ServerStreaming:
builder.AddMethod(
method, CreateGrpcDelegate <ServerStreamingServerMethod <TRequest, TResponse> >());
break;
case MethodType.DuplexStreaming:
builder.AddMethod(method, CreateGrpcDelegate <DuplexStreamingServerMethod <TRequest, TResponse> >());
break;
}
return(builder.Build());
TDelegate CreateGrpcDelegate <TDelegate>() where TDelegate : Delegate
{
var grpcDelegate = Delegate.CreateDelegate(typeof(TDelegate), instance, method.Name);
return((TDelegate)grpcDelegate);
}
}
// creates service definition that can be registered with a server
#pragma warning disable 0618
public static ServerServiceDefinition BindService(BenchmarkServiceBase serviceImpl)
#pragma warning restore 0618
{
return(ServerServiceDefinition.CreateBuilder(__ServiceName)
.AddMethod(__Method_UnaryCall, serviceImpl.UnaryCall)
.AddMethod(__Method_StreamingCall, serviceImpl.StreamingCall).Build());
}
private static async Task RunAsync()
{
var server = new Grpc.Core.Server
{
Ports = { { "127.0.0.1", 5000, ServerCredentials.Insecure } },
Services =
{
ServerServiceDefinition.CreateBuilder()
.AddMethod(Descriptors.Method, async(requestStream, responseStream, context) =>
{
await requestStream.ForEachAsync(async additionRequest =>
{
// handle incoming request
// push response into stream
Console.WriteLine($"Recieved addition request, number1 = {additionRequest.X} --- number2 = {additionRequest.Y}");
await responseStream.WriteAsync(new AdditionResponse {
Output = additionRequest.X + additionRequest.Y
});
});
})
.Build()
}
};
server.Start();
Console.WriteLine($"Server started under [127.0.0.1:5000]. Press Enter to stop it...");
Console.ReadLine();
await server.ShutdownAsync();
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(HousekeepingManagementSvcBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_GetAssignmentsByDate, serviceImpl.GetAssignmentsByDate)
.AddMethod(__Method_AssignHousekeeperToRoomsNow, serviceImpl.AssignHousekeeperToRoomsNow)
.AddMethod(__Method_UpdateRoomStatus, serviceImpl.UpdateRoomStatus).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(CheckoutSvcBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_GetCheckoutCandidateViability, serviceImpl.GetCheckoutCandidateViability)
.AddMethod(__Method_CheckOutReservation, serviceImpl.CheckOutReservation)
.AddMethod(__Method_AmendForEarlyImmediateCheckout, serviceImpl.AmendForEarlyImmediateCheckout).Build());
}
/// <summary>Creates service definition that can be registered with a server</summary>
public static ServerServiceDefinition BindService(ForeignPropertyConfigurationSvcBase serviceImpl)
{
return(ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_Get, serviceImpl.Get)
.AddMethod(__Method_Create, serviceImpl.Create)
.AddMethod(__Method_Update, serviceImpl.Update)
.AddMethod(__Method_Remove, serviceImpl.Remove).Build());
}
