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;
}
}
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 <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;
}
}
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 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;
}
}
// 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 <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 override async Task ProcessAsync(PipelineCallContext context, ReadOnlyMemory <PipelinePolicy> pipeline)
{
context.AddHeader(_uaHeader);
await ProcessNextAsync(pipeline, context).ConfigureAwait(false);
}