Example usage for org.apache.commons.configuration Configuration getBoolean

List of usage examples for org.apache.commons.configuration Configuration getBoolean

Introduction

In this page you can find the example usage for org.apache.commons.configuration Configuration getBoolean.

Prototype

Boolean getBoolean(String key, Boolean defaultValue);

Source Link

Document

Get a Boolean associated with the given configuration key.

Usage

From source file:com.cisco.oss.foundation.http.netlifx.apache.ApacheNetflixHttpClient.java

private InternalServerProxyMetadata loadServersMetadataConfiguration() {

    Configuration subset = ConfigurationFactory.getConfiguration().subset(getApiName());
    final Iterator<String> keysIterator = subset.getKeys();

    // read default values
    int readTimeout = subset.getInt("http." + LoadBalancerConstants.READ_TIME_OUT,
            LoadBalancerConstants.DEFAULT_READ_TIMEOUT);
    int connectTimeout = subset.getInt("http." + LoadBalancerConstants.CONNECT_TIME_OUT,
            LoadBalancerConstants.DEFAULT_CONNECT_TIMEOUT);
    long waitingTime = subset.getLong("http." + LoadBalancerConstants.WAITING_TIME,
            LoadBalancerConstants.DEFAULT_WAITING_TIME);
    int numberOfAttempts = subset.getInt("http." + LoadBalancerConstants.NUMBER_OF_ATTEMPTS,
            LoadBalancerConstants.DEFAULT_NUMBER_OF_ATTEMPTS);
    long retryDelay = subset.getLong("http." + LoadBalancerConstants.RETRY_DELAY,
            LoadBalancerConstants.DEFAULT_RETRY_DELAY);

    long idleTimeout = subset.getLong("http." + LoadBalancerConstants.IDLE_TIME_OUT,
            LoadBalancerConstants.DEFAULT_IDLE_TIMEOUT);
    int maxConnectionsPerAddress = subset.getInt("http." + LoadBalancerConstants.MAX_CONNECTIONS_PER_ADDRESS,
            LoadBalancerConstants.DEFAULT_MAX_CONNECTIONS_PER_ADDRESS);
    int maxConnectionsTotal = subset.getInt("http." + LoadBalancerConstants.MAX_CONNECTIONS_TOTAL,
            LoadBalancerConstants.DEFAULT_MAX_CONNECTIONS_TOTAL);
    int maxQueueSizePerAddress = subset.getInt("http." + LoadBalancerConstants.MAX_QUEUE_PER_ADDRESS,
            LoadBalancerConstants.DEFAULT_MAX_QUEUE_PER_ADDRESS);
    boolean followRedirects = subset.getBoolean("http." + LoadBalancerConstants.FOLLOW_REDIRECTS, false);
    boolean disableCookies = subset.getBoolean("http." + LoadBalancerConstants.DISABLE_COOKIES, false);
    boolean autoCloseable = subset.getBoolean("http." + LoadBalancerConstants.AUTO_CLOSEABLE, true);
    boolean autoEncodeUri = subset.getBoolean("http." + LoadBalancerConstants.AUTO_ENCODE_URI, true);
    boolean staleConnectionCheckEnabled = subset
            .getBoolean("http." + LoadBalancerConstants.IS_STALE_CONN_CHECK_ENABLED, false);
    boolean serviceDirectoryEnabled = subset
            .getBoolean("http." + LoadBalancerConstants.SERVICE_DIRECTORY_IS_ENABLED, false);
    String serviceName = subset.getString("http." + LoadBalancerConstants.SERVICE_DIRECTORY_SERVICE_NAME,
            "UNKNOWN");

    String keyStorePath = subset.getString("http." + LoadBalancerConstants.KEYSTORE_PATH, "");
    String keyStorePassword = subset.getString("http." + LoadBalancerConstants.KEYSTORE_PASSWORD, "");
    String trustStorePath = subset.getString("http." + LoadBalancerConstants.TRUSTSTORE_PATH, "");
    String trustStorePassword = subset.getString("http." + LoadBalancerConstants.TRUSTSTORE_PASSWORD, "");
    startEurekaClient = subset.getBoolean("http.startEurekaClient", true);

    final List<String> keys = new ArrayList<String>();

    while (keysIterator.hasNext()) {
        String key = keysIterator.next();
        keys.add(key);//from  ww  w.j  av  a 2  s  .  c om
    }

    Collections.sort(keys);

    List<Pair<String, Integer>> hostAndPortPairs = new CopyOnWriteArrayList<Pair<String, Integer>>();

    for (String key : keys) {

        if (key.contains(LoadBalancerConstants.HOST)) {

            String host = subset.getString(key);

            // trim the host name
            if (org.apache.commons.lang.StringUtils.isNotEmpty(host)) {
                host = host.trim();
            }
            final String portKey = key.replace(LoadBalancerConstants.HOST, LoadBalancerConstants.PORT);
            if (subset.containsKey(portKey)) {
                int port = subset.getInt(portKey);
                // save host and port for future creation of server list
                hostAndPortPairs.add(Pair.of(host, port));
            }
        }

    }

    InternalServerProxyMetadata metadata = new InternalServerProxyMetadata(readTimeout, connectTimeout,
            idleTimeout, maxConnectionsPerAddress, maxConnectionsTotal, maxQueueSizePerAddress, waitingTime,
            numberOfAttempts, retryDelay, hostAndPortPairs, keyStorePath, keyStorePassword, trustStorePath,
            trustStorePassword, followRedirects, autoCloseable, staleConnectionCheckEnabled, disableCookies,
            serviceDirectoryEnabled, serviceName, autoEncodeUri);
    //        metadata.getHostAndPortPairs().addAll(hostAndPortPairs);
    //        metadata.setReadTimeout(readTimeout);
    //        metadata.setConnectTimeout(connectTimeout);
    //        metadata.setNumberOfRetries(numberOfAttempts);
    //        metadata.setRetryDelay(retryDelay);
    //        metadata.setWaitingTime(waitingTime);

    return metadata;

}

