org.xdi.oxauth.service.AppInitializer クラス

org.xdi.oxauth.service.AppInitializer 連携図

公開メンバ関数
void	createApplicationComponents ()
void	applicationInitialized (@Observes @Initialized(ApplicationScoped.class) Object init)
StringEncrypter	getStringEncrypter ()
void	initTimer ()
void	reloadConfigurationTimerEvent (@Observes @Scheduled AuthConfigurationEvent authConfigurationEvent)
PersistenceEntryManager	createPersistenceAuthEntryManager (GluuLdapConfiguration persistenceAuthConfig)
PersistenceEntryManager	createPersistenceEntryManager ()
List< GluuLdapConfiguration >	createPersistenceAuthConfigs ()
List< PersistenceEntryManager >	createPersistenceAuthEntryManager ()
void	recreatePersistenceEntryManager (@Observes @LdapConfigurationReload String event)
void	recreatePersistenceAuthEntryManagers (List< GluuLdapConfiguration > newPersistenceAuthConfigs)
AuthenticationMode	getDefaultAuthenticationMode ()
void	destroy (@Observes @BeforeDestroyed(ApplicationScoped.class) ServletContext init)

限定公開メンバ関数
void	initSchedulerService ()

非公開メンバ関数
void	reloadConfiguration ()
void	closePersistenceEntryManager (PersistenceEntryManager oldPersistenceEntryManager)
void	closePersistenceEntryManagers (List< PersistenceEntryManager > oldPersistenceEntryManagers)
List< Properties >	prepareAuthConnectionProperties (List< GluuLdapConfiguration > persistenceAuthConfigs)
Properties	prepareAuthConnectionProperties (GluuLdapConfiguration persistenceAuthConfig)
String	buildServersString (List<?> servers)
void	setDefaultAuthenticationMethod (PersistenceEntryManager localPersistenceEntryManager)
String	getActualDefaultAuthenticationMethod (PersistenceEntryManager localPersistenceEntryManager)
GluuAppliance	loadAppliance (PersistenceEntryManager localPersistenceEntryManager, String ... persistenceReturnAttributes)
List< GluuLdapConfiguration >	loadPersistenceAuthConfigs (PersistenceEntryManager localPersistenceEntryManager)
List< oxIDPAuthConf >	loadLdapIdpAuthConfigs (PersistenceEntryManager localPersistenceEntryManager)
GluuLdapConfiguration	loadPersistenceAuthConfig (oxIDPAuthConf configuration)

非公開変数類
Logger	log
BeanManager	beanManager
Event< String >	event
Event< TimerEvent >	timerEvent
Instance< PersistenceEntryManager >	persistenceEntryManagerInstance
Instance< List< PersistenceEntryManager > >	persistenceAuthEntryManagerInstance
Instance< List< GluuLdapConfiguration > >	persistenceAuthConfigInstance
ApplicationFactory	applicationFactory
Instance< AuthenticationMode >	authenticationModeInstance
Instance< EncryptionService >	encryptionServiceInstance
PythonService	pythonService
MetricService	metricService
CustomScriptManager	customScriptManager
ConfigurationFactory	configurationFactory
CleanerTimer	cleanerTimer
KeyGeneratorTimer	keyGeneratorTimer
CustomLibrariesLoader	customLibrariesLoader
LdapStatusTimer	ldapStatusTimer
QuartzSchedulerManager	quartzSchedulerManager
LoggerService	loggerService
JsonService	jsonService
AtomicBoolean	isActive
long	lastFinishedTime
AuthenticationMode	authenticationMode
List< GluuLdapConfiguration >	persistenceAuthConfigs

静的非公開変数類
static final String	EVENT_TYPE = "AppInitializerTimerEvent"
static final int	DEFAULT_INTERVAL = 30

詳解

著者

Javier Rojas Blum

Yuriy Movchan

Yuriy Zabrovarnyy

バージョン

0.1, 24/10/2011

関数詳解

applicationInitialized()

