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

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

Introduction

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

Prototype

public Integer getInteger(String key, Integer defaultValue) 

Source Link

Usage

From source file:com.github.steveash.typedconfig.resolver.ProxyValueResolverTest.java

@Test
public void shouldNotEqualEachOther() throws Exception {
    when(mock.getInteger("some1", null)).thenReturn(42);
    when(mock.getInteger("some2", null)).thenReturn(23);

    HierarchicalConfiguration mock2 = mock(HierarchicalConfiguration.class);
    when(mock2.getInteger("some1", null)).thenReturn(420);
    when(mock2.getInteger("some2", null)).thenReturn(230);

    Child c1 = cpf.make(Child.class, mock);
    Child c2 = cpf.make(Child.class, mock2);

    assertFalse(c1.equals(c2));//from  w w  w . ja  v  a2 s .co m
    assertFalse(c1.hashCode() == c2.hashCode());
}

From source file:com.github.steveash.typedconfig.resolver.type.simple.IntegerValueResolverFactory.java

@Override
public ValueResolver makeForThis(final ConfigBinding binding, final HierarchicalConfiguration config,
        ConfigFactoryContext context) {/*from   www .  j a va  2  s  .c om*/

    final String key = binding.getConfigKeyToLookup();
    return new ConvertableValueResolver(Integer.class, key) {
        @Override
        public Integer resolve() {
            return config.getInteger(binding.getConfigKeyToLookup(), null);
        }
    };
}

From source file:at.ac.tuwien.auto.iotsys.gateway.connectors.knx.KNXDeviceLoaderImpl.java

