EDIT

/**

 * Copyright (C) 2013 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.cdm.server.instance;

import static eu.etaxonomy.cdm.server.AssumedMemoryRequirements.HEAP_CDMSERVER;

import static eu.etaxonomy.cdm.server.AssumedMemoryRequirements.HEAP_PER_INSTANCE;

import static eu.etaxonomy.cdm.server.AssumedMemoryRequirements.MB;

import static eu.etaxonomy.cdm.server.AssumedMemoryRequirements.PERM_GEN_SPACE_CDMSERVER;

import static eu.etaxonomy.cdm.server.AssumedMemoryRequirements.PERM_GEN_SPACE_PER_INSTANCE;

import java.io.File;

import java.io.IOException;

import java.util.List;

import org.apache.commons.collections.map.ListOrderedMap;

import org.apache.log4j.Logger;

import org.eclipse.jetty.util.component.LifeCycle;

import eu.etaxonomy.cdm.server.Bootloader;

import eu.etaxonomy.cdm.server.JvmManager;

/**

 * Manager to load / reload list of instances the instance manager holds the

 * list of {@link CdmInstance}, the list can be updated, the instances are

 * identified by the bean id map<String,CdmInstance>

 *

 * The instance list is initially empty, all instances are usually started after

 * loading the list, see {@#loadDataSources()}

 *

 * @author a.kohlbecker

 * @date May 10, 2013

 */

public class InstanceManager implements LifeCycle.Listener {

    private static final Logger logger = Logger.getLogger(InstanceManager.class);

    boolean serverIsRunning = false;

    private File datasourcesFile;

    /**

     * @return the datasourcesFile

     */

    public File getDatasourcesFile() {

        return datasourcesFile;

    }

    /**

     * @param datasourcesFile the datasourcesFile to set

     */

    public void setDatasourcesFile(File datasourcesFile) {

        this.datasourcesFile = datasourcesFile;

    }

    private ListOrderedMap instances = new ListOrderedMap();

    private final boolean austostart = true;

    public InstanceManager(File configurationFile) {

        this.datasourcesFile = configurationFile;

    }

    /**

     * @return the {@link Bootloader}  singelton instance

     */

    private Bootloader bootloader() {

        return Bootloader.getBootloader();

    }

    /**

     * this list of instances may contain removed

     * instances.

     * {@link #numOfConfiguredInstances()}

     * @return the instances

     */

    @SuppressWarnings("unchecked")

    public List<CdmInstance> getInstances() {

        return instances.valueList();

    }

    public CdmInstance getInstance(String instanceName) {

        return (CdmInstance)instances.get(instanceName);

    }

    /**

     * Starts the given instance. Rebinds the JndiDataSource prior starting.

     *

     * @param instance

     * @throws Exception

     */

    public void start(CdmInstance instance) throws Exception{

        if(instance.getWebAppContext() != null){

//            instance.unbindJndiDataSource();

//            instance.bindJndiDataSource();

            if(!instance.bindJndiDataSource()){

                // a problem with the datasource occurred skip this webapp

//                cdmWebappContext = null;

                logger.error("a problem with the datasource occurred -> aboarding atartup of /" + instance.getConfiguration().getInstanceName());

                instance.setStatus(Status.error);

//                return cdmWebappContext;

            }

            if(logger.isDebugEnabled()) {

                logger.debug("starting " + instance.getConfiguration().getInstanceName());

            }

            instance.getWebAppContext().start();

        }

    }

    public void stop(CdmInstance instance) throws Exception{

        // TODO do we need to bootloader().removeCdmInstanceContext(existingInstance); always?

        //    see reLoadInstanceConfigurations()

        if(instance.getWebAppContext() != null){

            instance.getWebAppContext().stop();

        }

        instance.unbindJndiDataSource();

        instance.getProblems().clear();

        // explicitly set status stopped here to clear up prior error states

        instance.setStatus(Status.stopped);

    }

    /**

     * Sets the {@link SharedAttributes.ATTRIBUTE_FORCE_SCHEMA_UPDATE} attribute

     * to the application context and starts the instance

     *

     * @param instance

     * @throws Exception

     */

    public void updateToCurrentVersion(CdmInstance instance) throws Exception{

        if(instance.getWebAppContext() != null){

            instance.getWebAppContext().getAttributes().setAttribute(SharedAttributes.ATTRIBUTE_FORCE_SCHEMA_UPDATE, true);

        }

        start(instance);

    }

    /**

     * @return the number of existing instances, former instances which have been

     * removed are not counted

     */

    public int numOfConfiguredInstances(){

        int cnt=0;

        for(CdmInstance instance : getInstances()){

            if(instance.getStatus().equals(Status.removed)){

                continue;

            }

            cnt++;

        }

        return cnt;

    }

    /**

     * loads and reloads the list of instances.

     * After loading the configuration the required memory is checked

     * <p>

     * reload behavior:

     * <ol>

     * <li>newly added instances are created but are not started automatically</li>

     * <li>removed instances are stopped, configuration and context are removed,

     * state is set to Status.removed to indicate removal, removed instances can

     * be re-added.</li>

     * <li>the order of instances as defined in the config file is always retained

     * </ol>

     *

     */

