public async Task AsyncRequestTest()
{
/*
* IClientMessageHandler<AmpMessage> handler,
* IRpcClient<AmpMessage> rpcClient,
* ISerializer serializer,
* ILogger<DefaultCallInvoker> logger
*/
var serializer = new JsonSerializer();
var handler = new DefaultClientMessageHandler();
var client = new MockRpcClient2(serializer, handler);
var logger = NullLogger <DefaultCallInvoker> .Instance;
var invoker = new DefaultCallInvoker(handler, client, serializer, logger);
var req = new FooReq {
FooWord = "hello dotbpe"
};
var result = await invoker.AsyncRequest <FooReq, FooRes>("FooService.Foo", "default", 100, 1, req);
Assert.NotNull(result);
Assert.Equal(0, result.Code);
Assert.NotNull(result.Data);
Assert.Equal(req.FooWord, result.Data.RetFooWord);
}
private static async Task RunAsync()
{
var channel = new Channel("127.0.0.1", 5000, ChannelCredentials.Insecure);
var invoker = new DefaultCallInvoker(channel);
using (var call = invoker.AsyncDuplexStreamingCall(Descriptors.Method, null, new CallOptions {
}))
{
var responseCompleted = call.ResponseStream
.ForEachAsync(async response =>
{
Console.WriteLine($"Got response: {response.Text}");
});
for (int i = 0; i < 100; i++)
{
await call.RequestStream.WriteAsync(new Message { Text = i.ToString() });
}
await call.RequestStream.CompleteAsync();
await responseCompleted;
}
Console.WriteLine("Press enter to stop...");
Console.ReadLine();
await channel.ShutdownAsync();
}
public async Task AsyncNotifyTest()
{
/*
* IClientMessageHandler<AmpMessage> handler,
* IRpcClient<AmpMessage> rpcClient,
* ISerializer serializer,
* ILogger<DefaultCallInvoker> logger
*/
var handler = new DefaultClientMessageHandler();
var client = new MockRpcClient(handler);
var serializer = new JsonSerializer();
var logger = NullLogger <DefaultCallInvoker> .Instance;
var invoker = new DefaultCallInvoker(handler, client, serializer, logger);
var req = new FooReq {
FooWord = "hello dotbpe"
};
var result = await invoker.AsyncNotify("FooService.Foo", "default", 100, 1, req);
Assert.NotNull(result);
Assert.Equal(0, result.Code);
Assert.NotNull(client.ReceiveMessage);
Assert.Equal(100, client.ReceiveMessage.ServiceId);
Assert.Equal(1, client.ReceiveMessage.MessageId);
Assert.Equal("FooService.Foo", client.ReceiveMessage.FriendlyServiceName);
}
private static async Task RunAsync()
{
var channel = new Channel("127.0.0.1", 5000, ChannelCredentials.Insecure);
var invoker = new DefaultCallInvoker(channel);
using (var call = invoker.AsyncDuplexStreamingCall(Descriptors.Method, null, new CallOptions {
}))
{
var responseCompleted = call.ResponseStream
.ForEachAsync(async response =>
{
Console.WriteLine($"Output: {response.Output}");
});
Console.Write("Enter number 1: ");
int x = Convert.ToInt32(Console.ReadLine());
Console.Write("Enter number 2: ");
int y = Convert.ToInt32(Console.ReadLine());
await call.RequestStream.WriteAsync(new AdditionRequest { X = x, Y = y });
Console.ReadLine();
await call.RequestStream.CompleteAsync();
await responseCompleted;
}
Console.WriteLine("Press enter to stop...");
Console.ReadLine();
await channel.ShutdownAsync();
}
public static T Create <T>(Channel channel, IFormatterResolver resolver)
where T : IService <T>
{
#if UNITY_EDITOR
var invoker = new EditorWindowSupportsCallInvoker(channel);
#else
var invoker = new DefaultCallInvoker(channel);
#endif
return(Create <T>(invoker, resolver));
}
public DefaultRpcChannel(IRpcServiceDiscovery rpcServiceDiscovery, ISerializer serializer, IOptions <RpcClientOptions> options)
{
var(host, port) = rpcServiceDiscovery == null
? (options.Value.Host, options.Value.Port)
: rpcServiceDiscovery.ResolveAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var channel = new Channel(host, port, ChannelCredentials.Insecure);
this._host = host;
this._invoker = new DefaultCallInvoker(channel);
this._serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="logger"></param>
/// <param name="clientConfiguration"></param>
/// <param name="connectionInfoList"></param>
/// <param name="channelCustomSelector"></param>
public ManagedCallInvoker(ILogger logger, GrpcClientConfiguration clientConfiguration,
List <GrpcChannelConnectionData> connectionInfoList, Func <object, string, string, string> channelCustomSelector = null)
{
// set properteis
_configuration = clientConfiguration;
_logger = logger;
_channelCustomSelector = channelCustomSelector;
// create invoke bundles
Invokers = connectionInfoList.Select(options => {
var ch = new Channel(options.Url, options.Port, ChannelCredentials.Insecure);
var inv = new DefaultCallInvoker(ch);
var bundle = new InvokerBundle(ch, inv, options);
return(bundle);
}).ToList();
// setup round robin
_roundRobin = new RoundRobinPolicy <InvokerBundle>(Invokers, GetScore);
}
private static async Task RunAsync()
{
var channel = new Channel("127.0.0.1", 5000, ChannelCredentials.Insecure);
var invoker = new DefaultCallInvoker(channel);
var client = ClientBuilder.Build <IApi>(channel);
var resStream = client.StreamToStream(Observable.Range(0, 10).Select(x => new Request {
Value = x
}));
foreach (var item in resStream.ToEnumerable())
{
Console.WriteLine($"Response : {item.Value}");
}
Console.WriteLine("Press enter to stop...");
Console.ReadLine();
await channel.ShutdownAsync();
}
/// <summary>
///
/// </summary>
/// <typeparam name="TRequest"></typeparam>
/// <typeparam name="TResponse"></typeparam>
/// <param name="method"></param>
/// <param name="headers"></param>
/// <param name="requests"></param>
/// <returns></returns>
private Task <object> CallGrpcAsyncCore <TRequest, TResponse>(GrpcServiceMethod method, IDictionary <string, string> headers, IEnumerable <TRequest> requests) where TRequest : class where TResponse : class
{
CallInvoker invoker = new DefaultCallInvoker(m_Settings.Channel);
CallOptions option = CreateCallOptions(headers);
Method <TRequest, TResponse> rpc = (Method <TRequest, TResponse>)method.Method;
switch (rpc.Type)
{
case MethodType.Unary:
Task <TResponse> taskUnary = AsyncUnaryCall(invoker, rpc, option, requests.FirstOrDefault());
return(Task.FromResult <object>(taskUnary.Result));
case MethodType.ClientStreaming:
Task <TResponse> taskClientStreaming = AsyncClientStreamingCall(invoker, rpc, option, requests);
return(Task.FromResult <object>(taskClientStreaming.Result));
case MethodType.ServerStreaming:
Task <IList <TResponse> > taskServerStreaming = AsyncServerStreamingCall(invoker, rpc, option, requests.FirstOrDefault());
return(Task.FromResult <object>(taskServerStreaming.Result));
case MethodType.DuplexStreaming:
Task <IList <TResponse> > taskDuplexStreaming = AsyncDuplexStreamingCall(invoker, rpc, option, requests);
return(Task.FromResult <object>(taskDuplexStreaming.Result));
default:
throw new NotSupportedException(string.Format("MethodType '{0}' is not supported.", rpc.Type));
}
}
private static async Task RunAsync(string hostName, int portNumber, string fileName, int collectionInterval,
string zmiName, CancellationToken token)
{
while (true)
{
if (token.IsCancellationRequested)
{
token.ThrowIfCancellationRequested();
}
var channel = new Channel(hostName, portNumber, ChannelCredentials.Insecure);
var invoker = new DefaultCallInvoker(channel);
await ProcessFile(invoker, zmiName, fileName)
.ContinueWith(async _ => await channel.ShutdownAsync(), token);
var channel2 = new Channel(hostName, portNumber, ChannelCredentials.Insecure);
var invoker2 = new DefaultCallInvoker(channel2);
await ProcessContactsFile(invoker2)
.ContinueWith(async _ => await channel2.ShutdownAsync(), token);
await Task.Delay(collectionInterval, token);
}
}
public static async Task <RegisterResponseModel> Register(RegisterRequestModel request)
{
var channel = new Channel(ConfigurationManager.AppSettings["Server"], int.Parse(ConfigurationManager.AppSettings["Port"]), ChannelCredentials.Insecure);
var invoker = new DefaultCallInvoker(channel);
RegisterResponseModel res = null;
using (var call = invoker.AsyncDuplexStreamingCall(ServiceDefinition.Register, null, new CallOptions {
}))
{
var responseCompleted = call.ResponseStream
.ForEachAsync(async response =>
{
res = response;
});
await call.RequestStream.WriteAsync(request);
await call.RequestStream.CompleteAsync();
await responseCompleted;
}
return(res);
}
public CustomerDataClient(Channel channel)
{
m_callInvoker = new DefaultCallInvoker(channel);
}
public Client(string host, int port)
{
this.host = host;
this.ch = new Channel(host, port, ChannelCredentials.Insecure);
this.invoker = new DefaultCallInvoker(ch);
}
/// <summary>
///
/// </summary>
/// <param name="server"></param>
/// <param name="port"></param>
public RpcClient(string server, int port)
{
m_Channel = new Channel(server, port, ChannelCredentials.Insecure);
CallInvoker = new DefaultCallInvoker(m_Channel);
}
private TResponse Call <TResponse>(Func <CallInvoker, MiddlewareContext, TResponse> call, MiddlewareContext context)
{
DefaultCallInvoker callInvoker = new DefaultCallInvoker(grpcChannel);
// 实现方式2 继承Interceptor
//var ss = callInvoker.Intercept(new ClientCallbackInterceptor(
// () => Console.WriteLine("-----------ClientCallbackInterceptor----------------------")
// ));
// callInvoker.Intercept(new Interceptor());
/*
* .Intercept(new ClientCallbackInterceptor(() => stringBuilder.Append("array1")),
* new ClientCallbackInterceptor(() => stringBuilder.Append("array2")),
* new ClientCallbackInterceptor(() => stringBuilder.Append("array3")))
* .Intercept(metadata =>
* {
* stringBuilder.Append("interceptor2");
* return metadata;
* }).Intercept(metadata =>
* {
* stringBuilder.Append("interceptor3");
* return metadata;
* });
*/
TResponse response = default(TResponse);
if (MiddlewarePipeline != null)
{
context.HandlerExecutor = async() =>
{
response = await Task.FromResult(call(callInvoker, context));
context.Response = response;
};
MiddlewarePipeline.RunPipeline(context).ConfigureAwait(false);
}
else
{
response = call(callInvoker, context);
}
return(response);
/*
*
*
*
* //catch (RpcException rpcEx)
* //{
* // if (rpcEx.Status.StatusCode == StatusCode.Unavailable)
* // {
* // // 注销服务;剔除服务;
* // }
* // throw;
* //}
* var times = 0;
* if (options.Headers != null)
* {
* var retry = options.Headers.FirstOrDefault(t => t.Key == "grpc-retry");
* if (!string.IsNullOrWhiteSpace(retry?.Value))
* {
* times = int.Parse(retry?.Value);
* }
* }
* Policy
* .Handle<Exception>()
* .Retry(times, (exception, retryCount) =>
* {
* response = callInvoker.BlockingUnaryCall(method, host, options, request);
* });
*/
}
/// <summary>
/// チャネルとサービスメソッド名を指定してインスタンスを生成します。
/// </summary>
/// <param name="channel">チャネル</param>
/// <param name="serviceName">サービス名</param>
/// <param name="methodName">メソッド名</param>
internal HeartbeatObject(Channel channel, string serviceName, string methodName)
{
m_Channel = channel;
m_Invoker = new DefaultCallInvoker(channel);
m_Method = CreateMethod(serviceName, methodName);
}
public async Task Invoke(HttpContext httpContext)
{
try
{
var path = httpContext.Request.Path.Value;
MethodHandler handler;
if (!handlers.TryGetValue(path, out handler))
{
await next(httpContext);
return;
}
// from form...
object deserializedObject;
if (httpContext.Request.ContentType == "application/x-www-form-urlencoded")
{
//object parameters
var args = new List <object>();
var typeArgs = new List <Type>();
foreach (var p in handler.MethodInfo.GetParameters())
{
typeArgs.Add(p.ParameterType);
StringValues stringValues;
if (httpContext.Request.Form.TryGetValue(p.Name, out stringValues))
{
if (p.ParameterType == typeof(string))
{
args.Add((string)stringValues);
}
else if (p.ParameterType.GetTypeInfo().IsEnum)
{
args.Add(Enum.Parse(p.ParameterType, (string)stringValues));
}
else
{
var collectionType = GetCollectionType(p.ParameterType);
if (stringValues.Count == 1 || collectionType == null)
{
var values = (string)stringValues;
if (p.ParameterType == typeof(DateTime) || p.ParameterType == typeof(DateTimeOffset) || p.ParameterType == typeof(DateTime?) || p.ParameterType == typeof(DateTimeOffset?))
{
values = "\"" + values + "\"";
}
args.Add(JsonConvert.DeserializeObject(values, p.ParameterType));
}
else
{
string serializeTarget;
if (collectionType == typeof(string))
{
serializeTarget = "[" + string.Join(", ", stringValues.Select(x => JsonConvert.SerializeObject(x))) + "]"; // escape serialzie
}
else if (collectionType.GetTypeInfo().IsEnum || collectionType == typeof(DateTime) || collectionType == typeof(DateTimeOffset) || collectionType == typeof(DateTime?) || collectionType == typeof(DateTimeOffset?))
{
serializeTarget = "[" + string.Join(", ", stringValues.Select(x => "\"" + x + "\"")) + "]";
}
else
{
serializeTarget = "[" + (string)stringValues + "]";
}
args.Add(JsonConvert.DeserializeObject(serializeTarget, p.ParameterType));
}
}
}
else
{
if (p.HasDefaultValue)
{
args.Add(p.DefaultValue);
}
else
{
args.Add(null);
}
}
}
deserializedObject = MagicOnionMarshallers.InsantiateDynamicArgumentTuple(typeArgs.ToArray(), args.ToArray());
}
else
{
string body;
using (var sr = new StreamReader(httpContext.Request.Body, Encoding.UTF8))
{
body = sr.ReadToEnd();
}
if (handler.RequestType == typeof(byte[]) && string.IsNullOrWhiteSpace(body))
{
body = "[]";
}
deserializedObject = Newtonsoft.Json.JsonConvert.DeserializeObject(body, handler.RequestType);
}
// JSON to C# Object to MessagePack
var requestObject = handler.BoxedSerialize(deserializedObject);
var method = new Method <byte[], byte[]>(MethodType.Unary, handler.ServiceName, handler.MethodInfo.Name, MagicOnionMarshallers.ThroughMarshaller, MagicOnionMarshallers.ThroughMarshaller);
// create header
var metadata = new Metadata();
foreach (var header in httpContext.Request.Headers)
{
metadata.Add(header.Key, header.Value);
}
var invoker = new DefaultCallInvoker(channel);
var rawResponse = await invoker.AsyncUnaryCall(method, null, default(CallOptions).WithHeaders(metadata), requestObject);
// MessagePack -> Object -> Json
var obj = handler.BoxedDeserialize(rawResponse);
var v = JsonConvert.SerializeObject(obj, new[] { new Newtonsoft.Json.Converters.StringEnumConverter() });
httpContext.Response.ContentType = "application/json";
await httpContext.Response.WriteAsync(v);
}
catch (Exception ex)
{
httpContext.Response.StatusCode = 500;
await httpContext.Response.WriteAsync(ex.ToString());
}
}
public override async Task <AssociationHandle> Associate(Address remoteAddress)
{
var channel = new Channel(remoteAddress.Host, remoteAddress.Port.Value, ChannelCredentials.Insecure);
var invoker = new DefaultCallInvoker(channel);
}
