/// <summary>
/// Attempt to re-query the credentials for the specified URI
/// </summary>
/// <param name="targetChannel">The web channel to update credentials for</param>
/// <param name="forceUpdate">True to force a requery to the user even if they previously canceled requesting credentials</param>
public static bool UpdateCredentials(WebChannel targetChannel, bool forceUpdate)
{
if (targetChannel == null)
{
throw new ArgumentNullException(nameof(targetChannel));
}
return(UpdateCredentials(GetEntryUri(targetChannel), Guid.Empty, forceUpdate));
}
internal HubConnectionStatus(ServerConfiguration configuration, WebChannel channel, HubRepository repository, bool isValid, HubStatus status, string message)
{
Configuration = configuration;
Channel = channel;
Repository = repository;
Status = status;
Message = message;
IsValid = isValid;
}
/// <summary>
/// Perform a logout on the supplied channel
/// </summary>
/// <param name="channel"></param>
/// <param name="client"></param>
#pragma warning disable 1998
async Task IWebAuthenticationProvider.Logout(WebChannel channel, HttpClient client)
#pragma warning restore 1998
{
//we have to always use a lock when handling the access token.
lock (m_Lock)
{
m_AccessToken = null;
System.Threading.Monitor.PulseAll(m_Lock);
}
}
/// <summary>
/// Perform a login on the supplied channel
/// </summary>
/// <param name="channel"></param>
/// <param name="client"></param>
async Task IWebAuthenticationProvider.Login(WebChannel channel, HttpClient client)
{
//we need to get the access token for our repository id
string requestUrl = string.Format("Repositories/{0}/AccessToken.bin", RepositoryId);
var accessToken = await client.GetStringAsync(requestUrl).ConfigureAwait(false);
lock (m_Lock)
{
//and here we WOULD decrypt the access token if it was encrypted
m_AccessToken = accessToken;
System.Threading.Monitor.PulseAll(m_Lock);
}
}
/// <summary>
/// Create a web channel to the specified server configuration. Low level primitive that does no redirection.
/// </summary>
private static WebChannel CreateChannel(ServerConfiguration configuration)
{
WebChannel channel;
if (configuration.UseGibraltarService)
{
channel = new WebChannel(Logger, true, SdsServerName, String.Format(SdsEntryPath, configuration.CustomerName), ClientProtocolVersion);
}
else
{
//we need to create the right application base directory to get into Hub.
string entryPath = EffectiveApplicationBaseDirectory(configuration.ApplicationBaseDirectory, configuration.Repository);
//and now we can actually create the channel! Yay!
channel = new WebChannel(Logger, configuration.UseSsl, configuration.Server, configuration.Port, entryPath, ClientProtocolVersion);
}
return(channel);
}
/// <summary>
/// Perform per-request authentication processing.
/// </summary>
/// <param name="channel">The channel object</param>
/// <param name="client">The web client that is about to be used to execute the request. It can't be used by the authentication provider to make requests.</param>
/// <param name="request">The request that is about to be sent</param>
/// <param name="resourceUrl">The resource URL (with query string) specified by the client.</param>
/// <param name="requestSupportsAuthentication">Indicates if the request being processed supports authentication or not.</param>
/// <remarks>If the request doesn't support authentication, it's a best practice to not provide any authentication information.</remarks>
void IWebAuthenticationProvider.PreProcessRequest(WebChannel channel, HttpClient client, HttpRequestMessage request, string resourceUrl, bool requestSupportsAuthentication)
{
//figure out the effective relative URL.
string fullUrl = resourceUrl;
if (client.BaseAddress != null)
{
fullUrl = client.BaseAddress + resourceUrl;
}
var clientUri = new Uri(fullUrl);
//we're doing sets not adds to make sure we overwrite any existing value.
if (requestSupportsAuthentication)
{
request.Headers.TryAddWithoutValidation(AuthorizationHeader, AuthorizationPrefix + ": " + CalculateHash(clientUri.PathAndQuery));
request.Headers.Add(ClientRepositoryHeader, RepositoryId.ToString());
}
else
{
//remove our repository header.
request.Headers.Remove(ClientRepositoryHeader);
}
}
/// <summary>
/// Get credentials for the specified URL target and repository information
/// </summary>
/// <param name="targetChannel">The web channel representing the endpoint that the credentials are for</param>
/// <param name="useApiKey">True if an API key was used to originally set up the connection</param>
/// <param name="repositoryId">The owner Id to specify to the server (for example repository Id)</param>
/// <param name="keyContainerName">The name of the key container to retrieve the private key from</param>
/// <param name="useMachineStore">True to use the machine store instead of the user store for the digital certificate</param>
/// <returns></returns>
/// <remarks>If existing credentials are available they will be provided, otherwise null will be returned.
/// This method is Multithread safe.</remarks>
public static IWebAuthenticationProvider GetCachedCredentials(WebChannel targetChannel, bool useApiKey, Guid repositoryId, string keyContainerName, bool useMachineStore)
{
return(GetCachedCredentials(GetEntryUri(targetChannel), useApiKey, repositoryId, keyContainerName, useMachineStore));
}
/// <summary>
/// Request user credentials, coordinating between multiple threads looking for the same credentials.
/// </summary>
/// <remarks>Unlike Update, this will not re-prompt the user if they previously declined to provide credentials</remarks>
public static bool RequestCredentials(WebChannel targetChannel, Guid repositoryId)
{
return(RequestCredentials(GetEntryUri(targetChannel), repositoryId));
}
/// <summary>
/// Determine the entry URI used for credential keys
/// </summary>
public static string GetEntryUri(WebChannel channel)
{
return(GetEntryUri(channel.HostName));
}
