static async Task <HelloReply> ReturnHeadersTwice(HelloRequest request, ServerCallContext context)
{
await context.WriteResponseHeadersAsync(null);
await context.WriteResponseHeadersAsync(null);
return(new HelloReply {
Message = "Should never reach here"
});
}
static async Task <HelloReply> ReturnHeadersTwice(HelloRequest request, ServerCallContext context)
{
await context.WriteResponseHeadersAsync(Metadata.Empty).DefaultTimeout();
await context.WriteResponseHeadersAsync(Metadata.Empty).DefaultTimeout();
return(new HelloReply {
Message = "Should never reach here"
});
}
public override async Task <HelloReply> SayHelloSendHeadersTwice(HelloRequest request, ServerCallContext context)
{
await context.WriteResponseHeadersAsync(null);
// This will throw an error
await context.WriteResponseHeadersAsync(null);
return(new HelloReply {
Message = "Should never reach here."
});
}
public override async Task <GetResponse> Get(GetRequest request, ServerCallContext context)
{
if (request.Id < 1)
{
_logger.LogWarning("Invalid Stock ID received: {stockId}", request.Id);
throw new RpcException(new Status(StatusCode.InvalidArgument, "Invalid argument"), "Id must be greater than 1");
}
var stock = await _repository.GetAsync(request.Id);
if (stock is null)
{
throw new RpcException(new Status(StatusCode.NotFound, "Not found"));
}
var headers = new Metadata
{
{ "server-id", ServerId }
};
await context.WriteResponseHeadersAsync(headers);
return(new GetResponse
{
Stock = new Protos.Stock
{
Id = stock.Id,
Symbol = stock.Symbol,
Name = stock.Name
}
});
}
public override async Task <BlockList> RequestBlocks(BlocksRequest request, ServerCallContext context)
{
if (request == null || request.PreviousBlockHash == null || _syncStateService.SyncState != SyncState.Finished)
{
return(new BlockList());
}
Logger.LogDebug($"Peer {context.GetPeerInfo()} requested {request.Count} blocks from {request.PreviousBlockHash}.");
var blockList = new BlockList();
var blocks = await _blockchainService.GetBlocksWithTransactions(request.PreviousBlockHash, request.Count);
if (blocks == null)
{
return(blockList);
}
blockList.Blocks.AddRange(blocks);
if (blockList.Blocks.Count != request.Count)
{
Logger.LogTrace($"Replied with {blockList.Blocks.Count} blocks for request {request}");
}
if (NetworkOptions.CompressBlocksOnRequest)
{
var headers = new Metadata {
new Metadata.Entry(GrpcConstants.GrpcRequestCompressKey, GrpcConstants.GrpcGzipConst)
};
await context.WriteResponseHeadersAsync(headers);
}
return(blockList);
}
public override async Task <AllMethodsResponse> ClientStream(IAsyncStreamReader <AllMethodsRequest> requestStream,
ServerCallContext context)
{
// always write some response headers
await context.WriteResponseHeadersAsync(new Metadata
{
{ "server-header", "server header value" },
{ "server-header", "server header value duplicate" },
{ "server-header-bin", Encoding.UTF8.GetBytes("server header binary value") },
});
context.Status = new Status(StatusCode.OK, "my server status");
context.ResponseTrailers.Add("server-trailer", "server trailer value");
context.ResponseTrailers.Add("server-trailer", "server trailer value duplicate");
context.ResponseTrailers.Add("server-trailer-bin", Encoding.UTF8.GetBytes("server trailer binary value"));
var questionCount = 0;
while (await requestStream.MoveNext())
{
questionCount++;
}
return(new AllMethodsResponse
{
Answer = $"You asked ${questionCount} questions.",
YourDeadline = context.Deadline.ToString(CultureInfo.InvariantCulture),
YourRequestHeaders = { MetadataToMap(context.RequestHeaders) },
});
}
public static Task SetCorrelationId(this ServerCallContext context, string value)
{
var metadata = new Metadata();
metadata.Add(CorrelationIdHeader, value);
return(context.WriteResponseHeadersAsync(metadata));
}
private static void SetTokenString(ServerCallContext context, string tokenString)
{
context.WriteResponseHeadersAsync(new Metadata
{
new Metadata.Entry(AuthorizationHeaderKey, $"{AuthorizationHeaderPrefix}{tokenString}"),
});
}
public override async Task <TResponse> UnaryServerHandler <TRequest, TResponse>(TRequest request, ServerCallContext context, UnaryServerMethod <TRequest, TResponse> continuation)
{
TResponse response = null;
try
{
var sw = Stopwatch.StartNew();
//Request
response = await base.UnaryServerHandler(request, context, continuation);
//Response
counter++;
sw.Stop();
Console.WriteLine($"Request: {context.Method}. Params: {request}. Responded {context.Status.StatusCode} in {sw.Elapsed.TotalMilliseconds:0.0000} ms. Counter: {counter}");
}
catch (System.Exception ex)
{
var correlationID = Guid.NewGuid();
Console.WriteLine("Original Exception");
Console.WriteLine($"{ex}.CorrelationID: {correlationID}");
context.ResponseTrailers.Add(new Metadata.Entry("Source", ex.Source));
context.ResponseTrailers.Add(new Metadata.Entry("Parameters", request.ToString()));
await context.WriteResponseHeadersAsync(new Metadata());
throw new Exception($"Generic Error. CorrelationID: {correlationID}");
}
return(response);
}
async Task WaitForAllStreams(IAsyncStreamReader <DataMessage> requestStream, IServerStreamWriter <DataMessage> responseStream, ServerCallContext context)
{
var callId = context.RequestHeaders.GetValue("call-id");
for (var i = 0; i < contexts.Length; i++)
{
if (contexts[i].Id == callId)
{
contexts[i].ReceivedOnServer = true;
}
}
Logger.LogInformation($"Received {callId}");
Interlocked.Increment(ref count);
if (writeResponseHeaders)
{
await context.WriteResponseHeadersAsync(new Metadata());
}
if (count >= streamCount)
{
tcs.TrySetResult(null);
}
await tcs.Task;
}
public override async Task ChatStream(IAsyncStreamReader <ChatMessage> requestStream, IServerStreamWriter <ServerChatMessage> responseStream, ServerCallContext context)
{
string username = context.RequestHeaders.GetValue("username");
var responseHeaders = new Metadata();
if (string.IsNullOrEmpty(username))
{
responseHeaders.Add("status", "Error");
responseHeaders.Add("message", "Username is required in request headers");
await context.WriteResponseHeadersAsync(responseHeaders);
return;
}
var client = new ConnectedClient()
{
ChatReader = requestStream,
ChatWriter = responseStream,
ChatContext = context,
Username = username,
Guid = Guid.NewGuid()
};
responseHeaders.Add("status", "OK");
responseHeaders.Add("guid", client.Guid.ToString());
await context.WriteResponseHeadersAsync(responseHeaders);
await AddClient(client);
try
{
while (await requestStream.MoveNext())
{
await Broadcast(requestStream.Current);
}
}
catch (Exception ex)
{
logger.Error($"!!! RequestStream Exception: Username='******' !!! {ex.Message}");
}
await DeleteClient(client);
}
public override async Task SayHellos(HelloRequest request, IServerStreamWriter <HelloReply> responseStream, ServerCallContext context)
{
// Explicitly send the response headers before any streamed content
Metadata responseHeaders = new Metadata();
responseHeaders.Add("test-response-header", "value");
await context.WriteResponseHeadersAsync(responseHeaders);
await SayHellosCore(request, responseStream);
}
public override Task <HelloReply> SayHelloSendHeadersTwice(HelloRequest request, ServerCallContext context)
{
context.WriteResponseHeadersAsync(null);
try
{
context.WriteResponseHeadersAsync(null);
}
catch (InvalidOperationException e) when(e.Message == "Response headers can only be sent once per call.")
{
return(Task.FromResult(new HelloReply {
Message = "Exception validated"
}));
}
return(Task.FromResult(new HelloReply {
Message = "No exception thrown"
}));
}
public override async Task Bidi(IAsyncStreamReader <ExampleRequest> requestStream,
IServerStreamWriter <ExampleResponse> responseStream, ServerCallContext context)
{
// by default, the server always writes some custom response headers
await context.WriteResponseHeadersAsync(new Metadata
{
{ "server-header", "server header value" },
{ "server-header", "server header value duplicate" },
{ "server-header-bin", Encoding.UTF8.GetBytes("server header binary value") },
});
await responseStream.WriteAsync(new ExampleResponse
{
Answer = "Ask me anything"
});
var questionCount = 0;
await foreach (var x in requestStream.ReadAllAsync())
{
questionCount++;
switch (x.PleaseFail)
{
case FailRequest.MessageThenErrorStatus:
context.Status = new Status(StatusCode.ResourceExhausted, "you requested an error");
await responseStream.WriteAsync(new ExampleResponse
{
Answer = $"You asked {questionCount} questions and requested an error"
});
break;
case FailRequest.ErrorStatusOnly:
throw new RpcException(
new Status(StatusCode.ResourceExhausted, "you requested an error, no message"),
new Metadata
{
{ "server-trailer", "created by rpc exception on server" }
}
);
case FailRequest.None:
await responseStream.WriteAsync(new ExampleResponse
{
Answer = $"You asked: {x.Question}"
});
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
/// <exclude />
public static async Task WriteServerStreamingResult <THeader, TResult>(
IAsyncEnumerable <TResult> result,
Marshaller <THeader> headerMarshaller,
THeader header,
IServerStreamWriter <Message <TResult> > stream,
ServerCallContext context)
{
await context.WriteResponseHeadersAsync(CompatibilityTools.SerializeMethodOutputHeader(headerMarshaller, header)).ConfigureAwait(false);
await WriteServerStreamingResult(result, stream, context).ConfigureAwait(false);
}
public override async Task <AllMethodsResponse> Unary(AllMethodsRequest request, ServerCallContext context)
{
// by default, the server always writes some custom response headers
if (!request.DisableSendingExampleResponseHeaders)
{
await context.WriteResponseHeadersAsync(new Metadata
{
{ "server-header", "server header value" },
{ "server-header", "server header value duplicate" },
{ "server-header-bin", Encoding.UTF8.GetBytes("server header binary value") },
});
}
// always add some response trailers
context.ResponseTrailers.Add("server-trailer", "server trailer value");
context.ResponseTrailers.Add("server-trailer", "server trailer value duplicate");
context.ResponseTrailers.Add("server-trailer-bin", Encoding.UTF8.GetBytes("server trailer binary value"));
// wait for the requested amount of milliseconds
await Task.Delay(request.PleaseDelayResponseMs);
// are we requested to fail? set an error status or even throw
switch (request.PleaseFail)
{
case FailRequest.MessageThenErrorStatus:
context.Status = new Status(StatusCode.ResourceExhausted, "you requested an error");
break;
case FailRequest.ErrorStatusOnly:
throw new RpcException(
new Status(StatusCode.ResourceExhausted, "you requested an error, no message"),
new Metadata
{
{ "server-trailer", "created by rpc exception on server" }
}
);
case FailRequest.None:
context.Status = new Status(StatusCode.OK, "great!");
break;
}
return(new AllMethodsResponse
{
Answer = $"You asked: {request.Question}",
YourDeadline = context.Deadline.ToString(CultureInfo.InvariantCulture),
YourRequestHeaders = { MetadataToMap(context.RequestHeaders) },
YourFailRequest = request.PleaseFail,
});
}
public override async Task DuplexStreaming(
IAsyncStreamReader <HelloRequest> requestStream,
IServerStreamWriter <HelloResult> responseStream,
ServerCallContext context)
{
var greet = CompatibilityToolsTestExtensions.DeserializeMethodInput <string>(ProtobufMarshallerFactory.Default, context.RequestHeaders);
await context.WriteResponseHeadersAsync(CompatibilityToolsTestExtensions.SerializeMethodOutput(ProtobufMarshallerFactory.Default, greet)).ConfigureAwait(false);
while (await requestStream.MoveNext(context.CancellationToken).ConfigureAwait(false))
{
var message = greet + " " + requestStream.Current.Name + "!";
await responseStream.WriteAsync(new HelloResult { Message = message }).ConfigureAwait(false);
}
}
public override async Task ExecuteFunction(IAsyncStreamReader <BundledRows> requestStream, IServerStreamWriter <BundledRows> responseStream, ServerCallContext context)
{
try
{
logger.Debug("ExecuteFunction was called");
var functionRequestHeaderStream = context.RequestHeaders.SingleOrDefault(header => header.Key == "qlik-functionrequestheader-bin");
if (functionRequestHeaderStream == null)
{
throw new Exception("ExecuteFunction called without Function Request Header in Request Headers.");
}
var functionRequestHeader = new FunctionRequestHeader();
functionRequestHeader.MergeFrom(new CodedInputStream(functionRequestHeaderStream.ValueBytes));
var commonHeader = context.RequestHeaders.ParseIMessageFirstOrDefault <CommonRequestHeader>();
logger.Info($"request from user: {commonHeader.UserId} for AppId: {commonHeader.AppId}");
await context.WriteResponseHeadersAsync(new Metadata { { "qlik-cache", "no-store" } });
var functionCall = functionRequestHeader.FunctionId;
logger.Debug($"Function id: {functionCall}");
var row = GetParameter(requestStream);
var input = GetParameterValue(0, row);
string result = String.Empty;
switch (functionCall)
{
case 1:
result = input;
break;
default:
result = "Unknown Function";
break;
}
logger.Debug($"Result: {result}");
await responseStream.WriteAsync(GetResult(result));
}
catch (Exception ex)
{
logger.Error(ex, "ExecuteFunction has errors");
await responseStream.WriteAsync(GetResult("Error"));
}
finally
{
LogManager.Flush();
}
}
public override Task <RpcContractGrpc.Void> CallName(NameResult request, ServerCallContext context)
{
try
{
Console.WriteLine($"from grpc CallName {request.Name} call Hello! [{ServiceName}]");
return(Task.FromResult(new RpcContractGrpc.Void()));
}
catch (Exception ex)
{
var md = new Metadata();
md.Add("err", ex.Message);
context.WriteResponseHeadersAsync(md);
return(Task.FromResult(new RpcContractGrpc.Void()));
}
}
private static async Task EnsureEchoMetadataAsync(ServerCallContext context)
{
var echoInitialList = context.RequestHeaders.Where((entry) => entry.Key == "x-grpc-test-echo-initial").ToList();
if (echoInitialList.Any())
{
var entry = echoInitialList.Single();
await context.WriteResponseHeadersAsync(new Metadata { entry });
}
var echoTrailingList = context.RequestHeaders.Where((entry) => entry.Key == "x-grpc-test-echo-trailing-bin").ToList();
if (echoTrailingList.Any())
{
context.ResponseTrailers.Add(echoTrailingList.Single());
}
}
public override async Task PlayTrivia(IAsyncStreamReader <TriviaAnswer> requestStream, IServerStreamWriter <global::TriviaGame.TriviaQuestion> responseStream, ServerCallContext context)
{
_logger.LogInformation("Playing trivia");
var playerName = context.RequestHeaders.SingleOrDefault(h => h.Key == "playername")?.Value;
var gameId = context.RequestHeaders.SingleOrDefault(h => h.Key == "gameid")?.Value;
_logger.LogInformation($"Starting trivia game with {playerName} in {gameId} with ");
var game = _lobby.Games[Guid.Parse(gameId)];
var player = game.GetPlayer(playerName);
var responseHeader = new Metadata();
responseHeader.Add("numberofquestions", TriviaBank.Questions.Count.ToString());
await context.WriteResponseHeadersAsync(responseHeader);
await player.Play(requestStream, responseStream);
}
public override async Task <BlockList> RequestBlocks(BlocksRequest request, ServerCallContext context)
{
if (request == null ||
request.PreviousBlockHash == null ||
_syncStateService.SyncState != SyncState.Finished ||
request.Count == 0 ||
request.Count > GrpcConstants.MaxSendBlockCountLimit)
{
return(new BlockList());
}
Logger.LogDebug(
$"Peer {context.GetPeerInfo()} requested {request.Count} blocks from {request.PreviousBlockHash}.");
var blockList = new BlockList();
try
{
var blocks =
await _blockchainService.GetBlocksWithTransactions(request.PreviousBlockHash, request.Count);
blockList.Blocks.AddRange(blocks);
if (NetworkOptions.CompressBlocksOnRequest)
{
var headers = new Metadata
{
new Metadata.Entry(GrpcConstants.GrpcRequestCompressKey, GrpcConstants.GrpcGzipConst)
};
await context.WriteResponseHeadersAsync(headers);
}
Logger.LogTrace(
$"Replied to {context.GetPeerInfo()} with {blockList.Blocks.Count}, request was {request}");
}
catch (Exception e)
{
Logger.LogError(e, $"Request blocks error - {context.GetPeerInfo()} - request {request}: ");
throw;
}
return(blockList);
}
public override async Task Copy(CopyRequest request, IServerStreamWriter <CopyReply> responseStream, ServerCallContext context)
{
try
{
Console.WriteLine($"received request for {request.Name}");
FileStreamAndHeaders streamAndHeaders = GetFileStreamAndHeaders(request);
using (streamAndHeaders.Stream)
{
await context.WriteResponseHeadersAsync(streamAndHeaders.GetHeaders()).ConfigureAwait(false);
if (streamAndHeaders.Error is null)
{
Debug.Assert(!(streamAndHeaders.Stream is null));
Debug.Assert(streamAndHeaders.ChunkSize > 0);
byte[] buffer = new byte[streamAndHeaders.ChunkSize];
long chunks, bytes;
switch (streamAndHeaders.Compression)
{
case CopyCompression.None:
(chunks, bytes) = await StreamContent(streamAndHeaders.Stream, buffer, responseStream).ConfigureAwait(false);
break;
case CopyCompression.Gzip:
(chunks, bytes) = await StreamContentWithCompression(streamAndHeaders.Stream, buffer, responseStream).ConfigureAwait(false);
break;
default:
throw new NotSupportedException();
}
Console.WriteLine($"wrote {bytes} bytes in {chunks} chunks");
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public override async Task EchoAllData(
IAsyncStreamReader <DataMessage> requestStream,
IServerStreamWriter <DataMessage> responseStream,
ServerCallContext context)
{
var flushHeaders = context.RequestHeaders.Any(x => x.Key == "flush-headers");
if (flushHeaders)
{
await context.WriteResponseHeadersAsync(new Metadata());
}
await foreach (var message in requestStream.ReadAllAsync())
{
await responseStream.WriteAsync(new DataMessage
{
Data = message.Data
});
}
}
private async Task GenerateAndSendHeadersAsync(ServerCallContext context, int nrOfRows, int nrOfCols, List <ResultDataColumn> resultDataColumns, bool cacheResultInQlik)
{
//Send TableDescription header
TableDescription tableDesc = new TableDescription
{
NumberOfRows = nrOfRows
};
for (int col = 0; col < nrOfCols; col++)
{
if (String.IsNullOrEmpty(resultDataColumns[col].Name))
{
tableDesc.Fields.Add(new FieldDescription
{
DataType = resultDataColumns[col].DataType
});
}
else
{
tableDesc.Fields.Add(new FieldDescription
{
DataType = resultDataColumns[col].DataType,
Name = resultDataColumns[col].Name
});
}
}
var tableMetadata = new Metadata
{
{ new Metadata.Entry("qlik-tabledescription-bin", MessageExtensions.ToByteArray(tableDesc)) }
};
if (!cacheResultInQlik)
{
tableMetadata.Add("qlik-cache", "no-store");
}
await context.WriteResponseHeadersAsync(tableMetadata);
}
// Server side handler of the SayHello RPC
public override Task <HelloReply> SayHello(HelloRequest request, ServerCallContext context)
{
// print who called us
var greetHeader = string.Join(", ", context.RequestHeaders
.Where(header => string.Equals(header.Key, "X-GREET", StringComparison.OrdinalIgnoreCase))
.Select(header => $"[{header.Value}]"));
Console.WriteLine($"got a request from {context.Peer} with {greetHeader}");
// federate (if required)
var federatedRequests = this.federator.SayHello(request);
// wait for responses
var helloFrom = string.Empty;
var responseTasks = new List <Task <HelloReply> >();
if (federatedRequests != null)
{
var headerTasks = new List <Task <Metadata> >(federatedRequests.Select(r => r.ResponseHeadersAsync));
responseTasks = new List <Task <HelloReply> >(federatedRequests.Select(r => r.ResponseAsync));
Task.WaitAll(headerTasks.ToArray());
helloFrom = string
.Join(",", headerTasks
.Select(t => t.Result
.Where(header => string.Equals(header.Key, "X-GREET", StringComparison.OrdinalIgnoreCase))
.Select(header => $"{header.Value}")));
}
// respond to caller
var headerMetadata = new Metadata();
headerMetadata.Add("X-GREET", $"[{instanceName}]{helloFrom}");
context.WriteResponseHeadersAsync(headerMetadata);
Task.WaitAll(responseTasks.ToArray());
return(Task.FromResult(new HelloReply {
Message = request.Name
}));
}
private static async Task WriteResponseHeadersAsync(CallContext context)
{
ServerCallContext serverContext = context !;
var defaultHeader = serverContext.RequestHeaders.FindHeader(DefaultHeaderName, false);
defaultHeader.ShouldNotBeNull();
defaultHeader.Value.ShouldBe(DefaultHeaderValue);
var callHeader = serverContext.RequestHeaders.FindHeader(CallHeaderName, false);
callHeader.ShouldNotBeNull();
callHeader.Value.ShouldBe(CallHeaderValue);
await serverContext
.WriteResponseHeadersAsync(new Metadata
{
{ DefaultHeaderName, DefaultHeaderValue },
{ CallHeaderName, CallHeaderValue }
})
.ConfigureAwait(false);
}
public override async Task <GetWeatherForecastsResponse> GetWeatherForecasts(Empty request, ServerCallContext context)
{
var httpContext = context.GetHttpContext();
await context.WriteResponseHeadersAsync(new Metadata
{
{ "host", $"{httpContext.Request.Scheme}://{httpContext.Request.Host}" }
});
var rng = new Random();
var results = Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.UtcNow.AddDays(index).ToTimestamp(),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
}).ToArray();
var response = new GetWeatherForecastsResponse();
response.Forecasts.AddRange(results);
return(response);
}
public override async Task <ResponseMessage> HeadersTrailers(RequestMessage request, ServerCallContext context)
{
RequestHeaders = context.RequestHeaders;
await context.WriteResponseHeadersAsync(ResponseHeaders);
foreach (var entry in ResponseTrailers)
{
if (entry.IsBinary)
{
context.ResponseTrailers.Add(entry.Key, entry.ValueBytes);
}
else
{
context.ResponseTrailers.Add(entry.Key, entry.Value);
}
}
return(new ResponseMessage
{
Value = request.Value,
Binary = request.Binary
});
}
public override Task GetData(DataRequest request, IServerStreamWriter <DataChunk> responseStream, ServerCallContext context)
{
return(Task.Run(() =>
{
try
{
var query = request?.Parameters?.Statement ?? null;
logger.Debug($"Parse query {query}");
var script = ScriptCode.Parse(query);
if (script == null)
{
throw new Exception("The sql script is not valid.");
}
var userParameter = UserParameter.Create(request.Connection.ConnectionString);
var resultTable = GetData(script, userParameter);
logger.Debug($"Send result table {resultTable.Name}");
//Write meta table
var metaResponse = GetDataResponseInfo(resultTable);
var metaData = new Metadata();
metaData.Add("x-qlik-getdata-bin", metaResponse.ToByteArray());
context.WriteResponseHeadersAsync(metaData).Wait();
//Write data
var dataChunk = GetDataChunk(resultTable);
responseStream.WriteAsync(dataChunk);
}
catch (Exception ex)
{
logger.Error(ex, "The query could not be executed.");
LogManager.Flush();
var errorChunk = new DataChunk();
errorChunk.StringCodes.Add(-1);
responseStream.WriteAsync(errorChunk);
}
}));
}