From source file:net.sf.jclal.activelearning.multilabel.querystrategy.MultiLabelDensityDiversityQueryStrategy.java

/**
 *
 * @param configuration Configuration object for density diversity strategy.
 *
 * The XML labels supported are:/*from w  w w . ja  v  a 2  s . c om*/
 * <ul>
 * <li><b>importance-density= double</b></li>
 * <li>
 * <b>distance-function type= class</b>
 * <p>
 * Package: net.sf.jclal.util.distancefunction
 * </p>
 * <p>
 * Class: All
 * </p>
 * <p>
 * Package: weka.core
 * </p>
 * <p>
 * Class: EuclideanDistance || ManhattanDistance || MinkowskiDistance...</p>
 * </li>
 * <li>matrix-file= boolean</li>
 * <li>
 * <b>sub-query-strategy type= class</b>
 * <p>
 * Package: net.sf.jclal.activelearning.multilabel.querystrategy</p>
 * <p>
 * Class: All</p>
 * </li>
 * </ul>
 */
@Override
public void configure(Configuration configuration) {

    try {
        super.configure(configuration);
    } catch (Exception e) {
    }

    // Set relativeImportanceOfDensity
    double currentImportance = configuration.getDouble("importance-density", relativeImportanceOfDensity);

    setRelativeImportanceOfDensity(currentImportance);

    String distanceError = "distance-function type= ";
    try {

        // Set the distance classname
        String distanceClassname = configuration.getString("distance-function[@type]");
        distanceError += distanceClassname;

        // the distance class
        Class<? extends NormalizableDistance> distance = (Class<? extends NormalizableDistance>) Class
                .forName(distanceClassname);

        // the distance instance
        NormalizableDistance currentDistance = distance.newInstance();

        // Configure the distance
        if (currentDistance instanceof IConfigure) {
            ((IConfigure) currentDistance).configure(configuration.subset("distance-function"));
        }

        // Set the distance
        setTypeOfDistance(currentDistance);
    } catch (ClassNotFoundException e) {
        throw new ConfigurationRuntimeException("Illegal distance classname: " + distanceError, e);
    } catch (InstantiationException e) {
        throw new ConfigurationRuntimeException("Illegal distance classname: " + distanceError, e);
    } catch (IllegalAccessException e) {
        throw new ConfigurationRuntimeException("Illegal distance classname: " + distanceError, e);
    }

    // Set the sub query strategy
    String subError = "sub-query-strategy type= ";
    try {
        // sub Query strategy classname
        String strategyClassname = configuration.getString("sub-query-strategy[@type]");
        subError += strategyClassname;
        // sub Query strategy class
        Class<? extends IQueryStrategy> strategyClass = (Class<? extends IQueryStrategy>) Class
                .forName(strategyClassname);
        // sub Query strategy instance
        IQueryStrategy currentSubStrategy = strategyClass.newInstance();

        // Configure sub Query strategy (if necessary)
        if (currentSubStrategy instanceof IConfigure) {
            ((IConfigure) currentSubStrategy).configure(configuration.subset("sub-query-strategy"));
        }
        // Set the sub Query strategy
        setSubQueryStrategy(currentSubStrategy);
    } catch (ClassNotFoundException e) {
        throw new ConfigurationRuntimeException("Illegal sub-query-strategy classname: " + subError, e);
    } catch (InstantiationException e) {
        throw new ConfigurationRuntimeException("Illegal sub-query-strategy classname: " + subError, e);
    } catch (IllegalAccessException e) {
        throw new ConfigurationRuntimeException("Illegal sub-query-strategy classname: " + subError, e);
    }

    //Set if handle the matrix over a file and not over the main memory
    boolean matrixFile = configuration.getBoolean("matrix-file", matrixOverFile);

    setMatrixOverFile(matrixFile);
}

From source file:ching.icecreaming.action.ViewAction.java

@Action(value = "view", results = { @Result(name = "login", location = "edit.jsp"),
        @Result(name = "input", location = "view.jsp"), @Result(name = "success", location = "view.jsp"),
        @Result(name = "error", location = "error.jsp") })
