WebSVN - jonas - Diff - Rev 22396 and 22426 - /sub-projects/configurator/trunk/impl/src/main/java/org/ow2/jonas/tools/configurator/impl/Jonas53.java


/**
 * JOnAS Configurator
 * Copyright (C) 2008-2010 Bull S.A.S.
 * Copyright (C) 2008-2010 France Telecom R&D
 * Contact: jonas-team@ow2.org
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *
 * --------------------------------------------------------------------------
 
 * $Id: Jonas53.java 22426 2012-05-04 17:05:04Z cazauxj $
 * --------------------------------------------------------------------------
 */
package org.ow2.jonas.tools.configurator.impl;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.logging.Logger;

import org.apache.tools.ant.Project;
import org.apache.tools.ant.listener.TimestampedLogger;
import org.ow2.jonas.antmodular.cluster.clusterdaemon.ClusterDaemon;
import org.ow2.jonas.antmodular.cmi.Cmi;
import org.ow2.jonas.antmodular.jonasbase.bootstrap.JOnASBaseTask;
import org.ow2.jonas.antmodular.jonasbase.bootstrap.JonasProperties;
import org.ow2.jonas.antmodular.jonasbase.bootstrap.Services;
import org.ow2.jonas.antmodular.jonasbase.carol.Carol;
import org.ow2.jonas.antmodular.jonasbase.db.base.Db;
import org.ow2.jonas.antmodular.jonasbase.db.h2.DbH2;
import org.ow2.jonas.antmodular.jonasbase.discovery.multicast.DiscoveryMulticast;
import org.ow2.jonas.antmodular.jonasbase.ha.Ha;
import org.ow2.jonas.antmodular.jonasbase.jms.Jms;
import org.ow2.jonas.antmodular.jonasbase.mail.Mail;
import org.ow2.jonas.antmodular.jonasbase.resource.JdbcXml;
import org.ow2.jonas.antmodular.jonasbase.security.User;
import org.ow2.jonas.antmodular.jonasbase.security.Jaas;
import org.ow2.jonas.antmodular.jonasbase.smartclient.SmartClient;
import org.ow2.jonas.antmodular.jonasbase.web.tomcat.TomcatSessionManager;
import org.ow2.jonas.antmodular.jonasbase.wsdl.WsdlPublish;
import org.ow2.jonas.antmodular.web.base.Ajp;
import org.ow2.jonas.antmodular.web.base.Connectors;
import org.ow2.jonas.antmodular.web.base.Http;
import org.ow2.jonas.antmodular.web.base.Https;
import org.ow2.jonas.antmodular.web.base.SessionReplication;
import org.ow2.jonas.antmodular.web.base.WebContainer;
import org.ow2.jonas.tools.configurator.api.JDBCConfiguration;
import org.ow2.jonas.tools.configurator.api.JdbcXMLConfiguration;
import org.ow2.jonas.tools.configurator.api.JonasConfigurator;

/**
 * JonasConfigurator implementation for Jonas 5.3.x
 * 
 * @author S. Ali Tokmen
 * @author Jeremy Cazaux (support to extensible parameters according to a specific implementation)
 */
public class Jonas53 extends FileReplacerHelper implements JonasConfigurator {

    /**
     * JONAS_BASE
     */
    private File jonasFileBase;

    /**
     * Link to the jonas ant task
     */
    private JOnASBaseTask jonasBase;

    /**
     * To configure databases service
     */
    private DbH2 db;

    /**
     * The cluster daemon configuration
     */
    private ClusterDaemon clusterDaemon;

    /**
     * Configuration logger
     */
    private static Logger logger = Logger.getLogger(Jonas53.class.getName());

    /**
     * To configure protocols
     */
    private Carol carol;

    /**
     * Has JOnAS protocols list been set?
     */
    private boolean isProtocolsListSet = false;

    /**
     * To configure discovery sevice
     */
    private DiscoveryMulticast discovery;

    /**
     * JDBC resources
     */
    private List<JdbcXml> jdbcXmlList;

    /**
     * To configure jms
     */
    private Jms jms;

    /**
     * To configure jonas global properties
     */
    private JonasProperties jonasProperties;

    /**
     * To configure mails
     */
    private List<Mail> mails; 

    /**
     * To configure active services
     */
    private Services services;

    /**
     * To configure web container
     */
    private String webContainer;

    /**
     * To configure web container
     */
    private String jvmRoute;

    /**
     * To configure the algorithm of the web session replication
     */
    private String sessionReplicationAlgorithm;

    /**
     * Cluster name of the web session replication
     */
    private String sessionReplicationClusterName;

    /**
     * Multicast address usefull to configure the web session replication
     */
    private String sessionReplicationMulticastAddress;

    /**
     * Multicast port usefull to configure the web session replication
     */
    private String sessionReplicationMulticastPort;

    /**
     * Listen port usefull to configure the web session replication
     */
    private String sessionReplicationListenPort;

    /**
     * To configure wsdl wsdlPublisherFile
     */
    private org.ow2.jonas.antmodular.jonasbase.wsdl.File wsdlPublisherFile;

    /**
     * To configure WSDL publishing
     */
    private WsdlPublish wsdlPublish;

    /**
     * To configure ejb clustering
     */
    private Cmi cmi;

    /**
     * To configure ha cluster
     */
    private Ha ha;

    /**
     * To configure the smartclient service
     */
    private SmartClient smartClient;

    /**
     * To configure the security
     */
    private Jaas security;

    /**
     * The project, not really usefull, only to have a project to pass to ant
     * task.
     */
    private Project project;

    /**
     * Is jonas root set
     */
    private boolean isJonasRootSet = false;

    /**
     * Is jonas base set
     */
    private boolean isJonasBaseSet = false;

    /**
     * Is http webservice activated
     */
    private Boolean isHttpActivated = false;

    /**
     * Is https webservice activated
     */
    private Boolean isHttpsActivated = false;

    /**
     * Is ajp webservice activated
     */
    private Boolean isAjpActivated = false;

    /**
     * Is http replication webservice activated
     */
    private Boolean isHttpReplicationActivated = false;

    /**
     * Is http session manager activated (only usefull for tomcat7 currently)
     */
    private Boolean isHttpSessionManagerActivated = false;

    /**
     * Is web on demand activated
     */
    private Boolean isWebOnDemandActivated = false;

    /**
     * Web ondemand redirect port
     */
    private String webOnDemandRedirectPort;

    /**
     * The http port to configure
     */
    private String httpPort;

    /**
     * The max http threads to configure
     */
    private String httpMaxThreads;

    /**
     * The min spare threads to configure
     */
    private String httpMinSpareThreads;

    /**
     * The enable http lookups property to configure
     */
    private Boolean httpEnableLookups;

    /**
     * The http connection timeout to configure
     */
    private String httpConnectionTimeout;

    /**
     * The http accept count to configure
     */
    private String httpAcceptCount;

    /**
     * The max keep alive http request 
     */
    private String httpMaxKeepAliveRequest;

    /**
     * The http compression
     */
    private String httpCompression;

    /**
     * The http redirect port
     */
    private String httpRedirectPort;

    /**
     * The https port
     */
    private String httpsPort;

    /**
     * The max https threads
     */
    private String httpsMaxThreads;

    /**
     * The min spare https threads
     */
    private String httpsMinSpareThreads;

    /**
     * The enable https lookups property to configure
     */
    private Boolean httpsEnableLookups;

    /**
     * The https connection timeout
     */
    private String httpsConnectionTimeout;

    /**
     * The https accept count
     */
    private String httpsAcceptCount;

    /**
     * The max keep alive https requests
     */
    private String httpsMaxKeepAliveRequest;

    /**
     * The https compression
     */
    private String httpsCompression;

    /**
     * The https redirect port
     */
    private String httpsRedirectPort;

    /**
     * The https keystore file
     */
    private String httpsKeystoreFile;

    /**
     * The https keystore password
     */
    private String httpsKeystorePass;

    /**
     * The ajp port
     */
    private String ajpPort;

    /**
     * The max ajp threads
     */
    private String ajpMaxThreads;

    /**
     * The min spare ajp threads
     */
    private String ajpMinSpareThreads;

    /**
     * The enable ajp lookups property to configure
     */
    private Boolean ajpEnableLookups;

    /**
     * The ajp connection timeout
     */
    private String ajpConnectionTimeout;

    /**
     * The ajp accept count
     */
    private String ajpAcceptCount;

    /**
     * The ajp redirect port
     */
    private String ajpRedirectPort;

    /**
     * Max active web sessions
     */
    private String maxActiveSession;

    /**
     * Database id
     */
    private String dbId;

    /**
     * List of users 
     */
    List<User> users;

    /**
     * List of admins
     */
    List<User> admins;

    /**
     * Wrapper Configurator api
     */
    JOnASWrapper wrapper;

    /**
     * Derfault constructor
     */
    public Jonas53() {
        this.createProject();
        this.jonasBase = new JOnASBaseTask();
        this.jonasBase.setProject(this.project);
 
        this.jonasBase.setSkipOptionalDeployablesCopy(true);

        this.jonasProperties = new JonasProperties();
        this.jonasProperties.setProject(this.project);

        this.services = new Services();
        this.services.setProject(this.project);

        this.carol = new Carol();
        this.carol.setProject(this.project);

        this.security = new Jaas();
        this.security.setProject(this.project);

        this.jdbcXmlList = new ArrayList<JdbcXml>();
        this.mails = new ArrayList<Mail>();
        
        this.users = new ArrayList<User>();
        this.admins = new ArrayList<User>();

        Jonas53.logger.finest("Created the JOnAS 5 configurator instance");
    }

    /**
     * Create the project
     */
    private void createProject() {
        this.project = new Project();
        this.project.init();
        this.project.initProperties();

        TimestampedLogger logger = new TimestampedLogger();
        logger.setMessageOutputLevel(Project.MSG_DEBUG);

        logger.setOutputPrintStream(new PrintStream(new OutputStream() {
            StringBuffer buf = new StringBuffer();

            @Override
            public void write(final int b) throws IOException {
                if (b == '\n' || b == '\r') {
                    if (this.buf.length() > 0) {
                        Jonas53.logger.finest(this.buf.toString());
                        this.buf.setLength(0);
                    }
                } else {
                    this.buf.append((char) b);
                }
            }
        }));

        this.project.addBuildListener(logger);
    }

    /* ------------------------------- */
    /* Jonas global parameters */
    /**
     * {@inheritDoc}
     */
    public void setJdk(final String jdk) {
        Jonas53.logger.finest("[GlobalParameters] setting jdk : " + jdk);
        NotApplicableHelper.notApplicable("GlobalParameters.Jdk");
    }

    /**
     * {@inheritDoc}
     */
    public void setJavaOpts(final String javaOpts) {
        Jonas53.logger.finest("[GlobalParameters] setting java opts : " + javaOpts);
        NotApplicableHelper.notApplicable("GlobalParameters.JavaOpts");
    }

    /**
     * {@inheritDoc}
     */
    public void setJonasRoot(final String jonasRoot) {
        Jonas53.logger.finest("[GlobalParameters] setting jonas root : " + jonasRoot);
        this.project.setProperty("jonas.root", jonasRoot);

        this.isJonasRootSet = true;
    }

    /**
     * {@inheritDoc}
     */
    public void setJonasBase(final String jonasBase) {
        Jonas53.logger.finest("[GlobalParameters] setting jonas base : " + jonasBase);
        this.jonasFileBase = new File(jonasBase);
        this.project.setProperty("jonas.base", jonasBase);

        this.isJonasBaseSet = true;
    }

    /**
     * {@inheritDoc}
     */
    public void isJOnASBaseToUpdate(final Boolean update) {
        Jonas53.logger.finest("[GlobalParameters] setting isJonasBaseToUpdate : " + update);
        if (update != null) {
            this.jonasBase.setUpdate(update);
        }
    }

    /**
     * {@inheritDoc}
     */
    public void setJonasName(final String jonasName) {
        Jonas53.logger.finest("[GlobalParameters] setting jonas name : " + jonasName);
        this.addReplacement("jonas.properties", "jonas.name    jonas", "jonas.name    " + jonasName);
    }

    /**
     * {@inheritDoc}
     */
    public void setJonasDomain(final String jonasDomain) {
        Jonas53.logger.finest("[GlobalParameters] setting jonas domain : " + jonasDomain);
        this.addReplacement("jonas.properties", "domain.name    jonas", "domain.name    " + jonasDomain);
    }

    /**
     * {@inheritDoc}
     */
    public void setHost(final String jonasHost) {
        Jonas53.logger.finest("[GlobalParameters] setting host : " + jonasHost);
        NotApplicableHelper.notApplicable("Host.");
    }

