org.gluu.oxtrust.config.ConfigurationFactory クラス

org.gluu.oxtrust.config.ConfigurationFactory 連携図

クラス
class	PersistenceConfiguration

公開メンバ関数
void	init ()
void	create ()
void	initTimer ()
void	reloadConfigurationTimerEvent (@Observes @Scheduled ConfigurationEvent configurationEvent)
String	confDir ()
PersistenceConfiguration	getPersistenceConfiguration ()
FileConfiguration	getLdapCentralConfiguration ()
AppConfiguration	getAppConfiguration ()
CacheRefreshConfiguration	getCacheRefreshConfiguration ()
ImportPersonConfig	getImportPersonConfig ()
AttributeResolverConfiguration	getAttributeResolverConfiguration ()
String	getCryptoConfigurationSalt ()
String	getConfigurationDn ()
void	loadCryptoConfigurationSalt ()
void	destroy (Class<? extends Configuration > clazz)
LdapOxTrustConfiguration	loadConfigurationFromLdap (String... returnAttributes)
String	getIDPTemplatesLocation ()

静的公開変数類
static final String	PERSISTENCE_CONFIGUARION_RELOAD_EVENT_TYPE = "persistenceConfigurationReloadEvent"
static final String	PERSISTENCE_CENTRAL_CONFIGUARION_RELOAD_EVENT_TYPE = "persistenceCentralConfigurationReloadEvent"
static final String	BASE_DIR
static final String	DIR = BASE_DIR + File.separator + "conf" + File.separator
static final String	LDAP_PROPERTIES_FILE = DIR + "oxtrust-ldap.properties"
static final String	LDAP_DEFAULT_PROPERTIES_FILE = DIR + "ox-ldap.properties"
static final String	LDAP_CENTRAL_PROPERTIES_FILE = DIR + "oxtrust-central-ldap.properties"
static final String	APPLICATION_CONFIGURATION = "oxtrust-config.json"
static final String	CACHE_PROPERTIES_FILE = "oxTrustCacheRefresh.properties"
static final String	LOG_ROTATION_CONFIGURATION = "oxTrustLogRotationConfiguration.xml"
static final String	SALT_FILE_NAME = "salt"

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

静的関数
	[static initializer]

変数
String	configFilePath
String	cacheRefreshFilePath
String	logRotationFilePath
String	saltFilePath

非公開メンバ関数
void	reloadConfiguration ()
boolean	createFromFile ()
boolean	reloadAppConfFromFile ()
AppConfiguration	loadAppConfFromFile ()
void	loadLdapCentralConfiguration ()
FileConfiguration	createFileConfiguration (String fileName, boolean isMandatory)
boolean	createFromLdap (boolean recoverFromFiles)
void	init (LdapOxTrustConfiguration conf)
PersistenceConfiguration	loadLdapConfiguration (String ldapFileName)
PersistenceConfiguration	loadPersistenceConfiguration (String gluuFileName)
void	replaceWithSystemValues (FileConfiguration fileConfiguration)
String	determineGluuConfigurationFileName ()
String	determineLdapConfigurationFileName ()

非公開変数類
Logger	log
JsonService	jsonService
Event< TimerEvent >	timerEvent
Event< AppConfiguration >	configurationUpdateEvent
Event< String >	event
Instance< PersistenceEntryManager >	persistenceEntryManagerInstance
Instance< PersistenceEntryManagerFactory >	persistenceEntryManagerFactoryInstance
Instance< Configuration >	configurationInstance
String	confDir
boolean	loaded = false
PersistenceConfiguration	persistenceConfiguration
FileConfiguration	ldapCentralConfiguration
AppConfiguration	appConfiguration
CacheRefreshConfiguration	cacheRefreshConfiguration
ImportPersonConfig	importPersonConfig
AttributeResolverConfiguration	attributeResolverConfiguration
String	cryptoConfigurationSalt
AtomicBoolean	isActive
long	ldapCentralFileLastModifiedTime = -1
long	loadedRevision = -1
boolean	loadedFromLdap = true

