Examples with XMLConfiguration org.apache.commons.configuration2.XMLConfiguration used on opensource projects

Example 6 with XMLConfiguration

use of org.apache.commons.configuration2.XMLConfiguration in project selenium-tests by Wikia.

the class XMLReader method getValue.

/**
 * method used to get credentials from configuration xml
 */
public static String getValue(File file, String key) {
    if (!file.exists() || file.isDirectory()) {
        throw new ConfigurationRuntimeException("Cannot find a file with credentials");
    }
    try {
        Parameters params = new Parameters();
        FileBasedConfigurationBuilder<XMLConfiguration> builder = new FileBasedConfigurationBuilder<>(XMLConfiguration.class).configure(params.fileBased().setFile(file));
        org.apache.commons.configuration2.Configuration config = builder.getConfiguration();
        return config.getString(key);
    } catch (ConfigurationException e) {
        throw new ConfigurationRuntimeException(e);
    }
}

Example 7 with XMLConfiguration

use of org.apache.commons.configuration2.XMLConfiguration in project load-balancer by RestComm.

the class XmlConfigurationLoader method configureSip.

private static void configureSip(XMLConfiguration xml, SipConfiguration dst) {
    HierarchicalConfiguration<ImmutableNode> src = xml.configurationAt("sip");
    List<HierarchicalConfiguration<ImmutableNode>> srcRoutingRulesIpv4 = xml.configurationsAt("sip.routingRulesIpv4.rule");
    List<HierarchicalConfiguration<ImmutableNode>> srcRoutingRulesIpv6 = xml.configurationsAt("sip.routingRulesIpv6.rule");
    ExternalLegConfiguration ex = dst.getExternalLegConfiguration();
    InternalLegConfiguration in = dst.getInternalLegConfiguration();
    AlgorithmConfiguration alg = dst.getAlgorithmConfiguration();
    // Basic SIP configuration
    dst.setPublicIp(src.getString("publicIp", SipConfiguration.PUBLIC_IP));
    dst.setPublicIpv6(src.getString("publicIpv6", SipConfiguration.PUBLIC_IPV6));
    dst.setExtraServerNodes(src.getString("extraServerNodes", SipConfiguration.EXTRA_SERVER_NODES));
    dst.setPerformanceTestingMode(src.getBoolean("performanceTestingMode", SipConfiguration.PERFORMANCE_TESTING_MODE));
    dst.setUseIpLoadBalancerAddressInViaHeaders(src.getBoolean("useIpLoadBalancerAddressInViaHeaders", SipConfiguration.USE_IP_LOAD_BALANCER_ADRESS_IN_VIA_HEADERS));
    dst.setSendTrying(src.getBoolean("isSendTrying", SipConfiguration.IS_SEND_TRYING));
    dst.setBlockedValues(src.getString("blockedValues", SipConfiguration.BLOCKED_VALUES));
    dst.setUsePrettyEncoding(src.getBoolean("usePrettyEncoding", SipConfiguration.USE_PRETTY_ENCODING));
    dst.setIsSend5xxResponse(src.getBoolean("isSend5xxResponse", SipConfiguration.IS_SEND_5XX_RESPONSE));
    dst.setIsSend5xxResponseSatusCode(src.getInteger("isSend5xxResponseSatusCode", SipConfiguration.IS_SEND_5XX_RESPONSE_STATUS_CODE));
    dst.setIsSend5xxResponseReasonHeader(src.getString("isSend5xxResponseReasonHeader", SipConfiguration.IS_SEND_5XX_RESPONSE_REASON_HEADER));
    String responsesStatusCodeNodeRemoval = src.getString("responsesStatusCodeNodeRemoval", SipConfiguration.RESPONSES_STATUS_CODE_NODE_REMOVAL);
    if (responsesStatusCodeNodeRemoval != null) {
        List<Integer> responsesStatusCodeNodeRemovalList = new ArrayList<Integer>();
        StringTokenizer tokens = new StringTokenizer(responsesStatusCodeNodeRemoval, ",");
        while (tokens.hasMoreTokens()) {
            String token = tokens.nextToken();
            responsesStatusCodeNodeRemovalList.add(Integer.parseInt(token));
        }
        dst.setResponseStatusCodeNodeRemoval(responsesStatusCodeNodeRemovalList);
    }
    if (src.getString("maxNumberResponsesWithError") != null && !src.getString("maxNumberResponsesWithError").equals(""))
        dst.setMaxNumberResponsesWithError(src.getInteger("maxNumberResponsesWithError", SipConfiguration.MAX_NUMBER_RESPONSES_WITH_ERROR));
    if (src.getString("maxErrorTime") != null && !src.getString("maxErrorTime").equals(""))
        dst.setMaxErrorTime(src.getLong("maxErrorTime", SipConfiguration.MAX_ERROR_TIME));
    dst.setIsUseWithNexmo(src.getBoolean("isUseWithNexmo", SipConfiguration.IS_USE_WITH_NEXMO));
    dst.setMatchingHostnameForRoute(src.getString("matchingHostnameForRoute", SipConfiguration.MATCHING_HOSTNAME_FOR_ROUTE));
    dst.setIsFilterSubdomain(src.getBoolean("isFilterSubdomain", SipConfiguration.IS_FILTER_SUBDOMAIN));
    if (src.getString("internalTransport") != null && !src.getString("internalTransport").equals(""))
        dst.setInternalTransport(src.getString("internalTransport", SipConfiguration.INTERNAL_TRANSPORT));
    if (src.getString("trafficRampupCyclePeriod") != null && !src.getString("trafficRampupCyclePeriod").equals(""))
        dst.setTrafficRampupCyclePeriod(src.getInteger("trafficRampupCyclePeriod", SipConfiguration.TRAFFIC_RAMPUP_CYCLE_PERIOD));
    if (src.getString("trafficPercentageIncrease") != null && !src.getString("trafficPercentageIncrease").equals(""))
        dst.setTrafficPercentageIncrease(src.getInteger("trafficPercentageIncrease", SipConfiguration.MAX_WEIGHT_INDEX));
    if (src.getString("maxRequestNumberWithoutResponse") != null && !src.getString("maxRequestNumberWithoutResponse").equals(""))
        dst.setMaxRequestNumberWithoutResponse(src.getInteger("maxRequestNumberWithoutResponse", SipConfiguration.MAX_REQUEST_NUMBER_WITHOUT_RESPONSE));
    if (src.getString("maxResponseTime") != null && !src.getString("maxResponseTime").equals(""))
        dst.setMaxResponseTime(src.getLong("maxResponseTime", SipConfiguration.MAX_RESPONSE_TIME));
    // Routing rules
    if (srcRoutingRulesIpv4 != null) {
        ArrayList<RoutingRule> routingRulesIpv4 = new ArrayList<RoutingRule>();
        for (HierarchicalConfiguration<ImmutableNode> property : srcRoutingRulesIpv4) routingRulesIpv4.add(new RoutingRule(property.getString("ipPattern"), property.getBoolean("patch")));
        dst.setRoutingRulesIpv4(routingRulesIpv4);
    }
    if (srcRoutingRulesIpv6 != null) {
        ArrayList<RoutingRule> routingRulesIpv6 = new ArrayList<RoutingRule>();
        for (HierarchicalConfiguration<ImmutableNode> property : srcRoutingRulesIpv6) routingRulesIpv6.add(new RoutingRule(property.getString("ipPattern"), property.getBoolean("patch")));
        dst.setRoutingRulesIpv6(routingRulesIpv6);
    }
    // Algorithm configuration
    if (src.getString("algorithm.algorithmClass") != null && !src.getString("algorithm.algorithmClass").equals(""))
        alg.setAlgorithmClass(src.getString("algorithm.algorithmClass", AlgorithmConfiguration.ALGORITHM_CLASS));
    if (src.getString("algorithm.sipHeaderAffinityKey") != null && !src.getString("algorithm.sipHeaderAffinityKey").equals(""))
        alg.setSipHeaderAffinityKey(src.getString("algorithm.sipHeaderAffinityKey", AlgorithmConfiguration.SIP_HEADER_AFFINITY_KEY));
    if (src.getString("algorithm.sipHeaderAffinityExclusionPattern") != null && !src.getString("algorithm.sipHeaderAffinityExclusionPattern").equals(""))
        alg.setSipHeaderAffinityKeyExclusionPattern(src.getString("algorithm.sipHeaderAffinityExclusionPattern"));
    if (src.getString("algorithm.sipHeaderAffinityFallbackKey") != null && !src.getString("algorithm.sipHeaderAffinityFallbackKey").equals(""))
        alg.setSipHeaderAffinityFallbackKey(src.getString("algorithm.sipHeaderAffinityFallbackKey"));
    alg.setCallIdAffinityGroupFailover(src.getBoolean("algorithm.callIdAffinityGroupFailover", AlgorithmConfiguration.CALL_ID_AFFINITY_GROUP_FAILOVER));
    alg.setCallIdAffinityMaxTimeInCache(src.getInteger("algorithm.callIdAffinityMaxTimeInCache", AlgorithmConfiguration.CALL_ID_AFFINITY_MAX_TIME_IN_CACHE));
    alg.setHttpAffinityKey(src.getString("algorithm.httpAffinityKey", AlgorithmConfiguration.HTTP_AFFINITY_KEY));
    alg.setSubclusterMap(src.getString("subclusterMap", AlgorithmConfiguration.SUBCLUSTER_MAP));
    alg.setEarlyDialogWorstCase(src.getBoolean("earlyDialogWorstCase", AlgorithmConfiguration.EARLY_DIALOG_WORST_CASE));
    // external leg configuration
    ex.setHost(src.getString("external.host", ExternalLegConfiguration.HOST));
    String externalIpLoadBalancerAddresses = src.getString("external.ipLoadBalancerAddress", ExternalLegConfiguration.IP_LOAD_BALANCER_ADRESS);
    if (externalIpLoadBalancerAddresses != null && !externalIpLoadBalancerAddresses.equals("")) {
        ArrayList<String> externalIpLoadBalancerAddressesList = new ArrayList<String>();
        StringTokenizer tokens = new StringTokenizer(externalIpLoadBalancerAddresses, ",");
        while (tokens.hasMoreTokens()) {
            String token = tokens.nextToken();
            externalIpLoadBalancerAddressesList.add(token);
        }
        ex.setIpLoadBalancerAddress(externalIpLoadBalancerAddressesList);
    }
    if (src.getString("external.udpPort") != null && !src.getString("external.udpPort").equals(""))
        ex.setUdpPort(src.getInteger("external.udpPort", ExternalLegConfiguration.UDP_PORT));
    if (src.getString("external.tcpPort") != null && !src.getString("external.tcpPort").equals(""))
        ex.setTcpPort(src.getInteger("external.tcpPort", ExternalLegConfiguration.TCP_PORT));
    if (src.getString("external.tlsPort") != null && !src.getString("external.tlsPort").equals(""))
        ex.setTlsPort(src.getInteger("external.tlsPort", ExternalLegConfiguration.TLS_PORT));
    if (src.getString("external.wsPort") != null && !src.getString("external.wsPort").equals(""))
        ex.setWsPort(src.getInteger("external.wsPort", ExternalLegConfiguration.WS_PORT));
    if (src.getString("external.wssPort") != null && !src.getString("external.wssPort").equals(""))
        ex.setWssPort(src.getInteger("external.wssPort", ExternalLegConfiguration.WSS_PORT));
    if (src.getString("external.ipLoadBalancerUdpPort") != null && !src.getString("external.ipLoadBalancerUdpPort").equals(""))
        ex.setIpLoadBalancerUdpPort(src.getInteger("external.ipLoadBalancerUdpPort", ExternalLegConfiguration.IP_LOAD_BALANCER_UDP_PORT));
    if (src.getString("external.ipLoadBalancerTcpPort") != null && !src.getString("external.ipLoadBalancerTcpPort").equals(""))
        ex.setIpLoadBalancerTcpPort(src.getInteger("external.ipLoadBalancerTcpPort", ExternalLegConfiguration.IP_LOAD_BALANCER_TCP_PORT));
    if (src.getString("external.ipLoadBalancerTlsPort") != null && !src.getString("external.ipLoadBalancerTlsPort").equals(""))
        ex.setIpLoadBalancerTlsPort(src.getInteger("external.ipLoadBalancerTlsPort", ExternalLegConfiguration.IP_LOAD_BALANCER_TLS_PORT));
    if (src.getString("external.ipLoadBalancerWsPort") != null && !src.getString("external.ipLoadBalancerWsPort").equals(""))
        ex.setIpLoadBalancerWsPort(src.getInteger("external.ipLoadBalancerWsPort", ExternalLegConfiguration.IP_LOAD_BALANCER_WS_PORT));
    if (src.getString("external.ipLoadBalancerWssPort") != null && !src.getString("external.ipLoadBalancerWssPort").equals(""))
        ex.setIpLoadBalancerWssPort(src.getInteger("external.ipLoadBalancerWssPort", ExternalLegConfiguration.IP_LOAD_BALANCER_WSS_PORT));
    // external ipv6
    ex.setIpv6Host(src.getString("external.ipv6Host", ExternalLegConfiguration.IPV6_HOST));
    String externalIpv6LoadBalancerAddresses = src.getString("external.ipv6LoadBalancerAddress", ExternalLegConfiguration.IPV6_LOAD_BALANCER_ADRESS);
    if (externalIpv6LoadBalancerAddresses != null && !externalIpv6LoadBalancerAddresses.equals("")) {
        ArrayList<String> externalIpv6LoadBalancerAddressesList = new ArrayList<String>();
        StringTokenizer tokens = new StringTokenizer(externalIpv6LoadBalancerAddresses, ",");
        while (tokens.hasMoreTokens()) {
            String token = tokens.nextToken();
            externalIpv6LoadBalancerAddressesList.add(token);
        }
        ex.setIpv6LoadBalancerAddress(externalIpv6LoadBalancerAddressesList);
    }
    if (src.getString("external.ipv6UdpPort") != null && !src.getString("external.ipv6UdpPort").equals(""))
        ex.setIpv6UdpPort(src.getInteger("external.ipv6UdpPort", ExternalLegConfiguration.IPV6_UDP_PORT));
    if (src.getString("external.ipv6TcpPort") != null && !src.getString("external.ipv6TcpPort").equals(""))
        ex.setIpv6TcpPort(src.getInteger("external.ipv6TcpPort", ExternalLegConfiguration.IPV6_TCP_PORT));
    if (src.getString("external.ipv6TlsPort") != null && !src.getString("external.ipv6TlsPort").equals(""))
        ex.setIpv6TlsPort(src.getInteger("external.ipv6TlsPort", ExternalLegConfiguration.IPV6_TLS_PORT));
    if (src.getString("external.ipv6WsPort") != null && !src.getString("external.ipv6WsPort").equals(""))
        ex.setIpv6WsPort(src.getInteger("external.ipv6WsPort", ExternalLegConfiguration.IPV6_WS_PORT));
    if (src.getString("external.ipv6WssPort") != null && !src.getString("external.ipv6WssPort").equals(""))
        ex.setIpv6WssPort(src.getInteger("external.ipv6WssPort", ExternalLegConfiguration.IPV6_WSS_PORT));
    if (src.getString("external.ipv6LoadBalancerUdpPort") != null && !src.getString("external.ipv6LoadBalancerUdpPort").equals(""))
        ex.setIpv6LoadBalancerUdpPort(src.getInteger("external.ipv6LoadBalancerUdpPort", ExternalLegConfiguration.IPV6_LOAD_BALANCER_UDP_PORT));
    if (src.getString("external.ipv6LoadBalancerTcpPort") != null && !src.getString("external.ipv6LoadBalancerTcpPort").equals(""))
        ex.setIpv6LoadBalancerTcpPort(src.getInteger("external.ipv6LoadBalancerTcpPort", ExternalLegConfiguration.IPV6_LOAD_BALANCER_TCP_PORT));
    if (src.getString("external.ipv6LoadBalancerTlsPort") != null && !src.getString("external.ipv6LoadBalancerTlsPort").equals(""))
        ex.setIpv6LoadBalancerTlsPort(src.getInteger("external.ipv6LoadBalancerTlsPort", ExternalLegConfiguration.IPV6_LOAD_BALANCER_TLS_PORT));
    if (src.getString("external.ipv6LoadBalancerWsPort") != null && !src.getString("external.ipv6LoadBalancerWsPort").equals(""))
        ex.setIpv6LoadBalancerWsPort(src.getInteger("external.ipv6LoadBalancerWsPort", ExternalLegConfiguration.IPV6_LOAD_BALANCER_WS_PORT));
    if (src.getString("external.ipv6LoadBalancerWssPort") != null && !src.getString("external.ipv6LoadBalancerWssPort").equals(""))
        ex.setIpv6LoadBalancerWssPort(src.getInteger("external.ipv6LoadBalancerWssPort", ExternalLegConfiguration.IPV6_LOAD_BALANCER_WSS_PORT));
    // internal leg configuration
    in.setHost(src.getString("internal.host", InternalLegConfiguration.HOST));
    String internalIpLoadBalancerAddresses = src.getString("internal.ipLoadBalancerAddress", InternalLegConfiguration.IP_LOAD_BALANCER_ADRESS);
    if (internalIpLoadBalancerAddresses != null && !internalIpLoadBalancerAddresses.equals("")) {
        ArrayList<String> internalIpLoadBalancerAddressesList = new ArrayList<String>();
        StringTokenizer tokens = new StringTokenizer(internalIpLoadBalancerAddresses, ",");
        while (tokens.hasMoreTokens()) {
            String token = tokens.nextToken();
            internalIpLoadBalancerAddressesList.add(token);
        }
        in.setIpLoadBalancerAddress(internalIpLoadBalancerAddressesList);
    }
    if (src.getString("internal.udpPort") != null && !src.getString("internal.udpPort").equals(""))
        in.setUdpPort(src.getInteger("internal.udpPort", InternalLegConfiguration.UDP_PORT));
    if (src.getString("internal.tcpPort") != null && !src.getString("internal.tcpPort").equals(""))
        in.setTcpPort(src.getInteger("internal.tcpPort", InternalLegConfiguration.TCP_PORT));
    if (src.getString("internal.tlsPort") != null && !src.getString("internal.tlsPort").equals(""))
        in.setTlsPort(src.getInteger("internal.tlsPort", InternalLegConfiguration.TLS_PORT));
    if (src.getString("internal.wsPort") != null && !src.getString("internal.wsPort").equals(""))
        in.setWsPort(src.getInteger("internal.wsPort", InternalLegConfiguration.WS_PORT));
    if (src.getString("internal.wssPort") != null && !src.getString("internal.wssPort").equals(""))
        in.setWssPort(src.getInteger("internal.wssPort", InternalLegConfiguration.WSS_PORT));
    if (src.getString("internal.ipLoadBalancerUdpPort") != null && !src.getString("internal.ipLoadBalancerUdpPort").equals(""))
        in.setIpLoadBalancerUdpPort(src.getInteger("internal.ipLoadBalancerUdpPort", InternalLegConfiguration.IP_LOAD_BALANCER_UDP_PORT));
    if (src.getString("internal.ipLoadBalancerTcpPort") != null && !src.getString("internal.ipLoadBalancerTcpPort").equals(""))
        in.setIpLoadBalancerTcpPort(src.getInteger("internal.ipLoadBalancerTcpPort", InternalLegConfiguration.IP_LOAD_BALANCER_TCP_PORT));
    if (src.getString("internal.ipLoadBalancerTlsPort") != null && !src.getString("internal.ipLoadBalancerTlsPort").equals(""))
        in.setIpLoadBalancerTlsPort(src.getInteger("internal.ipLoadBalancerTlsPort", InternalLegConfiguration.IP_LOAD_BALANCER_TLS_PORT));
    if (src.getString("internal.ipLoadBalancerWsPort") != null && !src.getString("internal.ipLoadBalancerWsPort").equals(""))
        in.setIpLoadBalancerWsPort(src.getInteger("internal.ipLoadBalancerWsPort", InternalLegConfiguration.IP_LOAD_BALANCER_WS_PORT));
    if (src.getString("internal.ipLoadBalancerWssPort") != null && !src.getString("internal.ipLoadBalancerWssPort").equals(""))
        in.setIpLoadBalancerWssPort(src.getInteger("internal.ipLoadBalancerWssPort", InternalLegConfiguration.IP_LOAD_BALANCER_WSS_PORT));
    // ipv6
    in.setIpv6Host(src.getString("internal.ipv6Host", InternalLegConfiguration.IPV6_HOST));
    String internalIpv6LoadBalancerAddresses = src.getString("internal.ipv6LoadBalancerAddress", InternalLegConfiguration.IPV6_LOAD_BALANCER_ADRESS);
    if (internalIpv6LoadBalancerAddresses != null && !internalIpv6LoadBalancerAddresses.equals("")) {
        ArrayList<String> internalIpv6LoadBalancerAddressesList = new ArrayList<String>();
        StringTokenizer tokens = new StringTokenizer(internalIpv6LoadBalancerAddresses, ",");
        while (tokens.hasMoreTokens()) {
            String token = tokens.nextToken();
            internalIpv6LoadBalancerAddressesList.add(token);
        }
        in.setIpv6LoadBalancerAddress(internalIpv6LoadBalancerAddressesList);
    }
    ;
    if (src.getString("internal.ipv6UdpPort") != null && !src.getString("internal.ipv6UdpPort").equals(""))
        in.setIpv6UdpPort(src.getInteger("internal.ipv6UdpPort", InternalLegConfiguration.IPV6_UDP_PORT));
    if (src.getString("internal.ipv6TcpPort") != null && !src.getString("internal.ipv6TcpPort").equals(""))
        in.setIpv6TcpPort(src.getInteger("internal.ipv6TcpPort", InternalLegConfiguration.IPV6_TCP_PORT));
    if (src.getString("internal.ipv6TlsPort") != null && !src.getString("internal.ipv6TlsPort").equals(""))
        in.setIpv6TlsPort(src.getInteger("internal.ipv6TlsPort", InternalLegConfiguration.IPV6_TLS_PORT));
    if (src.getString("internal.ipv6WsPort") != null && !src.getString("internal.ipv6WsPort").equals(""))
        in.setIpv6WsPort(src.getInteger("internal.ipv6WsPort", InternalLegConfiguration.IPV6_WS_PORT));
    if (src.getString("internal.ipv6WssPort") != null && !src.getString("internal.ipv6WssPort").equals(""))
        in.setIpv6WssPort(src.getInteger("internal.ipv6WssPort", InternalLegConfiguration.IPV6_WSS_PORT));
    if (src.getString("internal.ipv6LoadBalancerUdpPort") != null && !src.getString("internal.ipv6LoadBalancerUdpPort").equals(""))
        in.setIpv6LoadBalancerUdpPort(src.getInteger("internal.ipv6LoadBalancerUdpPort", InternalLegConfiguration.IPV6_LOAD_BALANCER_UDP_PORT));
    if (src.getString("internal.ipv6LoadBalancerTcpPort") != null && !src.getString("internal.ipv6LoadBalancerTcpPort").equals(""))
        in.setIpv6LoadBalancerTcpPort(src.getInteger("internal.ipv6LoadBalancerTcpPort", InternalLegConfiguration.IPV6_LOAD_BALANCER_TCP_PORT));
    if (src.getString("internal.ipv6LoadBalancerTlsPort") != null && !src.getString("internal.ipv6LoadBalancerTlsPort").equals(""))
        in.setIpv6LoadBalancerTlsPort(src.getInteger("internal.ipv6LoadBalancerTlsPort", InternalLegConfiguration.IPV6_LOAD_BALANCER_TLS_PORT));
    if (src.getString("internal.ipv6LoadBalancerWsPort") != null && !src.getString("internal.ipv6LoadBalancerWsPort").equals(""))
        in.setIpv6LoadBalancerWsPort(src.getInteger("internal.ipv6LoadBalancerWsPort", InternalLegConfiguration.IPV6_LOAD_BALANCER_WS_PORT));
    if (src.getString("internal.ipv6LoadBalancerWssPort") != null && !src.getString("internal.ipv6LoadBalancerWssPort").equals(""))
        in.setIpv6LoadBalancerWssPort(src.getInteger("internal.ipv6LoadBalancerWssPort", InternalLegConfiguration.IPV6_LOAD_BALANCER_WSS_PORT));
}

