/// <summary> /// Gets a stream of points, and responds with statistics about the "trip": number of points, /// number of known features visited, total distance traveled, and total time spent. /// </summary> public async Task <RouteSummary> RecordRoute(Grpc.Core.IAsyncStreamReader <Point> requestStream, Grpc.Core.ServerCallContext context) { int pointCount = 0; int featureCount = 0; int distance = 0; Point previous = null; var stopwatch = new Stopwatch(); stopwatch.Start(); while (await requestStream.MoveNext()) { var point = requestStream.Current; pointCount++; if (CheckFeature(point).Exists()) { featureCount++; } if (previous != null) { distance += (int)previous.GetDistance(point); } previous = point; } stopwatch.Stop(); return(new RouteSummary { PointCount = pointCount, FeatureCount = featureCount, Distance = distance, ElapsedTime = (int)(stopwatch.ElapsedMilliseconds / 1000) }); }
/// <summary> /// Server side handler of the WriteDataBlock RPC. DataNode writes block to a file and then returns success status of write. /// </summary> /// <param name="requestStream">Stream of bytes</param> /// <param name="context">Context of call. Contains metadata containing blockid and list of addresses</param> /// <returns>Status of task</returns> public override async Task <ClientProto.StatusResponse> WriteBlock(Grpc.Core.IAsyncStreamReader <ClientProto.BlockData> requestStream, ServerCallContext context) { List <Metadata.Entry> metaData = context.RequestHeaders.ToList(); // Get blockID Guid blockId = Util.GetBlockID(metaData); int blockSize = Util.GetBlockSize(metaData); string filePath = BlockStorage.Instance.CreateFile(blockId); Channel channel = ConnectionManager.Instance.GetChannel(blockId); ClientProto.StatusResponse response = new ClientProto.StatusResponse { Type = ClientProto.StatusResponse.Types.StatusType.Success }; // No channel found means last datanode in pipe if (channel != null) { response = await WriteAndForwardBlock(requestStream, context, channel, filePath, blockId, blockSize); } else // Just write to file { response = await WriteBlock(requestStream, filePath, blockId, blockSize); } if (response.Type == ClientProto.StatusResponse.Types.StatusType.Success) { Console.WriteLine("Done writing block: " + blockId.ToString()); // Send block report to NameNode var client = new DataNodeProto.DataNodeProto.DataNodeProtoClient(ConnectionManager.Instance.NameNodeConnection); BlockReport.SendSingleBlockReport(client); } return(response); }
public override async Task FindMax(Grpc.Core.IAsyncStreamReader <FindMax.FindMaxRequest> requestStream, Grpc.Core.IServerStreamWriter <FindMax.FindMaxResponse> responseStream, Grpc.Core.ServerCallContext context) { try { var max = 0; Console.WriteLine($"Received:"); while (await requestStream.MoveNext()) { Console.WriteLine($"{requestStream.Current.Number}"); if (max < requestStream.Current.Number) { max = requestStream.Current.Number; } } Console.WriteLine($"Max found: {max}"); await responseStream.WriteAsync(new FindMaxResponse() { Max = max }); } catch (System.Exception e) { throw new RpcException(new Status(StatusCode.Internal, $"Something went wrong - Exception: {e}")); } }
/// <summary> /// Writes block to disk /// </summary> /// <param name="requestStream">Stream of bytes</param> /// <param name="filePath">Full path of file</param> /// <param name="blockId">Unique identifier of block</param> /// <returns>Status of writing the block</returns> public async Task <ClientProto.StatusResponse> WriteBlock(Grpc.Core.IAsyncStreamReader <ClientProto.BlockData> requestStream, string filePath, Guid blockId, int blockSize) { using (var stream = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.None, 131072, FileOptions.WriteThrough)) // 128KB { while (await requestStream.MoveNext()) { try { var blockData = requestStream.Current; byte[] data = blockData.Data.ToByteArray(); // Write to file stream.Write(data, 0, data.Length); } catch (IOException e) { BlockStorage.Instance.DeleteBlock(blockId); return(new ClientProto.StatusResponse { Type = ClientProto.StatusResponse.Types.StatusType.Fail, Message = e.Message }); } } stream.Flush(); } // If write was successful, make sure block size is correct return(!BlockStorage.Instance.ValidateBlock(blockId, filePath, blockSize) ? new ClientProto.StatusResponse { Type = ClientProto.StatusResponse.Types.StatusType.Fail, Message = "Block size is not correct" } : new ClientProto.StatusResponse { Type = ClientProto.StatusResponse.Types.StatusType.Success }); }
public override async Task StartStream( Grpc.Core.IAsyncStreamReader <Plugin.ConnInfo> requestStream, Grpc.Core.IServerStreamWriter <Plugin.ConnInfo> responseStream, Grpc.Core.ServerCallContext context) { var cts = CancellationTokenSource.CreateLinkedTokenSource( _pluginHost.StopHostingToken, context.CancellationToken); _log.LogInformation("Starting streaming..."); var ct = cts.Token; try { while (!ct.IsCancellationRequested) { while (await requestStream.MoveNext(ct)) { var connInfo = requestStream.Current; _log.LogWarning("Not sure what to do -- got connection info: {@conninfo}", connInfo); await responseStream.WriteAsync(connInfo); } } } catch (OperationCanceledException) { _log.LogWarning("Operation has been canceled"); } _log.LogInformation("Streaming completed"); }
/// <summary> /// Receives a stream of message/location pairs, and responds with a stream of all previous /// messages at each of those locations. /// </summary> public async Task RouteChat(Grpc.Core.IAsyncStreamReader <RouteNote> requestStream, Grpc.Core.IServerStreamWriter <RouteNote> responseStream, Grpc.Core.ServerCallContext context) { while (await requestStream.MoveNext()) { var note = requestStream.Current; List <RouteNote> prevNotes = AddNoteForLocation(note.Location, note); foreach (var prevNote in prevNotes) { await responseStream.WriteAsync(prevNote); } } }
/// <summary> /// Server side handler of the WriteDataBlock RPC. DataNode writes block to a file and then returns success status of write. /// </summary> /// <param name="requestStream">Data of block</param> /// <param name="context">Call Context</param> /// <returns>Status of task</returns> public override async Task <DataNodeProto.StatusResponse> WriteDataBlock(Grpc.Core.IAsyncStreamReader <DataNodeProto.BlockData> requestStream, ServerCallContext context) { List <Metadata.Entry> metaData = context.RequestHeaders.ToList(); Guid blockId = Util.GetBlockID(metaData); int blockSize = Util.GetBlockSize(metaData); string filePath = BlockStorage.Instance.CreateFile(blockId); bool writeSuccess = true; try { // Write block to file system using (var writerStream = new FileStream(filePath, FileMode.Append, FileAccess.Write)) { while (await requestStream.MoveNext()) { try { var bytes = requestStream.Current.Data.ToByteArray(); writerStream.Write(bytes, 0, bytes.Length); } catch { writeSuccess = false; } } } } catch (Exception e) { Console.WriteLine("Writing block that was forwarded failed: " + e.Message); } if (BlockStorage.Instance.ValidateBlock(blockId, filePath, blockSize) && writeSuccess) { // Send block report to NameNode var client = new DataNodeProto.DataNodeProto.DataNodeProtoClient(ConnectionManager.Instance.NameNodeConnection); BlockReport.SendSingleBlockReport(client); return(new DataNodeProto.StatusResponse { Type = DataNodeProto.StatusResponse.Types.StatusType.Success }); } else { return(new DataNodeProto.StatusResponse { Type = DataNodeProto.StatusResponse.Types.StatusType.Fail }); } }
public SarmataSession(String serviceAddress, Dictionary <String, String> settings) { asrChannel = new Grpc.Core.Channel(serviceAddress, Grpc.Core.ChannelCredentials.Insecure); asrClient = new Sarmata.ASR.ASRClient(asrChannel); var openStream = asrClient.Recognize(cancellationToken: new CancellationToken()); requestStream = openStream.RequestStream; responseStream = openStream.ResponseStream; Sarmata.RecognizeRequest initialMessage = new Sarmata.RecognizeRequest() { InitialRequest = settings2request(settings) }; requestStream.WriteAsync(initialMessage).Wait(); }
/// <summary> /// Receives a stream of message/location pairs, and responds with a stream of all previous /// messages at each of those locations. /// </summary> public async Task RouteChat(Grpc.Core.ServerCallContext context, Grpc.Core.IAsyncStreamReader <RouteNote> requestStream, Grpc.Core.IServerStreamWriter <RouteNote> responseStream) { while (await requestStream.MoveNext()) { var note = requestStream.Current; List <RouteNote> notes = GetOrCreateNotes(note.Location); List <RouteNote> prevNotes; lock (notes) { prevNotes = new List <RouteNote>(notes); } foreach (var prevNote in prevNotes) { await responseStream.WriteAsync(prevNote); } lock (notes) { notes.Add(note); } } }
/// <summary> /// Writes block to disk and forwards to next DataNode /// </summary> /// <param name="requestStream">Stream of bytes</param> /// <param name="context">Context of call</param> /// <param name="channel">Channel for pipe</param> /// <param name="filePath">Full path of file</param> /// <param name="blockId">Unique identifier of block</param> /// <returns>Status of writing the block</returns> public async Task <ClientProto.StatusResponse> WriteAndForwardBlock(Grpc.Core.IAsyncStreamReader <ClientProto.BlockData> requestStream, ServerCallContext context, Channel channel, string filePath, Guid blockId, int blockSize) { bool success = true; string message = ""; var client = new ClientProto.ClientProto.ClientProtoClient(channel); using (var call = client.WriteBlock(context.RequestHeaders)) { bool dataNodeFailed = false; using (var stream = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.None, 131072, FileOptions.WriteThrough)) // 128KB { while (await requestStream.MoveNext()) { try { var blockData = requestStream.Current; byte[] data = blockData.Data.ToByteArray(); // Write to file stream.Write(data, 0, data.Length); // Don't need to forward data in pipe if datanode failed if (!dataNodeFailed) { try { // Send data through pipe await call.RequestStream.WriteAsync(blockData); } catch (RpcException e) { dataNodeFailed = true; Console.WriteLine("Writing block failed: " + e.Message); message = e.Message; } } } catch (IOException e) { dataNodeFailed = true; message = e.Message; success = false; } } stream.Flush(); } ClientProto.StatusResponse resp = new ClientProto.StatusResponse { Type = ClientProto.StatusResponse.Types.StatusType.Fail, Message = message }; // If DataNode did not fail, get response and shut down if (!dataNodeFailed) { await call.RequestStream.CompleteAsync(); resp = await call.ResponseAsync; ConnectionManager.Instance.ShutDownChannel(blockId, channel); } // If write was successful and block size is correct, return success // Otherwise return the response sent down through pipe return((success && BlockStorage.Instance.ValidateBlock(blockId, filePath, blockSize)) ? new ClientProto.StatusResponse { Type = ClientProto.StatusResponse.Types.StatusType.Success } : resp); } }
public abstract global::System.Threading.Tasks.Task shouldBeStreaming(Grpc.Core.IAsyncStreamReader <global::Bond.Grpc.IMessage <stream> > requests, Grpc.Core.IAsyncStreamWriter <global::Bond.Grpc.IMessage <stream> > responses, global::Grpc.Core.ServerCallContext context);
public abstract global::System.Threading.Tasks.Task foo35(Grpc.Core.IAsyncStreamReader <global::Bond.Grpc.IMessage <BasicTypes> > requests, Grpc.Core.IAsyncStreamWriter <global::Bond.Grpc.IMessage <BasicTypes> > responses, global::Grpc.Core.ServerCallContext context);
public abstract global::System.Threading.Tasks.Task <global::Bond.Grpc.IMessage <global::Bond.Void> > foo33(Grpc.Core.IAsyncStreamReader <global::Bond.Grpc.IMessage <BasicTypes> > requests, global::Grpc.Core.ServerCallContext context);
/// <summary> /// Gets a stream of points, and responds with statistics about the "trip": number of points, /// number of known features visited, total distance traveled, and total time spent. /// </summary> public async Task <RouteSummary> RecordRoute(Grpc.Core.ServerCallContext context, Grpc.Core.IAsyncStreamReader <Point> requestStream) { int pointCount = 0; int featureCount = 0; int distance = 0; Point previous = null; var stopwatch = new Stopwatch(); stopwatch.Start(); while (await requestStream.MoveNext()) { var point = requestStream.Current; pointCount++; if (RouteGuideUtil.Exists(CheckFeature(point))) { featureCount++; } if (previous != null) { distance += (int)CalcDistance(previous, point); } previous = point; } stopwatch.Stop(); return(RouteSummary.CreateBuilder().SetPointCount(pointCount) .SetFeatureCount(featureCount).SetDistance(distance) .SetElapsedTime((int)(stopwatch.ElapsedMilliseconds / 1000)).Build()); }