静的非公開変数類
static final int	DEFAULT_INTERVAL = 30
static final String	GLUU_FILE_PATH = DIR + "gluu.properties"

詳解

著者

Yuriy Movchan

バージョン

0.1, 05/15/2013

関数詳解

[static initializer]()

org.gluu.oxtrust.config.ConfigurationFactory.[static initializer] ( )

inlinestaticpackage

confDir()

String org.gluu.oxtrust.config.ConfigurationFactory.confDir ( )

inline

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

                return DIR;
        }

create()

void org.gluu.oxtrust.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.gluu.oxtrust.config.ConfigurationFactory.createFileConfiguration ( String  fileName, boolean  isMandatory  )

inlineprivate

                                                                                                {
                try {
                        FileConfiguration fileConfiguration = new FileConfiguration(fileName);
                        if (fileConfiguration.isLoaded()) {
                                log.debug("########## fileName = " + fileConfiguration.getFileName());
                                log.debug("########## oxtrust_ConfigurationEntryDN = "
                                                + fileConfiguration.getString("oxtrust_ConfigurationEntryDN"));
                                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.gluu.oxtrust.config.ConfigurationFactory.createFromFile ( )

inlineprivate

                                     {
                boolean result = reloadAppConfFromFile();

                return result;
        }

createFromLdap()

boolean org.gluu.oxtrust.config.ConfigurationFactory.createFromLdap ( boolean  recoverFromFiles )

inlineprivate

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

                                // Destroy old configuration
                                if (this.loaded) {
                                        destroy(AppConfiguration.class);
                                        destroy(CacheRefreshConfiguration.class);
                                        destroy(ImportPersonConfig.class);
                                        destroy(AttributeResolverConfiguration.class);
                                }

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

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

                if (recoverFromFiles) {
                        log.warn("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.gluu.oxtrust.config.ConfigurationFactory.destroy ( Class<? extends Configuration >  clazz )

inline

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

determineGluuConfigurationFileName()

String org.gluu.oxtrust.config.ConfigurationFactory.determineGluuConfigurationFileName ( )

inlineprivate

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

        return null;
    }

determineLdapConfigurationFileName()

String org.gluu.oxtrust.config.ConfigurationFactory.determineLdapConfigurationFileName ( )

inlineprivate

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

                return LDAP_DEFAULT_PROPERTIES_FILE;
        }

getAppConfiguration()

AppConfiguration org.gluu.oxtrust.config.ConfigurationFactory.getAppConfiguration ( )

inline

                                                      {
                return appConfiguration;
        }

getAttributeResolverConfiguration()

AttributeResolverConfiguration org.gluu.oxtrust.config.ConfigurationFactory.getAttributeResolverConfiguration ( )

inline

                                                                                  {
                return attributeResolverConfiguration;
        }

getCacheRefreshConfiguration()

CacheRefreshConfiguration org.gluu.oxtrust.config.ConfigurationFactory.getCacheRefreshConfiguration ( )

inline

                                                                        {
                return cacheRefreshConfiguration;
        }

getConfigurationDn()

String org.gluu.oxtrust.config.ConfigurationFactory.getConfigurationDn ( )

inline

                                           {
        return this.persistenceConfiguration.getConfiguration().getString("oxtrust_ConfigurationEntryDN");
    }

getCryptoConfigurationSalt()

String org.gluu.oxtrust.config.ConfigurationFactory.getCryptoConfigurationSalt ( )

inline

                                                   {
                return cryptoConfigurationSalt;
        }

getIDPTemplatesLocation()

String org.gluu.oxtrust.config.ConfigurationFactory.getIDPTemplatesLocation ( )

inline

                                                {
                String jetyBase = System.getProperty("jetty.base");

                if (StringHelper.isEmpty(jetyBase)) {
                        return ConfigurationFactory.DIR;
                }

                return jetyBase + File.separator + "conf" + File.separator;
        }

getImportPersonConfig()

ImportPersonConfig org.gluu.oxtrust.config.ConfigurationFactory.getImportPersonConfig ( )

inline

                                                          {
                return importPersonConfig;
        }

getLdapCentralConfiguration()

FileConfiguration org.gluu.oxtrust.config.ConfigurationFactory.getLdapCentralConfiguration ( )

inline

                                                               {
                return ldapCentralConfiguration;
        }

getPersistenceConfiguration()

PersistenceConfiguration org.gluu.oxtrust.config.ConfigurationFactory.getPersistenceConfiguration ( )

inline

                                                                  {
        return persistenceConfiguration;
    }

init() [1/2]

void org.gluu.oxtrust.config.ConfigurationFactory.init ( )

inline

                           {
                this.isActive = new AtomicBoolean(true);
                try {
                        log.info("Creating oxTrustConfiguration");
                        this.persistenceConfiguration = loadPersistenceConfiguration();
                        loadLdapCentralConfiguration();
                        this.confDir = confDir();

                        this.configFilePath = confDir + APPLICATION_CONFIGURATION;
                        this.cacheRefreshFilePath = confDir + CACHE_PROPERTIES_FILE;
                        this.logRotationFilePath = confDir + LOG_ROTATION_CONFIGURATION;
                        this.saltFilePath = confDir + SALT_FILE_NAME;

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

init() [2/2]

void org.gluu.oxtrust.config.ConfigurationFactory.init ( LdapOxTrustConfiguration  conf )

inlineprivate

                                                         {
                this.appConfiguration = conf.getApplication();
                this.cacheRefreshConfiguration = conf.getCacheRefresh();
                this.importPersonConfig = conf.getImportPersonConfig();
                this.attributeResolverConfiguration = conf.getAttributeResolverConfig();
                this.loadedRevision = conf.getRevision();
        }

initTimer()

void org.gluu.oxtrust.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));
        }

loadAppConfFromFile()

AppConfiguration org.gluu.oxtrust.config.ConfigurationFactory.loadAppConfFromFile ( )

inlineprivate

                                                       {
                try {
                        String jsonConfig = FileUtils.readFileToString(new File(configFilePath));
                        AppConfiguration appConfiguration = jsonService.jsonToObject(jsonConfig, AppConfiguration.class);

                        return appConfiguration;
                } catch (Exception ex) {
                        log.error("Failed to load configuration from {}", configFilePath, ex);
                }

                return null;
        }

loadConfigurationFromLdap()

LdapOxTrustConfiguration org.gluu.oxtrust.config.ConfigurationFactory.loadConfigurationFromLdap ( String...  returnAttributes )

inline

                                                                                              {
                final PersistenceEntryManager ldapEntryManager = persistenceEntryManagerInstance.get();
                final String configurationDn = getConfigurationDn();
                try {
                        final LdapOxTrustConfiguration conf = ldapEntryManager.find(LdapOxTrustConfiguration.class, configurationDn,
                                        returnAttributes);

                        return conf;
                } catch (BasePersistenceException ex) {
                        log.error("Failed to load configuration from LDAP", ex);
                }

                return null;
        }

loadCryptoConfigurationSalt()

void org.gluu.oxtrust.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 {}", this.saltFilePath, ex);
                        throw new ConfigurationException("Failed to load configuration from " + this.saltFilePath, ex);
                }
        }