Example 8 with XMLConfiguration

use of org.apache.commons.configuration2.XMLConfiguration in project sponge by softelnet.

the class DefaultConfigurationManager method createXmlConfiguration.

protected Pair<XMLConfiguration, URL> createXmlConfiguration(String fileName) {
    List<Lookup> lookups = Arrays.asList(new SystemPropertiesLookup(), new HomeLookup(), new ConfigLookup());
    Parameters params = new Parameters();
    FallbackBasePathLocationStrategy locationStrategy = new FallbackBasePathLocationStrategy(FileLocatorUtils.DEFAULT_LOCATION_STRATEGY, home);
    FileBasedConfigurationBuilder<XMLConfiguration> builder = new FileBasedConfigurationBuilder<>(XMLConfiguration.class).configure(params.xml().setDefaultLookups(lookups).setLocationStrategy(locationStrategy).setFileName(fileName).setSchemaValidation(true).setEntityResolver(new ResourceSchemaResolver()));
    try {
        XMLConfiguration xmlConfiguration = builder.getConfiguration();
        return new ImmutablePair<>(xmlConfiguration, locationStrategy.getLocatedUrl());
    } catch (ConfigurationException e) {
        throw new ConfigException("Error reading configuration file " + fileName, e);
    }
}

Example 9 with XMLConfiguration

