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); }