com.google.enterprise.connector.importexport.ExportConnectors.java Source code

Introduction

Here is the source code for com.google.enterprise.connector.importexport.ExportConnectors.java

Source

// Copyright 2010 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.enterprise.connector.importexport;

import com.google.common.base.Predicate;
import com.google.common.collect.Maps;
import com.google.enterprise.connector.common.JarUtils;
import com.google.enterprise.connector.common.PropertiesUtils;
import com.google.enterprise.connector.instantiator.Configuration;
import com.google.enterprise.connector.manager.Manager;
import com.google.enterprise.connector.persist.ConnectorTypeNotFoundException;
import com.google.enterprise.connector.persist.PersistentStore;
import com.google.enterprise.connector.persist.StoreContext;

import java.util.Collection;
import java.util.Map;
import java.util.Properties;
import java.util.logging.Logger;

/**
 * An encapsulation of all the information we export/import Connector
 * Manager instance.
 */
public class ExportConnectors {
    private static final Logger LOGGER = Logger.getLogger(ExportConnectors.class.getName());

    private final PersistentStore persistentStore;
    private final Manager manager;

    public ExportConnectors(PersistentStore persistentStore, Manager manager) {
        this.persistentStore = persistentStore;
        this.manager = manager;
    }

    /**
     * Returns a ImportExportConnectorList representing the current
     * set of connectors.
     *
     * @return a ImportExportConnectorList
     */
    public ImportExportConnectorList getConnectors() {
        return getConnectors(null);
    }

    /**
     * Returns a ImportExportConnectorList representing the specified
     * set of connectors.
     *
     * @param connectorNames Collection of names of connectors to include.
     *        If {@code null}, all connectors are included.
     * @return a ImportExportConnectorList
     */
    public ImportExportConnectorList getConnectors(Collection<String> connectorNames) {
        ImportExportConnectorList connectors = new ImportExportConnectorList();
        for (StoreContext storeContext : persistentStore.getInventory().keySet()) {
            if (connectorNames != null && !connectorNames.contains(storeContext.getConnectorName())) {
                continue;
            }

            Configuration config = persistentStore.getConnectorConfiguration(storeContext);
            if (config != null) {
                // Strip the often transient google properties (such as google work dir).
                // Encrypt sensitive properties before including them in the output.
                // Note that the order of operations is important here.  We strip the
                // google* properties first, then encrypt passwords, which adds back a
                // googlePropertiesVersion - needed to decrypt the properties correctly.
                config = new Configuration(encryptSensitiveProperties(removeGoogleProperties(config.getMap())),
                        config);
                // Try to determine the connector version.
                String typeVersion = null;
                if (manager != null) {
                    try {
                        typeVersion = JarUtils
                                .getJarVersion(manager.getConnectorType(config.getTypeName()).getClass());
                    } catch (ConnectorTypeNotFoundException ctnfe) {
                        LOGGER.warning("Failed to locate ConnectorType for " + config.getTypeName());
                    }
                }

                // Add this connector to the list.
                connectors.add(new ImportExportConnector(storeContext.getConnectorName(), config, typeVersion,
                        persistentStore.getConnectorSchedule(storeContext),
                        persistentStore.getConnectorState(storeContext)));
            }
        }
        return connectors;
    }

    /**
     * Removes properties whose names start with "google" from the Configuration.
     *
     * @param configMap a Map of configuration properties.
     * @return configMap with "google*" properties filtered out.
     */
    private Map<String, String> removeGoogleProperties(Map<String, String> configMap) {
        // We don't bother making a copy, since encryptSensitiveProperties
        // makes a copy first thing.
        return Maps.filterKeys(configMap, new Predicate<String>() {
            public boolean apply(String input) {
                return !input.startsWith("google");
            }
        });
    }

    /**
     * Encrypts sensitive configuration properties in the supplied configMap.
     *
     * @param configMap a Map of configuration properties.
     * @return configMap with sensitive property values encrypted.
     */
    private Map<String, String> encryptSensitiveProperties(Map<String, String> configMap) {
        Properties props = PropertiesUtils.fromMap(configMap);
        PropertiesUtils.encryptSensitiveProperties(props);
        PropertiesUtils.stampPropertiesVersion(props);
        return PropertiesUtils.toMap(props);
    }
}