public String execute() throws Exception {
    Enumeration enumerator = null;
    String[] array1 = null, array2 = null;
    int int1 = -1, int2 = -1, int3 = -1;
    InputStream inputStream1 = null;
    OutputStream outputStream1 = null;
    java.io.File file1 = null, file2 = null, dir1 = null;
    List<File> files = null;
    HttpHost httpHost1 = null;//  w  ww. j a  va  2 s.  c  o m
    HttpGet httpGet1 = null, httpGet2 = null;
    HttpPut httpPut1 = null;
    URI uri1 = null;
    URL url1 = null;
    DefaultHttpClient httpClient1 = null;
    URIBuilder uriBuilder1 = null, uriBuilder2 = null;
    HttpResponse httpResponse1 = null, httpResponse2 = null;
    HttpEntity httpEntity1 = null, httpEntity2 = null;
    List<NameValuePair> nameValuePair1 = null;
    String string1 = null, string2 = null, string3 = null, string4 = null, return1 = LOGIN;
    XMLConfiguration xmlConfiguration = null;
    List<HierarchicalConfiguration> list1 = null, list2 = null;
    HierarchicalConfiguration hierarchicalConfiguration2 = null;
    DataModel1 dataModel1 = null;
    DataModel2 dataModel2 = null;
    List<DataModel1> listObject1 = null, listObject3 = null;
    org.joda.time.DateTime dateTime1 = null, dateTime2 = null;
    org.joda.time.Period period1 = null;
    PeriodFormatter periodFormatter1 = new PeriodFormatterBuilder().appendYears()
            .appendSuffix(String.format(" %s", getText("year")), String.format(" %s", getText("years")))
            .appendSeparator(" ").appendMonths()
            .appendSuffix(String.format(" %s", getText("month")), String.format(" %s", getText("months")))
            .appendSeparator(" ").appendWeeks()
            .appendSuffix(String.format(" %s", getText("week")), String.format(" %s", getText("weeks")))
            .appendSeparator(" ").appendDays()
            .appendSuffix(String.format(" %s", getText("day")), String.format(" %s", getText("days")))
            .appendSeparator(" ").appendHours()
            .appendSuffix(String.format(" %s", getText("hour")), String.format(" %s", getText("hours")))
            .appendSeparator(" ").appendMinutes()
            .appendSuffix(String.format(" %s", getText("minute")), String.format(" %s", getText("minutes")))
            .appendSeparator(" ").appendSeconds().minimumPrintedDigits(2)
            .appendSuffix(String.format(" %s", getText("second")), String.format(" %s", getText("seconds")))
            .printZeroNever().toFormatter();
    if (StringUtils.isBlank(urlString) || StringUtils.isBlank(wsType)) {
        urlString = portletPreferences.getValue("urlString", "/");
        wsType = portletPreferences.getValue("wsType", "folder");
    }
    Configuration propertiesConfiguration1 = new PropertiesConfiguration("system.properties");
    timeZone1 = portletPreferences.getValue("timeZone", TimeZone.getDefault().getID());
    enumerator = portletPreferences.getNames();
    if (enumerator.hasMoreElements()) {
        array1 = portletPreferences.getValues("server", null);
        if (array1 != null) {
            if (ArrayUtils.isNotEmpty(array1)) {
                for (int1 = 0; int1 < array1.length; int1++) {
                    switch (int1) {
                    case 0:
                        sid = array1[int1];
                        break;
                    case 1:
                        uid = array1[int1];
                        break;
                    case 2:
                        pid = array1[int1];
                        break;
                    case 3:
                        alias1 = array1[int1];
                        break;
                    default:
                        break;
                    }
                }
                sid = new String(Base64.decodeBase64(sid.getBytes()));
                uid = new String(Base64.decodeBase64(uid.getBytes()));
                pid = new String(Base64.decodeBase64(pid.getBytes()));
            }
            return1 = INPUT;
        } else {
            return1 = LOGIN;
        }
    } else {
        return1 = LOGIN;
    }

    if (StringUtils.equals(urlString, "/")) {

        if (listObject1 != null) {
            listObject1.clear();
        }
        if (session.containsKey("breadcrumbs")) {
            session.remove("breadcrumbs");
        }
    } else {
        array2 = StringUtils.split(urlString, "/");
        listObject1 = (session.containsKey("breadcrumbs")) ? (List<DataModel1>) session.get("breadcrumbs")
                : new ArrayList<DataModel1>();
        int2 = array2.length - listObject1.size();
        if (int2 > 0) {
            listObject1.add(new DataModel1(urlString, label1));
        } else {
            int2 += listObject1.size();
            for (int1 = listObject1.size() - 1; int1 >= int2; int1--) {
                listObject1.remove(int1);
            }
        }
        session.put("breadcrumbs", listObject1);
    }
    switch (wsType) {
    case "folder":
        break;
    case "reportUnit":
        try {
            dateTime1 = new org.joda.time.DateTime();
            return1 = INPUT;
            httpClient1 = new DefaultHttpClient();
            if (StringUtils.equals(button1, getText("Print"))) {
                nameValuePair1 = new ArrayList<NameValuePair>();
                if (listObject2 != null) {
                    if (listObject2.size() > 0) {
                        for (DataModel2 dataObject2 : listObject2) {
                            listObject3 = dataObject2.getOptions();
                            if (listObject3 == null) {
                                string2 = dataObject2.getValue1();
                                if (StringUtils.isNotBlank(string2))
                                    nameValuePair1.add(new BasicNameValuePair(dataObject2.getId(), string2));
                            } else {
                                for (int1 = listObject3.size() - 1; int1 >= 0; int1--) {
                                    dataModel1 = (DataModel1) listObject3.get(int1);
                                    string2 = dataModel1.getString2();
                                    if (StringUtils.isNotBlank(string2))
                                        nameValuePair1
                                                .add(new BasicNameValuePair(dataObject2.getId(), string2));
                                }
                            }
                        }
                    }
                }
                url1 = new URL(sid);
                uriBuilder1 = new URIBuilder(sid);
                uriBuilder1.setUserInfo(uid, pid);
                if (StringUtils.isBlank(format1))
                    format1 = "pdf";
                uriBuilder1.setPath(url1.getPath() + "/rest_v2/reports" + urlString + "." + format1);
                if (StringUtils.isNotBlank(locale2)) {
                    nameValuePair1.add(new BasicNameValuePair("userLocale", locale2));
                }
                if (StringUtils.isNotBlank(page1)) {
                    if (NumberUtils.isNumber(page1)) {
                        nameValuePair1.add(new BasicNameValuePair("page", page1));
                    }
                }
                if (nameValuePair1.size() > 0) {
                    uriBuilder1.setQuery(URLEncodedUtils.format(nameValuePair1, "UTF-8"));
                }
                uri1 = uriBuilder1.build();
                httpGet1 = new HttpGet(uri1);
                httpResponse1 = httpClient1.execute(httpGet1);
                int1 = httpResponse1.getStatusLine().getStatusCode();
                if (int1 == HttpStatus.SC_OK) {
                    string3 = System.getProperty("java.io.tmpdir") + File.separator
                            + httpServletRequest.getSession().getId();
                    dir1 = new File(string3);
                    if (!dir1.exists()) {
                        dir1.mkdir();
                    }
                    httpEntity1 = httpResponse1.getEntity();
                    file1 = new File(string3, StringUtils.substringAfterLast(urlString, "/") + "." + format1);
                    if (StringUtils.equalsIgnoreCase(format1, "html")) {
                        result1 = EntityUtils.toString(httpEntity1);
                        FileUtils.writeStringToFile(file1, result1);
                        array1 = StringUtils.substringsBetween(result1, "<img src=\"", "\"");
                        if (ArrayUtils.isNotEmpty(array1)) {
                            dir1 = new File(
                                    string3 + File.separator + FilenameUtils.getBaseName(file1.getName()));
                            if (dir1.exists()) {
                                FileUtils.deleteDirectory(dir1);
                            }
                            file2 = new File(FilenameUtils.getFullPath(file1.getAbsolutePath())
                                    + FilenameUtils.getBaseName(file1.getName()) + ".zip");
                            if (file2.exists()) {
                                if (FileUtils.deleteQuietly(file2)) {
                                }
                            }
                            for (int2 = 0; int2 < array1.length; int2++) {
                                try {
                                    string2 = url1.getPath() + "/rest_v2/reports" + urlString + "/"
                                            + StringUtils.substringAfter(array1[int2], "/");
                                    uriBuilder1.setPath(string2);
                                    uri1 = uriBuilder1.build();
                                    httpGet1 = new HttpGet(uri1);
                                    httpResponse1 = httpClient1.execute(httpGet1);
                                    int1 = httpResponse1.getStatusLine().getStatusCode();
                                } finally {
                                    if (int1 == HttpStatus.SC_OK) {
                                        try {
                                            string2 = StringUtils.substringBeforeLast(array1[int2], "/");
                                            dir1 = new File(string3 + File.separator + string2);
                                            if (!dir1.exists()) {
                                                dir1.mkdirs();
                                            }
                                            httpEntity1 = httpResponse1.getEntity();
                                            inputStream1 = httpEntity1.getContent();
                                        } finally {
                                            string1 = StringUtils.substringAfterLast(array1[int2], "/");
                                            file2 = new File(string3 + File.separator + string2, string1);
                                            outputStream1 = new FileOutputStream(file2);
                                            IOUtils.copy(inputStream1, outputStream1);
                                        }
                                    }
                                }
                            }
                            outputStream1 = new FileOutputStream(
                                    FilenameUtils.getFullPath(file1.getAbsolutePath())
                                            + FilenameUtils.getBaseName(file1.getName()) + ".zip");
                            ArchiveOutputStream archiveOutputStream1 = new ArchiveStreamFactory()
                                    .createArchiveOutputStream(ArchiveStreamFactory.ZIP, outputStream1);
                            archiveOutputStream1.putArchiveEntry(new ZipArchiveEntry(file1, file1.getName()));
                            IOUtils.copy(new FileInputStream(file1), archiveOutputStream1);
                            archiveOutputStream1.closeArchiveEntry();
                            dir1 = new File(FilenameUtils.getFullPath(file1.getAbsolutePath())
                                    + FilenameUtils.getBaseName(file1.getName()));
                            files = (List<File>) FileUtils.listFiles(dir1, TrueFileFilter.INSTANCE,
                                    TrueFileFilter.INSTANCE);
                            for (File file3 : files) {
                                archiveOutputStream1.putArchiveEntry(new ZipArchiveEntry(file3, StringUtils
                                        .substringAfter(file3.getCanonicalPath(), string3 + File.separator)));
                                IOUtils.copy(new FileInputStream(file3), archiveOutputStream1);
                                archiveOutputStream1.closeArchiveEntry();
                            }
                            archiveOutputStream1.close();
                        }
                        bugfixGateIn = propertiesConfiguration1.getBoolean("bugfixGateIn", false);
                        string4 = bugfixGateIn
                                ? String.format("<img src=\"%s/namespace1/file-link?sessionId=%s&fileName=",
                                        portletRequest.getContextPath(),
                                        httpServletRequest.getSession().getId())
                                : String.format("<img src=\"%s/namespace1/file-link?fileName=",
                                        portletRequest.getContextPath());
                        result1 = StringUtils.replace(result1, "<img src=\"", string4);
                    } else {
                        inputStream1 = httpEntity1.getContent();
                        outputStream1 = new FileOutputStream(file1);
                        IOUtils.copy(inputStream1, outputStream1);
                        result1 = file1.getAbsolutePath();
                    }
                    return1 = SUCCESS;
                } else {
                    addActionError(String.format("%s %d: %s", getText("Error"), int1,
                            getText(Integer.toString(int1))));
                }
                dateTime2 = new org.joda.time.DateTime();
                period1 = new Period(dateTime1, dateTime2.plusSeconds(1));
                message1 = getText("Execution.time") + ": " + periodFormatter1.print(period1);
            } else {
                url1 = new URL(sid);
                uriBuilder1 = new URIBuilder(sid);
                uriBuilder1.setUserInfo(uid, pid);
                uriBuilder1.setPath(url1.getPath() + "/rest_v2/reports" + urlString + "/inputControls");
                uri1 = uriBuilder1.build();
                httpGet1 = new HttpGet(uri1);
                httpResponse1 = httpClient1.execute(httpGet1);
                int1 = httpResponse1.getStatusLine().getStatusCode();
                switch (int1) {
                case HttpStatus.SC_NO_CONTENT:
                    break;
                case HttpStatus.SC_OK:
                    httpEntity1 = httpResponse1.getEntity();
                    if (httpEntity1 != null) {
                        inputStream1 = httpEntity1.getContent();
                        if (inputStream1 != null) {
                            xmlConfiguration = new XMLConfiguration();
                            xmlConfiguration.load(inputStream1);
                            list1 = xmlConfiguration.configurationsAt("inputControl");
                            if (list1.size() > 0) {
                                listObject2 = new ArrayList<DataModel2>();
                                for (HierarchicalConfiguration hierarchicalConfiguration1 : list1) {
                                    string2 = hierarchicalConfiguration1.getString("type");
                                    dataModel2 = new DataModel2();
                                    dataModel2.setId(hierarchicalConfiguration1.getString("id"));
                                    dataModel2.setLabel1(hierarchicalConfiguration1.getString("label"));
                                    dataModel2.setType1(string2);
                                    dataModel2.setMandatory(hierarchicalConfiguration1.getBoolean("mandatory"));
                                    dataModel2.setReadOnly(hierarchicalConfiguration1.getBoolean("readOnly"));
                                    dataModel2.setVisible(hierarchicalConfiguration1.getBoolean("visible"));
                                    switch (string2) {
                                    case "bool":
                                    case "singleValueText":
                                    case "singleValueNumber":
                                    case "singleValueDate":
                                    case "singleValueDatetime":
                                        hierarchicalConfiguration2 = hierarchicalConfiguration1
                                                .configurationAt("state");
                                        dataModel2.setValue1(hierarchicalConfiguration2.getString("value"));
                                        break;
                                    case "singleSelect":
                                    case "singleSelectRadio":
                                    case "multiSelect":
                                    case "multiSelectCheckbox":
                                        hierarchicalConfiguration2 = hierarchicalConfiguration1
                                                .configurationAt("state");
                                        list2 = hierarchicalConfiguration2.configurationsAt("options.option");
                                        if (list2.size() > 0) {
                                            listObject3 = new ArrayList<DataModel1>();
                                            for (HierarchicalConfiguration hierarchicalConfiguration3 : list2) {
                                                dataModel1 = new DataModel1(
                                                        hierarchicalConfiguration3.getString("label"),
                                                        hierarchicalConfiguration3.getString("value"));
                                                if (hierarchicalConfiguration3.getBoolean("selected")) {
                                                    dataModel2.setValue1(
                                                            hierarchicalConfiguration3.getString("value"));
                                                }
                                                listObject3.add(dataModel1);
                                            }
                                            dataModel2.setOptions(listObject3);
                                        }
                                        break;
                                    default:
                                        break;
                                    }
                                    listObject2.add(dataModel2);
                                }
                            }
                        }
                    }
                    break;
                default:
                    addActionError(String.format("%s %d: %s", getText("Error"), int1,
                            getText(Integer.toString(int1))));
                    break;
                }
                if (httpEntity1 != null) {
                    EntityUtils.consume(httpEntity1);
                }
                uriBuilder1.setPath(url1.getPath() + "/rest/resource" + urlString);
                uri1 = uriBuilder1.build();
                httpGet1 = new HttpGet(uri1);
                httpResponse1 = httpClient1.execute(httpGet1);
                int2 = httpResponse1.getStatusLine().getStatusCode();
                if (int2 == HttpStatus.SC_OK) {
                    httpEntity1 = httpResponse1.getEntity();
                    inputStream1 = httpEntity1.getContent();
                    xmlConfiguration = new XMLConfiguration();
                    xmlConfiguration.load(inputStream1);
                    list1 = xmlConfiguration.configurationsAt("resourceDescriptor");
                    for (HierarchicalConfiguration hierarchicalConfiguration4 : list1) {
                        if (StringUtils.equalsIgnoreCase(
                                StringUtils.trim(hierarchicalConfiguration4.getString("[@wsType]")), "prop")) {
                            if (map1 == null)
                                map1 = new HashMap<String, String>();
                            string2 = StringUtils.substringBetween(
                                    StringUtils.substringAfter(
                                            hierarchicalConfiguration4.getString("[@uriString]"), "_files/"),
                                    "_", ".properties");
                            map1.put(string2,
                                    StringUtils.isBlank(string2) ? getText("Default") : getText(string2));
                        }
                    }
                }
                if (httpEntity1 != null) {
                    EntityUtils.consume(httpEntity1);
                }
            }
        } catch (IOException | ConfigurationException | URISyntaxException exception1) {
            exception1.printStackTrace();
            addActionError(exception1.getLocalizedMessage());
            httpGet1.abort();
            return ERROR;
        } finally {
            httpClient1.getConnectionManager().shutdown();
            IOUtils.closeQuietly(inputStream1);
        }
        break;
    default:
        addActionError(getText("This.file.type.is.not.supported"));
        break;
    }
    if (return1 != LOGIN) {
        sid = new String(Base64.encodeBase64(sid.getBytes()));
        uid = new String(Base64.encodeBase64(uid.getBytes()));
        pid = new String(Base64.encodeBase64(pid.getBytes()));
    }
    return return1;
}

