org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory クラス

org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory の継承関係図

org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory 連携図

クラス
enum	MigrationStrategy

公開メンバ関数
JpaConnectionProvider	create (KeycloakSession session)
void	close ()
String	getId ()
void	init (Config.Scope config)
void	postInit (KeycloakSessionFactory factory)
void	migration (MigrationStrategy strategy, boolean initializeEmpty, String schema, File databaseUpdateFile, Connection connection, KeycloakSession session)
Connection	getConnection ()
String	getSchema ()
Map< String, String >	getOperationalInfo ()
default int	order ()

限定公開メンバ関数
void	checkJtaEnabled (KeycloakSessionFactory factory)
void	prepareOperationalInfo (Connection connection)
String	detectDialect (Connection connection)
void	startGlobalStats (KeycloakSession session, int globalStatsIntervalSecs)
void	update (Connection connection, String schema, KeycloakSession session, JpaUpdaterProvider updater)
void	export (Connection connection, String schema, File databaseUpdateFile, KeycloakSession session, JpaUpdaterProvider updater)

非公開メンバ関数
void	lazyInit (KeycloakSession session)
File	getDatabaseUpdateFile ()
MigrationStrategy	getMigrationStrategy ()

非公開変数類
volatile EntityManagerFactory	emf
Config.Scope	config
Map< String, String >	operationalInfo
boolean	jtaEnabled
JtaTransactionManagerLookup	jtaLookup
KeycloakSessionFactory	factory

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

詳解

著者

Stian Thorgersen

---

クラス詳解

org::keycloak::connections::jpa::DefaultJpaConnectionProviderFactory::MigrationStrategy

enum org::keycloak::connections::jpa::DefaultJpaConnectionProviderFactory::MigrationStrategy

org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.MigrationStrategy 連携図

列挙値
MANUAL
UPDATE
VALIDATE

関数詳解

checkJtaEnabled()

void org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.checkJtaEnabled ( KeycloakSessionFactory  factory )

inlineprotected

                                                                   {
        jtaLookup = (JtaTransactionManagerLookup) factory.getProviderFactory(JtaTransactionManagerLookup.class);
        if (jtaLookup != null) {
            if (jtaLookup.getTransactionManager() != null) {
                jtaEnabled = true;
            }
        }
    }

close()

void org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.close ( )

inline

org.keycloak.provider.ProviderFactory< T extends Provider >を実装しています。

                        {
        if (emf != null) {
            emf.close();
        }
    }

create()

JpaConnectionProvider org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.create ( KeycloakSession  session )

inline

org.keycloak.provider.ProviderFactory< T extends Provider >を実装しています。

                                                                 {
        logger.trace("Create JpaConnectionProvider");
        lazyInit(session);

        EntityManager em = null;
        if (!jtaEnabled) {
            logger.trace("enlisting EntityManager in JpaKeycloakTransaction");
            em = emf.createEntityManager();
        } else {

            em = emf.createEntityManager(SynchronizationType.SYNCHRONIZED);
        }
        em = PersistenceExceptionConverter.create(em);
        if (!jtaEnabled) session.getTransactionManager().enlist(new JpaKeycloakTransaction(em));
        return new DefaultJpaConnectionProvider(em);
    }

detectDialect()

String org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.detectDialect ( Connection  connection )

inlineprotected

                                                          {
        String driverDialect = config.get("driverDialect");
        if (driverDialect != null && driverDialect.length() > 0) {
            return driverDialect;
        } else {
            try {
                String dbProductName = connection.getMetaData().getDatabaseProductName();
                String dbProductVersion = connection.getMetaData().getDatabaseProductVersion();

                // For MSSQL2014, we may need to fix the autodetected dialect by hibernate
                if (dbProductName.equals("Microsoft SQL Server")) {
                    String topVersionStr = dbProductVersion.split("\\.")[0];
                    boolean shouldSet2012Dialect = true;
                    try {
                        int topVersion = Integer.parseInt(topVersionStr);
                        if (topVersion < 12) {
                            shouldSet2012Dialect = false;
                        }
                    } catch (NumberFormatException nfe) {
                    }
                    if (shouldSet2012Dialect) {
                        String sql2012Dialect = "org.hibernate.dialect.SQLServer2012Dialect";
                        logger.debugf("Manually override hibernate dialect to %s", sql2012Dialect);
                        return sql2012Dialect;
                    }
                }
            } catch (SQLException e) {
                logger.warnf("Unable to detect hibernate dialect due database exception : %s", e.getMessage());
            }

            return null;
        }
    }

