public override async Task <int> ExecuteAsync( InitCommandArguments arguments, CancellationToken cancellationToken) { using IDisposable command = Output.WriteCommand(); AccessToken?accessToken = await arguments.AuthArguments .RequestTokenAsync(Output, cancellationToken) .ConfigureAwait(false); var context = new InitCommandContext( arguments.Name.Value()?.Trim() ?? Path.GetFileName(Environment.CurrentDirectory), FileSystem.ResolvePath(arguments.Path.Value()?.Trim()), new Uri(arguments.Uri.Value !), accessToken?.Token, accessToken?.Scheme, CustomHeaderHelper.ParseHeadersArgument(arguments.CustomHeaders.Values)); if (await ExecuteInternalAsync(context, cancellationToken).ConfigureAwait(false)) { return(0); } return(1); }
public override async Task <int> ExecuteAsync( InitCommandArguments arguments, CancellationToken cancellationToken = default) { using IDisposable command = Output.WriteCommand(); AccessToken?accessToken = await arguments.AuthArguments .RequestTokenAsync(Output, cancellationToken) .ConfigureAwait(false); var context = new InitCommandContext( arguments.Schema.Value()?.Trim() ?? "schema", FileSystem.ResolvePath(arguments.Path.Value()?.Trim()), new Uri(arguments.Uri.Value !), accessToken?.Token, accessToken?.Scheme); if (await ExecuteInternalAsync(context, cancellationToken).ConfigureAwait(false)) { return(0); } return(1); }
public override async Task <int> ExecuteAsync( DownloadCommandArguments arguments, CancellationToken cancellationToken) { using IDisposable command = Output.WriteCommand(); AccessToken?accessToken = await arguments.AuthArguments .RequestTokenAsync(Output, cancellationToken) .ConfigureAwait(false); var context = new DownloadCommandContext( new Uri(arguments.Uri.Value !), FileSystem.ResolvePath(arguments.FileName.Value()?.Trim(), "schema.graphql"), accessToken?.Token, accessToken?.Scheme); FileSystem.EnsureDirectoryExists( FileSystem.GetDirectoryName(context.FileName)); return(await DownloadSchemaAsync( context, cancellationToken) .ConfigureAwait(false) ? 0 : 1); }
public virtual async Task <AccessToken> GetTokenAsync(CancellationToken cancellationToken) { if (!this.accessToken.HasValue || AccessTokenExpired) { this.accessToken = await this.tokenCredential.GetTokenAsync(new TokenRequestContext(this.scopes), cancellationToken).ConfigureAwait(false); } return(this.accessToken.Value); }
internal CommunicationUserIdentifierAndToken(CommunicationIdentity identity, CommunicationIdentityAccessToken accessToken) { if (identity == null) { throw new ArgumentNullException(nameof(identity)); } Identity = identity; InternalAccessToken = accessToken; User = new CommunicationUserIdentifier(identity.Id); _accessToken = accessToken is null ? null : new AccessToken(accessToken.Token, accessToken.ExpiresOn); }
private async ValueTask <AccessToken> RefreshCachedTokenWithRetryHelperAsync( ITrace trace) { try { Exception?lastException = null; const int totalRetryCount = 2; for (int retry = 0; retry < totalRetryCount; retry++) { if (this.cancellationToken.IsCancellationRequested) { DefaultTrace.TraceInformation( "Stop RefreshTokenWithIndefiniteRetries because cancellation is requested"); break; } using (ITrace getTokenTrace = trace.StartChild( name: nameof(this.RefreshCachedTokenWithRetryHelperAsync), component: TraceComponent.Authorization, level: Tracing.TraceLevel.Info)) { try { this.cachedAccessToken = await this.tokenCredential.GetTokenAsync( requestContext : this.tokenRequestContext, cancellationToken : default); if (!this.cachedAccessToken.HasValue) { throw new ArgumentNullException("TokenCredential.GetTokenAsync returned a null token."); } if (this.cachedAccessToken.Value.ExpiresOn < DateTimeOffset.UtcNow) { throw new ArgumentOutOfRangeException($"TokenCredential.GetTokenAsync returned a token that is already expired. Current Time:{DateTime.UtcNow:O}; Token expire time:{this.cachedAccessToken.Value.ExpiresOn:O}"); } if (!this.userDefinedBackgroundTokenCredentialRefreshInterval.HasValue) { double refreshIntervalInSeconds = (this.cachedAccessToken.Value.ExpiresOn - DateTimeOffset.UtcNow).TotalSeconds * DefaultBackgroundTokenCredentialRefreshIntervalPercentage; // Ensure the background refresh interval is a valid range. refreshIntervalInSeconds = Math.Max(refreshIntervalInSeconds, TokenCredentialCache.MinimumTimeBetweenBackgroundRefreshInterval.TotalSeconds); refreshIntervalInSeconds = Math.Min(refreshIntervalInSeconds, TokenCredentialCache.MaxBackgroundRefreshInterval.TotalSeconds); this.systemBackgroundTokenCredentialRefreshInterval = TimeSpan.FromSeconds(refreshIntervalInSeconds); } return(this.cachedAccessToken.Value); }
public override string GetAuthorizationHeader() { lock (_tokenLock) { // A new token is generated if it is the first time or the cached token is close to expiry. if (!_cachedAccessToken.HasValue || TokenHelper.IsCloseToExpiry(_cachedAccessToken.Value.ExpiresOn)) { _cachedAccessToken = _credential.GetToken( new TokenRequestContext(CommonConstants.IotHubAadTokenScopes), new CancellationToken()); } } return($"Bearer {_cachedAccessToken.Value.Token}"); }
public override async Task <int> ExecuteAsync( PublishClientCommandArguments arguments, CancellationToken cancellationToken) { using IDisposable command = Output.WriteCommand(); AccessToken?accessToken = await arguments.AuthArguments .RequestTokenAsync(Output, cancellationToken) .ConfigureAwait(false); var context = new PublishClientCommandContext( new Uri(arguments.Registry.Value !), arguments.EnvironmentName.Value !, arguments.SchemaName.Value !, arguments.ClientName.Value !, arguments.ExternalId.Value !, arguments.SearchDirectory.Value()?.Trim() ?? FileSystem.CurrentDirectory, arguments.QueryFileName.Values.Where(t => t is { }).ToList() !,
public override async Task <int> ExecuteAsync( PublishSchemaCommandArguments arguments, CancellationToken cancellationToken) { using IDisposable command = Output.WriteCommand(); AccessToken?accessToken = await arguments.AuthArguments .RequestTokenAsync(Output, cancellationToken) .ConfigureAwait(false); var context = new PublishSchemaCommandContext( new Uri(arguments.Registry.Value !), arguments.EnvironmentName.Value !, arguments.SchemaName.Value !, arguments.SchemaFileName.Value !, arguments.Tag.HasValue() ? arguments.Tag.Values .Where(t => t !is { })
// The HTTP protocol uses this method to get the bearer token for authentication. public override string GetAuthorizationHeader() { #if NET451 throw new InvalidOperationException($"TokenCredential is not supported on NET451"); #else lock (_tokenLock) { // A new token is generated if it is the first time or the cached token is close to expiry. if (!_cachedAccessToken.HasValue || TokenHelper.IsCloseToExpiry(_cachedAccessToken.Value.ExpiresOn)) { _cachedAccessToken = _credential.GetToken( new TokenRequestContext(CommonConstants.IotHubAadTokenScopes), new CancellationToken()); } } return($"{TokenType} {_cachedAccessToken.Value.Token}"); #endif }
/// <inheritdoc /> protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var now = DateTimeOffset.Now; if (_authorizedUris == null) { throw new InvalidOperationException($"The '{nameof(CustomAuthorizationMessageHandler)}' is not configured. " + $"Call '{nameof(CustomAuthorizationMessageHandler.ConfigureHandler)}' and provide a list of endpoint urls to attach the token to."); } if (_authorizedUris.Any(uri => uri.IsBaseOf(request.RequestUri !))) { if (_lastToken == null || now >= _lastToken.Expires.AddMinutes(-5)) { var tokenResult = _tokenOptions != null ? await _provider.RequestAccessToken(_tokenOptions) : await _provider.RequestAccessToken(); if (tokenResult.TryGetToken(out var token)) { _lastToken = token; _cachedHeader = new AuthenticationHeaderValue("Bearer", _lastToken.Value); } else { _lastToken = null; _cachedHeader = null; } } if (_cachedHeader != null) { // We don't try to handle 401s and retry the request with a new token automatically since that would mean we need to copy the request // headers and buffer the body and we expect that the user instead handles the 401s. (Also, we can't really handle all 401s as we might // not be able to provision a token without user interaction). request.Headers.Authorization = _cachedHeader; } } return(await base.SendAsync(request, cancellationToken)); }
public override async Task <int> ExecuteAsync( UpdateCommandArguments arguments, CancellationToken cancellationToken) { using IDisposable command = Output.WriteCommand(); AccessToken?accessToken = await arguments.AuthArguments .RequestTokenAsync(Output, cancellationToken) .ConfigureAwait(false); var context = new UpdateCommandContext( arguments.Uri.HasValue() ? new Uri(arguments.Uri.Value() !.Trim()) : null, FileSystem.ResolvePath(arguments.Path.Value()?.Trim()), accessToken?.Token, accessToken?.Scheme); return(context.Path is null ? await FindAndUpdateSchemasAsync(context, cancellationToken) .ConfigureAwait(false) : await UpdateSingleSchemaAsync(context, context.Path, cancellationToken) .ConfigureAwait(false)); }
private bool IsTokenValid(AccessToken?token) => token != null && UtcNow() < token?.ExpiresOn;
public void Login(AccessToken token) { _loginCredentials = token; _user = GetUser <User>(new ViewerQuery()); }
public void SetAuthentication(AccessToken accessToken) { this.accessToken = accessToken; }
public AccessInfo2(AccessToken?Token, AccessStatus Status) { this.Token = Token; this.Status = Status; }
public ExchangeRefreshTokenResponse(AccessToken token, bool success = false, string?message = null) : base(success, message) { AccessToken = token; }
public DisabledAccessTokenValueObject(CustomIdentityUser?customIdentityUser, AccessToken?accessToken) { CustomIdentityUser = customIdentityUser; AccessToken = accessToken; }