void org.xdi.oxauth.service.AppInitializer.applicationInitialized ( @Observes @Initialized(ApplicationScoped.class) Object  init )

inline

                                                                                                    {
        log.debug("Initializing application services");
        customLibrariesLoader.init();

        configurationFactory.create();

        PersistenceEntryManager localPersistenceEntryManager = persistenceEntryManagerInstance.get();
        this.persistenceAuthConfigs = loadPersistenceAuthConfigs(localPersistenceEntryManager);

        setDefaultAuthenticationMethod(localPersistenceEntryManager);

                // Initialize python interpreter
        pythonService.initPythonInterpreter(configurationFactory.getPersistenceConfiguration().getConfiguration().getString("pythonModulesDir", null));

                // Initialize script manager
        List<CustomScriptType> supportedCustomScriptTypes = Arrays.asList(CustomScriptType.PERSON_AUTHENTICATION, CustomScriptType.CONSENT_GATHERING,
                        CustomScriptType.CLIENT_REGISTRATION, CustomScriptType.ID_GENERATOR, CustomScriptType.UMA_RPT_POLICY, CustomScriptType.UMA_CLAIMS_GATHERING,
                                CustomScriptType.APPLICATION_SESSION, CustomScriptType.DYNAMIC_SCOPE);

        // Start timer
        initSchedulerService();

        // Schedule timer tasks
        metricService.initTimer();
        configurationFactory.initTimer();
        loggerService.initTimer();
        ldapStatusTimer.initTimer();
        cleanerTimer.initTimer();
        customScriptManager.initTimer(supportedCustomScriptTypes);
        keyGeneratorTimer.initTimer();
        initTimer();
        }

buildServersString()

String org.xdi.oxauth.service.AppInitializer.buildServersString ( List<?>  servers )

inlineprivate

                                                           {
                StringBuilder sb = new StringBuilder();

                if (servers == null) {
                        return sb.toString();
                }
                
                boolean first = true;
                for (Object server : servers) {
                        if (first) {
                                first = false;
                        } else {
                                sb.append(",");
                        }

                        if (server instanceof SimpleProperty) {
                                sb.append(((SimpleProperty) server).getValue());
                        } else {
                                sb.append(server);
                        }
                }

                return sb.toString();
        }

closePersistenceEntryManager()

void org.xdi.oxauth.service.AppInitializer.closePersistenceEntryManager ( PersistenceEntryManager  oldPersistenceEntryManager )

inlineprivate

                                                                                                      {
                // Close existing connections
        log.debug("Attempting to destroy {}: {}", ApplicationFactory.PERSISTENCE_ENTRY_MANAGER_NAME, oldPersistenceEntryManager);
        oldPersistenceEntryManager.destroy();
        log.debug("Destroyed {}: {}", ApplicationFactory.PERSISTENCE_ENTRY_MANAGER_NAME, oldPersistenceEntryManager);
        }

closePersistenceEntryManagers()

void org.xdi.oxauth.service.AppInitializer.closePersistenceEntryManagers ( List< PersistenceEntryManager >  oldPersistenceEntryManagers )

inlineprivate

                                                                                                              {
                // Close existing connections
                for (PersistenceEntryManager oldPersistenceEntryManager : oldPersistenceEntryManagers) {
                log.debug("Attempting to destroy {}: {}", ApplicationFactory.PERSISTENCE_AUTH_ENTRY_MANAGER_NAME, oldPersistenceEntryManager);
                        oldPersistenceEntryManager.destroy();
                log.debug("Destroyed {}: {}", ApplicationFactory.PERSISTENCE_AUTH_ENTRY_MANAGER_NAME, oldPersistenceEntryManager);
                }
        }

createApplicationComponents()

void org.xdi.oxauth.service.AppInitializer.createApplicationComponents ( )

inline

                                              {
        SecurityProviderUtility.installBCProvider();
    }

createPersistenceAuthConfigs()

List<GluuLdapConfiguration> org.xdi.oxauth.service.AppInitializer.createPersistenceAuthConfigs ( )

