/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   This program 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 General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  package com.gridsystems.config.modules.tomcat;
  
  import java.io.File;
  import java.io.IOException;
  import java.text.MessageFormat;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Properties;
  import java.util.ResourceBundle;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import com.gridsystems.config.ConfiguratorModel;
  import com.gridsystems.config.modules.jvm.JVMConfigurator;
  import com.gridsystems.config.tools.IpVerifier;
  import com.gridsystems.config.tools.Template;
  import com.gridsystems.utils.NetUtils;
  
  /**
   * Data model for the Tomcat configurator.
   *
   * @author Rodrigo Ruiz
   * @author Xmas
   * @version 1.0
   */
  public class TomcatConfigModel implements ConfiguratorModel {
  
    /**
     * Allowed type of the IPs.
     */
    protected static final int ALLOWED_IP_TYPE = IpVerifier.IP_4_IP_6;
  
    /**
     * Property key name for the IP Address field.
     */
    public static final String HOST_IP = "host.ip";
  
    /**
     * Default shutdown port.
     */
    public static final int DEFAULT_SHUTDOWN_PORT = 9114;
  
    /**
     * Default HTTP port.
     */
    public static final int DEFAULT_HTTP_PORT = 9112;
  
    /**
     * Default HTTPS port.
     */
    public static final int DEFAULT_HTTPS_PORT = 9116;
  
    /**
     * Default server restart exit code.
     */
    public static final int DEFAULT_RESTART_CODE = 0;
  
    /**
     * Default server shutdown exit code.
     */
    public static final int DEFAULT_SHUTDOWN_CODE = 1;
  
    /**
     * Default server restart enabled flag.
     */
    public static final boolean DEFAULT_RESTART_ENABLED = false;
  
    /**
     * Default HTTPS enabled flag.
     */
    public static final boolean DEFAULT_HTTPS_ENABLED = false;
  
    /**
     * Default keystore directory.
     */
    public static final String DEFAULT_KEYSTORE_DIR = "../conf/security";
  
    /**
     * Default keystore password.
    */
   public static final String DEFAULT_KEYSTORE_PASS = "changeit2";
 
   /**
    * Class logger.
    */
   private static Log log = LogFactory.getLog("TomcatConfigModel");
 
   /** Customizer bundle. */
   private static ResourceBundle customizerBundle
     = ResourceBundle.getBundle("ServerConfiguratorCustomizer");
 
   /**
    * Gets the name of the product to Install.
    * @return Name of the product to Install.
    */
   public static String getProductName() {
     return getCustomizerString("Configurator.ProductName");
   }
 
   /**
    * Gets customizer string value from key.
    * @param key Key of String.
    * @return Value of customizer
    */
   public static String getCustomizerString(String key) {
     return customizerBundle.getString(key);
   }
 
   /**
    * The IP address field value.
    */
   private String ip = null;
 
   /**
    * Shutdown port.
    */
   private int fShutdownPort = DEFAULT_SHUTDOWN_PORT;
 
   /**
    * Server restart enabled flag.
    */
   private boolean fRestartEnabled = DEFAULT_RESTART_ENABLED;
 
   /**
    * Server restart exit code.
    */
   private int fRestartExitCode = DEFAULT_RESTART_CODE;
 
   /**
    * Server shutdown exit code.
    */
   private int fShutdownExitCode = DEFAULT_SHUTDOWN_CODE;
 
   /**
    * Keystore directory.
    */
   private File fKeystoreDir;
 
   /**
    * Keystore password.
    */
   private String fKeystorePass;
 
   /**
    * Previous keystore password.
    */
   private String fOldPassword;
 
   /**
    * Truststore password.
    */
   private String fTruststorePass;
 
   /**
    * Tomcat connector list.
    */
   private List<Connector> connectors = new ArrayList<Connector>();
 
   /**
    * Default constructor.
    */
   public TomcatConfigModel() { }
 
   /**
    * Creates a new instance.
    *
    * @param m The new model from which the old keystore password
    *                      must be taken
    */
   public TomcatConfigModel(TomcatConfigModel m) {
     if (m != null) {
       this.connectors = m.connectors;
       this.fKeystoreDir = m.fKeystoreDir;
       this.fKeystorePass = m.fKeystorePass;
       this.fOldPassword = m.fOldPassword;
       this.fRestartEnabled = m.fRestartEnabled;
       this.fRestartExitCode = m.fRestartExitCode;
       this.fShutdownExitCode = m.fShutdownExitCode;
       this.fShutdownPort = m.fShutdownPort;
       this.fTruststorePass = m.fTruststorePass;
       this.ip = m.ip;
     }
   }
 
   /**
    * Gets the canonical path to the keystore directory.
    *
    * @return The canonical path to the keystore directory.
    */
   protected String getKeystorePath() {
     try {
       return fKeystoreDir.getCanonicalPath().replace('\\', '/');
     } catch (IOException e) {
       return fKeystoreDir.getAbsolutePath().replace('\\', '/');
     }
   }
 
   /**
    * @see ConfiguratorModel#load()
    */
   public void load() {
     JVMConfigurator jvmc = JVMConfigurator.getInstance();
     // IP
     if (this.ip == null || this.ip.length() == 0) {
       this.ip = jvmc.getProperty(HOST_IP, null);
       if (this.ip == null || this.ip.length() == 0) {
         this.ip = NetUtils.getMachineIP();
       }
     }
     // Other properties
     fShutdownPort = jvmc.getIntProperty("tomcat.shutdown.port", DEFAULT_SHUTDOWN_PORT);
     fRestartEnabled = jvmc.getBoolProperty("restart.enabled", DEFAULT_RESTART_ENABLED);
     fRestartExitCode = jvmc.getIntProperty("exitcode.restart", DEFAULT_RESTART_CODE);
     fShutdownExitCode = jvmc.getIntProperty("exitcode.shutdown", DEFAULT_SHUTDOWN_CODE);
 
     String path = jvmc.getProperty("keystore.dir", DEFAULT_KEYSTORE_DIR);
     fKeystoreDir = new File(path);
 
     fKeystorePass = jvmc.getProperty("keystore.password", null);
     if (fKeystorePass == null) {
       fKeystorePass = DEFAULT_KEYSTORE_PASS;
       fOldPassword = "changeit";
     } else {
       fOldPassword = fKeystorePass;
     }
 
     fTruststorePass = jvmc.getProperty("truststore.password", null);
     if (fTruststorePass == null) {
       fTruststorePass = fKeystorePass;
     }
 
     File f = new File("../conf/connectors.conf");
     if (f.isFile()) {
       try {
         connectors = Connector.loadFromFile(f);
       } catch (Exception e) {
         log.error("Error parsing the connector list", e);
       }
     }
     fixConnectors();
   }
 
   /**
    * {@inheritDoc}
    */
   public void store() throws IOException {
     File f = new File("../conf/connectors.conf");
     Connector.saveToFile(f, connectors);
   }
 
   /**
    * {@inheritDoc}
    */
   public void apply() throws IOException {
     // General Error
     if (this.connectors.size() == 0) {
       ResourceBundle bundle;
       bundle = ResourceBundle.getBundle(TomcatConfigurator.BUNDLE);
       throw new IOException(bundle.getString("errors.general"));
     }
     Properties props = new Properties();
     props.setProperty(HOST_IP, this.ip);
     props.setProperty("http.port", Integer.toString(getHttpPort()));
     props.setProperty("shutdown.port", Integer.toString(fShutdownPort));
     props.setProperty("restart.enabled", fRestartEnabled ? "true" : "false");
     props.setProperty("restart.exitcode", Integer.toString(fRestartExitCode));
     props.setProperty("shutdown.exitcode", Integer.toString(fShutdownExitCode));
 
     // SSL support
     String keystore = getKeystorePath() + "/keystore";
     String password = fKeystorePass;
     String truststore = getKeystorePath() + "/cacerts";
     String trustpass = fTruststorePass;
 
     // Check that truststore does exist
     File f = new File(truststore);
     if (!f.exists()) {
       truststore = null;
       trustpass = null;
     }
     String xml = Connector.toXML(connectors, keystore, password, truststore, trustpass);
 
     props.setProperty("connectors", xml);
 
     // server.xml configuration file
     applyTemplate(props, "../conf/template_server.xml", "template_server.xml",
                          "../conf/server.xml");
 
     // kernel startup/shutdown script
     String ext = (File.separatorChar == '\\') ? ".bat" : ".sh";
     String src = "template_kernel" + (fRestartEnabled ? "HA" : "") + ext;
     String dst = "kernel" + ext;
 
     applyTemplate(props, src, src, dst);
 
     // Set a properties to apply to template_ServerHA.cfg
     Connector maidenPort = getMaidenPort();
     Properties serverHaProperties = new Properties();
     serverHaProperties.put(
       "server.maiden.port.number", Integer.toString(maidenPort.getPort()));
     serverHaProperties.put(
       "server.maiden.port.protocol", maidenPort.getProtocol());
     applyTemplate(serverHaProperties, "template_ServerHA.cfg",
       "template_ServerHA.cfg", "ServerHA.cfg");
 
     // Keystore creation
     if (isHttpsEnabled()) {
       Properties p = new Properties();
       p.setProperty("keystore.pass", fKeystorePass);
       p.setProperty("keystore.oldPass", fOldPassword);
       KeystoreUtils.createKeystores(fKeystoreDir, p);
     }
 
     applyJVMConfiguration(maidenPort);
 
     // The current password has changed
     fOldPassword = fKeystorePass;
   }
 
   /**
    * Applies the configuration for the Java Virtual Machine.
    * @param maidenPort the Maiden port
    */
   private void applyJVMConfiguration(Connector maidenPort) {
     // Changes to the JVM configurator are done AFTER keystore manipulation, to
     // avoid inconsistencies in case of errors
     JVMConfigurator jvmc = JVMConfigurator.getInstance();
     jvmc.setProperty(
       "server.maiden.port.number", Integer.toString(maidenPort.getPort()));
     jvmc.setProperty(
       "server.maiden.port.protocol", maidenPort.getProtocol());
     jvmc.setProperty("tomcat.shutdown.port", Integer.toString(fShutdownPort));
     jvmc.setProperty("restart.enabled", fRestartEnabled ? "true" : "false");
     jvmc.setProperty("restart.exitcode", Integer.toString(fRestartExitCode));
     jvmc.setProperty("shutdown.exitcode", Integer.toString(fShutdownExitCode));
 
     jvmc.setProperty("keystore.dir", getKeystorePath());
     jvmc.setProperty("keystore.password", fKeystorePass);
     jvmc.setProperty("truststore.password", fTruststorePass);
     jvmc.setProperty(HOST_IP, this.ip);
 
     //File cacerts = new File(fKeystoreDir, "cacerts");
     //jvmc.setProperty("javax.net.ssl.trustStore", cacerts.getAbsolutePath());
     //jvmc.setProperty("javax.net.ssl.trustStorePassword", fTruststorePass);
     jvmc.setProperty("java.awt.headless", "true");
 
     // Switch off the logs for Skaringa (this is, for Commons-Logging
     //jvmc.setProperty("org.apache.commons.logging.Log",
     //                 "org.apache.commons.logging.impl.SimpleLog");
     //jvmc.setProperty("org.apache.commons.logging.simplelog.defaultlog", "fatal");
   }
 
   /**
    * Gets a template as a resource located at <code>res</code>, with
    * working copy at <code>src</code>, and writes it at <code>dest</code>
    * replacing the values specified at <code>props</code>.
    *
    * @param props The values to replace in the template
    * @param src   The file where the template is located
    * @param res   The resource path to use if src does not exist
    * @param dest  The destination file
    */
   private void applyTemplate(Properties props, String src, String res, String dest) {
     try {
       Template t;
       t = new Template(new File(src), this.getClass().getResource(res));
       t.writeTo(props, new File(dest));
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
 
   /**
    * Gets the IP address of the host.
    *
    * @return a String with the IP address of the host.
    */
   public String getIp() {
     return this.ip;
   }
 
   /**
    * Sets the IP address of the host.
    *
    * @param ip a String with the IP address of the host.
    */
   public void setIp(String ip) {
     this.ip = ip;
   }
 
   /**
    * Gets the HTTP port.
    *
    * @return The HTTP port
    */
   public int getHttpPort() {
     for (Iterator it = connectors.iterator(); it.hasNext();) {
       Connector c = (Connector) it.next();
       if ("Default HTTP".equals(c.getName())) {
         return c.getPort();
       }
     }
 
     // Default HTTP connector not found!?
     return ((Connector)connectors.get(0)).getPort();
   }
 
   /**
    * Gets the shutdown port.
    *
    * @return The shutdown port
    */
   public int getShutdownPort() {
     return fShutdownPort;
   }
 
   /**
    * Gets the HTTPS port.
    *
    * @return The HTTPS port
    */
   public int getHttpsPort() {
     for (Iterator it = connectors.iterator(); it.hasNext();) {
       Connector c = (Connector) it.next();
       if ("Default HTTPS".equals(c.getName())) {
         return c.getPort();
       }
     }
     return 0;
   }
 
   /**
    * Gets the port to be used by the Server Maiden.
    *
    * Gets the port to be used by the Server Maiden. It will try to return, by
    * priority:<ol>
    * <li>The "DefaultHTTP" port.</li>
    * <li>The "DefaultHTTPS" port.</li>
    * <li>Any other HTTP port.</li>
    * <li>Any other HTTPS port.</li>
    * </ol>
    *
    * @return the selected port.
    */
   public Connector getMaidenPort() {
     Connector returnValue = null;
     // Levels: 0 -> "Default HTTPS", 1 -> Unknown HTTP, 2-> Unknown HTTPS
     int level = Integer.MAX_VALUE;
     for (Iterator it = connectors.iterator(); it.hasNext();) {
       Connector c = (Connector) it.next();
       if ("DefaultHTTP".equals(c.getName())) {
         // This is the most important port.
         return c;
       }
       if ("DefaultHTTPS".equals(c.getName())) {
         returnValue = c;
         level = 0;
       } else {
         if (c.getProtocol().equalsIgnoreCase(Connector.HTTPS)) {
           // Unknown HTTPS Port. It does not sustitute any other.
           if (level > 2) {
             returnValue = c;
             level = 2;
           }
         } else {
           // Unknown HTTP Port. Only sustitutes Unknown HTTPS ports.
           if (level > 1) {
             returnValue = c;
             level = 1;
           }
         }
       }
     }
     return returnValue;
   }
   /**
    * Gets the "HTTPS enabled" flag value.
    *
    * @return The current "HTTPS enabled" flag value
    */
   public boolean isHttpsEnabled() {
     for (Iterator it = connectors.iterator(); it.hasNext();) {
       Connector c = (Connector) it.next();
       if (c.getProtocol().equalsIgnoreCase(Connector.HTTPS)) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Gets the "Restart enabled" flag value.
    *
    * @return The current "Restart enabled" flag value
    */
   public boolean isRestartEnabled() {
     return fRestartEnabled;
   }
 
   /**
    * Gets the restart exit code.
    *
    * @return The restart exit code
    */
   public int getRestartExitCode() {
     return fRestartExitCode;
   }
 
   /**
    * Gets the shutdown exit code.
    *
    * @return The shutdown exit code
    */
   public int getShutdownExitCode() {
     return fShutdownExitCode;
   }
 
   /**
    * Sets the port number for shutdown requests.
    *
    * @param port The port number
    */
   public void setShutdownPort(int port) {
     this.fShutdownPort = port;
   }
 
   /**
    * Sets the port for shutdown requests.
    *
    * @param s The port number. The default value is 8085.
    *          If s is not a valid number, the default value will be set.
    */
   public void setShutdownPort(String s) {
     try {
       fShutdownPort = Integer.parseInt(s);
     } catch (Exception e) {
       fShutdownPort = DEFAULT_SHUTDOWN_PORT;
     }
   }
 
   /**
    * Enables or disables the restart control.
    *
    * @param enabled Whether or not restart control must be enabled
    */
   public void setRestartEnabled(boolean enabled) {
     fRestartEnabled = enabled;
   }
 
   /**
    * Sets the exit code that will instruct the daemon to restart the server.
    *
    * @param exitCode the exit code for restarts
    */
   public void setRestartExitCode(int exitCode) {
     fRestartExitCode = exitCode;
   }
 
   /**
    * Sets the exit code that will instruct the daemon to not restart the server.
    *
    * @param exitCode The exit code for shutdowns
    */
   public void setShutdownExitCode(int exitCode) {
     fShutdownExitCode = exitCode;
   }
 
   /**
    * Gets the keystore directory.
    *
    * @return The keystore directory
    */
   public File getKeystoreDir() {
     return this.fKeystoreDir;
   }
 
   /**
    * Sets the keystore directory.
    *
    * @param dir The keystore directory
    */
   public void setKeystoreDir(File dir) {
     this.fKeystoreDir = dir;
   }
 
   /**
    * Gets the keystore password.
    *
    * @return The keystore password
    */
   public String getKeystorePassword() {
     return this.fKeystorePass;
   }
 
   /**
    * Sets the keystore password.
    *
    * @param pass The keystore password
    */
   public void setKeystorePassword(String pass) {
     this.fKeystorePass = pass;
   }
 
   /**
    * Gets the list of connectors.
    *
    * @return  the list of connectors
    */
   public Connector[] getConnectors() {
     Connector[] list = new Connector[connectors.size()];
     for (int i = 0; i < list.length; i++) {
       list[i] = ((Connector) connectors.get(i)).copy();
     }
     return list;
   }
 
   /**
    * Sets the list of connectors.
    *
    * @param cc the list of connectors
    * @throws Exception If a validation error occurs
    */
   public void setConnectors(Connector[] cc) throws Exception {
     validate(cc);
     connectors = Arrays.asList(cc);
     //fixConnectors();
   }
 
   /**
    * Adds a connector to the list.
    *
    * @param c  the connector
    */
   public void addConnector(Connector c) {
     connectors.add(0, c);
   }
 
   /**
    * Validate data of this Model.
    *
    * @param conns  the list of connectors to validate
    * @throws Exception In case of invalid data
    */
   public void validate(List conns) throws Exception {
     HashMap<String, Connector> map = new HashMap<String, Connector>();
     for (Iterator it = conns.iterator(); it.hasNext();) {
       Connector c = (Connector) it.next();
       check(map, c);
     }
   }
 
   /**
    * Validate data of this Model.
    *
    * @param conns  the list of connectors to validate
    * @throws Exception In case of invalid data
    */
   public void validate(Connector[] conns) throws Exception {
     HashMap<String, Connector> map = new HashMap<String, Connector>();
     for (int i = 0; i < conns.length; i++) {
       check(map, conns[i]);
     }
   }
 
   /**
    * Validate data of this Model.
    *
    * @throws Exception In case of invalid data
    */
   public void validate() throws Exception {
     if ((this.ip == null) || (this.ip.length() == 0)) {
       log.error("IP is empty! Maybe a configuration error has happened");
       ResourceBundle bundle = TomcatConfigurator.getInstance().getBundle();
       throw new IOException(bundle.getString("errors.empty.ip"));
     }
     if (IpVerifier.isLoopbackAddress(this.ip, ALLOWED_IP_TYPE)) {
       log.error("The IP is a loopback address! Maybe a configuration error has happened");
       ResourceBundle bundle = TomcatConfigurator.getInstance().getBundle();
       throw new IOException(bundle.getString("errors.loopback.ip"));
     }
     validate(connectors);
   }
 
   /**
    * Checks that the specified connector is compatible with the connectors
    * in the passed map. If it is compatible, it is added to the map.
    *
    * @param map   the map of compatible connectors
    * @param c     the connector to check
    * @throws Exception  if the connector is not compatible with those in map
    */
   private void check(HashMap<String, Connector> map, Connector c) throws Exception {
     if (c.getPort() == fShutdownPort) {
       throw new IncompatiblePortException(c);
     }
 
     String bindAddress = c.getAddress();
     String name;
     if (bindAddress == null || bindAddress.length() == 0) {
       // Global binding: All connectors in this port must use the same protocol
       for (Iterator it = map.values().iterator(); it.hasNext();) {
         Connector cc = (Connector) it.next();
         if (cc.getName().equals(c.getName())) {
           ResourceBundle bundle = TomcatConfigurator.getInstance().getBundle();
           String pattern = bundle.getString("errors.duplicatedPorts");
           Object[] params = new Object[] {c.getName()};
           throw new Exception(MessageFormat.format(pattern, params));
         }
         if (cc.getPort() == c.getPort()
           && !cc.getProtocol().equalsIgnoreCase(c.getProtocol())) {
           throw new IncompatiblePortException(cc);
         }
       }
       // Fix bind address for name construction
       name = "0.0.0.0:" + c.getPort();
     } else {
       name = bindAddress + ":" + c.getPort();
 
       // Specific binding: global or specific connector protocols must match
       Connector cc = (Connector) map.get("0.0.0.0:" + c.getPort());
       if (cc != null) {
         cc = (Connector) map.get(name);
       }
       if (cc != null && !cc.getProtocol().equalsIgnoreCase(c.getProtocol())) {
         throw new IncompatiblePortException(c);
       }
     }
 
     log.info("Checking port " + c.getPort());
     if (!NetUtils.checkPort(c.getPort())) {
       throw new PortInUseException(c);
     }
 
     // All ok, adds this connector to the set
     map.put(name, c);
   }
 
   /**
    * Ensures that there is at least one entry in the connectors list, and that entry
    * is the "Default HTTP" connector.
    */
   private void fixConnectors() {
     boolean hasDefault;
 
     if (connectors == null) {
       connectors = new ArrayList<Connector>();
       hasDefault = false;
     } else {
       if (connectors.size() == 0) {
         hasDefault = false;
       } else {
         hasDefault = false;
         int i = 0;
         while (!hasDefault && (i < connectors.size())) {
           Connector c = (Connector) connectors.get(i);
           if (("Default HTTP".equals(c.getName())
               && !c.getProtocol().equals(Connector.HTTPS))
             || ("Default HTTPS".equals(c.getName())
               && c.getProtocol().equals(Connector.HTTPS))) {
             hasDefault = true;
           }
           i++;
         }
       }
     }
 
     if (!hasDefault) {
       Connector def = new Connector("Default HTTP", DEFAULT_HTTP_PORT, Connector.HTTP);
       def.setUserCreated(false);
       connectors.add(0, def);
 
       Connector sdef;
       sdef = new Connector("Default HTTPS", DEFAULT_HTTPS_PORT, Connector.HTTPS);
       sdef.setUserCreated(false);
       connectors.add(1, sdef);
     }
   }
 
 
 
 }