/**
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 2006 Sun Microsystems Inc. All Rights Reserved
*
* The contents of this file are subject to the terms
* of the Common Development and Distribution License
* (the License). You may not use this file except in
* compliance with the License.
*
* You can obtain a copy of the License at
* See the License for the specific language governing
* permission and limitations under the License.
*
* When distributing Covered Code, include this CDDL
* Header Notice in each file and include the License file
* at opensso/legal/CDDLv1.0.txt.
* If applicable, add the following below the CDDL Header,
* with the fields enclosed by brackets [] replaced by
* your own identifying information:
* "Portions Copyrighted [year] [name of copyright owner]"
*
* $Id: AgentConfiguration.java,v 1.39 2009/04/02 00:02:11 leiming Exp $
*
*/
/*
* Portions Copyrighted 2010-2013 ForgeRock AS.
*/
/**
* <p>
* Provides access to the configuration as set in the system.
* </p><p>
* It uses the agent bootstrap configuration file called
* OpenSSOAgentBootstrap.properties to get the agent startup configuration that
* includes the OpenSSO (OpenSSO) server information and the
* agent user credential. It uses these information to authenticate to
* the OpenSSO server. The OpenSSO Authentication service completes the agent
* authentication and sends a SSO token back to the agent. Using the SSO
* token, the agent calls the OpenSSO Attribute service to fetch its
* configuration. The OpenSSO Attribute service sends the agent configuration
* back to the agent. The agent configuration returned contains the agent
* configuration repository location. If the location is "centralized",
* then agent will use the agent configuration just returned. If the
* location is "local" or not present, then the agent knows that its
* configuration is at the local. It reads the rest of its configuration
* from the local configuration file OpenSSOAgentConfiguration.properties.
* </p><p>
* Most of the agent configuration properties are hot swappable. The
* changes to these properties are effective without having to restart
* the agent container. The property changes are updated at the agent
* in two ways. The agent configuration change notification and agent
* configuration change polling.
* </p><p>
* The agent configuration change notification is available in the case
* of the agent configuration is centralized. Anytime one or more agent
* properties are changed in the OpenSSO, a notification is sent to the agent.
* Upon receiving the notification, the affected agent will refetch its
* from the OpenSSO server and updates its configuration using the new values.
* </p><p>
* Configuration polling updates are available if the configuration setting
* <code>com.sun.identity.agents.j2ee.config.load.interval</code> has been set
* to a non-zero positive value indicating the number of seconds after which
* the system will poll to identify configuration changes. If this value is set
* to zero, the configuration reloads will be disabled. Every time a
* configuration reload occurs, the value of the configuration setting that
* governs the reload interval is also recalculated, thereby making it possible
* to dynamically disable reloads by setting the value to zero when reloads are
* active. Note that in the event of a reload, only the configuration keys that
* are designated for Agent operation are reloaded. These keys begin with the
* <code>com.sun.identity.agents.config</code> prefix. The keys that do
* not match this criteria are kept unchanged and reflect the values that were
* present during system initialization. Certain keys which meet this crieteria
* would still not be reloaded due to potential security concerns associated
* with the swapping of the associated values.
* </p><p>
* General access methods in this class are package protected and thus cannot
* be directly invoked by classes that are not within the same package. It is
* expected and required that all configuration access be done via a designated
* <code>Manager</code> of the subsystem which in turn acts as an intermediate
* caching point for configuration values. Public methods are available for
* configuration settings that are considered core settings.
* </p>
*
* @see com.sun.identity.agents.arch.Manager
* @see com.sun.identity.agents.arch.IConfigurationListener
*/
public class AgentConfiguration implements
{
/**
* A constant value used to identify the default web application context
* for configuration settings that are application specific.
*/
/**
* Returns a header name that contains the client IP address. If no header
* name is specified in the configuration file, this method will return
* <code>null</code>.
*
* @return a header name that contains client IP address or <code>null</code>
* if no header name is specified.
*/
return _clientIPAddressHeader;
}
/**
* Returns a header name that contains the client hostname. If no header
* name is specified in the configuration file, this method will return
* <code>null</code>.
*
* @return a header name that contains client hostname or <code>null</code>
* if no header name is specified.
*/
return _clientHostNameHeader;
}
/**
* Returns the name of the organization that can be used for authenticating
* the Agent services. This value represents the organization name or the
* realm name to which the Agent profile belongs.
*
* @return the organization or realm name to which the Agent profile belongs.
*/
return _organizationName;
}
return getProperty("com.iplanet.am.server.host");
}
return getProperty("com.iplanet.am.server.port");
}
return getProperty("com.iplanet.am.server.protocol");
}
return _policyAdminLoc;
}
/**
* Returns a boolean indicating if the notifications for Policy changes
* have been set as enabled.
* @return <code>true</code> if notifications for Policy are enabled,
* <code>false</code> otherwise.
*/
public static boolean isPolicyNotificationEnabled() {
return _policyNotificationEnabledFlag;
}
/**
* Returns the URL that will be used by the Server to send all
* notifications to agents. This will include policy, session, and agent
* configuration change notifications.
* @return the client notification URL.
*/
return _clientNotificationURL;
}
/**
* Returns a boolean indicating if the notificatiosn for Sessino changes have
* been set as enabled.
*
* @return <code>true</code> if notifications for Session are enabled,
* <code>false</code> otherwise.
*/
public static boolean isSessionNotificationEnabled() {
return _sessionNotificationEnabledFlag;
}
/**
* Returns the name of the OpenSSO Session property that is used by
* the Agent runtime to identify the user-id of the current user.
*
* @return the Session property name that identifies the user-id of the
* current user.
*/
return _userIdPropertyName;
}
/**
* A method that ensures that any class that directly depends
* upon Client SDK can first initialize the <code>AgentConfiguration</code>.
* Failing to initialize the <code>AgentConfiguration</code> can result
* in the malfunction of the Client SDK due to configuration dependancies.
*/
public static void initialize() {
// No processing requried
}
/**
* Returns the name of the cookie or URI parameter that holds the users
* SSO token.
*
* @return the SSO token cookie or parameter name.
*/
return _ssoTokenCookieName;
}
/**
* Returns the <code>ServiceResolver</code> instance associated with the
* Agent runtime.
* @return the configured <code>ServiceResolver</code>.
*/
return _serviceResolver;
}
/**
* Returns the <code>UserMapingMode</code> configured in the system. This
* setting is not hot-swappable and is initialized during system
* initialization and never changed thereafter.
*
* @return the configured <code>UserMappingMode</code>.
*/
return _userMappingMode;
}
/**
* Returns the <code>AuditLogMode</code> configured in the system. This
* setting is not hot-swappable and is initialized during system
* initialization and never changed thereafeter.
*
* @return the configured <code>AuditLogMode</code>.
*/
return _auditLogMode;
}
/**
* Returns the user attribute value configured in the system. This setting
* is not hot-swappable and is initialized during system initialization and
* never changed thereafter.
*
* @return the configured user attribute value.
*/
return _userAttributeName;
}
/**
* Returns <code>true</code> if the runtime is configured to use the user's
* <code>DN</code> instead of the regular <code>userid</code> for
* identification purposes. This setting is not hot-swappable and is
* initialized during system initialization and never changed thereafter.
*
* @return <code>true</code> if the system is configured to use the user's
* <code>DN</code> for identification purposes, <code>false</code> otherwise.
*/
public static boolean isUserPrincipalEnabled() {
return _userPrincipalEnabled;
}
/**
* Allows other parts of the subsystem to register for configuration
* change events by registering the specified
* <code>IConfigurationListener</code>.
*
* @param listener the <code>IConfigurationListener</code> to be registered.
*/
public static void addConfigurationListener(
if(isLogMessageEnabled()) {
logMessage("AgentConfiguration: Adding listener for : "
}
synchronized(configurationListeners) {
}
}
/**
* Returns the application user name to be used to identify the Agent
* runtime.
*
* @return the application user name.
*/
return _applicationUser;
}
/**
* Returns the application password to be used to identify the Agent
* runtime.
*
* @return the application password.
*/
return _applicationPassword;
}
/**
* Would be called by agent configuration notification handler when the
* agent housekeeping app receives configuration update notifications from
* the OpenSSO server
*/
public static void updatePropertiesUponNotification() {
if(isAgentConfigurationRemote()) {
hotSwapAgentConfiguration(true);
if (isLogMessageEnabled()) {
"AgentConfiguration.updatePropertiesUponNotification():" +
" updating configuration from a notification while" +
" in centralized mode.");
}
} else {
if (isLogMessageEnabled()) {
"AgentConfiguration.updatePropertiesUponNotification():" +
" caller trying to update configuration from a" +
" notification while in local mode." +
" Should only be called when in centralized mode.");
}
}
}
/**
* Returns the configuration value corresponding to the specified
* <code>id</code> or the supplied <code>defaultValue</code> if not
* present.
*
* @param id the configuration key to be looked up.
* @param defaultValue the default value to be used in case no configuration
* is specified for the given <code>id</code>.
*
* @return the associated configuration value with the specified
* <code>id</code> or the <code>defaultValue</code> if no value is specified
* in the configuration.
*/
}
return value;
}
/**
* Returns the configuration value corresponding to the specified
* <code>id</code> or <code>null</code> if no value is present.
*
* @param id the configuration key to be looked up.
*
* @return the associated configuration value with the specified
* <code>id</code> or <code>null</code> if no value is specified in the
* configuration.
*/
}
}
return result;
}
/**
* Returns a <code>Properties</code> instance that holds all the available
* configuration as available in the system.
*
* @return the configuration as a <code>Properties</code> instance.
*/
}
return result;
}
}
return properties;
}
/*
* This method will check for the JVM option:
*
* <code>openam.agents.bootstrap.dir</code>
*
* before falling back to trying to load the file from the CLASSPATH
*/
private static synchronized void setConfigurationFilePath() {
if (!isInitialized()) {
// try to load the bootstrap from the JVM option
if (bootstrapDir != null) {
return;
}
}
// fallback to loading the bootstrap file from the classpath
}
}
throw new RuntimeException(
"Failed to get configuration file:" + CONFIG_FILE_NAME);
}
try {
}
throw new RuntimeException(
"Failed to get absolute file path:" + CONFIG_FILE_NAME);
}
throw new RuntimeException(
"Failed to get configuration file:" + CONFIG_FILE_NAME);
}
if (index < 0) {
throw new RuntimeException(
"Failed to find the agent bootstrap file:" + CONFIG_FILE_NAME);
}
}
}
/*
* Is file valid @param filename
*
* @return boolean
*/
boolean result = false;
result = true;
}
}
return result;
}
/**
* Load from OpenSSOAgentBootstrap.properties for start up properties.
* This method should only be called once at start up time
* since bootstrap properties are not hot swappable by editing the
* properties file without a restart.
* If it is called more than once(already initialized, then it will just
* return the bootstrap properties that were read and saved at start
* up time.
**/
throws Exception {
if (!isInitialized()) {
try {
instream = new BufferedInputStream(
new FileInputStream(getConfigFilePath()));
throw ex;
} finally {
try {
// No handling required
}
}
}
} else { //already initialized
//this is to enforce that coders do not accidently try to re-read
//the agents bootstrap configuration file. If already initialized
//then will return the original set of bootstrap properties
}
return result;
}
throws AgentException {
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration: Centralized agent properties ="
+ result);
}
return result;
}
throws AgentException {
try {
instream = new BufferedInputStream(
new FileInputStream(getLocalConfigFilePath()));
throw new AgentException(ex);
} finally {
try {
// No handling required
}
}
}
if (isLogMessageEnabled()) {
}
return result;
}
if (isLogMessageEnabled()) {
}
}
if (_appSSOToken != null) {
try {
// check if token is still valid with the session server.
// This refreshSession call throws a SSOException if the token
// is not valid any more.
} catch (SSOException se) {
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration.getAppSSOToken: " +
"The app SSO token is invalid, indicating openam " +
"server may have restarted, so need to " +
"reauthenticate to get a new app SSO token");
}
}
} else {
}
return _appSSOToken;
}
if (_attributeServiceURLs == null) {
try {
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration: attribute service urls"
}
} catch (URLNotFoundException ue) {
throw new AgentException(ue);
}
}
return _attributeServiceURLs;
}
/**
* Collect all configuration info. Store all config properties, including
* OpenSSOAgentBootstrap.properties bootstrap small set of props and also
* agent config props (from OpenSSO server or if local config file
* OpenSSOAgentConfiguration.properties) and store ALL the properties in a
* class field for later use, plus set a few fields on this class for some
* props that are used throughout agent code and accessed from this class.
* Also, for any clientsdk properties, push them into the JVM system
* properties so they can be accessed by clientsdk.
* All non-system properties start with AGENT_CONFIG_PREFIX and this is how
* we distinguish between agent properties and clientsdk properties.
* Note, a few clientsdk props (like notification url and notification
* enable flags) are ALSO stored by this class in fields since
* they are also use throughout agent code as well as by clientsdk.
*/
private static synchronized void bootStrapClientConfiguration() {
if (!isInitialized()) {
try {
sysPropertyMap = new HashMap();
properties.clear();
//debug level can optionally be set in OpenSSOAgentBootstrap.properties
//but by default is not set, so we provide default if no value
//This debug level(either default or prop in OpenSSOAgentBootstrap.properties)
//file is only used for bootup time logging.
//Real runtime debug level value is later retrieved with rest of
//agent config from OpenSSO server
if ((initialDebugLevel == null) ||
}
//push the bootstrap properties to JVM system properties
//save in sysPropertyMap for upcoming log messages
}
}
//app sso token provider plugin property and value are not
//exposed to users so not in bootstrap property file
// instantiate the instance of DebugPropertiesObserver
//if OpenSSO server 8.0
if (attrServiceURLs != null) {
//if agent profile on OpenSSO server is 2.2 style(null or
//blank value)-maybe to help agent upgrade use case)
//OR agent profile is 3.0 style(common case) with local
//config flag set
if ((agentConfigLocation == null)
AGENT_CONFIG_LOCAL))) {
} else if (agentConfigLocation.equalsIgnoreCase(
} else {
throw new AgentException("Invalid agent config"
+ "location: does not specify local or centralized");
}
} else { //else if Access Manager 7.1/7.0 server
// Need to read the rest of agent config from its local
// configuration file
}
//save in sysPropertyMap for upcoming log messages
}
}
// notify possible debug level change
if (debugObserver != null) {
}
//used by agentsdk and clientsdk, not hot swappable
try {
} catch (NumberFormatException nfex) {
"AgentConfiguration: Exception while reading "
}
markCurrent();
throw new RuntimeException("Failed to load configuration: "
+ ex.getMessage());
}
if (isLogMessageEnabled()) {
if (sysPropertyMap != null) {
"AgentConfiguration: The following properties "
+ "were added to system: " + sysPropertyMap);
} else {
"AgentConfiguration: No properties were added "
+ " to system.");
}
logMessage("AgentConfiguration: Mod Interval is set to: "
+ getModInterval() + " ms.");
}
//Start the Configuration Monitor if necessary
if (!getLockConfig()) {
}
}
}
/**
* Registers the agent config notification handler with PLLClient. The
* handler is registered once and exists for continuous hot swaps if an
* agent is configured to enable agent configuration updates from the OpenSSO
* server. The handler is used by notification filter task handler when
* the filter receives agent configuration XML notifications. This method
* only needs to be called once when the agent boots up and initializes.
*/
private static void registerAgentNotificationHandler () {
try {
handler);
if (isLogMessageEnabled()) {
"AgentConfiguration.registerAgentNotificationHandler():" +
" registered handler for accepting agent configuration" +
" notifications while in centralized mode.");
}
} catch (AlreadyRegisteredException arex) {
//should only be one handler per VM since static & global
//so probably will never happen
if(isLogWarningEnabled()){
logWarning("AgentConfiguration.registerAgentNotificationHandler" +
" Tried to register the AgentConfigNotificationHandler" +
" with PLL Client but PLL client already has it" +
" registered." , arex );
}
}
}
private static synchronized void setServiceResolver() {
if (!isInitialized()) {
try {
if (isLogMessageEnabled()) {
"AgentConfiguration: service resolver set to: "
}
if (isLogMessageEnabled()) {
"AgentConfiguration: service resolver reports "
+ "EJBContext available: "
}
"AgentConfiguration: Failed to set Service Resolver: "
throw new RuntimeException(
"Failed to set Service Resolver: "
+ serviceResolverClassName + ": "
+ ex.getMessage());
}
}
}
private static synchronized void setOrganizationName() {
if (!isInitialized()) {
if (_organizationName == null ||
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration.setOrganizationName:"
+ " organization name for realm is not set in the"
+ " agent bootstrap file, so using the default"
+ " root realm = "
}
} else {
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration.setOrganizationName:"
+ " organization name for realm is set to: "
}
}
}
}
private static synchronized void setUserMappingMode() {
throw new RuntimeException("Unknown User Mapping Mode: "
}
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration.setUserMappingMode: User Mapping"
+ " mode set to: "
+ _userMappingMode);
}
}
private static synchronized void setAuditLogMode() {
throw new RuntimeException("Unknown Audit Log Mode: "
}
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration.setAuditLogMode: Audit Log mode"
+ " set to: "
+ _auditLogMode);
}
}
private static synchronized void setUserAttributeName() {
if (userAttributeName == null ||
logError("AgentConfiguation.setUserAttributeName: Unable to load"
+ " user attribute name. Using default value: "
}
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration.setUserAttributeName: User"
+ " attribute name set to: "
}
}
private static synchronized void setUserPrincipalEnabledFlag() {
if (userPrinsipalFlagString == null ||
}
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration.setUserPrincipalEnabledFlag: use-DN"
+ " User Principal Enabled Flag is set to: "
}
}
private static synchronized void setSSOTokenName() {
if (!isInitialized()) {
if (_ssoTokenCookieName == null ||
throw new RuntimeException("Invalid SSO Cookie name set");
}
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration: SSO Token name set to: "
}
}
}
private static synchronized void setPolicyAdminLoc() {
if (!isInitialized()) {
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration: Policy Admin Location: "
+ _policyAdminLoc);
}
}
}
private static synchronized void setApplicationUser() {
if (!isInitialized()) {
{
throw new RuntimeException(
"Invalid application user specified");
}
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration: Application User: "
+ _applicationUser);
}
}
}
private static synchronized void setApplicationPassword() {
if (!isInitialized()) {
try {
}
logError("AgentConfiguration: Unable to create new instance of "
+ "Crypt class with exception ", ex);
}
if (_applicationPassword == null ||
throw new RuntimeException(
"Invalid application password specified");
}
}
}
private static synchronized void setProfileName() {
if (!isInitialized()) {
}
if (isLogMessageEnabled()) {
}
}
}
private static synchronized void setUserIdPropertyName() {
if (isLogWarningEnabled()) {
logWarning("AgentConfiguration.setUserIdPropertyName: No value"
+ " specified for user id property name. Using default: "
+ propertyName);
}
}
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration.setUserIdPropertyName: User id"
+ " property name set to: "
}
}
//this property is a hot swappable ClientSDK property
private static synchronized void setSessionNotificationEnabledFlag() {
_sessionNotificationEnabledFlag = true;
boolean pollingEnabled = false;
}
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration: Session notification enable: "
}
}
//this property is used by both the agentsdk code and also the clientsdk
private static synchronized void setClientNotificationURL() {
if (!isInitialized()) {
} else {
if (isLogWarningEnabled()) {
"AgentConfiguration: No client notification URL set");
}
}
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration: Client notification URL: "
}
}
}
//this property is a hot swappable ClientSDK property
private static synchronized void setPolicyNotificationEnabledFlag() {
boolean enable = false;
}
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration: Policy notification enable: "
}
}
private static synchronized void setClientIPAddressHeader() {
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration.setClientIPAddressHeader:"
+ " Client IP Address Header: "
}
}
private static synchronized void setClientHostNameHeader() {
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration.setClientHostNameHeader: Client"
+ " Hostname Header: "
}
}
private static synchronized void initializeConfiguration() {
if (!isInitialized()) {
//read in all properties, save all props & values in map to use
//later and push some to system for clientsdk
//now set some class fields with property values
//set fields as some clientsdk props also used by agent code
logAgentEnv();
}
}
/**
* Logs the version information for the running agent.
*/
private static void logAgentVersion() {
}
/**
* Logs some of the system env information for the running agent.
*/
private static void logAgentEnv() {
if (isLogMessageEnabled()) {
logMessage("Agent Env information:");
}
}
/**
* Logs the version of OpenSSO Server.
*/
private static void logServerVersion() {
try {
getDebug());
version = "Access Manager 7.x Server";
}
} catch (AgentException ex) {
}
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration.logServerVersion() - \n\n" +
"------------------------------------------------\n" +
"------------------------------------------------\n");
}
}
/**
* Some properties managed by this class are hotswappable and should be
* set on initialization and reload of configuration property values
*/
private static void setHotSwappableConfigProps() {
}
/**
* some of clientSDK props are hot-swappable and are used by clientSDK thru
* SystemProperties helper class and are ALSO used by agent code and hence
* we store their current values in some fields.
*/
private static void setHotSwappableClientSDKProps() {
}
}
}
}
}
}
}
private static boolean isLogWarningEnabled() {
return getDebug().warningEnabled();
}
private static boolean isLogMessageEnabled() {
return getDebug().messageEnabled();
}
private static void updatePropertiesUponPolling() {
if (needToRefresh()) {
if (!isAgentConfigurationRemote()) {
if (!configFile.exists()) {
}
markCurrent();
return;
}
}
hotSwapAgentConfiguration(false);
}
}
// if lock config is enabled, there will be no config change.
if (getLockConfig()) {
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration.hotSwapAgentConfiguration() - " +
"Agent config is locked, there's no config update.");
}
return;
}
if (loadProperties(fromNotification)) {
// notify possible debug level change
if (debugObserver != null) {
}
}
}
private static void notifyModuleConfigurationListeners() {
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration: Notifying all listeners");
}
synchronized(configurationListeners) {
if(isLogMessageEnabled()) {
logMessage("AgentConfiguration: Notified listener for "
+ nextListener.getName());
}
}
}
}
private synchronized static boolean loadProperties(
boolean fromNotification) {
boolean result = false;
try {
properties.clear();
//add in bootstrap properties which were saved on
//agent initial start up
if (!isAgentConfigurationRemote()) {
} else {
}
// check and return if notification.enabled is false.
if (fromNotification &&
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration: received config " +
"notification, but no update " +
"since notification enabled is false");
}
return false;
}
if (isLogMessageEnabled()) {
}
if (modIntervalString != null &&
} else {
logWarning("AgentConfiguration: No mod interval setting found");
modIntervalString = "0";
}
long modInterval = 0L;
try {
} catch (NumberFormatException nfex) {
logWarning("AgentConfiguration: Exception while reading "
}
return false;
}
getProperties().clear();
markCurrent();
}
}
//set local copies of config property values stored by this class
//set local copies of some clientsdk property values we store
result = true;
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration: loaded new configuration.");
}
result = false;
logError("AgentConfiguration: Setting reload interval to 0");
setModInterval(0L);
}
return result;
}
private static boolean needToRefresh() {
>= getModInterval());
}
public ConfigurationMonitor() {
if(isLogMessageEnabled()) {
logMessage("AgentConfiguration: Monitor initialized");
}
}
public boolean isEmpty() {
return true;
}
return false;
}
return false;
}
public long getRunPeriod() {
long interval = getModInterval();
return interval;
}
public void run() {
if(isLogMessageEnabled()) {
logMessage("AgentConfiguration: Monitor started");
}
}
}
private static boolean isInitialized() {
return _initialized;
}
private static void markInitialized() {
if (!isInitialized()) {
_initialized = true;
if (isLogMessageEnabled()) {
logMessage("AgentConfiguration: initialized.");
}
}
}
private static boolean isAgentConfigurationRemote() {
return _isAgentConfigurationRemote;
}
private static void markAgentConfigurationRemote() {
_isAgentConfigurationRemote = true;
}
return _configFilePath;
}
}
return _localConfigFilePath;
}
}
return _properties;
}
}
return _debug;
}
}
private static long getModInterval() {
return _modInterval;
}
private static long getLastLoadTime() {
return _lastLoadTime;
}
private static void markCurrent() {
}
return _moduleConfigListeners;
}
//ensure its only set once at start up, not on configuration reloads
if (!isInitialized()) {
}
}
return _bootstrapProperties;
}
private static boolean getLockConfig() {
return _lockConfig;
}
return _profileName;
}
private static void setLockConfig() {
if (!isInitialized()) {
_lockConfig = true;
}
}
}
private static boolean _isAgentConfigurationRemote = false;
private static boolean _initialized;
private static boolean _userPrincipalEnabled;
private static boolean _policyNotificationEnabledFlag;
private static boolean _sessionNotificationEnabledFlag;
private static boolean _lockConfig = false;
static {
}
}