From source file:nl.salp.warcraft4j.config.PropertyWarcraft4jConfig.java

/**
 * Initialise the instance from a configuration.
 *
 * @param configuration The configuration.
 *
 * @throws Warcraft4jConfigException When the configuration is invalid.
 *///from ww  w  .jav  a2s.  c  om

private void initialise(Configuration configuration) throws Warcraft4jConfigException {
    if (configuration == null || configuration.isEmpty()) {
        throw new Warcraft4jConfigException(
                "Can't create a Warcraft4J configuration from an empty configuration.");
    }
    online = configuration.getBoolean(ONLINE_KEY, ONLINE_DEFAULT);

    wowDir = Paths.get(configuration.getString(WOW_DIR_KEY, WOW_DIR_DEFAULT));
    if (Files.notExists(wowDir) || !Files.isDirectory(wowDir) || !Files.isReadable(wowDir)) {
        throw new Warcraft4jConfigException(
                format("WoW installation directory %s does not exist or can't be read.", wowDir));
    }

    cache = configuration.getBoolean(CACHE_KEY, CACHE_DEFAULT);
    if (cache) {
        cacheDir = Paths.get(configuration.getString(CACHE_DIR_KEY, CACHE_DIR_DEFAULT));
        if (Files.notExists(cacheDir)) {
            try {
                cacheDir = Files.createDirectories(cacheDir);
            } catch (IOException e) {
                throw new Warcraft4jConfigException(format("Unable to create cache directory %s.", cacheDir),
                        e);
            }
        } else if (!Files.isDirectory(cacheDir)) {
            throw new Warcraft4jConfigException(format("Cache directory %s is not a directory.", cacheDir));
        } else if (!Files.isReadable(cacheDir) || !Files.isWritable(cacheDir)) {
            throw new Warcraft4jConfigException(format("Cache directory %s is not accessible.", cacheDir));
        }
    }
    locale = Locale.getLocale(configuration.getString(LOCALE_KEY))
            .orElseThrow(() -> new Warcraft4jConfigException(
                    format("Locale %s is not a valid locale.", configuration.getString(LOCALE_KEY))));
    region = Region.getRegion(configuration.getString(REGION_KEY))
            .orElseThrow(() -> new Warcraft4jConfigException(
                    format("Region %s is not a valid region.", configuration.getString(REGION_KEY))));
    branch = Branch.getBranch(configuration.getString(BRANCH_KEY))
            .orElseThrow(() -> new Warcraft4jConfigException(
                    format("Branch %s is not a valid branch.", configuration.getString(BRANCH_KEY))));
}

