Example usage for org.apache.commons.configuration HierarchicalConfiguration containsKey

List of usage examples for org.apache.commons.configuration HierarchicalConfiguration containsKey

Introduction

In this page you can find the example usage for org.apache.commons.configuration HierarchicalConfiguration containsKey.

Prototype

public boolean containsKey(String key) 

Source Link

Document

Checks if the specified key is contained in this configuration.

Usage

From source file:com.sonicle.webtop.core.sdk.ServiceManifest.java

public ServiceManifest(HierarchicalConfiguration svcEl) throws Exception {

    String pkg = svcEl.getString("package");
    if (StringUtils.isEmpty(pkg))
        throw new Exception("Invalid value for property [package]");
    javaPackage = StringUtils.lowerCase(pkg);
    id = javaPackage;/*w  w  w. j  a va  2  s  .co  m*/

    String jspkg = svcEl.getString("jsPackage");
    if (StringUtils.isEmpty(jspkg))
        throw new Exception("Invalid value for property [jsPackage]");
    jsPackage = jspkg; // Lowercase allowed!

    String sname = svcEl.getString("shortName");
    if (StringUtils.isEmpty(sname))
        throw new Exception("Invalid value for property [shortName]");
    xid = sname;

    ServiceVersion ver = new ServiceVersion(svcEl.getString("version"));
    if (ver.isUndefined())
        throw new Exception("Invalid value for property [version]");
    version = ver;

    buildDate = StringUtils.defaultIfBlank(svcEl.getString("buildDate"), null);
    buildType = StringUtils.defaultIfBlank(svcEl.getString("buildType"), BUILD_TYPE_DEV);
    company = StringUtils.defaultIfBlank(svcEl.getString("company"), null);
    companyEmail = StringUtils.defaultIfBlank(svcEl.getString("companyEmail"), null);
    companyWebSite = StringUtils.defaultIfBlank(svcEl.getString("companyWebSite"), null);
    supportEmail = StringUtils.defaultIfBlank(svcEl.getString("supportEmail"), null);

    List<HierarchicalConfiguration> hconf = null;

    hconf = svcEl.configurationsAt("controller");
    if (!hconf.isEmpty()) {
        //if (hconf.size() != 1) throw new Exception(invalidCardinalityEx("controller", "1"));
        if (hconf.size() > 1)
            throw new Exception(invalidCardinalityEx("controller", "*1"));

        final String cn = hconf.get(0).getString("[@className]");
        if (StringUtils.isBlank(cn))
            throw new Exception(invalidAttributeValueEx("controller", "className"));
        controllerClassName = buildJavaClassName(javaPackage, cn);

    } else { // Old-style configuration
        if (svcEl.containsKey("controllerClassName")) {
            controllerClassName = LangUtils.buildClassName(javaPackage,
                    StringUtils.defaultIfEmpty(svcEl.getString("controllerClassName"), "Controller"));
        }
    }

    hconf = svcEl.configurationsAt("manager");
    if (!hconf.isEmpty()) {
        if (!hconf.isEmpty()) {
            if (hconf.size() > 1)
                throw new Exception(invalidCardinalityEx("manager", "*1"));

            final String cn = hconf.get(0).getString("[@className]");
            if (StringUtils.isBlank(cn))
                throw new Exception(invalidAttributeValueEx("manager", "className"));
            managerClassName = buildJavaClassName(javaPackage, cn);
        }

    } else { // Old-style configuration
        if (svcEl.containsKey("managerClassName")) {
            managerClassName = LangUtils.buildClassName(javaPackage,
                    StringUtils.defaultIfEmpty(svcEl.getString("managerClassName"), "Manager"));
        }
    }

    /*
    hconf = svcEl.configurationsAt("privateService");
    if (!hconf.isEmpty()) {
       if (!hconf.isEmpty()) {
    if (hconf.size() > 1) throw new Exception(invalidCardinalityEx("manager", "*1"));
            
    final String cn = hconf.get(0).getString("[@className]");
    if (StringUtils.isBlank(cn)) throw new Exception(invalidAttributeValueEx("privateService", "className"));
    final String jcn = hconf.get(0).getString("[@jsClassName]");
    if (StringUtils.isBlank(jcn)) throw new Exception(invalidAttributeValueEx("privateService", "jsClassName"));
            
    privateServiceClassName = LangUtils.buildClassName(javaPackage, cn);
    privateServiceJsClassName = jcn;
    privateServiceVarsModelJsClassName = hconf.get(0).getString("[@jsClassName]");
       }
               
    } else { // Old-style configuration
       if (svcEl.containsKey("serviceClassName")) {
    String cn = StringUtils.defaultIfEmpty(svcEl.getString("serviceClassName"), "Service");
    privateServiceClassName = LangUtils.buildClassName(javaPackage, cn);
    privateServiceJsClassName = StringUtils.defaultIfEmpty(svcEl.getString("serviceJsClassName"), cn);
    privateServiceVarsModelJsClassName = StringUtils.defaultIfEmpty(svcEl.getString("serviceVarsModelJsClassName"), "model.ServiceVars");
       }
    }
    */

    if (svcEl.containsKey("serviceClassName")) {
        String cn = StringUtils.defaultIfEmpty(svcEl.getString("serviceClassName"), "Service");
        privateServiceClassName = LangUtils.buildClassName(javaPackage, cn);
        privateServiceJsClassName = StringUtils.defaultIfEmpty(svcEl.getString("serviceJsClassName"), cn);
        privateServiceVarsModelJsClassName = StringUtils
                .defaultIfEmpty(svcEl.getString("serviceVarsModelJsClassName"), "model.ServiceVars");
    }

    if (svcEl.containsKey("publicServiceClassName")) {
        String cn = StringUtils.defaultIfEmpty(svcEl.getString("publicServiceClassName"), "PublicService");
        publicServiceClassName = LangUtils.buildClassName(javaPackage,
                StringUtils.defaultIfEmpty(svcEl.getString("publicServiceClassName"), "PublicService"));
        publicServiceJsClassName = StringUtils.defaultIfEmpty(svcEl.getString("publicServiceJsClassName"), cn);
        publicServiceVarsModelJsClassName = StringUtils.defaultIfEmpty(
                svcEl.getString("publicServiceVarsModelJsClassName"), "model.PublicServiceVars");
    }

    hconf = svcEl.configurationsAt("jobService");
    if (!hconf.isEmpty()) {
        if (hconf.size() > 1)
            throw new Exception(invalidCardinalityEx("jobService", "*1"));

        final String cn = hconf.get(0).getString("[@className]");
        if (StringUtils.isBlank(cn))
            throw new Exception(invalidAttributeValueEx("jobService", "className"));
        jobServiceClassName = LangUtils.buildClassName(javaPackage, cn);

    } else { // Old-style configuration
        if (svcEl.containsKey("jobServiceClassName")) {
            jobServiceClassName = LangUtils.buildClassName(javaPackage,
                    StringUtils.defaultIfEmpty(svcEl.getString("jobServiceClassName"), "JobService"));
        }
    }

    if (!svcEl.configurationsAt("userOptions").isEmpty()) {
        userOptionsServiceClassName = LangUtils.buildClassName(javaPackage, StringUtils
                .defaultIfEmpty(svcEl.getString("userOptions.serviceClassName"), "UserOptionsService"));
        userOptionsViewJsClassName = StringUtils.defaultIfEmpty(svcEl.getString("userOptions.viewJsClassName"),
                "view.UserOptions");
        userOptionsModelJsClassName = StringUtils
                .defaultIfEmpty(svcEl.getString("userOptions.modelJsClassName"), "model.UserOptions");
    }

    hidden = svcEl.getBoolean("hidden", false);

    hconf = svcEl.configurationsAt("restApiEndpoint");
    if (!hconf.isEmpty()) {
        for (HierarchicalConfiguration el : hconf) {
            final String name = el.getString("[@name]");
            if (StringUtils.isBlank(name))
                throw new Exception(invalidAttributeValueEx("restApiEndpoint", "name"));
            final String path = el.getString("[@path]", "");

            if (restApiEndpoints.containsKey(path))
                throw new Exception(invalidAttributeValueEx("restApiEndpoint", "path"));
            restApiEndpoints.put(path, new RestApiEndpoint(buildJavaClassName(javaPackage, name), path));
        }
    }

    if (!svcEl.configurationsAt("restApis").isEmpty()) {
        List<HierarchicalConfiguration> restApiEls = svcEl.configurationsAt("restApis.restApi");
        for (HierarchicalConfiguration el : restApiEls) {
            final String oasFile = el.getString("[@oasFile]");
            if (StringUtils.isBlank(oasFile))
                throw new Exception(invalidAttributeValueEx("restApis.restApi", "oasFile"));
            final String context = oasFileToContext(oasFile);
            final String implPackage = el.getString("[@package]", "." + JAVAPKG_REST + "." + context);

            if (restApis.containsKey(oasFile))
                throw new Exception(invalidAttributeValueEx("restApis.restApi", "oasFile"));
            //String oasFilePath = LangUtils.packageToPath(buildJavaPackage(javaPackage, "." + JAVAPKG_REST)) + "/" + oasFile;
            String oasFilePath = LangUtils.packageToPath(javaPackage) + "/" + oasFile;
            restApis.put(oasFile,
                    new RestApi(oasFilePath, context, buildJavaPackage(javaPackage, implPackage)));
        }
    }

    if (!svcEl.configurationsAt("permissions").isEmpty()) {
        List<HierarchicalConfiguration> elPerms = svcEl.configurationsAt("permissions.permission");
        for (HierarchicalConfiguration elPerm : elPerms) {
            if (elPerm.containsKey("[@group]")) {
                String groupName = elPerm.getString("[@group]");
                if (StringUtils.isEmpty(groupName))
                    throw new Exception("Permission must have a valid uppercase group name");

                if (elPerm.containsKey("[@actions]")) {
                    String[] actions = StringUtils.split(elPerm.getString("[@actions]"), ",");
                    if (actions.length == 0)
                        throw new Exception("Resource must declare at least 1 action");
                    permissions.add(new ServicePermission(groupName, actions));
                } else {
                    throw new Exception("Permission must declare actions supported on group");
                }
            }
        }

        List<HierarchicalConfiguration> elShPerms = svcEl.configurationsAt("permissions.sharePermission");
        for (HierarchicalConfiguration elShPerm : elShPerms) {
            if (elShPerm.containsKey("[@group]")) {
                String groupName = elShPerm.getString("[@group]");
                if (StringUtils.isEmpty(groupName))
                    throw new Exception("Permission must have a valid uppercase group name");
                permissions.add(new ServiceSharePermission(groupName));
            }
        }
    }

    if (!svcEl.configurationsAt("portlets").isEmpty()) {
        List<HierarchicalConfiguration> elPortlets = svcEl.configurationsAt("portlets.portlet");
        for (HierarchicalConfiguration el : elPortlets) {
            if (el.containsKey("[@jsClassName]")) {
                final String jsClassName = el.getString("[@jsClassName]");
                if (StringUtils.isBlank(jsClassName))
                    throw new Exception("Invalid value for attribute [portlet->jsClassName]");
                portlets.add(new Portlet(LangUtils.buildClassName(jsPackage, jsClassName)));
            }
        }
    }
}