    /**
     * {@inheritDoc}
     */
    public void setJonasDevelopment(final boolean development) {
        logger.finest("[GlobalParameters] setting jonas.development : " + development);
        this.jonasProperties.setDevelopment(development);
    }

    /**
     * {@inheritDoc}
     */
    public void setLogConfigFile(final String logConfigFile) {
        this.jonasProperties.setConfigfile(logConfigFile);
    }

    /**
     * {@inheritDoc}
     */
    public void setMaster(final Boolean isMaster) {
        this.jonasProperties.setMaster(isMaster);
    }

    /**
     * {@inheritDoc}
     */
    public void setSecurityPropagation(final Boolean securityPropagation) {
        this.jonasProperties.setSecurityPropagation(securityPropagation);
    }

    /**
     * {@inheritDoc}
     */
    public void setTransactionPropagation(final Boolean transactionPropagation) {
        this.jonasProperties.setTransactionPropagation(transactionPropagation);
    }

    /**
     * {@inheritDoc}
     */
    public void setCsiv2Propagation(final Boolean csiv2Propagation) {
        this.jonasProperties.setCsiv2Propagation(csiv2Propagation);
    }

    /* ------------------------------- */

    /* ------------------------------- */
    /* Jonas protocols configuation */
    /**
     * {@inheritDoc}
     */
    public void setProtocolsList(final String protocolsList) {
        if (protocolsList != null && protocolsList.contains("cmi")) {
            throw new IllegalArgumentException("In JOnAS 5, CMI has become a service. To enable CMI, follow these steps:"
                + "\n\t1) In the CAROL protocols list, use JRMP, IIOP and/or IRMI as usual"
                + "\n\t2) In the JOnAS services list, add the \"cmi\" service");
        }

        Jonas53.logger.finest("[Protocols configuration] setting protocols list : " + protocolsList);
        this.carol.setProtocols(protocolsList);
        this.isProtocolsListSet = true;
    }

    /**
     * {@inheritDoc}
     */
    public void setProtocolsIrmiPort(final String irmiPort) {
        Jonas53.logger.finest("[Protocols configuration] setting irmi port : " + irmiPort);
        this.carol.setIrmiPort(irmiPort);
    }

    /**
     * {@inheritDoc}
     */
    public void setProtocolsIiopPort(final String iiopPort) {
        Jonas53.logger.finest("[Protocols configuration] setting iiop port : " + iiopPort);
        this.carol.setIiopPort(iiopPort);
    }

    /**
     * {@inheritDoc}
     */
    public void setProtocolsJrmpPort(final String jrmpPort) {
        Jonas53.logger.finest("[Protocols configuration] setting jrmp port : " + jrmpPort);
        this.carol.setJrmpPort(jrmpPort);
    }

    /**
     * {@inheritDoc}
     */
    public void setProtocolsJrmLocalRegistry(final Boolean localRegistry) {
        Jonas53.logger.finest("[Protocols configuration] setting jrmp local registry : " + localRegistry);
        this.carol.setLocalRegistry(localRegistry);
    }

    /**
     * {@inheritDoc}
     */
    public void setCarolHost(final String host) {
        Jonas53.logger.finest("[Protocols configuration] setting host : " + host);
        this.carol.setHost(host);
    }

    /**
     * {@inheritDoc}
     */
    public void setProtocolsCmiPort(final String cmiPort) {
        Jonas53.logger.finest("[Protocols configuration] setting cmi port : " + cmiPort);
        NotApplicableHelper.notApplicable("Protocols.CmiPort");
    }

    /**
     * {@inheritDoc}
     */
    public void setProtocolsLocalCallOptimized(final Boolean localCallOptimized) {
        Jonas53.logger.finest("[Protocols configuration] setting jndi local call optimisation : " + localCallOptimized);
        this.carol.setJrmpOptimization(localCallOptimized);
    }

    /* ------------------------------- */

    /* ------------------------------- */
    /* Active services */
    /**
     * {@inheritDoc}
     */
    public void setServices(final String services) {
        Jonas53.logger.finest("setting actives services list : " + services);
        this.services.setNames(services);
        this.jonasProperties.setServices(services);
    }

    /* ------------------------------- */