From source file:nl.salp.warcraft4j.dev.DevToolsConfig.java

private void initialise(Configuration configuration) {
    if (configuration == null || configuration.isEmpty()) {
        throw new Warcraft4jConfigException(
                "Can't create a Warcraft4J configuration from an empty configuration.");
    }//from www. j  a v  a2  s.  c om
    online = configuration.getBoolean(USE_CDN, USE_CDN_DEFAULT);
    if (!configuration.containsKey(WOW_DIR)) {
        throw new Warcraft4jConfigException("WoW installation directory was not configured.");
    }
    wowDir = Paths.get(resolve(configuration.getString(WOW_DIR), configuration));
    if (Files.notExists(wowDir) || !Files.isDirectory(wowDir) || !Files.isReadable(wowDir)) {
        throw new Warcraft4jConfigException(
                format("WoW installation directory %s does not exist or can't be read.", wowDir));
    }
    w4jDir = Paths.get(resolve(configuration.getString(W4J_DIR), configuration));
    if (Files.notExists(w4jDir)) {
        try {
            Files.createDirectories(w4jDir);
        } catch (IOException e) {
            throw new Warcraft4jConfigException(
                    format("Unable to create Warcraft4J working directory %s.", w4jDir), e);
        }
    } else if (!Files.isDirectory(w4jDir) || !Files.isReadable(w4jDir) || !Files.isWritable(w4jDir)) {
        throw new Warcraft4jConfigException(
                format("Warcraft4J working directory %s is either not a directory or not accessible.", w4jDir));
    }

    listFile = Paths.get(resolve(configuration.getString(LISTFILE, LISTFILE_DEFAULT), configuration));
    if (Files.notExists(listFile) || !Files.isRegularFile(listFile) || !Files.isReadable(listFile)) {
        listFile = null;
    }

    if (configuration.containsKey(DATA_EXTRACTED)) {
        extractDataDir = Paths.get(resolve(configuration.getString(DATA_EXTRACTED), configuration));
        if (Files.notExists(extractDataDir)) {
            try {
                Files.createDirectories(extractDataDir);
            } catch (IOException e) {
                throw new Warcraft4jConfigException(format("Unable to create extracted directory %s.", w4jDir),
                        e);
            }
        } else if (!Files.isDirectory(w4jDir) || !Files.isReadable(w4jDir) || !Files.isWritable(w4jDir)) {
            throw new Warcraft4jConfigException(
                    format("Extracted data directory %s is either not a directory or not accessible.", w4jDir));
        }
    }

    cache = configuration.getBoolean(CDN_CACHE, CDN_CACHE_DEFAULT);
    if (cache) {
        cacheDir = Paths
                .get(resolve(configuration.getString(CDN_CACHE_PATH, CDN_CACHE_PATH_DEFAULT), configuration));
        if (Files.notExists(cacheDir)) {
            try {
                Files.createDirectories(cacheDir);
            } catch (IOException e) {
                throw new Warcraft4jConfigException(format("Unable to create cache directory %s.", cacheDir),
                        e);
            }
        } else if (!Files.isDirectory(cacheDir) || !Files.isReadable(cacheDir) || !Files.isWritable(cacheDir)) {
            throw new Warcraft4jConfigException(
                    format("Cache directory %s is either not a directory or not accessible.", cacheDir));
        }
    }
    locale = Locale
            .getLocale(resolve(configuration.getString(WOW_LOCALE, valueOf(WOW_LOCALE_DEFAULT)), configuration))
            .orElseThrow(() -> new Warcraft4jConfigException(format("Locale %s is not a valid locale.",
                    resolve(configuration.getString(WOW_LOCALE), configuration))));
    region = Region
            .getRegion(resolve(configuration.getString(WOW_REGION, valueOf(WOW_REGION_DEFAULT)), configuration))
            .orElseThrow(() -> new Warcraft4jConfigException(format("Region %s is not a valid region.",
                    resolve(configuration.getString(WOW_REGION), configuration))));
    branch = Branch
            .getBranch(resolve(configuration.getString(WOW_BRANCH, valueOf(WOW_BRANCH_DEFAULT)), configuration))
            .orElseThrow(() -> new Warcraft4jConfigException(format("Branch %s is not a valid branch.",
                    resolve(configuration.getString(WOW_BRANCH), configuration))));
    mongodbUri = configuration.getString(MONGODB_URI, null);
    mongodbUser = configuration.getString(MONGODB_USER, null);
    mongodbPassword = configuration.getString(MONGODB_PASSWORD, null);
    if (configuration.containsKey(NEO4J_DATA_PATH)) {
        neo4jDataPath = Paths.get(resolve(configuration.getString(NEO4J_DATA_PATH), configuration));
        if (Files.notExists(neo4jDataPath)) {
            try {
                Files.createDirectories(neo4jDataPath);
            } catch (IOException e) {
                throw new Warcraft4jConfigException(
                        format("Unable to create Neo4J data directory %s.", neo4jDataPath), e);
            }
        } else if (!Files.isDirectory(neo4jDataPath) || !Files.isReadable(neo4jDataPath)
                || !Files.isWritable(neo4jDataPath)) {
            throw new Warcraft4jConfigException(format(
                    "Neo4J data directory %s is either not a directory or not accessible.", neo4jDataPath));
        }
    }
    neo4jExtUri = configuration.getString(NEO4J_EXT_URI, null);
    neo4jExtUser = configuration.getString(NEO4J_EXT_USER, null);
    neo4jExtPassword = configuration.getString(NEO4J_EXT_PASSWORD, null);
}

