org.keycloak.services.resources.KeycloakApplication クラス

org.keycloak.services.resources.KeycloakApplication の継承関係図

org.keycloak.services.resources.KeycloakApplication 連携図

公開メンバ関数
	KeycloakApplication (@Context ServletContext context, @Context Dispatcher dispatcher)
String	getContextPath ()
URI	getBaseUri (UriInfo uriInfo)
KeycloakSessionFactory	getSessionFactory ()
Set< Class<?> >	getClasses ()
Set< Object >	getSingletons ()
void	importRealms ()
void	importRealm (RealmRepresentation rep, String from)
void	importAddUser ()

静的公開メンバ関数
static void	loadConfig (ServletContext context)
static KeycloakSessionFactory	createSessionFactory ()
static void	setupScheduledTasks (final KeycloakSessionFactory sessionFactory)

静的公開変数類
static final String	KEYCLOAK_CONFIG_PARAM_NAME = "org.keycloak.server-subsystem.Config"
static final String	KEYCLOAK_EMBEDDED = "keycloak.embedded"
static final String	SERVER_CONTEXT_CONFIG_PROPERTY_OVERRIDES = "keycloak.server.context.config.property-overrides"

限定公開メンバ関数
ExportImportManager	migrateAndBootstrap ()
void	migrateModel ()

限定公開変数類
boolean	embedded = false
Set< Object >	singletons = new HashSet<Object>()
Set< Class<?> >	classes = new HashSet<Class<?>>()
KeycloakSessionFactory	sessionFactory
String	contextPath

非公開メンバ関数
void	exit (int status)

静的非公開メンバ関数
static String	loadDmrConfig (ServletContext context)
static< T > T	loadJson (InputStream is, Class< T > type)

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

詳解

著者

Bill Burke

バージョン

Revision

1

構築子と解体子

KeycloakApplication()

org.keycloak.services.resources.KeycloakApplication.KeycloakApplication ( @Context ServletContext  context, @Context Dispatcher  dispatcher  )

inline

                                                                                                {
        try {
            if ("true".equals(context.getInitParameter(KEYCLOAK_EMBEDDED))) {
                embedded = true;
            }

            loadConfig(context);

            this.contextPath = context.getContextPath();
            this.sessionFactory = createSessionFactory();

            dispatcher.getDefaultContextObjects().put(KeycloakApplication.class, this);
            ResteasyProviderFactory.pushContext(KeycloakApplication.class, this); // for injection
            context.setAttribute(KeycloakSessionFactory.class.getName(), this.sessionFactory);

            singletons.add(new RobotsResource());
            singletons.add(new RealmsResource());
            singletons.add(new AdminRoot());
            classes.add(ThemeResource.class);
            classes.add(JsResource.class);

            classes.add(KeycloakTransactionCommitter.class);
            classes.add(KeycloakErrorHandler.class);

            singletons.add(new ObjectMapperResolver(Boolean.parseBoolean(System.getProperty("keycloak.jsonPrettyPrint", "false"))));

            ExportImportManager[] exportImportManager = new ExportImportManager[1];

            KeycloakModelUtils.runJobInTransaction(sessionFactory, new KeycloakSessionTask() {

                @Override
                public void run(KeycloakSession lockSession) {
                    DBLockManager dbLockManager = new DBLockManager(lockSession);
                    dbLockManager.checkForcedUnlock();
                    DBLockProvider dbLock = dbLockManager.getDBLock();
                    dbLock.waitForLock();
                    try {
                        exportImportManager[0] = migrateAndBootstrap();
                    } finally {
                        dbLock.releaseLock();
                    }
                }

            });


            if (exportImportManager[0].isRunExport()) {
                exportImportManager[0].runExport();
            }

            AtomicBoolean bootstrapAdminUser = new AtomicBoolean(false);
            KeycloakModelUtils.runJobInTransaction(sessionFactory, new KeycloakSessionTask() {

                @Override
                public void run(KeycloakSession session) {
                    boolean shouldBootstrapAdmin = new ApplianceBootstrap(session).isNoMasterUser();
                    bootstrapAdminUser.set(shouldBootstrapAdmin);
                }

            });

            sessionFactory.publish(new PostMigrationEvent());

            singletons.add(new WelcomeResource(bootstrapAdminUser.get()));

            setupScheduledTasks(sessionFactory);
        } catch (Throwable t) {
            if (!embedded) {
                exit(1);
            }
            throw t;
        }
    }

関数詳解

createSessionFactory()

