org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider クラス

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

org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider 連携図

公開メンバ関数
	LiquibaseJpaUpdaterProvider (KeycloakSession session)
void	update (Connection connection, String defaultSchema)
void	export (Connection connection, String defaultSchema, File file)
Status	validate (Connection connection, String defaultSchema)
void	close ()

静的公開メンバ関数
static String	getTable (String table, String defaultSchema)

静的公開変数類
static final String	CHANGELOG = "META-INF/jpa-changelog-master.xml"
static final String	DEPLOYMENT_ID_COLUMN = "DEPLOYMENT_ID"

限定公開メンバ関数
void	updateChangeSet (Liquibase liquibase, Connection connection, Writer exportWriter) throws LiquibaseException, SQLException
Status	validateChangeSet (Liquibase liquibase, String changelog) throws LiquibaseException

非公開メンバ関数
void	update (Connection connection, File file, String defaultSchema)
void	outputChangeLogTableCreationScript (Liquibase liquibase, final Writer exportWriter) throws DatabaseException
void	resetLiquibaseServices (Liquibase liquibase)
List< ChangeSet >	getLiquibaseUnrunChangeSets (Liquibase liquibase)
Liquibase	getLiquibaseForKeycloakUpdate (Connection connection, String defaultSchema) throws LiquibaseException
Liquibase	getLiquibaseForCustomProviderUpdate (Connection connection, String defaultSchema, String changelogLocation, ClassLoader classloader, String changelogTableName) throws LiquibaseException

非公開変数類
final KeycloakSession	session

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

詳解

著者

Stian Thorgersen

構築子と解体子

LiquibaseJpaUpdaterProvider()

org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.LiquibaseJpaUpdaterProvider ( KeycloakSession  session )

inline

                                                                {
        this.session = session;
    }

関数詳解

close()

void org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.close ( )

inline

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

                        {
    }

export()

void org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.export ( Connection  connection, String  defaultSchema, File  file  )

inline

org.keycloak.connections.jpa.updater.JpaUpdaterProviderを実装しています。

                                                                               {
        update(connection, file, defaultSchema);
    }

getLiquibaseForCustomProviderUpdate()

Liquibase org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.getLiquibaseForCustomProviderUpdate ( Connection  connection, String  defaultSchema, String  changelogLocation, ClassLoader  classloader, String  changelogTableName  ) throws LiquibaseException

inlineprivate

                                                                                                                                                                                                               {
        LiquibaseConnectionProvider liquibaseProvider = session.getProvider(LiquibaseConnectionProvider.class);
        return liquibaseProvider.getLiquibaseForCustomUpdate(connection, defaultSchema, changelogLocation, classloader, changelogTableName);
    }

getLiquibaseForKeycloakUpdate()

Liquibase org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.getLiquibaseForKeycloakUpdate ( Connection  connection, String  defaultSchema  ) throws LiquibaseException

inlineprivate

                                                                                                                           {
        LiquibaseConnectionProvider liquibaseProvider = session.getProvider(LiquibaseConnectionProvider.class);
        return liquibaseProvider.getLiquibase(connection, defaultSchema);
    }

getLiquibaseUnrunChangeSets()

List<ChangeSet> org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.getLiquibaseUnrunChangeSets ( Liquibase  liquibase )

inlineprivate

                                                                             {
        // TODO tracked as: https://issues.jboss.org/browse/KEYCLOAK-3730
        // TODO: When https://liquibase.jira.com/browse/CORE-2919 is resolved, replace the following two lines with:
        // List<ChangeSet> changeSets = liquibase.listUnrunChangeSets((Contexts) null, new LabelExpression(), false);
        Method listUnrunChangeSets = Reflections.findDeclaredMethod(Liquibase.class, "listUnrunChangeSets", Contexts.class, LabelExpression.class, boolean.class);
        return Reflections.invokeMethod(true, listUnrunChangeSets, List.class, liquibase, (Contexts) null, new LabelExpression(), false);
    }

getTable()

static String org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.getTable ( String  table, String  defaultSchema  )

inlinestatic

                                                                      {
        return defaultSchema != null ? defaultSchema + "." + table : table;
    }

outputChangeLogTableCreationScript()

void org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.outputChangeLogTableCreationScript ( Liquibase  liquibase, final Writer  exportWriter  ) throws DatabaseException

