org.xdi.oxauth.model.config.ConfigurationFactory クラス

org.xdi.oxauth.model.config.ConfigurationFactory 連携図

クラス
class	PersistenceConfiguration

公開メンバ関数
void	init ()
void	create ()
void	initTimer ()
void	reloadConfigurationTimerEvent (@Observes @Scheduled ConfigurationEvent configurationEvent)
PersistenceConfiguration	getPersistenceConfiguration ()
AppConfiguration	getAppConfiguration ()
StaticConfiguration	getStaticConfiguration ()
WebKeysConfiguration	getWebKeysConfiguration ()
ErrorResponseFactory	getErrorResponseFactory ()
BaseDnConfiguration	getBaseDn ()
String	getCryptoConfigurationSalt ()
void	destroy (Class<? extends Configuration > clazz)
void	initJwksFromString (String p_webKeys) throws IOException, JsonParseException, JsonMappingException
void	loadCryptoConfigurationSalt ()

静的公開変数類
static final String	PERSISTENCE_CONFIGUARION_RELOAD_EVENT_TYPE = "persistenceConfigurationReloadEvent"
static final String	LDAP_DEFAULT_FILE_PATH = DIR + "ox-ldap.properties"

限定公開メンバ関数
PersistenceConfiguration	loadPersistenceConfiguration ()

静的関数
	[static initializer]

変数
String	configFilePath
String	errorsFilePath
String	staticConfFilePath
String	webKeysFilePath
String	saltFilePath

非公開メンバ関数
void	reloadConfiguration ()
String	confDir ()
boolean	createFromFile ()
boolean	reloadWebkeyFromFile ()
boolean	reloadStaticConfFromFile ()
boolean	reloadErrorsFromFile ()
boolean	reloadConfFromFile ()
boolean	createFromLdap (boolean recoverFromFiles)
Conf	loadConfigurationFromLdap (String... returnAttributes)
void	init (Conf p_conf)
void	initWebKeysFromJson (String p_webKeys)
void	initStaticConfigurationFromJson (String p_statics)
void	initConfigurationFromJson (String p_configurationJson)
void	initErrorsFromJson (String p_errosAsJson)
PersistenceConfiguration	loadLdapConfiguration (String ldapFileName)
PersistenceConfiguration	loadPersistenceConfiguration (String gluuFileName)
void	replaceWithSystemValues (FileConfiguration fileConfiguration)
String	determineGluuConfigurationFileName ()
String	determineLdapConfigurationFileName ()
AppConfiguration	loadConfFromFile ()
ErrorMessages	loadErrorsFromFile ()
StaticConfiguration	loadStaticConfFromFile ()
WebKeysConfiguration	loadWebKeysFromFile ()
FileConfiguration	createFileConfiguration (String fileName, boolean isMandatory)

非公開変数類
Logger	log
Event< TimerEvent >	timerEvent
Event< AppConfiguration >	configurationUpdateEvent
Event< String >	event
Instance< PersistenceEntryManager >	persistenceEntryManagerInstance
Instance< PersistenceEntryManagerFactory >	persistenceEntryManagerFactoryInstance
Instance< Configuration >	configurationInstance
final String	CONFIG_FILE_NAME = "oxauth-config.json"
final String	ERRORS_FILE_NAME = "oxauth-errors.json"
final String	STATIC_CONF_FILE_NAME = "oxauth-static-conf.json"
final String	WEB_KEYS_FILE_NAME = "oxauth-web-keys.json"
final String	SALT_FILE_NAME = "salt"
String	confDir
boolean	loaded = false
PersistenceConfiguration	persistenceConfiguration
AppConfiguration	conf
StaticConfiguration	staticConf
WebKeysConfiguration	jwks
ErrorResponseFactory	errorResponseFactory
String	cryptoConfigurationSalt
AtomicBoolean	isActive
long	loadedRevision = -1
boolean	loadedFromLdap = true

静的非公開変数類
static final int	DEFAULT_INTERVAL = 30
static final String	BASE_DIR
static final String	DIR = BASE_DIR + File.separator + "conf" + File.separator
static final String	GLUU_FILE_PATH = DIR + "gluu.properties"
static final String	LDAP_FILE_PATH = DIR + "oxauth-ldap.properties"

詳解

著者

Yuriy Zabrovarnyy

Javier Rojas Blum

Yuriy Movchan

バージョン

