Beispiel #1
0
            public async Task GetAllBytes(ChunReq chunReq)
            {
                Log("***GetBytes chunks started  at:" + DateTime.Now);
                long start = DateTime.Now.Ticks;

                try
                {
                    Stopwatch sw = new Stopwatch();
                    sw.Start();
                    using (var call = client.GetAllBytes(chunReq))
                    {
                        var      responseStream = call.ResponseStream;
                        FullFile fullFile       = null;
                        while (await responseStream.MoveNext())
                        {
                            fullFile = responseStream.Current;
                        }
                        // string responseString = Encoding.UTF8.GetString(responseBytes.ToArray());
                        sw.Stop();
                        long end  = DateTime.Now.Ticks;
                        long diff = end - start;
                        // File.WriteAllBytes("fullFileAllBytes.jpg", fullFile.AllBytes.ToByteArray());
                        Log("***GetAllBytes response finished  at:" + DateTime.Now + "took: " + sw.Elapsed);
                    }
                }
                catch (RpcException e)
                {
                    Log("RPC failed " + e);
                    throw;
                }
            }
Beispiel #2
0
 public override async Task GetAllBytes(ChunReq request, IServerStreamWriter <FullFile> responseStream, ServerCallContext context)
 {
     FullFile fullFile = new FullFile()
     {
         AllBytes = ByteString.CopyFrom(testBytes)
     };
     await responseStream.WriteAsync(fullFile);
 }
Beispiel #3
0
            public async Task GetBytes(ChunReq chunReq)
            {
                Log("***GetBytes chunks started  at:" + DateTime.Now);
                long      start = DateTime.Now.Ticks;
                Stopwatch sw    = new Stopwatch();

                sw.Start();
                int         chunkCounter  = 0;
                List <byte> responseBytes = new List <byte>();

                try
                {
                    using (var call = client.GetBytes(chunReq))
                    {
                        var responseStream = call.ResponseStream;

                        while (await responseStream.MoveNext())
                        {
                            Log("***Received bytes.. chunk counter  " + chunkCounter);
                            Chunk chunk = responseStream.Current;
                            if (chunk.FirstChunk)
                            {
                                responseBytes = chunk.ChunkBytes.ToByteArray().ToList();
                            }
                            else
                            {
                                List <byte> chunkBytes = chunk.ChunkBytes.ToByteArray().ToList();
                                responseBytes.AddRange(chunkBytes);
                            }
                            chunkCounter++;
                        }
                        sw.Stop();
                        // string responseString = Encoding.UTF8.GetString(responseBytes.ToArray());
                        long end  = DateTime.Now.Ticks;
                        long diff = end - start;
                        Log("***GetBytes chunks finished  at:" + DateTime.Now + "took: " + sw.Elapsed);
                        try
                        {
                            Log("***writing file***");
                            Log("***writing file responseBytes lenght***" + responseBytes.Count());
                            byte[] resByteArray = responseBytes.ToArray();
                            Log("***writing file resByteArray lenght***" + resByteArray.Length);
                            // File.WriteAllBytes("resFileChunk.jpg", resByteArray);
                        }
                        catch (Exception ex)
                        {
                            Log("***writing file ex ***" + ex.Message);
                        }
                    }
                }
                catch (RpcException e)
                {
                    Log("RPC failed " + e);
                    throw;
                }
            }
Beispiel #4
0
        static void Main(string[] args)
        {
            int           MaxMessageLengthBytes = Int32.MaxValue;
            ChannelOption maxSendMessageLength  = new ChannelOption(ChannelOptions.MaxMessageLength, MaxMessageLengthBytes);

            ChannelOption[] grpcChannelOptions = { maxSendMessageLength };

            var channel = new Channel("127.0.0.1:50052", ChannelCredentials.Insecure, grpcChannelOptions);
            //var channel = new Channel("127.0.0.1:50052", ChannelCredentials.Insecure);

            var client = new RouteGuideClient(new RouteGuide.RouteGuideClient(channel));

            // Looking for a valid feature
            // client.GetFeature(409146138, -746188906);

            // Feature missing.
            //client.GetFeature(0, 0);

            // Looking for features between 40, -75 and 42, -73.
            //client.ListFeatures(400000000, -750000000, 420000000, -730000000).Wait();

            // Record a few randomly selected points from the features file.
            // client.RecordRoute(RouteGuideUtil.ParseFeatures(RouteGuideUtil.DefaultFeaturesFile), 10).Wait();

            // Send and receive some notes.
            //client.RouteChat().Wait();
            ChunReq chunReq = new ChunReq()
            {
                ChunkCounter = 0
            };

            client.GetBytes(chunReq).Wait();
            try
            {
                client.GetAllBytes(chunReq).Wait();
            }
            catch (Exception ex)
            {
            }

            channel.ShutdownAsync().Wait();
            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
Beispiel #5
0
        public override async Task GetBytes(ChunReq request, IServerStreamWriter <Chunk> responseStream, ServerCallContext context)
        {
            int numberOfChunks = (int)Math.Ceiling((decimal)testBytes.Length / chunkSize);

            Console.WriteLine($"testBytes length:{testBytes.Length} number of chunks:{numberOfChunks}");
            try
            {
                if (testBytes.Length <= chunkSize)
                {
                    Chunk chunk = new Chunk()
                    {
                        FirstChunk = true,
                        ChunkBytes = ByteString.CopyFrom(testBytes.Slice(0, testString.Length)),
                        LastChunk  = false
                    };
                    await responseStream.WriteAsync(chunk);
                }
                for (int i = 0; i < numberOfChunks; i++)
                {
                    int startIndex = i * chunkSize;
                    int endIndex   = startIndex + chunkSize;
                    if (endIndex > testBytes.Length)
                    {
                        endIndex = testBytes.Length;
                    }
                    Console.WriteLine($"sending chunk start:{startIndex} end:{endIndex}");
                    Chunk chunk = new Chunk()
                    {
                        FirstChunk = (i == 0),
                        ChunkBytes = ByteString.CopyFrom(testBytes.Slice(startIndex, endIndex)),
                        LastChunk  = false
                    };
                    await responseStream.WriteAsync(chunk);
                }
            }
            catch (Exception ex)
            {
                //return Task.FromResult(true);
            }
            // return Task.FromResult(true);
        }