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