inline

                                                                      {
        return persistenceAuthConfigs;
    }

createPersistenceAuthEntryManager() [1/2]

PersistenceEntryManager org.xdi.oxauth.service.AppInitializer.createPersistenceAuthEntryManager ( GluuLdapConfiguration  persistenceAuthConfig )

inline

                                                                                                                      {
        Properties persistenceConnectionProperties = prepareAuthConnectionProperties(persistenceAuthConfig);

        PersistenceEntryManager persistenceAuthEntryManager = applicationFactory.getPersistenceEntryManagerFactory().createEntryManager(persistenceConnectionProperties);
            log.debug("Created custom authentication PersistenceEntryManager: {}", persistenceAuthEntryManager);

            return persistenceAuthEntryManager;
        }

createPersistenceAuthEntryManager() [2/2]

List<PersistenceEntryManager> org.xdi.oxauth.service.AppInitializer.createPersistenceAuthEntryManager ( )

inline

                                                                                 {
                List<PersistenceEntryManager> persistenceAuthEntryManagers = new ArrayList<PersistenceEntryManager>();
                if (this.persistenceAuthConfigs.size() == 0) {
                        return persistenceAuthEntryManagers;
                }

                List<Properties> persistenceAuthProperties = prepareAuthConnectionProperties(this.persistenceAuthConfigs);

                for (int i = 0; i < persistenceAuthProperties.size(); i++) {
                        PersistenceEntryManager persistenceAuthEntryManager = applicationFactory.getPersistenceEntryManagerFactory().createEntryManager(persistenceAuthProperties.get(i));
                log.debug("Created {}#{}: {}", new Object[] { ApplicationFactory.PERSISTENCE_AUTH_ENTRY_MANAGER_NAME, i, persistenceAuthEntryManager });
                
                persistenceAuthEntryManagers.add(persistenceAuthEntryManager);
                }

                return persistenceAuthEntryManagers;
        }

createPersistenceEntryManager()

PersistenceEntryManager org.xdi.oxauth.service.AppInitializer.createPersistenceEntryManager ( )

inline

                                                                   {
        PersistenceConfiguration persistenceConfiguration = this.configurationFactory.getPersistenceConfiguration();
        FileConfiguration persistenceConfig = persistenceConfiguration.getConfiguration();
        Properties connectionProperties = (Properties) persistenceConfig.getProperties();

        EncryptionService securityService = encryptionServiceInstance.get();
        Properties decryptedConnectionProperties = securityService.decryptAllProperties(connectionProperties);
        
        PersistenceEntryManager persistenceEntryManager = applicationFactory.getPersistenceEntryManagerFactory().createEntryManager(decryptedConnectionProperties); 
        log.info("Created {}: {}", new Object[] { ApplicationFactory.PERSISTENCE_ENTRY_MANAGER_NAME, persistenceEntryManager });

        return persistenceEntryManager;
    }

destroy()

void org.xdi.oxauth.service.AppInitializer.destroy ( @Observes @BeforeDestroyed(ApplicationScoped.class) ServletContext  init )

inline

                                                                                                 {
        log.info("Closing LDAP connection at server shutdown...");
        PersistenceEntryManager persistenceEntryManager = persistenceEntryManagerInstance.get();
        closePersistenceEntryManager(persistenceEntryManager);
        
        List<PersistenceEntryManager> persistenceAuthEntryManagers = persistenceAuthEntryManagerInstance.get();
        closePersistenceEntryManagers(persistenceAuthEntryManagers);
    }

getActualDefaultAuthenticationMethod()

String org.xdi.oxauth.service.AppInitializer.getActualDefaultAuthenticationMethod ( PersistenceEntryManager  localPersistenceEntryManager )

inlineprivate

                                                                                                                  {
                GluuAppliance appliance = loadAppliance(localPersistenceEntryManager, "oxAuthenticationMode");

                if (appliance == null) {
                        return null;
                }

                return appliance.getAuthenticationMode();
        }

getDefaultAuthenticationMode()

