public static ClusterResult Send(
[NotNull] this IClusterClient client,
[NotNull] Request request)
=> client
.SendAsync(request)
.GetAwaiter()
.GetResult();
public async Task <HerculesResult <IList <Guid> > > GetTraceIdsAsync(string tracePrefix, TimeSpan timeout)
{
try
{
var request = Request.Get("/tracing").WithAdditionalQueryParameter("prefix", tracePrefix);
var result = await client.SendAsync(request, timeout).ConfigureAwait(false);
var status = ResponseAnalyzer.Analyze(result.Response, out var errorMessage);
var payload = status == HerculesStatus.Success
? JsonConvert
.DeserializeObject <List <string> >(result.Response.Content.ToString())
.Select(Guid.Parse)
.ToList()
: null;
return(new HerculesResult <IList <Guid> >(status, payload, errorMessage));
}
catch (Exception error)
{
log.Error(error);
return(new HerculesResult <IList <Guid> >(HerculesStatus.UnknownError, null, error.Message));
}
}
public async Task <RemoteUpdateResult> UpdateAsync(RemoteUpdateResult lastResult, CancellationToken cancellationToken)
{
if (!enabled)
{
return(CreateEmptyResult(lastResult));
}
var request = CreateRequest(lastResult?.Version);
var requestPriority = lastResult == null ? RequestPriority.Critical : RequestPriority.Ordinary;
var requestResult = await client.SendAsync(request, priority : requestPriority, cancellationToken : cancellationToken).ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
throw new OperationCanceledException();
}
var updateResult = TryHandleFailure(requestResult, lastResult);
if (updateResult != null)
{
return(updateResult);
}
switch (requestResult.Response.Code)
{
case ResponseCode.NotModified:
return(HandleNotModifiedResponse(lastResult));
case ResponseCode.Ok:
return(HandleSuccessResponse(lastResult, requestResult.Response, requestResult.Replica));
}
throw NoAcceptableResponseException(requestResult);
}
public static async Task <T> GetAsync <T>(this IClusterClient client, string url)
{
var request = Request.Get(url);
var result = await client.SendAsync(request);
var json = result.Response.Content.ToString();
return(JsonConvert.DeserializeObject <T>(json));
}
private async Task <HerculesResult> SendAsync(Request request, object requestDto, TimeSpan timeout, IResponseAnalyzer analyzer)
{
try
{
if (requestDto != null)
{
request = request.WithContentTypeHeader(Constants.ContentTypes.Json);
request = request.WithContent(Serializer.Serialize(requestDto));
}
var result = await client.SendAsync(WithManagementApiTimeout(request, timeout), timeout).ConfigureAwait(false);
var status = analyzer.Analyze(result.Response, out var errorMessage);
return(new HerculesResult(status, errorMessage));
}
catch (Exception error)
{
log.Error(error);
return(new HerculesResult(HerculesStatus.UnknownError, error.Message));
}
}
public async Task <IResponseMessage> SendAsync(
HttpMethod method,
string uriPath,
Dictionary <string, object> uriQueryParams = null,
object content = null,
TimeSpan?timeout = null)
{
var request = await CreateRequest(method, uriPath, uriQueryParams, content, timeout);
var response = await client.SendAsync(request, timeout : timeout);
return(new ClusterResultWrapper(response));
}
public static ClusterResult Send(
[NotNull] this IClusterClient client,
[NotNull] Request request,
[CanBeNull] RequestParameters parameters = null,
[CanBeNull] TimeSpan?timeout = null,
CancellationToken cancellationToken = default)
=> client.SendAsync(
request,
parameters,
timeout,
cancellationToken)
.GetAwaiter()
.GetResult();
/// <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));
}
}
public static Task <ClusterResult> SendAsync(
[NotNull] this IClusterClient client,
[NotNull] Request request,
[CanBeNull] TimeSpan?timeout = null,
[CanBeNull] IRequestStrategy strategy = null,
[CanBeNull] RequestPriority?priority = null,
CancellationToken cancellationToken = default)
=> client.SendAsync(
request,
RequestParameters.Empty
.WithStrategy(strategy)
.WithPriority(priority),
timeout,
cancellationToken);
public static ClusterResult Send(
[NotNull] this IClusterClient client,
[NotNull] Request request,
[CanBeNull] TimeSpan?timeout = null,
[CanBeNull] IRequestStrategy strategy = null,
CancellationToken cancellationToken = default(CancellationToken),
[CanBeNull] RequestPriority?priority = null,
[CanBeNull] string operationName = null)
{
using (operationName == null ? null : Context.Properties.Use(TracingAnnotationNames.Operation, operationName))
{
return(client.SendAsync(request, timeout, strategy, cancellationToken, priority).GetAwaiter().GetResult());
}
}
/// <inheritdoc cref="SendAsync"/>
public static ClusterResult Send(
[NotNull] this IClusterClient client,
[NotNull] Request request,
[CanBeNull] TimeSpan?timeout = null,
[CanBeNull] IRequestStrategy strategy = null,
[CanBeNull] RequestPriority?priority = null,
CancellationToken cancellationToken = default)
=> client.SendAsync(
request,
timeout,
strategy,
priority,
cancellationToken)
.GetAwaiter()
.GetResult();
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();
}
}
public async Task Updater_should_throw_exception_if_singular_code_is_not_200()
{
singularClient.SendAsync(Arg.Any <Request>())
.Returns(info => Task.FromResult(ServerErrorResult()));
Func <Task> assertion = async() =>
{
await settingsUpdater.UpdateAsync(Environment, Service);
};
await assertion.Should()
.ThrowExactlyAsync <Exception>()
.WithMessage("Failed to update idempotency settings from singular. Response code = InternalServerError.");
}
public async Task <ReadTraceResult> ReadAsync(TraceReadQuery query, TimeSpan timeout, CancellationToken cancellationToken = default)
{
try
{
var request = Request.Get("/trace").WithTraceReadQuery(query);
var result = await client.SendAsync(request, timeout, cancellationToken : cancellationToken).ConfigureAwait(false);
var status = ResponseAnalyzer.Analyze(result.Response, out var errorMessage);
var payload = default(ReadTracePayload);
if (status == HerculesStatus.Success)
{
payload = CreateReadTracePayload(JsonConvert.DeserializeObject <TraceResponseDto>(result.Response.Content.ToString()));
}
return(new ReadTraceResult(status, payload, errorMessage));
}
catch (Exception error)
{
log.Error(error);
return(new ReadTraceResult(HerculesStatus.UnknownError, default, error.Message));
public async Task <SettingsUpdaterResult> UpdateAsync(string environment, string service, SettingsUpdaterResult previousResult = null)
{
var request = Request.Get("_settings/versioned")
.WithAdditionalQueryParameter("service", service)
.WithAdditionalQueryParameter("environment", environment)
.WithAdditionalQueryParameter("currentVersion", previousResult?.Version)
.WithAdditionalQueryParameter("versionType", previousResult?.VersionType);
var clusterResult = await singularClient.SendAsync(request).ConfigureAwait(false);
var response = clusterResult.Response;
var content = await TryReadContentAsync(response).ConfigureAwait(false);
if (response.Code == ResponseCode.NotModified)
{
if (previousResult == null)
{
throw new Exception("Received unexpected 'NotModified' response from server although no current version was sent in request.");
}
return(new SettingsUpdaterResult(false, previousResult.Version, previousResult.VersionType, null));
}
if (response.Code == ResponseCode.Ok)
{
var settingsNodes = JsonConfigurationParser.Parse(content);
var versionedRawSettings = settingsBinder.Bind <VersionedSettings <SingularSettings> >(JsonConfigurationParser.Parse(content));
if (versionedRawSettings?.Settings == null)
{
throw new Exception($"Received unexpected empty settings. Content: {content}");
}
return(new SettingsUpdaterResult(true, versionedRawSettings.Version, versionedRawSettings.VersionType, settingsNodes[nameof(VersionedSettings <SingularSettings> .Settings)]));
}
var errorMessage = $"Failed to update idempotency settings from singular. Response code = {response.Code}.";
if (!string.IsNullOrEmpty(content))
{
errorMessage += $" Error = {content}";
}
throw new Exception(errorMessage);
}
public static async Task <ClusterResult> GetAsync(this IClusterClient client, string url)
{
var request = Request.Get(url);
return(await client.SendAsync(request));
}
private void SetupResponse(ClusterResultStatus status, params ResponseCode[] responses)
{
client
.SendAsync(Arg.Any <Request>())
.ReturnsForAnyArgs(new ClusterResult(status, responses.Select(r => new ReplicaResult(null, new Response(r), ResponseVerdict.Reject, TimeSpan.Zero)).ToList(), null, null));
}