    /* ------------------------------- */
    /* Service web configuration */
    /**
     * {@inheritDoc}
     */
    public void setWebcontainer(final String webContainer) {
        Jonas53.logger.finest("[Web configuration] setting webContainer : " + webContainer);
        this.webContainer = webContainer;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpConnectorActivation(final Boolean activation) {
        Jonas53.logger.finest("[Web configuration] setting isHttpActivated : " + activation);
        this.isHttpActivated = activation;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpsConnectorActivation(final Boolean activation) {
        Jonas53.logger.finest("[Web configuration] setting isHttpsActivated : " + activation);
        this.isHttpsActivated = activation;
    }

    /**
     * {@inheritDoc}
     */
    public void setAjpConnectorActivation(final Boolean activation) {
        Jonas53.logger.finest("[Web configuration] setting isAjpActivated : " + activation);
        this.isAjpActivated = activation;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpSessionReplicationActivation(final Boolean activation) {
        Jonas53.logger.finest("[Web configuration] setting isHttpReplicationActivated : " + activation);
        this.isHttpReplicationActivated = activation;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpSessionManagerActivation(final Boolean activation) {
        Jonas53.logger.finest("[Web configuration] setting isHttpSessionManagerActivated : " + activation);
        this.isHttpSessionManagerActivated = activation;
    }

    /**
     * {@inheritDoc}
     */
    public void setWebOndemandActivation(final Boolean activation) {
        Jonas53.logger.finest("[Web configuration] setting isWebOnDemandActivated : " + activation);
        this.isWebOnDemandActivated = activation;
    }

    /**
     * {@inheritDoc}
     */
    public void setWebOndemandRedirectPort(final String redirectPort) {
        Jonas53.logger.finest("[Web configuration] setting ondemand redirect port : " + redirectPort);
        this.webOnDemandRedirectPort = redirectPort;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpPort(final String httpPort) {
        Jonas53.logger.finest("[Web configuration] setting http port : " + httpPort);
        this.httpPort = httpPort;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpMaxThreads(final String httpMaxThreads) {
        Jonas53.logger.finest("[Web configuration] setting max http threads : " + httpMaxThreads);
        this.httpMaxThreads = httpMaxThreads;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpMinSpareThreads(final String httpMinSpareThreads) {
        Jonas53.logger.finest("[Web configuration] setting min http spare threads : " + httpMinSpareThreads);
        this.httpMinSpareThreads = httpMinSpareThreads;
    }

    /**
     * {@inheritDoc}
     */
    @Deprecated // not used..
    public void setHttpMaxSpareThreads(final String httpMaxSpareThreads) {
        Jonas53.logger.finest("[Web configuration] setting max http spare threads : " + httpMaxSpareThreads);
        NotApplicableHelper.notApplicable("HTTP.maxSpareThreads");
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpEnableLookups(final Boolean enableLookups) {
        Jonas53.logger.finest("setting http enable lookups : " + enableLookups);
        this.httpEnableLookups = enableLookups;
    } 

    /**
     * {@inheritDoc}
     */
    public void setHttpConnectionTimeout(final String connectionTimeout) {
        Jonas53.logger.finest("setting http connection timeout : " + connectionTimeout);
        this.httpConnectionTimeout = connectionTimeout;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpAcceptCount(final String acceptCount) {
        Jonas53.logger.finest("setting http accept count : " + acceptCount);
        this.httpAcceptCount = acceptCount;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpMaxKeepAliveRequest(final String maxKeepAliveRequest) {
        Jonas53.logger.finest("setting max keep alive http request : " + maxKeepAliveRequest);
        this.httpMaxKeepAliveRequest = maxKeepAliveRequest;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpCompression(final String compression) {
        Jonas53.logger.finest("setting http compression : " + compression);
        this.httpCompression = compression;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpRedirectPort(final String redirectPort) {
        Jonas53.logger.finest("setting http redirect port : " + redirectPort);
        this.httpRedirectPort = redirectPort;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpsPort(final String httpsPort) {
        Jonas53.logger.finest("[Web configuration] setting https port : " + httpsPort);
        this.httpsPort = httpsPort;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpsMaxThreads(final String httpsMaxThreads) {
        Jonas53.logger.finest("[Web configuration] setting max https threads : " + httpsMaxThreads);
        this.httpsMaxThreads = httpsMaxThreads;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpsMinSpareThreads(final String httpsMinSpareThreads) {
        Jonas53.logger.finest("setting min https spare threads : " + httpsMinSpareThreads);
        this.httpsMinSpareThreads = httpsMinSpareThreads;
    }

    /**
     * {@inheritDoc}
     */
    @Deprecated //never used...
    public void setHttpsMaxSpareThreads(final String httpsMaxSpareThreads) {
        Jonas53.logger.finest("setting max https spare threads : " + httpsMaxSpareThreads);
        NotApplicableHelper.notApplicable("HTTPS.maxSpareThreads");
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpsEnableLookups(final Boolean enableLookups) {
        Jonas53.logger.finest("setting https enable lookups property : " + enableLookups);
        this.httpsEnableLookups = enableLookups;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpsConnectionTimeout(final String connectionTimeout) {
        Jonas53.logger.finest("setting https connection timeout : " + connectionTimeout);
        this.httpsConnectionTimeout = connectionTimeout;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpsAcceptCount(final String acceptCount) {
        Jonas53.logger.finest("setting https accept count : " + acceptCount);
        this.httpsAcceptCount = acceptCount;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpsMaxKeepAliveRequest(final String maxKeepAliveRequest) {
        Jonas53.logger.finest("setting max keep alive https request : " + maxKeepAliveRequest);
        this.httpsMaxKeepAliveRequest = maxKeepAliveRequest;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpsCompression(final String compression) {
        Jonas53.logger.finest("setting https compression : " + compression);
        this.httpsCompression = compression;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpsRedirectPort(final String redirectPort) {
        Jonas53.logger.finest("setting https redirect port : " + redirectPort);
        this.httpsRedirectPort = redirectPort;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpsKeystoreFile(final String keystoreFile) {
        Jonas53.logger.finest("setting https keystore file : " + keystoreFile);
        this.httpsKeystoreFile = keystoreFile;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpsKeystorePass(final String keystorePass) {
        Jonas53.logger.finest("setting https keystore password : " + keystorePass);
        this.httpsKeystorePass = keystorePass;
    }

    /**
     * {@inheritDoc}
     */
    public void setAjpPort(final String ajpPort) {
        Jonas53.logger.finest("[Web configuration] setting ajp port : " + ajpPort);
        this.ajpPort = ajpPort;
    }

    /**
     * {@inheritDoc}
     */
    public void setAjpMaxThreads(final String ajpMaxThreads) {
        Jonas53.logger.finest("[Web configuration] setting max ajp threads : " + ajpMaxThreads);
        this.ajpMaxThreads = ajpMaxThreads;
    }

    /**
     * {@inheritDoc}
     */
    public void setAjpMinSpareThreads(final String ajpMinSpareThreads) {
        Jonas53.logger.finest("[Web configuration] setting min ajp spare threads : " + ajpMinSpareThreads);
        this.ajpMinSpareThreads = ajpMinSpareThreads;
    }

    /**
     * {@inheritDoc}
     */
    @Deprecated //never used...
    public void setAjpMaxSpareThreads(final String ajpMaxSpareThreads) {
        Jonas53.logger.finest("[Web configuration] setting max ajp spare threads : " + ajpMaxSpareThreads);
        NotApplicableHelper.notApplicable("AJP.maxSpareThreads");
    }

    /**
     * {@inheritDoc}
     */
    public void setAjpEnableLookups(final Boolean enableLookups) {
        Jonas53.logger.finest("setting ajp enable lookups property : " + enableLookups);
        this.ajpEnableLookups = enableLookups;
    }

    /**
     * {@inheritDoc}
     */
    public void setAjpConnectionTimeout(final String connectionTimeout) {
        Jonas53.logger.finest("setting ajp connection timeout : " + connectionTimeout);
        this.ajpConnectionTimeout = connectionTimeout;        
    }

    /**
     * {@inheritDoc}
     */
    public void setAjpAcceptCount(final String acceptCount) {
        Jonas53.logger.finest("setting ajp accept count : " + acceptCount);
        this.ajpAcceptCount = acceptCount;
    }

    /**
     * {@inheritDoc}
     */
    public void setAjpRedirectPort(final String redirectPort) {
        Jonas53.logger.finest("setting ajp redirect port : " + redirectPort);
        this.ajpRedirectPort = redirectPort;
    }

    /**
     * {@inheritDoc}
     */
    public void setMaxActiveWebSessions(final String maxActiveSession) {
        Jonas53.logger.finest("setting max active session : " + maxActiveSession);
        this.maxActiveSession = maxActiveSession;
    }

    /**
     * {@inheritDoc}
     */
    public void setJmxSecured(final boolean enabled) {
        Jonas53.logger.finest("[Security] setting JMX security:" + enabled);
        security.setSecureJmx(enabled);
    }

    /**
     * {@inheritDoc}
     */
    public void addUser(final String username, final String password, final String roles, final String groups, 
                        final String description) {
        User user = new User();
        user.setName(username);
        user.setPassword(password);
        user.setGroups(groups);
        user.setRoles(roles);
        user.setDescription(description);
        this.users.add(user);
    }

    /**
     * {@inheritDoc}
     */
    public void addAdmin(final String username, final String password) {
        User admin = new User();
        admin.setName(username);
        admin.setPassword(password);
        this.admins.add(admin);
    }

    /**
     * {@inheritDoc}
     */
    public void setJvmRoute(final String jvmRoute) {
        Jonas53.logger.finest("[Web configuration] setting jvm route : " + jvmRoute);
        this.jvmRoute = jvmRoute;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpReplicationClusterName(final String clusterName) {
        Jonas53.logger.finest("[Web configuration] setting cluster name : " + clusterName);
        this.sessionReplicationClusterName = clusterName; 
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpReplicationMulticastAddress(final String mCastAddr) {
        Jonas53.logger.finest("[Web configuration] setting multi cast address : " + mCastAddr);
        this.sessionReplicationMulticastAddress = mCastAddr;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpReplicationMulticastPort(final String mCastPort) {
        Jonas53.logger.finest("[Web configuration] setting multi cast port : " + mCastPort);
        this.sessionReplicationMulticastPort = mCastPort;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpReplicationListenPort(final String listenPort) {
        Jonas53.logger.finest("[Web configuration] setting listen port : " + listenPort);
        this.sessionReplicationListenPort = listenPort;
    }

    /**
     * {@inheritDoc}
     */
    public void setHttpReplicationAlgorithm(final String algorithm) {
        Jonas53.logger.finest("[Web configuration] setting http replication algorithm : " + algorithm);
        this.sessionReplicationAlgorithm = algorithm;
    }

    /* ------------------------------- */

    /* ------------------------------- */
    /**
     * Active db service
     */
    private void initDb() {
        if (this.db == null) {
            this.db = new DbH2();
            this.db.setProject(this.project);
        }
    }

    /* Service db configuration */
    /**
     * {@inheritDoc}
     */
    public void setDbPort(final String port) {
        Jonas53.logger.finest("[Database configuration] setting db port: " + port);
        initDb();
        this.db.setPort(port);
    }

    /**
     * {@inheritDoc}
     */
    public void setDbName(final String name) {
        Jonas53.logger.finest("[Database configuration] setting db name: " + name);
        initDb();
        this.db.setDbName(name);
    }

    /**
     * {@inheritDoc}
     */
    public void setDbUsers(final String users) {
        Jonas53.logger.finest("[Database configuration] setting db users: " + users);
        initDb();
        this.db.setUsers(users);
    }
 
    /**
     * {@inheritDoc}
     */
    public void setDbId(final String dbId) {
        this.dbId = dbId;
    }

    /* ------------------------------- */

    /* ------------------------------- */
    /* Service discovery configuration */
    /**
     * {@inheritDoc}
     */
    public void setDiscoveryMasterActivated(final Boolean masterActivated) {
        Jonas53.logger.finest("[Discovery configuration] setting masterActivated : " + masterActivated);
        this.jonasProperties.setMaster(masterActivated);
    }

    /**
     * {@inheritDoc}
     */
    public void setDiscoverySourcePort(final String sourcePort) {
        Jonas53.logger.finest("[Discovery configuration] setting source port : " + sourcePort);
        initDiscovery();
        this.discovery.setSourcePort(sourcePort);
    }

    /**
     * {@inheritDoc}
     */
    public void setDiscoveryDomainName(final String domainName) {
        Jonas53.logger.finest("[Discovery configuration] setting domain name : " + domainName);
        this.addReplacement("jonas.properties", "domain.name    jonas", "domain.name    " + domainName);
    }

    /**
     * {@inheritDoc}
     */
    public void setDiscoveryGreetingPort(final String greetingPort) {
        Jonas53.logger.finest("[Discovery configuration] setting greeting port : " + greetingPort);
        initDiscovery();
        this.discovery.setGreetingPort(greetingPort);
    }

    /**
     * {@inheritDoc}
     */
    public void setDiscoveryMulticastAddress(final String multicastAddress) {
        Jonas53.logger.finest("[Discovery configuration] setting multicast address : " + multicastAddress);
        initDiscovery();
        this.discovery.setMcastAddr(multicastAddress);
    }

    /**
     * {@inheritDoc}
     */
    public void setDiscoveryMulticastPort(final String multicastPort) {
        Jonas53.logger.finest("[Discovery configuration] setting multicast port : " + multicastPort);
        initDiscovery();
        this.discovery.setMcastPort(multicastPort);
    }

    /**
     * {@inheritDoc}
     */
    public void setDiscoveryTTL(final String ttl) {
        Jonas53.logger.finest("[Discovery configuration] setting ttl : " + ttl);
        initDiscovery();
        this.discovery.setTtl(ttl);
    }

    /**
     * Init discovery object if not set
     */
    private void initDiscovery() {
        if (this.discovery == null) {
            this.discovery = new DiscoveryMulticast();
            this.discovery.setProject(this.project);
        }
    }

    /* ------------------------------- */

    /* ------------------------------- */
    /* Service mail configuration */
    /**
     * {@inheritDoc}
     */
    public void setMailFactoryType(final String factoryType) {
        Jonas53.logger.finest("[Mail Service Configuration] setting mail factory type : " + factoryType);
        NotApplicableHelper.notApplicable("Mail.factoryType");
    }

    /**
     * {@inheritDoc}
     */
    public void setMailFactoryName(final String factoryName) {
        Jonas53.logger.finest("[Mail Service Configuration] setting mail factory name : " + factoryName);
        NotApplicableHelper.notApplicable("Mail.factoryName");
    }

    /**
     * {@inheritDoc}
     */
    public void addMailMimme(final String name, final String host, final String mailto, final String subject) {
        Jonas53.logger.finest("[Mail Service Configuration] addition of a new mail mimme configuration file.");
        Mail mail = new Mail();
        mail.setProject(this.project);
        mail.setName(name);
        mail.setHost(host);
        mail.setMailTo(mailto);
        mail.setSubject(subject);
        mail.setType("MimePartDataSource");
        this.mails.add(mail);
    }

    /**
     * {@inheritDoc}
     */
    public void addMailSession(final String name) {
        Jonas53.logger.finest("[Mail Service Configuration] addition of a new mail session configuration file.");
        Mail mail = new Mail();
        mail.setProject(this.project);
        mail.setName(name);
        mail.setType("Session");
        this.mails.add(mail);
    }

    /* ------------------------------- */

    /* ------------------------------- */
    /* Service WS configuration */

    /**
     * Init WsdlPublisherFile if not set
     */
    private void initWsdlPublisherFile() {
        if (this.wsdlPublisherFile == null) {
            this.wsdlPublisherFile = new org.ow2.jonas.antmodular.jonasbase.wsdl.File();
        }
    }

    /**
     * {@inheritDoc}
     */
    public void setWsdlPublisherFileName(final String fileName) {
        Jonas53.logger.finest("[WS Service configuration] setting wsdlPublisherFile name : " + fileName);
        initWsdlPublisherFile();
        this.wsdlPublisherFile.setName(fileName);
    }

    /**
     * {@inheritDoc}
     */
    public void setWsdlPublisherFileDirectory(final String fileDir) {
        Jonas53.logger.finest("[WS Service configuration] setting wsdlPublisherFile directory : " + fileDir);
        initWsdlPublisherFile();
        this.wsdlPublisherFile.setDir(fileDir);
    }

    /* ------------------------------- */

    /* ------------------------------- */
    /* Service HA configuration */
    /**
     * {@inheritDoc}
     */
    public void setHaActivated(final Boolean activated) {
        Jonas53.logger.finest("[HA Service configuration] setting ha activated : " + activated);
        //do nothing
    }

    /**
     * {@inheritDoc}
     */
    public void setHaMulticastAddress(final String multicastAddr) {
        Jonas53.logger.finest("[HA Service configuration] setting multicast address : " + multicastAddr);
        initHa();
        this.ha.setMcastAddr(multicastAddr);
    }

    /**
     * {@inheritDoc}
     */
    public void setHaMulticastPort(final String multicastPort) {
        Jonas53.logger.finest("[HA Service configuration] setting multicast port : " + multicastPort);
        initHa();
        this.ha.setMcastPort(multicastPort);
    }

    /**
     * Activate HA
     */
    private void initHa() {
        if (this.ha == null) {
            this.ha = new Ha();
            this.ha.setProject(this.project);
        }
    }

    /* ------------------------------- */

    /* ------------------------------- */
    /* Security manager configuration */
    /**
     * {@inheritDoc}
     */
    public void setSecurityManagerActivated(final Boolean activation) {
        Jonas53.logger.finest("[Security Manager configuration] setting isActivates : " + activation);
        this.jonasProperties.setSecurityManager(activation);
    }

    /* ------------------------------- */

    /* ------------------------------- */
    /* Ejb clustering configuration */
    /**
     * {@inheritDoc}
     */
    /**
     * {@inheritDoc}
     */
    public void setEjbClusteringActivated(final Boolean activated) {
        Jonas53.logger.finest("[Ejb Clustering configuration] setting ejb clustering activated activated : " + activated);
        if (activated) {
            this.cmi = new Cmi();
            this.cmi.setProject(this.project);
        }
    }

    public void setEjbClusteringMulticastAddress(final String multicastAddr) {
        Jonas53.logger.finest("[Ejb Clustering configuration] setting multicast address : " + multicastAddr);
        if (this.cmi != null) {
            this.cmi.setMcastAddr(multicastAddr);
        }
    }

    /**
     * {@inheritDoc}
     */
    public void setEjbClusteringMulticastPort(final String multicastPort) {
        Jonas53.logger.finest("[Ejb Clustering configuration] setting multicast port : " + multicastPort);
        if (this.cmi != null) {
            this.cmi.setMcastPort(multicastPort);
        }
    }

    /**
     * {@inheritDoc}
     */
    public void setEjbClusteringReplicationEnable(final Boolean enable) {
        Jonas53.logger.finest("[EJB Clustering configuration] : " + enable);
        if (this.cmi != null) {
            this.cmi.setReplicationEnabled(enable);
        }
    }

    /* ------------------------------- */

    /* ------------------------------- */
    /* Jms configuration */

    /**
     * Initialize JMS if not set
     */
    private void initJms() {
        if (this.jms == null) {
            this.jms = new Jms();
            this.jms.setProject(this.project);
        }
    }

    /**
     * {@inheritDoc}
     */
    public void setJmsPort(final String port) {
        Jonas53.logger.finest("[Jms configuration] setting port : " + port);
        initJms();
        this.jms.setPort(port);
    }

    /**
     * {@inheritDoc}
     */
    public void setJmsQueues(final String queue) {
        Jonas53.logger.finest("[Jms configuration] setting queue : " + queue);
        initJms();
        this.jms.setInitialQueues(queue);
    }

    /**
     * {@inheritDoc}
     */
    public void setJmsTopics(final String topic) {
        Jonas53.logger.finest("[Jms configuration] setting topic : " + topic);
        initJms();
        this.jms.setInitialTopics(topic);
    }

    /**
     * {@inheritDoc}
     */
    public void setJmsHost(final String host) {
        Jonas53.logger.finest("[Jms configuration] setting host : " + host);
        initJms();
        this.jms.setHost(host);
    }

    /**
     * {@inheritDoc}
     */
    public void addJdbcResource(final JdbcXMLConfiguration jdbcXMLConfiguration) {
        JdbcXml jdbcXml = new JdbcXml();
        jdbcXml.setProject(this.project);
        if (jdbcXMLConfiguration.classname != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting classname: " + jdbcXMLConfiguration.classname);
            jdbcXml.setClassName(jdbcXMLConfiguration.classname);
        }
        if (jdbcXMLConfiguration.mapper != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting mapper: " + jdbcXMLConfiguration.mapper);
            jdbcXml.setMapper(jdbcXMLConfiguration.mapper);    
        }
        if (jdbcXMLConfiguration.name != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting name: " + jdbcXMLConfiguration.name);
            jdbcXml.setName(jdbcXMLConfiguration.name);
        }
        if (jdbcXMLConfiguration.username != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting username: " + jdbcXMLConfiguration.username);
            jdbcXml.setUserName(jdbcXMLConfiguration.username);
        }
        if (jdbcXMLConfiguration.password != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting password: " + jdbcXMLConfiguration.password);
            jdbcXml.setPassword(jdbcXMLConfiguration.password);
        } 
        if (jdbcXMLConfiguration.url != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting url: " + jdbcXMLConfiguration.url);
            jdbcXml.setUrl(jdbcXMLConfiguration.url);
        } 
        if (jdbcXMLConfiguration.conCheckLevel != null)  {
            Jonas53.logger.finest("[JdbcXML configuration] setting conCheckLevel: " + jdbcXMLConfiguration.conCheckLevel);
            jdbcXml.setConCheckLevel(jdbcXMLConfiguration.conCheckLevel);
        }
        if (jdbcXMLConfiguration.connMaxAge != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting connMaxAge: " + jdbcXMLConfiguration.connMaxAge);
            jdbcXml.setConnMaxAge(jdbcXMLConfiguration.connMaxAge);
        }  
        if (jdbcXMLConfiguration.conTestStmt != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting conTestStmt: " + jdbcXMLConfiguration.conTestStmt);
            jdbcXml.setConTestStmt(jdbcXMLConfiguration.conTestStmt);
        } 
        if (jdbcXMLConfiguration.initConPool != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting initConPool: " + jdbcXMLConfiguration.initConPool);
            jdbcXml.setInitConPool(jdbcXMLConfiguration.initConPool);
        } 
        if (jdbcXMLConfiguration.maxConPool != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting maxConPool: " + jdbcXMLConfiguration.maxConPool);
            jdbcXml.setMaxConPool(jdbcXMLConfiguration.maxConPool);
        } 
        if (jdbcXMLConfiguration.maxOpenTime != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting maxOpenTime: " + jdbcXMLConfiguration.maxOpenTime);
            jdbcXml.setMaxOpenTime(jdbcXMLConfiguration.maxOpenTime);
        }
        if (jdbcXMLConfiguration.maxWaiters != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting maxWaiters: " + jdbcXMLConfiguration.maxWaiters);
            jdbcXml.setMaxWaiters(jdbcXMLConfiguration.maxWaiters);
        }
        if (jdbcXMLConfiguration.minConPool != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting minConPool: " + jdbcXMLConfiguration.minConPool);
            jdbcXml.setMinConPool(jdbcXMLConfiguration.minConPool);
        }
        if (jdbcXMLConfiguration.maxWaitTime != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting maxWaiters: " + jdbcXMLConfiguration.maxWaiters);
            jdbcXml.setMaxWaitTime(jdbcXMLConfiguration.maxWaitTime);
        }
        if (jdbcXMLConfiguration.pstmtCachePolicy != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting pstmtCachePolicy: " + jdbcXMLConfiguration.pstmtCachePolicy);
            jdbcXml.setPstmtCachePolicy(jdbcXMLConfiguration.pstmtCachePolicy);
        }
        if (jdbcXMLConfiguration.pstmtMax != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting pstmtMax: " + jdbcXMLConfiguration.pstmtMax);
            jdbcXml.setPstmtMax(jdbcXMLConfiguration.pstmtMax);
        }
        if (jdbcXMLConfiguration.samplingPeriod != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting samplingPeriod: " + jdbcXMLConfiguration.samplingPeriod);
            jdbcXml.setSamplingPeriod(jdbcXMLConfiguration.samplingPeriod);
        }
        if (jdbcXMLConfiguration.description != null) {
            Jonas53.logger.finest("[JdbcXML configuration] setting description: " + jdbcXMLConfiguration.description);
            jdbcXml.setDescription(jdbcXMLConfiguration.description);
        }
        this.jdbcXmlList.add(jdbcXml);
    }

    /**
     * {@inheritDoc}
     */
    public void addJdbcResource(final String ref, final JdbcXMLConfiguration jdbcXMLConfiguration) {
        if (ref.equals(dbId)) {
            initDb();
            jdbcXMLConfiguration.classname = this.db.getClassname();
            jdbcXMLConfiguration.mapper = this.db.getMapper();
            jdbcXMLConfiguration.url = this.db.getUrl("localhost");
            Map.Entry<String, String> user = this.db.getFirstUsernameAndPassword();
            jdbcXMLConfiguration.username = user.getKey();
            jdbcXMLConfiguration.password = user.getValue();
            addJdbcResource(jdbcXMLConfiguration);
        } else {
            NotApplicableHelper.notApplicable("Resource.Jdbc. The reference " + ref + " is invalid.");
        }
    }

    /**
     * {@inheritDoc}
     */
    public void addJdbcRA(final String raName, final JDBCConfiguration configuration) {
        NotApplicableHelper.notApplicable("resource.addJdbcRa");
    }

    /**
     * Initialize Smartclient if not set
     */
    private void initSmartclient() {
        if (this.smartClient == null) {
            this.smartClient = new SmartClient();
            this.smartClient.setProject(this.project);
        }
    }

    /**
     * {@inheritDoc}
     */
    public void setSmartClientPort(final String port) {
        Jonas53.logger.finest("[Smartclient configuration] setting port: " + port);
        initSmartclient();
        this.smartClient.setPort(port);
    }

    /* ------------------------------- */

    /**
     * {@inheritDoc}
     */
    public void execute() {
        if (!this.isJonasRootSet) {
            throw new IllegalArgumentException("Jonas root is not set.");
        }
        if (!this.isJonasBaseSet) {
            throw new IllegalArgumentException("Jonas base is not set.");
        }

        this.jonasBase.addConfiguredServices(this.services);
        this.jonasBase.execute();
        this.jonasProperties.execute();
        this.doReplacements(new File(this.jonasFileBase, "conf"));

        if (this.ha != null) {
            this.ha.execute();
        }
        if (this.cmi != null) {
            this.cmi.execute();
        }

        WebContainer webContainer = null;
        try {
            if (this.webContainer == null) {
                // If not set, get the webContainer from jonas.properties
                //
                // jonas.service.web.class is for example org.ow2.jonas.web.tomcat7.Tomcat7Service,
                // we therefore split it at each for and get the length - 2 (in our example, tomcat7).
                Properties jonasProperties = new Properties();
                InputStream fis = new FileInputStream(new File(this.jonasFileBase, "conf/jonas.properties"));
                try {
                    jonasProperties.load(fis);
                } finally {
                    fis.close();
                    fis = null;
                    System.gc();
                }
                final String webToken = jonasProperties.getProperty("jonas.service.web.class");
                if (webToken != null) {
                    String[] defaultWebcontainerClass = webToken.split("\\.");
                    this.webContainer = defaultWebcontainerClass[defaultWebcontainerClass.length - 2];
                }
            }

            if (this.webContainer != null) {
                for (String webContainerClassName : getAllClasses((URLClassLoader) this.getClass().getClassLoader(),
                        WebContainer.class.getName())) {

                    if (webContainerClassName.contains(this.webContainer)) {
                        webContainer = (WebContainer)
                                this.getClass().getClassLoader().loadClass(webContainerClassName).newInstance();
                        webContainer.setProject(this.project);
                    }
                }
            }
        } catch (Exception e) {
            throw new IllegalStateException("Cannot create Web container", e);
        }

        if (webContainer != null) {
            //jvm route
            if (this.jvmRoute != null) {
                invokeMethod(webContainer, "setJvmRoute", this.jvmRoute, "Web.jvmRoute",
                        "[Web configuration] cannot set jvm route : " + jvmRoute);
            }

            //web ondemand
            invokeMethod(webContainer, "setOndemandenabled", String.valueOf(this.isWebOnDemandActivated),
                    "webContainer.ondemandenabled", "[Web configuration] cannot set ondemandenable : " + this.isWebOnDemandActivated);

            if (this.isWebOnDemandActivated && this.webOnDemandRedirectPort != null) {
                invokeMethod(webContainer, "setOndemandredirectPort", this.webOnDemandRedirectPort, "webContainer.ondemandRedirectPort",
                        "[Web configuration] cannot set ondemand redirect port : " + this.webOnDemandRedirectPort);
            }

            //create AJP connector
            Ajp ajp = null;
            if (this.isAjpActivated) {
                ajp = (Ajp) instanciateConnector(Ajp.class.getName(), this.webContainer);
                if (ajp != null) {
                    if (this.ajpEnableLookups != null) {
                        invokeMethod(ajp, "setEnableLookups", String.valueOf(this.ajpEnableLookups), "ajp.enableLookups",
                                "[AJP configuration] cannot set enableLookups property : " + this.ajpEnableLookups);
                    }
                    if (this.ajpAcceptCount != null) {
                        invokeMethod(ajp, "setAcceptCount", this.ajpAcceptCount, "ajp.acceptCount",
                                "[AJP configuration] cannot set accept count : " + this.ajpAcceptCount);
                    }
                    if (this.ajpConnectionTimeout != null) {
                        invokeMethod(ajp, "setConnectionTimeout", this.ajpConnectionTimeout, "ajp.connectionTimeout",
                                "[AJP configuration] cannot set connection timeout to: " + this.ajpConnectionTimeout);
                    }
                    if (this.ajpMaxThreads != null) {
                        invokeMethod(ajp, "setMaxThreads", this.ajpMaxThreads, "ajp.maxThreads",
                                "[AJP configuration] cannot set max threads ; " + this.ajpMaxThreads);
                    }
                    if (this.ajpMinSpareThreads != null) {
                        invokeMethod(ajp, "setMinSpareThreads", this.ajpMinSpareThreads, "ajp.minSpareThreads",
                                "[AJP configuration] cannot set min spare threads : " + this.ajpMinSpareThreads);
                    }
                    if (this.ajpPort != null) {
                        invokeMethod(ajp, "setPort", this.ajpPort, "ajp.port", "[AJP configuration] cannot set port : " +
                                this.ajpPort);
                    }
                    if (this.ajpRedirectPort != null) {
                        invokeMethod(ajp, "setRedirectPort", this.ajpRedirectPort, "ajp.redirectPort",
                                "[AJP configuration] cannot set redirect port : " + this.ajpRedirectPort);
                    }
                }
            }

            //create HTTP connector
            Http http = null;
            if (this.isHttpActivated) {
                http = (Http) instanciateConnector(Http.class.getName(), this.webContainer);
                if (http != null) {
                    if (this.httpEnableLookups != null) {
                        invokeMethod(http, "setEnableLookups", String.valueOf(this.httpEnableLookups), "http.enableLookups",
                                "[HTTP configuration] cannot set enableLookups property : " + this.httpEnableLookups);
                    }
                    if (this.httpAcceptCount != null) {
                        invokeMethod(http, "setAcceptCount", this.httpAcceptCount, "http.acceptCount",
                                "[HTTP configuration] cannot set accept count : " + this.httpAcceptCount);
                    }
                    if (this.httpConnectionTimeout != null) {
                        invokeMethod(http, "setConnectionTimeout", this.httpConnectionTimeout, "http.connectionTimeout",
                                "[HTTP configuration] cannot set connection timeout to: " + this.httpConnectionTimeout);
                    }
                    if (this.httpMaxThreads != null) {
                        invokeMethod(http, "setMaxThreads", this.httpMaxThreads, "http.maxThreads",
                                "[HTTP configuration] cannot set max threads ; " + this.httpMaxThreads);
                    }
                    if (this.httpMinSpareThreads != null) {
                        invokeMethod(http, "setMinSpareThreads", this.httpMinSpareThreads, "http.minSpareThreads",
                                "[HTTP configuration] cannot set min spare threads : " + this.httpMinSpareThreads);
                    }
                    if (this.httpPort != null) {
                        invokeMethod(http, "setPort", this.httpPort, "http.port", "[HTTP configuration] cannot set port : " +
                                this.httpPort);
                    }
                    if (this.httpRedirectPort != null) {
                        invokeMethod(http, "setRedirectPort", this.httpRedirectPort, "http.redirectPort",
                                "[HTTP configuration] cannot set redirect port : " + this.httpRedirectPort);
                    }
                    if (this.httpCompression != null) {
                        invokeMethod(http, "setCompression", this.httpCompression, "http.compression",
                                "[HTTP configuration] cannot set compression : " + this.httpCompression);
                    }
                    if (this.httpMaxKeepAliveRequest != null) {
                        invokeMethod(http, "setMaxKeepAliveRequest", this.httpMaxKeepAliveRequest, "http.maxKeepAliveRequest",
                                "[HTTP configuration] cannot set max keep alive request : " + this.httpMaxKeepAliveRequest);
                    }
                }
            }

            //create HTTPS connector
            Https https = null;
            if (this.isHttpsActivated) {
                https = (Https) instanciateConnector(Https.class.getName(), this.webContainer);
                if (https != null) {
                    if (this.httpsEnableLookups != null) {
                        invokeMethod(https, "setEnableLookups", String.valueOf(this.httpsEnableLookups), "https.enableLookups",
                                "[HTTPS configuration] cannot set enableLookups property : " + this.httpsEnableLookups);
                    }
                    if (this.httpsAcceptCount != null) {
                        invokeMethod(https, "setAcceptCount", this.httpsAcceptCount, "https.acceptCount",
                                "[HTTPS configuration] cannot set accept count : " + this.httpsAcceptCount);
                    }
                    if (this.httpsConnectionTimeout != null) {
                        invokeMethod(https, "setConnectionTimeout", this.httpsConnectionTimeout, "https.connectionTimeout",
                                "[HTTPS configuration] cannot set connection timeout to: " + this.httpsConnectionTimeout);
                    }
                    if (this.httpsMaxThreads != null) {
                        invokeMethod(https, "setMaxThreads", this.httpsMaxThreads, "https.maxThreads",
                                "[HTTPS configuration] cannot set max threads ; " + this.httpsMaxThreads);
                    }
                    if (this.httpsMinSpareThreads != null) {
                        invokeMethod(https, "setMinSpareThreads", this.httpsMinSpareThreads, "https.minSpareThreads",
                                "[HTTPS configuration] cannot set min spare threads : " + this.httpsMinSpareThreads);
                    }
                    if (this.httpsPort != null) {
                        invokeMethod(https, "setPort", this.httpsPort, "https.port", "[HTTPS configuration] cannot set port : " +
                                this.httpsPort);
                    }
                    if (this.httpsRedirectPort != null) {
                        invokeMethod(https, "setRedirectPort", this.httpsRedirectPort, "https.redirectPort",
                                "[HTTPS configuration] cannot set redirect port : " + this.httpsRedirectPort);
                    }
                    if (this.httpsCompression != null) {
                        invokeMethod(https, "setCompression", this.httpsCompression, "https.compression",
                                "[HTTPS configuration] cannot set compression : " + this.httpsCompression);
                    }
                    if (this.httpsMaxKeepAliveRequest != null) {
                        invokeMethod(https, "setMaxKeepAliveRequest", this.httpsMaxKeepAliveRequest, "https.maxKeepAliveRequest",
                                "[HTTPS configuration] cannot set max keep alive request : " + this.httpsMaxKeepAliveRequest);
                    }
                    if (this.httpsKeystoreFile != null) {
                        invokeMethod(https, "setKeystoreFile", this.httpsKeystoreFile, "https.keyStoreFile",
                                "[HTTPS configuration] cannot set keystore file : " + this.httpsKeystoreFile);
                    }
                    if (this.httpsKeystorePass != null) {
                        invokeMethod(https, "setKeystorePass", this.httpsKeystorePass, "https.keyStorePass",
                                "[HTTPS configuration] cannot set keystore pass : " + this.httpsKeystorePass);
                    }
                }
            }

            SessionReplication sessionReplication = null;
            if (this.isHttpReplicationActivated) {
                sessionReplication = new SessionReplication();
                if (this.sessionReplicationAlgorithm != null) {
                    sessionReplication.setAlgorithm(this.sessionReplicationAlgorithm);
                }
                if (this.sessionReplicationClusterName != null) {
                    sessionReplication.setName(this.sessionReplicationClusterName);
                }
                if (this.sessionReplicationMulticastAddress != null) {
                    sessionReplication.setMcastAddr(this.sessionReplicationMulticastAddress);
                }
                if (this.sessionReplicationMulticastPort != null) {
                    sessionReplication.setMcastPort(this.sessionReplicationMulticastPort);
                }
                if (this.sessionReplicationListenPort != null) {
                    sessionReplication.setListenPort(this.sessionReplicationListenPort);
                }
            }

            TomcatSessionManager tomcatSessionManager = null;
            if (this.isHttpSessionManagerActivated) {
                tomcatSessionManager = new TomcatSessionManager();
                if (this.maxActiveSession != null) {
                    tomcatSessionManager.setMaxActiveSessions(this.maxActiveSession);
                }
            }

            //instanciate webcontainer Connectors object
            Connectors connectors = null;
            Method connectorsMethod = null;
            for (Method method : webContainer.getClass().getMethods()) {
                if (method.getName().equals("addConfiguredConnectors") && method.getParameterTypes().length == 1) {
                    try {
                        connectors = (Connectors) method.getParameterTypes()[0].newInstance();
                        connectors.setProject(this.project);
                        connectors.setSkipOptionalDeployablesCopy(true);
                    } catch (Exception e) {
                        throw new IllegalStateException("Cannot generate Web connector to configure", e);
                    }
                    connectorsMethod = method;
                    break;
                }
            }
            if (connectors == null) {
                throw new IllegalStateException("Cannot find method for adding configured Web connector");
            }

            //addition of all connector to the Connectors object
            if (http != null) {
                invokeMethod(connectors, "addConfiguredHttp", http, "web.connectors.http",
                        "[Web container] cannot add configured Web HTTP connector");
            }
            if (https != null) {
                invokeMethod(connectors, "addConfiguredHttps", https, "web.connectors.https",
                        "[Web container] cannot add configured Web HTTPS connector");
            }
            if (ajp != null) {
                invokeMethod(connectors, "addConfiguredAjp", ajp, "web.connectors.ajp",
                        "[Web container] cannot add configured Web AJP connector");
            }

            //addition of Connectors object to the WebContainer
            try {
                connectorsMethod.invoke(webContainer, connectors);
            } catch (Exception e) {
                throw new IllegalStateException("Cannot add configured Web connector", e);
            }

            //addition of session manager to the webcontainer
            if (tomcatSessionManager != null) {
                invokeMethod(webContainer, "addConfiguredSessionManager", tomcatSessionManager, "web.sessionManager",
                        "[Web container] cannot add configured Web session manager");
            }

            //addition of session replication object to the webContainer
            if (sessionReplication != null) {
                invokeMethod(webContainer, "addConfiguredSessionReplication", sessionReplication, "web.sessionReplication",
                        "[Web container] cannot add configured Web session replication");
            }

            //execute the webcontainer task
            webContainer.execute();
        }

        if (!this.isProtocolsListSet) {
            this.carol.setProtocols("jrmp");
        }
        this.carol.execute();

        if (this.db != null) {
            this.db.execute();
        }

        //TODO to be able to configure each discovery service
        if (this.discovery != null) {
            this.discovery.execute();
        }

        if (this.smartClient != null) {
            this.smartClient.execute();
        } 

        boolean first = true;
        for (JdbcXml jdbcXml : this.jdbcXmlList) {
            
            // The JdbcXml task will write all DS definitions to a single file
            // called JONAS_BASE/deploy/jdbc-ds.xml
            //
            // Since the file does not exist at the first call, we need to set
            // it as "new file"; after we tell JdbcXml to merge
            jdbcXml.setNewFile(Boolean.toString(first));
            jdbcXml.execute();
            first = false;
        }

        if (this.jms != null) {
            this.jms.execute();
        }

        for (User admin: admins) {
            this.security.addConfiguredAdmin(admin);
        }
        for (User user: users) {
            this.security.addConfiguredUser(user);
        }
        this.security.execute();

        for (Mail mail: this.mails) {
            mail.execute();
        }

        if (this.wsdlPublisherFile != null) {
            this.wsdlPublish = new WsdlPublish();
            this.wsdlPublish.setProject(this.project);
            this.wsdlPublish.addConfiguredFile(this.wsdlPublisherFile);
            this.wsdlPublish.execute();
        }

        if (this.wrapper != null) {
            this.wrapper.execute();
        }
    }

    /* --------------------------------- */
    /* Cluster daemon configuration part */

    /**
     * Initialize ClusterDaemon if not set
     */
    private void initClusterDaemon() {
        if (this.clusterDaemon == null) {
            this.clusterDaemon = new ClusterDaemon();
            this.clusterDaemon.setProject(this.project);
        }
    }

    /**
     * {@inheritDoc}
     */
    public void setCDClusterName(final String clusterName) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting cluster name : " + clusterName);
        initClusterDaemon();
        this.clusterDaemon.setName(clusterName);
    }

    /**
     * {@inheritDoc}
     */
    public void setCDClusterDomain(final String clusterDomain) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting cluster domain name : " + clusterDomain);
        initClusterDaemon();
        this.clusterDaemon.setDomainName(clusterDomain);
    }

    /**
     * {@inheritDoc}
     */
    public void setCDProtocol(final String protocol) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting protocol : " + protocol);
        NotApplicableHelper.notApplicable("clusterdaemon.protocol");
    }

    /**
     * {@inheritDoc}
     */
    public void setCDPort(final String port) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting port : " + port);
        NotApplicableHelper.notApplicable("clusterdaemon.port");
    }

    /**
     * {@inheritDoc}
     */
    public void setCDDestDirPrefix(final String destDirPrefix) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting dest dir prefix : " + destDirPrefix);
        initClusterDaemon();
        this.clusterDaemon.setDestDirPrefix(destDirPrefix);
        this.clusterDaemon.setCdDir(destDirPrefix);
        this.project.setProperty("jonas.base", destDirPrefix);
    }

    /**
     * {@inheritDoc}
     */
    public void setCDInteractionMode(final String interactionMode) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting interaction mode : " + interactionMode);
        initClusterDaemon();
        this.clusterDaemon.setInteractionMode(interactionMode);
    }

    /**
     * {@inheritDoc}
     */
    public void setCDJavaHome(final String javaHome) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting java home : " + javaHome);
        initClusterDaemon();
        this.clusterDaemon.setJdk(javaHome);
    }

    /**
     * {@inheritDoc}
     */
    public void setCDJonasRoot(final String jonasRoot) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting jonas root : " + jonasRoot);
        NotApplicableHelper.notApplicable("jonas.root");
    }

    /**
     * {@inheritDoc}
     */
    public void setCDServerNamePrefix(final String serverNamePrefix) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting server name prefix : " + serverNamePrefix);
        initClusterDaemon();
        this.clusterDaemon.setClusterNodesName(serverNamePrefix);
    }

    /**
     * {@inheritDoc}
     */
    public void setCDXparam(final String xparam) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting xparam : " + xparam);
        initClusterDaemon();
        this.clusterDaemon.setXprm(xparam);
    }

    /**
     * {@inheritDoc}
     */
    public void setCDAutoBoot(final boolean autoBoot) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting auto boot : " + autoBoot);
        initClusterDaemon();
        this.clusterDaemon.setAutoBoot(new Boolean(autoBoot).toString());
    }

    /**
     * {@inheritDoc}
     */
    public void setCDNbInstances(final int nbInsts) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting nb instance : " + nbInsts);
        initClusterDaemon();
        this.clusterDaemon.setInstNb(nbInsts);
    }

    /**
     * {@inheritDoc}
     */
    public void setCDJOnASScript(final String jonasScript) {
        Jonas53.logger.finest("[Cluster daemon configuration] setting jonas script : " + jonasScript);
        initClusterDaemon();
        this.clusterDaemon.setJonasScript(jonasScript);
    }

    /**
     * {@inheritDoc}
     */
    public void executeCDConf() {
        if (this.clusterDaemon != null) {
            this.clusterDaemon.execute();
        }
    }
    /* --------------------------------- */

    /**
     * {@inheritDoc}
     */
    public void setWrapperConfiguration(final String javaHome, final String wrapperHome, final String serviceName,
                                        final String serviceDescription, final Boolean verbosity, final String logfile,
                                        final String logfileRollmode) {
        File wrapperDir = null;
        if (wrapperHome != null) {
            wrapperDir = new File(wrapperHome);
        }
        if (wrapperDir == null || !wrapperDir.exists()) {
            wrapperDir = new File(this.project.getProperty("jonas.root") + File.separator + "wrapper");
        }

        //locate wrapper ANT task
        File wrapperAntTaskFile = new File(wrapperDir + File.separator + "lib" + File.separator + "ant" + File.separator
                + "ow2_jonas_wrapper_ant.jar");
        if (!wrapperAntTaskFile.exists()) {
            Jonas53.logger.finest("Wrapper home is incorrect. Cannot find Wrapper ANT task");
            NotApplicableHelper.notApplicable("wrapper.home");
        } else {
            URL wrapperAntTask = null;
            try {
                wrapperAntTask = wrapperAntTaskFile.toURI().toURL();
            } catch (MalformedURLException e) {
                Jonas53.logger.severe("Cannot get the URL of the file " + wrapperAntTaskFile.getAbsolutePath());
            }

            if (wrapperAntTask != null) {
                ClassLoader classLoader = new URLClassLoader(new URL[] {wrapperAntTask}, this.getClass().getClassLoader());
                Class<? extends JOnASWrapper> clazz = null;
                try {
                    clazz = classLoader.loadClass(JOnASWrapper.class.getName()).asSubclass(JOnASWrapper.class);
                } catch (ClassNotFoundException e) {
                    Jonas53.logger.severe("Cannot found class " + JOnASWrapper.class.getName());
                }
                try {
                    this.wrapper = clazz.newInstance();
                } catch (InstantiationException e) {
                    Jonas53.logger.severe("Cannot instanciate " + Jonas53.class.getName());
                } catch (IllegalAccessException e) {
                    Jonas53.logger.severe("Cannot instanciate " + Jonas53.class.getName());
                }
                if (this.wrapper != null) {
                    this.wrapper.setProject(this.project);
                    if (javaHome != null) {
                        this.wrapper.setJavaHome(javaHome);
                    }
                    if (wrapperHome != null) {
                        this.wrapper.setWrapperHome(wrapperHome);
                    }
                    if (serviceName != null) {
                        this.wrapper.setServiceName(serviceName);
                    }
                    if (serviceDescription != null) {
                        this.wrapper.setServiceDescription(serviceDescription);
                    }
                    if (verbosity != null) {
                        this.wrapper.setVerbosity(verbosity);
                    }
                    if (logfile != null) {
                        this.wrapper.setLogfile(logfile);
                    }
                    if (logfileRollmode != null) {
                        this.wrapper.setLogfileRollmode(logfileRollmode);
                    }
                }
            }
        }
    }


    /**
     * Gets all classes in a given URLClassLoader that are children of a given class or interface.
     * @param urlCL URLClassLoader to scan.
     * @param parent Parent class or interface that returned classes should implement.
     * @return All classes in <code>urlCl</code> that are children of class or interface <code>parent</code>.
     * @throws IOException If the URLClassLoader cannot be read.
     * @throws URISyntaxException If the URLClassLoader cannot be read.
     * @throws ClassNotFoundException If class or interface <code>parent</code> cannot be loaded.
     */
    private SortedSet<String> getAllClasses(URLClassLoader urlCL, String parent)
        throws IOException, URISyntaxException, ClassNotFoundException {

        SortedSet<String> classes = new TreeSet<String>();

        Class<?> parentClass;
        try {
            parentClass = urlCL.loadClass(parent);
        } catch (ClassNotFoundException e) {
            throw new IllegalArgumentException("Class " + parent + " not found in " + urlCL);
        }

        for (URL url : urlCL.getURLs()) {
            classes.addAll(getAllClasses(url, urlCL, parentClass));
        }

        return classes;
    }

    /**
     * Gets all classes in a given JAR file or a URLClassLoader that are children of a given class or interface.
     * @param jarUrl JAR file's URL.
     * @param urlCL URLClassLoader to scan.
     * @param parentClass Parent class or interface that returned classes should implement.
     * @return All classes in <code>jar</code> that are member of <code>urlCl</code> that are children of class or interface
     * <code>parent</code>.
     * @throws IOException If the JAR file cannot be read.
     * @throws URISyntaxException If the JAR file cannot be read.
     * @throws ClassNotFoundException If class or interface <code>parent</code> cannot be loaded.
     */
    private SortedSet<String> getAllClasses(URL jarUrl, URLClassLoader urlCL, Class<?> parentClass)
        throws IOException, URISyntaxException, ClassNotFoundException {

        SortedSet<String> classes = new TreeSet<String>();

        File jarFile = new File(jarUrl.toURI());
        if (!jarFile.isFile()) {
            return classes;
        }

        JarFile jar = new JarFile(jarFile);
        Enumeration<JarEntry> entries = jar.entries();
        while (entries.hasMoreElements()) {
            JarEntry entry = entries.nextElement();
            String entryName = entry.getName();
            if (entryName.endsWith(".class") && !entryName.contains("$")) {
                entryName = entryName.substring(0, entryName.length() - 6);
                entryName = entryName.replace('/', '.');
                entryName = entryName.replace('\\', '.');

                Class<?> entryClass;
                try {
                    entryClass = urlCL.loadClass(entryName);
                } catch (NoClassDefFoundError ignored) {
                    continue;
                }
                if (!entryClass.isInterface() && ! Modifier.isAbstract(entryClass.getModifiers())
                    && parentClass.isAssignableFrom(entryClass)) {

                    classes.add(entryName);
                }
            }
        }

        return classes;
    }

    /**
     * Generic method in order to invoke a method
     * @param object The object which contains the method to invoke
     * @param methodToInvoke Name of the method to invoke
     * @param parameter The parameter of the method to invoke.
     * @param notApplicableLog Log if no such method is defined in the given object class
     * @param invocationExceptionLog Log if the method invocation failed
     */
    private void invokeMethod(final Object object, final String methodToInvoke,
                              final Object parameter, final String notApplicableLog,
                              final String invocationExceptionLog) {
        List<Object> parameters = new ArrayList<Object>();
        parameters.add(parameter);
        invokeMethod(object, methodToInvoke, parameters, notApplicableLog, invocationExceptionLog);
    }

    /**
     * Generic method in order to invoke a method
     * @param object The object which contains the method to invoke
     * @param methodToInvoke Name of the method to invoke
     * @param parameters  List of parameters of the method to invoke.
     * @param notApplicableLog Log if no such method is defined in the given object class
     * @param invocationExceptionLog Log if the method invocation failed
     */
    private void invokeMethod(final Object object, final String methodToInvoke,
                              final List<Object> parameters, final String notApplicableLog,
                              final String invocationExceptionLog) {
        if (object == null) {
            throw new IllegalArgumentException("'object' parameter shouldn't be null");
        }
        if (parameters == null) {
            throw new IllegalArgumentException("'parameters' parameter shouldn't be null");
        }

        List<Class<?>> parametersClass = new ArrayList<Class<?>>();
        for (Object parameter: parameters) {
            parametersClass.add(parameter.getClass());
        } 
        Method method = null;
        try {
            method = object.getClass().getMethod(methodToInvoke, parametersClass.toArray(new Class<?>[parametersClass.size()]));
        } catch (NoSuchMethodException e) {
            NotApplicableHelper.notApplicable(notApplicableLog);
        }
        if (method != null) {
            try {
                method.invoke(object, parameters.toArray(new Object[parameters.size()]));
            } catch (Exception e) {
                throw new IllegalArgumentException(invocationExceptionLog, e);
            }
        }
    }

    /**
     * Instanciate a connector (HTTP, HTTPS, AJP) according to the webcontainer implementation
     * @param connectorClassName Name of the generic connector class 
     * @param webContainer Name of the webcontainer implementation
     * @return the instance of a connector
     */
    private Object instanciateConnector(final String connectorClassName, final String webContainer) {
        try {
            //try to find a connector classname with a name equals to ${connector.name} + ${webcontainer.name}
            SortedSet<String> classesName = getAllClasses((URLClassLoader) this.getClass().getClassLoader(), connectorClassName);
            for (String className: classesName) {
                if (className.contains(webContainer)) {
                    return this.getClass().getClassLoader().loadClass(className).newInstance();
                }
            }

            //try to find a connector classname with a name equals to ${connector.name} + ${webcontainer.nameWithoutVersions}
            String webContainerWitoutVersion =  webContainer.trim(); 
            while (Character.isDigit(webContainerWitoutVersion.charAt(webContainerWitoutVersion.length() - 1))) {
                webContainerWitoutVersion = webContainerWitoutVersion.substring(0, webContainerWitoutVersion.length() - 1);
            }
            for (String className: classesName) {
                if (className.contains(webContainerWitoutVersion)) {
                    return this.getClass().getClassLoader().loadClass(className).newInstance();
                }
            }

            //nothing found...so just return a super instance of the connector
            return this.getClass().getClassLoader().loadClass(connectorClassName).newInstance();

        } catch (Exception e) {
            throw new IllegalStateException("Cannot create an AJP connector", e);
        }
    }
}

Rev 22396	Rev 22426
1	`/**`	1	`/**`
2	`* JOnAS Configurator`	2	`* JOnAS Configurator`
3	`* Copyright (C) 2008-2010 Bull S.A.S.`	3	`* Copyright (C) 2008-2010 Bull S.A.S.`
4	`* Copyright (C) 2008-2010 France Telecom R&D`	4	`* Copyright (C) 2008-2010 France Telecom R&D`
5	`* Contact: jonas-team@ow2.org`	5	`* Contact: jonas-team@ow2.org`
6	`*`	6	`*`
7	`* This library is free software; you can redistribute it and/or`	7	`* This library is free software; you can redistribute it and/or`
8	`* modify it under the terms of the GNU Lesser General Public`	8	`* modify it under the terms of the GNU Lesser General Public`
9	`* License as published by the Free Software Foundation; either`	9	`* License as published by the Free Software Foundation; either`
10	`* version 2.1 of the License, or any later version.`	10	`* version 2.1 of the License, or any later version.`
11	`*`	11	`*`
12	`* This library is distributed in the hope that it will be useful,`	12	`* This library is distributed in the hope that it will be useful,`
13	`* but WITHOUT ANY WARRANTY; without even the implied warranty of`	13	`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
14	`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`	14	`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
15	`* Lesser General Public License for more details.`	15	`* Lesser General Public License for more details.`
16	`*`	16	`*`
17	`* You should have received a copy of the GNU Lesser General Public`	17	`* You should have received a copy of the GNU Lesser General Public`
18	`* License along with this library; if not, write to the Free Software`	18	`* License along with this library; if not, write to the Free Software`
19	`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307`	19	`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307`
20	`* USA`	20	`* USA`
21	`*`	21	`*`
22	`* --------------------------------------------------------------------------`	22	`* --------------------------------------------------------------------------`
23	`* $Id: Jonas53.java 22396 2012-04-25 07:51:54Z cazauxj $`	-
-		23	`* $Id: Jonas53.java 22426 2012-05-04 17:05:04Z cazauxj $`
24	`* --------------------------------------------------------------------------`	24	`* --------------------------------------------------------------------------`
25	`*/`	25	`*/`
26	`package org.ow2.jonas.tools.configurator.impl;`	26	`package org.ow2.jonas.tools.configurator.impl;`
27		27
28	`import java.io.File;`	28	`import java.io.File;`
29	`import java.io.FileInputStream;`	29	`import java.io.FileInputStream;`
30	`import java.io.IOException;`	30	`import java.io.IOException;`
31	`import java.io.InputStream;`	31	`import java.io.InputStream;`
32	`import java.io.OutputStream;`	32	`import java.io.OutputStream;`
33	`import java.io.PrintStream;`	33	`import java.io.PrintStream;`
34	`import java.lang.reflect.Method;`	34	`import java.lang.reflect.Method;`
35	`import java.lang.reflect.Modifier;`	35	`import java.lang.reflect.Modifier;`
36	`import java.net.MalformedURLException;`	36	`import java.net.MalformedURLException;`
37	`import java.net.URISyntaxException;`	37	`import java.net.URISyntaxException;`
38	`import java.net.URL;`	38	`import java.net.URL;`
39	`import java.net.URLClassLoader;`	39	`import java.net.URLClassLoader;`
40	`import java.util.ArrayList;`	40	`import java.util.ArrayList;`
41	`import java.util.Enumeration;`	41	`import java.util.Enumeration;`
42	`import java.util.List;`	42	`import java.util.List;`
43	`import java.util.Map;`	43	`import java.util.Map;`
44	`import java.util.Properties;`	44	`import java.util.Properties;`
45	`import java.util.SortedSet;`	45	`import java.util.SortedSet;`
46	`import java.util.TreeSet;`	46	`import java.util.TreeSet;`
47	`import java.util.jar.JarEntry;`	47	`import java.util.jar.JarEntry;`
48	`import java.util.jar.JarFile;`	48	`import java.util.jar.JarFile;`
49	`import java.util.logging.Logger;`	49	`import java.util.logging.Logger;`
50		50
51	`import org.apache.tools.ant.Project;`	51	`import org.apache.tools.ant.Project;`
52	`import org.apache.tools.ant.listener.TimestampedLogger;`	52	`import org.apache.tools.ant.listener.TimestampedLogger;`
53	`import org.ow2.jonas.antmodular.cluster.clusterdaemon.ClusterDaemon;`	53	`import org.ow2.jonas.antmodular.cluster.clusterdaemon.ClusterDaemon;`
54	`import org.ow2.jonas.antmodular.cmi.Cmi;`	54	`import org.ow2.jonas.antmodular.cmi.Cmi;`
55	`import org.ow2.jonas.antmodular.jonasbase.bootstrap.JOnASBaseTask;`	55	`import org.ow2.jonas.antmodular.jonasbase.bootstrap.JOnASBaseTask;`
56	`import org.ow2.jonas.antmodular.jonasbase.bootstrap.JonasProperties;`	56	`import org.ow2.jonas.antmodular.jonasbase.bootstrap.JonasProperties;`
57	`import org.ow2.jonas.antmodular.jonasbase.bootstrap.Services;`	57	`import org.ow2.jonas.antmodular.jonasbase.bootstrap.Services;`
58	`import org.ow2.jonas.antmodular.jonasbase.carol.Carol;`	58	`import org.ow2.jonas.antmodular.jonasbase.carol.Carol;`
59	`import org.ow2.jonas.antmodular.jonasbase.db.base.Db;`	59	`import org.ow2.jonas.antmodular.jonasbase.db.base.Db;`
60	`import org.ow2.jonas.antmodular.jonasbase.db.h2.DbH2;`	60	`import org.ow2.jonas.antmodular.jonasbase.db.h2.DbH2;`
61	`import org.ow2.jonas.antmodular.jonasbase.discovery.multicast.DiscoveryMulticast;`	61	`import org.ow2.jonas.antmodular.jonasbase.discovery.multicast.DiscoveryMulticast;`
62	`import org.ow2.jonas.antmodular.jonasbase.ha.Ha;`	62	`import org.ow2.jonas.antmodular.jonasbase.ha.Ha;`
63	`import org.ow2.jonas.antmodular.jonasbase.jms.Jms;`	63	`import org.ow2.jonas.antmodular.jonasbase.jms.Jms;`
64	`import org.ow2.jonas.antmodular.jonasbase.mail.Mail;`	64	`import org.ow2.jonas.antmodular.jonasbase.mail.Mail;`
65	`import org.ow2.jonas.antmodular.jonasbase.resource.JdbcXml;`	65	`import org.ow2.jonas.antmodular.jonasbase.resource.JdbcXml;`
66	`import org.ow2.jonas.antmodular.jonasbase.security.User;`	66	`import org.ow2.jonas.antmodular.jonasbase.security.User;`
67	`import org.ow2.jonas.antmodular.jonasbase.security.Jaas;`	67	`import org.ow2.jonas.antmodular.jonasbase.security.Jaas;`
68	`import org.ow2.jonas.antmodular.jonasbase.smartclient.SmartClient;`	68	`import org.ow2.jonas.antmodular.jonasbase.smartclient.SmartClient;`
69	`import org.ow2.jonas.antmodular.jonasbase.web.tomcat.TomcatSessionManager;`	69	`import org.ow2.jonas.antmodular.jonasbase.web.tomcat.TomcatSessionManager;`
70	`import org.ow2.jonas.antmodular.jonasbase.wsdl.WsdlPublish;`	70	`import org.ow2.jonas.antmodular.jonasbase.wsdl.WsdlPublish;`
71	`import org.ow2.jonas.antmodular.web.base.Ajp;`	71	`import org.ow2.jonas.antmodular.web.base.Ajp;`
72	`import org.ow2.jonas.antmodular.web.base.Connectors;`	72	`import org.ow2.jonas.antmodular.web.base.Connectors;`
73	`import org.ow2.jonas.antmodular.web.base.Http;`	73	`import org.ow2.jonas.antmodular.web.base.Http;`
74	`import org.ow2.jonas.antmodular.web.base.Https;`	74	`import org.ow2.jonas.antmodular.web.base.Https;`
75	`import org.ow2.jonas.antmodular.web.base.SessionReplication;`	75	`import org.ow2.jonas.antmodular.web.base.SessionReplication;`
76	`import org.ow2.jonas.antmodular.web.base.WebContainer;`	76	`import org.ow2.jonas.antmodular.web.base.WebContainer;`
77	`import org.ow2.jonas.tools.configurator.api.JDBCConfiguration;`	77	`import org.ow2.jonas.tools.configurator.api.JDBCConfiguration;`
78	`import org.ow2.jonas.tools.configurator.api.JdbcXMLConfiguration;`	78	`import org.ow2.jonas.tools.configurator.api.JdbcXMLConfiguration;`
79	`import org.ow2.jonas.tools.configurator.api.JonasConfigurator;`	79	`import org.ow2.jonas.tools.configurator.api.JonasConfigurator;`
80		80
81	`/**`	81	`/**`
82	`* JonasConfigurator implementation for Jonas 5.3.x`	82	`* JonasConfigurator implementation for Jonas 5.3.x`
83	`*`	83	`*`
84	`* @author S. Ali Tokmen`	84	`* @author S. Ali Tokmen`
85	`* @author Jeremy Cazaux (support to extensible parameters according to a specific implementation)`	85	`* @author Jeremy Cazaux (support to extensible parameters according to a specific implementation)`
86	`*/`	86	`*/`
87	`public class Jonas53 extends FileReplacerHelper implements JonasConfigurator {`	87	`public class Jonas53 extends FileReplacerHelper implements JonasConfigurator {`
88		88
89	`/**`	89	`/**`
90	`* JONAS_BASE`	90	`* JONAS_BASE`
91	`*/`	91	`*/`
92	`private File jonasFileBase;`	92	`private File jonasFileBase;`
93		93
94	`/**`	94	`/**`
95	`* Link to the jonas ant task`	95	`* Link to the jonas ant task`
96	`*/`	96	`*/`
97	`private JOnASBaseTask jonasBase;`	97	`private JOnASBaseTask jonasBase;`
98		98
99	`/**`	99	`/**`
100	`* To configure databases service`	100	`* To configure databases service`
101	`*/`	101	`*/`
102	`private DbH2 db;`	102	`private DbH2 db;`
103		103
104	`/**`	104	`/**`
105	`* The cluster daemon configuration`	105	`* The cluster daemon configuration`
106	`*/`	106	`*/`
107	`private ClusterDaemon clusterDaemon;`	107	`private ClusterDaemon clusterDaemon;`
108		108
109	`/**`	109	`/**`
110	`* Configuration logger`	110	`* Configuration logger`
111	`*/`	111	`*/`
112	`private static Logger logger = Logger.getLogger(Jonas53.class.getName());`	112	`private static Logger logger = Logger.getLogger(Jonas53.class.getName());`
113		113
114	`/**`	114	`/**`
115	`* To configure protocols`	115	`* To configure protocols`
116	`*/`	116	`*/`
117	`private Carol carol;`	117	`private Carol carol;`
118		118
119	`/**`	119	`/**`
120	`* Has JOnAS protocols list been set?`	120	`* Has JOnAS protocols list been set?`
121	`*/`	121	`*/`
122	`private boolean isProtocolsListSet = false;`	122	`private boolean isProtocolsListSet = false;`
123		123
124	`/**`	124	`/**`
125	`* To configure discovery sevice`	125	`* To configure discovery sevice`
126	`*/`	126	`*/`
127	`private DiscoveryMulticast discovery;`	127	`private DiscoveryMulticast discovery;`
128		128
129	`/**`	129	`/**`
130	`* JDBC resources`	130	`* JDBC resources`
131	`*/`	131	`*/`
132	`private List<JdbcXml> jdbcXmlList;`	132	`private List<JdbcXml> jdbcXmlList;`
133		133
134	`/**`	134	`/**`
135	`* To configure jms`	135	`* To configure jms`
136	`*/`	136	`*/`
137	`private Jms jms;`	137	`private Jms jms;`
138		138
139	`/**`	139	`/**`
140	`* To configure jonas global properties`	140	`* To configure jonas global properties`
141	`*/`	141	`*/`
142	`private JonasProperties jonasProperties;`	142	`private JonasProperties jonasProperties;`
143		143
144	`/**`	144	`/**`
145	`* To configure mails`	145	`* To configure mails`
146	`*/`	146	`*/`
147	`private List<Mail> mails;`	147	`private List<Mail> mails;`
148		148
149	`/**`	149	`/**`
150	`* To configure active services`	150	`* To configure active services`
151	`*/`	151	`*/`
152	`private Services services;`	152	`private Services services;`
153		153
154	`/**`	154	`/**`
155	`* To configure web container`	155	`* To configure web container`
156	`*/`	156	`*/`
157	`private String webContainer;`	157	`private String webContainer;`
158		158
159	`/**`	159	`/**`
160	`* To configure web container`	160	`* To configure web container`
161	`*/`	161	`*/`
162	`private String jvmRoute;`	162	`private String jvmRoute;`
163		163
164	`/**`	164	`/**`
165	`* To configure the algorithm of the web session replication`	165	`* To configure the algorithm of the web session replication`
166	`*/`	166	`*/`
167	`private String sessionReplicationAlgorithm;`	167	`private String sessionReplicationAlgorithm;`
168		168
169	`/**`	169	`/**`
170	`* Cluster name of the web session replication`	170	`* Cluster name of the web session replication`
171	`*/`	171	`*/`
172	`private String sessionReplicationClusterName;`	172	`private String sessionReplicationClusterName;`
173		173
174	`/**`	174	`/**`
175	`* Multicast address usefull to configure the web session replication`	175	`* Multicast address usefull to configure the web session replication`
176	`*/`	176	`*/`
177	`private String sessionReplicationMulticastAddress;`	177	`private String sessionReplicationMulticastAddress;`
178		178
179	`/**`	179	`/**`
180	`* Multicast port usefull to configure the web session replication`	180	`* Multicast port usefull to configure the web session replication`
181	`*/`	181	`*/`
182	`private String sessionReplicationMulticastPort;`	182	`private String sessionReplicationMulticastPort;`
183		183
184	`/**`	184	`/**`
185	`* Listen port usefull to configure the web session replication`	185	`* Listen port usefull to configure the web session replication`
186	`*/`	186	`*/`
187	`private String sessionReplicationListenPort;`	187	`private String sessionReplicationListenPort;`
188		188
189	`/**`	189	`/**`
190	`* To configure wsdl wsdlPublisherFile`	190	`* To configure wsdl wsdlPublisherFile`
191	`*/`	191	`*/`
192	`private org.ow2.jonas.antmodular.jonasbase.wsdl.File wsdlPublisherFile;`	192	`private org.ow2.jonas.antmodular.jonasbase.wsdl.File wsdlPublisherFile;`
193		193
194	`/**`	194	`/**`
195	`* To configure WSDL publishing`	195	`* To configure WSDL publishing`
196	`*/`	196	`*/`
197	`private WsdlPublish wsdlPublish;`	197	`private WsdlPublish wsdlPublish;`
198		198
199	`/**`	199	`/**`
200	`* To configure ejb clustering`	200	`* To configure ejb clustering`
201	`*/`	201	`*/`
202	`private Cmi cmi;`	202	`private Cmi cmi;`
203		203
204	`/**`	204	`/**`
205	`* To configure ha cluster`	205	`* To configure ha cluster`
206	`*/`	206	`*/`
207	`private Ha ha;`	207	`private Ha ha;`
208		208
209	`/**`	209	`/**`
210	`* To configure the smartclient service`	210	`* To configure the smartclient service`
211	`*/`	211	`*/`
212	`private SmartClient smartClient;`	212	`private SmartClient smartClient;`
213		213
214	`/**`	214	`/**`
215	`* To configure the security`	215	`* To configure the security`
216	`*/`	216	`*/`
217	`private Jaas security;`	217	`private Jaas security;`
218		218
219	`/**`	219	`/**`
220	`* The project, not really usefull, only to have a project to pass to ant`	220	`* The project, not really usefull, only to have a project to pass to ant`
221	`* task.`	221	`* task.`
222	`*/`	222	`*/`
223	`private Project project;`	223	`private Project project;`
224		224
225	`/**`	225	`/**`
226	`* Is jonas root set`	226	`* Is jonas root set`
227	`*/`	227	`*/`
228	`private boolean isJonasRootSet = false;`	228	`private boolean isJonasRootSet = false;`
229		229
230	`/**`	230	`/**`
231	`* Is jonas base set`	231	`* Is jonas base set`
232	`*/`	232	`*/`
233	`private boolean isJonasBaseSet = false;`	233	`private boolean isJonasBaseSet = false;`
234		234
235	`/**`	235	`/**`
236	`* Is http webservice activated`	236	`* Is http webservice activated`
237	`*/`	237	`*/`
238	`private Boolean isHttpActivated = false;`	238	`private Boolean isHttpActivated = false;`
239		239
240	`/**`	240	`/**`
241	`* Is https webservice activated`	241	`* Is https webservice activated`
242	`*/`	242	`*/`
243	`private Boolean isHttpsActivated = false;`	243	`private Boolean isHttpsActivated = false;`
244		244
245	`/**`	245	`/**`
246	`* Is ajp webservice activated`	246	`* Is ajp webservice activated`
247	`*/`	247	`*/`
248	`private Boolean isAjpActivated = false;`	248	`private Boolean isAjpActivated = false;`
249		249
250	`/**`	250	`/**`
251	`* Is http replication webservice activated`	251	`* Is http replication webservice activated`
252	`*/`	252	`*/`
253	`private Boolean isHttpReplicationActivated = false;`	253	`private Boolean isHttpReplicationActivated = false;`
254		254
255	`/**`	255	`/**`
256	`* Is http session manager activated (only usefull for tomcat7 currently)`	256	`* Is http session manager activated (only usefull for tomcat7 currently)`
257	`*/`	257	`*/`
258	`private Boolean isHttpSessionManagerActivated = false;`	258	`private Boolean isHttpSessionManagerActivated = false;`
259		259
260	`/**`	260	`/**`
261	`* Is web on demand activated`	261	`* Is web on demand activated`
262	`*/`	262	`*/`
263	`private Boolean isWebOnDemandActivated = false;`	263	`private Boolean isWebOnDemandActivated = false;`
264		264
265	`/**`	265	`/**`
266	`* Web ondemand redirect port`	266	`* Web ondemand redirect port`
267	`*/`	267	`*/`
268	`private String webOnDemandRedirectPort;`	268	`private String webOnDemandRedirectPort;`
269		269
270	`/**`	270	`/**`
271	`* The http port to configure`	271	`* The http port to configure`
272	`*/`	272	`*/`
273	`private String httpPort;`	273	`private String httpPort;`
274		274
275	`/**`	275	`/**`
276	`* The max http threads to configure`	276	`* The max http threads to configure`
277	`*/`	277	`*/`
278	`private String httpMaxThreads;`	278	`private String httpMaxThreads;`
279		279
280	`/**`	280	`/**`
281	`* The min spare threads to configure`	281	`* The min spare threads to configure`
282	`*/`	282	`*/`
283	`private String httpMinSpareThreads;`	283	`private String httpMinSpareThreads;`
284		284
285	`/**`	285	`/**`
286	`* The enable http lookups property to configure`	286	`* The enable http lookups property to configure`
287	`*/`	287	`*/`
288	`private Boolean httpEnableLookups;`	288	`private Boolean httpEnableLookups;`
289		289
290	`/**`	290	`/**`
291	`* The http connection timeout to configure`	291	`* The http connection timeout to configure`
292	`*/`	292	`*/`
293	`private String httpConnectionTimeout;`	293	`private String httpConnectionTimeout;`
294		294
295	`/**`	295	`/**`
296	`* The http accept count to configure`	296	`* The http accept count to configure`
297	`*/`	297	`*/`
298	`private String httpAcceptCount;`	298	`private String httpAcceptCount;`
299		299
300	`/**`	300	`/**`
301	`* The max keep alive http request`	301	`* The max keep alive http request`
302	`*/`	302	`*/`
303	`private String httpMaxKeepAliveRequest;`	303	`private String httpMaxKeepAliveRequest;`
304		304
305	`/**`	305	`/**`
306	`* The http compression`	306	`* The http compression`
307	`*/`	307	`*/`
308	`private String httpCompression;`	308	`private String httpCompression;`
309		309
310	`/**`	310	`/**`
311	`* The http redirect port`	311	`* The http redirect port`
312	`*/`	312	`*/`
313	`private String httpRedirectPort;`	313	`private String httpRedirectPort;`
314		314
315	`/**`	315	`/**`
316	`* The https port`	316	`* The https port`
317	`*/`	317	`*/`
318	`private String httpsPort;`	318	`private String httpsPort;`
319		319
320	`/**`	320	`/**`
321	`* The max https threads`	321	`* The max https threads`
322	`*/`	322	`*/`
323	`private String httpsMaxThreads;`	323	`private String httpsMaxThreads;`
324		324
325	`/**`	325	`/**`
326	`* The min spare https threads`	326	`* The min spare https threads`
327	`*/`	327	`*/`
328	`private String httpsMinSpareThreads;`	328	`private String httpsMinSpareThreads;`
329		329
330	`/**`	330	`/**`
331	`* The enable https lookups property to configure`	331	`* The enable https lookups property to configure`
332	`*/`	332	`*/`
333	`private Boolean httpsEnableLookups;`	333	`private Boolean httpsEnableLookups;`
334		334
335	`/**`	335	`/**`
336	`* The https connection timeout`	336	`* The https connection timeout`
337	`*/`	337	`*/`
338	`private String httpsConnectionTimeout;`	338	`private String httpsConnectionTimeout;`
339		339
340	`/**`	340	`/**`
341	`* The https accept count`	341	`* The https accept count`
342	`*/`	342	`*/`
343	`private String httpsAcceptCount;`	343	`private String httpsAcceptCount;`
344		344
345	`/**`	345	`/**`
346	`* The max keep alive https requests`	346	`* The max keep alive https requests`
347	`*/`	347	`*/`
348	`private String httpsMaxKeepAliveRequest;`	348	`private String httpsMaxKeepAliveRequest;`
349		349
350	`/**`	350	`/**`
351	`* The https compression`	351	`* The https compression`
352	`*/`	352	`*/`
353	`private String httpsCompression;`	353	`private String httpsCompression;`
354		354
355	`/**`	355	`/**`
356	`* The https redirect port`	356	`* The https redirect port`
357	`*/`	357	`*/`
358	`private String httpsRedirectPort;`	358	`private String httpsRedirectPort;`
359		359
360	`/**`	360	`/**`
361	`* The https keystore file`	361	`* The https keystore file`
362	`*/`	362	`*/`
363	`private String httpsKeystoreFile;`	363	`private String httpsKeystoreFile;`
364		364
365	`/**`	365	`/**`
366	`* The https keystore password`	366	`* The https keystore password`
367	`*/`	367	`*/`
368	`private String httpsKeystorePass;`	368	`private String httpsKeystorePass;`
369		369
370	`/**`	370	`/**`
371	`* The ajp port`	371	`* The ajp port`
372	`*/`	372	`*/`
373	`private String ajpPort;`	373	`private String ajpPort;`
374		374
375	`/**`	375	`/**`
376	`* The max ajp threads`	376	`* The max ajp threads`
377	`*/`	377	`*/`
378	`private String ajpMaxThreads;`	378	`private String ajpMaxThreads;`
379		379
380	`/**`	380	`/**`
381	`* The min spare ajp threads`	381	`* The min spare ajp threads`
382	`*/`	382	`*/`
383	`private String ajpMinSpareThreads;`	383	`private String ajpMinSpareThreads;`
384		384
385	`/**`	385	`/**`
386	`* The enable ajp lookups property to configure`	386	`* The enable ajp lookups property to configure`
387	`*/`	387	`*/`
388	`private Boolean ajpEnableLookups;`	388	`private Boolean ajpEnableLookups;`
389		389
390	`/**`	390	`/**`
391	`* The ajp connection timeout`	391	`* The ajp connection timeout`
392	`*/`	392	`*/`
393	`private String ajpConnectionTimeout;`	393	`private String ajpConnectionTimeout;`
394		394
395	`/**`	395	`/**`
396	`* The ajp accept count`	396	`* The ajp accept count`
397	`*/`	397	`*/`
398	`private String ajpAcceptCount;`	398	`private String ajpAcceptCount;`
399		399
400	`/**`	400	`/**`
401	`* The ajp redirect port`	401	`* The ajp redirect port`
402	`*/`	402	`*/`
403	`private String ajpRedirectPort;`	403	`private String ajpRedirectPort;`
404		404
405	`/**`	405	`/**`
406	`* Max active web sessions`	406	`* Max active web sessions`
407	`*/`	407	`*/`
408	`private String maxActiveSession;`	408	`private String maxActiveSession;`
409		409
410	`/**`	410	`/**`
411	`* Database id`	411	`* Database id`
412	`*/`	412	`*/`
413	`private String dbId;`	413	`private String dbId;`
414		414
415	`/**`	415	`/**`
416	`* List of users`	416	`* List of users`
417	`*/`	417	`*/`
418	`List<User> users;`	418	`List<User> users;`
419		419
420	`/**`	420	`/**`
421	`* List of admins`	421	`* List of admins`
422	`*/`	422	`*/`
423	`List<User> admins;`	423	`List<User> admins;`
424		424
425	`/**`	425	`/**`
426	`* Wrapper Configurator api`	426	`* Wrapper Configurator api`
427	`*/`	427	`*/`
428	`JOnASWrapper wrapper;`	428	`JOnASWrapper wrapper;`
429		429
430	`/**`	430	`/**`
431	`* Derfault constructor`	431	`* Derfault constructor`
432	`*/`	432	`*/`
433	`public Jonas53() {`	433	`public Jonas53() {`
434	`this.createProject();`	434	`this.createProject();`
435	`this.jonasBase = new JOnASBaseTask();`	435	`this.jonasBase = new JOnASBaseTask();`
436	`this.jonasBase.setProject(this.project);`	436	`this.jonasBase.setProject(this.project);`
437	`this.jonasBase.setSkipDeployablesTemplateCopy(false);`	-
-		437	`this.jonasBase.setSkipOptionalDeployablesCopy(true);`
438		438
439	`this.jonasProperties = new JonasProperties();`	439	`this.jonasProperties = new JonasProperties();`
440	`this.jonasProperties.setProject(this.project);`	440	`this.jonasProperties.setProject(this.project);`
441		441
442	`this.services = new Services();`	442	`this.services = new Services();`
443	`this.services.setProject(this.project);`	443	`this.services.setProject(this.project);`
444		444
445	`this.carol = new Carol();`	445	`this.carol = new Carol();`
446	`this.carol.setProject(this.project);`	446	`this.carol.setProject(this.project);`
447		447
448	`this.security = new Jaas();`	448	`this.security = new Jaas();`
449	`this.security.setProject(this.project);`	449	`this.security.setProject(this.project);`
450		450
451	`this.jdbcXmlList = new ArrayList<JdbcXml>();`	451	`this.jdbcXmlList = new ArrayList<JdbcXml>();`
452	`this.mails = new ArrayList<Mail>();`	452	`this.mails = new ArrayList<Mail>();`
453		453
454	`this.users = new ArrayList<User>();`	454	`this.users = new ArrayList<User>();`
455	`this.admins = new ArrayList<User>();`	455	`this.admins = new ArrayList<User>();`
456		456
457	`Jonas53.logger.finest("Created the JOnAS 5 configurator instance");`	457	`Jonas53.logger.finest("Created the JOnAS 5 configurator instance");`
458	`}`	458	`}`
459		459
460	`/**`	460	`/**`
461	`* Create the project`	461	`* Create the project`
462	`*/`	462	`*/`
463	`private void createProject() {`	463	`private void createProject() {`
464	`this.project = new Project();`	464	`this.project = new Project();`
465	`this.project.init();`	465	`this.project.init();`
466	`this.project.initProperties();`	466	`this.project.initProperties();`
467		467
468	`TimestampedLogger logger = new TimestampedLogger();`	468	`TimestampedLogger logger = new TimestampedLogger();`
469	`logger.setMessageOutputLevel(Project.MSG_DEBUG);`	469	`logger.setMessageOutputLevel(Project.MSG_DEBUG);`
470		470
471	`logger.setOutputPrintStream(new PrintStream(new OutputStream() {`	471	`logger.setOutputPrintStream(new PrintStream(new OutputStream() {`
472	`StringBuffer buf = new StringBuffer();`	472	`StringBuffer buf = new StringBuffer();`
473		473
474	`@Override`	474	`@Override`
475	`public void write(final int b) throws IOException {`	475	`public void write(final int b) throws IOException {`
476	`if (b == '\n' \|\| b == '\r') {`	476	`if (b == '\n' \|\| b == '\r') {`
477	`if (this.buf.length() > 0) {`	477	`if (this.buf.length() > 0) {`
478	`Jonas53.logger.finest(this.buf.toString());`	478	`Jonas53.logger.finest(this.buf.toString());`
479	`this.buf.setLength(0);`	479	`this.buf.setLength(0);`
480	`}`	480	`}`
481	`} else {`	481	`} else {`
482	`this.buf.append((char) b);`	482	`this.buf.append((char) b);`
483	`}`	483	`}`
484	`}`	484	`}`
485	`}));`	485	`}));`
486		486
487	`this.project.addBuildListener(logger);`	487	`this.project.addBuildListener(logger);`
488	`}`	488	`}`
489		489
490	`/* ------------------------------- */`	490	`/* ------------------------------- */`
491	`/* Jonas global parameters */`	491	`/* Jonas global parameters */`
492	`/**`	492	`/**`
493	`* {@inheritDoc}`	493	`* {@inheritDoc}`
494	`*/`	494	`*/`
495	`public void setJdk(final String jdk) {`	495	`public void setJdk(final String jdk) {`
496	`Jonas53.logger.finest("[GlobalParameters] setting jdk : " + jdk);`	496	`Jonas53.logger.finest("[GlobalParameters] setting jdk : " + jdk);`
497	`NotApplicableHelper.notApplicable("GlobalParameters.Jdk");`	497	`NotApplicableHelper.notApplicable("GlobalParameters.Jdk");`
498	`}`	498	`}`

jonas

(root)/sub-projects/configurator/trunk/impl/src/main/java/org/ow2/jonas/tools/configurator/impl/Jonas53.java - Rev 22396 → 22426