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)); }