SymmetricEngineHolder.java

/**
 * Licensed to JumpMind Inc under one or more contributor
 * license agreements.  See the NOTICE file distributed
 * with this work for additional information regarding
 * copyright ownership.  JumpMind Inc licenses this file
 * to you under the GNU General Public License, version 3.0 (GPLv3)
 * (the "License"); you may not use this file except in compliance
 * with the License.
 *
 * You should have received a copy of the GNU General Public License,
 * version 3.0 (GPLv3) along with this library; if not, see
 * <http://www.gnu.org/licenses/>.
 *
 * 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 org.jumpmind.symmetric.web;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.jumpmind.db.util.BasicDataSourcePropertyConstants;
import org.jumpmind.properties.TypedProperties;
import org.jumpmind.security.ISecurityService;
import org.jumpmind.security.SecurityConstants;
import org.jumpmind.security.SecurityServiceFactory;
import org.jumpmind.security.SecurityServiceFactory.SecurityServiceType;
import org.jumpmind.symmetric.AbstractCommandLauncher;
import org.jumpmind.symmetric.ISymmetricEngine;
import org.jumpmind.symmetric.SymmetricAdmin;
import org.jumpmind.symmetric.SymmetricException;
import org.jumpmind.symmetric.common.ParameterConstants;
import org.jumpmind.symmetric.model.Node;
import org.jumpmind.symmetric.model.NodeGroup;
import org.jumpmind.symmetric.model.NodeGroupLink;
import org.jumpmind.symmetric.model.NodeGroupLinkAction;
import org.jumpmind.symmetric.service.IConfigurationService;
import org.jumpmind.symmetric.service.IRegistrationService;
import org.jumpmind.symmetric.service.ITriggerRouterService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;

public class SymmetricEngineHolder {

    final Logger log = LoggerFactory.getLogger(getClass());

    private static Map<String, ServerSymmetricEngine> staticEngines = new HashMap<String, ServerSymmetricEngine>();

    private static Set<EngineStarter> staticEnginesStarting = new HashSet<SymmetricEngineHolder.EngineStarter>();

    private Map<String, ServerSymmetricEngine> engines = new HashMap<String, ServerSymmetricEngine>();

    private Set<EngineStarter> enginesStarting = new HashSet<SymmetricEngineHolder.EngineStarter>();

    private boolean staticEnginesMode = false;

    private boolean multiServerMode = false;

    private boolean autoStart = true;

    private boolean autoCreate = true;

    private ApplicationContext springContext;

    private String singleServerPropertiesFile;

    private static Date createTime = new Date();

    private int engineCount;

    private String deploymentType = "server";

    private boolean holderHasBeenStarted = false;

    public Map<String, ServerSymmetricEngine> getEngines() {
        return engines;
    }

    public void setDeploymentType(String deploymentType) {
        this.deploymentType = deploymentType;
    }

    public void setMultiServerMode(boolean multiServerMode) {
        this.multiServerMode = multiServerMode;
    }

    public boolean isMultiServerMode() {
        return multiServerMode;
    }

    public void setAutoCreate(boolean autoCreate) {
        this.autoCreate = autoCreate;
    }

    public boolean isAutoCreate() {
        return autoCreate;
    }

    public void setStaticEnginesMode(boolean staticEnginesMode) {
        this.staticEnginesMode = staticEnginesMode;
    }

    public boolean isStaticEnginesMode() {
        return staticEnginesMode;
    }

    public void setSingleServerPropertiesFile(String singleServerPropertiesFile) {
        this.singleServerPropertiesFile = singleServerPropertiesFile;
    }

    public String getSingleServerPropertiesFile() {
        return singleServerPropertiesFile;
    }

    public boolean areEnginesConfigured() {
        return enginesStarting.size() > 0 || engines.size() > 0;
    }

    public int getNumerOfEnginesStarting() {
        return enginesStarting.size();
    }

    public void setAutoStart(boolean autoStart) {
        this.autoStart = autoStart;
    }

    public boolean isAutoStart() {
        return autoStart;
    }

    public synchronized void stop() {
        Set<String> engineNames = engines.keySet();
        for (String engineName : engineNames) {
            engines.get(engineName).destroy();
        }
        engines.clear();
    }

    public void start() {
        try {
            if (staticEnginesMode) {
                log.info("In static engine mode");
                engines = staticEngines;
                enginesStarting = staticEnginesStarting;
            }

            if (autoCreate) {
                if (isMultiServerMode()) {
                    File enginesDir = new File(AbstractCommandLauncher.getEnginesDir());
                    File[] files = null;

                    if (enginesDir != null) {
                        files = enginesDir.listFiles();
                    }

                    if (files == null) {
                        String firstAttempt = enginesDir.getAbsolutePath();
                        enginesDir = new File(".");
                        log.warn(
                                "Unable to retrieve engine properties files from {}.  Trying current working directory {}",
                                firstAttempt, enginesDir.getAbsolutePath());

                        if (enginesDir != null) {
                            files = enginesDir.listFiles();
                        }
                    }
                    
                    validateEngineFiles(files);

                    if (files != null) {
                        for (int i = 0; i < files.length; i++) {
                            File file = files[i];
                            if (file.getName().endsWith(".properties")) {
                                engineCount++;
                                enginesStarting.add(new EngineStarter(file.getAbsolutePath()));
                            }
                        }
                    } else {
                        log.error("Unable to retrieve engine properties files from default location or from current working directory.  No engines to start.");
                    }

                } else {
                    engineCount++;
                    enginesStarting.add(new EngineStarter(singleServerPropertiesFile));
                }

                for (EngineStarter starter : enginesStarting) {
                    starter.start();
                }

            }

        } finally {
            holderHasBeenStarted = true;
        }

    }

    public void uninstallEngine(ISymmetricEngine engine) {
        Node node = engine.getNodeService().getCachedIdentity();
        String engineName = engine.getEngineName();
        File file = new SymmetricAdmin("uninstall", "", "")
                .findPropertiesFileForEngineWithName(engineName);
        engine.uninstall();
        engine.destroy();
        if (file != null) {
            file.delete();
        }
        getEngines().remove(engineName);

        for (ISymmetricEngine existingEngine : this.getEngines().values()) {
            existingEngine.removeAndCleanupNode(node.getNodeId());
        }        
    }

    public void setSpringContext(ApplicationContext applicationContext) {
        this.springContext = applicationContext;
    }

    public int getEngineCount() {
        return engineCount;
    }

    protected ISymmetricEngine create(String propertiesFile) {
        ServerSymmetricEngine engine = null;
        try {
            engine = new ServerSymmetricEngine(propertiesFile != null ? new File(propertiesFile)
                    : null, springContext, this);
            engine.setDeploymentType(deploymentType);
            synchronized (this) {
                if (!engines.containsKey(engine.getEngineName())) {
                    engines.put(engine.getEngineName(), engine);
                } else {
                    log.error(
                            "An engine with the name of {} was not started because an engine of the same name has already been started.  Please set the engine.name property in the properties file to a unique name.",
                            engine.getEngineName());
                }

            }
            return engine;
        } catch (Exception e) {
            log.error("", e);
            return null;
        }
    }

    public ISymmetricEngine install(Properties passedInProperties) throws Exception {
        TypedProperties properties = new TypedProperties(passedInProperties);
        String password = properties.getProperty(BasicDataSourcePropertyConstants.DB_POOL_PASSWORD);
        if (StringUtils.isNotBlank(password) && !password.startsWith(SecurityConstants.PREFIX_ENC)) {
            try {
                ISecurityService service = SecurityServiceFactory.create(SecurityServiceType.CLIENT, properties);
                properties.setProperty(BasicDataSourcePropertyConstants.DB_POOL_PASSWORD,
                        SecurityConstants.PREFIX_ENC + service.encrypt(password));
            } catch (Exception ex) {
                log.warn("Could not encrypt password", ex);
            }
        }

        String engineName = validateRequiredProperties(properties);
        passedInProperties.setProperty(ParameterConstants.ENGINE_NAME, engineName);
        if (engines.get(engineName) != null) {
            try {
                engines.get(engineName).stop();
            } catch (Exception e) {
                log.error("", e);
            }
            engines.remove(engineName);
        }

        File enginesDir = new File(AbstractCommandLauncher.getEnginesDir());
        File symmetricProperties = new File(enginesDir, engineName + ".properties");
        FileOutputStream fileOs = null;
        try {
            fileOs = new FileOutputStream(symmetricProperties);
            properties.store(fileOs, "Updated by SymmetricDS Pro");
        } catch (IOException ex) {
            throw new RuntimeException("Failed to write symmetric.properties to engine directory",
                    ex);
        } finally {
            IOUtils.closeQuietly(fileOs);
        }

        ISymmetricEngine engine = null;
        try {

            String registrationUrl = properties.getProperty(ParameterConstants.REGISTRATION_URL);
            if (StringUtils.isNotBlank(registrationUrl)) {
                Collection<ServerSymmetricEngine> all = getEngines().values();
                for (ISymmetricEngine currentEngine : all) {
                    if (currentEngine.getParameterService().getSyncUrl()
                            .equals(registrationUrl)) {
                        String serverNodeGroupId = currentEngine.getParameterService()
                                .getNodeGroupId();
                        String clientNodeGroupId = properties
                                .getProperty(ParameterConstants.NODE_GROUP_ID);
                        String externalId = properties.getProperty(ParameterConstants.EXTERNAL_ID);

                        IConfigurationService configurationService = currentEngine
                                .getConfigurationService();
                        ITriggerRouterService triggerRouterService = currentEngine.
                                getTriggerRouterService();
                        List<NodeGroup> groups = configurationService.getNodeGroups();
                        boolean foundGroup = false;
                        for (NodeGroup nodeGroup : groups) {
                            if (nodeGroup.getNodeGroupId().equals(clientNodeGroupId)) {
                                foundGroup = true;
                            }
                        }

                        if (!foundGroup) {
                            configurationService.saveNodeGroup(new NodeGroup(clientNodeGroupId));
                        }

                        boolean foundLink = false;
                        List<NodeGroupLink> links = configurationService
                                .getNodeGroupLinksFor(serverNodeGroupId, false);
                        for (NodeGroupLink nodeGroupLink : links) {
                            if (nodeGroupLink.getTargetNodeGroupId().equals(clientNodeGroupId)) {
                                foundLink = true;
                            }
                        }

                        if (!foundLink) {
                            configurationService.saveNodeGroupLink(new NodeGroupLink(
                                    serverNodeGroupId, clientNodeGroupId, NodeGroupLinkAction.W));
                            triggerRouterService.syncTriggers();
                        }

                        IRegistrationService registrationService = currentEngine
                                .getRegistrationService();
                        if (!registrationService.isAutoRegistration()
                                && !registrationService.isRegistrationOpen(clientNodeGroupId,
                                        externalId)) {
                            Node node = new Node(properties);
                            registrationService.openRegistration(node);
                        }
                    }
                }
            }

            engine = create(symmetricProperties.getAbsolutePath());
            if (engine != null) {
                engineCount++;
                engine.start();
            } else {
                FileUtils.deleteQuietly(symmetricProperties);
                log.warn("The engine could not be created.  It will not be started");
            }
            return engine;

        } catch (RuntimeException ex) {
            if (engine != null) {
                engine.destroy();
            }
            FileUtils.deleteQuietly(symmetricProperties);
            throw ex;
        }

    }

    public boolean areEnginesStarting() {
        return !holderHasBeenStarted || enginesStarting.size() > 0;
    }

    public boolean hasAnyEngineInitialized() {
        if (enginesStarting.size() < engines.size()) {
            return true;
        }
        for (EngineStarter starter : enginesStarting) {
            ISymmetricEngine engine = starter.getEngine();
            if (engine != null && engine.isInitialized()) {
                return true;
            }
        }
        return false;
    }
    
    protected void validateEngineFiles(File[] files) {
        
        Map<String, String> dbToPropertyFiles = new LinkedHashMap<String, String>();
         
        for (File file : files) {
            if (file.getName().endsWith(".properties")) {
                // external.id
                Properties properties = new Properties();
                InputStream fileInputStream = null;
                try {
                    fileInputStream = new FileInputStream(file.getAbsolutePath());
                    properties.load(fileInputStream);                    
                    String dbUrl = properties.getProperty(BasicDataSourcePropertyConstants.DB_POOL_URL, "");                    
                    checkDuplicate(dbUrl, BasicDataSourcePropertyConstants.DB_POOL_URL, dbToPropertyFiles, file);
                } catch (Exception ex) {
                    if (ex instanceof SymmetricException) {
                        log.error("**** FATAL **** error " + ex.toString()); // Jetty logs the stack at WARN level.
                        throw (SymmetricException)ex;
                    } else {                        
                        log.warn("Failed to validate engine properties file " + file, ex);
                    }
                } finally {
                    if (fileInputStream != null) {
                        IOUtils.closeQuietly(fileInputStream);
                    }
                }
            }
        }
    }
    
    protected void checkDuplicate(String value, String key, Map<String, String> values, File propertiesFile) {
        if (values.containsKey(value)) {
            throw new SymmetricException(String.format("Invalid configuration detected. 2 properties files reference "
                    + "the same %s: '%s'. Maybe an engines file was copied and needs to be moved. See: %s and %s.", 
                    key, value, values.get(value), propertiesFile.getAbsolutePath()));
        } else {
            values.put(value, propertiesFile.getAbsolutePath());
        }
    }

    public String getEngineName(Properties properties) {
        String engineName = properties.getProperty(ParameterConstants.ENGINE_NAME);
        if (StringUtils.isBlank(engineName)) {
            String externalId = properties.getProperty(ParameterConstants.EXTERNAL_ID, "");
            String groupId = properties.getProperty(ParameterConstants.NODE_GROUP_ID, "");
            if (externalId.equals(groupId)) {
                engineName = groupId;
            } else {
                engineName = groupId + "-" + externalId;
            }
            engineName = properties.getProperty(ParameterConstants.ENGINE_NAME, engineName);
            String engineExt = "";
            int engineNumber = 0;
            while (new File(AbstractCommandLauncher.getEnginesDir(), engineName + engineExt
                    + ".properties").exists()) {
                engineNumber++;
                engineExt = "-" + engineNumber;
            }
            engineName = engineName + engineExt;
        }
        return engineName;
    }

    public String validateRequiredProperties(Properties properties) {
        String externalId = properties.getProperty(ParameterConstants.EXTERNAL_ID);
        if (StringUtils.isBlank(externalId)) {
            throw new IllegalStateException("Missing property " + ParameterConstants.EXTERNAL_ID);
        }

        String groupId = properties.getProperty(ParameterConstants.NODE_GROUP_ID);
        if (StringUtils.isBlank(groupId)) {
            throw new IllegalStateException("Missing property " + ParameterConstants.NODE_GROUP_ID);
        }

        String engineName = getEngineName(properties);
        properties.setProperty(ParameterConstants.ENGINE_NAME, engineName);

        if (StringUtils.isBlank(properties.getProperty(ParameterConstants.SYNC_URL))) {
            throw new IllegalStateException("Missing property " + ParameterConstants.SYNC_URL);
        }
        if (StringUtils.isBlank(properties
                .getProperty(BasicDataSourcePropertyConstants.DB_POOL_DRIVER))) {
            throw new IllegalStateException("Missing property "
                    + BasicDataSourcePropertyConstants.DB_POOL_DRIVER);
        }
        if (StringUtils.isBlank(properties
                .getProperty(BasicDataSourcePropertyConstants.DB_POOL_URL))) {
            throw new IllegalStateException("Missing property "
                    + BasicDataSourcePropertyConstants.DB_POOL_URL);
        }
        if (!properties.containsKey(BasicDataSourcePropertyConstants.DB_POOL_USER)) {
            throw new IllegalStateException("Missing property "
                    + BasicDataSourcePropertyConstants.DB_POOL_USER);
        }
        if (!properties.containsKey(BasicDataSourcePropertyConstants.DB_POOL_PASSWORD)) {
            throw new IllegalStateException("Missing property "
                    + BasicDataSourcePropertyConstants.DB_POOL_PASSWORD);
        }
        if (!properties.containsKey(ParameterConstants.REGISTRATION_URL)) {
            properties.setProperty(ParameterConstants.REGISTRATION_URL, "");
        }
        return engineName;
    }

    public static Date getCreateTime() {
        return createTime;
    }

    static int threadNumber = 0;

    class EngineStarter extends Thread {

        String propertiesFile;
        ISymmetricEngine engine;

        public EngineStarter(String propertiesFile) {
            super("symmetric-engine-startup-"+threadNumber++);
            this.propertiesFile = propertiesFile;
        }

        @Override
        public void run() {
            engine = create(propertiesFile);        	
            if (engine != null && autoStart &&
                    engine.getParameterService().is(ParameterConstants.AUTO_START_ENGINE)) {
                engine.start();
            }
            enginesStarting.remove(this);
        }
        
        public ISymmetricEngine getEngine() {
            return engine;
        }
    }
}