static KeycloakSessionFactory org.keycloak.services.resources.KeycloakApplication.createSessionFactory ( )

inlinestatic

                                                                {
        DefaultKeycloakSessionFactory factory = new DefaultKeycloakSessionFactory();
        factory.init();
        return factory;
    }

exit()

void org.keycloak.services.resources.KeycloakApplication.exit ( int  status )

inlineprivate

                                  {
        new Thread() {
            @Override
            public void run() {
                System.exit(status);
            }
        }.start();
    }

getBaseUri()

URI org.keycloak.services.resources.KeycloakApplication.getBaseUri ( UriInfo  uriInfo )

inline

Get base URI of WAR distribution, not JAX-RS

引数

uriInfo

戻り値

                                           {
        return uriInfo.getBaseUriBuilder().replacePath(getContextPath()).build();
    }

getClasses()

Set<Class<?> > org.keycloak.services.resources.KeycloakApplication.getClasses ( )

inline

                                      {
        return classes;
    }

getContextPath()

String org.keycloak.services.resources.KeycloakApplication.getContextPath ( )

inline

                                   {
        return contextPath;
    }

getSessionFactory()

KeycloakSessionFactory org.keycloak.services.resources.KeycloakApplication.getSessionFactory ( )

inline

                                                      {
        return sessionFactory;
    }

getSingletons()

Set<Object> org.keycloak.services.resources.KeycloakApplication.getSingletons ( )

inline

                                       {
        return singletons;
    }

importAddUser()

void org.keycloak.services.resources.KeycloakApplication.importAddUser ( )

inline

                                {
        String configDir = System.getProperty("jboss.server.config.dir");
        if (configDir != null) {
            File addUserFile = new File(configDir + File.separator + "keycloak-add-user.json");
            if (addUserFile.isFile()) {
                ServicesLogger.LOGGER.imprtingUsersFrom(addUserFile);

                List<RealmRepresentation> realms;
                try {
                    realms = JsonSerialization.readValue(new FileInputStream(addUserFile), new TypeReference<List<RealmRepresentation>>() {
                    });
                } catch (IOException e) {
                    ServicesLogger.LOGGER.failedToLoadUsers(e);
                    return;
                }

                for (RealmRepresentation realmRep : realms) {
                    for (UserRepresentation userRep : realmRep.getUsers()) {
                        KeycloakSession session = sessionFactory.create();
                        try {
                            session.getTransactionManager().begin();

                            RealmModel realm = session.realms().getRealmByName(realmRep.getRealm());
                            if (realm == null) {
                                ServicesLogger.LOGGER.addUserFailedRealmNotFound(userRep.getUsername(), realmRep.getRealm());
                            } else {
                                UserModel user = session.users().addUser(realm, userRep.getUsername());
                                user.setEnabled(userRep.isEnabled());
                                RepresentationToModel.createCredentials(userRep, session, realm, user, false);
                                RepresentationToModel.createRoleMappings(userRep, user, realm);
                            }

                            session.getTransactionManager().commit();
                            ServicesLogger.LOGGER.addUserSuccess(userRep.getUsername(), realmRep.getRealm());
                        } catch (ModelDuplicateException e) {
                            session.getTransactionManager().rollback();
                            ServicesLogger.LOGGER.addUserFailedUserExists(userRep.getUsername(), realmRep.getRealm());
                        } catch (Throwable t) {
                            session.getTransactionManager().rollback();
                            ServicesLogger.LOGGER.addUserFailed(t, userRep.getUsername(), realmRep.getRealm());
                        } finally {
                            session.close();
                        }
                    }
                }

                if (!addUserFile.delete()) {
                    ServicesLogger.LOGGER.failedToDeleteFile(addUserFile.getAbsolutePath());
                }
            }
        }
    }

importRealm()

void org.keycloak.services.resources.KeycloakApplication.importRealm ( RealmRepresentation  rep, String  from  )

inline

                                                                  {
        KeycloakSession session = sessionFactory.create();
        boolean exists = false;
        try {
            session.getTransactionManager().begin();

            try {
                RealmManager manager = new RealmManager(session);
                manager.setContextPath(getContextPath());

                if (rep.getId() != null && manager.getRealm(rep.getId()) != null) {
                    ServicesLogger.LOGGER.realmExists(rep.getRealm(), from);
                    exists = true;
                }

                if (manager.getRealmByName(rep.getRealm()) != null) {
                    ServicesLogger.LOGGER.realmExists(rep.getRealm(), from);
                    exists = true;
                }
                if (!exists) {
                    RealmModel realm = manager.importRealm(rep);
                    ServicesLogger.LOGGER.importedRealm(realm.getName(), from);
                }
                session.getTransactionManager().commit();
            } catch (Throwable t) {
                session.getTransactionManager().rollback();
                if (!exists) {
                    ServicesLogger.LOGGER.unableToImportRealm(t, rep.getRealm(), from);
                }
            }
        } finally {
            session.close();
        }
    }

