void TcpReader()
{
try
{
using (StreamReader reader = new StreamReader(_client.GetStream(), Encoding.UTF8))
{
string line;
while ((line = reader.ReadLine()) != null)
{
try
{
Event response = JsonConvert.DeserializeObject <Event>(line);
_responseAnalyzer.Analyze(response);
}
catch (Exception)
{
Debug.Log("Non-JSON Message: " + line);
}
}
}
}
catch (SocketException socketException)
{
Debug.Log("Socket exception: " + socketException);
}
}
public async Task <RawReadStreamResult> ReadAsync(ReadStreamQuery query, string apiKey, TimeSpan timeout, CancellationToken cancellationToken = default)
{
try
{
var url = new RequestUrlBuilder("stream/read")
{
{ Constants.QueryParameters.Stream, query.Name },
{ Constants.QueryParameters.Limit, query.Limit },
{ Constants.QueryParameters.ClientShard, query.ClientShard },
{ Constants.QueryParameters.ClientShardCount, query.ClientShardCount }
}
.Build();
var body = CreateRequestBody(query.Coordinates ?? StreamCoordinates.Empty);
var request = Request
.Post(url)
.WithContentTypeHeader(Constants.ContentTypes.OctetStream)
.WithContent(body);
if (compressionEnabled)
{
request = request.WithAcceptEncodingHeader(Constants.Compression.Lz4Encoding);
}
if (!string.IsNullOrEmpty(apiKey))
{
request = request.WithHeader(Constants.HeaderNames.ApiKey, apiKey);
}
var result = await client
.SendAsync(request, timeout, cancellationToken : cancellationToken)
.ConfigureAwait(false);
var operationStatus = responseAnalyzer.Analyze(result.Response, out var errorMessage);
if (operationStatus != HerculesStatus.Success)
{
if (result.Response.HasContent)
{
bufferPool.Return(result.Response.Content.Buffer);
}
return(new RawReadStreamResult(operationStatus, null, errorMessage));
}
return(new RawReadStreamResult(operationStatus, ParseReadResponseBody(result.Response)));
}
catch (Exception error)
{
log.Warn(error);
return(new RawReadStreamResult(HerculesStatus.UnknownError, null, error.Message));
}
}
void UdpReader()
{
while (true)
{
IPEndPoint remoteIpEndPoint = new IPEndPoint(System.Net.IPAddress.Any, 0);
// Blocks until a message returns on this socket from a remote host.
Byte[] receiveBytes = _client.Receive(ref remoteIpEndPoint);
_responseAnalyzer.Analyze(new Event(new UDPPacket(receiveBytes)));
}
}
/// <inheritdoc />
public async Task <ReadTimelineResult <T> > ReadAsync(ReadTimelineQuery query, TimeSpan timeout, CancellationToken cancellationToken = default)
{
try
{
var url = new RequestUrlBuilder("timeline/read")
{
{ Constants.QueryParameters.Timeline, query.Name },
{ Constants.QueryParameters.Limit, query.Limit },
{ Constants.QueryParameters.ClientShard, query.ClientShard },
{ Constants.QueryParameters.ClientShardCount, query.ClientShardCount },
{ "from", EpochHelper.ToUnixTimeUtcTicks(query.From.UtcDateTime) },
{ "to", EpochHelper.ToUnixTimeUtcTicks(query.To.UtcDateTime) }
}
.Build();
var body = CreateRequestBody(query.Coordinates ?? TimelineCoordinates.Empty);
var request = Request
.Post(url)
.WithContentTypeHeader(Constants.ContentTypes.OctetStream)
.WithContent(body);
var result = await client
.SendAsync(request, timeout, cancellationToken : cancellationToken)
.ConfigureAwait(false);
try
{
var operationStatus = responseAnalyzer.Analyze(result.Response, out var errorMessage);
if (operationStatus != HerculesStatus.Success)
{
return(new ReadTimelineResult <T>(operationStatus, null, errorMessage));
}
return(new ReadTimelineResult <T>(operationStatus, ParseResponseBody(result.Response)));
}
finally
{
if (result.Response.HasContent)
{
bufferPool.Return(result.Response.Content.Buffer);
}
}
}
catch (Exception error)
{
log.Error(error);
return(new ReadTimelineResult <T>(HerculesStatus.UnknownError, null, error.Message));
}
}
private async Task <InsertEventsResult> SendAsync(
[NotNull] string path,
[NotNull] string stream,
[CanBeNull] string apiKey,
[NotNull] ValueDisposable <Content> content,
TimeSpan timeout,
CancellationToken cancellationToken)
{
try
{
var request = Request.Post(path)
.WithAdditionalQueryParameter(Constants.QueryParameters.Stream, stream)
.WithContentTypeHeader(Constants.ContentTypes.OctetStream);
if (!string.IsNullOrEmpty(apiKey))
{
request = request.WithHeader(Constants.HeaderNames.ApiKey, apiKey);
}
if (compressionEnabled)
{
request = request
.WithContentEncodingHeader(Constants.Compression.Lz4Encoding)
.WithHeader(Constants.Compression.OriginalContentLengthHeaderName, content.Value.Length);
content = Compress(content);
}
request = request.WithContent(content.Value);
var result = await client
.SendAsync(request, cancellationToken : cancellationToken, timeout : timeout)
.ConfigureAwait(false);
var operationStatus = responseAnalyzer.Analyze(result.Response, out var errorMessage);
return(new InsertEventsResult(operationStatus, errorMessage));
}
catch (Exception error)
{
log.Warn(error);
return(new InsertEventsResult(HerculesStatus.UnknownError, error.Message));
}
finally
{
content.Dispose();
}
}