June 15, 2016

関数詳解

[static initializer]()

org.xdi.oxauth.model.config.ConfigurationFactory.[static initializer] ( )

inlinestaticpackage

confDir()

String org.xdi.oxauth.model.config.ConfigurationFactory.confDir ( )

inlineprivate

                                 {
                final String confDir = this.persistenceConfiguration.getConfiguration().getString("confDir", null);
                if (StringUtils.isNotBlank(confDir)) {
                        return confDir;
                }

                return DIR;
        }

create()

void org.xdi.oxauth.model.config.ConfigurationFactory.create ( )

inline

                             {
                if (!createFromLdap(true)) {
                        log.error("Failed to load configuration from LDAP. Please fix it!!!.");
                        throw new ConfigurationException("Failed to load configuration from LDAP.");
                } else {
                        log.info("Configuration loaded successfully.");
                }
        }

createFileConfiguration()

FileConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.createFileConfiguration ( String  fileName, boolean  isMandatory  )

inlineprivate

                                                                                                {
                try {
                        FileConfiguration fileConfiguration = new FileConfiguration(fileName);

                        return fileConfiguration;
                } catch (Exception ex) {
                        if (isMandatory) {
                                log.error("Failed to load configuration from {}", fileName, ex);
                                throw new ConfigurationException("Failed to load configuration from " + fileName, ex);
                        }
                }

                return null;
        }

createFromFile()

boolean org.xdi.oxauth.model.config.ConfigurationFactory.createFromFile ( )

inlineprivate

                                         {
                boolean result = reloadConfFromFile() && reloadErrorsFromFile() && reloadStaticConfFromFile()
                                && reloadWebkeyFromFile();

                return result;
        }

createFromLdap()

boolean org.xdi.oxauth.model.config.ConfigurationFactory.createFromLdap ( boolean  recoverFromFiles )

inlineprivate

                                                                 {
                log.info("Loading configuration from LDAP...");
                try {
                        final Conf c = loadConfigurationFromLdap();
                        if (c != null) {
                                init(c);

                                // Destroy old configuration
                                if (this.loaded) {
                                        destroy(AppConfiguration.class);
                                        destroy(StaticConfiguration.class);
                                        destroy(WebKeysConfiguration.class);
                                        destroy(ErrorResponseFactory.class);
                                }

                                this.loaded = true;
                                configurationUpdateEvent.select(ConfigurationUpdate.Literal.INSTANCE).fire(conf);

                                return true;
                        }
                } catch (Exception ex) {
                        log.error(ex.getMessage(), ex);
                }

                if (recoverFromFiles) {
                        log.info("Unable to find configuration in LDAP, try to load configuration from file system... ");
                        if (createFromFile()) {
                                this.loadedFromLdap = false;
                                return true;
                        }
                }

                return false;
        }

destroy()

void org.xdi.oxauth.model.config.ConfigurationFactory.destroy ( Class<? extends Configuration >  clazz )

inline

                                                                  {
                Instance<? extends Configuration> confInstance = configurationInstance.select(clazz);
                configurationInstance.destroy(confInstance.get());
        }

determineGluuConfigurationFileName()

String org.xdi.oxauth.model.config.ConfigurationFactory.determineGluuConfigurationFileName ( )

inlineprivate

                                                            {
                File ldapFile = new File(GLUU_FILE_PATH);
                if (ldapFile.exists()) {
                        return GLUU_FILE_PATH;
                }

                return null;
        }

determineLdapConfigurationFileName()

String org.xdi.oxauth.model.config.ConfigurationFactory.determineLdapConfigurationFileName ( )

inlineprivate

                                                            {
                File ldapFile = new File(LDAP_FILE_PATH);
                if (ldapFile.exists()) {
                        return LDAP_FILE_PATH;
                }

                return LDAP_DEFAULT_FILE_PATH;
        }

getAppConfiguration()

AppConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.getAppConfiguration ( )

inline

                                                      {
                return conf;
        }

getBaseDn()

BaseDnConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.getBaseDn ( )

inline

                                               {
                return getStaticConfiguration().getBaseDn();
        }

getCryptoConfigurationSalt()

String org.xdi.oxauth.model.config.ConfigurationFactory.getCryptoConfigurationSalt ( )

inline

                                                   {
                return cryptoConfigurationSalt;
        }

getErrorResponseFactory()

