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

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

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.configuration.*
  5. PropertiesConfiguration
  6. containsKey

Introduction

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

Prototype

public boolean containsKey(String key)

Source Link

Usage

From source file:org.xwiki.wikistream.confluence.xml.internal.ConfluenceXMLPackage.java

private void readAttachmentObject(XMLStreamReader xmlReader)
        throws XMLStreamException, WikiStreamException, ConfigurationException, IOException {
    PropertiesConfiguration properties = newProperties();

    int attachmentId = readObjectProperties(xmlReader, properties);

    if (properties.containsKey(KEY_ATTACHMENT_CONTENT)) {
        int pageId = properties.getInt(KEY_ATTACHMENT_CONTENT);

        // Save attachment
        saveAttachmentProperties(properties, pageId, attachmentId);
    }/*from  www.  j  av a  2 s.c  om*/
}

From source file:org.xwiki.wikistream.confluence.xml.internal.ConfluenceXMLPackage.java

private void readSpacePermissionObject(XMLStreamReader xmlReader)
        throws XMLStreamException, ConfigurationException, IOException, WikiStreamException {
    PropertiesConfiguration properties = newProperties();

    int permissionId = readObjectProperties(xmlReader, properties);

    if (properties.containsKey("space")) {
        int spaceId = properties.getInt("space");

        // Save attachment
        saveSpacePermissionsProperties(properties, spaceId, permissionId);
    }/*from w  w w  .  j  a  v a2s. co  m*/
}

From source file:org.xwiki.wikistream.confluence.xml.internal.ConfluenceXMLPackage.java

private void readBodyContentObject(XMLStreamReader xmlReader)
        throws XMLStreamException, ConfigurationException, WikiStreamException, IOException {
    PropertiesConfiguration properties = newProperties();
    properties.setDelimiterParsingDisabled(true);

    readObjectProperties(xmlReader, properties);

    if (properties.containsKey("content")) {
        int pageId = properties.getInt("content");

        savePageProperties(properties, pageId);
    }/*from   w  ww.  ja v  a 2  s.  c o m*/
}

From source file:org.xwiki.wikistream.confluence.xml.internal.input.ConfluenceInputWikiStream.java