export()

void org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.export ( Connection  connection, String  schema, File  databaseUpdateFile, KeycloakSession  session, JpaUpdaterProvider  updater  )

inlineprotected

                                                                                                                                              {
        DBLockProvider dbLock = new DBLockManager(session).getDBLock();
        if (dbLock.hasLock()) {
            updater.export(connection, schema, databaseUpdateFile);
        } else {
            KeycloakModelUtils.runJobInTransaction(session.getKeycloakSessionFactory(), new KeycloakSessionTask() {
                @Override
                public void run(KeycloakSession lockSession) {
                    DBLockManager dbLockManager = new DBLockManager(lockSession);
                    DBLockProvider dbLock2 = dbLockManager.getDBLock();
                    dbLock2.waitForLock();
                    try {
                        updater.export(connection, schema, databaseUpdateFile);
                    } finally {
                        dbLock2.releaseLock();
                    }
                }
            });
        }
    }

getConnection()

Connection org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.getConnection ( )

inline

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

                                      {
        try {
            String dataSourceLookup = config.get("dataSource");
            if (dataSourceLookup != null) {
                DataSource dataSource = (DataSource) new InitialContext().lookup(dataSourceLookup);
                return dataSource.getConnection();
            } else {
                Class.forName(config.get("driver"));
                return DriverManager.getConnection(config.get("url"), config.get("user"), config.get("password"));
            }
        } catch (Exception e) {
            throw new RuntimeException("Failed to connect to database", e);
        }
    }

getDatabaseUpdateFile()

File org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.getDatabaseUpdateFile ( )

inlineprivate

                                         {
        String databaseUpdateFile = config.get("migrationExport", "keycloak-database-update.sql");
        return new File(databaseUpdateFile);
    }

getId()

String org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.getId ( )

inline

org.keycloak.provider.ProviderFactory< T extends Provider >を実装しています。

                          {
        return "default";
    }

getMigrationStrategy()

MigrationStrategy org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.getMigrationStrategy ( )

inlineprivate

                                                     {
        String migrationStrategy = config.get("migrationStrategy");
        if (migrationStrategy == null) {
            // Support 'databaseSchema' for backwards compatibility
            migrationStrategy = config.get("databaseSchema");
        }

        if (migrationStrategy != null) {
            return MigrationStrategy.valueOf(migrationStrategy.toUpperCase());
        } else {
            return MigrationStrategy.UPDATE;
        }
    }

getOperationalInfo()

Map<String, String> org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.getOperationalInfo ( )

inline

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

                                                    {
        return operationalInfo;
    }

getSchema()

String org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.getSchema ( )

inline

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

                              {
        return config.get("schema");
    }

init()

void org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.init ( Config.Scope  config )

inline

org.keycloak.provider.ProviderFactory< T extends Provider >を実装しています。

                                          {
        this.config = config;
    }

lazyInit()

void org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.lazyInit ( KeycloakSession  session )