From source file:edu.kit.dama.mdm.core.MetaDataManagement.java

/**
 * Load configuration from XML-File/*from   ww w.  j  a  v  a2  s  . com*/
 */
private void loadConfiguration() {
    String firstImplementation = null;
    String firstPersistenceUnit = null;
    HierarchicalConfiguration hc = null;
    List<String> persistenceUnits = null;
    URL configURL = null;
    try {
        configURL = DataManagerSettings.getConfigurationURL();
        LOGGER.debug("Loading configuration from {}", configURL);
        hc = new HierarchicalConfiguration(new XMLConfiguration(configURL));
        LOGGER.debug("Configuration successfully loaded");
    } catch (ConfigurationException ex) {
        // error in configuration
        // reason see debug log message:
        LOGGER.error("Failed to load configuration.", ex);
        throw new RuntimeException(ex);
    }
    SubnodeConfiguration configurationAt = hc.configurationAt(CONFIG_ROOT);
    List fields = configurationAt.configurationsAt(CONFIG_PERSISTENCE_IMPL);
    LOGGER.debug("Found {} configured persistence implementations", fields.size());
    persistenceUnitMap = new HashMap<>();
    persistenceClassMap = new HashMap<>();
    persistenceUnitDefaultMap = new HashMap<>();

    String implementationName;
    IPersistenceFactory iPersistenceFactory = null;
    for (Iterator it = fields.iterator(); it.hasNext();) {
        HierarchicalConfiguration sub = (HierarchicalConfiguration) it.next();
        LOGGER.debug("Reading sub-configuration");
        // First get all persistence units.
        persistenceUnits = new ArrayList<>();
        try {
            List<HierarchicalConfiguration> persistenceUnitsList = sub
                    .configurationsAt(CONFIG_PERSISTENCE_UNIT);
            if (persistenceUnitsList == null) {
                persistenceUnitsList = new LinkedList<>();
            }
            LOGGER.debug("Configuration contains {} persistence units.", persistenceUnitsList.size());
            firstPersistenceUnit = null;
            for (HierarchicalConfiguration item : persistenceUnitsList) {
                String value = item.getString(".");
                String defaultAttribute = item.getString("[@default]");

                LOGGER.debug("PersistenceUnit found: " + value);
                LOGGER.debug("@default = {}", defaultAttribute);

                if (Boolean.parseBoolean(defaultAttribute)) {
                    if (firstPersistenceUnit == null) {
                        LOGGER.debug("{} is used as default persistence unit.", value);
                        firstPersistenceUnit = value;
                    } else {
                        LOGGER.warn(
                                "{} is an additional persistence unit defined as default. We'll ignore this.",
                                value);
                    }
                }

                LOGGER.debug("Adding persistence unit to list of units.");
                persistenceUnits.add(value);
            }

        } catch (Exception any) {
            LOGGER.error("Failed to read persistence units.", any);
        }
        LOGGER.debug("firstPersistenceUnit: " + firstPersistenceUnit);
        if ((persistenceUnits.size() > 0) && (firstPersistenceUnit == null)) {
            LOGGER.debug("No default persistence unit defined. Using first entry ({})",
                    persistenceUnits.get(0));
            firstPersistenceUnit = persistenceUnits.get(0);
        }
        LOGGER.debug("Getting implementation name.");
        implementationName = sub.getString(CONFIG_PERSISTENCE_NAME);
        LOGGER.debug("Implementation name '{}' found.", implementationName);
        if (firstImplementation == null) {
            LOGGER.debug("Using implementation '{}' as first implementation.", implementationName);
            firstImplementation = implementationName;
        }
        LOGGER.debug("Testing implementation '{}'", implementationName);
        if (sub.containsKey(CONFIG_DEFAULT_PERSISTENCE)) {
            LOGGER.debug("'{}' is configured as default implementation.", implementationName);
            if (defaultImplementation != null) {
                LOGGER.warn("{} is an additional implementation defined as default. We'll ignore this.",
                        implementationName);
            } else {
                defaultImplementation = implementationName;
            }
        }
        Class<?> loadClass;
        boolean success = false;
        String persistenceClass = sub.getString(CONFIG_PERSISTENCE_CLASS);
        try {

            LOGGER.debug("Loading class '{}': ", persistenceClass);
            loadClass = getClass().getClassLoader().loadClass(persistenceClass);
            LOGGER.debug("Checking IPersistenceFactory.class.assignableFrom({})", persistenceClass);
            success = IPersistenceFactory.class.isAssignableFrom(loadClass);
            iPersistenceFactory = null;
            if (success) {
                LOGGER.debug("Creating instance of class {}", persistenceClass);
                iPersistenceFactory = (IPersistenceFactory) loadClass.newInstance();
                LOGGER.debug("Persistence factory successfully instantiated.");
            } else {
                LOGGER.error("IPersistenceFactory seems not to be assignable from class {}", persistenceClass);
            }
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException ex) {
            LOGGER.error("Failed to create instance of persistence implementation " + persistenceClass, ex);
            success = false;
        }
        if (success) {
            persistenceUnitMap.put(implementationName, persistenceUnits);
            persistenceClassMap.put(implementationName, iPersistenceFactory);
            persistenceUnitDefaultMap.put(implementationName, firstPersistenceUnit);
        } else {
            throw new edu.kit.dama.mdm.core.exception.ConfigurationException(
                    "Failed to initialize persistence factory from URL '" + configURL
                            + "'. See logfile for details.");
        }
    }
    if (defaultImplementation == null) {
        LOGGER.debug("Default implementation not set, yet. Using first one ({}) as default.",
                firstImplementation);
        defaultImplementation = firstImplementation;
    }
}