inlineprivate

                                                                                                                             {
        Database database = liquibase.getDatabase();

        Executor oldTemplate = ExecutorService.getInstance().getExecutor(database);
        LoggingExecutor executor = new LoggingExecutor(ExecutorService.getInstance().getExecutor(database), exportWriter, database);
        ExecutorService.getInstance().setExecutor(database, executor);

        executor.comment("*********************************************************************");
        executor.comment("* Keycloak database creation script - apply this script to empty DB *");
        executor.comment("*********************************************************************" + StreamUtil.getLineSeparator());

        executor.execute(new CreateDatabaseChangeLogTableStatement());
        // DatabaseChangeLogLockTable is created before this code is executed and recreated if it does not exist automatically
        // in org.keycloak.connections.jpa.updater.liquibase.lock.CustomLockService.init() called indirectly from
        // KeycloakApplication constructor (search for waitForLock() call). Hence it is not included in the creation script.

        executor.comment("*********************************************************************" + StreamUtil.getLineSeparator());

        ExecutorService.getInstance().setExecutor(database, oldTemplate);
    }

resetLiquibaseServices()

void org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.resetLiquibaseServices ( Liquibase  liquibase )

inlineprivate

                                                             {
        Method resetServices = Reflections.findDeclaredMethod(Liquibase.class, "resetServices");
        Reflections.invokeMethod(true, resetServices, liquibase);
    }

update() [1/2]

void org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.update ( Connection  connection, String  defaultSchema  )

inline

org.keycloak.connections.jpa.updater.JpaUpdaterProviderを実装しています。

                                                                    {
        update(connection, null, defaultSchema);
    }

update() [2/2]

void org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.update ( Connection  connection, File  file, String  defaultSchema  )

inlineprivate

                                                                                {
        logger.debug("Starting database update");

        // Need ThreadLocal as liquibase doesn't seem to have API to inject custom objects into tasks
        ThreadLocalSessionContext.setCurrentSession(session);

        Writer exportWriter = null;
        try {
            // Run update with keycloak master changelog first
            Liquibase liquibase = getLiquibaseForKeycloakUpdate(connection, defaultSchema);
            if (file != null) {
                exportWriter = new FileWriter(file);
            }
            updateChangeSet(liquibase, connection, exportWriter);

            // Run update for each custom JpaEntityProvider
            Set<JpaEntityProvider> jpaProviders = session.getAllProviders(JpaEntityProvider.class);
            for (JpaEntityProvider jpaProvider : jpaProviders) {
                String customChangelog = jpaProvider.getChangelogLocation();
                if (customChangelog != null) {
                    String factoryId = jpaProvider.getFactoryId();
                    String changelogTableName = JpaUtils.getCustomChangelogTableName(factoryId);
                    liquibase = getLiquibaseForCustomProviderUpdate(connection, defaultSchema, customChangelog, jpaProvider.getClass().getClassLoader(), changelogTableName);
                    updateChangeSet(liquibase, connection, exportWriter);
                }
            }
        } catch (LiquibaseException | IOException | SQLException e) {
            throw new RuntimeException("Failed to update database", e);
        } finally {
            ThreadLocalSessionContext.removeCurrentSession();
            if (exportWriter != null) {
                try {
                    exportWriter.close();
                } catch (IOException ioe) {
                    // ignore
                }
            }
        }
    }

updateChangeSet()

void org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.updateChangeSet ( Liquibase  liquibase, Connection  connection, Writer  exportWriter  ) throws LiquibaseException, SQLException