ErrorResponseFactory org.xdi.oxauth.model.config.ConfigurationFactory.getErrorResponseFactory ( )

inline

                                                              {
                return errorResponseFactory;
        }

getPersistenceConfiguration()

PersistenceConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.getPersistenceConfiguration ( )

inline

                                                                  {
        return persistenceConfiguration;
    }

getStaticConfiguration()

StaticConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.getStaticConfiguration ( )

inline

                                                            {
                return staticConf;
        }

getWebKeysConfiguration()

WebKeysConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.getWebKeysConfiguration ( )

inline

                                                              {
                return jwks;
        }

init() [1/2]

void org.xdi.oxauth.model.config.ConfigurationFactory.init ( )

inline

                           {
                this.isActive = new AtomicBoolean(true);
                try {
            this.persistenceConfiguration = loadPersistenceConfiguration();
                        this.confDir = confDir();

                        this.configFilePath = confDir + CONFIG_FILE_NAME;
                        this.errorsFilePath = confDir + ERRORS_FILE_NAME;
                        this.staticConfFilePath = confDir + STATIC_CONF_FILE_NAME;

                        String certsDir = this.persistenceConfiguration.getConfiguration().getString("certsDir");
                        if (StringHelper.isEmpty(certsDir)) {
                                certsDir = confDir;
                        }
                        this.webKeysFilePath = certsDir + File.separator + WEB_KEYS_FILE_NAME;
                        this.saltFilePath = confDir + SALT_FILE_NAME;

                        loadCryptoConfigurationSalt();
                } finally {
                        this.isActive.set(false);
                }
        }

init() [2/2]

void org.xdi.oxauth.model.config.ConfigurationFactory.init ( Conf  p_conf )

inlineprivate

                                       {
                initConfigurationFromJson(p_conf.getDynamic());
                initStaticConfigurationFromJson(p_conf.getStatics());
                initWebKeysFromJson(p_conf.getWebKeys());
                initErrorsFromJson(p_conf.getErrors());
                this.loadedRevision = p_conf.getRevision();
        }

initConfigurationFromJson()

void org.xdi.oxauth.model.config.ConfigurationFactory.initConfigurationFromJson ( String  p_configurationJson )

inlineprivate

                                                                           {
                try {
                        final AppConfiguration c = ServerUtil.createJsonMapper().readValue(p_configurationJson,
                                        AppConfiguration.class);
                        if (c != null) {
                                conf = c;
                        }
                } catch (Exception e) {
                        log.error(e.getMessage(), e);
                }
        }

initErrorsFromJson()

void org.xdi.oxauth.model.config.ConfigurationFactory.initErrorsFromJson ( String  p_errosAsJson )

inlineprivate

                                                              {
                try {
                        final ErrorMessages errorMessages = ServerUtil.createJsonMapper().readValue(p_errosAsJson,
                                        ErrorMessages.class);
                        if (errorMessages != null) {
                                errorResponseFactory = new ErrorResponseFactory(errorMessages);
                        }
                } catch (Exception e) {
                        log.error(e.getMessage(), e);
                }
        }

initJwksFromString()

void org.xdi.oxauth.model.config.ConfigurationFactory.initJwksFromString ( String  p_webKeys ) throws IOException, JsonParseException, JsonMappingException

inline

                                                                                                                      {
                final WebKeysConfiguration k = ServerUtil.createJsonMapper().readValue(p_webKeys, WebKeysConfiguration.class);
                if (k != null) {
                        jwks = k;
                }
        }

initStaticConfigurationFromJson()

void org.xdi.oxauth.model.config.ConfigurationFactory.initStaticConfigurationFromJson ( String  p_statics )

inlineprivate

                                                                       {
                try {
                        final StaticConfiguration c = ServerUtil.createJsonMapper().readValue(p_statics, StaticConfiguration.class);
                        if (c != null) {
                                staticConf = c;
                        }
                } catch (Exception e) {
                        log.error(e.getMessage(), e);
                }
        }

initTimer()

void org.xdi.oxauth.model.config.ConfigurationFactory.initTimer ( )

inline

                                {
                log.debug("Initializing Configuration Timer");

                final int delay = 30;
                final int interval = DEFAULT_INTERVAL;

                timerEvent.fire(new TimerEvent(new TimerSchedule(delay, interval), new ConfigurationEvent(),
                                Scheduled.Literal.INSTANCE));
        }

