/// <summary> /// Gets the current active config. This value will be cached for the next call. /// If refreshConfig is true, however, we will refresh the cache. Everytime the cache is refreshed, /// a new access token will be generated for the current active config (even if there is no change /// in the current active config). /// </summary> public async static Task <ActiveUserConfig> GetActiveUserConfig( CancellationToken cancellationToken = default(CancellationToken), bool refreshConfig = false) { if (ActiveConfig != null && !refreshConfig) { // Check that finger print has not changed. string newFingerPrint = ActiveConfig.GetCurrentConfigurationFingerPrint(); if (ActiveConfig.CachedFingerPrint == newFingerPrint) { return(ActiveConfig); } } // Otherwise, we have to create a new active config. await s_lock.WaitAsync(); try { string activeConfigJson = await GCloudWrapper.GetActiveConfig(); cancellationToken.ThrowIfCancellationRequested(); ActiveConfig = new ActiveUserConfig(activeConfigJson); return(ActiveConfig); } finally { s_lock.Release(); } }
/// <summary> /// Gets the current active config. This value will be cached for the next call. /// If refreshConfig is true, however, we will refresh the cache. Everytime the cache is refreshed, /// a new access token will be generated for the current active config (even if there is no change /// in the current active config). /// </summary> public async static Task<ActiveUserConfig> GetActiveUserConfig( CancellationToken cancellationToken = default(CancellationToken), bool refreshConfig = false) { if (s_activeUserConfig != null && !refreshConfig) { // Check that finger print has not changed. string newFingerPrint = s_activeUserConfig.GetCurrentConfigurationFingerPrint(); if (s_activeUserConfig.CachedFingerPrint == newFingerPrint) { return s_activeUserConfig; } } // Otherwise, we have to create a new active config. await s_lock.WaitAsync(); try { string activeConfigJson = await GCloudWrapper.GetActiveConfig(); cancellationToken.ThrowIfCancellationRequested(); s_activeUserConfig = new ActiveUserConfig(activeConfigJson); return s_activeUserConfig; } finally { s_lock.Release(); } }
/// <summary> /// Asynchronously revokes the token by calling /// <see cref="Google.Apis.Auth.OAuth2.Flows.IAuthorizationCodeFlow.RevokeTokenAsync"/>. /// </summary> /// <param name="taskCancellationToken">Cancellation token to cancel an operation.</param> /// <returns><c>true</c> if the token was revoked successfully.</returns> public async Task <bool> RevokeTokenAsync(CancellationToken taskCancellationToken) { TokenResponse userToken = await ActiveUserConfig.GetActiveUserToken(taskCancellationToken); await flow.RevokeTokenAsync("userId", userToken.AccessToken, taskCancellationToken).ConfigureAwait(false); // We don't set the token to null, cause we want that the next request (without reauthorizing) will fail). return(true); }
/// <summary> /// Refreshes the token by calling to ActiveUserConfig.GetActiveUserToken /// </summary> public async Task <bool> RefreshTokenAsync(CancellationToken taskCancellationToken) { TokenResponse userToken = await ActiveUserConfig.GetActiveUserToken(taskCancellationToken, refresh : true); if (userToken != null && userToken.AccessToken != null) { return(true); } return(false); }
/// <summary> /// Returns a property of the configuration based on the given key. /// </summary> public async static Task <string> GetPropertyValue(string key) { string result = null; ActiveUserConfig activeConfig = await GetActiveUserConfig(); if (activeConfig != null && activeConfig.PropertiesJson.TryGetPropertyValue(key, ref result)) { return(result); } return(result); }
/// <summary> /// Gets the token that belongs to the current active config. /// This value will be normally be cached as the current active user config is normally cached. /// If refresh is true or if the current token already expired, however, we will refresh /// the active user config to get a new token. /// </summary> public async static Task <TokenResponse> GetActiveUserToken(CancellationToken cancellationToken, bool refresh = false) { ActiveUserConfig userConfig = null; if (!refresh) { userConfig = await GetActiveUserConfig(cancellationToken); if (!userConfig.UserToken.IsExpired) { return(userConfig.UserToken); } } userConfig = await GetActiveUserConfig(cancellationToken, refreshConfig : true); return(userConfig.UserToken); }
/// <summary> /// Returns the setting with the given name from the currently active gcloud configuration. /// </summary> public static string GetSettingsValue(string settingName) { try { return(ActiveUserConfig.GetPropertyValue(settingName).Result); } catch (AggregateException aggEx) { if (aggEx.InnerExceptions != null) { // Exception thrown by GCloudWrapper is InvalidOperationException. Exception invalidOpEx = aggEx.InnerExceptions.FirstOrDefault(ex => ex is InvalidOperationException); if (invalidOpEx != null) { throw invalidOpEx; } } throw aggEx; } catch (Exception ex) { throw ex; } }
public virtual async Task <string> GetAccessTokenForRequestAsync(string authUri = null, CancellationToken cancellationToken = default(CancellationToken)) { TokenResponse token = await ActiveUserConfig.GetActiveUserToken(cancellationToken); return(token.AccessToken); }