Exception in OpenIdDict TokenCleanupBackgroundWorker with Oracle Devart Driver: Transaction isolation level RepeatableRead not supported. #6741

3 Answer(s)

• 

  0

  maliming created 2 years ago

  Support Team Fullstack Developer

  hi

  You can override these methods to use another IsolationLevel, I will make it configurable in the next version.

  Your question credit has been refunded.

  Markdown supported.

  Copy, paste, or drag & drop images and files (max 100 MB per file, 100 MB total per post)

  Save Cancel
• 

  0

  wazbek created 2 years ago

  hi @maliming

  What is the best way to override them?

  Thanks.

  Markdown supported.

  Copy, paste, or drag & drop images and files (max 100 MB per file, 100 MB total per post)

  Save Cancel
• 

  0

  maliming created 2 years ago

  Support Team Fullstack Developer

  hi

  public override void ConfigureServices(ServiceConfigurationContext context)
  {
      context.Services.AddOpenIddict()
          .AddCore(builder =>
          {
              builder
                  .AddApplicationStore<MyAbpOpenIddictApplicationStore>()
                  .AddAuthorizationStore<MyAbpOpenIddictAuthorizationStore>()
                  .AddTokenStore<MyAbpOpenIddictTokenStore>();
          });
  }
  

  
  public class MyAbpOpenIddictApplicationStore : AbpOpenIddictApplicationStore
  {
      public MyAbpOpenIddictApplicationStore(IOpenIddictApplicationRepository repository,
          IUnitOfWorkManager unitOfWorkManager, IOpenIddictTokenRepository tokenRepository, IGuidGenerator guidGenerator,
          AbpOpenIddictIdentifierConverter identifierConverter,
          IOpenIddictDbConcurrencyExceptionHandler concurrencyExceptionHandler) : base(repository, unitOfWorkManager,
          tokenRepository, guidGenerator, identifierConverter, concurrencyExceptionHandler)
      {
      }
  
      public async override ValueTask DeleteAsync(OpenIddictApplicationModel application, CancellationToken cancellationToken)
      {
          Check.NotNull(application, nameof(application));
  
          try
          {
              using (var uow = UnitOfWorkManager.Begin(requiresNew: true, isTransactional: true, isolationLevel: IsolationLevel.ReadCommitted))
              {
                  await TokenRepository.DeleteManyByApplicationIdAsync(application.Id, cancellationToken: cancellationToken);
  
                  await Repository.DeleteAsync(application.Id, cancellationToken: cancellationToken);
  
                  await uow.CompleteAsync(cancellationToken);
              }
          }
          catch (AbpDbConcurrencyException e)
          {
              Logger.LogException(e);
              await ConcurrencyExceptionHandler.HandleAsync(e);
              throw new OpenIddictExceptions.ConcurrencyException(e.Message, e.InnerException);
          }
      }
  }
  
  public class MyAbpOpenIddictAuthorizationStore : AbpOpenIddictAuthorizationStore
  {
      public MyAbpOpenIddictAuthorizationStore(IOpenIddictAuthorizationRepository repository,
          IUnitOfWorkManager unitOfWorkManager, IGuidGenerator guidGenerator,
          IOpenIddictApplicationRepository applicationRepository, IOpenIddictTokenRepository tokenRepository,
          AbpOpenIddictIdentifierConverter identifierConverter,
          IOpenIddictDbConcurrencyExceptionHandler concurrencyExceptionHandler) : base(repository, unitOfWorkManager,
          guidGenerator, applicationRepository, tokenRepository, identifierConverter, concurrencyExceptionHandler)
      {
      }
  
      public async override ValueTask DeleteAsync(OpenIddictAuthorizationModel authorization, CancellationToken cancellationToken)
      {
          Check.NotNull(authorization, nameof(authorization));
  
          try
          {
              using (var uow = UnitOfWorkManager.Begin(requiresNew: true, isTransactional: true, isolationLevel: IsolationLevel.ReadCommitted))
              {
                  await TokenRepository.DeleteManyByAuthorizationIdAsync(authorization.Id, cancellationToken: cancellationToken);
  
                  await Repository.DeleteAsync(authorization.Id, cancellationToken: cancellationToken);
  
                  await uow.CompleteAsync(cancellationToken);
              }
          }
          catch (AbpDbConcurrencyException e)
          {
              Logger.LogException(e);
              await ConcurrencyExceptionHandler.HandleAsync(e);
              throw new OpenIddictExceptions.ConcurrencyException(e.Message, e.InnerException);
          }
      }
  
      public async override ValueTask<long> PruneAsync(DateTimeOffset threshold, CancellationToken cancellationToken)
      {
          using (var uow = UnitOfWorkManager.Begin(requiresNew: true, isTransactional: true, isolationLevel: IsolationLevel.ReadCommitted))
          {
              var date = threshold.UtcDateTime;
              var count = await Repository.PruneAsync(date, cancellationToken: cancellationToken);
              await uow.CompleteAsync(cancellationToken);
              return count;
          }
      }
  
  }
  
  public class MyAbpOpenIddictTokenStore : AbpOpenIddictTokenStore
  {
      public MyAbpOpenIddictTokenStore(IOpenIddictTokenRepository repository, IUnitOfWorkManager unitOfWorkManager,
          IGuidGenerator guidGenerator, IOpenIddictApplicationRepository applicationRepository,
          IOpenIddictAuthorizationRepository authorizationRepository,
          AbpOpenIddictIdentifierConverter identifierConverter,
          IOpenIddictDbConcurrencyExceptionHandler concurrencyExceptionHandler) : base(repository, unitOfWorkManager,
          guidGenerator, applicationRepository, authorizationRepository, identifierConverter, concurrencyExceptionHandler)
      {
      }
  
      public async override ValueTask<long> PruneAsync(DateTimeOffset threshold, CancellationToken cancellationToken)
      {
          using (var uow = UnitOfWorkManager.Begin(requiresNew: true, isTransactional: true, isolationLevel: IsolationLevel.ReadCommitted))
          {
              var date = threshold.UtcDateTime;
              var count = await Repository.PruneAsync(date, cancellationToken: cancellationToken);
              await uow.CompleteAsync(cancellationToken);
              return count;
          }
      }
  }
  

  Markdown supported.

  Copy, paste, or drag & drop images and files (max 100 MB per file, 100 MB total per post)

  Save Cancel

  1