@Override
protected void read(Object filter, ConfluenceFilter proxyFilter) throws WikiStreamException {
    // Prepare package
    try {//from   w w  w  .  ja v a  2 s.  c  o m
        this.confluencePackage = new ConfluenceXMLPackage(this.properties.getSource());
    } catch (Exception e) {
        throw new WikiStreamException("Failed to read package", e);
    }

    // Generate users events
    for (int userInt : this.confluencePackage.getUsers()) {
        PropertiesConfiguration userProperties;
        try {
            userProperties = this.confluencePackage.getUserProperties(userInt);
        } catch (ConfigurationException e) {
            throw new WikiStreamException("Failed to get user properties", e);
        }

        String userId = userProperties.getString(ConfluenceXMLPackage.KEY_USER_NAME, String.valueOf(userInt));
        if (this.properties.isConvertToXWiki() && userId.equals("admin")) {
            userId = "Admin";
        }

        FilterEventParameters userParameters = new FilterEventParameters();

        userParameters.put(UserFilter.PARAMETER_FIRSTNAME,
                userProperties.getString(ConfluenceXMLPackage.KEY_USER_FIRSTNAME));
        userParameters.put(UserFilter.PARAMETER_LASTNAME,
                userProperties.getString(ConfluenceXMLPackage.KEY_USER_LASTNAME));
        userParameters.put(UserFilter.PARAMETER_EMAIL,
                userProperties.getString(ConfluenceXMLPackage.KEY_USER_EMAIL));
        userParameters.put(UserFilter.PARAMETER_ACTIVE,
                userProperties.getBoolean(ConfluenceXMLPackage.KEY_USER_ACTIVE));

        try {
            userParameters.put(UserFilter.PARAMETER_REVISION_DATE, this.confluencePackage
                    .getDate(userProperties, ConfluenceXMLPackage.KEY_USER_REVISION_DATE));
            userParameters.put(UserFilter.PARAMETER_CREATION_DATE, this.confluencePackage
                    .getDate(userProperties, ConfluenceXMLPackage.KEY_USER_CREATION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }

        // TODO: no idea how to import/convert the password, probably salted with the Confluence instance id

        // > User
        proxyFilter.beginUser(userId, userParameters);

        // < User
        proxyFilter.endUser(userId, userParameters);
    }

    // Generate users events
    for (int groupInt : this.confluencePackage.getGroups()) {
        PropertiesConfiguration groupProperties;
        try {
            groupProperties = this.confluencePackage.getGroupProperties(groupInt);
        } catch (ConfigurationException e) {
            throw new WikiStreamException("Failed to get group properties", e);
        }

        String groupId = groupProperties.getString(ConfluenceXMLPackage.KEY_GROUP_NAME,
                String.valueOf(groupInt));
        if (this.properties.isConvertToXWiki()) {
            if (groupId.equals("confluence-administrators")) {
                groupId = "XWikiAdminGroup";
            } else if (groupId.equals("confluence-users")) {
                groupId = "XWikiAllGroup";
            }
        }

        FilterEventParameters groupParameters = new FilterEventParameters();

        try {
            groupParameters.put(GroupFilter.PARAMETER_REVISION_DATE, this.confluencePackage
                    .getDate(groupProperties, ConfluenceXMLPackage.KEY_GROUP_REVISION_DATE));
            groupParameters.put(GroupFilter.PARAMETER_CREATION_DATE, this.confluencePackage
                    .getDate(groupProperties, ConfluenceXMLPackage.KEY_GROUP_CREATION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }

        // > Group
        proxyFilter.beginGroup(groupId, groupParameters);

        // Members users
        if (groupProperties.containsKey(ConfluenceXMLPackage.KEY_GROUP_MEMBERUSERS)) {
            List<Integer> users = this.confluencePackage.getIntegertList(groupProperties,
                    ConfluenceXMLPackage.KEY_GROUP_MEMBERUSERS);
            for (Integer memberInt : users) {
                FilterEventParameters memberParameters = new FilterEventParameters();

                try {
                    String memberId = this.confluencePackage.getUserProperties(memberInt)
                            .getString(ConfluenceXMLPackage.KEY_USER_NAME, String.valueOf(memberInt));

                    if (this.properties.isConvertToXWiki() && memberId.equals("admin")) {
                        memberId = "Admin";
                    }

                    proxyFilter.onGroupMemberGroup(memberId, memberParameters);
                } catch (ConfigurationException e) {
                    this.logger.error("Failed to get user properties", e);
                }
            }
        }

        // Members groups
        if (groupProperties.containsKey(ConfluenceXMLPackage.KEY_GROUP_MEMBERGROUPS)) {
            List<Integer> groups = this.confluencePackage.getIntegertList(groupProperties,
                    ConfluenceXMLPackage.KEY_GROUP_MEMBERGROUPS);
            for (Integer memberInt : groups) {
                FilterEventParameters memberParameters = new FilterEventParameters();

                try {
                    String memberId = this.confluencePackage.getGroupProperties(memberInt)
                            .getString(ConfluenceXMLPackage.KEY_GROUP_NAME, String.valueOf(memberInt));

                    if (this.properties.isConvertToXWiki()) {
                        if (memberId.equals("confluence-administrators")) {
                            memberId = "XWikiAdminGroup";
                        } else if (memberId.equals("confluence-users")) {
                            memberId = "XWikiAllGroup";
                        }
                    }

                    proxyFilter.onGroupMemberGroup(memberId, memberParameters);
                } catch (ConfigurationException e) {
                    this.logger.error("Failed to get group properties", e);
                }
            }
        }

        // < Group
        proxyFilter.endGroup(groupId, groupParameters);
    }

    // Generate documents events
    for (Map.Entry<Integer, List<Integer>> entry : this.confluencePackage.getPages().entrySet()) {
        int spaceId = entry.getKey();

        PropertiesConfiguration spaceProperties;
        try {
            spaceProperties = this.confluencePackage.getSpaceProperties(spaceId);
        } catch (ConfigurationException e) {
            throw new WikiStreamException("Failed to get space properties", e);
        }

        String spaceName = spaceProperties.getString(ConfluenceXMLPackage.KEY_SPACE_NAME);
        FilterEventParameters spaceParameters = new FilterEventParameters();

        // > WikiSpace
        proxyFilter.beginWikiSpace(spaceName, spaceParameters);

        // Main page
        if (spaceProperties.containsKey(ConfluenceXMLPackage.KEY_SPACE_DESCRIPTION)) {
            readPage(spaceProperties.getInt(ConfluenceXMLPackage.KEY_SPACE_DESCRIPTION), filter, proxyFilter);
        }

        // Other pages
        for (int pageId : entry.getValue()) {
            readPage(pageId, filter, proxyFilter);
        }

        // < WikiSpace
        proxyFilter.endWikiSpace(spaceName, spaceParameters);
    }

    // Cleanup

    try {
        this.confluencePackage.close();
    } catch (IOException e) {
        throw new WikiStreamException("Failed to close package", e);
    }
}

From source file:org.xwiki.wikistream.confluence.xml.internal.input.ConfluenceInputWikiStream.java

private void readPage(int pageId, Object filter, ConfluenceFilter proxyFilter) throws WikiStreamException {
    PropertiesConfiguration pageProperties = getPageProperties(pageId);

    String documentName;/* w  w w.java  2 s .c  o m*/
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_HOMEPAGE)) {
        documentName = this.properties.getSpacePageName();
    } else {
        documentName = pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_TITLE);
    }

    FilterEventParameters documentParameters = new FilterEventParameters();
    if (this.properties.getDefaultLocale() != null) {
        documentParameters.put(WikiDocumentFilter.PARAMETER_LOCALE, this.properties.getDefaultLocale());
    }

    // > WikiDocument
    proxyFilter.beginWikiDocument(documentName, documentParameters);

    Locale locale = Locale.ROOT;

    FilterEventParameters documentLocaleParameters = new FilterEventParameters();
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_CREATION_AUTHOR)) {
        documentLocaleParameters.put(WikiDocumentFilter.PARAMETER_CREATION_AUTHOR,
                pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_CREATION_AUTHOR));
    }
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_CREATION_DATE)) {
        try {
            documentLocaleParameters.put(WikiDocumentFilter.PARAMETER_CREATION_DATE, this.confluencePackage
                    .getDate(pageProperties, ConfluenceXMLPackage.KEY_PAGE_CREATION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }
    }
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_REVISION)) {
        documentLocaleParameters.put(WikiDocumentFilter.PARAMETER_LASTREVISION,
                pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_REVISION));
    }

    // > WikiDocumentLocale
    proxyFilter.beginWikiDocumentLocale(locale, documentLocaleParameters);

    // Revisions
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_REVISIONS)) {
        List<Integer> revisions = this.confluencePackage.getIntegertList(pageProperties,
                ConfluenceXMLPackage.KEY_PAGE_REVISIONS);
        for (Integer revisionId : revisions) {
            readPageRevision(revisionId, filter, proxyFilter);
        }
    }

    // Current version
    readPageRevision(pageId, filter, proxyFilter);

    // < WikiDocumentLocale
    proxyFilter.endWikiDocumentLocale(locale, documentLocaleParameters);

    // < WikiDocument
    proxyFilter.endWikiDocument(documentName, documentParameters);
}

