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 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 });
}
}
/// <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 override async Task<RouteSummary> RecordRoute(IAsyncStreamReader<Point> requestStream, 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)
};
}
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);
}
}
public async Task<StreamingInputCallResponse> StreamingInputCall(IAsyncStreamReader<StreamingInputCallRequest> requestStream, ServerCallContext context)
{
int sum = 0;
await requestStream.ForEachAsync(async request =>
{
sum += request.Payload.Body.Length;
});
return StreamingInputCallResponse.CreateBuilder().SetAggregatedPayloadSize(sum).Build();
}
public async Task<Num> Sum(ServerCallContext context, IAsyncStreamReader<Num> requestStream)
{
long sum = 0;
await requestStream.ForEach(async num =>
{
sum += num.Num_;
});
return Num.CreateBuilder().SetNum_(sum).Build();
}
public async Task<StreamingInputCallResponse> StreamingInputCall(IAsyncStreamReader<StreamingInputCallRequest> requestStream, ServerCallContext context)
{
int sum = 0;
await requestStream.ForEachAsync(async request =>
{
sum += request.Payload.Body.Length;
});
return new StreamingInputCallResponse { AggregatedPayloadSize = sum };
}
public override async Task<Num> Sum(IAsyncStreamReader<Num> requestStream, ServerCallContext context)
{
long sum = 0;
await requestStream.ForEachAsync(async num =>
{
sum += num.Num_;
});
return new Num { Num_ = sum };
}
public async Task<PersonListResponse> CreatePeople(IAsyncStreamReader<Person> requestStream, ServerCallContext context)
{
LogRpc(context);
while (await requestStream.MoveNext(CancellationToken.None))
{
var person = requestStream.Current;
_personRepository.TryCreate(person);
}
return new PersonListResponse { People = { _personRepository.GetAllPeople() } };
}
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 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 async Task<ChatMessageCollection> GetChatHistory(IAsyncStreamReader<ChatMessageRequest> requestStream, ServerCallContext context)
{
Log(context);
var responses = new List<ChatMessage>();
// Async enumerator
while (await requestStream.MoveNext(CancellationToken.None))
{
ChatMessageRequest chatMessageRequest = requestStream.Current;
ICollection<ChatMessage> chatMessages = await _chatMessageRepository.GetAccountChatHistoryAsync(chatMessageRequest.AccountId);
responses.AddRange(chatMessages);
}
return new ChatMessageCollection { ChatMessages = { responses } };
}
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 override async Task RunClient(IAsyncStreamReader<ClientArgs> requestStream, IServerStreamWriter<ClientStatus> responseStream, ServerCallContext context)
{
GrpcPreconditions.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();
}
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 static ResponseProgress <TResult, TProgress> Create <TResult, TProgress>(
IAsyncStreamReader <IProgressMessage <TResult, TProgress> > streamReader,
IProgress <TProgress>?progress = null)
{
return(new ResponseProgress <TResult, TProgress>(streamReader, progress));
}
public override async Task <AverageResponse> AverageStreaming(IAsyncStreamReader <SingleNumber> requestStream, ServerCallContext callContext)
{
double runningSum = 0;
int runningSamples = 0;
while (await requestStream.MoveNext(default))
public override Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>(IAsyncStreamReader <TRequest> requestStream, ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation)
{
var methodName = context.Method.Split('/').Last();
var callMethod = _methods.FirstOrDefault(p => p.Name == methodName);
var serviceScopeFactory = _serviceProvider.GetService <IServiceScopeFactory>();
using (var scope = serviceScopeFactory.CreateScope())
{
var serviceInstance = scope.ServiceProvider.GetService(serviceType);
var serviceResult = callMethod.Invoke(serviceInstance, new object[] { requestStream, context });
return(serviceResult as Task <TResponse>);
}
}
public async Task HalfDuplexCall(IAsyncStreamReader<StreamingOutputCallRequest> requestStream, IServerStreamWriter<StreamingOutputCallResponse> responseStream, ServerCallContext context)
{
throw new NotImplementedException();
}
public GcpClientResponseStream(IAsyncStreamReader <TResponse> originalStreamReader, Action <TResponse> postProcess)
{
this._originalStreamReader = originalStreamReader;
this._postProcess = postProcess;
}
public override Task PushFile(IAsyncStreamReader <PushFileRequest> requestStream, IServerStreamWriter <PushFileResponse> responseStream, ServerCallContext context) => _contentServer.HandlePushFileAsync(requestStream, responseStream, context);
public override async Task <VoidReply> LibAnnouncementBroadcastStream(IAsyncStreamReader <LibAnnouncement> requestStream, ServerCallContext context)
{
await requestStream.ForEachAsync(async r => await ProcessLibAnnouncement(r, context));
return(new VoidReply());
}
public override async Task DivMany(IAsyncStreamReader<DivArgs> requestStream, IServerStreamWriter<DivReply> responseStream, ServerCallContext context)
{
await requestStream.ForEachAsync(async divArgs => await responseStream.WriteAsync(DivInternal(divArgs)));
}
/// <summary>
/// 上传文件
/// </summary>
/// <param name="requestStream">请求流</param>
/// <param name="responseStream">响应流</param>
/// <param name="context">站点上下文</param>
/// <returns></returns>
public override async Task UploadFile(IAsyncStreamReader <FileReply> requestStream, IServerStreamWriter <FileResponse> responseStream, ServerCallContext context)
{
List <string> lstFilesName = new List <string>(); //文件名
List <FileReply> lstContents = new List <FileReply>(); //数据集合
FileStream fs = null;
DateTime startTime = DateTime.Now;//开始时间
string mark = string.Empty;
string savePath = string.Empty;
try
{
//reply.Block数字的含义是服务器和客户端约定的
while (await requestStream.MoveNext())//读取数据
{
var reply = requestStream.Current;
mark = reply.Mark;
if (reply.Block == -2)//传输完成
{
Console.WriteLine($"{mark}，完成上传文件。共计【{lstFilesName.Count}】个，耗时：{DateTime.Now - startTime}");
break;
}
else if (reply.Block == -1)//取消了传输
{
Console.WriteLine($"文件【{reply.FileName}】取消传输！");
lstContents.Clear();
fs?.Close();
if (!string.IsNullOrEmpty(savePath) && File.Exists(savePath))//如果传输不成功，删除该文件
{
File.Delete(savePath);
}
savePath = string.Empty;
break;
}
else if (reply.Block == 0) //文件传输完成
{
if (lstContents.Any()) //如果还有数据，就写入文件
{
lstContents.OrderBy(c => c.Block).ToList().ForEach(c => c.Content.WriteTo(fs));
lstContents.Clear();
}
lstFilesName.Add(savePath); //传输成功的文件
fs?.Close(); //释放文件流
savePath = string.Empty;
//告知客户端，已经完成传输
await responseStream.WriteAsync(new FileResponse
{
FileName = reply.FileName,
Mark = mark
});
}
else
{
//有新文件
if (string.IsNullOrEmpty(savePath))
{
savePath = $"{AppContext.BaseDirectory}\\{Config.Options.JobDirectory}\\{reply.FileName}".Replace('\\', Path.DirectorySeparatorChar);
fs = new FileStream(savePath, FileMode.Create, FileAccess.ReadWrite);
Console.WriteLine($"{mark}，上传文件：{savePath}，{DateTime.UtcNow.ToString("HH:mm:ss:ffff")}");
}
lstContents.Add(reply);
if (lstContents.Count() >= 20)//每个包1M，20M为一个集合，一起写入数据。
{
lstContents.OrderBy(c => c.Block).ToList().ForEach(c => c.Content.WriteTo(fs));
lstContents.Clear();
}
}
}
}
catch (Exception ex)
{
Console.WriteLine($"{mark}，发生异常({ex.GetType()})：{ex.Message}");
}
finally
{
fs?.Dispose();
}
}
private async Task <(long Chunks, long Bytes)> StreamContentWithCompressionAsync(Stream targetStream, IAsyncStreamReader <CopyFileResponse> replyStream, CancellationToken ct)
{
Contract.Requires(targetStream != null);
Contract.Requires(replyStream != null);
long chunks = 0L;
long bytes = 0L;
using (BufferedReadStream grpcStream = new BufferedReadStream(async() =>
{
if (await replyStream.MoveNext(ct))
{
chunks++;
bytes += replyStream.Current.Content.Length;
return(replyStream.Current.Content.ToByteArray());
}
else
{
return(null);
}
}))
{
using (Stream decompressedStream = new GZipStream(grpcStream, CompressionMode.Decompress, true))
{
await decompressedStream.CopyToAsync(targetStream, _bufferSize, ct);
}
}
return(chunks, bytes);
}
private async Task <(long Chunks, long Bytes)> StreamContentAsync(Stream targetStream, IAsyncStreamReader <CopyFileResponse> replyStream, CancellationToken ct)
{
Contract.Requires(targetStream != null);
Contract.Requires(replyStream != null);
long chunks = 0L;
long bytes = 0L;
while (await replyStream.MoveNext(ct))
{
chunks++;
CopyFileResponse reply = replyStream.Current;
bytes += reply.Content.Length;
reply.Content.WriteTo(targetStream);
}
return(chunks, bytes);
}
public virtual global::System.Threading.Tasks.Task <global::Proto.Remoting.Unit> Receive(
IAsyncStreamReader <global::Proto.Remoting.MessageBatch> requestStream, ServerCallContext context)
{
throw new RpcException(new Status(StatusCode.Unimplemented, ""));
}
/// <summary>
/// Constructor for <see cref="IAsyncStreamReader{T}"/> wrapper
/// </summary>
/// <param name="reader">Stream reader that should be wrapped by this class</param>
/// <param name="onMessage">Action that should be executed on each message received from the stream</param>
public WrapperStreamReader(IAsyncStreamReader <T> reader, Action onMessage)
{
_reader = reader;
_onMessage = onMessage;
}
public override Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>(IAsyncStreamReader <TRequest> requestStream, ServerCallContext context,
ClientStreamingServerMethod <TRequest, TResponse> continuation)
{
try
{
var peer = _peerPool.FindPeerByPublicKey(context.GetPublicKey());
if (peer == null)
{
Logger.LogWarning($"Could not find peer {context.GetPublicKey()}");
return(Task.FromResult <TResponse>(null));
}
if (!peer.InboundSessionId.BytesEqual(context.GetSessionId()))
{
Logger.LogWarning($"Wrong session id, ({peer.InboundSessionId.ToHex()} vs {context.GetSessionId().ToHex()}) {context.GetPublicKey()}");
return(Task.FromResult <TResponse>(null));
}
context.RequestHeaders.Add(new Metadata.Entry(GrpcConstants.PeerInfoMetadataKey, $"{peer}"));
}
catch (Exception e)
{
Logger.LogError("Auth interceptor error: ", e);
return(null);
}
return(continuation(requestStream, context));
}
/// <summary>
/// A sequence of requests followed by a sequence of responses.
/// The server buffers all the client requests and then serves them in order. A
/// stream of responses are returned to the client when the server starts with
/// first request.
/// </summary>
public virtual global::System.Threading.Tasks.Task HalfDuplexCall(IAsyncStreamReader <global::Grpc.Testing.StreamingOutputCallRequest> requestStream, IServerStreamWriter <global::Grpc.Testing.StreamingOutputCallResponse> responseStream, ServerCallContext context)
{
throw new RpcException(new Status(StatusCode.Unimplemented, ""));
}
/// <inheritdoc/>
public override async Task Connect(
IAsyncStreamReader <EmbeddingClientToRuntimeMessage> runtimeStream,
IServerStreamWriter <EmbeddingRuntimeToClientMessage> clientStream,
ServerCallContext context)
{
// TODO: It seems like things are not properly unregistered on exceptions?
// TODO: I tested this out and while making the DI container work, it kept failing and telling me that the projection was already registered on the second attempt.
Log.ConnectingEmbeddings(_logger);
using var cts = CancellationTokenSource.CreateLinkedTokenSource(_hostApplicationLifetime.ApplicationStopping, context.CancellationToken);
var connection = await _reverseCallServices.Connect(runtimeStream, clientStream, context, _protocol, context.CancellationToken).ConfigureAwait(false);
if (!connection.Success)
{
return;
}
using var dispatcher = connection.Result.dispatcher;
var arguments = connection.Result.arguments;
var tryCreateExecutionContext = _executionContextCreator.TryCreateUsing(arguments.ExecutionContext);
if (!tryCreateExecutionContext.Success)
{
await dispatcher.Reject(
_protocol.CreateFailedConnectResponse($"Failed to register embedding because the execution context is invalid: ${tryCreateExecutionContext.Exception.Message}"),
cts.Token).ConfigureAwait(false);
return;
}
var executionContext = tryCreateExecutionContext.Result; // TODO: Use this
if (_embeddingProcessors.HasEmbeddingProcessors(arguments.Definition.Embedding))
{
await dispatcher.Reject(
_protocol.CreateFailedConnectResponse($"Failed to register Embedding: {arguments.Definition.Embedding.Value}. Embedding already registered with the same id"),
cts.Token).ConfigureAwait(false);
return;
}
if (await RejectIfInvalidDefinition(arguments.Definition, dispatcher, cts.Token).ConfigureAwait(false))
{
return;
}
var persistDefinition = await _embeddingDefinitionPersister.TryPersist(arguments.Definition, cts.Token).ConfigureAwait(false);
if (!persistDefinition.Success)
{
await dispatcher.Reject(
_protocol.CreateFailedConnectResponse($"Failed to register Embedding: {arguments.Definition.Embedding.Value}. Failed to persist embedding definition. {persistDefinition.Exception.Message}"),
cts.Token).ConfigureAwait(false);
return;
}
var dispatcherTask = dispatcher.Accept(new EmbeddingRegistrationResponse(), cts.Token);
var processorTask = _embeddingProcessors.TryStartEmbeddingProcessorForAllTenants(
arguments.Definition.Embedding,
tenant => _getEmbeddingProcessorFactoryFor(tenant)
.Create(
arguments.Definition.Embedding,
new Embedding(
arguments.Definition.Embedding,
dispatcher,
_embeddingRequestFactory,
_loggerFactory.CreateLogger <Embedding>()),
arguments.Definition.InititalState,
executionContext),
cts.Token);
var tasks = new TaskGroup(dispatcherTask, processorTask);
await tasks.WaitForAllCancellingOnFirst(cts).ConfigureAwait(false);
}
/// <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);
}
}
}
public LoggableStreamReader(IMagicOnionLogger logger, ServiceContext context, IAsyncStreamReader <T> reader)
{
this.logger = logger;
this.context = context;
this.reader = reader;
}
public async Task HandlePushFileAsync(IAsyncStreamReader <PushFileRequest> requestStream, IServerStreamWriter <PushFileResponse> responseStream, ServerCallContext callContext)
{
// Detaching from the calling thread to (potentially) avoid IO Completion port thread exhaustion
await Task.Yield();
var startTime = DateTime.UtcNow;
var pushRequest = PushRequest.FromMetadata(callContext.RequestHeaders);
var hash = pushRequest.Hash;
var cacheContext = new Context(pushRequest.TraceId, Logger);
var token = callContext.CancellationToken;
var store = _contentStoreByCacheName.Values.OfType <IPushFileHandler>().FirstOrDefault();
if (!CanHandlePushRequest(cacheContext, hash, store))
{
await callContext.WriteResponseHeadersAsync(PushResponse.DoNotCopy.Metadata);
return;
}
try
{
// Running the logic inside try/finally block to remove the hash being processed regardless of the result of this method.
await callContext.WriteResponseHeadersAsync(PushResponse.Copy.Metadata);
PutResult?result = null;
using (var disposableFile = new DisposableFile(cacheContext, _fileSystem, _temporaryDirectory !.CreateRandomFileName()))
{
// NOTE(jubayard): DeleteOnClose not used here because the file needs to be placed into the CAS.
// Opening a file for read/write and then doing pretty much anything to it leads to weird behavior
// that needs to be tested on a case by case basis. Since we don't know what the underlying store
// plans to do with the file, it is more robust to just use the DisposableFile construct.
using (var tempFile = await _fileSystem.OpenSafeAsync(disposableFile.Path, FileAccess.Write, FileMode.CreateNew, FileShare.None))
{
while (await requestStream.MoveNext())
{
if (token.IsCancellationRequested)
{
return;
}
var request = requestStream.Current;
var bytes = request.Content.ToByteArray();
await tempFile.WriteAsync(bytes, 0, bytes.Length, token);
}
}
result = await store.HandlePushFileAsync(cacheContext, hash, disposableFile.Path, token);
}
var response = result
? new PushFileResponse {
Header = ResponseHeader.Success(startTime)
}
: new PushFileResponse {
Header = ResponseHeader.Failure(startTime, result.ErrorMessage)
};
await responseStream.WriteAsync(response);
}
finally
{
_ongoingPushes.Remove(hash);
}
}
public override async Task GetTownWeatherStream(
IAsyncStreamReader <TownWeatherRequest> requestStream,
IServerStreamWriter <TownWeatherForecast> responseStream,
ServerCallContext context)
{
var rng = new Random();
var now = DateTime.UtcNow;
// we'll use a channel here to handle in-process 'messages' concurrently being written to and read from the channel.
var channel = Channel.CreateUnbounded <TownWeatherForecast>();
// background task which uses async streams to write each forecast from the channel to the response steam.
_ = Task.Run(async() =>
{
await foreach (var forecast in channel.Reader.ReadAllAsync())
{
await responseStream.WriteAsync(forecast);
}
});
// a list of tasks handling requests concurrently
var getTownWeatherRequestTasks = new List <Task>();
try
{
// async streams used to process each request from the stream as they are receieved
await foreach (var request in requestStream.ReadAllAsync())
{
_logger.LogInformation($"Getting weather for {request.TownName}");
getTownWeatherRequestTasks.Add(GetTownWeatherAsync(request.TownName)); // start and add the request handling task
}
_logger.LogInformation("Client finished streaming");
}
catch (Exception e)
{
_logger.LogError(e, "An exception occurred");
}
// wait for all responses to be written to the channel
// from the concurrent tasks handling each request
await Task.WhenAll(getTownWeatherRequestTasks);
channel.Writer.TryComplete();
// wait for all responses to be read from the channel and streamed as responses
await channel.Reader.Completion;
_logger.LogInformation("Completed response streaming");
// a local function which defines a task to handle a town forecast request
// it produces 10 forecasts for each town, simulating a 0.5s time to gather each forecast
// multiple instances of this will run concurrently for each recieved request
async Task GetTownWeatherAsync(string town)
{
for (var i = 0; i < 10; i++)
{
var forecast = new WeatherData
{
DateTimeStamp = Timestamp.FromDateTime(now.AddDays(i)),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
};
await Task.Delay(500); // Gotta look busy
// write the forecast to the channel which will be picked up concurrently by the channel reading background task
await channel.Writer.WriteAsync(new TownWeatherForecast
{
TownName = town,
WeatherData = forecast
});
}
}
}
public override async Task <TResponse> ClientStreamingServerHandler <TRequest, TResponse>(IAsyncStreamReader <TRequest> requestStream,
ServerCallContext context, ClientStreamingServerMethod <TRequest, TResponse> continuation)
{
return(await Monitor <TRequest, TResponse>(requestStream, context, continuation));
}
public override Task StreamAggregatedResources(IAsyncStreamReader <DiscoveryRequest> requestStream,
IServerStreamWriter <DiscoveryResponse> responseStream,
ServerCallContext context)
{
return(_services.HandleStream(requestStream, responseStream, context, TypeStrings.Any));
}
public override async Task DuplexStreamingServerHandler <TRequest, TResponse>(IAsyncStreamReader <TRequest> requestStream, IServerStreamWriter <TResponse> responseStream, ServerCallContext context, DuplexStreamingServerMethod <TRequest, TResponse> continuation)
{
await Monitor <TRequest, TResponse>(requestStream, context, continuation, responseStream);
}
public override async Task <AppendResp> Append(
IAsyncStreamReader <AppendReq> requestStream,
ServerCallContext context)
{
if (!await requestStream.MoveNext().ConfigureAwait(false))
{
throw new InvalidOperationException();
}
if (requestStream.Current.ContentCase != AppendReq.ContentOneofCase.Options)
{
throw new InvalidOperationException();
}
var options = requestStream.Current.Options;
var streamName = options.StreamName;
var expectedVersion = options.ExpectedStreamRevisionCase switch {
AppendReq.Types.Options.ExpectedStreamRevisionOneofCase.Revision => new StreamRevision(
options.Revision).ToInt64(),
AppendReq.Types.Options.ExpectedStreamRevisionOneofCase.Any => AnyStreamRevision.Any.ToInt64(),
AppendReq.Types.Options.ExpectedStreamRevisionOneofCase.StreamExists => AnyStreamRevision.StreamExists.ToInt64(),
AppendReq.Types.Options.ExpectedStreamRevisionOneofCase.NoStream => AnyStreamRevision.NoStream.ToInt64(),
_ => throw new InvalidOperationException()
};
var user = context.GetHttpContext().User;
var requiresLeader = GetRequiresLeader(context.RequestHeaders);
var correlationId = Guid.NewGuid(); // TODO: JPB use request id?
var events = new List <Event>();
var size = 0;
while (await requestStream.MoveNext().ConfigureAwait(false))
{
if (requestStream.Current.ContentCase != AppendReq.ContentOneofCase.ProposedMessage)
{
throw new InvalidOperationException();
}
var proposedMessage = requestStream.Current.ProposedMessage;
var data = proposedMessage.Data.ToByteArray();
size += data.Length;
if (size > _maxAppendSize)
{
throw RpcExceptions.MaxAppendSizeExceeded(_maxAppendSize);
}
if (!proposedMessage.Metadata.TryGetValue(Constants.Metadata.Type, out var eventType))
{
throw RpcExceptions.RequiredMetadataPropertyMissing(Constants.Metadata.Type);
}
if (!proposedMessage.Metadata.TryGetValue(Constants.Metadata.ContentType, out var contentType))
{
throw RpcExceptions.RequiredMetadataPropertyMissing(Constants.Metadata.ContentType);
}
events.Add(new Event(
Uuid.FromDto(proposedMessage.Id).ToGuid(),
eventType,
contentType == Constants.Metadata.ContentTypes.ApplicationJson,
data,
proposedMessage.CustomMetadata.ToByteArray()));
}
var appendResponseSource = new TaskCompletionSource <AppendResp>();
var envelope = new CallbackEnvelope(HandleWriteEventsCompleted);
_queue.Publish(new ClientMessage.WriteEvents(
correlationId,
correlationId,
envelope,
true,
streamName,
expectedVersion,
events.ToArray(),
user));
return(await appendResponseSource.Task.ConfigureAwait(false));
void HandleWriteEventsCompleted(Message message)
{
if (message is ClientMessage.NotHandled notHandled && RpcExceptions.TryHandleNotHandled(notHandled, out var ex))
{
appendResponseSource.TrySetException(ex);
return;
}
if (!(message is ClientMessage.WriteEventsCompleted completed))
{
appendResponseSource.TrySetException(
RpcExceptions.UnknownMessage <ClientMessage.WriteEventsCompleted>(message));
return;
}
switch (completed.Result)
{
case OperationResult.Success:
var response = new AppendResp();
if (completed.LastEventNumber == -1)
{
response.NoStream = new Empty();
}
else
{
response.CurrentRevision = StreamRevision.FromInt64(completed.LastEventNumber);
}
if (completed.CommitPosition == -1)
{
response.NoPosition = new Empty();
}
else
{
var position = Position.FromInt64(completed.CommitPosition, completed.PreparePosition);
response.Position = new AppendResp.Types.Position {
CommitPosition = position.CommitPosition,
PreparePosition = position.PreparePosition
};
}
appendResponseSource.TrySetResult(response);
return;
case OperationResult.PrepareTimeout:
case OperationResult.CommitTimeout:
case OperationResult.ForwardTimeout:
appendResponseSource.TrySetException(RpcExceptions.Timeout());
return;
case OperationResult.WrongExpectedVersion:
appendResponseSource.TrySetException(RpcExceptions.WrongExpectedVersion(
streamName,
expectedVersion,
completed.CurrentVersion));
return;
case OperationResult.StreamDeleted:
appendResponseSource.TrySetException(RpcExceptions.StreamDeleted(streamName));
return;
case OperationResult.InvalidTransaction:
appendResponseSource.TrySetException(RpcExceptions.InvalidTransaction());
return;
case OperationResult.AccessDenied:
appendResponseSource.TrySetException(RpcExceptions.AccessDenied());
return;
default:
appendResponseSource.TrySetException(RpcExceptions.UnknownError(completed.Result));
return;
}
}
}
}
/// <summary>
/// Handler used for unimplemented method.
/// </summary>
private Task UnimplementedMethod(IAsyncStreamReader <byte[]> requestStream, IServerStreamWriter <byte[]> responseStream, ServerCallContext ctx)
{
ctx.Status = new Status(StatusCode.Unimplemented, "");
return(TaskUtils.CompletedTask);
}
public virtual Task <global::Grpc.Testing.StreamingInputCallResponse> StreamingInputCall(IAsyncStreamReader <global::Grpc.Testing.StreamingInputCallRequest> requestStream, ServerCallContext context)
{
throw new RpcException(new Status(StatusCode.Unimplemented, ""));
}
public static IObservable <T> AsObservable <T>(this IAsyncStreamReader <T> reader) => new GrpcStreamObservable <T>(reader);
private static async Task<string> ConcatAndEchoHandler(IAsyncStreamReader<string> requestStream, ServerCallContext context)
{
string result = "";
await requestStream.ForEach(async (request) =>
{
if (request == "THROW")
{
throw new Exception("This was thrown on purpose by a test");
}
result += request;
});
// simulate processing takes some time.
await Task.Delay(250);
return result;
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="streamReader">The stream reader.</param>
/// <param name="converter">Conversion method.</param>
internal AsyncConvertAsyncStreamReader(IAsyncStreamReader <TResponse> streamReader, Func <TResponse, Task <TResult> > converter)
{
m_StreamReader = streamReader;
m_Converter = converter;
}
public MarshallingAsyncStreamReader(IAsyncStreamReader <byte[]> inner, IFormatterResolver resolver)
{
this.inner = inner;
this.resolver = resolver;
}
static Task ChatBufferHint(IAsyncStreamReader <ChatMessage> requestStream, IServerStreamWriter <ChatMessage> responseStream, ServerCallContext context)
{
context.WriteOptions = new WriteOptions(WriteFlags.BufferHint);
return(ChatterService.ChatCore(requestStream, responseStream));
}
public override Task HalfDuplexCall(IAsyncStreamReader <StreamingOutputCallRequest> requestStream, IServerStreamWriter <StreamingOutputCallResponse> responseStream, ServerCallContext context)
{
throw new NotImplementedException();
}
public override Task StreamRoutes(IAsyncStreamReader <DiscoveryRequest> requestStream, IServerStreamWriter <DiscoveryResponse> responseStream, ServerCallContext context)
{
return(_service.HandleStream(requestStream, responseStream, context, TypeStrings.RouteType));
}
/// <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 void AsyncDuplexStreamingCall_returns_builder(IClientStreamWriter <HelloRequest> requests, IAsyncStreamReader <HelloReply> responses)
{
var call = TestCallBuilder.AsyncDuplexStreamingCall(requests, responses);
Assert.That(call, Is.InstanceOf <AsyncDuplexStreamingTestCallBuilder <HelloRequest, HelloReply> >());
}