From source file:org.apache.james.mailetcontainer.lib.AbstractStateCompositeProcessor.java

@PostConstruct
public void init() throws Exception {
    List<HierarchicalConfiguration> processorConfs = config.configurationsAt("processor");
    for (HierarchicalConfiguration processorConf : processorConfs) {
        String processorName = processorConf.getString("[@state]");

        // if the "child" processor has no jmx config we just use the one of
        // the composite
        if (!processorConf.containsKey("[@enableJmx]")) {
            processorConf.addProperty("[@enableJmx]", enableJmx);
        }/*from  w w  w. j  av a  2  s  .co  m*/
        processors.put(processorName, createMailProcessor(processorName, processorConf));
    }

    if (enableJmx) {
        this.jmxListener = new JMXStateCompositeProcessorListener(this);
        addListener(jmxListener);
    }

    // check if all needed processors are configured
    checkProcessors();
}

From source file:org.apache.james.user.ldap.LdapRepositoryConfiguration.java

public static LdapRepositoryConfiguration from(HierarchicalConfiguration configuration)
        throws ConfigurationException {
    String ldapHost = configuration.getString("[@ldapHost]", "");
    String principal = configuration.getString("[@principal]", "");
    String credentials = configuration.getString("[@credentials]", "");
    String userBase = configuration.getString("[@userBase]");
    String userIdAttribute = configuration.getString("[@userIdAttribute]");
    String userObjectClass = configuration.getString("[@userObjectClass]");
    // Default is to use connection pooling
    boolean useConnectionPool = configuration.getBoolean("[@useConnectionPool]", USE_CONNECTION_POOL);
    int connectionTimeout = configuration.getInt("[@connectionTimeout]", NO_CONNECTION_TIMEOUT);
    int readTimeout = configuration.getInt("[@readTimeout]", NO_READ_TIME_OUT);
    // Default maximum retries is 1, which allows an alternate connection to
    // be found in a multi-homed environment
    int maxRetries = configuration.getInt("[@maxRetries]", 1);
    boolean supportsVirtualHosting = configuration.getBoolean(SUPPORTS_VIRTUAL_HOSTING,
            !ENABLE_VIRTUAL_HOSTING);//w w  w  . jav a 2 s .co m
    // Default retry start interval is 0 second
    long retryStartInterval = configuration.getLong("[@retryStartInterval]", 0);
    // Default maximum retry interval is 60 seconds
    long retryMaxInterval = configuration.getLong("[@retryMaxInterval]", 60);
    int scale = configuration.getInt("[@retryIntervalScale]", 1000); // seconds

    HierarchicalConfiguration restrictionConfig = null;
    // Check if we have a restriction we can use
    // See JAMES-1204
    if (configuration.containsKey("restriction[@memberAttribute]")) {
        restrictionConfig = configuration.configurationAt("restriction");
    }
    ReadOnlyLDAPGroupRestriction restriction = new ReadOnlyLDAPGroupRestriction(restrictionConfig);

    //see if there is a filter argument
    String filter = configuration.getString("[@filter]");

    Optional<String> administratorId = Optional.ofNullable(configuration.getString("[@administratorId]"));

    return new LdapRepositoryConfiguration(ldapHost, principal, credentials, userBase, userIdAttribute,
            userObjectClass, useConnectionPool, connectionTimeout, readTimeout, maxRetries,
            supportsVirtualHosting, retryStartInterval, retryMaxInterval, scale, restriction, filter,
            administratorId);
}