AuthenticationMode org.xdi.oxauth.service.AppInitializer.getDefaultAuthenticationMode ( )

inline

                                                                 {
                return authenticationMode;
        }

getStringEncrypter()

StringEncrypter org.xdi.oxauth.service.AppInitializer.getStringEncrypter ( )

inline

                                                    {
                String encodeSalt = configurationFactory.getCryptoConfigurationSalt();
        
        if (StringHelper.isEmpty(encodeSalt)) {
                throw new ConfigurationException("Encode salt isn't defined");
        }
        
        try {
                StringEncrypter stringEncrypter = StringEncrypter.instance(encodeSalt);
                
                return stringEncrypter;
                } catch (EncryptionException ex) {
                throw new ConfigurationException("Failed to create StringEncrypter instance");
                }
        }

initSchedulerService()

void org.xdi.oxauth.service.AppInitializer.initSchedulerService ( )

inlineprotected

                                          {
        quartzSchedulerManager.start();

        String disableScheduler = System.getProperties().getProperty("gluu.disable.scheduler");
        if ((disableScheduler != null) && Boolean.valueOf(disableScheduler)) {
            this.log.warn("Suspending Quartz Scheduler Service...");
            quartzSchedulerManager.standby();
            return;
        }
    }

initTimer()

void org.xdi.oxauth.service.AppInitializer.initTimer ( )

inline

                            {
                this.isActive = new AtomicBoolean(false);
                this.lastFinishedTime = System.currentTimeMillis();

                timerEvent.fire(new TimerEvent(new TimerSchedule(60, DEFAULT_INTERVAL), new AuthConfigurationEvent(),
                                Scheduled.Literal.INSTANCE));
    }

loadAppliance()

GluuAppliance org.xdi.oxauth.service.AppInitializer.loadAppliance ( PersistenceEntryManager  localPersistenceEntryManager, String ...  persistenceReturnAttributes  )

inlineprivate

                                                                                                                                          {
                String baseDn = configurationFactory.getBaseDn().getAppliance();
                String applianceInum = configurationFactory.getAppConfiguration().getApplianceInum();
                if (StringHelper.isEmpty(baseDn) || StringHelper.isEmpty(applianceInum)) {
                        return null;
                }

                String applianceDn = String.format("inum=%s,%s", applianceInum, baseDn);

                GluuAppliance appliance = null;
                try {
                        appliance = localPersistenceEntryManager.find(GluuAppliance.class, applianceDn, persistenceReturnAttributes);
                } catch (BasePersistenceException ex) {
                        log.error("Failed to load appliance entry from Ldap", ex);
                        return null;
                }

                return appliance;
        }

loadLdapIdpAuthConfigs()

List<oxIDPAuthConf> org.xdi.oxauth.service.AppInitializer.loadLdapIdpAuthConfigs ( PersistenceEntryManager  localPersistenceEntryManager )

inlineprivate

                                                                                                                 {
                GluuAppliance appliance = loadAppliance(localPersistenceEntryManager, "oxIDPAuthentication");

                if ((appliance == null) || (appliance.getOxIDPAuthentication() == null)) {
                        return null;
                }

                List<oxIDPAuthConf> configurations = new ArrayList<oxIDPAuthConf>();
                for (String configurationJson : appliance.getOxIDPAuthentication()) {

                        try {
                                oxIDPAuthConf configuration = jsonService.jsonToObject(configurationJson, oxIDPAuthConf.class);
                                if (configuration.getType().equalsIgnoreCase("ldap") || configuration.getType().equalsIgnoreCase("auth")) {
                                        configurations.add(configuration);
                                }
                        } catch (Exception ex) {
                                log.error("Failed to create object by json: '{}'", configurationJson, ex);
                        }
                }

                return configurations;
        }

loadPersistenceAuthConfig()

GluuLdapConfiguration org.xdi.oxauth.service.AppInitializer.loadPersistenceAuthConfig ( oxIDPAuthConf  configuration )