initWebKeysFromJson()

void org.xdi.oxauth.model.config.ConfigurationFactory.initWebKeysFromJson ( String  p_webKeys )

inlineprivate

                                                           {
                try {
                        initJwksFromString(p_webKeys);
                } catch (Exception ex) {
                        log.error("Failed to load JWKS. Attempting to generate new JWKS...", ex);

                        String newWebKeys = null;
                        try {
                                // Generate new JWKS
                                JSONObject jsonObject = AbstractCryptoProvider.generateJwks(
                                                getAppConfiguration().getKeyRegenerationInterval(), getAppConfiguration().getIdTokenLifetime(),
                                                getAppConfiguration());
                                newWebKeys = jsonObject.toString();

                                // Attempt to load new JWKS
                                initJwksFromString(newWebKeys);

                                // Store new JWKS in LDAP
                                Conf conf = loadConfigurationFromLdap();
                                conf.setWebKeys(newWebKeys);

                                long nextRevision = conf.getRevision() + 1;
                                conf.setRevision(nextRevision);

                                final PersistenceEntryManager ldapManager = persistenceEntryManagerInstance.get();
                                ldapManager.merge(conf);

                                log.info("New JWKS generated successfully");
                        } catch (Exception ex2) {
                                log.error("Failed to re-generate JWKS keys", ex2);
                        }
                }
        }

loadConfFromFile()

AppConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.loadConfFromFile ( )

inlineprivate

                                                    {
                try {
                        return ServerUtil.createJsonMapper().readValue(new File(configFilePath), AppConfiguration.class);
                } catch (Exception e) {
                        log.warn(e.getMessage(), e);
                }
                return null;
        }

loadConfigurationFromLdap()

Conf org.xdi.oxauth.model.config.ConfigurationFactory.loadConfigurationFromLdap ( String...  returnAttributes )

inlineprivate

                                                                           {
                final PersistenceEntryManager ldapManager = persistenceEntryManagerInstance.get();
                final String dn = this.persistenceConfiguration.getConfiguration().getString("oxauth_ConfigurationEntryDN");
                try {
                        final Conf conf = ldapManager.find(Conf.class, dn, returnAttributes);

                        return conf;
                } catch (BasePersistenceException ex) {
                        log.error(ex.getMessage());
                }

                return null;
        }

loadCryptoConfigurationSalt()

void org.xdi.oxauth.model.config.ConfigurationFactory.loadCryptoConfigurationSalt ( )

inline

                                                  {
                try {
                        FileConfiguration cryptoConfiguration = createFileConfiguration(saltFilePath, true);

                        this.cryptoConfigurationSalt = cryptoConfiguration.getString("encodeSalt");
                } catch (Exception ex) {
                        log.error("Failed to load configuration from {}", saltFilePath, ex);
                        throw new ConfigurationException("Failed to load configuration from " + saltFilePath, ex);
                }
        }

loadErrorsFromFile()

ErrorMessages org.xdi.oxauth.model.config.ConfigurationFactory.loadErrorsFromFile ( )

inlineprivate

                                                   {
                try {
                        return ServerUtil.createJsonMapper().readValue(new File(errorsFilePath), ErrorMessages.class);
                } catch (Exception e) {
                        log.warn(e.getMessage(), e);
                }
                return null;
        }

loadLdapConfiguration()

PersistenceConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.loadLdapConfiguration ( String  ldapFileName )

inlineprivate

                                                                                {
        try {
            FileConfiguration ldapConfiguration = new FileConfiguration(ldapFileName);

            // Allow to override value via environment variables
            replaceWithSystemValues(ldapConfiguration);

            long ldapFileLastModifiedTime = -1;
            File ldapFile = new File(ldapFileName);
            if (ldapFile.exists()) {
                ldapFileLastModifiedTime = ldapFile.lastModified();
            }

            PersistenceConfiguration persistenceConfiguration = new PersistenceConfiguration(ldapFileName, ldapConfiguration, org.gluu.persist.ldap.impl.LdapEntryManagerFactory.class, ldapFileLastModifiedTime);

            return persistenceConfiguration;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }

        return null;
    }

loadPersistenceConfiguration() [1/2]

PersistenceConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.loadPersistenceConfiguration ( )