From source file:org.apache.james.user.ldap.ReadOnlyUsersLDAPRepository.java

/**
 * Extracts the parameters required by the repository instance from the
 * James server configuration data. The fields extracted include
 * {@link #ldapHost}, {@link #userIdAttribute}, {@link #userBase},
 * {@link #principal}, {@link #credentials} and {@link #restriction}.
 *
 * @param configuration// www.ja va  2  s  . c  om
 *            An encapsulation of the James server configuration data.
 */
public void configure(HierarchicalConfiguration configuration) throws ConfigurationException {
    ldapHost = configuration.getString("[@ldapHost]", "");
    principal = configuration.getString("[@principal]", "");
    credentials = configuration.getString("[@credentials]", "");
    userBase = configuration.getString("[@userBase]");
    userIdAttribute = configuration.getString("[@userIdAttribute]");
    userObjectClass = configuration.getString("[@userObjectClass]");
    // Default is to use connection pooling
    useConnectionPool = configuration.getBoolean("[@useConnectionPool]", true);
    connectionTimeout = configuration.getInt("[@connectionTimeout]", -1);
    readTimeout = configuration.getInt("[@readTimeout]", -1);
    // Default maximum retries is 1, which allows an alternate connection to
    // be found in a multi-homed environment
    maxRetries = configuration.getInt("[@maxRetries]", 1);
    // Default retry start interval is 0 second
    long retryStartInterval = configuration.getLong("[@retryStartInterval]", 0);
    // Default maximum retry interval is 60 seconds
    long retryMaxInterval = configuration.getLong("[@retryMaxInterval]", 60);
    int scale = configuration.getInt("[@retryIntervalScale]", 1000); // seconds
    schedule = new DoublingRetrySchedule(retryStartInterval, retryMaxInterval, scale);

    HierarchicalConfiguration restrictionConfig = null;
    // Check if we have a restriction we can use
    // See JAMES-1204
    if (configuration.containsKey("restriction[@memberAttribute]")) {
        restrictionConfig = configuration.configurationAt("restriction");
    }
    restriction = new ReadOnlyLDAPGroupRestriction(restrictionConfig);

    //see if there is a filter argument
    filter = configuration.getString("[@filter]");

}

