public override Task WriteAsync(StreamingPullRequest message)
{
lock (_lock)
{
_extends.AddRange(message.ModifyDeadlineAckIds.Select(id => new TimedId(_clock.GetCurrentDateTimeUtc(), id)));
_acks.AddRange(message.AckIds.Select(id => new TimedId(_clock.GetCurrentDateTimeUtc(), id)));
return(Task.FromResult(0));
}
}
public override async Task WriteAsync(StreamingPullRequest message)
{
await _taskHelper.ConfigureAwait(_scheduler.Delay(_writeAsyncPreDelay, CancellationToken.None));
var now = _clock.GetCurrentDateTimeUtc();
lock (_lock)
{
_extends.AddRange(message.ModifyDeadlineAckIds.Select(id => new TimedId(now, id)).ToList());
_acks.AddRange(message.AckIds.Select(id => new TimedId(now, id)).ToList());
}
}
public override Task WriteAsync(StreamingPullRequest message)
{
if (message.ModifyDeadlineAckIds.Count != 0 || message.AckIds.Count != 0)
{
throw new InvalidOperationException("WriteAsync must not modify deadlines or send acks/nacks.");
}
if (Equals(message, new StreamingPullRequest()))
{
// An empty message is a ping
lock (_lock)
{
_streamPings.Add(_clock.GetCurrentDateTimeUtc());
}
}
return(Task.FromResult(0));
}
public async Task StreamingPull()
{
// Snippet: StreamingPull(CallSettings,BidirectionalStreamingSettings)
// Create client
SubscriberClient subscriberClient = SubscriberClient.Create();
// Initialize streaming call, retrieving the stream object
SubscriberClient.StreamingPullStream duplexStream = subscriberClient.StreamingPull();
// Sending requests and retrieving responses can be arbitrarily interleaved.
// Exact sequence will depend on client/server behavior.
// Create task to do something with responses from server
Task.Run(async() =>
{
IAsyncEnumerator <StreamingPullResponse> responseStream = duplexStream.ResponseStream;
while (await responseStream.MoveNext())
{
StreamingPullResponse response = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
});
// Send requests to the server
bool done = false;
while (!done)
{
// Initialize a request
StreamingPullRequest request = new StreamingPullRequest
{
SubscriptionAsSubscriptionName = new SubscriptionName("[PROJECT]", "[SUBSCRIPTION]"),
StreamAckDeadlineSeconds = 0,
};
// Stream a request to the server
await duplexStream.WriteAsync(request);
// Set "done" to true when sending requests is complete
}
// Complete writing requests to the stream
await duplexStream.WriteCompleteAsync();
// End snippet
}
public override async Task StreamingPull(StreamingPullRequest request, IServerStreamWriter <StreamingPullResponse> responseStream, ServerCallContext context)
{
var subscription = subscriptions[request.Id];
subscription.SubscriberThread = new Thread(() =>
{
SortedList <long, ConsumeResult <string, byte[]> > toBeSend = new SortedList <long, ConsumeResult <string, byte[]> >((int)subscription.BufferSize);
long lastTimestamp = 0;
while (!context.CancellationToken.IsCancellationRequested) // The code here won't work if the send data is wrong.
{
var consumeResult = subscription.Consumer.Consume(context.CancellationToken);
if (consumeResult == null)
{
continue;
}
if (consumeResult.Headers.TryGetLast("previous", out var previous))
{
if (long.TryParse(Encoding.ASCII.GetString(previous), out var previousTimestamp))
{
if (previousTimestamp == lastTimestamp)
{
toBeSend.Add(consumeResult.Timestamp.UnixTimestampMs, consumeResult);
}
else if (previousTimestamp < lastTimestamp)
{
toBeSend.Add(consumeResult.Timestamp.UnixTimestampMs, consumeResult);
continue;
}
else
{
_logger.LogError("This should not be possible");
}
}
}
foreach (var(key, result) in toBeSend)
{
subscription.Buffer.Post(new DataMessage()
{
Data = ByteString.CopyFrom(result.Value,
0,
result.Value.Length),
Index = result.Offset.Value.ToString(),
Key = (uint)result.Timestamp.UnixTimestampMs,
Partition = (uint)result.Partition.Value,
PartitionKey = result.Key,
Redelivary = false
});
lastTimestamp = result.Timestamp.UnixTimestampMs;
}
toBeSend.Clear();
}
subscription.Buffer.Complete();
});
subscription.SubscriberThread.Start();
while (subscription.Buffer.Completion.IsCompleted)
{
var message = await subscription.Buffer.ReceiveAsync();
await responseStream.WriteAsync(new StreamingPullResponse()
{
Message = message
});
}
}