From source file:org.xwiki.wikistream.confluence.xml.internal.input.ConfluenceInputWikiStream.java

private void readPageRevision(int pageId, PropertiesConfiguration pageProperties, Object filter,
        ConfluenceFilter proxyFilter) throws WikiStreamException {
    String revision = pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_REVISION);

    FilterEventParameters documentRevisionParameters = new FilterEventParameters();
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_PARENT)) {
        try {//from  w w  w. ja va  2  s.  c o m
            documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_PARENT, this.confluencePackage
                    .getReferenceFromId(pageProperties, ConfluenceXMLPackage.KEY_PAGE_PARENT));
        } catch (ConfigurationException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse parent", e);
            }
        }
    }
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_REVISION_AUTHOR)) {
        documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_REVISION_AUTHOR,
                pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_REVISION_AUTHOR));
    }
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_REVISION_DATE)) {
        try {
            documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_REVISION_DATE, this.confluencePackage
                    .getDate(pageProperties, ConfluenceXMLPackage.KEY_PAGE_REVISION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }
    }
    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_REVISION_COMMENT)) {
        documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_REVISION_COMMENT,
                pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_REVISION_COMMENT));
    }
    documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_TITLE,
            pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_TITLE));

    String bodyContent = null;
    Syntax bodySyntax = null;
    int bodyType = -1;

    if (pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_BODY)
            && pageProperties.containsKey(ConfluenceXMLPackage.KEY_PAGE_BODY_TYPE)) {
        bodyContent = pageProperties.getString(ConfluenceXMLPackage.KEY_PAGE_BODY);
        bodyType = pageProperties.getInt(ConfluenceXMLPackage.KEY_PAGE_BODY_TYPE);

        switch (bodyType) {
        case 0:
            bodySyntax = Syntax.CONFLUENCE_1_0;
            break;
        case 2:
            bodySyntax = Syntax.CONFLUENCEXHTML_1_0;
            break;
        default:
            if (this.properties.isVerbose()) {
                this.logger.error("Unknown body type [{}]", bodyType);
            }
            break;
        }
    }

    // If target filter does not support rendering events, pass the content as it is
    if (!(filter instanceof Listener) && bodyContent != null && bodySyntax != null) {
        documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_CONTENT, bodyContent);
        documentRevisionParameters.put(WikiDocumentFilter.PARAMETER_SYNTAX, bodySyntax);
    }

    // > WikiDocumentRevision
    proxyFilter.beginWikiDocumentRevision(revision, documentRevisionParameters);

    // Content
    if (filter instanceof Listener && bodyContent != null && bodySyntax != null) {
        try {
            switch (bodyType) {
            case 0:
                this.confluenceWIKIParser.parse(new StringReader(bodyContent), proxyFilter);
                break;
            case 2:
                this.confluenceXHTMLParser.parse(new StringReader(bodyContent), proxyFilter);
                break;
            default:
                break;
            }
        } catch (org.xwiki.rendering.parser.ParseException e) {
            throw new WikiStreamException(String.format("Failed parser content [%s]", bodyContent), e);
        }
    }

    // Attachments
    Map<String, PropertiesConfiguration> pageAttachments = new LinkedHashMap<String, PropertiesConfiguration>();
    for (int attachmentId : this.confluencePackage.getAttachments(pageId)) {
        PropertiesConfiguration attachmentProperties;
        try {
            attachmentProperties = this.confluencePackage.getAttachmentProperties(pageId, attachmentId);
        } catch (ConfigurationException e) {
            throw new WikiStreamException("Failed to get attachment properties", e);
        }

        String attachmentName = attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_NAME);

        PropertiesConfiguration currentAttachmentProperties = pageAttachments.get(attachmentName);
        if (currentAttachmentProperties != null) {
            int version = attachmentProperties.getInt(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION);
            int currentVersion = currentAttachmentProperties
                    .getInt(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION);

            if (version > currentVersion) {
                pageAttachments.put(attachmentName, attachmentProperties);
            }
        } else {
            pageAttachments.put(attachmentName, attachmentProperties);
        }
    }

    for (PropertiesConfiguration attachmentProperties : pageAttachments.values()) {
        readAttachment(pageId, attachmentProperties, filter, proxyFilter);
    }

    // < WikiDocumentRevision
    proxyFilter.endWikiDocumentRevision(revision, documentRevisionParameters);
}