inlineprotected

                                                                                                                                            {
        String changelog = liquibase.getChangeLogFile();
        Database database = liquibase.getDatabase();
        Table changelogTable = SnapshotGeneratorFactory.getInstance().getDatabaseChangeLogTable(new SnapshotControl(database, false, Table.class, Column.class), database);

        if (changelogTable != null) {
            boolean hasDeploymentIdColumn = changelogTable.getColumn(DEPLOYMENT_ID_COLUMN) != null;

            // create DEPLOYMENT_ID column if it doesn't exist
            if (!hasDeploymentIdColumn) {
                ChangeLogHistoryService changelogHistoryService = ChangeLogHistoryServiceFactory.getInstance().getChangeLogService(database);
                changelogHistoryService.generateDeploymentId();
                String deploymentId = changelogHistoryService.getDeploymentId();

                logger.debugv("Adding missing column {0}={1} to {2} table", DEPLOYMENT_ID_COLUMN, deploymentId,changelogTable.getName());

                List<SqlStatement> statementsToExecute = new ArrayList<>();
                statementsToExecute.add(new AddColumnStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(),
                        changelogTable.getName(), DEPLOYMENT_ID_COLUMN, "VARCHAR(10)", null));
                statementsToExecute.add(new UpdateStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), changelogTable.getName())
                        .addNewColumnValue(DEPLOYMENT_ID_COLUMN, deploymentId));
                statementsToExecute.add(new SetNullableStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(),
                        changelogTable.getName(), DEPLOYMENT_ID_COLUMN, "VARCHAR(10)", false));

                ExecutorService executorService = ExecutorService.getInstance();
                Executor executor = executorService.getExecutor(liquibase.getDatabase());

                for (SqlStatement sql : statementsToExecute) {
                    executor.execute(sql);
                    database.commit();
                }
            }
        }

        List<ChangeSet> changeSets = getLiquibaseUnrunChangeSets(liquibase);
        if (!changeSets.isEmpty()) {
            List<RanChangeSet> ranChangeSets = liquibase.getDatabase().getRanChangeSetList();
            if (ranChangeSets.isEmpty()) {
                logger.infov("Initializing database schema. Using changelog {0}", changelog);
            } else {
                if (logger.isDebugEnabled()) {
                    logger.debugv("Updating database from {0} to {1}. Using changelog {2}", ranChangeSets.get(ranChangeSets.size() - 1).getId(), changeSets.get(changeSets.size() - 1).getId(), changelog);
                } else {
                    logger.infov("Updating database. Using changelog {0}", changelog);
                }
            }

            if (exportWriter != null) {
                if (ranChangeSets.isEmpty()) {
                    outputChangeLogTableCreationScript(liquibase, exportWriter);
                }
                liquibase.update((Contexts) null, new LabelExpression(), exportWriter, false);
            } else {
                liquibase.update((Contexts) null);
            }

            logger.debugv("Completed database update for changelog {0}", changelog);
        } else {
            logger.debugv("Database is up to date for changelog {0}", changelog);
        }

        // Needs to restart liquibase services to clear ChangeLogHistoryServiceFactory.getInstance().
        // See https://issues.jboss.org/browse/KEYCLOAK-3769 for discussion relevant to why reset needs to be here
        resetLiquibaseServices(liquibase);
    }

validate()

Status org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.validate ( Connection  connection, String  defaultSchema  )

inline

org.keycloak.connections.jpa.updater.JpaUpdaterProviderを実装しています。

                                                                        {
        logger.debug("Validating if database is updated");
        ThreadLocalSessionContext.setCurrentSession(session);

        try {
            // Validate with keycloak master changelog first
            Liquibase liquibase = getLiquibaseForKeycloakUpdate(connection, defaultSchema);

            Status status = validateChangeSet(liquibase, liquibase.getChangeLogFile());
            if (status != Status.VALID) {
                return status;
            }

            // Validate each custom JpaEntityProvider
            Set<JpaEntityProvider> jpaProviders = session.getAllProviders(JpaEntityProvider.class);
            for (JpaEntityProvider jpaProvider : jpaProviders) {
                String customChangelog = jpaProvider.getChangelogLocation();
                if (customChangelog != null) {
                    String factoryId = jpaProvider.getFactoryId();
                    String changelogTableName = JpaUtils.getCustomChangelogTableName(factoryId);
                    liquibase = getLiquibaseForCustomProviderUpdate(connection, defaultSchema, customChangelog, jpaProvider.getClass().getClassLoader(), changelogTableName);
                    if (validateChangeSet(liquibase, liquibase.getChangeLogFile()) != Status.VALID) {
                        return Status.OUTDATED;
                    }
                }
            }
        } catch (LiquibaseException e) {
            throw new RuntimeException("Failed to validate database", e);
        }

        return Status.VALID;
    }

validateChangeSet()

Status org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.validateChangeSet ( Liquibase  liquibase, String  changelog  ) throws LiquibaseException

inlineprotected

                                                                                                        {
        final Status result;
        List<ChangeSet> changeSets = getLiquibaseUnrunChangeSets(liquibase);

        if (!changeSets.isEmpty()) {
            if (changeSets.size() == liquibase.getDatabaseChangeLog().getChangeSets().size()) {
                result = Status.EMPTY;
            } else {
                logger.debugf("Validation failed. Database is not up-to-date for changelog %s", changelog);
                result = Status.OUTDATED;
            }
        } else {
            logger.debugf("Validation passed. Database is up-to-date for changelog %s", changelog);
            result = Status.VALID;
        }

        // Needs to restart liquibase services to clear ChangeLogHistoryServiceFactory.getInstance().
        // See https://issues.jboss.org/browse/KEYCLOAK-3769 for discussion relevant to why reset needs to be here
        resetLiquibaseServices(liquibase);

        return result;
    }

メンバ詳解

CHANGELOG

final String org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.CHANGELOG = "META-INF/jpa-changelog-master.xml"

static

DEPLOYMENT_ID_COLUMN

final String org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.DEPLOYMENT_ID_COLUMN = "DEPLOYMENT_ID"

static

logger

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

staticprivate

session

final KeycloakSession org.keycloak.connections.jpa.updater.liquibase.LiquibaseJpaUpdaterProvider.session

private

---

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

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