From source file:org.bgp4j.config.nodes.impl.CapabilitiesParser.java

public Capabilities parseConfig(HierarchicalConfiguration hierarchicalConfiguration)
        throws ConfigurationException {
    CapabilitiesImpl caps = new CapabilitiesImpl();

    int as4Number = hierarchicalConfiguration.getInt("LargeAutonomousSystem[@local]", -1);

    if (as4Number > 0) {
        if (hierarchicalConfiguration.getBoolean("LargeAutonomousSystem[@optional]", false))
            caps.addOptionalCapability(new AutonomousSystem4Capability(as4Number));
        else/*from  w w  w .ja v a 2 s . c o m*/
            caps.addRequiredCapability(new AutonomousSystem4Capability(as4Number));
    }

    if (hierarchicalConfiguration.containsKey("RouteRefresh")) {
        if (hierarchicalConfiguration.getBoolean("RouteRefresh[@optional]", false))
            caps.addOptionalCapability(new RouteRefreshCapability());
        else
            caps.addRequiredCapability(new RouteRefreshCapability());
    }
    parseMultiprotocolCapabilities(hierarchicalConfiguration.configurationsAt("MultiProtocol"), caps);
    parseOutboundRouteFilteringCapabilities(
            hierarchicalConfiguration.configurationsAt("OutboundRouteFiltering"), caps);

    return caps;
}