inlineprivate

                                                   {
        if (emf == null) {
            synchronized (this) {
                if (emf == null) {
                    KeycloakModelUtils.suspendJtaTransaction(session.getKeycloakSessionFactory(), () -> {
                        logger.debug("Initializing JPA connections");

                        Map<String, Object> properties = new HashMap<String, Object>();

                        String unitName = "keycloak-default";

                        String dataSource = config.get("dataSource");
                        if (dataSource != null) {
                            if (config.getBoolean("jta", jtaEnabled)) {
                                properties.put(AvailableSettings.JTA_DATASOURCE, dataSource);
                            } else {
                                properties.put(AvailableSettings.NON_JTA_DATASOURCE, dataSource);
                            }
                        } else {
                            properties.put(AvailableSettings.JDBC_URL, config.get("url"));
                            properties.put(AvailableSettings.JDBC_DRIVER, config.get("driver"));

                            String user = config.get("user");
                            if (user != null) {
                                properties.put(AvailableSettings.JDBC_USER, user);
                            }
                            String password = config.get("password");
                            if (password != null) {
                                properties.put(AvailableSettings.JDBC_PASSWORD, password);
                            }
                        }

                        String schema = getSchema();
                        if (schema != null) {
                            properties.put(JpaUtils.HIBERNATE_DEFAULT_SCHEMA, schema);
                        }

                        MigrationStrategy migrationStrategy = getMigrationStrategy();
                        boolean initializeEmpty = config.getBoolean("initializeEmpty", true);
                        File databaseUpdateFile = getDatabaseUpdateFile();

                        properties.put("hibernate.show_sql", config.getBoolean("showSql", false));
                        properties.put("hibernate.format_sql", config.getBoolean("formatSql", true));

                        Connection connection = getConnection();
                        try {
                            prepareOperationalInfo(connection);

                            String driverDialect = detectDialect(connection);
                            if (driverDialect != null) {
                                properties.put("hibernate.dialect", driverDialect);
                            }

                            migration(migrationStrategy, initializeEmpty, schema, databaseUpdateFile, connection, session);

                            int globalStatsInterval = config.getInt("globalStatsInterval", -1);
                            if (globalStatsInterval != -1) {
                                properties.put("hibernate.generate_statistics", true);
                            }

                            logger.trace("Creating EntityManagerFactory");
                            logger.tracev("***** create EMF jtaEnabled {0} ", jtaEnabled);
                            if (jtaEnabled) {
                                properties.put(org.hibernate.cfg.AvailableSettings.JTA_PLATFORM, new AbstractJtaPlatform() {
                                    @Override
                                    protected TransactionManager locateTransactionManager() {
                                        return jtaLookup.getTransactionManager();
                                    }

                                    @Override
                                    protected UserTransaction locateUserTransaction() {
                                        return null;
                                    }
                                });
                            }
                            emf = JpaUtils.createEntityManagerFactory(session, unitName, properties, getClass().getClassLoader(), jtaEnabled);
                            logger.trace("EntityManagerFactory created");

                            if (globalStatsInterval != -1) {
                                startGlobalStats(session, globalStatsInterval);
                            }
                        } finally {
                            // Close after creating EntityManagerFactory to prevent in-mem databases from closing
                            if (connection != null) {
                                try {
                                    connection.close();
                                } catch (SQLException e) {
                                    logger.warn("Can't close connection", e);
                                }
                            }
                        }
                    });
                }
            }
        }
    }

migration()

void org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.migration ( MigrationStrategy  strategy, boolean  initializeEmpty, String  schema, File  databaseUpdateFile, Connection  connection, KeycloakSession  session  )

inline

                                                                                                                                                                       {
        JpaUpdaterProvider updater = session.getProvider(JpaUpdaterProvider.class);

        JpaUpdaterProvider.Status status = updater.validate(connection, schema);
        if (status == JpaUpdaterProvider.Status.VALID) {
            logger.debug("Database is up-to-date");
        } else if (status == JpaUpdaterProvider.Status.EMPTY) {
            if (initializeEmpty) {
                update(connection, schema, session, updater);
            } else {
                switch (strategy) {
                    case UPDATE:
                        update(connection, schema, session, updater);
                        break;
                    case MANUAL:
                        export(connection, schema, databaseUpdateFile, session, updater);
                        throw new ServerStartupError("Database not initialized, please initialize database with " + databaseUpdateFile.getAbsolutePath(), false);
                    case VALIDATE:
                        throw new ServerStartupError("Database not initialized, please enable database initialization", false);
                }
            }
        } else {
            switch (strategy) {
                case UPDATE:
                    update(connection, schema, session, updater);
                    break;
                case MANUAL:
                    export(connection, schema, databaseUpdateFile, session, updater);
                    throw new ServerStartupError("Database not up-to-date, please migrate database with " + databaseUpdateFile.getAbsolutePath(), false);
                case VALIDATE:
                    throw new ServerStartupError("Database not up-to-date, please enable database migration", false);
            }
        }
    }