inlineprotected

                                                                      {
        PersistenceConfiguration currentPersistenceConfiguration = null;

        String gluuFileName = determineGluuConfigurationFileName();
        if (gluuFileName != null) {
            currentPersistenceConfiguration = loadPersistenceConfiguration(gluuFileName);
        }

        // Fall back to old LDAP persistence layer
        if (currentPersistenceConfiguration == null) {
            log.warn("Failed to load persistence configuration. Attempting to use LDAP layer");
            String ldapFileName = determineLdapConfigurationFileName();
            currentPersistenceConfiguration = loadLdapConfiguration(ldapFileName);
        }
        
        return currentPersistenceConfiguration;
    }

loadPersistenceConfiguration() [2/2]

PersistenceConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.loadPersistenceConfiguration ( String  gluuFileName )

inlineprivate

                                                                                       {
        try {
            // Determine persistence type
            FileConfiguration gluuFileConf = new FileConfiguration(gluuFileName);
            String persistenceType = gluuFileConf.getString("persistence.type");
            
            // Determine configuration file name and factory class type
            String persistenceFileName = null; 
            Class<? extends PersistenceEntryManagerFactory> persistenceEntryManagerFactoryType = null;
            
            for (PersistenceEntryManagerFactory persistenceEntryManagerFactory : persistenceEntryManagerFactoryInstance) {
                log.debug("Found Persistence Entry Manager Factory with type '{}'", persistenceEntryManagerFactory);
                if (StringHelper.equalsIgnoreCase(persistenceEntryManagerFactory.getPersistenceType(), persistenceType)) {
                    persistenceFileName = persistenceEntryManagerFactory.getDefaultConfigurationFileName();
                    persistenceEntryManagerFactoryType = (Class<? extends PersistenceEntryManagerFactory>) persistenceEntryManagerFactory.getClass().getSuperclass();
                    break;
                }
            }
            
            if (persistenceFileName == null) {
                log.error("Unable to get Persistence Entry Manager Factory by type '{}'", persistenceType);
                return null;
            }

            String persistenceFileNamePath = DIR + persistenceFileName;

            FileConfiguration persistenceFileConf = new FileConfiguration(persistenceFileNamePath);
            if (!persistenceFileConf.isLoaded()) {
                log.error("Unable to load configuration file '{}'", persistenceFileNamePath);
                return null;
            }

            // Allow to override value via environment variables
            replaceWithSystemValues(persistenceFileConf);

            long persistenceFileLastModifiedTime = -1;
            File persistenceFile = new File(persistenceFileNamePath);
            if (persistenceFile.exists()) {
                persistenceFileLastModifiedTime = persistenceFile.lastModified();
            }

            PersistenceConfiguration persistenceConfiguration = new PersistenceConfiguration(persistenceFileName, persistenceFileConf, persistenceEntryManagerFactoryType, persistenceFileLastModifiedTime);

            return persistenceConfiguration;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }

        return null;
    }

loadStaticConfFromFile()

StaticConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.loadStaticConfFromFile ( )

inlineprivate

                                                             {
                try {
                        return ServerUtil.createJsonMapper().readValue(new File(staticConfFilePath), StaticConfiguration.class);
                } catch (Exception e) {
                        log.warn(e.getMessage(), e);
                }
                return null;
        }

loadWebKeysFromFile()

WebKeysConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.loadWebKeysFromFile ( )

inlineprivate

                                                           {
                try {
                        return ServerUtil.createJsonMapper().readValue(new File(webKeysFilePath), WebKeysConfiguration.class);
                } catch (Exception e) {
                        log.warn(e.getMessage(), e);
                }
                return null;
        }

reloadConfFromFile()

boolean org.xdi.oxauth.model.config.ConfigurationFactory.reloadConfFromFile ( )

inlineprivate

                                             {
                final AppConfiguration configFromFile = loadConfFromFile();
                if (configFromFile != null) {
                        log.info("Reloaded configuration from file: " + configFilePath);
                        conf = configFromFile;
                        return true;
                } else {
                        log.error("Failed to load configuration from file: " + configFilePath);
                }

                return false;
        }

reloadConfiguration()

void org.xdi.oxauth.model.config.ConfigurationFactory.reloadConfiguration ( )