inlineprivate

                                                                                             {
                if (configuration == null) {
                        return null;
                }

                try {
                        if (configuration.getType().equalsIgnoreCase("auth")) {
                                return jsonService.jsonToObject(configuration.getConfig(), GluuLdapConfiguration.class);
                        }
                } catch (Exception ex) {
                        log.error("Failed to create object by oxIDPAuthConf: '{}'", configuration, ex);
                }

                return null;
        }

loadPersistenceAuthConfigs()

List<GluuLdapConfiguration> org.xdi.oxauth.service.AppInitializer.loadPersistenceAuthConfigs ( PersistenceEntryManager  localPersistenceEntryManager )

inlineprivate

                                                                                                                             {
                List<GluuLdapConfiguration> persistenceAuthConfigs = new ArrayList<GluuLdapConfiguration>();

                List<oxIDPAuthConf> persistenceIdpAuthConfigs = loadLdapIdpAuthConfigs(localPersistenceEntryManager);
                if (persistenceIdpAuthConfigs == null) {
                        return persistenceAuthConfigs;
                }

                for (oxIDPAuthConf persistenceIdpAuthConfig : persistenceIdpAuthConfigs) {
                        GluuLdapConfiguration persistenceAuthConfig = loadPersistenceAuthConfig(persistenceIdpAuthConfig);
                        if ((persistenceAuthConfig != null) && persistenceAuthConfig.isEnabled()) {
                                persistenceAuthConfigs.add(persistenceAuthConfig);
                        }
                }
                
                return persistenceAuthConfigs; 
        }

prepareAuthConnectionProperties() [1/2]

List<Properties> org.xdi.oxauth.service.AppInitializer.prepareAuthConnectionProperties ( List< GluuLdapConfiguration >  persistenceAuthConfigs )

inlineprivate

                                                                                                                 {
        List<Properties> result = new ArrayList<Properties>();

                // Prepare connection providers per LDAP authentication configuration
        for (GluuLdapConfiguration persistenceAuthConfig : persistenceAuthConfigs) {
            Properties decrypytedConnectionProperties = prepareAuthConnectionProperties(persistenceAuthConfig);

                result.add(decrypytedConnectionProperties);
        }

                return result;
    }

prepareAuthConnectionProperties() [2/2]

Properties org.xdi.oxauth.service.AppInitializer.prepareAuthConnectionProperties ( GluuLdapConfiguration  persistenceAuthConfig )

inlineprivate

                                                                                                        {
        FileConfiguration configuration = configurationFactory.getPersistenceConfiguration().getConfiguration();

                Properties properties = (Properties) configuration.getProperties().clone();
                if (persistenceAuthConfig != null) {
                    properties.setProperty("servers", buildServersString(persistenceAuthConfig.getServers()));
                    
                    String bindDn = persistenceAuthConfig.getBindDN();
                    if (StringHelper.isNotEmpty(bindDn)) {
                        properties.setProperty("bindDN", bindDn);
                                properties.setProperty("bindPassword", persistenceAuthConfig.getBindPassword());
                    }
                        properties.setProperty("useSSL", Boolean.toString(persistenceAuthConfig.isUseSSL()));
                        properties.setProperty("maxconnections", Integer.toString(persistenceAuthConfig.getMaxConnections()));
                }

                EncryptionService securityService = encryptionServiceInstance.get();
                Properties decrypytedProperties = securityService.decryptAllProperties(properties);

                return decrypytedProperties;
        }

recreatePersistenceAuthEntryManagers()

void org.xdi.oxauth.service.AppInitializer.recreatePersistenceAuthEntryManagers ( List< GluuLdapConfiguration >  newPersistenceAuthConfigs )

