using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Linq;
|
using System.Net.Http;
|
using System.Net.Http.Headers;
|
using System.Reflection;
|
using System.Threading;
|
using System.Threading.Tasks;
|
|
namespace OpenTap.Authentication
|
{
|
/// <summary> This class stores information about the logged in client. </summary>
|
[Browsable(false)]
|
public class AuthenticationSettings : ComponentSettings<AuthenticationSettings>
|
{
|
private string baseAddress = null;
|
|
class AuthenticationClientHandler : HttpClientHandler
|
{
|
private readonly string domain;
|
readonly bool withRetryPolicy;
|
|
static readonly TimeSpan[] waits =
|
{
|
TimeSpan.Zero,
|
TimeSpan.FromSeconds(1),
|
TimeSpan.FromSeconds(2),
|
TimeSpan.FromSeconds(5),
|
TimeSpan.FromSeconds(10),
|
};
|
|
async Task<HttpResponseMessage> SendWithRetry(HttpRequestMessage request,
|
CancellationToken cancellationToken)
|
{
|
foreach (var wait in waits)
|
{
|
await Task.Delay(wait, cancellationToken);
|
var result = await base.SendAsync(request, cancellationToken);
|
if (result.IsSuccessStatusCode == false && HttpUtils.TransientStatusCode(result.StatusCode) && wait != waits.Last())
|
continue;
|
return result;
|
}
|
|
// There is no chance of getting down here. result from SendAsync is never null.
|
throw new InvalidOperationException();
|
}
|
|
public AuthenticationClientHandler(string domain = null, bool withRetryPolicy = false)
|
{
|
this.domain = domain;
|
this.withRetryPolicy = withRetryPolicy;
|
}
|
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
|
CancellationToken cancellationToken)
|
{
|
Current.PrepareRequest(request, domain, cancellationToken);
|
if (withRetryPolicy)
|
return SendWithRetry(request, cancellationToken);
|
return base.SendAsync(request, cancellationToken);
|
}
|
}
|
|
/// <summary>
|
/// Token store containing access and refresh tokens.
|
/// These tokens are used in the HttpClients returned by <see cref="GetClient"/> to authenticate requests.
|
/// </summary>
|
public IList<TokenInfo> Tokens { get; set; } = new List<TokenInfo>();
|
|
/// <summary>
|
/// A well formed absolute URL used as as BaseAddress in HttpClients returned by <see cref="GetClient"/>.
|
/// This setting determines what relative URLs (e.g. a package repository URL) are relative to.
|
/// Can be null.
|
/// </summary>
|
[DefaultValue(null)]
|
public string BaseAddress
|
{
|
get => baseAddress; set
|
{
|
if (Uri.IsWellFormedUriString(value, UriKind.Absolute))
|
baseAddress = value;
|
else if (String.IsNullOrEmpty(value))
|
baseAddress = null;
|
else
|
throw new FormatException("BaseAddress must be a well formed absolute URI.");
|
}
|
}
|
|
void PrepareRequest(HttpRequestMessage request, string domain, CancellationToken cancellationToken)
|
{
|
TokenInfo token = null;
|
if (domain != null)
|
token = Tokens.FirstOrDefault(t => t.Domain == domain);
|
if (token == null)
|
token = Tokens.FirstOrDefault(t => t.Domain == request.RequestUri.Host);
|
if (token != null)
|
{
|
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token.AccessToken);
|
}
|
}
|
|
private static string userAgent = null;
|
|
/// <summary>
|
/// Get a HttpClient with a preconfigued BaseAddress and preconfigured authentication using a Bearer token from <see cref="Tokens"/>.
|
/// It is up to the caller of this method to control the lifetime of the HttpClient
|
/// </summary>
|
/// <param name="domain">This value is compared to <see cref="TokenInfo.Domain"/> to find the token from <see cref="Tokens"/> to use as Bearer token for requests. If unspecified, the host part of the request URI is used.</param>
|
/// <param name="withRetryPolicy">If the request should be retried in case of transient errors.</param>
|
/// <param name="baseAddress">The base address used in the returned client. A relative URL given here will be relative to <see cref="BaseAddress"/>. Default is <see cref="BaseAddress"/>.</param>
|
/// <returns>A preconfigued HttpClient object</returns>
|
public HttpClient GetClient(string domain = null, bool withRetryPolicy = false, string baseAddress = null)
|
{
|
if (Uri.IsWellFormedUriString(domain, UriKind.Absolute))
|
throw new ArgumentException("Domain should only be the host part of a URI and not a full absolute URI.", nameof(domain));
|
var client = new HttpClient(new AuthenticationClientHandler(domain, withRetryPolicy));
|
if (baseAddress != null)
|
{
|
if (Uri.IsWellFormedUriString(baseAddress, UriKind.Absolute))
|
client.BaseAddress = new Uri(baseAddress);
|
else if (Uri.IsWellFormedUriString(baseAddress, UriKind.Relative))
|
if (BaseAddress != null)
|
client.BaseAddress = new Uri(new Uri(BaseAddress), baseAddress);
|
else
|
throw new ArgumentException("Address cannot be relative when AuthenticationSettings.BaseAddress is null.", nameof(baseAddress));
|
else
|
throw new ArgumentException("Address must be a well formed URL or null.", nameof(baseAddress));
|
}
|
else if(BaseAddress != null)
|
client.BaseAddress = new Uri(BaseAddress);
|
|
if (userAgent == null)
|
{
|
userAgent = $"OpenTAP/{PluginManager.GetOpenTapAssembly().SemanticVersion}";
|
|
if (Cli.CliActionExecutor.SelectedAction is ITypeData td)
|
{
|
// We are running a CLI Action. Add it's name and version to the User-Agent header
|
var source = TypeData.GetTypeDataSource(td);
|
userAgent += $" {td.Name}/{source.Version}";
|
}
|
else
|
{
|
var asm = Assembly.GetEntryAssembly();
|
if (asm != null)
|
{
|
var assemblyData = PluginManager.GetSearcher().Assemblies.FirstOrDefault(ad => ad.Location == asm.Location);
|
if (assemblyData?.SemanticVersion is SemanticVersion ver)
|
{
|
// The process was started from an assembly that we know ablout and that has a semantic version number. Add it's name and version to the User-Agent header
|
userAgent += $" {assemblyData.Name}/{ver}";
|
}
|
}
|
}
|
}
|
var callingUseAgent = userAgent;
|
if (Assembly.GetCallingAssembly() is Assembly asm2)
|
{
|
var assemblyData = PluginManager.GetSearcher().Assemblies.FirstOrDefault(ad => ad.Location == asm2.Location);
|
if (assemblyData?.SemanticVersion is SemanticVersion ver)
|
{
|
// The process was started from an assembly that we know about and that has a semantic version number. Add it's name and version to the User-Agent header
|
callingUseAgent += $" {assemblyData.Name}/{ver}";
|
}
|
}
|
client.DefaultRequestHeaders.Add("User-Agent", callingUseAgent);
|
return client;
|
}
|
}
|
}
|