From source file:openlr.properties.OpenLRPropertyAccess.java

/**
 * Gets the boolean property value./*from w  w  w.  j  a va 2 s .c o m*/
 * 
 * @param properties
 *            the properties
 * @param property
 *            the property
 * @return the boolean property value
 * @throws OpenLRProcessingException
 *             the open lr processing exception
 */
public static boolean getBooleanPropertyValue(final Configuration properties, final OpenLRProperty property)
        throws OpenLRProcessingException {
    if (property.getPropertyType() != PropertyType.BOOLEAN) {
        String error = property.getKey() + " is not a boolean";
        LOG.error(error);
        throw new OpenLRPropertyException(PropertyError.INVALID_PROPERTY_TYPE, error);
    }
    if (properties == null) {
        return (Boolean) property.getDefault();
    }
    return properties.getBoolean(property.getKey(), (Boolean) property.getDefault());
}

From source file:org.acmsl.queryj.ConfigurationQueryJCommandImpl.java

/**
 * Retrieves the setting for given key.//from www . j  a v a 2 s  .co  m
 * @param key the key.
 * @param defaultValue the default value.
 * @param settings the settings.
 * @return the value for such key.
 */
protected boolean getBooleanSetting(@NotNull final String key, final boolean defaultValue,
        @NotNull final Configuration settings) {
    return settings.getBoolean(key, defaultValue);
}