inline

                                                                                                            {
        // Get existing application scoped instance
                List<PersistenceEntryManager> oldPersistenceAuthEntryManagers = CdiUtil.getContextBean(beanManager,
                                new ParameterizedTypeImpl(List.class, PersistenceEntryManager.class), ApplicationFactory.PERSISTENCE_AUTH_ENTRY_MANAGER_NAME);

        // Recreate components
                this.persistenceAuthConfigs = newPersistenceAuthConfigs;
        
        // Close existing connections
        closePersistenceEntryManagers(oldPersistenceAuthEntryManagers);

                // Destroy old Ldap auth entry managers
                for (PersistenceEntryManager oldPersistenceAuthEntryManager : oldPersistenceAuthEntryManagers) {
                log.debug("Attempting to destroy {}: {}", ApplicationFactory.PERSISTENCE_AUTH_ENTRY_MANAGER_NAME, oldPersistenceAuthEntryManager);
                        oldPersistenceAuthEntryManager.destroy();
                log.debug("Destroyed {}: {}", ApplicationFactory.PERSISTENCE_AUTH_ENTRY_MANAGER_NAME, oldPersistenceAuthEntryManager);
                }
                
        // Force to create new Ldap auth entry managers bean
        List<PersistenceEntryManager> persistenceAuthEntryManagers = persistenceAuthEntryManagerInstance.get();
        persistenceAuthEntryManagerInstance.destroy(persistenceAuthEntryManagers);
        log.info("Recreated instance {}: {}", ApplicationFactory.PERSISTENCE_AUTH_ENTRY_MANAGER_NAME, persistenceAuthEntryManagers);

        // Force to create new auth configuration bean
        List<GluuLdapConfiguration> oldPersistenceAuthConfigs = persistenceAuthConfigInstance.get();
                persistenceAuthConfigInstance.destroy(oldPersistenceAuthConfigs);
    }

recreatePersistenceEntryManager()

void org.xdi.oxauth.service.AppInitializer.recreatePersistenceEntryManager ( @Observes @LdapConfigurationReload String  event )

inline

                                                                                                 {
        // Get existing application scoped instance
        PersistenceEntryManager oldPersistenceEntryManager = CdiUtil.getContextBean(beanManager, PersistenceEntryManager.class, ApplicationFactory.PERSISTENCE_ENTRY_MANAGER_NAME);

        // Close existing connections
        closePersistenceEntryManager(oldPersistenceEntryManager);

        // Force to create new bean
        PersistenceEntryManager persistenceEntryManager = persistenceEntryManagerInstance.get();
        persistenceEntryManagerInstance.destroy(persistenceEntryManager);
        log.info("Recreated instance {}: {}", ApplicationFactory.PERSISTENCE_ENTRY_MANAGER_NAME, persistenceEntryManager);
    }

reloadConfiguration()

void org.xdi.oxauth.service.AppInitializer.reloadConfiguration ( )

inlineprivate

                                           {
        PersistenceEntryManager localPersistenceEntryManager = persistenceEntryManagerInstance.get();

        log.trace("Attempting to use {}: {}", ApplicationFactory.PERSISTENCE_ENTRY_MANAGER_NAME, localPersistenceEntryManager.getOperationService());
                List<GluuLdapConfiguration> newPersistenceAuthConfigs = loadPersistenceAuthConfigs(localPersistenceEntryManager);
                
                if (!this.persistenceAuthConfigs.equals(newPersistenceAuthConfigs)) {
                        recreatePersistenceAuthEntryManagers(newPersistenceAuthConfigs);
                        this.persistenceAuthConfigs = newPersistenceAuthConfigs;

                        event.select(ReloadAuthScript.Literal.INSTANCE).fire(ExternalAuthenticationService.MODIFIED_INTERNAL_TYPES_EVENT_TYPE);
                }

                setDefaultAuthenticationMethod(localPersistenceEntryManager);
        }

reloadConfigurationTimerEvent()

void org.xdi.oxauth.service.AppInitializer.reloadConfigurationTimerEvent ( @Observes @Scheduled AuthConfigurationEvent  authConfigurationEvent )

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);
                        this.lastFinishedTime = System.currentTimeMillis();
                }
        }

setDefaultAuthenticationMethod()

void org.xdi.oxauth.service.AppInitializer.setDefaultAuthenticationMethod ( PersistenceEntryManager  localPersistenceEntryManager )