loadLdapCentralConfiguration()

void org.gluu.oxtrust.config.ConfigurationFactory.loadLdapCentralConfiguration ( )

inlineprivate

                                                    {
                this.ldapCentralConfiguration = createFileConfiguration(LDAP_CENTRAL_PROPERTIES_FILE, false);

                File ldapCentralFile = new File(LDAP_CENTRAL_PROPERTIES_FILE);
                if (ldapCentralFile.exists()) {
                        this.ldapCentralFileLastModifiedTime = ldapCentralFile.lastModified();
                }
        }

loadLdapConfiguration()

PersistenceConfiguration org.gluu.oxtrust.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.gluu.oxtrust.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.gluu.oxtrust.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;
    }

reloadAppConfFromFile()

boolean org.gluu.oxtrust.config.ConfigurationFactory.reloadAppConfFromFile ( )

inlineprivate

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

                return false;
        }

reloadConfiguration()

void org.gluu.oxtrust.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);
            }
        }

                // Reload LDAP central configuration if needed
                File ldapCentralFile = new File(LDAP_CENTRAL_PROPERTIES_FILE);
                if (ldapCentralFile.exists()) {
                        final long lastModified = ldapCentralFile.lastModified();
                        if (lastModified > ldapCentralFileLastModifiedTime) {
                                // Reload configuration only if it was modified
                                loadLdapCentralConfiguration();
                                event.select(LdapCentralConfigurationReload.Literal.INSTANCE)
                                                .fire(PERSISTENCE_CENTRAL_CONFIGUARION_RELOAD_EVENT_TYPE);
                        }
                } else if (this.ldapCentralConfiguration != null) {
                        // Allow to remove not mandatory configuration file
                        this.ldapCentralConfiguration = null;
                        event.select(LdapCentralConfigurationReload.Literal.INSTANCE)
                                        .fire(PERSISTENCE_CENTRAL_CONFIGUARION_RELOAD_EVENT_TYPE);
                }

                if (!loadedFromLdap) {
                        return;
                }

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

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

                createFromLdap(false);
        }