    synchronized public void reLoadInstanceConfigurations() {

        ListOrderedMap currentInstances = instances;

        ListOrderedMap updatedInstances = new ListOrderedMap();

        List<Configuration> configList = DataSourcePropertyParser.parseDataSourceConfigs(datasourcesFile);

        logger.info("cdm server instance names loaded: " + configList.toString());

        for (Configuration config : configList) {

            String key = config.getInstanceName();

            if(currentInstances.containsKey(key)){

                CdmInstance existingInstance = (CdmInstance)currentInstances.get(key);

                if(!(existingInstance.getStatus().equals(Status.removed) && existingInstance.getWebAppContext() == null)){

                    // re-added instance if not already removed (removed instances will not be re-added if they have been stopped successfully)

                    updatedInstances.put(key, existingInstance);

                    if ( !(existingInstance).getConfiguration().equals(config)) {

                        // instance has changed: stop it, clear error states, set new configuration

                        try {

                            // TODO change problems into messages + severity (notice, error)

                            stop(existingInstance);

                            bootloader().removeCdmInstanceContext(existingInstance);

                            existingInstance.setConfiguration(config);

                            existingInstance.getProblems().add("Reloaded with modified configuration");

                        } catch (Exception e) {

                            existingInstance.getProblems().add("Error while stopping modified instance: " + e.getMessage());

                            logger.error(e, e);

                        }

                    }

                }

            } else {

                // create and add a new instance

                updatedInstances.put(key, new CdmInstance(config));

            }

        }

        // find removed instances

        for(Object keyOfExisting : currentInstances.keyList()){

            if(!updatedInstances.containsKey(keyOfExisting)){

                CdmInstance removedInstance = (CdmInstance)currentInstances.get(keyOfExisting);

                if(removedInstance.getStatus().equals(Status.removed)){

                    // instance already is removed, forget it now

                    continue;

                }

                // remove the instance but remember it until next config reload

                updatedInstances.put(keyOfExisting, removedInstance);

                removedInstance.setStatus(Status.removed);

                removedInstance.getProblems().add("Removed from configuration and thus stopped");

                try {

                    bootloader().removeCdmInstanceContext(removedInstance);

                } catch (Exception e) {

                    logger.error(e.getMessage(), e);

                }

            }

        }

        instances = updatedInstances;

        verifyMemoryRequirements();

        if(serverIsRunning) {

            addNewInstancesToServer(false);

        }

    }

    private void addNewInstancesToServer(boolean austostart) {

        for (CdmInstance instance : getInstances()) {

            if (instance.getStatus().equals(Status.uninitialized)) {

                try {

                    if(bootloader().addCdmInstanceContext(instance) != null && austostart) {

                        try {

                            start(instance);

                        } catch (Exception e) {

                            logger.error("Could not start " + instance.getWebAppContext().getContextPath());

                            instance.getProblems().add(e.getMessage());

                            instance.setStatus(Status.error);

                        }

                    }

                } catch (IOException e) {

                    logger.error(e, e); // TODO better throw?

                }

            }

        }

    }

    @Override

    public void lifeCycleFailure(LifeCycle event, Throwable cause) {

        logger.error("Jetty LifeCycleFailure", cause);

    }

    @Override

    public void lifeCycleStarted(LifeCycle event) {

        serverIsRunning = true;

        logger.info("cdmserver has started, now adding CDM server contexts");

        addNewInstancesToServer(austostart);

    }

    @Override

    public void lifeCycleStarting(LifeCycle event) {

    }

    @Override

    public void lifeCycleStopped(LifeCycle event) {

        serverIsRunning = false;

    }

    @Override

    public void lifeCycleStopping(LifeCycle event) {

        serverIsRunning = false;

    }

    /**

    *

    */

   private void verifyMemoryRequirements() {

       verifyMemoryRequirement("PermGenSpace", PERM_GEN_SPACE_CDMSERVER, PERM_GEN_SPACE_PER_INSTANCE, JvmManager.getPermGenSpaceUsage().getMax());

       verifyMemoryRequirement("HeapSpace", HEAP_CDMSERVER, HEAP_PER_INSTANCE, JvmManager.getHeapMemoryUsage().getMax());

   }

    private void verifyMemoryRequirement(String memoryName, long requiredSpaceServer, long requiredSpacePerInstance, long availableSpace) {

        long recommendedMinimumSpace = recommendedMinimumSpace(requiredSpaceServer, requiredSpacePerInstance, null);

        if(recommendedMinimumSpace > availableSpace){

            String message = memoryName + " ("

                + (availableSpace / MB)

                + "MB) insufficient for "

                + numOfConfiguredInstances()

                + " instances. Increase " + memoryName + " to "

                + (recommendedMinimumSpace / MB)

                + "MB";

                ;

            logger.error(message + " => disabling some instances!!!");

            // disabling some instances

            int i=0;

            for(CdmInstance instance : getInstances()){

                i++;

                if(recommendedMinimumSpace(requiredSpaceServer, requiredSpacePerInstance, i)  > availableSpace){

                    instance.setStatus(Status.disabled);

                    instance.getProblems().add("Disabled due to: " + message);

                }

            }

        }

    }

    /**

     * @param requiredServerSpace

     * @param requiredSpacePerIntance

     * @param numOfInstances may be null, the total number of instances found in

     *  the current configuration is used in this case.

     * @return

     */

    public long recommendedMinimumSpace(long requiredServerSpace, long requiredSpacePerIntance, Integer numOfInstances) {

        if(numOfInstances == null){

            numOfInstances = numOfConfiguredInstances();

        }

        return (numOfInstances * requiredSpacePerIntance) + requiredServerSpace;

    }

}