Beispiel #1
0
        private static void Sqrt(Channel channel)
        {
            Console.WriteLine("Sqrt service");
            var sqrtClient = new SqrtService.SqrtServiceClient(channel);

            var number = new Sqrt.Number
            {
                A = -1
            };

            try
            {
                var sqrtRequest = new SqrtRequest()
                {
                    Number = number
                };

                var sqrtResponse = sqrtClient.SquareRoot(sqrtRequest);

                Console.WriteLine(sqrtResponse.Result);
                Console.WriteLine("");
            }
            catch (RpcException e)
            {
                Console.WriteLine("Error : " + e.Status.Detail);
            }
        }
Beispiel #2
0
        static async Task Main(string[] args)
        {
            Channel channel = new Channel(target, ChannelCredentials.Insecure);
            await channel.ConnectAsync().ContinueWith((task) =>
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    Console.WriteLine("The Client Connected Successfully");
                }
            });

            var client = new SqrtService.SqrtServiceClient(channel);

            //int number = 16;//4
            int number = -1;//throws exception

            try
            {
                var response = client.sqrt(new SqrtRequest()
                {
                    Number = number
                });
                Console.WriteLine(response.SquareRoot);
            }
            catch (RpcException e)
            {
                Console.WriteLine("Error : " + e.Status.Detail);
            }


            channel.ShutdownAsync().Wait();
            Console.ReadKey();
        }
Beispiel #3
0
        public static void CalcSqrt(SqrtService.SqrtServiceClient client)
        {
            int number = -1;

            try
            {
                var response = client.sqrt(new SqrtRequest()
                {
                    Number = number
                });
                Console.WriteLine(response.SquareRoot);
            }
            catch (RpcException e)
            {
                Console.WriteLine("Error: {0}", e.Status.Detail);
            }
        }
Beispiel #4
0
        static async Task Main(string[] args)
        {
            const string target  = "127.0.0.1:50051";
            Channel      channel = new Channel(target, ChannelCredentials.Insecure);
            await channel.ConnectAsync().ContinueWith((task) =>
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    Console.WriteLine("The client connected sussesfully");
                }
            });


            var client = new SqrtService.SqrtServiceClient(channel);
            int number = -1;

            try
            {
                //var response = client.sqrt(new SqrtRequest() { Number = number });
                //deadline
                var response = client.sqrt(new SqrtRequest()
                {
                    Number = number
                },
                                           deadline: DateTime.UtcNow.AddMilliseconds(500));
                Console.WriteLine(response.SquareRoot);
            }
            catch (RpcException e) when(e.StatusCode == StatusCode.DeadlineExceeded)
            {
                Console.WriteLine("Error deadline : " + e.Status.Detail);
            }
            catch (RpcException e)
            {
                Console.WriteLine("Error : " + e.Status.Detail);
                throw;
            }



            channel.ShutdownAsync().Wait();
            Console.ReadKey();
        }
        public static async Task <SqrtResponse> Execute(string host, int port, SqrtRequest sqrtRequest)
        {
            var clientCert = File.ReadAllText("ssl/client.crt");
            var clientKey  = File.ReadAllText("ssl/client.key");
            var caCrt      = File.ReadAllText("ssl/ca.crt");

            var channelCredentials = new SslCredentials(caCrt, new KeyCertificatePair(clientCert, clientKey));

            Channel      channel  = null;
            SqrtResponse response = null;

            try
            {
                channel = new Channel(host, port, channelCredentials);

                await channel.ConnectAsync();

                var client = new SqrtService.SqrtServiceClient(channel);

                response = await client.SqrtAsync(sqrtRequest, deadline : DateTime.UtcNow.AddMilliseconds(5000));
            }
            catch (RpcException ex) when(ex.Status.StatusCode == StatusCode.InvalidArgument)
            {
                Console.WriteLine($"RPC Exception: {ex}");
                Console.WriteLine($"Status Code: {ex.Status.StatusCode}");
                Console.WriteLine($"Status Detail: {ex.Status.Detail}");
            }
            catch (Exception)
            {
                // log
                throw;
            }
            finally
            {
                if (channel != null)
                {
                    await channel.ShutdownAsync();
                }
            }

            return(response);
        }
Beispiel #6
0
        static async Task ErrorHandling(Channel channel)
        {
            WriteHeader("ErrorHandling");
            var errorClient = new SqrtService.SqrtServiceClient(channel);

            for (var i = 10; i > -5; i--)
            {
                try
                {
                    var result = await errorClient.SqrtAsync(new SqrtRequest { Number = i });

                    Console.WriteLine($"Sqrt for {i} is {result}");
                    await Task.Delay(400);
                }
                catch (RpcException ex)
                {
                    Console.WriteLine($"Error message: {ex.Message}, detail: {ex.Status.Detail}, status: {ex.Status}");
                }
            }
        }
        static async Task Main(string[] args)
        {
            Channel channel = new Channel(target, ChannelCredentials.Insecure);

            await channel.ConnectAsync().ContinueWith((task) =>
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    Console.WriteLine("The client connected successfully");
                }
            });

            var client = new SqrtService.SqrtServiceClient(channel);
            int number = 16;

            try
            {
                var response = client.sqrt(new SqrtRequest()
                {
                    Number = number
                },
                                           deadline: DateTime.UtcNow.AddSeconds(1));

                Console.WriteLine(response.SquareRoot);
            }
            catch (RpcException e) when(e.StatusCode == StatusCode.InvalidArgument)
            {
                Console.WriteLine("Error : " + e.Status.Detail);
            }
            catch (RpcException e) when(e.StatusCode == StatusCode.DeadlineExceeded)
            {
                Console.WriteLine("Deadline exceeded !");
            }

            channel.ShutdownAsync().Wait();
            Console.ReadKey();
        }