public ArrayList<Connector> initDevices(ObjectBroker objectBroker) {
    setConfiguration(devicesConfig);//from w w w . j  av a2s.co m
    objectBroker.getConfigDb().prepareDeviceLoader(getClass().getName());

    ArrayList<Connector> connectors = new ArrayList<Connector>();

    List<JsonNode> connectorsFromDb = objectBroker.getConfigDb().getConnectors("knx");
    int connectorsSize = 0;

    if (connectorsFromDb.size() <= 0) {
        Object knxConnectors = devicesConfig.getProperty("knx.connector.name");

        if (knxConnectors != null) {
            connectorsSize = 1;
        }

        if (knxConnectors instanceof Collection<?>) {
            connectorsSize = ((Collection<?>) knxConnectors).size();
        }
    } else
        connectorsSize = connectorsFromDb.size();

    for (int connector = 0; connector < connectorsSize; connector++) {

        HierarchicalConfiguration subConfig = devicesConfig.configurationAt("knx.connector(" + connector + ")");

        Object knxConfiguredDevices = subConfig.getProperty("device.type");// just to get the number of devices
        String connectorId = "";
        String connectorName = subConfig.getString("name");
        String routerIP = subConfig.getString("router.ip");
        int routerPort = subConfig.getInteger("router.port", 3671);
        String localIP = subConfig.getString("localIP");
        Boolean enabled = subConfig.getBoolean("enabled", false);

        try {
            connectorId = connectorsFromDb.get(connector).get("_id").asText();
            connectorName = connectorsFromDb.get(connector).get("name").asText();
            enabled = connectorsFromDb.get(connector).get("enabled").asBoolean();
            routerIP = connectorsFromDb.get(connector).get("routerHostname").asText();
            routerPort = connectorsFromDb.get(connector).get("routerPort").asInt();
            localIP = connectorsFromDb.get(connector).get("localIP").asText();
        } catch (Exception e) {
            log.info("Cannot fetch configuration from Database, using devices.xml");
        }

        if (enabled) {
            try {
                KNXConnector knxConnector = new KNXConnector(routerIP, routerPort, localIP);
                knxConnector.setName(connectorName);
                knxConnector.setTechnology("knx");
                knxConnector.setEnabled(enabled);
                //knxConnector.connect();
                connectors.add(knxConnector);

                int numberOfDevices = 0;
                List<Device> devicesFromDb = objectBroker.getConfigDb().getDevices(connectorId);

                if (connectorsFromDb.size() <= 0) {
                    if (knxConfiguredDevices != null) {
                        numberOfDevices = 1; // there is at least one
                                             // device.
                    }
                    if (knxConfiguredDevices instanceof Collection<?>) {
                        Collection<?> knxDevices = (Collection<?>) knxConfiguredDevices;
                        numberOfDevices = knxDevices.size();
                    }
                } else
                    numberOfDevices = devicesFromDb.size();

                log.info(
                        numberOfDevices + " KNX devices found in configuration for connector " + connectorName);
                for (int i = 0; i < numberOfDevices; i++) {

                    String type = subConfig.getString("device(" + i + ").type");
                    List<Object> address = subConfig.getList("device(" + i + ").address");
                    String addressString = address.toString();

                    String ipv6 = subConfig.getString("device(" + i + ").ipv6");
                    String href = subConfig.getString("device(" + i + ").href");

                    String name = subConfig.getString("device(" + i + ").name");

                    String displayName = subConfig.getString("device(" + i + ").displayName");

                    Boolean historyEnabled = subConfig.getBoolean("device(" + i + ").historyEnabled", false);

                    Boolean groupCommEnabled = subConfig.getBoolean("device(" + i + ").groupCommEnabled",
                            false);

                    Integer historyCount = subConfig.getInt("device(" + i + ").historyCount", 0);

                    Boolean refreshEnabled = subConfig.getBoolean("device(" + i + ").refreshEnabled", false);

                    Device deviceFromDb;
                    try {
                        deviceFromDb = devicesFromDb.get(i);
                        type = deviceFromDb.getType();
                        addressString = deviceFromDb.getAddress();
                        String subAddr[] = addressString.substring(1, addressString.length() - 1).split(", ");
                        address = Arrays.asList((Object[]) subAddr);
                        ipv6 = deviceFromDb.getIpv6();
                        href = deviceFromDb.getHref();
                        name = deviceFromDb.getName();
                        displayName = deviceFromDb.getDisplayName();
                        historyEnabled = deviceFromDb.isHistoryEnabled();
                        groupCommEnabled = deviceFromDb.isGroupcommEnabled();
                        refreshEnabled = deviceFromDb.isRefreshEnabled();
                        historyCount = deviceFromDb.getHistoryCount();
                    } catch (Exception e) {
                    }

                    // Transition step: comment when done
                    Device d = new Device(type, ipv6, addressString, href, name, displayName, historyCount,
                            historyEnabled, groupCommEnabled, refreshEnabled);
                    objectBroker.getConfigDb().prepareDevice(connectorName, d);

                    if (type != null && address != null) {
                        int addressCount = address.size();
                        try {
                            Constructor<?>[] declaredConstructors = Class.forName(type)
                                    .getDeclaredConstructors();
                            for (int k = 0; k < declaredConstructors.length; k++) {
                                if (declaredConstructors[k].getParameterTypes().length == addressCount + 1) { // constructor
                                    // that
                                    // takes
                                    // the
                                    // KNX
                                    // connector
                                    // and
                                    // group
                                    // address
                                    // as
                                    // argument
                                    Object[] args = new Object[address.size() + 1];
                                    // first arg is KNX connector

                                    args[0] = knxConnector;
                                    for (int l = 1; l <= address.size(); l++) {
                                        try {
                                            String adr = (String) address.get(l - 1);
                                            if (adr == null || adr.equals("null")) {
                                                args[l] = null;
                                            } else {
                                                args[l] = new GroupAddress(adr);
                                            }
                                        } catch (KNXFormatException e) {
                                            e.printStackTrace();
                                        }
                                    }
                                    try {
                                        // create a instance of the
                                        // specified KNX device
                                        Obj knxDevice = (Obj) declaredConstructors[k].newInstance(args);

                                        knxDevice.setHref(new Uri(
                                                URLEncoder.encode(connectorName, "UTF-8") + "/" + href));

                                        if (name != null && name.length() > 0) {
                                            knxDevice.setName(name);
                                        }

                                        if (displayName != null && displayName.length() > 0) {
                                            knxDevice.setDisplayName(displayName);
                                        }

                                        if (ipv6 != null) {
                                            objectBroker.addObj(knxDevice, ipv6);
                                        } else {
                                            objectBroker.addObj(knxDevice);
                                        }

                                        myObjects.add(knxDevice);

                                        knxDevice.initialize();

                                        if (historyEnabled != null && historyEnabled) {
                                            if (historyCount != null && historyCount != 0) {
                                                objectBroker.addHistoryToDatapoints(knxDevice, historyCount);
                                            } else {
                                                objectBroker.addHistoryToDatapoints(knxDevice);
                                            }
                                        }

                                        if (groupCommEnabled) {
                                            objectBroker.enableGroupComm(knxDevice);
                                        }

                                        if (refreshEnabled != null && refreshEnabled) {
                                            objectBroker.enableObjectRefresh(knxDevice);
                                        }

                                    } catch (IllegalArgumentException e) {
                                        e.printStackTrace();
                                    } catch (InstantiationException e) {
                                        e.printStackTrace();
                                    } catch (IllegalAccessException e) {
                                        e.printStackTrace();
                                    } catch (InvocationTargetException e) {
                                        e.printStackTrace();
                                    }
                                }
                            }
                        } catch (SecurityException e) {
                            e.printStackTrace();
                        } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    return connectors;
}

From source file:at.ac.tuwien.auto.iotsys.gateway.connectors.bacnet.BacnetDeviceLoaderImpl.java

public ArrayList<Connector> initDevices(ObjectBroker objectBroker) {
    setConfiguration(devicesConfig);/*from www  .j  a va  2s  . c  o  m*/
    objectBroker.getConfigDb().prepareDeviceLoader(getClass().getName());

    ArrayList<Connector> connectors = new ArrayList<Connector>();

    List<JsonNode> connectorsFromDb = objectBroker.getConfigDb().getConnectors("bacnet");
    int connectorsSize = 0;
    // bacnet
    if (connectorsFromDb.size() <= 0) {
        Object bacnetConnectors = devicesConfig.getProperty("bacnet.connector.name");

        if (bacnetConnectors != null) {
            connectorsSize = 1;
        } else {
            connectorsSize = 0;
        }

        if (bacnetConnectors instanceof Collection<?>) {
            connectorsSize = ((Collection<?>) bacnetConnectors).size();
        }
    } else
        connectorsSize = connectorsFromDb.size();

    for (int connector = 0; connector < connectorsSize; connector++) {
        HierarchicalConfiguration subConfig = devicesConfig
                .configurationAt("bacnet.connector(" + connector + ")");

        Object bacnetConfiguredDevices = subConfig.getProperty("device.type");
        String connectorId = "";
        String connectorName = subConfig.getString("name");
        String broadcastAddress = subConfig.getString("broadcastAddress");
        int localPort = subConfig.getInteger("localPort", 3671);
        int localDeviceID = subConfig.getInteger("localDeviceID", 12345);
        boolean enabled = subConfig.getBoolean("enabled", false);
        Boolean groupCommEnabled = subConfig.getBoolean("groupCommEnabled", null);
        Boolean historyEnabled = subConfig.getBoolean("historyEnabled", null);

        try {
            connectorId = connectorsFromDb.get(connector).get("_id").asText();
            connectorName = connectorsFromDb.get(connector).get("name").asText();
            enabled = connectorsFromDb.get(connector).get("enabled").asBoolean();
            groupCommEnabled = connectorsFromDb.get(connector).get("groupCommEnabled").asBoolean();
            historyEnabled = connectorsFromDb.get(connector).get("historyEnabled").asBoolean();
            broadcastAddress = connectorsFromDb.get(connector).get("broadcastAddress").asText();
            localPort = connectorsFromDb.get(connector).get("localPort").asInt();
            localDeviceID = connectorsFromDb.get(connector).get("localDeviceID").asInt();
        } catch (Exception e) {
            log.info("Cannot fetch configuration from Database, using devices.xml");
        }

        if (enabled) {
            try {
                BACnetConnector bacnetConnector = new BACnetConnector(localDeviceID, broadcastAddress,
                        localPort);
                bacnetConnector.setName(connectorName);
                bacnetConnector.setTechnology("bacnet");
                bacnetConnector.setEnabled(enabled);

                Obj bacRoot = bacnetConnector.getRootObj();
                bacRoot.setName(connectorName);
                bacRoot.setHref(new Uri(connectorName.replaceAll("[^a-zA-Z0-9-~\\(\\)]", "")));
                objectBroker.addObj(bacRoot, true);

                // Transition step: Moving configs to DB: all connector enabled, uncomment when done
                //bacnetConnector.connect();

                Boolean discoveryEnabled = subConfig.getBoolean("discovery-enabled", false);
                if (discoveryEnabled)
                    bacnetConnector.discover(
                            new DeviceDiscoveryListener(objectBroker, groupCommEnabled, historyEnabled));

                connectors.add(bacnetConnector);

                int numberOfDevices = 0;
                List<Device> devicesFromDb = objectBroker.getConfigDb().getDevices(connectorId);

                if (connectorsFromDb.size() <= 0) {
                    // TODO: bacnetConfiguredDevices is from devices.xml --> mismatch when a connector does not have any device associated,
                    // e.g., bacnet a-lab (auto) connector
                    // do like this for other device loaders!
                    if (bacnetConfiguredDevices != null) {
                        numberOfDevices = 1; // there is at least one device.
                    }
                    if (bacnetConfiguredDevices instanceof Collection<?>) {
                        Collection<?> bacnetDevices = (Collection<?>) bacnetConfiguredDevices;
                        numberOfDevices = bacnetDevices.size();
                    }
                } else
                    numberOfDevices = devicesFromDb.size();

                log.info(numberOfDevices + " BACnet devices found in configuration for connector "
                        + connectorName);

                // Transition step: comment when done
                for (int i = 0; i < numberOfDevices; i++) {
                    String type = subConfig.getString("device(" + i + ").type");
                    List<Object> address = subConfig.getList("device(" + i + ").address");
                    String addressString = address.toString();
                    String ipv6 = subConfig.getString("device(" + i + ").ipv6");
                    String href = subConfig.getString("device(" + i + ").href");

                    // device specific setting
                    Boolean historyEnabledDevice = subConfig.getBoolean("device(" + i + ").historyEnabled",
                            null);

                    if (historyEnabledDevice != null) {
                        historyEnabled = historyEnabledDevice;
                    }

                    // device specific setting
                    Boolean groupCommEnabledDevice = subConfig.getBoolean("device(" + i + ").groupCommEnabled",
                            null);

                    if (groupCommEnabledDevice != null) {
                        // overwrite general settings
                        groupCommEnabled = groupCommEnabledDevice;
                    }

                    String name = subConfig.getString("device(" + i + ").name");

                    String displayName = subConfig.getString("device(" + i + ").displayName");

                    Boolean refreshEnabled = subConfig.getBoolean("device(" + i + ").refreshEnabled", false);

                    Integer historyCount = subConfig.getInt("device(" + i + ").historyCount", 0);

                    Device deviceFromDb;
                    try {
                        deviceFromDb = devicesFromDb.get(i);
                        type = deviceFromDb.getType();
                        addressString = deviceFromDb.getAddress();
                        String subAddr[] = addressString.substring(1, addressString.length() - 1).split(", ");
                        address = Arrays.asList((Object[]) subAddr);
                        ipv6 = deviceFromDb.getIpv6();
                        href = deviceFromDb.getHref();
                        name = deviceFromDb.getName();
                        displayName = deviceFromDb.getDisplayName();
                        historyEnabled = deviceFromDb.isHistoryEnabled();
                        groupCommEnabled = deviceFromDb.isGroupcommEnabled();
                        refreshEnabled = deviceFromDb.isRefreshEnabled();
                        historyCount = deviceFromDb.getHistoryCount();
                    } catch (Exception e) {
                    }
                    // Transition step: comment when done
                    Device d = new Device(type, ipv6, addressString, href, name, displayName, historyCount,
                            historyEnabled, groupCommEnabled, refreshEnabled);
                    objectBroker.getConfigDb().prepareDevice(connectorName, d);

                    if (type != null && address != null) {

                        // now follow possible multiple data points
                        // identified through
                        // the device Id, object type, the instance number and the
                        // property identifier, which shall be packaged into an BacnetDatapointInfo object

                        ObjectIdentifier[] objectIdentifier = new ObjectIdentifier[(address.size()) / 4];
                        PropertyIdentifier[] propertyIdentifier = new PropertyIdentifier[(address.size()) / 4];

                        BacnetDataPointInfo[] bacnetDataPointInfo = new BacnetDataPointInfo[(address.size())
                                / 4];

                        int q = 0;
                        for (int p = 0; p <= address.size() - 4; p += 4) {
                            int remoteDeviceID = Integer.parseInt((String) address.get(p));
                            ObjectIdentifier objIdentifier = new ObjectIdentifier(
                                    new ObjectType(Integer.parseInt((String) address.get(p + 1))),
                                    Integer.parseInt((String) address.get(p + 2)));
                            PropertyIdentifier propIdentifier = new PropertyIdentifier(
                                    Integer.parseInt((String) address.get(p + 3)));
                            objectIdentifier[q] = objIdentifier;
                            propertyIdentifier[q] = propIdentifier;
                            bacnetDataPointInfo[q] = new BacnetDataPointInfo(remoteDeviceID, objIdentifier,
                                    propIdentifier);
                            q = q + 1;
                        }
                        Object[] args = new Object[q + 1];
                        args[0] = bacnetConnector;
                        //                        args[1] = Integer.parseInt(remoteDeviceID);
                        for (int p = 0; p < bacnetDataPointInfo.length; p++) {
                            args[1 + p] = bacnetDataPointInfo[p];
                        }

                        try {

                            Constructor<?>[] declaredConstructors = Class.forName(type)
                                    .getDeclaredConstructors();
                            for (int k = 0; k < declaredConstructors.length; k++) {
                                if (declaredConstructors[k].getParameterTypes().length == args.length) { // constructor
                                    // that
                                    // takes
                                    // the
                                    // KNX
                                    // connector
                                    // and
                                    // group
                                    // address
                                    // as
                                    // argument
                                    Obj bacnetDevice = (Obj) declaredConstructors[k].newInstance(args); // create
                                    // a
                                    // instance
                                    // of
                                    // the
                                    // specified
                                    // KNX
                                    // device
                                    bacnetDevice.setHref(
                                            new Uri(URLEncoder.encode(connectorName, "UTF-8") + "/" + href));

                                    if (name != null && name.length() > 0) {
                                        bacnetDevice.setName(name);
                                    }

                                    if (displayName != null && displayName.length() > 0) {
                                        bacnetDevice.setDisplayName(displayName);
                                    }

                                    if (ipv6 != null) {
                                        objectBroker.addObj(bacnetDevice, ipv6);
                                    } else {
                                        objectBroker.addObj(bacnetDevice);
                                    }

                                    myObjects.add(bacnetDevice);

                                    bacnetDevice.initialize();

                                    if (historyEnabled != null && historyEnabled) {
                                        if (historyCount != null && historyCount != 0) {
                                            objectBroker.addHistoryToDatapoints(bacnetDevice, historyCount);
                                        } else {
                                            objectBroker.addHistoryToDatapoints(bacnetDevice);
                                        }
                                    }

                                    if (refreshEnabled != null && refreshEnabled) {
                                        objectBroker.enableObjectRefresh(bacnetDevice);
                                    }

                                    if (groupCommEnabled != null && groupCommEnabled) {
                                        objectBroker.enableGroupComm(bacnetDevice);
                                    }
                                }
                            }
                        } catch (SecurityException e) {
                            e.printStackTrace();
                        } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    return connectors;
}

From source file:at.ac.tuwien.auto.iotsys.gateway.connectors.knx.KNXDeviceLoaderETSImpl.java

public ArrayList<Connector> initDevices(ObjectBroker objectBroker) {
    log.info("KNX ETS device loader starting. - connectorsConfig: " + connectorsConfig);
    setConfiguration(connectorsConfig);/*w ww  .  j  ava  2s .  c o  m*/

    ArrayList<Connector> connectors = new ArrayList<Connector>();

    log.info("connectors config now: " + connectorsConfig);
    Object knxConnectors = connectorsConfig.getProperty("knx-ets.connector.name");

    int connectorsSize = 0;

    if (knxConnectors != null) {
        connectorsSize = 1;
    }

    if (knxConnectors instanceof Collection<?>) {
        connectorsSize = ((Collection<?>) knxConnectors).size();
    }

    // Networks
    List networks = new List();
    networks.setName("networks");
    networks.setOf(new Contract(Network.CONTRACT));
    networks.setHref(new Uri("/networks"));

    boolean networkEnabled = false;

    for (int connector = 0; connector < connectorsSize; connector++) {
        HierarchicalConfiguration subConfig = connectorsConfig
                .configurationAt("knx-ets.connector(" + connector + ")");

        // String connectorName = subConfig.getString("name");
        String routerIP = subConfig.getString("router.ip");
        int routerPort = subConfig.getInteger("router.port", 3671);
        String localIP = subConfig.getString("localIP");
        Boolean enabled = subConfig.getBoolean("enabled", false);
        Boolean forceRefresh = subConfig.getBoolean("forceRefresh", false);
        String knxProj = subConfig.getString("knx-proj");

        Boolean enableGroupComm = subConfig.getBoolean("groupCommEnabled", false);

        Boolean enableHistories = subConfig.getBoolean("historyEnabled", false);

        if (enabled) {
            if (!networkEnabled) {
                objectBroker.addObj(networks, true);
                networkEnabled = true;
            }
            File file = new File(knxProj);

            if (!file.exists() || file.isDirectory() || !file.getName().endsWith(".knxproj")
                    || file.getName().length() < 8) {
                log.warning("KNX project file " + knxProj + " is not a valid KNX project file.");
                continue;
            }

            String projDirName = knxProj.substring(0, knxProj.length() - 8);

            File projDir = new File(projDirName);

            if (!projDir.exists() || forceRefresh) {
                log.info("Expanding " + knxProj + " into directory " + projDirName);
                unZip(knxProj, projDirName);
            }

            String directory = "./" + knxProj.substring(knxProj.indexOf("/") + 1).replaceFirst(".knxproj", "");

            // now the unpacked ETS project should be available in the directory
            String transformFileName = knxProj.replaceFirst(".knxproj", "") + "/"
                    + file.getName().replaceFirst(".knxproj", "") + ".xml";

            File transformFile = new File(transformFileName);

            if (!transformFile.exists() || forceRefresh) {
                log.info("Transforming ETS configuration.");
                //               System.setProperty("javax.xml.transform.TransformerFactory", "net.sf.saxon.TransformerFactoryImpl");
                // Create a transform factory instance.
                TransformerFactory tfactory = TransformerFactory.newInstance();

                // Create a transformer for the stylesheet.
                Transformer transformer;

                try {
                    transformer = tfactory.newTransformer(new StreamSource("knx-config/stylesheet_knx.xsl"));
                    Collection<File> listFiles = FileUtils.listFiles(projDir,
                            FileFilterUtils.nameFileFilter("0.xml"), new IOFileFilter() {

                                @Override
                                public boolean accept(File file) {
                                    return true;
                                }

                                @Override
                                public boolean accept(File dir, String name) {
                                    return true;
                                }

                            });
                    if (listFiles.size() != 1) {
                        log.severe("Found no or more than one 0.xml file in " + projDirName);
                        continue;
                    }

                    log.info("Transforming with directory parameter set to " + directory);

                    transformer.setParameter("directory", directory);
                    transformer.transform(new StreamSource(listFiles.iterator().next().getAbsoluteFile()),
                            new StreamResult(transformFileName));

                    log.info("Transformation completed and result written to: " + transformFileName);
                } catch (TransformerConfigurationException e) {
                    e.printStackTrace();
                } catch (TransformerException e) {
                    e.printStackTrace();
                }
            }

            try {
                devicesConfig = new XMLConfiguration(transformFileName);
            } catch (Exception e) {
                log.log(Level.SEVERE, e.getMessage(), e);
            }

            KNXConnector knxConnector = new KNXConnector(routerIP, routerPort, localIP);

            connect(knxConnector);

            initNetworks(knxConnector, objectBroker, networks, enableGroupComm, enableHistories);

            connectors.add(knxConnector);
        }
    }

    return connectors;
}

From source file:net.datenwerke.sandbox.util.SandboxParser.java

protected void configureThreadRestrictions(SandboxContext context, HierarchicalConfiguration contextConf) {
    long maximumRunTime = contextConf.getLong("[@maximumRunTime]", -1);
    context.setMaximumRunTime(maximumRunTime);

    String maximumRunTimeUnit = contextConf.getString("[@maximumRunTimeUnit]", null);
    if (null != maximumRunTimeUnit && !"".equals(maximumRunTimeUnit.trim()))
        context.setMaximumRunTimeUnit(TimeUnit.valueOf(maximumRunTimeUnit.toUpperCase()));

    String maximumRunTimeMode = contextConf.getString("[@maximumRunTimeMode]", null);
    if (null != maximumRunTimeMode && !"".equals(maximumRunTimeMode.trim()))
        context.setMaximumRuntimeMode(RuntimeMode.valueOf(maximumRunTimeMode.toUpperCase()));

    int maxStackDepth = contextConf.getInteger("[@maximumStackDepth]", -1);
    context.setMaximumStackDepth(maxStackDepth);
}

From source file:org.apache.james.http.jetty.JettyHttpServerFactory.java

private Configuration buildConfiguration(HierarchicalConfiguration serverConfig) {
    Builder builder = Configuration.builder();

    boolean randomPort = serverConfig.getBoolean("port[@random]", false);
    Integer port = serverConfig.getInteger("port[@fixed]", null);
    if (randomPort && port != null) {
        throw new ConfigurationException("Random port is not compatible with fixed port");
    }/*w w  w. j  av a2 s.c o m*/
    if (randomPort) {
        builder.randomPort();
    }
    if (port != null) {
        builder.port(port);
    }
    for (HierarchicalConfiguration mapping : serverConfig.configurationsAt("mappings.mapping")) {
        String classname = mapping.getString("servlet");
        Class<? extends Servlet> servletClass = findServlet(classname);
        builder.serve(mapping.getString("path")).with(servletClass);
    }
    for (HierarchicalConfiguration mapping : serverConfig.configurationsAt("filters.mapping")) {
        String classname = mapping.getString("filter");
        Class<? extends Filter> filterClass = findFilter(classname);
        builder.filter(mapping.getString("path")).with(filterClass);
    }
    return builder.build();
}