public static void migrate(KeycloakSession session) {
    MigrationModel model = session.realms().getMigrationModel();

    ModelVersion currentVersion = new ModelVersion(Version.VERSION_KEYCLOAK);
    ModelVersion latestUpdate = migrations[migrations.length-1].getVersion();
    ModelVersion databaseVersion = model.getStoredVersion() != null ? new ModelVersion(model.getStoredVersion()) : null;

    if (databaseVersion == null || databaseVersion.lessThan(latestUpdate)) {
        for (Migration m : migrations) {
            if (databaseVersion == null || databaseVersion.lessThan(m.getVersion())) {
                if (databaseVersion != null) {
                    logger.debugf("Migrating older model to %s", m.getVersion());
                }
                m.migrate(session);
            }
        }
    }

    if (databaseVersion == null || databaseVersion.lessThan(currentVersion)) {
        model.setStoredVersion(currentVersion.toString());
    }

    Version.RESOURCES_VERSION = model.getResourcesTag();
}
 

@GET
@Produces(MediaType.TEXT_HTML_UTF_8)
public Response getLoginStatusIframe(@QueryParam("version") String version) {
    CacheControl cacheControl;
    if (version != null) {
        if (!version.equals(Version.RESOURCES_VERSION)) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
        cacheControl = CacheControlUtil.getDefaultCacheControl();
    } else {
        cacheControl = CacheControlUtil.noCache();
    }

    InputStream resource = getClass().getClassLoader().getResourceAsStream("login-status-iframe.html");
    if (resource != null) {
        P3PHelper.addP3PHeader();
        session.getProvider(SecurityHeadersProvider.class).options().allowAnyFrameAncestor();
        return Response.ok(resource).cacheControl(cacheControl).build();
    } else {
        return Response.status(Response.Status.NOT_FOUND).build();
    }
}
 

/**
 * Get theme content
 *
 * @param themType
 * @param themeName
 * @param path
 * @return
 */