inlineprivate

                                           {
                // Reload LDAP configuration if needed
            PersistenceConfiguration newPersistenceConfiguration = loadPersistenceConfiguration();

                if (newPersistenceConfiguration != null) {
                        if (!StringHelper.equalsIgnoreCase(this.persistenceConfiguration.getFileName(), newPersistenceConfiguration.getFileName()) || (newPersistenceConfiguration.getLastModifiedTime() > this.persistenceConfiguration.getLastModifiedTime())) {
                                // Reload configuration only if it was modified
                                this.persistenceConfiguration = newPersistenceConfiguration;
                                event.select(LdapConfigurationReload.Literal.INSTANCE).fire(PERSISTENCE_CONFIGUARION_RELOAD_EVENT_TYPE);
                        }
                }

                if (!loadedFromLdap) {
                        return;
                }

                final Conf conf = loadConfigurationFromLdap("oxRevision");
                if (conf == null) {
                        return;
                }

                if (conf.getRevision() <= this.loadedRevision) {
                        return;
                }

                createFromLdap(false);
        }

reloadConfigurationTimerEvent()

void org.xdi.oxauth.model.config.ConfigurationFactory.reloadConfigurationTimerEvent ( @Observes @Scheduled ConfigurationEvent  configurationEvent )

inline

                                                                                                              {
                if (this.isActive.get()) {
                        return;
                }

                if (!this.isActive.compareAndSet(false, true)) {
                        return;
                }

                try {
                        reloadConfiguration();
                } catch (Throwable ex) {
                        log.error("Exception happened while reloading application configuration", ex);
                } finally {
                        this.isActive.set(false);
                }
        }

reloadErrorsFromFile()

boolean org.xdi.oxauth.model.config.ConfigurationFactory.reloadErrorsFromFile ( )

inlineprivate

                                               {
                final ErrorMessages errorsFromFile = loadErrorsFromFile();
                if (errorsFromFile != null) {
                        log.info("Reloaded errors from file: " + errorsFilePath);
                        errorResponseFactory = new ErrorResponseFactory(errorsFromFile);
                        return true;
                } else {
                        log.error("Failed to load errors from file: " + errorsFilePath);
                }

                return false;
        }

reloadStaticConfFromFile()

boolean org.xdi.oxauth.model.config.ConfigurationFactory.reloadStaticConfFromFile ( )

inlineprivate

                                                   {
                final StaticConfiguration staticConfFromFile = loadStaticConfFromFile();
                if (staticConfFromFile != null) {
                        log.info("Reloaded static conf from file: " + staticConfFilePath);
                        staticConf = staticConfFromFile;
                        return true;
                } else {
                        log.error("Failed to load static configuration from file: " + staticConfFilePath);
                }

                return false;
        }

reloadWebkeyFromFile()

boolean org.xdi.oxauth.model.config.ConfigurationFactory.reloadWebkeyFromFile ( )

inlineprivate

                                               {
                final WebKeysConfiguration webKeysFromFile = loadWebKeysFromFile();
                if (webKeysFromFile != null) {
                        log.info("Reloaded web keys from file: " + webKeysFilePath);
                        jwks = webKeysFromFile;
                        return true;
                } else {
                        log.error("Failed to load web keys configuration from file: " + webKeysFilePath);
                }

                return false;
        }

replaceWithSystemValues()

void org.xdi.oxauth.model.config.ConfigurationFactory.replaceWithSystemValues ( FileConfiguration  fileConfiguration )

inlineprivate

                                                                                  {
                Set<Map.Entry<Object, Object>> ldapProperties = fileConfiguration.getProperties().entrySet();
                for (Map.Entry<Object, Object> ldapPropertyEntry : ldapProperties) {
                        String ldapPropertyKey = (String) ldapPropertyEntry.getKey();
                        if (System.getenv(ldapPropertyKey) != null) {
                                ldapPropertyEntry.setValue(System.getenv(ldapPropertyKey));
                        }
                }
        }

メンバ詳解

BASE_DIR

final String org.xdi.oxauth.model.config.ConfigurationFactory.BASE_DIR

staticprivate

conf

AppConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.conf

private

confDir

String org.xdi.oxauth.model.config.ConfigurationFactory.confDir

private

CONFIG_FILE_NAME

final String org.xdi.oxauth.model.config.ConfigurationFactory.CONFIG_FILE_NAME = "oxauth-config.json"

private

configFilePath

String org.xdi.oxauth.model.config.ConfigurationFactory.configFilePath

package

configurationInstance

Instance<Configuration> org.xdi.oxauth.model.config.ConfigurationFactory.configurationInstance