importRealms()

void org.keycloak.services.resources.KeycloakApplication.importRealms ( )

inline

                               {
        String files = System.getProperty("keycloak.import");
        if (files != null) {
            StringTokenizer tokenizer = new StringTokenizer(files, ",");
            while (tokenizer.hasMoreTokens()) {
                String file = tokenizer.nextToken().trim();
                RealmRepresentation rep;
                try {
                    rep = loadJson(new FileInputStream(file), RealmRepresentation.class);
                } catch (FileNotFoundException e) {
                    throw new RuntimeException(e);
                }
                importRealm(rep, "file " + file);
            }
        }
    }

loadConfig()

static void org.keycloak.services.resources.KeycloakApplication.loadConfig ( ServletContext  context )

inlinestatic

                                                          {
        try {
            JsonNode node = null;

            String dmrConfig = loadDmrConfig(context);
            if (dmrConfig != null) {
                node = new ObjectMapper().readTree(dmrConfig);
                ServicesLogger.LOGGER.loadingFrom("standalone.xml or domain.xml");
            }

            String configDir = System.getProperty("jboss.server.config.dir");
            if (node == null && configDir != null) {
                File f = new File(configDir + File.separator + "keycloak-server.json");
                if (f.isFile()) {
                    ServicesLogger.LOGGER.loadingFrom(f.getAbsolutePath());
                    node = new ObjectMapper().readTree(f);
                }
            }

            if (node == null) {
                URL resource = Thread.currentThread().getContextClassLoader().getResource("META-INF/keycloak-server.json");
                if (resource != null) {
                    ServicesLogger.LOGGER.loadingFrom(resource);
                    node = new ObjectMapper().readTree(resource);
                }
            }

            if (node != null) {
                Map<String, String> propertyOverridesMap = new HashMap<>();
                String propertyOverrides = context.getInitParameter(SERVER_CONTEXT_CONFIG_PROPERTY_OVERRIDES);
                if (context.getInitParameter(SERVER_CONTEXT_CONFIG_PROPERTY_OVERRIDES) != null) {
                    JsonNode jsonObj = new ObjectMapper().readTree(propertyOverrides);
                    jsonObj.fields().forEachRemaining(e -> propertyOverridesMap.put(e.getKey(), e.getValue().asText()));
                }
                Properties properties = new SystemEnvProperties(propertyOverridesMap);
                Config.init(new JsonConfigProvider(node, properties));
            } else {
                throw new RuntimeException("Keycloak config not found.");
            }
        } catch (IOException e) {
            throw new RuntimeException("Failed to load config", e);
        }
    }

loadDmrConfig()

static String org.keycloak.services.resources.KeycloakApplication.loadDmrConfig ( ServletContext  context )

inlinestaticprivate

                                                                {
        String dmrConfig = context.getInitParameter(KEYCLOAK_CONFIG_PARAM_NAME);
        if (dmrConfig == null) return null;

        ModelNode dmrConfigNode = ModelNode.fromString(dmrConfig);
        if (dmrConfigNode.asPropertyList().isEmpty()) return null;
        
        // note that we need to resolve expressions BEFORE we convert to JSON
        return dmrConfigNode.resolve().toJSONString(true);
    }

loadJson()

static <T> T org.keycloak.services.resources.KeycloakApplication.loadJson ( InputStream  is, Class< T >  type  )

inlinestaticprivate

                                                                 {
        try {
            return JsonSerialization.readValue(is, type);
        } catch (IOException e) {
            throw new RuntimeException("Failed to parse json", e);
        }
    }

migrateAndBootstrap()

ExportImportManager org.keycloak.services.resources.KeycloakApplication.migrateAndBootstrap ( )