From source file:org.ambraproject.article.service.BrowseServiceImpl.java

/**
 * Set the configuration class/*from   w ww. j  ava2s.c om*/
 *
 * @param config the configuration class to use
 * @throws ApplicationException if required configuration settings are missing
 */
@Required
public void setConfiguration(Configuration config) throws ApplicationException {
    if (config.containsKey("ambra.services.browse.sortOptions.option")) {
        validSorts = new HashMap();
        displaySorts = new ArrayList();

        HierarchicalConfiguration hc = (HierarchicalConfiguration) config;
        List<HierarchicalConfiguration> sorts = hc.configurationsAt("ambra.services.browse.sortOptions.option");

        for (HierarchicalConfiguration s : sorts) {
            String key = s.getString("[@displayName]");
            String value = s.getString("");
            validSorts.put(key, value);
            displaySorts.add(key);
        }

        ((HierarchicalConfiguration) config).setExpressionEngine(null);
    } else {
        throw new ApplicationException(
                "ambra.services.browse.sortOptions.option not defined " + "in configuration.");
    }

    this.cacheTimeToLive = config.getInt("ambra.services.browse.time", 15) * 60;
    this.useCache = config.getBoolean("ambra.services.browse.cache", true);
}

From source file:org.ambraproject.service.article.BrowseServiceImpl.java