reloadConfigurationTimerEvent()

void org.gluu.oxtrust.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);
                }
        }

replaceWithSystemValues()

void org.gluu.oxtrust.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));
            }
        }
    }

メンバ詳解

appConfiguration

AppConfiguration org.gluu.oxtrust.config.ConfigurationFactory.appConfiguration

private

APPLICATION_CONFIGURATION

final String org.gluu.oxtrust.config.ConfigurationFactory.APPLICATION_CONFIGURATION = "oxtrust-config.json"

static

attributeResolverConfiguration

AttributeResolverConfiguration org.gluu.oxtrust.config.ConfigurationFactory.attributeResolverConfiguration

private

BASE_DIR

final String org.gluu.oxtrust.config.ConfigurationFactory.BASE_DIR

static

CACHE_PROPERTIES_FILE

final String org.gluu.oxtrust.config.ConfigurationFactory.CACHE_PROPERTIES_FILE = "oxTrustCacheRefresh.properties"

static

cacheRefreshConfiguration

CacheRefreshConfiguration org.gluu.oxtrust.config.ConfigurationFactory.cacheRefreshConfiguration

private

cacheRefreshFilePath

String org.gluu.oxtrust.config.ConfigurationFactory.cacheRefreshFilePath

package

confDir

String org.gluu.oxtrust.config.ConfigurationFactory.confDir

private

configFilePath

String org.gluu.oxtrust.config.ConfigurationFactory.configFilePath

package

configurationInstance

Instance<Configuration> org.gluu.oxtrust.config.ConfigurationFactory.configurationInstance

private

configurationUpdateEvent

Event<AppConfiguration> org.gluu.oxtrust.config.ConfigurationFactory.configurationUpdateEvent

private

cryptoConfigurationSalt

String org.gluu.oxtrust.config.ConfigurationFactory.cryptoConfigurationSalt

private

DEFAULT_INTERVAL

final int org.gluu.oxtrust.config.ConfigurationFactory.DEFAULT_INTERVAL = 30

staticprivate

DIR

final String org.gluu.oxtrust.config.ConfigurationFactory.DIR = BASE_DIR + File.separator + "conf" + File.separator

static

event

Event<String> org.gluu.oxtrust.config.ConfigurationFactory.event

private