inlineprotected

                                                        {
        ExportImportManager exportImportManager;
        logger.debug("Calling migrateModel");
        migrateModel();

        logger.debug("bootstrap");
        KeycloakSession session = sessionFactory.create();
        try {
            session.getTransactionManager().begin();
            JtaTransactionManagerLookup lookup = (JtaTransactionManagerLookup) sessionFactory.getProviderFactory(JtaTransactionManagerLookup.class);
            if (lookup != null) {
                if (lookup.getTransactionManager() != null) {
                    try {
                        Transaction transaction = lookup.getTransactionManager().getTransaction();
                        logger.debugv("bootstrap current transaction? {0}", transaction != null);
                        if (transaction != null) {
                            logger.debugv("bootstrap current transaction status? {0}", transaction.getStatus());
                        }
                    } catch (SystemException e) {
                        throw new RuntimeException(e);
                    }
                }
            }


            ApplianceBootstrap applianceBootstrap = new ApplianceBootstrap(session);
            exportImportManager = new ExportImportManager(session);

            boolean createMasterRealm = applianceBootstrap.isNewInstall();
            if (exportImportManager.isRunImport() && exportImportManager.isImportMasterIncluded()) {
                createMasterRealm = false;
            }

            if (createMasterRealm) {
                applianceBootstrap.createMasterRealm(contextPath);
            }
            session.getTransactionManager().commit();
        } catch (RuntimeException re) {
            if (session.getTransactionManager().isActive()) {
                session.getTransactionManager().rollback();
            }
            throw re;
        } finally {
            session.close();
        }

        if (exportImportManager.isRunImport()) {
            exportImportManager.runImport();
        } else {
            importRealms();
        }

        importAddUser();

        return exportImportManager;
    }

migrateModel()

void org.keycloak.services.resources.KeycloakApplication.migrateModel ( )

inlineprotected

                                  {
        KeycloakSession session = sessionFactory.create();
        try {
            session.getTransactionManager().begin();
            MigrationModelManager.migrate(session);
            session.getTransactionManager().commit();
        } catch (Exception e) {
            session.getTransactionManager().rollback();
            throw e;
        } finally {
            session.close();
        }
    }

setupScheduledTasks()

static void org.keycloak.services.resources.KeycloakApplication.setupScheduledTasks ( final KeycloakSessionFactory  sessionFactory )

inlinestatic

                                                                                        {
        long interval = Config.scope("scheduled").getLong("interval", 60L) * 1000;

        KeycloakSession session = sessionFactory.create();
        try {
            TimerProvider timer = session.getProvider(TimerProvider.class);
            timer.schedule(new ClusterAwareScheduledTaskRunner(sessionFactory, new ClearExpiredEvents(), interval), interval, "ClearExpiredEvents");
            timer.schedule(new ClusterAwareScheduledTaskRunner(sessionFactory, new ClearExpiredClientInitialAccessTokens(), interval), interval, "ClearExpiredClientInitialAccessTokens");
            timer.schedule(new ScheduledTaskRunner(sessionFactory, new ClearExpiredUserSessions()), interval, ClearExpiredUserSessions.TASK_NAME);
            new UserStorageSyncManager().bootstrapPeriodic(sessionFactory, timer);
        } finally {
            session.close();
        }
    }

メンバ詳解

classes

Set<Class<?> > org.keycloak.services.resources.KeycloakApplication.classes = new HashSet<Class<?>>()

protected

contextPath

String org.keycloak.services.resources.KeycloakApplication.contextPath

protected

embedded

boolean org.keycloak.services.resources.KeycloakApplication.embedded = false

protected

KEYCLOAK_CONFIG_PARAM_NAME

final String org.keycloak.services.resources.KeycloakApplication.KEYCLOAK_CONFIG_PARAM_NAME = "org.keycloak.server-subsystem.Config"

static

KEYCLOAK_EMBEDDED

final String org.keycloak.services.resources.KeycloakApplication.KEYCLOAK_EMBEDDED = "keycloak.embedded"

static

logger

final Logger org.keycloak.services.resources.KeycloakApplication.logger = Logger.getLogger(KeycloakApplication.class)

staticprivate

SERVER_CONTEXT_CONFIG_PROPERTY_OVERRIDES

final String org.keycloak.services.resources.KeycloakApplication.SERVER_CONTEXT_CONFIG_PROPERTY_OVERRIDES = "keycloak.server.context.config.property-overrides"

static

sessionFactory

KeycloakSessionFactory org.keycloak.services.resources.KeycloakApplication.sessionFactory

protected

singletons

Set<Object> org.keycloak.services.resources.KeycloakApplication.singletons = new HashSet<Object>()

protected

---

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

• D:/AppData/doxygen/keycloak/oidc-service/src/main/java/org/keycloak/services/resources/KeycloakApplication.java