From source file:org.onosproject.drivers.cisco.XmlParserCisco.java

private static DeviceInterfaceDescription.Mode getInterfaceMode(HierarchicalConfiguration intfConfig) {
    if (intfConfig.containsKey(TRUNK_MODE_KEY)) {
        return DeviceInterfaceDescription.Mode.TRUNK;
    } else if (intfConfig.containsKey(ACCESS_KEY)) {
        return DeviceInterfaceDescription.Mode.ACCESS;
    } else {//from   www  . jav  a  2s .  co  m
        return DeviceInterfaceDescription.Mode.NORMAL;
    }
}

From source file:org.onosproject.drivers.cisco.XmlParserCisco.java

private static VlanId getVlanForAccess(HierarchicalConfiguration intfConfig) {
    if (intfConfig.containsKey(ACCESS_KEY)) {
        return VlanId.vlanId(intfConfig.getString(ACCESS_KEY));
    }// w w  w . ja v a  2  s . co  m
    return null;
}

From source file:org.onosproject.drivers.cisco.XmlParserCisco.java

private static List<VlanId> getVlansForTrunk(HierarchicalConfiguration intfConfig) {
    if (intfConfig.containsKey(TRUNK_VLAN_KEY)) {
        return parseVlans(intfConfig.getStringArray(TRUNK_VLAN_KEY));
    }//from w  w w . j a va2  s. co m
    return null;
}

From source file:org.onosproject.drivers.cisco.XmlParserCisco.java

private static short getInterfaceLimit(HierarchicalConfiguration intfConfig) {
    if (intfConfig.containsKey(RATE_LIMIT_KEY)) {
        return intfConfig.getShort(RATE_LIMIT_KEY);
    }//w  w w . jav a 2 s.c  om
    return NO_LIMIT;
}