public override async Task DoPut(
FlightServerRecordBatchStreamReader requestStream,
IAsyncStreamWriter <FlightPutResult> responseStream,
ServerCallContext context
)
{
var newTable = new List <RecordBatch> {
};
long numRows = 0;
await foreach (var batch in requestStream.ReadAllAsync(context.CancellationToken))
{
newTable.Add(batch);
numRows += batch.Length;
}
var descriptor = await requestStream.FlightDescriptor;
var ticket = DescriptorAsTicket(descriptor);
var schema = await requestStream.Schema;
_flightData.Flights.Add(ticket, new FlightInfo(
schema,
descriptor,
new List <FlightEndpoint> {
GetEndpoint(ticket, $"http://{context.Host}")
},
numRows,
-1 // Unknown
));
_flightData.Tables.Add(ticket, newTable);
await responseStream.WriteAsync(new FlightPutResult("Table saved."));
}
public override async Task ListActions(
IAsyncStreamWriter <FlightActionType> responseStream,
ServerCallContext context
)
{
await responseStream.WriteAsync(new FlightActionType("clear", "Clear the flights from the server"));
}
public DuplexStreamingContext(ServiceContext context)
{
this.context = context;
this.innerReader = context.RequestStream;
this.innerWriter = context.ResponseStream;
this.logger = context.MagicOnionLogger;
}
/// <summary>
/// Writes the specified objects.
/// </summary>
/// <typeparam name="T">The type of the object.</typeparam>
/// <param name="streamWriter"></param>
/// <param name="objects">The objects.</param>
/// <returns></returns>
public static async Task WritesAsync <T>(this IAsyncStreamWriter <T> streamWriter, IEnumerable <Task <T> > objects)
{
foreach (Task <T> request in objects)
{
await streamWriter.WriteAsync(await request.ConfigureAwait(false)).ConfigureAwait(false);
}
}
public DuplexStreamingContext(ServiceContext context)
{
this.context = context;
this.innerReader = new LoggableStreamReader <byte[]>(context.MagicOnionLogger, context, context.RequestStream);
this.innerWriter = new LoggableStreamWriter <byte[]>(context.MagicOnionLogger, context, context.ResponseStream);
this.requestMarshaller = (Marshaller <TRequest>)context.RequestMarshaller;
this.responseMarshaller = (Marshaller <TResponse>)context.ResponseMarshaller;
}
/// <inheritdoc/>
public virtual IWorkflowRuntimeProxy CreateProxy(string id, IAsyncStreamWriter <V1RuntimeSignal> signalStream)
{
if (string.IsNullOrWhiteSpace(id))
{
throw new ArgumentNullException(nameof(id));
}
return(ActivatorUtilities.CreateInstance <WorkflowRuntimeProxy>(this.ServiceProvider, id, signalStream));
}
public override async Task ListFlights(FlightCriteria request, IAsyncStreamWriter <FlightInfo> responseStream, ServerCallContext context)
{
var flightInfos = _flightStore.Flights.Select(x => x.Value.GetFlightInfo()).ToList();
foreach (var flightInfo in flightInfos)
{
await responseStream.WriteAsync(flightInfo);
}
}
public override async Task ListActions(IAsyncStreamWriter <FlightActionType> responseStream, ServerCallContext context)
{
await responseStream.WriteAsync(new FlightActionType("get", "get a flight"));
await responseStream.WriteAsync(new FlightActionType("put", "add a flight"));
await responseStream.WriteAsync(new FlightActionType("delete", "delete a flight"));
await responseStream.WriteAsync(new FlightActionType("test", "test action"));
}
public override async Task ListFlights(
FlightCriteria request,
IAsyncStreamWriter <FlightInfo> responseStream,
ServerCallContext context
)
{
foreach (var flight in _flightData.Flights.Values)
{
await responseStream.WriteAsync(flight);
}
}
public override async Task Countdown(IMessage <Box <uint> > request, IAsyncStreamWriter <IMessage <Box <uint> > > responses, ServerCallContext context)
{
uint num = request.Payload.Deserialize().value;
while (num > 0)
{
await responses.WriteAsync(Message.From(Box.Create(num)));
--num;
}
}
public async void Init()
{
// Add client cert to the handler
Task AsyncAuthInterceptor(AuthInterceptorContext context, Grpc.Core.Metadata metadata)
{
return(Task.Run(() => { metadata.Add("Authorization", $"Bearer {_token}"); }));
}
var channelCredentials = new SslCredentials(File.ReadAllText($"{Application.streamingAssetsPath}/server1.crt"));//, //new KeyCertificatePair(File.ReadAllText($"{Application.dataPath}/server1.crt"), ""));
var callCredentials = CallCredentials.FromInterceptor(AsyncAuthInterceptor);
Record.Log($"Trying to connect ...");
_channel = new Channel(
"127.0.0.1",
50051,
ChannelCredentials.Create(
channelCredentials,
callCredentials)/*,
* new []{ // https://grpc.github.io/grpc/node/grpc.html#~ChannelOptions
* new ChannelOption("grpc.keepalive_permit_without_calls", 1),
* new ChannelOption("grpc.keepalive_time_ms", 5 * 1000), // 5 seconds
* }*/
);
await _channel.ConnectAsync(deadline : System.DateTime.UtcNow.AddSeconds(20));
Record.Log($"gRPC channel status: {_channel.State}");
_networkClient = new ErutanClient(_channel);
//var headers = new Grpc.Core.Metadata(); // https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md
//headers.Add(new Grpc.Core.Metadata.Entry("grpc-timeout", "2S"));
_stream = _networkClient.Stream();
_inStream = _stream.ResponseStream;
_outStream = _stream.RequestStream;
// Listen to server packets on different thread
_listenerThread = new Thread(Listen)
{
IsBackground = true
};
_listenerThread.Start();
// Send packets to server on different thread
_senderThread = new Thread(DequeuePacketsToBeSent)
{
IsBackground = true
};
_senderThread.Start();
StreamConnected?.Invoke();
IsConnected = true;
}
public override async Task ListFlights(FlightCriteria request, IAsyncStreamWriter <FlightInfo> responseStream, ServerCallContext context)
{
var tables = _koraliumTransportService.GetTables();
var httpContext = context.GetHttpContext();
foreach (var table in tables)
{
var selectAllSql = table.SelectAllColumnsStatement();
await responseStream.WriteAsync(GetFlightInfo(selectAllSql, context));
}
}
public override async Task DoAction(FlightAction request, IAsyncStreamWriter <FlightResult> responseStream, ServerCallContext context)
{
switch (request.Type)
{
case "test":
await responseStream.WriteAsync(new FlightResult("test data"));
break;
default:
throw new NotImplementedException();
}
}
static async Task CommandLoopAsync(IAsyncStreamWriter <ActionMessage> stream, CancellationToken token)
{
Console.WriteLine("Use +XXXX to add a symbol, -XXXX to remove it.");
await Task.Yield();
while (!token.IsCancellationRequested)
{
Console.Write("> ");
var command = Console.ReadLine();
if (string.IsNullOrWhiteSpace(command))
{
break;
}
ActionMessage message;
switch (command[0])
{
case '+':
message = new ActionMessage {
Add = new AddSymbolRequest {
Symbol = command.Substring(1)
}
};
break;
case '-':
message = new ActionMessage {
Remove = new RemoveSymbolRequest {
Symbol = command.Substring(1)
}
};
break;
default:
Console.WriteLine($"Unknown command: {command}");
continue;
}
try
{
await stream.WriteAsync(message);
}
catch (RpcException ex)
{
Console.WriteLine($"Error sending command: {ex.Message}");
}
catch (OperationCanceledException)
{
// Ignored
}
}
}
async Task SendJoin(IAsyncStreamWriter <TransportMessage> requestStream)
{
var message = new TransportMessage
{
MessageId = NewId.NextGuid().ToString(),
Join = new Join {
Node = new Node().Initialize(_hostNode)
}
};
await requestStream.WriteAsync(message).ConfigureAwait(false);
_node.LogSent(message);
}
public BaseDiscoveryRequestStreamHandler(
IAsyncStreamReader <DiscoveryRequest> requestStream,
IServerStreamWriter <DiscoveryResponse> responseStream,
string defaultTypeUrl,
long streamId,
IConfigWatcher configWatcher,
IEnumerable <IDiscoveryServerCallbacks> callbacks)
{
_defaultTypeUrl = defaultTypeUrl;
_requestStream = requestStream;
_responseStream = responseStream;
_streamId = streamId;
_configWatcher = configWatcher;
_callbacks = callbacks;
}
public override Task DoAction(
FlightAction request,
IAsyncStreamWriter <FlightResult> responseStream,
ServerCallContext context
)
{
if (request.Type == "clear")
{
_flightData.Flights.Clear();
_flightData.Tables.Clear();
}
else
{
throw new RpcException(new Status(StatusCode.InvalidArgument, "Action does not exist."));
}
return(Task.CompletedTask);
}
private async Task SendLoginResponses(string targetLogin,
IAsyncStreamWriter <ServerResponse> responseStream,
ServerResponse loginResponse)
{
if (loginResponse.Type == ResponseType.Init || loginResponse.Type == ResponseType.LoginExists)
{
await responseStream.WriteAsync(loginResponse);
if (loginResponse.Type == ResponseType.Init)
{
Responses.TryAdd(targetLogin, new ConcurrentQueue <ServerResponse>());
}
}
else if (loginResponse.Type == ResponseType.PlayerJoin)
{
await responseStream.WriteAsync(loginResponse);
}
}
/// <inheritdoc/>
public IPingedConnection <TClientMessage, TServerMessage> CreatePingedReverseCallConnection <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse>(
RequestId requestId,
IAsyncStreamReader <TClientMessage> runtimeStream,
IAsyncStreamWriter <TServerMessage> clientStream,
ServerCallContext context,
IConvertReverseCallMessages <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse> messageConverter)
where TClientMessage : IMessage, new()
where TServerMessage : IMessage, new()
where TConnectArguments : class
where TConnectResponse : class
where TRequest : class
where TResponse : class
=> new PingedConnection <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse>(
requestId,
runtimeStream,
clientStream,
context,
messageConverter,
new TokenSourceDeadline(),
_callbackScheduler,
_metricsCollector,
_loggerFactory);
/// <summary>
/// Initializes a new instance of the <see cref="PingedConnection{TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse}"/> class.
/// </summary>
/// <param name="requestId">The request id for the gRPC method call.</param>
/// <param name="runtimeStream">The <see cref="IAsyncStreamReader{TClientMessage}"/> to read messages to the Runtime.</param>
/// <param name="clientStream">The <see cref="IServerStreamWriter{TServerMessage}"/> to write messages to the Client.</param>
/// <param name="context">The <see cref="ServerCallContext"/> of the method call.</param>
/// <param name="messageConverter">The <see cref="MethodConverter"/> to use for decoding the connect arguments and reading the desired ping interval from.</param>
/// <param name="keepalive">The keepalive token canceller to use for keeping track of ping timeouts.</param>
/// <param name="pingScheduler">The callback scheduler to use for scheduling accurate pings.</param>
/// <param name="metrics">The metrics collector to use for metrics about reverse calls.</param>
/// <param name="loggerFactory">The logger factory to use to create loggers.</param>
public PingedConnection(
RequestId requestId,
IAsyncStreamReader <TClientMessage> runtimeStream,
IAsyncStreamWriter <TServerMessage> clientStream,
ServerCallContext context,
IConvertReverseCallMessages <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse> messageConverter,
ICancelTokenIfDeadlineIsMissed keepalive,
ICallbackScheduler pingScheduler,
IMetricsCollector metrics,
ILoggerFactory loggerFactory)
{
_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(context.CancellationToken, keepalive.Token);
_requestId = requestId;
_keepalive = keepalive;
_pingScheduler = pingScheduler;
_wrappedReader = new WrappedAsyncStreamReader <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse>(
requestId,
runtimeStream,
messageConverter,
metrics,
loggerFactory.CreateLogger <WrappedAsyncStreamReader <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse> >(),
_cancellationTokenSource.Token);
_wrappedWriter = new WrappedAsyncStreamWriter <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse>(
requestId,
clientStream,
messageConverter,
metrics,
loggerFactory.CreateLogger <WrappedAsyncStreamWriter <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse> >(),
_cancellationTokenSource.Token);
_metrics = metrics;
_logger = loggerFactory.CreateLogger <PingedConnection <TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse> >();
WaitForCallContextInFirstMessageThenStartPinging();
_keepAliveExpiredRegistration = keepalive.Token.Register(NotifyKeepaliveTimedOut);
}
public BuildJobRunner(ILogger logger, string buildDir, IAsyncStreamReader <RunBuildCommand> commandStream, IAsyncStreamWriter <BuildStatusUpdate> updateStream, CancellationToken cancellationToken)
{
this.logger = logger;
this.buildDir = buildDir;
this.commandStream = commandStream;
this.updateStream = updateStream;
this.cancellationToken = cancellationToken;
}
/// <summary>
/// Converts the request type.
/// </summary>
/// <typeparam name="TSource">The type before conversion.</typeparam>
/// <typeparam name="T">The type of the object.</typeparam>
/// <param name="streamWriter"></param>
/// <param name="requestConverter">Method to convert a object.</param>
/// <returns>A stream writer to write a converted object.</returns>
public static IAsyncStreamWriter <TSource> Convert <TSource, T>(this IAsyncStreamWriter <T> streamWriter, Func <TSource, Task <T> > requestConverter)
{
return(new Internals.AsyncConvertAsyncStreamWriter <TSource, T>(streamWriter, requestConverter));
}
public override async Task DoPut(FlightServerRecordBatchStreamReader requestStream, IAsyncStreamWriter <FlightPutResult> responseStream, ServerCallContext context)
{
var flightDescriptor = await requestStream.FlightDescriptor;
if (!_flightStore.Flights.TryGetValue(flightDescriptor, out var flightHolder))
{
flightHolder = new FlightHolder(flightDescriptor, await requestStream.Schema, $"http://{context.Host}");
_flightStore.Flights.Add(flightDescriptor, flightHolder);
}
while (await requestStream.MoveNext())
{
flightHolder.AddBatch(new RecordBatchWithMetadata(requestStream.Current, requestStream.ApplicationMetadata.FirstOrDefault()));
await responseStream.WriteAsync(FlightPutResult.Empty);
}
}
public void ConnectCustomerToChatRoom(int roomId, Guid customerId, IAsyncStreamWriter <ChatMessage> responseStream)
{
_chatRoomProvider.GetChatRoomById(roomId).CustomersInRoom.FirstOrDefault(c => c.Id == customerId).Stream = responseStream;
}
private protected FlightRecordBatchStreamWriter(IAsyncStreamWriter <FlightData> clientStreamWriter, FlightDescriptor flightDescriptor)
{
_clientStreamWriter = clientStreamWriter;
_flightDescriptor = flightDescriptor;
}
internal StreamWriter(IAsyncStreamWriter <TOut> inputStream, Func <TIn, TOut> convertFunction)
{
_inputStream = inputStream;
_convertFunction = convertFunction;
}
public ServerStreamingContext(ServiceContext context)
{
this.context = context;
this.inner = context.ResponseStream;
this.logger = context.MagicOnionLogger;
}
public void ConnectPlayerStream(int PlayerId, IAsyncStreamWriter <CommandReplay> stream)
{
playerStreamlist[PlayerId].Stream = stream;
}
private static async Task <IResult> RewriteStream <T>(IAsyncStreamReader <T> source, IAsyncStreamWriter <T> destination) where T : class
{
try
{
while (await source.MoveNext())
{
await destination.WriteAsync(source.Current);
}
}
catch (Exception e)
{
return(Result.Failure(e.Message));
}
return(Result.Success());
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="streamWriter">The stream writer.</param>
/// <param name="converter">Conversion method.</param>
internal ConvertAsyncStreamWriter(IAsyncStreamWriter <T> streamWriter, Func <TSource, T> converter)
{
m_StreamWriter = streamWriter;
m_Converter = converter;
}
