/// <summary>
/// Prepare and send an HTTP API call to obtain a authenticate a set of credentials with the OpenStack Identity
/// Service V2.
/// </summary>
/// <param name="service">The <see cref="IIdentityService"/> instance.</param>
/// <param name="request">An <seealso cref="AuthenticationRequest"/> object containing the credentials to
/// authenticate.</param>
/// <param name="cancellationToken">The <seealso cref="CancellationToken"/> that the task will observe.</param>
/// <returns>
/// A <seealso cref="Task"/> representing the asynchronous operation. When the task completes successfully, the
/// <see cref="Task{TResult}.Result"/> property will contain an <see cref="Access"/> instance containing the
/// authentication details.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <para>If <paramref name="service"/> is <see langword="null"/>.</para>
/// </exception>
/// <exception cref="HttpWebException">
/// If an error occurs during an HTTP request as part of preparing or sending the API call.
/// </exception>
/// <seealso cref="IIdentityService.PrepareAuthenticateAsync"/>
/// <seealso href="http://developer.openstack.org/api-ref-identity-v2.html#identity-auth-v2">Tokens (Identity API v2.0 - OpenStack Complete API Reference)</seealso>
public static Task <Access> AuthenticateAsync(this IIdentityService service, AuthenticationRequest request, CancellationToken cancellationToken)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
return(TaskBlocks.Using(
() => service.PrepareAuthenticateAsync(request, cancellationToken),
task => task.Result.SendAsync(cancellationToken).Select(innerTask => innerTask.Result.Item2.Access)));
}
/// <summary>
/// Prepare and send an HTTP API call to obtain a list of API versions available at the current endpoint for a
/// service.
/// </summary>
/// <param name="service">The <see cref="IBaseIdentityService"/> instance.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> that the task will observe.</param>
/// <returns>
/// A <seealso cref="Task"/> representing the asynchronous operation. When the task completes successfully, the
/// <see cref="Task{TResult}.Result"/> property will contain the first page of results describing the API
/// versions available at the current endpoint.
/// </returns>
/// <exception cref="ArgumentNullException">
/// if <paramref name="service"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="HttpWebException">
/// If an error occurred during an HTTP request while preparing or sending the HTTP API call.
/// </exception>
/// <seealso cref="IBaseIdentityService.PrepareListApiVersionsAsync"/>
/// <seealso href="http://developer.openstack.org/api-ref-identity-v2.html#identity-v2-versions">API versions (Identity API v2.0 - OpenStack Complete API Reference)</seealso>
/// <seealso href="http://developer.openstack.org/api-ref-identity-v3.html#versions-identity-v3">API versions (Identity API v3 - OpenStack Complete API Reference)</seealso>
public static Task <ReadOnlyCollectionPage <ApiVersion> > ListApiVersionsAsync(this IBaseIdentityService service, CancellationToken cancellationToken)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
return(TaskBlocks.Using(
() => service.PrepareListApiVersionsAsync(cancellationToken),
task => task.Result.SendAsync(cancellationToken).Select(innerTask => innerTask.Result.Item2)));
}
/// <summary>
/// Gets the next page in the paginated collection.
/// </summary>
/// <param name="page">A page in the collection.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> that the task will observe.</param>
/// <returns>
/// <para>A <see cref="Task"/> object representing the asynchronous operation. When the task
/// completes successfully, the <see cref="Task{TResult}.Result"/> property will contain
/// a collection containing the next page of results.</para>
/// </returns>
/// <exception cref="ArgumentNullException">If <paramref name="page"/> is <see langword="null"/>.</exception>
/// <exception cref="InvalidOperationException">If <see cref="ReadOnlyCollectionPage{T}.CanHaveNextPage"/> is
/// <see langword="false"/>.</exception>
/// <exception cref="WebException">If the HTTP request does not return successfully.</exception>
public static Task <ReadOnlyCollectionPage <T> > GetNextPageAsync <T>(this ReadOnlyCollectionPage <T> page, CancellationToken cancellationToken)
{
if (page == null)
{
throw new ArgumentNullException("page");
}
return(TaskBlocks.Using(
() => page.PrepareGetNextPageAsync(cancellationToken),
task => task.Result.SendAsync(cancellationToken).Select(innerTask => innerTask.Result.Item2)));
}
public Task <string> GetStringAsync(Uri requestUri)
{
Func <Task <HttpResponseMessage> > resource = () => GetAsync(requestUri, HttpCompletionOption.ResponseContentRead);
Func <Task <HttpResponseMessage>, Task <string> > body =
respTask => {
var resp = respTask.Result;
resp.EnsureSuccessStatusCode();
return(resp.Content.ReadAsStringAsync());
};
return(TaskBlocks.Using(resource, body));
}
/// <summary>
/// Prepare and send an HTTP API call to obtain information about a particular version of the API available at
/// the current endpoint for the service.
/// </summary>
/// <param name="service">The <see cref="IBaseIdentityService"/> instance.</param>
/// <param name="apiVersionId">The unique ID of the API version.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> that the task will observe.</param>
/// <returns>
/// A <seealso cref="Task"/> representing the asynchronous operation. When the task completes successfully, the
/// <see cref="Task{TResult}.Result"/> property will contain an <see cref="ApiVersion"/> instance describing the
/// specified version of the API.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <para>If <paramref name="service"/> is <see langword="null"/>.</para>
/// <para>-or-</para>
/// <para>If <paramref name="apiVersionId"/> is <see langword="null"/>.</para>
/// </exception>
/// <exception cref="HttpWebException">
/// If an error occurred during an HTTP request while preparing or sending the HTTP API call.
/// </exception>
/// <seealso cref="BaseIdentityServiceExtensions.GetApiVersionAsync"/>
/// <seealso href="http://developer.openstack.org/api-ref-identity-v2.html#identity-v2-versions">API versions (Identity API v2.0 - OpenStack Complete API Reference)</seealso>
/// <seealso href="http://developer.openstack.org/api-ref-identity-v3.html#versions-identity-v3">API versions (Identity API v3 - OpenStack Complete API Reference)</seealso>
public static Task <ApiVersion> GetApiVersionAsync(this IBaseIdentityService service, ApiVersionId apiVersionId, CancellationToken cancellationToken)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
if (apiVersionId == null)
{
throw new ArgumentNullException("apiVersionId");
}
return(TaskBlocks.Using(
() => service.PrepareGetApiVersionAsync(apiVersionId, cancellationToken),
task => task.Result.SendAsync(cancellationToken).Select(innerTask => innerTask.Result.Item2.Version)));
}
/// <summary>
/// Prepare and send an HTTP API call to obtain details for a specific extension available for the current
/// OpenStack Identity Service V2 endpoint.
/// </summary>
/// <param name="service">The <see cref="IIdentityService"/> instance.</param>
/// <param name="alias">The unique alias identifying the extension.</param>
/// <param name="cancellationToken">The <seealso cref="CancellationToken"/> that the task will observe.</param>
/// <returns>
/// A <seealso cref="Task"/> representing the asynchronous operation. When the task completes successfully, the
/// <see cref="Task{TResult}.Result"/> property will contain an <see cref="Extension"/> instance describing the
/// extension.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <para>If <paramref name="service"/> is <see langword="null"/>.</para>
/// <para>-or-</para>
/// <para>If <paramref name="alias"/> is <see langword="null"/>.</para>
/// </exception>
/// <exception cref="HttpWebException">
/// If an error occurs during an HTTP request as part of preparing or sending the API call.
/// </exception>
/// <seealso cref="IIdentityService.PrepareGetExtensionAsync"/>
/// <seealso href="http://developer.openstack.org/api-ref-identity-v2.html#identity-api-extensions">Extensions (Identity API v2.0 - OpenStack Complete API Reference)</seealso>
public static Task <Extension> GetExtensionAsync(this IIdentityService service, ExtensionAlias alias, CancellationToken cancellationToken)
{
if (service == null)
{
throw new ArgumentNullException("service");
}
if (alias == null)
{
throw new ArgumentNullException("alias");
}
return(TaskBlocks.Using(
() => service.PrepareGetExtensionAsync(alias, cancellationToken),
task => task.Result.SendAsync(cancellationToken).Select(innerTask => innerTask.Result.Item2.Extension)));
}
Task <HttpResponseMessage> SendAsyncWorker(HttpRequestMessage request, HttpCompletionOption completionOption, CancellationToken cancellationToken)
{
var currentSource = this.cts;
Func <Task <CancellationTokenSource> > acquireResource = () => Task.FromResult(CancellationTokenSource.CreateLinkedTokenSource(currentSource.Token, cancellationToken));
Func <Task <CancellationTokenSource>, Task <HttpResponseMessage> > body =
resourceTask =>
{
var lcts = resourceTask.Result;
lcts.CancelAfter(timeout);
var task = base.SendAsync(request, lcts.Token);
if (task == null)
{
throw new InvalidOperationException("Handler failed to return a value");
}
return(task.Then(
responseTask =>
{
var response = responseTask.Result;
if (response == null)
{
throw new InvalidOperationException("Handler failed to return a response");
}
//
// Read the content when default HttpCompletionOption.ResponseContentRead is set
//
if (response.Content != null && (completionOption & HttpCompletionOption.ResponseHeadersRead) == 0)
{
return response.Content.LoadIntoBufferAsync(MaxResponseContentBufferSize)
.Select(_ => response);
}
return Task.FromResult(response);
})
.Finally(_ => GC.KeepAlive(currentSource)));
};
return(TaskBlocks.Using(acquireResource, body));
}
#pragma warning restore 1998
#region UsingAsyncBuildingBlock
public Task Using(StringBuilder builder)
{
return(TaskBlocks.Using(
() => AcquireResourceAsync(builder),
task => task.Result.WriteAsync(SampleText)));
}
protected internal override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (disposed != 0)
{
throw new ObjectDisposedException(GetType().ToString());
}
Interlocked.Exchange(ref sentRequest, 1);
wrequest = CreateWebRequest(request);
Task intermediate;
if (request.Content != null)
{
AddContentHeaders(wrequest, request.Content.Headers);
intermediate = wrequest.GetRequestStreamAsync()
.Then(streamTask => request.Content.CopyToAsync(streamTask.Result).Finally(_ => streamTask.Result.Dispose()));
}
else if (HttpMethod.Post.Equals(request.Method) || HttpMethod.Put.Equals(request.Method) || HttpMethod.Delete.Equals(request.Method))
{
// Explicitly set this to make sure we're sending a "Content-Length: 0" header.
// This fixes the issue that's been reported on the forums:
// http://forums.xamarin.com/discussion/17770/length-required-error-in-http-post-since-latest-release
wrequest.ContentLength = 0;
intermediate = Task.FromResult(default(VoidResult));
}
else
{
intermediate = Task.FromResult(default(VoidResult));
}
HttpWebResponse wresponse = null;
Func <Task <IDisposable> > resource =
() => Task.FromResult <IDisposable>(cancellationToken.Register(l => ((HttpWebRequest)l).Abort(), wrequest));
Func <Task <IDisposable>, Task> body =
_ =>
{
return(wrequest.GetResponseAsync().Select(task => wresponse = (HttpWebResponse)task.Result)
.Catch <WebException>(
(task, we) =>
{
if (we.Status == WebExceptionStatus.ProtocolError)
{
// HttpClient shouldn't throw exceptions for these errors
wresponse = (HttpWebResponse)we.Response;
}
else if (we.Status != WebExceptionStatus.RequestCanceled)
{
// propagate the antecedent
return task;
}
return Task.FromResult(default(VoidResult));
})
.Then(
task =>
{
if (cancellationToken.IsCancellationRequested)
{
return Task.FromCanceled <HttpResponseMessage>(cancellationToken);
}
else
{
return Task.FromResult(default(VoidResult));
}
}));
};
return(intermediate
.Then(_ => TaskBlocks.Using(resource, body))
.Select(_ => CreateResponseMessage(wresponse, request, cancellationToken)));
}
#pragma warning restore 1998
#region UsingWithResultAsyncBuildingBlock
public Task <string> UsingWithResult()
{
return(TaskBlocks.Using(
() => AcquireResourceAsync(),
task => task.Result.ReadToEndAsync()));
}