private

configurationUpdateEvent

Event<AppConfiguration> org.xdi.oxauth.model.config.ConfigurationFactory.configurationUpdateEvent

private

cryptoConfigurationSalt

String org.xdi.oxauth.model.config.ConfigurationFactory.cryptoConfigurationSalt

private

DEFAULT_INTERVAL

final int org.xdi.oxauth.model.config.ConfigurationFactory.DEFAULT_INTERVAL = 30

staticprivate

DIR

final String org.xdi.oxauth.model.config.ConfigurationFactory.DIR = BASE_DIR + File.separator + "conf" + File.separator

staticprivate

errorResponseFactory

ErrorResponseFactory org.xdi.oxauth.model.config.ConfigurationFactory.errorResponseFactory

private

ERRORS_FILE_NAME

final String org.xdi.oxauth.model.config.ConfigurationFactory.ERRORS_FILE_NAME = "oxauth-errors.json"

private

errorsFilePath

String org.xdi.oxauth.model.config.ConfigurationFactory.errorsFilePath

package

event

Event<String> org.xdi.oxauth.model.config.ConfigurationFactory.event

private

GLUU_FILE_PATH

final String org.xdi.oxauth.model.config.ConfigurationFactory.GLUU_FILE_PATH = DIR + "gluu.properties"

staticprivate

isActive

AtomicBoolean org.xdi.oxauth.model.config.ConfigurationFactory.isActive

private

jwks

WebKeysConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.jwks

private

LDAP_DEFAULT_FILE_PATH

final String org.xdi.oxauth.model.config.ConfigurationFactory.LDAP_DEFAULT_FILE_PATH = DIR + "ox-ldap.properties"

static

LDAP_FILE_PATH

final String org.xdi.oxauth.model.config.ConfigurationFactory.LDAP_FILE_PATH = DIR + "oxauth-ldap.properties"

staticprivate

loaded

boolean org.xdi.oxauth.model.config.ConfigurationFactory.loaded = false

private

loadedFromLdap

boolean org.xdi.oxauth.model.config.ConfigurationFactory.loadedFromLdap = true

private

loadedRevision

long org.xdi.oxauth.model.config.ConfigurationFactory.loadedRevision = -1

private

log

Logger org.xdi.oxauth.model.config.ConfigurationFactory.log

private

PERSISTENCE_CONFIGUARION_RELOAD_EVENT_TYPE

final String org.xdi.oxauth.model.config.ConfigurationFactory.PERSISTENCE_CONFIGUARION_RELOAD_EVENT_TYPE = "persistenceConfigurationReloadEvent"

static

persistenceConfiguration

PersistenceConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.persistenceConfiguration

private

persistenceEntryManagerFactoryInstance

Instance<PersistenceEntryManagerFactory> org.xdi.oxauth.model.config.ConfigurationFactory.persistenceEntryManagerFactoryInstance

private

persistenceEntryManagerInstance

Instance<PersistenceEntryManager> org.xdi.oxauth.model.config.ConfigurationFactory.persistenceEntryManagerInstance

private

SALT_FILE_NAME

final String org.xdi.oxauth.model.config.ConfigurationFactory.SALT_FILE_NAME = "salt"

private

saltFilePath

String org.xdi.oxauth.model.config.ConfigurationFactory.saltFilePath

package

STATIC_CONF_FILE_NAME

final String org.xdi.oxauth.model.config.ConfigurationFactory.STATIC_CONF_FILE_NAME = "oxauth-static-conf.json"

private

staticConf

StaticConfiguration org.xdi.oxauth.model.config.ConfigurationFactory.staticConf

private

staticConfFilePath

String org.xdi.oxauth.model.config.ConfigurationFactory.staticConfFilePath

package

timerEvent

Event<TimerEvent> org.xdi.oxauth.model.config.ConfigurationFactory.timerEvent

private

WEB_KEYS_FILE_NAME

final String org.xdi.oxauth.model.config.ConfigurationFactory.WEB_KEYS_FILE_NAME = "oxauth-web-keys.json"

private

webKeysFilePath

String org.xdi.oxauth.model.config.ConfigurationFactory.webKeysFilePath

package

---

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

• D:/AppData/OpenId/gluu/src/oxAuth/Server/src/main/java/org/xdi/oxauth/model/config/ConfigurationFactory.java