From source file:org.xwiki.wikistream.confluence.xml.internal.input.ConfluenceInputWikiStream.java

private void readAttachment(int pageId, PropertiesConfiguration attachmentProperties, Object filter,
        ConfluenceFilter proxyFilter) throws WikiStreamException {
    int attachmentId = attachmentProperties.getInt("id");

    String attachmentName = attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_NAME);
    long attachmentSize = attachmentProperties.getLong(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENT_SIZE);

    int version = attachmentProperties.getInt(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION);
    int originalRevisionId = attachmentProperties.getInt(ConfluenceXMLPackage.KEY_ATTACHMENT_ORIGINAL_REVISION,
            attachmentId);// ww  w.  j a v a 2 s .  c  o  m
    File contentFile = this.confluencePackage.getAttachmentFile(pageId, originalRevisionId, version);

    FilterEventParameters attachmentParameters = new FilterEventParameters();
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENT_TYPE)) {
        attachmentParameters.put(WikiAttachmentFilter.PARAMETER_CONTENT_TYPE,
                attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_CONTENT_TYPE));
    }
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_CREATION_AUTHOR)) {
        attachmentParameters.put(WikiAttachmentFilter.PARAMETER_CREATION_AUTHOR,
                attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_CREATION_AUTHOR));
    }
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_CREATION_DATE)) {
        try {
            attachmentParameters.put(WikiAttachmentFilter.PARAMETER_CREATION_DATE, this.confluencePackage
                    .getDate(attachmentProperties, ConfluenceXMLPackage.KEY_ATTACHMENT_CREATION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }
    }

    attachmentParameters.put(WikiAttachmentFilter.PARAMETER_REVISION, String.valueOf(version));
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_AUTHOR)) {
        attachmentParameters.put(WikiAttachmentFilter.PARAMETER_REVISION_AUTHOR,
                attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_AUTHOR));
    }
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_DATE)) {
        try {
            attachmentParameters.put(WikiAttachmentFilter.PARAMETER_REVISION_DATE, this.confluencePackage
                    .getDate(attachmentProperties, ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_DATE));
        } catch (ParseException e) {
            if (this.properties.isVerbose()) {
                this.logger.error("Failed to parse date", e);
            }
        }
    }
    if (attachmentProperties.containsKey(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_COMMENT)) {
        attachmentParameters.put(WikiAttachmentFilter.PARAMETER_REVISION_COMMENT,
                attachmentProperties.getString(ConfluenceXMLPackage.KEY_ATTACHMENT_REVISION_COMMENT));
    }

    // WikiAttachment

    try {
        FileInputStream fis = new FileInputStream(contentFile);

        try {
            proxyFilter.onWikiAttachment(attachmentName, fis, attachmentSize, attachmentParameters);
        } finally {
            fis.close();
        }
    } catch (Exception e) {
        throw new WikiStreamException("Failed to read attachment", e);
    }
}

