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