use of org.apache.commons.configuration2.XMLConfiguration in project midpoint by Evolveum.

the class StartupConfiguration method createXmlConfiguration.

private void createXmlConfiguration(String filename) throws ConfigurationException {
    Map<String, Lookup> lookups = new HashMap<>(ConfigurationInterpolator.getDefaultPrefixLookups());
    lookups.put(RandomLookup.PREFIX, new RandomLookup());
    lookups.put(HostnameLookup.PREFIX, new HostnameLookup());
    FileBasedConfigurationBuilder<XMLConfiguration> builder = new FileBasedConfigurationBuilder<>(XMLConfiguration.class).configure(new Parameters().xml().setFileName(filename).setPrefixLookups(lookups));
    /*
        On debug level this shows stacktrace for:
        DEBUG org.apache.commons.beanutils.FluentPropertyBeanIntrospector - Exception is:
        java.beans.IntrospectionException: bad write method arg count:
        public final void org.apache.commons.configuration2.AbstractConfiguration.setProperty
        This is reportedly beanutils over-strictness issue but is nowhere close to be fixed.
        Jira for commons-configuration can be also found, but they rely on beanutils fix.
        */
    config = builder.getConfiguration();
    config.addProperty(MIDPOINT_HOME_PROPERTY, midPointHomePath);
    applyEnvironmentProperties();
    resolveFileReferences();
}

