org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider クラス

org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider の継承関係図

org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider 連携図

公開メンバ関数
	LiquibaseDBLockProvider (LiquibaseDBLockProviderFactory factory, KeycloakSession session)
void	waitForLock ()
void	releaseLock ()
boolean	hasLock ()
boolean	supportsForcedUnlock ()
void	destroyLockInfo ()
void	close ()

非公開メンバ関数
void	lazyInit ()
void	restart ()
void	safeRollbackConnection ()
void	safeCloseConnection ()

非公開変数類
int	DEFAULT_MAX_ATTEMPTS = 3
final LiquibaseDBLockProviderFactory	factory
final KeycloakSession	session
CustomLockService	lockService
Connection	dbConnection
boolean	initialized = false
int	maxAttempts = DEFAULT_MAX_ATTEMPTS

静的非公開変数類
static final Logger	logger = Logger.getLogger(LiquibaseDBLockProvider.class)

詳解

著者

Marek Posolda

構築子と解体子

LiquibaseDBLockProvider()

org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.LiquibaseDBLockProvider ( LiquibaseDBLockProviderFactory  factory, KeycloakSession  session  )

inline

                                                                                                    {
        this.factory = factory;
        this.session = session;
    }

関数詳解

close()

void org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.close ( )

inline

org.keycloak.provider.Providerを実装しています。

                        {
        KeycloakModelUtils.suspendJtaTransaction(session.getKeycloakSessionFactory(), () -> {
            safeCloseConnection();
        });
    }

destroyLockInfo()

void org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.destroyLockInfo ( )

inline

org.keycloak.models.dblock.DBLockProviderを実装しています。

                                  {
        KeycloakModelUtils.suspendJtaTransaction(session.getKeycloakSessionFactory(), () -> {
            lazyInit();

            try {
                this.lockService.destroy();
                dbConnection.commit();
                logger.debug("Destroyed lock table");
            } catch (DatabaseException | SQLException de) {
                logger.error("Failed to destroy lock table");
                safeRollbackConnection();
            }
        });
    }

hasLock()

boolean org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.hasLock ( )

inline

org.keycloak.models.dblock.DBLockProviderを実装しています。

                             {
        return factory.hasLock();
    }

lazyInit()

void org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.lazyInit ( )

inlineprivate

                            {
        if (!initialized) {
            LiquibaseConnectionProvider liquibaseProvider = session.getProvider(LiquibaseConnectionProvider.class);
            JpaConnectionProviderFactory jpaProviderFactory = (JpaConnectionProviderFactory) session.getKeycloakSessionFactory().getProviderFactory(JpaConnectionProvider.class);

            this.dbConnection = jpaProviderFactory.getConnection();
            String defaultSchema = jpaProviderFactory.getSchema();

            try {
                Liquibase liquibase = liquibaseProvider.getLiquibase(dbConnection, defaultSchema);

                this.lockService = new CustomLockService();
                lockService.setChangeLogLockWaitTime(factory.getLockWaitTimeoutMillis());
                lockService.setDatabase(liquibase.getDatabase());
                initialized = true;
            } catch (LiquibaseException exception) {
                safeRollbackConnection();
                safeCloseConnection();
                throw new IllegalStateException(exception);
            }
        }
    }

releaseLock()

void org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.releaseLock ( )

inline

org.keycloak.models.dblock.DBLockProviderを実装しています。

                              {
        KeycloakModelUtils.suspendJtaTransaction(session.getKeycloakSessionFactory(), () -> {
            lazyInit();

            lockService.releaseLock();
            lockService.reset();
            factory.setHasLock(false);
        });
    }

restart()

void org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.restart ( )

inlineprivate

                           {
        safeCloseConnection();
        this.dbConnection = null;
        this.lockService = null;
        initialized = false;
        lazyInit();
    }

safeCloseConnection()

void org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.safeCloseConnection ( )

inlineprivate

                                       {
        // Close to prevent in-mem databases from closing
        if (dbConnection != null) {
            try {
                dbConnection.close();
            } catch (SQLException e) {
                logger.warn("Failed to close connection", e);
            }
        }
    }

safeRollbackConnection()

void org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.safeRollbackConnection ( )

inlineprivate

                                          {
        if (dbConnection != null) {
            try {
                this.dbConnection.rollback();
            } catch (SQLException se) {
                logger.warn("Failed to rollback connection after error", se);
            }
        }
    }

supportsForcedUnlock()

boolean org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.supportsForcedUnlock ( )

inline

org.keycloak.models.dblock.DBLockProviderを実装しています。

                                          {
        // Implementation based on "SELECT FOR UPDATE" can't force unlock as it's locked by other transaction
        return false;
    }

waitForLock()

void org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.waitForLock ( )

inline

org.keycloak.models.dblock.DBLockProviderを実装しています。

                              {
        KeycloakModelUtils.suspendJtaTransaction(session.getKeycloakSessionFactory(), () -> {

            lazyInit();

            while (maxAttempts > 0) {
                try {
                    lockService.waitForLock();
                    factory.setHasLock(true);
                    this.maxAttempts = DEFAULT_MAX_ATTEMPTS;
                    return;
                } catch (LockRetryException le) {
                    // Indicates we should try to acquire lock again in different transaction
                    safeRollbackConnection();
                    restart();
                    maxAttempts--;
                } catch (RuntimeException re) {
                    safeRollbackConnection();
                    safeCloseConnection();
                    throw re;
                }
            }
        });

    }

メンバ詳解

dbConnection

Connection org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.dbConnection

private

DEFAULT_MAX_ATTEMPTS

int org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.DEFAULT_MAX_ATTEMPTS = 3

private

factory

final LiquibaseDBLockProviderFactory org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.factory

private

initialized

boolean org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.initialized = false

private

lockService

CustomLockService org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.lockService

private

logger

final Logger org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.logger = Logger.getLogger(LiquibaseDBLockProvider.class)

staticprivate

maxAttempts

int org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.maxAttempts = DEFAULT_MAX_ATTEMPTS

private

session

final KeycloakSession org.keycloak.connections.jpa.updater.liquibase.lock.LiquibaseDBLockProvider.session

private

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/doxygen/keycloak/src/keycloak/src/main/java/org/keycloak/connections/jpa/updater/liquibase/lock/LiquibaseDBLockProvider.java