public override void HandleBefore(Context context) { var headers = new Dictionary <string, string>(); // Step 1, compute Content MD5 var md5hash = MD5.Create(); byte[] hashData = md5hash.ComputeHash(context.HttpRequestBody); string contentMD5 = Convert.ToBase64String(hashData); headers.Add("x-ots-contentmd5", contentMD5); // Step 2, make date time string var dateString = DateTime.UtcNow.ToString("R"); headers.Add("x-ots-date", dateString); // Step 3, other headers headers.Add("x-ots-apiversion", context.ClientConfig.APIVersion); headers.Add("x-ots-accesskeyid", context.ClientConfig.AccessKeyID); headers.Add("x-ots-instancename", context.ClientConfig.InstanceName); headers.Add("x-ots-user-agent", context.ClientConfig.UserAgent); // Step 4, compute signature string signature = MakeRequestSignature(context, headers); headers.Add("x-ots-signature", signature); context.HttpRequestHeaders = headers; InnerHandler.HandleBefore(context); }
public override Response <AuditResponse, Error> Handle(AuditRequest request) { var response = InnerHandler.Handle(request); if (response.IsSuccess) { FilterDefinitionBuilder <Tenant> filterBuilder = new FilterDefinitionBuilder <Tenant>(); var filter = filterBuilder.ElemMatch(x => x.Keys, key => key.Value == request.ApiKey); var tenant = _tenantCollection.FindSync(filter).First(); tenant.RecordProjectResult(new Project { Name = request.Project, Version = request.Version, Packages = response.Success.Packages.Select(package => new Domain.Package { Name = package.Name, Version = package.Version, PackageManager = "nuget", Vulnerabilities = package.Vulnerabilities?.Select(vulnerability => new Vulnerability { Classification = Classification.Unknown, Description = vulnerability.Description, Title = vulnerability.Title, References = vulnerability.References, AffectedVersions = vulnerability.Versions }).ToArray() ?? new Vulnerability[0] }) }); _tenantCollection.ReplaceOne(x => x.Id == tenant.Id, tenant); } return(response); }
public override async Task <Result <TResult> > HandleAsync(TCommand command, CancellationToken cancellationToken) { Assert.IsNotNull(command, nameof(command)); cancellationToken.ThrowIfCancellationRequested(); var transaction = await CreateTransactionAsync(cancellationToken); var result = Result.Failed <TResult>(500, "Transaction decorator throw an exception."); try { result = await InnerHandler.HandleAsync(command, cancellationToken); } finally { if (result.IsFailed == false) { await CommitTransactionAsync(transaction, cancellationToken); } else { await RollbackTransactionAsync(transaction, cancellationToken); } } return(result); }
public override async Task <int> ExecuteNonQueryAsync(ICommandBuilder commandBuilder, CancellationToken cancellationToken) { return(await CacheOrNot(commandBuilder, async (buffer) => { return await InnerHandler.ExecuteNonQueryAsync(commandBuilder, cancellationToken); })); }
private void InnerNext(InnerHandler sender, TSource item) { _queue.Enqueue(new Entry { Sender = sender, Value = item }); Signal(); }
private void Remove(InnerHandler handler) { for (; ;) { var a = Volatile.Read(ref _inners); var n = a.Length; if (n == 0) { break; } var idx = Array.IndexOf(a, handler); if (idx < 0) { break; } InnerHandler[] b; if (n == 1) { b = Empty; } else { b = new InnerHandler[n - 1]; Array.Copy(a, 0, b, 0, idx); Array.Copy(a, idx + 1, b, idx, n - idx - 1); } if (Interlocked.CompareExchange(ref _inners, b, a) == a) { handler.Dispose(); break; } } }
public override Response <AuditResponse, Error> Handle(HttpRequest request) { var model = SerialiseToModel(request); model.ApiKey = Guid.Parse(request.Headers["X-API-KEY"].First()); return(InnerHandler.Handle(model)); }
public override void HandleAfter(Context context) { InnerHandler.HandleAfter(context); // Disable reponse validation if (context.ClientConfig.SkipResponseValidation) { return; } try { CheckOtherHeaders(context); // Header['authorization'] is not neccessarily available // when HttpStatusCode.Forbidden happens. if (context.HttpResponseStatusCode != HttpStatusCode.Forbidden) { CheckAuthorization(context); } } catch (OTSClientException e) { // re-throw the exception with additonal information throw new OTSClientException( String.Format("{0} HTTP Status: {1}.", e.Message, context.HttpResponseStatusCode), context.HttpResponseStatusCode ); } }
private void First(Task <bool> task, InnerHandler sender) { if (sender.CheckDisposed()) { Dispose(sender.Source); } else { if (Volatile.Read(ref _winner) == null && Interlocked.CompareExchange(ref _winner, sender, null) == null) { if (task.IsCanceled) { _winTask.TrySetCanceled(); } else if (task.IsFaulted) { _winTask.TrySetException(ExceptionHelper.Extract(task.Exception)); } else { _winTask.SetResult(task.Result); } } } }
private void NextHandler(Task <bool> t) { if (t.IsFaulted) { ExceptionHelper.AddException(ref _error, ExceptionHelper.Extract(t.Exception)); _done = true; if (TryDispose()) { Signal(); } } else if (t.Result) { IAsyncEnumerator <TResult> src; try { src = _mapper(_source.Current).GetAsyncEnumerator(); } catch (Exception ex) { ExceptionHelper.AddException(ref _error, ex); _done = true; Dispose(_source); Signal(); return; } if (TryDispose()) { Interlocked.Increment(ref _allDisposeWip); var inner = new InnerHandler(src, this); for (; ;) { var curr = Volatile.Read(ref _current); if (curr == DisposedInnerHandler) { inner.Dispose(); break; } if (Interlocked.CompareExchange(ref _current, inner, curr) == curr) { curr?.Dispose(); inner.MoveNext(); MoveNext(); return; } } } } else { _done = true; if (TryDispose()) { Signal(); } } }
public override void HandleAfter(Context context) { InnerHandler.HandleAfter(context); IMessage message; context.OTSReponse = DecoderMap[context.APIName](context.HttpResponseBody, out message); LogEncodedMessage(context, message); }
public virtual IAsyncResult InvokeAsync(IAsyncExecutionContext executionContext) { if (this.InnerHandler != null) { return(InnerHandler.InvokeAsync(executionContext)); } throw new InvalidOperationException("Cannot invoke InnerHandler. InnerHandler is not set."); }
internal void InnerComplete(InnerHandler sender) { _queue.Enqueue(new Item { Sender = sender }); Signal(); }
internal void InnerError(InnerHandler sender, Exception ex) { AddException(ex); _queue.Enqueue(new Item { Sender = sender }); Signal(); }
public override void HandleBefore(Context context) { var encoder = EncoderMap[context.APIName]; var message = encoder(context.OTSRequest); LogEncodedMessage(context, message); context.HttpRequestBody = message.ToByteArray(); InnerHandler.HandleBefore(context); }
protected override void Dispose(bool disposing) { base.Dispose(disposing); if (disposing && ownsHandler) { InnerHandler.Dispose(); } }
public virtual System.Threading.Tasks.Task <T> InvokeAsync <T>(IExecutionContext executionContext) where T : AmazonWebServiceResponse, new() { if (this.InnerHandler != null) { return(InnerHandler.InvokeAsync <T>(executionContext)); } throw new InvalidOperationException("Cannot invoke InnerHandler. InnerHandler is not set."); }
/// <summary> /// Contains the processing logic for a synchronous request invocation. /// This method calls InnerHandler.InvokeSync to continue processing of the /// request by the pipeline. /// </summary> /// <param name="executionContext">The execution context which contains both the /// requests and response context.</param> // [System.Diagnostics.DebuggerHidden] public virtual void InvokeSync(IExecutionContext executionContext) { if (this.InnerHandler != null) { InnerHandler.InvokeSync(executionContext); return; } throw new InvalidOperationException("Cannot invoke InnerHandler. InnerHandler is not set."); }
public override Response <OrderDispatched, OrderError> Handle(Order request) { if (string.IsNullOrEmpty(request.Address)) { return(OrderError.Validation); } return(InnerHandler.Handle(request)); }
// ReSharper restore ExplicitCallerInfoArgument /// <summary> /// Releases the unmanaged resources used by the <see cref="T:System.Net.Http.DelegatingHandler" />, and optionally disposes of the managed resources. /// </summary> /// <param name="disposing">true to release both managed and unmanaged resources; false to releases only unmanaged resources.</param> protected override void Dispose(bool disposing) { if (disposing && Interlocked.CompareExchange(ref _disposeInner, 0, 1) == 1) { InnerHandler.Dispose(); } base.Dispose(disposing); }
public override TResponse Handle(HttpRequest request) { using (StreamReader reader = new StreamReader(request.Body)) { var json = reader.ReadToEnd(); var model = JsonConvert.DeserializeObject <TModel>(json); return(InnerHandler.Handle(model)); } }
internal void InnerNext(InnerHandler sender, TResult item) { _queue.Enqueue(new Item { Sender = sender, Value = item, HasValue = true }); Signal(); }
public async ValueTask DisposeAsync() { _winner = null; foreach (var ih in _sources) { ih.Dispose(); } await _disposeTask.Task; }
public virtual async Task InvokeAsync(IExecutionContext executionContext) { if (this.InnerHandler != null) { await InnerHandler.InvokeAsync(executionContext).ConfigureAwait(false); return; } throw new InvalidOperationException("Cannot invoke InnerHandler. InnerHandler is not set."); }
private void CreateNewTransportHandler() { if (InnerHandler != null) { InnerHandler.Dispose(); InnerHandler = null; } // Ask the ContinuationFactory to attach the proper handler given the Context's ITransportSettings. InnerHandler = ContinuationFactory(Context, null); }
public override Task HandleAsync(Order request, Context context, CancellationToken token) { if (string.IsNullOrEmpty(request.Address)) { context.SetError(OrderError.Validation); return(Task.CompletedTask); } return(InnerHandler.HandleAsync(request, context, token)); }
public override void HandleAfter(Context context) { var retryPolicy = context.ClientConfig.RetryPolicy; while (true) { OTSException exceptionForRetry = null; try { InnerHandler.HandleAfter(context); } catch (OTSClientException exception) { exceptionForRetry = exception; } catch (OTSServerException exception) { exceptionForRetry = exception; } if (OTSClientTestHelper.RetryTimesAndBackOffRecordSwith) { if (OTSClientTestHelper.RetryExceptions.Count() > OTSClientTestHelper.RetryTimes) { exceptionForRetry = OTSClientTestHelper.RetryExceptions[OTSClientTestHelper.RetryTimes]; } } if (ShouldRetry(retryPolicy, context, exceptionForRetry)) { int retryDelay = retryPolicy.DelayBeforeNextRetry(context, exceptionForRetry); Thread.Sleep(retryDelay); ResetRetry(context); context.RetryTimes += 1; if (OTSClientTestHelper.RetryTimesAndBackOffRecordSwith) { OTSClientTestHelper.RetryTimes += 1; OTSClientTestHelper.RetryDelays.Add(retryDelay); } continue; } if (exceptionForRetry != null) { throw exceptionForRetry; } // TODO handle retry in BatchWriteRow & BatchGetRow return; } }
public override Response <TSuccess, Error> Handle(HttpRequest request) { if (request.Headers.ContainsKey("X-API-KEY") && Guid.TryParse(request.Headers["X-API-KEY"].FirstOrDefault(), out var key) && DoesKeyExist(key)) { return(InnerHandler.Handle(request)); } return(SharedPipes.Authorization.Errors.AuthorizationErrors.Unauthorized); }
public override void HandleAfter(Context context) { OTSServerException exception; InnerHandler.HandleAfter(context); var statusCode = context.HttpResponseStatusCode; if ((int)statusCode >= 200 && (int)statusCode < 300) { return; } var builder = PB.Error.CreateBuilder(); string errorCode = null, errorMessage = null; try { builder.MergeFrom(context.HttpResponseBody); var message = builder.Build(); errorCode = message.Code; errorMessage = message.Message; } catch (Google.ProtocolBuffers.InvalidProtocolBufferException) { throwOTSServerException(context); } catch (Google.ProtocolBuffers.UninitializedMessageException) { throwOTSServerException(context); } string requestID; if (context.HttpResponseHeaders.ContainsKey("x-ots-requestid")) { requestID = context.HttpResponseHeaders["x-ots-requestid"]; } else { requestID = null; } exception = new OTSServerException( context.APIName, statusCode, errorCode, errorMessage, requestID ); if (context.ClientConfig.OTSErrorLogHandler != null) { context.ClientConfig.OTSErrorLogHandler.Invoke(exception.ToString()); } throw exception; }
public override async Task <IEnumerable <T> > ExecuteReaderAsync <T>(ICommandBuilder commandBuilder, CancellationToken cancellationToken) { return(await CacheOrNot(commandBuilder, async (buffer) => { var results = await InnerHandler.ExecuteReaderAsync <T>(commandBuilder, cancellationToken); if (buffer) { results = results.ToList(); } return results; })); }