GLUU_FILE_PATH

final String org.gluu.oxtrust.config.ConfigurationFactory.GLUU_FILE_PATH = DIR + "gluu.properties"

staticprivate

importPersonConfig

ImportPersonConfig org.gluu.oxtrust.config.ConfigurationFactory.importPersonConfig

private

isActive

AtomicBoolean org.gluu.oxtrust.config.ConfigurationFactory.isActive

private

jsonService

JsonService org.gluu.oxtrust.config.ConfigurationFactory.jsonService

private

LDAP_CENTRAL_PROPERTIES_FILE

final String org.gluu.oxtrust.config.ConfigurationFactory.LDAP_CENTRAL_PROPERTIES_FILE = DIR + "oxtrust-central-ldap.properties"

static

LDAP_DEFAULT_PROPERTIES_FILE

final String org.gluu.oxtrust.config.ConfigurationFactory.LDAP_DEFAULT_PROPERTIES_FILE = DIR + "ox-ldap.properties"

static

LDAP_PROPERTIES_FILE

final String org.gluu.oxtrust.config.ConfigurationFactory.LDAP_PROPERTIES_FILE = DIR + "oxtrust-ldap.properties"

static

ldapCentralConfiguration

FileConfiguration org.gluu.oxtrust.config.ConfigurationFactory.ldapCentralConfiguration

private

ldapCentralFileLastModifiedTime

long org.gluu.oxtrust.config.ConfigurationFactory.ldapCentralFileLastModifiedTime = -1

private

loaded

boolean org.gluu.oxtrust.config.ConfigurationFactory.loaded = false

private

loadedFromLdap

boolean org.gluu.oxtrust.config.ConfigurationFactory.loadedFromLdap = true

private

loadedRevision

long org.gluu.oxtrust.config.ConfigurationFactory.loadedRevision = -1

private

log

Logger org.gluu.oxtrust.config.ConfigurationFactory.log

private

LOG_ROTATION_CONFIGURATION

final String org.gluu.oxtrust.config.ConfigurationFactory.LOG_ROTATION_CONFIGURATION = "oxTrustLogRotationConfiguration.xml"

static

logRotationFilePath

String org.gluu.oxtrust.config.ConfigurationFactory.logRotationFilePath

package

PERSISTENCE_CENTRAL_CONFIGUARION_RELOAD_EVENT_TYPE

final String org.gluu.oxtrust.config.ConfigurationFactory.PERSISTENCE_CENTRAL_CONFIGUARION_RELOAD_EVENT_TYPE = "persistenceCentralConfigurationReloadEvent"

static

PERSISTENCE_CONFIGUARION_RELOAD_EVENT_TYPE

final String org.gluu.oxtrust.config.ConfigurationFactory.PERSISTENCE_CONFIGUARION_RELOAD_EVENT_TYPE = "persistenceConfigurationReloadEvent"

static

persistenceConfiguration

PersistenceConfiguration org.gluu.oxtrust.config.ConfigurationFactory.persistenceConfiguration

private

persistenceEntryManagerFactoryInstance

Instance<PersistenceEntryManagerFactory> org.gluu.oxtrust.config.ConfigurationFactory.persistenceEntryManagerFactoryInstance

private

persistenceEntryManagerInstance

Instance<PersistenceEntryManager> org.gluu.oxtrust.config.ConfigurationFactory.persistenceEntryManagerInstance

private

SALT_FILE_NAME

final String org.gluu.oxtrust.config.ConfigurationFactory.SALT_FILE_NAME = "salt"

static

saltFilePath

String org.gluu.oxtrust.config.ConfigurationFactory.saltFilePath

package

timerEvent

Event<TimerEvent> org.gluu.oxtrust.config.ConfigurationFactory.timerEvent

private

---

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

• D:/AppData/OpenId/gluu/src/oxTrust/server/src/main/java/org/gluu/oxtrust/config/ConfigurationFactory.java