From source file:services.plugins.atlassian.jira.jira1.JiraPluginRunner.java

/**
 * Reload the configuration of a mapping block.
 * /*from   w w  w.j av  a  2 s. c om*/
 * The current values that are still existing are kept.
 * 
 * @param pluginConfigurationBlockDescriptor
 *            the plugin configuration block descriptor
 * @param values
 *            the new values
 * @param label
 *            the label
 */
private void reloadConfiguration(String pluginConfigurationBlockDescriptorIdentifier, List<String> values,
        String label) throws PluginException {

    IPluginConfigurationBlockDescriptor pluginConfigurationBlockDescriptor = getPluginContext()
            .getPluginDescriptor().getConfigurationBlockDescriptors()
            .get(pluginConfigurationBlockDescriptorIdentifier);
    PropertiesConfiguration currentMapping = getPluginContext().getPropertiesConfigurationFromByteArray(
            getPluginContext().getConfigurationAndMergeWithDefault(pluginConfigurationBlockDescriptor));

    String mapping = "#pre-loaded configuration on " + new Date() + "\n";
    mapping += "#format: {jira_" + label + "_id}={bizdock_requirement_" + label + "_id}\n";

    for (String value : values) {
        String key = getIdFromValue(value);
        if (!currentMapping.containsKey(key)) {
            mapping += key + "=\n";
        } else {
            mapping += key + "=" + currentMapping.getString(key) + "\n";
        }
    }

    getPluginContext().setConfiguration(pluginConfigurationBlockDescriptor, mapping.getBytes());
}

From source file:uk.ac.bolton.spaws.service.LearningRegistryNode.java

private LearningRegistryNode() {
    try {/*from w w  w .  j a  va2 s .com*/
        PropertiesConfiguration properties = new PropertiesConfiguration("service.properties");
        if (properties.containsKey("spaws.node.location"))
            url = properties.getString("spaws.node.location");
        if (properties.containsKey("spaws.node.username"))
            username = properties.getString("spaws.node.username");
        if (properties.containsKey("spaws.node.password"))
            password = properties.getString("spaws.node.password");
    } catch (ConfigurationException e) {
        logger.error("error loading properties from configuration file; using defaults instead");
    }

    try {
        node = new Node(new URL(url), username, password);
    } catch (MalformedURLException e) {
        logger.warn("SPAWS node URL is invalid; using defaults");
        try {
            node = new Node(new URL(url), username, password);
        } catch (MalformedURLException e1) {
            // Should never happen...
        }

    }
}

From source file:uk.ac.edukapp.server.configuration.SolrServerConfiguration.java

private SolrServerConfiguration() {
    try {//from  ww w  .ja v a  2  s  .  c  om
        PropertiesConfiguration properties = new PropertiesConfiguration("store.properties");
        if (properties.containsKey("solr.server.location"))
            serverLocation = properties.getString("solr.server.location");
    } catch (ConfigurationException e) {
        logger.error("Error loading Solr server configuration", e);
    }
}