order()

default int org.keycloak.provider.ProviderFactory< T extends Provider >.order ( )

inlineinherited

org.keycloak.protocol.docker.DockerAuthV2ProtocolFactory, org.keycloak.urls.HostnameProviderFactory, org.keycloak.protocol.oidc.ext.OIDCExtProviderFactoryで実装されています。

                        {
        return 0;
    }

postInit()

void org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.postInit ( KeycloakSessionFactory  factory )

inline

org.keycloak.provider.ProviderFactory< T extends Provider >を実装しています。

                                                         {
        this.factory = factory;
        checkJtaEnabled(factory);

    }

prepareOperationalInfo()

void org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.prepareOperationalInfo ( Connection  connection )

inlineprotected

                                                                 {
        try {
            operationalInfo = new LinkedHashMap<>();
            DatabaseMetaData md = connection.getMetaData();
            operationalInfo.put("databaseUrl", md.getURL());
            operationalInfo.put("databaseUser", md.getUserName());
            operationalInfo.put("databaseProduct", md.getDatabaseProductName() + " " + md.getDatabaseProductVersion());
            operationalInfo.put("databaseDriver", md.getDriverName() + " " + md.getDriverVersion());

            logger.debugf("Database info: %s", operationalInfo.toString());
        } catch (SQLException e) {
            logger.warn("Unable to prepare operational info due database exception: " + e.getMessage());
        }
    }

startGlobalStats()

void org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.startGlobalStats ( KeycloakSession  session, int  globalStatsIntervalSecs  )

inlineprotected

                                                                                          {
        logger.debugf("Started Hibernate statistics with the interval %s seconds", globalStatsIntervalSecs);
        TimerProvider timer = session.getProvider(TimerProvider.class);
        timer.scheduleTask(new HibernateStatsReporter(emf), globalStatsIntervalSecs * 1000, "ReportHibernateGlobalStats");
    }

update()

void org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.update ( Connection  connection, String  schema, KeycloakSession  session, JpaUpdaterProvider  updater  )

inlineprotected

                                                                                                                     {
        DBLockProvider dbLock = new DBLockManager(session).getDBLock();
        if (dbLock.hasLock()) {
            updater.update(connection, schema);
        } else {
            KeycloakModelUtils.runJobInTransaction(session.getKeycloakSessionFactory(), new KeycloakSessionTask() {
                @Override
                public void run(KeycloakSession lockSession) {
                    DBLockManager dbLockManager = new DBLockManager(lockSession);
                    DBLockProvider dbLock2 = dbLockManager.getDBLock();
                    dbLock2.waitForLock();
                    try {
                        updater.update(connection, schema);
                    } finally {
                        dbLock2.releaseLock();
                    }
                }
            });
        }
    }

メンバ詳解

config

Config.Scope org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.config

private

emf

volatile EntityManagerFactory org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.emf

private

factory

KeycloakSessionFactory org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.factory

private

jtaEnabled

boolean org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.jtaEnabled

private

jtaLookup

JtaTransactionManagerLookup org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.jtaLookup

private

logger

final Logger org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.logger = Logger.getLogger(DefaultJpaConnectionProviderFactory.class)

staticprivate

operationalInfo

Map<String, String> org.keycloak.connections.jpa.DefaultJpaConnectionProviderFactory.operationalInfo

private

---

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

• D:/AppData/doxygen/keycloak/src/keycloak/src/main/java/org/keycloak/connections/jpa/DefaultJpaConnectionProviderFactory.java