@GET
@Path("/{version}/{themeType}/{themeName}/{path:.*}")
public Response getResource(@PathParam("version") String version, @PathParam("themeType") String themType, @PathParam("themeName") String themeName, @PathParam("path") String path) {
    if (!version.equals(Version.RESOURCES_VERSION)) {
        return Response.status(Response.Status.NOT_FOUND).build();
    }

    try {
        Theme theme = session.theme().getTheme(themeName, Theme.Type.valueOf(themType.toUpperCase()));
        InputStream resource = theme.getResourceAsStream(path);
        if (resource != null) {
            return Response.ok(resource).type(MimeTypeUtil.getContentType(path)).cacheControl(CacheControlUtil.getDefaultCacheControl()).build();
        } else {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
    } catch (Exception e) {
        ServicesLogger.LOGGER.failedToGetThemeRequest(e);
        return Response.serverError().build();
    }
}
 

private Response getJs(String name, String version) {
    CacheControl cacheControl;
    if (version != null) {
        if (!version.equals(Version.RESOURCES_VERSION)) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
        cacheControl = CacheControlUtil.getDefaultCacheControl();
    } else {
        cacheControl = CacheControlUtil.noCache();
    }

    Cors cors = Cors.add(request).allowAllOrigins();

    InputStream inputStream = getClass().getClassLoader().getResourceAsStream(name);
    if (inputStream != null) {
        return cors.builder(Response.ok(inputStream).type("text/javascript").cacheControl(cacheControl)).build();
    } else {
        return cors.builder(Response.status(Response.Status.NOT_FOUND)).build();
    }
}
 

public static SystemInfoRepresentation create(long serverStartupTime) {
    SystemInfoRepresentation rep = new SystemInfoRepresentation();
    rep.version = Version.VERSION;
    rep.serverTime = new Date().toString();
    rep.uptimeMillis = System.currentTimeMillis() - serverStartupTime;
    rep.uptime = formatUptime(rep.uptimeMillis);
    rep.javaVersion = System.getProperty("java.version");
    rep.javaVendor = System.getProperty("java.vendor");
    rep.javaVm = System.getProperty("java.vm.name");
    rep.javaVmVersion = System.getProperty("java.vm.version");
    rep.javaRuntime = System.getProperty("java.runtime.name");
    rep.javaHome = System.getProperty("java.home");
    rep.osName = System.getProperty("os.name");
    rep.osArchitecture = System.getProperty("os.arch");
    rep.osVersion = System.getProperty("os.version");
    rep.fileEncoding = System.getProperty("file.encoding");
    rep.userName = System.getProperty("user.name");
    rep.userDir = System.getProperty("user.dir");
    rep.userTimezone = System.getProperty("user.timezone");
    if (System.getProperty("user.country") != null && System.getProperty("user.language") != null) {
        rep.userLocale = (new Locale(System.getProperty("user.country"), System.getProperty("user.language")).toString());
    }
    return rep;
}
 

public static void main(String[] args) {

        log.infof("Using Keycloak Version: %s", Version.VERSION_KEYCLOAK);
        log.infof("Enabled Keycloak Features (Deprecated): %s", Profile.getDeprecatedFeatures());
        log.infof("Enabled Keycloak Features (Preview): %s", Profile.getPreviewFeatures());
        log.infof("Enabled Keycloak Features (Experimental): %s", Profile.getExperimentalFeatures());
        log.infof("Enabled Keycloak Features (Disabled): %s", Profile.getDisabledFeatures());

        SpringApplication.run(EmbeddedKeycloakServer.class, args);
    }
 

@Test
public void testServerInfo() {
    ServerInfoRepresentation info = adminClient.serverInfo().getInfo();
    assertNotNull(info);

    assertNotNull(info.getProviders());
    assertNotNull(info.getProviders().get("realm"));
    assertNotNull(info.getProviders().get("user"));
    assertNotNull(info.getProviders().get("authenticator"));

    assertNotNull(info.getThemes());
    assertNotNull(info.getThemes().get("account"));
    assertNotNull(info.getThemes().get("admin"));
    assertNotNull(info.getThemes().get("email"));
    assertNotNull(info.getThemes().get("login"));
    assertNotNull(info.getThemes().get("welcome"));

    assertNotNull(info.getEnums());

    assertNotNull(info.getMemoryInfo());
    assertNotNull(info.getSystemInfo());

    assertEquals(Version.VERSION, info.getSystemInfo().getVersion());
    assertNotNull(info.getSystemInfo().getServerTime());
    assertNotNull(info.getSystemInfo().getUptime());

    Map<String, ProviderRepresentation> jpaProviders = info.getProviders().get("connectionsJpa").getProviders();
    ProviderRepresentation jpaProvider = jpaProviders.values().iterator().next();
    log.infof("JPA Connections provider info: %s", jpaProvider.getOperationalInfo().toString());
}
 

public static void main(String[] args) throws Throwable {
    if (!System.getenv().containsKey("MAVEN_CMD_LINE_ARGS")) {
        Version.BUILD_TIME = new SimpleDateFormat("yyyy-MM-dd HH:mm").format(new Date());
    }

    bootstrapKeycloakServer(args);
}
 

public boolean createMasterRealm() {
    if (!isNewInstall()) {
        throw new IllegalStateException("Can't create default realm as realms already exists");
    }

    String adminRealmName = Config.getAdminRealm();
    ServicesLogger.LOGGER.initializingAdminRealm(adminRealmName);

    RealmManager manager = new RealmManager(session);
    RealmModel realm = manager.createRealm(adminRealmName, adminRealmName);
    realm.setName(adminRealmName);
    realm.setDisplayName(Version.NAME);
    realm.setDisplayNameHtml(Version.NAME_HTML);
    realm.setEnabled(true);
    realm.addRequiredCredential(CredentialRepresentation.PASSWORD);
    realm.setSsoSessionIdleTimeout(1800);
    realm.setAccessTokenLifespan(60);
    realm.setAccessTokenLifespanForImplicitFlow(Constants.DEFAULT_ACCESS_TOKEN_LIFESPAN_FOR_IMPLICIT_FLOW_TIMEOUT);
    realm.setSsoSessionMaxLifespan(36000);
    realm.setOfflineSessionIdleTimeout(Constants.DEFAULT_OFFLINE_SESSION_IDLE_TIMEOUT);
    // KEYCLOAK-7688 Offline Session Max for Offline Token
    realm.setOfflineSessionMaxLifespanEnabled(false);
    realm.setOfflineSessionMaxLifespan(Constants.DEFAULT_OFFLINE_SESSION_MAX_LIFESPAN);
    realm.setAccessCodeLifespan(60);
    realm.setAccessCodeLifespanUserAction(300);
    realm.setAccessCodeLifespanLogin(1800);
    realm.setSslRequired(SslRequired.EXTERNAL);
    realm.setRegistrationAllowed(false);
    realm.setRegistrationEmailAsUsername(false);

    session.getContext().setRealm(realm);

    return true;
}
 

@Override
public String getThemeName(Theme.Type type) {
    String name = null;

    switch (type) {
        case WELCOME:
            name = Config.scope("theme").get("welcomeTheme");
            break;
        case LOGIN:
            ClientModel client = session.getContext().getClient();
            if (client != null) {
                name = client.getAttribute(LOGIN_THEME_KEY);
            }

            if (name == null || name.isEmpty()) {
                name = session.getContext().getRealm().getLoginTheme();
            }
            
            break;
        case ACCOUNT:
            name = session.getContext().getRealm().getAccountTheme();
            break;
        case EMAIL:
            name = session.getContext().getRealm().getEmailTheme();
            break;
        case ADMIN:
            name = session.getContext().getRealm().getAdminTheme();
            break;
    }

    if (name == null || name.isEmpty()) {
        name = Config.scope("theme").get("default", Version.NAME.toLowerCase());
    }

    return name;
}
 

@Test
public void test() {
    testingClient.server().run(session -> {
        String currentVersion = Version.VERSION_KEYCLOAK.replaceAll("^(\\d+(?:\\.\\d+){0,2}).*$", "$1");

        JpaConnectionProvider p = session.getProvider(JpaConnectionProvider.class);
        EntityManager em = p.getEntityManager();

        List<MigrationModelEntity> l = em.createQuery("select m from MigrationModelEntity m ORDER BY m.updatedTime DESC", MigrationModelEntity.class).getResultList();
        Assert.assertEquals(1, l.size());
        Assert.assertTrue(l.get(0).getId().matches("[\\da-z]{5}"));
        Assert.assertEquals(currentVersion, l.get(0).getVersion());

        MigrationModel m = session.realms().getMigrationModel();
        Assert.assertEquals(currentVersion, m.getStoredVersion());
        Assert.assertEquals(m.getResourcesTag(), l.get(0).getId());

        Time.setOffset(-60000);

        session.realms().getMigrationModel().setStoredVersion("6.0.0");
        em.flush();

        Time.setOffset(0);

        l = em.createQuery("select m from MigrationModelEntity m ORDER BY m.updatedTime DESC", MigrationModelEntity.class).getResultList();
        Assert.assertEquals(2, l.size());
        Logger.getLogger(MigrationModelTest.class).info("MigrationModelEntity entries: ");
        Logger.getLogger(MigrationModelTest.class).info("--id: " + l.get(0).getId() + "; " + l.get(0).getVersion() + "; " + l.get(0).getUpdateTime());
        Logger.getLogger(MigrationModelTest.class).info("--id: " + l.get(1).getId() + "; " + l.get(1).getVersion() + "; " + l.get(1).getUpdateTime());
        Assert.assertTrue(l.get(0).getId().matches("[\\da-z]{5}"));
        Assert.assertEquals(currentVersion, l.get(0).getVersion());
        Assert.assertTrue(l.get(1).getId().matches("[\\da-z]{5}"));
        Assert.assertEquals("6.0.0", l.get(1).getVersion());

        m = session.realms().getMigrationModel();
        Assert.assertEquals(l.get(0).getId(), m.getResourcesTag());
        Assert.assertEquals(currentVersion, m.getStoredVersion());

        em.remove(l.get(1));
    });
}
 

@Override
public FetchOnServer getRunOnServer() {
    return (FetchOnServer) session -> Version.RESOURCES_VERSION;
}
 

/**
 * Main page of this realm's admin console
 *
 * @return
 * @throws URISyntaxException
 */
@GET
@NoCache
public Response getMainPage() throws IOException, FreeMarkerException {
    if (!session.getContext().getUri(UrlType.ADMIN).getRequestUri().getPath().endsWith("/")) {
        return Response.status(302).location(session.getContext().getUri(UrlType.ADMIN).getRequestUriBuilder().path("/").build()).build();
    } else {
        Theme theme = AdminRoot.getTheme(session, realm);

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

        URI adminBaseUri = session.getContext().getUri(UrlType.ADMIN).getBaseUri();
        String adminBaseUrl = adminBaseUri.toString();
        if (adminBaseUrl.endsWith("/")) {
            adminBaseUrl = adminBaseUrl.substring(0, adminBaseUrl.length() - 1);
        }

        URI authServerBaseUri = session.getContext().getUri(UrlType.FRONTEND).getBaseUri();
        String authServerBaseUrl = authServerBaseUri.toString();
        if (authServerBaseUrl.endsWith("/")) {
            authServerBaseUrl = authServerBaseUrl.substring(0, authServerBaseUrl.length() - 1);
        }

        map.put("authServerUrl", authServerBaseUrl);
        map.put("authUrl", adminBaseUrl);
        map.put("consoleBaseUrl", Urls.adminConsoleRoot(adminBaseUri, realm.getName()).getPath());
        map.put("resourceUrl", Urls.themeRoot(adminBaseUri).getPath() + "/admin/" + theme.getName());
        map.put("resourceCommonUrl", Urls.themeRoot(adminBaseUri).getPath() + "/common/keycloak");
        map.put("masterRealm", Config.getAdminRealm());
        map.put("resourceVersion", Version.RESOURCES_VERSION);
        map.put("properties", theme.getProperties());

        FreeMarkerUtil freeMarkerUtil = new FreeMarkerUtil();
        String result = freeMarkerUtil.processTemplate(map, "index.ftl", theme);
        Response.ResponseBuilder builder = Response.status(Response.Status.OK).type(MediaType.TEXT_HTML_UTF_8).language(Locale.ENGLISH).entity(result);

        // Replace CSP if admin is hosted on different URL
        if (!adminBaseUri.equals(authServerBaseUri)) {
            session.getProvider(SecurityHeadersProvider.class).options().allowFrameSrc(UriUtils.getOrigin(authServerBaseUri));
        }

        return builder.build();
    }
}
 

private Response createWelcomePage(String successMessage, String errorMessage) {
    try {
        Theme theme = getTheme();

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

        map.put("productName", Version.NAME);
        map.put("productNameFull", Version.NAME_FULL);

        map.put("properties", theme.getProperties());
        map.put("adminUrl", session.getContext().getUri(UrlType.ADMIN).getBaseUriBuilder().path("/admin/").build());

        map.put("resourcesPath", "resources/" + Version.RESOURCES_VERSION + "/" + theme.getType().toString().toLowerCase() +"/" + theme.getName());
        map.put("resourcesCommonPath", "resources/" + Version.RESOURCES_VERSION + "/common/keycloak");

        boolean bootstrap = shouldBootstrap();
        map.put("bootstrap", bootstrap);
        if (bootstrap) {
            boolean isLocal = isLocal();
            map.put("localUser", isLocal);

            if (isLocal) {
                String stateChecker = setCsrfCookie();
                map.put("stateChecker", stateChecker);
            }
        }
        if (successMessage != null) {
            map.put("successMessage", successMessage);
        }
        if (errorMessage != null) {
            map.put("errorMessage", errorMessage);
        }
        FreeMarkerUtil freeMarkerUtil = new FreeMarkerUtil();
        String result = freeMarkerUtil.processTemplate(map, "index.ftl", theme);

        ResponseBuilder rb = Response.status(errorMessage == null ? Status.OK : Status.BAD_REQUEST)
                .entity(result)
                .cacheControl(CacheControlUtil.noCache());
        return rb.build();
    } catch (Exception e) {
        throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
    }
}
 

@GET
@NoCache
public Response getMainPage() throws IOException, FreeMarkerException {
    if (!session.getContext().getUri().getRequestUri().getPath().endsWith("/")) {
        return Response.status(302).location(session.getContext().getUri().getRequestUriBuilder().path("/").build()).build();
    } else {
        Map<String, Object> map = new HashMap<>();

        UriInfo uriInfo = session.getContext().getUri(UrlType.FRONTEND);
        URI authUrl = uriInfo.getBaseUri();
        map.put("authUrl", authUrl.toString());
        map.put("baseUrl", uriInfo.getBaseUriBuilder().path(RealmsResource.class).path(realm.getName()).path(Constants.ACCOUNT_MANAGEMENT_CLIENT_ID).build(realm).toString());
        map.put("realm", realm);
        map.put("resourceUrl", Urls.themeRoot(authUrl).getPath() + "/" + Constants.ACCOUNT_MANAGEMENT_CLIENT_ID + "/" + theme.getName());
        map.put("resourceVersion", Version.RESOURCES_VERSION);
        
        String[] referrer = getReferrer();
        if (referrer != null) {
            map.put("referrer", referrer[0]);
            map.put("referrerName", referrer[1]);
            map.put("referrer_uri", referrer[2]);
        }
        
        UserModel user = null;
        if (auth != null) user = auth.getUser();
        Locale locale = session.getContext().resolveLocale(user);
        map.put("locale", locale.toLanguageTag());
        Properties messages = theme.getMessages(locale);
        map.put("msg", new MessageFormatterMethod(locale, messages));
        map.put("msgJSON", messagesToJsonString(messages));
        map.put("supportedLocales", supportedLocales(messages));
        map.put("properties", theme.getProperties());
        map.put("theme", (Function<String, String>) file -> {
            try {
                final InputStream resource = theme.getResourceAsStream(file);
                return new Scanner(resource, "UTF-8").useDelimiter("\\A").next();
            } catch (IOException e) {
                throw new RuntimeException("could not load file", e);
            }
        });

        EventStoreProvider eventStore = session.getProvider(EventStoreProvider.class);
        map.put("isEventsEnabled", eventStore != null && realm.isEventsEnabled());
        map.put("isAuthorizationEnabled", true);
        
        boolean isTotpConfigured = false;
        if (user != null) {
            isTotpConfigured = session.userCredentialManager().isConfiguredFor(realm, user, realm.getOTPPolicy().getType());
        }
        map.put("isTotpConfigured", isTotpConfigured);

        FreeMarkerUtil freeMarkerUtil = new FreeMarkerUtil();
        String result = freeMarkerUtil.processTemplate(map, "index.ftl", theme);
        Response.ResponseBuilder builder = Response.status(Response.Status.OK).type(MediaType.TEXT_HTML_UTF_8).language(Locale.ENGLISH).entity(result);
        return builder.build();
    }
}
 

public static URI themeRoot(URI baseUri) {
    return themeBase(baseUri).path(Version.RESOURCES_VERSION).build();
}
 

public DefaultThemeManager(DefaultThemeManagerFactory factory, KeycloakSession session) {
    this.factory = factory;
    this.session = session;
    this.defaultTheme = Config.scope("theme").get("default", Version.NAME.toLowerCase());
}
 

private Response createWelcomePage(String successMessage, String errorMessage) {
    try {
        Theme theme = getTheme();

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

        map.put("productName", Version.NAME);
        map.put("productNameFull", Version.NAME_FULL);

        map.put("properties", theme.getProperties());
        map.put("adminUrl", session.getContext().getUri(UrlType.ADMIN).getBaseUriBuilder().path("/admin/").build());

        map.put("resourcesPath", "resources/" + Version.RESOURCES_VERSION + "/" + theme.getType().toString().toLowerCase() +"/" + theme.getName());
        map.put("resourcesCommonPath", "resources/" + Version.RESOURCES_VERSION + "/common/keycloak");

        boolean bootstrap = shouldBootstrap();
        map.put("bootstrap", bootstrap);
        if (bootstrap) {
            boolean isLocal = isLocal();
            map.put("localUser", isLocal);

            if (isLocal) {
                String stateChecker = setCsrfCookie();
                map.put("stateChecker", stateChecker);
            }
        }
        if (successMessage != null) {
            map.put("successMessage", successMessage);
        }
        if (errorMessage != null) {
            map.put("errorMessage", errorMessage);
        }
        FreeMarkerUtil freeMarkerUtil = new FreeMarkerUtil();
        String result = freeMarkerUtil.processTemplate(map, "index.ftl", theme);

        ResponseBuilder rb = Response.status(errorMessage == null ? Status.OK : Status.BAD_REQUEST)
                .entity(result)
                .cacheControl(CacheControlUtil.noCache());
        return rb.build();
    } catch (Exception e) {
        throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
    }
}
 

public static void main(String[] args) throws Throwable {

        System.out.println("Starting KeycloakPlaygroundServer");
        Version.BUILD_TIME = new SimpleDateFormat("yyyy-MM-dd HH:mm").format(new Date());

        KeycloakServer keycloakServer = KeycloakServer.bootstrapKeycloakServer(args);

        deployMetricsServlet(keycloakServer);
    }