public override async Task StreamingCall(IAsyncStreamReader<SimpleRequest> requestStream, IServerStreamWriter<SimpleResponse> responseStream, ServerCallContext context)
{
await requestStream.ForEachAsync(async request =>
{
var response = new SimpleResponse { Payload = CreateZerosPayload(request.ResponseSize) };
await responseStream.WriteAsync(response);
});
}
public async Task DivMany(ServerCallContext context, IAsyncStreamReader<DivArgs> requestStream, IServerStreamWriter<DivReply> responseStream)
{
await requestStream.ForEach(async divArgs =>
{
await responseStream.WriteAsync(DivInternal(divArgs));
});
}
public Task ListenForNewPeople(ListenForNewPeopleRequest request, IServerStreamWriter<Person> responseStream, ServerCallContext context)
{
LogRpc(context);
_personRepository.PersonCreated += async (sender, arg) => await responseStream.WriteAsync(arg.Person);
_manualResetEvent.Wait();
return Task.FromResult(0);
}
public async Task OperationStream(IAsyncStreamReader<ServiceRequest> requestStream, IServerStreamWriter<ServiceResponse> responseStream, ServerCallContext context)
{
while (await requestStream.MoveNext(CancellationToken.None))
{
await responseStream.WriteAsync(new ServiceResponse { Id = requestStream.Current.Id });
}
}
public override async Task ServerReflectionInfo(IAsyncStreamReader<ServerReflectionRequest> requestStream, IServerStreamWriter<ServerReflectionResponse> responseStream, ServerCallContext context)
{
while (await requestStream.MoveNext())
{
var response = ProcessRequest(requestStream.Current);
await responseStream.WriteAsync(response);
}
}
/// <summary>
/// Gets all features contained within the given bounding rectangle.
/// </summary>
public override async Task ListFeatures(Rectangle request, IServerStreamWriter<Feature> responseStream, ServerCallContext context)
{
var responses = features.FindAll( (feature) => feature.Exists() && request.Contains(feature.Location) );
foreach (var response in responses)
{
await responseStream.WriteAsync(response);
}
}
public async Task StreamingOutputCall(StreamingOutputCallRequest request, IServerStreamWriter<StreamingOutputCallResponse> responseStream, ServerCallContext context)
{
foreach (var responseParam in request.ResponseParameters)
{
var response = new StreamingOutputCallResponse { Payload = CreateZerosPayload(responseParam.Size) };
await responseStream.WriteAsync(response);
}
}
public async Task StreamingOutputCall(StreamingOutputCallRequest request, IServerStreamWriter<StreamingOutputCallResponse> responseStream, ServerCallContext context)
{
foreach (var responseParam in request.ResponseParametersList)
{
var response = StreamingOutputCallResponse.CreateBuilder()
.SetPayload(CreateZerosPayload(responseParam.Size)).Build();
await responseStream.WriteAsync(response);
}
}
public async Task FullDuplexCall(IAsyncStreamReader<StreamingOutputCallRequest> requestStream, IServerStreamWriter<StreamingOutputCallResponse> responseStream, ServerCallContext context)
{
await requestStream.ForEachAsync(async request =>
{
foreach (var responseParam in request.ResponseParameters)
{
var response = new StreamingOutputCallResponse { Payload = CreateZerosPayload(responseParam.Size) };
await responseStream.WriteAsync(response);
}
});
}
public override async Task StreamingOutputCall(StreamingOutputCallRequest request, IServerStreamWriter<StreamingOutputCallResponse> responseStream, ServerCallContext context)
{
await EnsureEchoMetadataAsync(context);
EnsureEchoStatus(request.ResponseStatus, context);
foreach (var responseParam in request.ResponseParameters)
{
var response = new StreamingOutputCallResponse { Payload = CreateZerosPayload(responseParam.Size) };
await responseStream.WriteAsync(response);
}
}
public async Task Fib(FibArgs request, IServerStreamWriter<Num> responseStream, ServerCallContext context)
{
if (request.Limit <= 0)
{
// keep streaming the sequence until cancelled.
IEnumerator<Num> fibEnumerator = FibInternal(long.MaxValue).GetEnumerator();
while (!context.CancellationToken.IsCancellationRequested && fibEnumerator.MoveNext())
{
await responseStream.WriteAsync(fibEnumerator.Current);
await Task.Delay(100);
}
}
if (request.Limit > 0)
{
foreach (var num in FibInternal(request.Limit))
{
await responseStream.WriteAsync(num);
}
}
}
public override async Task Fib(FibArgs request, IServerStreamWriter<Num> responseStream, ServerCallContext context)
{
var limit = request.Limit > 0 ? request.Limit : long.MaxValue;
var fibEnumerator = FibInternal(limit).GetEnumerator();
// Keep streaming the sequence until the call is cancelled.
// Use CancellationToken from ServerCallContext to detect the cancellation.
while (!context.CancellationToken.IsCancellationRequested && fibEnumerator.MoveNext())
{
await responseStream.WriteAsync(fibEnumerator.Current);
await Task.Delay(100);
}
}
public override async Task RunServer(IAsyncStreamReader<ServerArgs> requestStream, IServerStreamWriter<ServerStatus> responseStream, ServerCallContext context)
{
GrpcPreconditions.CheckState(await requestStream.MoveNext());
var serverConfig = requestStream.Current.Setup;
var runner = ServerRunners.CreateStarted(serverConfig);
await responseStream.WriteAsync(new ServerStatus
{
Stats = runner.GetStats(false),
Port = runner.BoundPort,
Cores = Environment.ProcessorCount,
});
while (await requestStream.MoveNext())
{
var reset = requestStream.Current.Mark.Reset;
await responseStream.WriteAsync(new ServerStatus
{
Stats = runner.GetStats(reset)
});
}
await runner.StopAsync();
}
public async Task Chat(IAsyncStreamReader<ChatMessage> requestStream, IServerStreamWriter<ChatMessage> responseStream, ServerCallContext context)
{
Log(context);
Program.Log("Server starting to chat");
while (await requestStream.MoveNext())
{
ChatMessage clientChatMessage = requestStream.Current;
Program.Log($"Client says {clientChatMessage}");
ChatMessage serverChatMessage = Utility.GetRandomChatMessage(0);
await responseStream.WriteAsync(serverChatMessage);
}
// Returning from the method will automatically complete the response async enumerator on the client.
}
public async Task Fib(ServerCallContext context, FibArgs request, IServerStreamWriter<Num> responseStream)
{
if (request.Limit <= 0)
{
// TODO(jtattermusch): support cancellation
throw new NotImplementedException("Not implemented yet");
}
if (request.Limit > 0)
{
foreach (var num in FibInternal(request.Limit))
{
await responseStream.WriteAsync(num);
}
}
}
public override async Task GetAllLocations(GetAllLocationsRequest request, IServerStreamWriter <GetAllLocationsResponse> responseStream, ServerCallContext context)
{
_logger.LogInformation("Incoming request for GetAllLocationData");
var locationData = await GetLocationData();
var locations = locationData.Locations;
foreach (var item in locations)
{
await responseStream.WriteAsync(new GetAllLocationsResponse
{
LatitudeE7 = item.LatitudeE7,
LongitudeE7 = item.LongitudeE7
});
}
}
public async override Task Subscribe(Empty request, IServerStreamWriter <MessageSinkUpdate> responseStream, ServerCallContext context)
{
var unsubscriver = this.observable.Subscribe((message) =>
{
responseStream.WriteAsync(message);
});
var completion = new TaskCompletionSource <object>();
context.CancellationToken.Register(() =>
{
unsubscriver.Dispose();
completion.SetResult(null);
});
await completion.Task;
}
/// <summary>
/// Adds and removes records to replication db
/// Adds and updates available shapes
/// </summary>
/// <param name="connFactory"></param>
/// <param name="schema"></param>
/// <param name="record"></param>
/// <param name="config"></param>
/// <param name="responseStream"></param>
/// <returns>Error message string</returns>
public static async Task <string> WriteRecordAsync(IConnectionFactory connectionFactory, Schema schema, Record record, ConfigureReplicationFormData config, IServerStreamWriter <RecordAck> responseStream)
{
Logger.Debug($"Starting {record.RecordId}");
Stopwatch timer = Stopwatch.StartNew();
try
{
Logger.Debug(JsonConvert.SerializeObject(record, Formatting.Indented));
await WriteSemaphoreSlim.WaitAsync();
string safeSchemaName = config.SchemaName;
string safeGoldenTableName = config.GoldenTableName;
string safeVersionTableName = config.VersionTableName;
ReplicationTable goldenTable = GetGoldenReplicationTable(schema, safeSchemaName, safeGoldenTableName);
ReplicationTable versionTable = GetVersionReplicationTable(schema, safeSchemaName, safeVersionTableName);
List <string> recordVersionIds = record.Versions.Select(r => r.RecordId).ToList();
// GetNamed Record Data
// TODO: Finish
return(null);
}
catch (Exception ex)
{
Logger.Error(ex, $"Error writing record: {ex.Message}");
RecordAck ack = new RecordAck
{
CorrelationId = record.CorrelationId,
Error = ex.Message
};
await responseStream.WriteAsync(ack);
timer.Stop();
return(ex.Message);
}
finally
{
Logger.Debug($"Stopped {record.RecordId}. Time: {timer.ElapsedMilliseconds}");
WriteSemaphoreSlim.Release();
}
}
static Task SendBatch(GetAllRequest request, GetAllResponse batchToSend, IServerStreamWriter <GetAllResponse> responseStream, ILogger logger)
{
if (batchToSend.States.Count == 1 && batchToSend.CalculateSize() > MaxBatchMessageSize)
{
var stateThatIsTooLarge = batchToSend.States[0];
Log.ProjectionStateTooLargeButSendingAnyways(
logger,
stateThatIsTooLarge.Key,
request.ProjectionId,
request.ScopeId,
stateThatIsTooLarge.CalculateSize(),
MaxBatchMessageSize);
}
Log.SendingGetAllInBatchesResult(logger, request.ProjectionId, request.ScopeId, batchToSend.States.Count);
return(responseStream.WriteAsync(batchToSend));
}
/// <summary>
/// 게임 시작 요청
/// </summary>
/// <param name="request"></param>
/// <param name="responseStream"></param>
/// <param name="context"></param>
/// <returns></returns>
public override async Task StartPlay(StartPlayRequest request, IServerStreamWriter <StartPlayReply> responseStream, ServerCallContext context)
{
try
{
//await SequentialMatchmaking.StartPlay(request, responseStream, context);
await RankMatchmaking.StartPlay(request, responseStream, context);
}
catch (Exception ex)
{
Log.Error($"StartPlay error {ex.ToString()}");
var reply = new StartPlayReply();
reply.Code = ErrorCode.NotEnough;
reply.IsStart = false;
reply.CharacterList.Add(new StartPlayCharacterInfo()); // 자신포함으로 빈슬롯 한개 넣어줌
await responseStream.WriteAsync(reply);
}
}
public async override Task GetWeatherForecastByDateStream(IAsyncStreamReader <WeatherForecastByDateRequest> requestStream, IServerStreamWriter <WeatherForecast> responseStream, ServerCallContext context)
{
await foreach (var request in requestStream.ReadAllAsync())
{
if (context.CancellationToken.IsCancellationRequested)
{
break;
}
await Task.Delay(request.Delay.ToTimeSpan());
var response = _weatherForecastGenerator.GenerateWeatherForecast(request.Date);
await responseStream.WriteAsync(response);
_logger.LogInformation($"weather forecast sent on {request.Date:dd:MM:yyyy}");
}
}
public static bool TrySendResponse <T>([NotNull] IServerStreamWriter <T> responseStream,
[NotNull] T response)
{
try
{
responseStream.WriteAsync(response);
}
catch (InvalidOperationException ex)
{
// For example: System.InvalidOperationException: Only one write can be pending at a time
_msg.VerboseDebug("Error sending response to the client", ex);
return(false);
}
return(true);
}
public override async Task SendStatusSS(SRequest request, IServerStreamWriter <SResponse> responseStream, ServerCallContext context)
{
List <StatusInfo> statusList = StatusRepo();
SResponse sRes;
var i = 0;
while (!context.CancellationToken.IsCancellationRequested)
{
sRes = new SResponse();
sRes.StatusInfo.Add(statusList.Skip(i).Take(request.No));
await responseStream.WriteAsync(sRes);
i++;
await Task.Delay(1000);
}
}
public override async Task HalfDuplexEcho(IAsyncStreamReader <EchoRequest> requestStream, IServerStreamWriter <EchoResponse> responseStream, ServerCallContext context)
{
var messages = new List <string>();
await foreach (var message in requestStream.ReadAllAsync())
{
messages.Add(message.Message);
}
foreach (var message in messages)
{
await responseStream.WriteAsync(new EchoResponse
{
Message = message
});
}
}
public override async Task SendData(IAsyncStreamReader <TunnelMessage> requestStream, IServerStreamWriter <TunnelMessage> responseStream, ServerCallContext context)
{
var httpContext = context.GetHttpContext();
_logger.LogInformation($"Client connected to server: {httpContext.Connection.Id}");
while (await requestStream.MoveNext())
{
_logger.LogInformation($"Received message from Client: {requestStream.Current.Message}");
await responseStream.WriteAsync(new TunnelMessage
{
Name = "Response",
Message = "Response Test Message"
});
}
_logger.LogInformation($"Client disconnected");
}
public override async Task BidiHello
(
IAsyncStreamReader <HelloRequest> requestStream,
IServerStreamWriter <HelloReply> responseStream,
ServerCallContext context
)
{
await foreach (var request in requestStream.ReadAllAsync())
{
var helloReply = new HelloReply
{
Message = "Hello " + request.Name
};
await responseStream.WriteAsync(helloReply);
}
}
public override async Task GetPromoByTitle(PromoTitleRequest request, IServerStreamWriter <PromoCodeResponse> responseStream, ServerCallContext context)
{
var promoForTitle = await _repository.GetPromocodesByTitleAsync(request.Title);
if (promoForTitle == null)
{
_logger.LogWarning($"[PROMO-NOT FOUND]<>Not found any promo for {request.Title}");
return;
}
foreach (var promo in promoForTitle)
{
var pT = _mapper.Map <PromoCodeResponse>(promo);
await responseStream.WriteAsync(pT);
}
}
public override async Task Get(DataSourceGetRequest request,
IServerStreamWriter <DataSourceGetResponse> responseStream, ServerCallContext context)
{
var requestUid = Guid.NewGuid().ToString(); // TODO: Bind the UID to the request
_logger.LogInformation($"Started processing Get request: '{requestUid}' from '{context.Peer}'");
var(id, version, timestamp) = request.Deconstruct();
foreach (var i in Enumerable.Range(0, _rowsInTheResponse))
{
var response = GenerateGetResponse(id, version, timestamp, i, _rowsInTheResponse);
await responseStream.WriteAsync(response);
}
_logger.LogInformation($"Finished processing Get request: '{requestUid}' from '{context.Peer}'");
}
public override async Task CountStream(Empty request, IServerStreamWriter <CountData> responseStream, ServerCallContext context)
{
for (var i = 0; i < 10; i++)
{
if (context.CancellationToken.IsCancellationRequested)
{
break;
}
await Task.Delay(500);
await responseStream.WriteAsync(new CountData {
Count = i,
Timestamp = Timestamp.FromDateTime(DateTime.Now)
});
}
}
public override async Task MailBox(IAsyncStreamReader <ForwardMailMessage> requestStream, IServerStreamWriter <MailBoxMessage> responseStream, ServerCallContext context)
{
var mailboxName = context.RequestHeaders.Single(c => c.Key == "mailbox-name").Value;
_logger.LogInformation($"Connected to {mailboxName}");
_mailQueue.Changed += _mailQueue_Changed;
_mailQueue.Received();
try
{
await foreach (var item in requestStream.ReadAllAsync())
{
if (_mailQueue.TryForwardMail(out var message))
{
_logger.LogInformation($"Forwarded mail: {message.Content}");
}
else
{
_logger.LogWarning("No mail to forward.");
}
}
}
finally
{
_mailQueue.Changed -= _mailQueue_Changed;
}
_logger.LogInformation($"{mailboxName } disconnected");
await Task.CompletedTask;
async Task _mailQueue_Changed((int totalCount, int fowardCount, Reason reason) state)
{
await responseStream.WriteAsync(new MailBoxMessage
{
Forwarded = state.totalCount,
New = state.totalCount - state.fowardCount,
Reason = state.reason
});
}
}
public override async Task GetNewPhoneNumber(NewPhoneRequest request, IServerStreamWriter <PhoneReply> responseStream, ServerCallContext context)
{
try
{
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
String insertQuery = @"Select * from phone limit 10";
MySqlCommand command = new MySqlCommand(insertQuery, connection);
MySqlDataReader reader = command.ExecuteReader();
String PhoneNumbers = "";
PhoneReply phoneReply = new PhoneReply();
while (reader.Read())
{
String phone = $"{reader.GetString("number")} ";
if (PhoneNumbers == "")
{
PhoneNumbers = phone;
}
else
{
PhoneNumbers += phone;
}
}
phoneReply.Number = PhoneNumbers;
await responseStream.WriteAsync(phoneReply);
}
catch (Exception error)
{
String eror = error.Message;
}
finally
{
if (connection.State == ConnectionState.Open)
{
connection.Close();
}
}
}
public override async Task GetUser(Empty request, IServerStreamWriter <MessageResponse> responseStream, ServerCallContext context)
{
while (true)
{
var msg = _messageQueue.Dequeue();
if (msg == null)
{
Thread.Sleep(500);
}
else
{
var resp = new MessageResponse
{
Error = null,
AppId = msg.AppId,
Type = msg.MsgType,
OpenId = msg.FromUserName,
Time = msg.CreateTime
};
switch (msg.MsgType)
{
case "image":
resp.Content = msg.PicUrl;
break;
case "text":
resp.Content = msg.Content;
break;
case "link":
resp.Content = msg.Url;
break;
case "location":
resp.Content = string.Format("{0},{1}", msg.Location_X, msg.Location_Y);
break;
default:
resp.Content = msg.MediaId;
break;
}
await responseStream.WriteAsync(resp);
}
}
}
/// <summary>
/// ファイルダウンロード(サーバー ストリーミング メソッド)
/// </summary>
/// <param name="request"></param>
/// <param name="responseStream">ストリーミング</param>
/// <param name="context"></param>
/// <returns></returns>
public override async Task FileDownload(FileDownloadRequest request,
IServerStreamWriter <FileDownloadStream> responseStream, ServerCallContext context)
{
const int BufferSize = 10240;
byte[] buffer = new byte[BufferSize];
string currentDir = Directory.GetCurrentDirectory();
Console.WriteLine("$CurrentDirectory = {0}", currentDir);
using (var fs = new FileStream(request.FileName, FileMode.Open, FileAccess.Read))
{
int downloadSize = 0;
int readSize = 0;
while ((readSize = fs.Read(buffer, 0, BufferSize)) > 0)
{
Console.WriteLine("ダウンロード リクエスト");
//クライアントからキャンセルされたら終了する。
if (context.CancellationToken.IsCancellationRequested)
{
Console.WriteLine("キャンセル リクエスト");
break;
}
FileDownloadStream fileDownloadStream = new FileDownloadStream();
fileDownloadStream.Binary = Google.Protobuf.ByteString.CopyFrom(buffer);
fileDownloadStream.FileName = request.FileName;
fileDownloadStream.FileSize = readSize;
await responseStream.WriteAsync(fileDownloadStream);
await Task.Delay(TimeSpan.FromSeconds(1));
//await Task.Delay(TimeSpan.FromSeconds(1), context.CancellationToken);
downloadSize += readSize;
Console.WriteLine("{0}byte ダウンロード", downloadSize);
}
}
}
/// <summary>
/// Publishes a stream of data for a given schema
/// </summary>
/// <param name="request"></param>
/// <param name="responseStream"></param>
/// <param name="context"></param>
/// <returns></returns>
public override async Task ReadStream(ReadRequest request, IServerStreamWriter <Record> responseStream,
ServerCallContext context)
{
try
{
var schema = request.Schema;
var limit = request.Limit;
var limitFlag = request.Limit != 0;
var jobId = request.JobId;
long recordsCount = 0;
Logger.SetLogPrefix(jobId);
Logger.Debug(JsonConvert.SerializeObject(request.RealTimeStateJson, Formatting.Indented));
if (!string.IsNullOrWhiteSpace(request.RealTimeSettingsJson))
{
recordsCount = await Read.ReadRecordsRealTimeAsync(_apiClient, request, responseStream, context);
}
else
{
var records = Read.ReadRecordsAsync(_apiClient, schema);
await foreach (var record in records)
{
// stop publishing if the limit flag is enabled and the limit has been reached or the server is disconnected
if (limitFlag && recordsCount == limit || !_server.Connected)
{
break;
}
// publish record
await responseStream.WriteAsync(record);
recordsCount++;
}
}
Logger.Info($"Published {recordsCount} records");
}
catch (Exception e)
{
Logger.Error(e, e.Message, context);
}
}
public override async Task GetData(PeerDataRequest request, IServerStreamWriter <PeerDataReplyChunk> responseStream, ServerCallContext context)
{
_logger.LogInformation($"Serving the file at: {_permStorageBasePath}/{request.Identifier.FileName}");
var dataChunkSize = int.Parse(this._configuration["DataChunkSize"]);
var path = $"{_permStorageBasePath}/{request.Identifier.FileName}";
await using var file = File.OpenRead(path);
using (var compressedValue = new MemoryStream())
{
var comprActivity = _source.StartActivity("Compression");
comprActivity.Start();
using (var compressionStream = new GZipStream(compressedValue, CompressionLevel.Optimal, leaveOpen: true))
{
await file.CopyToAsync(compressionStream);
}
comprActivity.Stop();
compressedValue.Seek(0, SeekOrigin.Begin);
var sendingActivity = _source.StartActivity("SendingChunks");
sendingActivity.Start();
while (compressedValue.Position != compressedValue.Length)
{
var bytes = new byte[dataChunkSize];
var read = compressedValue.Read(bytes, 0, bytes.Length);
var peerDataReplyChunk = new PeerDataReplyChunk
{
Payload = ByteString.CopyFrom(bytes, 0, read)
};
_logger.LogInformation($"Sending message of size: {peerDataReplyChunk.CalculateSize()}");
await responseStream.WriteAsync(peerDataReplyChunk);
}
sendingActivity.Stop();
}
file.Dispose();
if (this._configuration["DeleteDataAfterUse"] == "true")
{
File.Delete(path);
}
}
/// <inheritdoc/>
public override Task Connect(HeadInfo request, IServerStreamWriter <Empty> responseStream, ServerCallContext context)
{
var headId = request.HeadId.To <HeadId>();
Timer timer = null;
try
{
_logger.Information($"Head connected '{headId}'");
if (request.ServicesByName.Count == 0)
{
_logger.Information("Not providing any head services");
}
else
{
request.ServicesByName.ForEach(_ => _logger.Information($"Providing service {_}"));
}
var connectionTime = _systemClock.GetCurrentTime();
var client = new Head(
headId,
request.Host,
request.Port,
request.Runtime,
request.ServicesByName,
connectionTime);
_connectedHeads.Connect(client);
timer = new Timer(1000)
{
Enabled = true
};
timer.Elapsed += (s, e) => responseStream.WriteAsync(new Empty());
context.CancellationToken.ThrowIfCancellationRequested();
context.CancellationToken.WaitHandle.WaitOne();
}
finally
{
_connectedHeads.Disconnect(headId);
timer?.Dispose();
}
return(Task.CompletedTask);
}
public async Task RecordLocation(IAsyncStreamReader <Point> requestStream, IServerStreamWriter <Response> responseStream, ServerCallContext context)
{
var stopwatch = new Stopwatch();
while (await requestStream.MoveNext())
{
stopwatch.Restart();
var point = requestStream.Current;
SavePointToCassandra(point);
stopwatch.Stop();
await responseStream.WriteAsync(new Response
{
ResponseTime = (int)stopwatch.ElapsedMilliseconds
});
}
}
public override async Task BatchAddOrder(IAsyncStreamReader <Order> requestStream, IServerStreamWriter <Order> responseStream, ServerCallContext context)
{
_logger.LogInformation("有人请求接口 -> BatchAddOrder");
while (await requestStream.MoveNext())
{
var inputOrder = requestStream.Current;
lock (this)
{
_logger.LogInformation($"接受数据：{inputOrder}");
inputOrder.Id = InMemoryData.Orders.Max(x => x.Id) + 1;
InMemoryData.Orders.Add(inputOrder);
}
await responseStream.WriteAsync(inputOrder);
Thread.Sleep(5000);
}
}
private async Task WriteUpdateAsyncFac(IServerStreamWriter <MatematicaResponse> stream, int factorial)
{
//var reply = new GetMemberReply();
try
{
await stream.WriteAsync(new MatematicaResponse
{
Msg2 = new FactorialReply
{
Number = factorial
}
});
}
catch (Exception e)
{
_logger.LogError($"Failed to write message: {e.Message}");
}
}
/// <summary>
/// Server streaming RPC
/// </summary>
public override async Task GetFoos(FooServerStreamingRequest request, IServerStreamWriter <FooResponse> responseStream, ServerCallContext context)
{
var count = 0;
while (count < request.MessageCount && !context.CancellationToken.IsCancellationRequested)
{
count++;
var response = new FooResponse
{
Message = $"Request message: {request.Message} ({count})"
};
await responseStream.WriteAsync(response).ConfigureAwait(false);
await Task.Delay(1000).ConfigureAwait(false);
}
}
public override async Task AllRooms(Protos.AllRoomsRequest request, IServerStreamWriter <AllRoomsResponse> responseStream, ServerCallContext context)
{
try
{
foreach (var item in _serviceContract.AllRooms())
{
var response = new Protos.AllRoomsResponse {
Value = (Protos.Room)item
};
await responseStream.WriteAsync(response);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error invoking AllRooms");
throw new RpcException(new Status(StatusCode.Internal, ex.Message));
}
}
public override async Task SayHello(HelloRequest request, IServerStreamWriter <HelloReply> responseStream, ServerCallContext context)
{
while (true)
{
await Task.Delay(1000);
Console.WriteLine("Start to stream a response...");
var response = new HelloReply()
{
Message = "123"
};
await responseStream.WriteAsync(response);
Console.WriteLine("Finished to stream a response...");
}
}
public override async Task Join(User request, IServerStreamWriter <MessageModel> responseStream, ServerCallContext context)
{
var token = context.CancellationToken;
users.User.Add(request);
Console.WriteLine("User {0} is connected!", request);
int i = 0;
while (!token.IsCancellationRequested)
{
while (i < history.Count)
{
await responseStream.WriteAsync(history[i++]);
}
await _semaphore.WaitAsync(1);
}
}
/// <summary>
/// Get input as stream and return as stream
/// </summary>
/// <param name="requestStream"></param>
/// <param name="responseStream"></param>
/// <param name="context"></param>
/// <returns></returns>
public override async Task GetInputStreamAsServerStream(IAsyncStreamReader <EchoInput> requestStream, IServerStreamWriter <EchoOutput> responseStream, ServerCallContext context)
{
_logger.LogTrace($"{context.Host} {context.Method}");
while (await requestStream.MoveNext())
{
var returnVal = new EchoOutput()
{
Output = requestStream.Current.Input.ToString(),
TimeStamp = Timestamp.FromDateTime(DateTime.UtcNow)
};
await responseStream.WriteAsync(returnVal);
//Sleep 3s
Thread.Sleep(3000);
}
}
public override async Task StreamingOutputCall(StreamingOutputCallRequest request, IServerStreamWriter <StreamingOutputCallResponse> responseStream, ServerCallContext context)
{
await EnsureEchoMetadataAsync(context, request.ResponseParameters.Any(rp => rp.Compressed?.Value ?? false));
EnsureEchoStatus(request.ResponseStatus, context);
foreach (var responseParam in request.ResponseParameters)
{
responseStream.WriteOptions = !(responseParam.Compressed?.Value ?? false)
? new WriteOptions(WriteFlags.NoCompress)
: null;
var response = new StreamingOutputCallResponse {
Payload = CreateZerosPayload(responseParam.Size)
};
await responseStream.WriteAsync(response);
}
}
public async Task ListenChat(ChatMessageRequest request, IServerStreamWriter<ChatMessage> responseStream, ServerCallContext context)
{
Log(context);
using (IAsyncEnumerator<ChatMessage> enumerator = _chatMessageRepository.ListenAccountChatAsync(request.AccountId).GetEnumerator())
{
// Custom reponse header
await context.WriteResponseHeadersAsync(new Metadata { new Metadata.Entry("Some-response-header-key", "Some-response-header-value") });
// Async enumerator
while (await enumerator.MoveNext())
{
ChatMessage chatMessage = enumerator.Current;
await responseStream.WriteAsync(chatMessage);
}
// Custom response trailer
context.ResponseTrailers.Add(new Metadata.Entry("Some-response-tailer-key", "Some-response-trailer-value"));
}
}
public async Task RunClient(IAsyncStreamReader<ClientArgs> requestStream, IServerStreamWriter<ClientStatus> responseStream, ServerCallContext context)
{
Grpc.Core.Utils.Preconditions.CheckState(await requestStream.MoveNext());
var clientConfig = requestStream.Current.Setup;
var runner = ClientRunners.CreateStarted(clientConfig);
await responseStream.WriteAsync(new ClientStatus
{
Stats = runner.GetStats(false)
});
while (await requestStream.MoveNext())
{
var reset = requestStream.Current.Mark.Reset;
await responseStream.WriteAsync(new ClientStatus
{
Stats = runner.GetStats(reset)
});
}
await runner.StopAsync();
}
/// <summary>
/// Receives a stream of message/location pairs, and responds with a stream of all previous
/// messages at each of those locations.
/// </summary>
public override async Task RouteChat(IAsyncStreamReader<RouteNote> requestStream, IServerStreamWriter<RouteNote> responseStream, 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>
/// Generic streaming call handler.
/// </summary>
public async Task StreamingCall(IAsyncStreamReader<byte[]> requestStream, IServerStreamWriter<byte[]> responseStream, ServerCallContext context)
{
await requestStream.ForEachAsync(async request =>
{
await responseStream.WriteAsync(response);
});
}
public override async Task DivMany(IAsyncStreamReader<DivArgs> requestStream, IServerStreamWriter<DivReply> responseStream, ServerCallContext context)
{
await requestStream.ForEachAsync(async divArgs => await responseStream.WriteAsync(DivInternal(divArgs)));
}
public async Task FullDuplexCall(ServerCallContext context, IAsyncStreamReader<StreamingOutputCallRequest> requestStream, IServerStreamWriter<StreamingOutputCallResponse> responseStream)
{
await requestStream.ForEach(async request =>
{
foreach (var responseParam in request.ResponseParametersList)
{
var response = StreamingOutputCallResponse.CreateBuilder()
.SetPayload(CreateZerosPayload(responseParam.Size)).Build();
await responseStream.WriteAsync(response);
}
});
}
public override async Task GetAllGauges(EmptyMessage request, IServerStreamWriter<GaugeResponse> responseStream, ServerCallContext context)
{
long qps = GetQpsAndReset();
var response = new GaugeResponse
{
Name = GaugeName,
LongValue = qps
};
await responseStream.WriteAsync(response);
}
public async Task GetPersonList(PersonListRequest request, IServerStreamWriter<Person> responseStream, ServerCallContext context)
{
LogRpc(context);
foreach (Person person in _personRepository.GetAllPeople())
{
await responseStream.WriteAsync(person);
}
}
