public override async Task ProcessAsync(PipelineCallContext context, ReadOnlyMemory <PipelinePolicy> pipeline)
{
_logged.Append($"REQUEST: {context.ToString()}\n");
await ProcessNextAsync(pipeline, context).ConfigureAwait(false);
_logged.Append($"RESPONSE: {context.Response.Status}\n");
}
public async Task <Response <ConfigurationSetting> > SetAsync(ConfigurationSetting setting, CancellationToken cancellation = default)
{
if (setting == null)
{
throw new ArgumentNullException(nameof(setting));
}
if (string.IsNullOrEmpty(setting.Key))
{
throw new ArgumentNullException($"{nameof(setting)}.{nameof(setting.Key)}");
}
Uri uri = BuildUrlForKvRoute(setting);
using (PipelineCallContext context = Pipeline.CreateContext(_options, cancellation))
{
ReadOnlyMemory <byte> content = Serialize(setting);
context.SetRequestLine(ServiceMethod.Put, uri);
context.AddHeader("Host", uri.Host);
context.AddHeader(MediaTypeKeyValueApplicationHeader);
context.AddHeader(Header.Common.JsonContentType);
context.AddHeader(Header.Common.CreateContentLength(content.Length));
AddAuthenticationHeaders(context, uri, ServiceMethod.Put, content, _secret, _credential);
context.SetContent(PipelineContent.Create(content));
await Pipeline.ProcessAsync(context).ConfigureAwait(false);
return(await CreateResponse(context));
}
}
internal static void AddAuthenticationHeaders(PipelineCallContext context, Uri uri, ServiceMethod method, ReadOnlyMemory <byte> content, byte[] secret, string credential)
{
string contentHash = null;
using (var alg = SHA256.Create())
{
// TODO (pri 3): ToArray should nopt be called here. Instead, TryGetArray, or PipelineContent should do hashing on the fly
contentHash = Convert.ToBase64String(alg.ComputeHash(content.ToArray()));
}
using (var hmac = new HMACSHA256(secret))
{
var host = uri.Host;
var pathAndQuery = uri.PathAndQuery;
string verb = method.ToString().ToUpper();
DateTimeOffset utcNow = DateTimeOffset.UtcNow;
var utcNowString = utcNow.ToString("r");
var stringToSign = $"{verb}\n{pathAndQuery}\n{utcNowString};{host};{contentHash}";
var signature = Convert.ToBase64String(hmac.ComputeHash(Encoding.ASCII.GetBytes(stringToSign))); // Calculate the signature
string signedHeaders = "date;host;x-ms-content-sha256"; // Semicolon separated header names
context.AddHeader("Date", utcNowString);
context.AddHeader("x-ms-content-sha256", contentHash);
context.AddHeader("Authorization", $"HMAC-SHA256 Credential={credential}, SignedHeaders={signedHeaders}, Signature={signature}");
}
}
public async Task <Response <Stream> > DetectLazyAsync(CancellationToken cancellation, Uri image, FaceDetectOptions options = default)
{
if (options == null)
{
options = new FaceDetectOptions();
}
Uri uri = BuildUri(options);
PipelineCallContext context = null;
try
{
context = _client.CreateContext(_options, cancellation);
context.SetRequestLine(ServiceMethod.Post, uri);
context.AddHeader(_keyHeader);
context.AddHeader(Header.Common.JsonContentType);
context.SetContent(new FaceContent(image, context));
await _client.ProcessAsync(context).ConfigureAwait(false);
return(new Response <Stream>(context.Response, context.Response.ContentStream));
}
catch
{
if (context != null)
{
context.Dispose();
}
throw;
}
}
static void SetContentStream(PipelineCallContext context, string imagePath)
{
byte[] temp = new byte[4096];
var stream = new FileStream(imagePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true);
context.SetContent(PipelineContent.Create(stream));
context.AddHeader(Header.Common.CreateContentLength(stream.Length));
}
public sealed override async Task ProcessAsync(PipelineCallContext context, ReadOnlyMemory <PipelinePolicy> next)
{
if (next.Length == 0)
{
await ProcessAsync(context).ConfigureAwait(false);
}
else
{
throw new ArgumentOutOfRangeException(nameof(next));
}
}
protected override bool ShouldRetry(PipelineCallContext context, int retry, out TimeSpan delay)
{
delay = TimeSpan.Zero;
if (retry > 5)
{
return(false);
}
if (context.Response.Status == 1)
{
return(false);
}
return(true);
}
protected override bool ShouldRetry(PipelineCallContext context, int attempted, out TimeSpan delay)
{
delay = _delay;
if (attempted > _maxRetries)
{
return(false);
}
if (Array.BinarySearch(_retriableCodes, context.Response.Status) < 0)
{
return(false);
}
return(true);
}
static async Task <Response <ConfigurationSetting> > CreateResponse(PipelineCallContext context)
{
ServiceResponse response = context.Response;
if (response.Status != 200)
{
return(new Response <ConfigurationSetting>(response));
}
var result = await ConfigurationServiceSerializer.ParseSettingAsync(response.ContentStream, context.Cancellation);
return(new Response <ConfigurationSetting>(response, result));
}
public sealed override async Task ProcessAsync(PipelineCallContext context)
{
var httpTransportContext = context as Context;
if (httpTransportContext == null)
{
throw new InvalidOperationException("the context is not compatible with the transport");
}
HttpRequestMessage httpRequest = httpTransportContext.BuildRequestMessage();
HttpResponseMessage responseMessage = await ProcessCoreAsync(context.Cancellation, httpRequest).ConfigureAwait(false);
httpTransportContext.ProcessResponseMessage(responseMessage);
}
public async Task <Response <ConfigurationSetting> > DeleteAsync(string key, SettingFilter filter = null, CancellationToken cancellation = default)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException(nameof(key));
}
Uri uri = BuildUrlForKvRoute(key, filter);
using (PipelineCallContext context = Pipeline.CreateContext(_options, cancellation))
{
context.SetRequestLine(ServiceMethod.Delete, uri);
context.AddHeader("Host", uri.Host);
AddFilterHeaders(filter, context);
AddAuthenticationHeaders(context, uri, ServiceMethod.Delete, content: default, _secret, _credential);
public async Task <Response <FaceDetectResult> > DetectAsync(CancellationToken cancellation, string imagePath, FaceDetectOptions options)
{
if (options == null)
{
options = new FaceDetectOptions();
}
Uri uri = BuildUri(options);
PipelineCallContext context = null;
try
{
context = _client.CreateContext(_options, cancellation);
context.SetRequestLine(ServiceMethod.Post, uri);
context.AddHeader(_keyHeader);
context.AddHeader(Header.Common.OctetStreamContentType);
SetContentStream(context, imagePath);
await _client.ProcessAsync(context).ConfigureAwait(false);
ServiceResponse response = context.Response;
if (!response.TryGetHeader(s_contentLength, out long contentLength))
{
throw new Exception("bad response: no content length header");
}
var buffer = new byte[contentLength];
var read = await response.ContentStream.ReadAsync(buffer, cancellation);
Func <ServiceResponse, FaceDetectResult> contentParser = null;
if (response.Status == 200)
{
contentParser = (rsp) => { return(FaceDetectResult.Parse(new ReadOnlySequence <byte>(buffer, 0, read))); };
}
return(new Response <FaceDetectResult>(response, contentParser));
}
catch
{
if (context != null)
{
context.Dispose();
}
throw;
}
}
public async Task <Response> PutRangeAsync(long index, int length, Stream content, CancellationToken cancellation)
{
if (index < 0)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
if (length < 0 || length > 4 * 1024 * 1024)
{
throw new ArgumentOutOfRangeException(nameof(length));
}
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
if (content.CanRead == false)
{
throw new ArgumentOutOfRangeException(nameof(content));
}
if (content.CanSeek == false)
{
throw new ArgumentOutOfRangeException(nameof(content));
}
PipelineCallContext context = null;
try {
context = Pipeline.CreateContext(_options, cancellation);
context.SetRequestLine(ServiceMethod.Put, _baseUri);
context.AddHeader(Header.Common.CreateContentLength(content.Length));
context.AddHeader(Header.Common.OctetStreamContentType);
context.SetContent(PipelineContent.Create(content));
await Pipeline.ProcessAsync(context).ConfigureAwait(false);
return(new Response(context.Response));
}
catch {
if (context != null)
{
context.Dispose();
}
throw;
}
}
public override async Task ProcessAsync(PipelineCallContext context, ReadOnlyMemory <PipelinePolicy> pipeline)
{
int attempt = 1;
while (true)
{
await ProcessNextAsync(pipeline, context).ConfigureAwait(false);
if (!ShouldRetry(context, attempt++, out var delay))
{
return;
}
if (delay > TimeSpan.Zero)
{
await Task.Delay(delay, context.Cancellation).ConfigureAwait(false);
}
}
}
// TODO (pri 3): do all the methods that call this accept revisions?
static void AddFilterHeaders(SettingFilter filter, PipelineCallContext context)
{
if (filter == null)
{
return;
}
if (filter.ETag.IfMatch != default)
{
context.AddHeader(IfMatchName, $"\"{filter.ETag.IfMatch}\"");
}
if (filter.Revision.HasValue)
{
var dateTime = filter.Revision.Value.UtcDateTime.ToString(AcceptDateTimeFormat);
context.AddHeader(AcceptDatetimeHeader, dateTime);
}
}
public async Task <Response> CreateAsync(CancellationToken cancellation)
{
PipelineCallContext context = null;
try {
context = Pipeline.CreateContext(_options, cancellation);
context.SetRequestLine(ServiceMethod.Put, _baseUri);
await Pipeline.ProcessAsync(context).ConfigureAwait(false);
return(new Response(context.Response));
}
catch {
if (context != null)
{
context.Dispose();
}
throw;
}
}
public FaceContent(Uri image, PipelineCallContext context)
{
_image = image;
_context = context;
}
protected abstract bool ShouldRetry(PipelineCallContext context, int attempted, out TimeSpan delay);
public abstract Task ProcessAsync(PipelineCallContext context, ReadOnlyMemory <PipelinePolicy> pipeline);
public abstract Task ProcessAsync(PipelineCallContext context);
protected internal static async Task ProcessNextAsync(ReadOnlyMemory <PipelinePolicy> pipeline, PipelineCallContext context)
{
var next = pipeline.Span[0];
await next.ProcessAsync(context, pipeline.Slice(1)).ConfigureAwait(false);
}
public override async Task ProcessAsync(PipelineCallContext context, ReadOnlyMemory <PipelinePolicy> pipeline)
{
context.AddHeader(_uaHeader);
await ProcessNextAsync(pipeline, context).ConfigureAwait(false);
}