Example 10 with XMLConfiguration

use of org.apache.commons.configuration2.XMLConfiguration in project zeppelin by apache.

the class ZeppelinConfiguration method loadXMLConfig.

private void loadXMLConfig(@Nullable String filename) throws ConfigurationException {
    if (StringUtils.isBlank(filename)) {
        filename = ZEPPELIN_SITE_XML;
    }
    List<FileLocationStrategy> subs = Arrays.asList(new ZeppelinLocationStrategy(), new ClasspathLocationStrategy());
    FileLocationStrategy strategy = new CombinedLocationStrategy(subs);
    Parameters params = new Parameters();
    FileBasedConfigurationBuilder<XMLConfiguration> xmlbuilder = new FileBasedConfigurationBuilder<XMLConfiguration>(XMLConfiguration.class).configure(params.xml().setLocationStrategy(strategy).setFileName(filename).setBasePath(File.separator + "conf" + File.separator));
    XMLConfiguration xmlConfig = xmlbuilder.getConfiguration();
    List<ImmutableNode> nodes = xmlConfig.getNodeModel().getRootNode().getChildren();
    if (nodes != null && !nodes.isEmpty()) {
        for (ImmutableNode p : nodes) {
            String name = String.valueOf(p.getChildren("name").get(0).getValue());
            String value = String.valueOf(p.getChildren("value").get(0).getValue());
            if (StringUtils.isNotBlank(name) && StringUtils.isNotBlank(value)) {
                setProperty(name, value);
            }
        }
    }
}