inlineprivate

                                                                                                          {
                String currentAuthMethod = null;
                if (this.authenticationMode != null) {
                        currentAuthMethod = this.authenticationMode.getName();
                }

                String actualAuthMethod = getActualDefaultAuthenticationMethod(localPersistenceEntryManager);
                
                if (!StringHelper.equals(currentAuthMethod, actualAuthMethod)) {
                        authenticationMode = null;
                        if (actualAuthMethod != null) {
                                this.authenticationMode = new AuthenticationMode(actualAuthMethod);
                        }

                        authenticationModeInstance.destroy(authenticationModeInstance.get());
                }
        }

メンバ詳解

applicationFactory

ApplicationFactory org.xdi.oxauth.service.AppInitializer.applicationFactory

private

authenticationMode

AuthenticationMode org.xdi.oxauth.service.AppInitializer.authenticationMode

private

authenticationModeInstance

Instance<AuthenticationMode> org.xdi.oxauth.service.AppInitializer.authenticationModeInstance

private

beanManager

BeanManager org.xdi.oxauth.service.AppInitializer.beanManager

private

cleanerTimer

CleanerTimer org.xdi.oxauth.service.AppInitializer.cleanerTimer

private

configurationFactory

ConfigurationFactory org.xdi.oxauth.service.AppInitializer.configurationFactory

private

customLibrariesLoader

CustomLibrariesLoader org.xdi.oxauth.service.AppInitializer.customLibrariesLoader

private

customScriptManager

CustomScriptManager org.xdi.oxauth.service.AppInitializer.customScriptManager

private

DEFAULT_INTERVAL

final int org.xdi.oxauth.service.AppInitializer.DEFAULT_INTERVAL = 30

staticprivate

encryptionServiceInstance

Instance<EncryptionService> org.xdi.oxauth.service.AppInitializer.encryptionServiceInstance

private

event

Event<String> org.xdi.oxauth.service.AppInitializer.event

private

EVENT_TYPE

final String org.xdi.oxauth.service.AppInitializer.EVENT_TYPE = "AppInitializerTimerEvent"

staticprivate

isActive

AtomicBoolean org.xdi.oxauth.service.AppInitializer.isActive

private

jsonService

JsonService org.xdi.oxauth.service.AppInitializer.jsonService

private

keyGeneratorTimer

KeyGeneratorTimer org.xdi.oxauth.service.AppInitializer.keyGeneratorTimer

private

lastFinishedTime

long org.xdi.oxauth.service.AppInitializer.lastFinishedTime

private

ldapStatusTimer

LdapStatusTimer org.xdi.oxauth.service.AppInitializer.ldapStatusTimer

private

log

Logger org.xdi.oxauth.service.AppInitializer.log

private

loggerService

LoggerService org.xdi.oxauth.service.AppInitializer.loggerService

private

metricService

MetricService org.xdi.oxauth.service.AppInitializer.metricService

private

persistenceAuthConfigInstance

Instance<List<GluuLdapConfiguration> > org.xdi.oxauth.service.AppInitializer.persistenceAuthConfigInstance

private

persistenceAuthConfigs

List<GluuLdapConfiguration> org.xdi.oxauth.service.AppInitializer.persistenceAuthConfigs

private

persistenceAuthEntryManagerInstance

Instance<List<PersistenceEntryManager> > org.xdi.oxauth.service.AppInitializer.persistenceAuthEntryManagerInstance

private

persistenceEntryManagerInstance

Instance<PersistenceEntryManager> org.xdi.oxauth.service.AppInitializer.persistenceEntryManagerInstance

private

pythonService

PythonService org.xdi.oxauth.service.AppInitializer.pythonService

private

quartzSchedulerManager

QuartzSchedulerManager org.xdi.oxauth.service.AppInitializer.quartzSchedulerManager

private

timerEvent

Event<TimerEvent> org.xdi.oxauth.service.AppInitializer.timerEvent

private

---

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

• D:/AppData/OpenId/gluu/src/oxAuth/Server/src/main/java/org/xdi/oxauth/service/AppInitializer.java