/**
 * Set the configuration class//from   w w w. j  a v a  2  s  .co  m
 *
 * @param config the configuration class to use
 * @throws ApplicationException if required configuration settings are missing
 */
@Required
public void setConfiguration(Configuration config) throws ApplicationException {
    this.cacheTimeToLive = config.getInt("ambra.services.browse.time", 15) * 60;
    this.useCache = config.getBoolean("ambra.services.browse.cache", true);
}

From source file:org.ambraproject.web.DummySSOFilter.java

public void init(final FilterConfig filterConfig) throws ServletException {
    // get params defined in web.xml
    casUrl = filterConfig.getInitParameter("casUrl");
    ssoUrl = filterConfig.getInitParameter("ssoUrl");
    wrap = "true".equalsIgnoreCase(filterConfig.getInitParameter("wrapRequest"));

    // look up any overrides in the ambra configuration
    Configuration configuration = ConfigurationStore.getInstance().getConfiguration();
    String casBaseUrl = configuration.getString("ambra.services.cas.url.base");
    if (casBaseUrl != null)
        casUrl = casBaseUrl;/*from  w w  w  . j  a  v a  2s  .  c om*/

    // final defaults
    if (ssoUrl == null)
        ssoUrl = "/dummy/";

    enabled = configuration.getBoolean(DUMMY_SSO_CONFIG_KEY, false);

    if (enabled)
        log.info("dummy sso enabled");
    else
        log.info("dummy sso disabled (use -D" + DUMMY_SSO_CONFIG_KEY + "=true to enable)");
}