/*
   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
  */
  
  /*
   * Project: KernelConfigurator
   * Created on 05-oct-2004
   *
   * Copyright (c)2004 Grid Systems
   *
   * WARNING: SJM. The RedundantServerPlugin has a copy of this class to read the
   * data of the ports of the server. That copy needs to be updated when this
   * class suffers changes that do affect the serialization of the port list.
   * WARNING2: SJM. The VirtualNityaPlugin has also a copy of this class for the
   * same purposes.
   */
  package com.gridsystems.config.modules.tomcat;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.lang.reflect.Field;
  import java.lang.reflect.Modifier;
  import java.security.Security;
  import java.text.ParseException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
  
  /**
   * Type description.
   *
   * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
   * @version 1.0
   */
  public class Connector implements Cloneable {
  
    /**
     * HTTP protocol identifier.
     */
    public static final String HTTP = "http";
  
    /**
     * HTTPS protocol identifier.
     */
    public static final String HTTPS = "https";
  
    /**
     * Default accept count.
     */
    private static final int DEFAULT_ACCEPT_COUNT = 10;
  
    /**
     * Default buffer size.
     */
    private static final int DEFAULT_BUFFER_SIZE = 2048;
  
    /**
     * Default maximum number of processing threads.
     */
    private static final int DEFAULT_MAX_THREADS = 20;
  
    /**
     * Default minimum number of processing threads.
     */
    private static final int DEFAULT_MIN_THREADS = 5;
  
    /**
     * Default connection timeout.
     */
    private static final long DEFAULT_TIMEOUT = 60000;
  
    /**
     * Algorithm used for keystores and keys.
     */
    private static final String ALGORITHM;
  
    /**
     * Default value for the clientAuth attribute.
     */
    private static final String DEFAULT_CLIENT_AUTH = "false";
 
   static {
     String[] preferred = {
       "SunX509", "IbmX509"
     };
     // The first algorithm is the default if none is found
     String alg = preferred[0];
 
     Set available = Security.getAlgorithms("TrustManagerFactory");
     for (int i = 0; i < preferred.length; i++) {
       for (Iterator it = available.iterator(); it.hasNext();) {
         String s = it.next().toString();
         if (s.equalsIgnoreCase(preferred[i])) {
           alg = preferred[i];
           break;
         }
       }
     }
     ALGORITHM = alg;
   };
 
   /**
    * Connector name, for screen display.
    * <p>
    * This field has no default value, so it MUST be declared at construction time.
    */
   private String name;
 
   /**
    * Set to <code>true</code> if you want calls to request.getRemoteHost() to perform
    * DNS lookups in order to return the actual host name of the remote client.
    * <p>
    * Set to <code>false</code> to skip the DNS lookup and return the IP address in
    * String form instead (thereby improving performance).
    * <p>
    * By default, DNS lookups are disabled.
    */
   private boolean enableLookups = false;
 
   /**
    * Flag controlling whether protocol use SSL.
    */
   private boolean secure = false;
 
   /**
    * Protocol: HTTP,HTTPS, FTP, ...
    */
   private String protocol = null;
 
   /**
    * The maximum queue length for incoming connection requests when all possible
    * request processing threads are in use. Any requests received when the queue is
    * full will be refused. The default value is 10.
    */
   private int acceptCount = DEFAULT_ACCEPT_COUNT;
 
   /**
    * The IP address this connector will be bound to.
    * <p>
    * By default, the connector will bind to all host public addresses.
    */
   private String address = null;
 
   /**
    * The size (in bytes) of the buffer to be provided for input streams created by
    * this connector. By default, buffers of 2048 bytes will be provided.
    */
   private int bufferSize = DEFAULT_BUFFER_SIZE;
 
   /**
    * The Connector may use <code>HTTP/1.1 GZIP</code> compression in an attempt to
    * save server bandwidth. The acceptable values for the parameter are:
    *
    * <ul>
    *   <li> <code>off</code> : disable compression,
    *   <li> <code>on</code> : allow compression, which causes text data to be compressed,
    *   <li> <code>force</code> : forces compression in all cases,
    *   <li> a numerical integer value : which is equivalent to "on", but specifies the
    *        minimum amount of data before the output is compressed.
    * </ul>
    *
    * If the content-length is not known and compression is set to "on" or more aggressive,
    * the output will also be compressed.
    * <p>
    * If not specified, this attribute is set to "off".
    */
   private String compression = "off";
 
   /**
    * The number of milliseconds during which the sockets used by this Connector will
    * linger when they are closed.
    * <p>
    * The default value is -1 (socket linger is disabled).
    */
   private int connectionLinger = -1;
 
   /**
    * The number of milliseconds this Connector will wait, after accepting a connection,
    * for the request URI line to be presented.
    * <p>
    * The default value is 60000 (i.e. 60 seconds).
    */
   private long connectionTimeout = DEFAULT_TIMEOUT;
 
   /**
    * The maximum number of request processing threads to be created by this Connector,
    * which therefore determines the maximum number of simultaneous requests that can be
    * handled.
    * <p>
    * If not specified, this attribute is set to 20.
    */
   private int maxProcessors = DEFAULT_MAX_THREADS;
 
   /**
    * The number of request processing threads that will be created when this Connector
    * is first started. This attribute should be set to a value smaller than that set for
    * maxProcessors.
    * <p>
    * The default value is 5.
    */
   private int minProcessors = DEFAULT_MIN_THREADS;
 
   /**
    * Port number.
    * <p>
    * This field has no default value, so it MUST be declared at construction time.
    */
   private int port;
 
   /**
    * Flag controlling whether a connector has been created by a user, or by a plugin.
    */
   private boolean userCreated = true;
 
   /**
    * clientAuth attribute.
    */
   private String clientAuth = DEFAULT_CLIENT_AUTH;
 
   /**
    * Hidden constructor.
    */
   private Connector() { }
 
   /**
    * Creates a new instance.
    *
    * @param name  the connector display name
    * @param port  the connector port
    * @param protocol The protocol.
    */
   public Connector(String name, int port, String protocol) {
     this.name = name;
     this.port = port;
     this.protocol = protocol;
   }
 
   /**
    * Gets the acceptCount value.
    *
    * @return The acceptCount
    */
   public int getAcceptCount() {
     return this.acceptCount;
   }
 
   /**
    * Sets the acceptCount value.
    *
    * @param acceptCount The acceptCount to set
    */
   public void setAcceptCount(int acceptCount) {
     this.acceptCount = acceptCount;
   }
 
   /**
    * Gets the address value.
    *
    * @return The address
    */
   public String getAddress() {
     return this.address;
   }
 
   /**
    * Sets the address value.
    *
    * @param address The address to set
    */
   public void setAddress(String address) {
     this.address = address;
   }
 
   /**
    * Gets the bufferSize value.
    *
    * @return The bufferSize
    */
   public int getBufferSize() {
     return this.bufferSize;
   }
 
   /**
    * Sets the bufferSize value.
    *
    * @param bufferSize The bufferSize to set
    */
   public void setBufferSize(int bufferSize) {
     this.bufferSize = bufferSize;
   }
 
   /**
    * Gets the clientAuth value.
    *
    * @return The attribute value
    */
   public String getClientAuth() {
     return this.clientAuth;
   }
 
   /**
    * Sets the clientAuth value.
    *
    * @param clientAuth The attribute value. Valid values are (false, true, want)
    */
   public void setClientAuth(String clientAuth) {
     this.clientAuth = (clientAuth == null) ? DEFAULT_CLIENT_AUTH : clientAuth;
   }
 
   /**
    * Gets the compression value.
    *
    * @return The compression
    */
   public String getCompression() {
     return this.compression;
   }
 
   /**
    * Sets the compression value.
    *
    * @param compression The compression to set
    */
   public void setCompression(String compression) {
     this.compression = compression;
   }
 
   /**
    * Gets the connectionLinger value.
    *
    * @return The connectionLinger
    */
   public int getConnectionLinger() {
     return this.connectionLinger;
   }
 
   /**
    * Sets the connectionLinger value.
    *
    * @param connectionLinger The connectionLinger to set
    */
   public void setConnectionLinger(int connectionLinger) {
     this.connectionLinger = connectionLinger;
   }
 
   /**
    * Gets the connectionTimeout value.
    *
    * @return The connectionTimeout
    */
   public long getConnectionTimeout() {
     return this.connectionTimeout;
   }
 
   /**
    * Sets the connectionTimeout value.
    *
    * @param connectionTimeout The connectionTimeout to set
    */
   public void setConnectionTimeout(long connectionTimeout) {
     this.connectionTimeout = connectionTimeout;
   }
 
   /**
    * Gets the enableLookups value.
    *
    * @return The enableLookups
    */
   public boolean isEnableLookups() {
     return this.enableLookups;
   }
 
   /**
    * Sets the enableLookups value.
    *
    * @param enableLookups The enableLookups to set
    */
   public void setEnableLookups(boolean enableLookups) {
     this.enableLookups = enableLookups;
   }
 
   /**
    * Gets the maxProcessors value.
    *
    * @return The maxProcessors
    */
   public int getMaxProcessors() {
     return this.maxProcessors;
   }
 
   /**
    * Sets the maxProcessors value.
    *
    * @param maxProcessors The maxProcessors to set
    */
   public void setMaxProcessors(int maxProcessors) {
     this.maxProcessors = maxProcessors;
   }
 
   /**
    * Gets the minProcessors value.
    *
    * @return The minProcessors
    */
   public int getMinProcessors() {
     return this.minProcessors;
   }
 
   /**
    * Sets the minProcessors value.
    *
    * @param minProcessors The minProcessors to set
    */
   public void setMinProcessors(int minProcessors) {
     this.minProcessors = minProcessors;
   }
 
   /**
    * Gets the name value.
    *
    * @return The name
    */
   public String getName() {
     return this.name;
   }
 
   /**
    * Sets the name value.
    *
    * @param name The name to set
    */
   public void setName(String name) {
     this.name = name;
   }
 
   /**
    * Gets the port value.
    *
    * @return The port
    */
   public int getPort() {
     return this.port;
   }
 
   /**
    * Sets the port value.
    *
    * @param port The port to set
    */
   public void setPort(int port) {
     this.port = port;
   }
 
   /**
    * Gets the userCreated value.
    *
    * @return The userCreated
    */
   public boolean isUserCreated() {
     return this.userCreated;
   }
 
   /**
    * Sets the userCreated value.
    *
    * @param userCreated The userCreated to set
    */
   public void setUserCreated(boolean userCreated) {
     this.userCreated = userCreated;
   }
 
   /**
    * Gets the name of the protocol to have returned by calls to request.getScheme().
    * <p>
    * It can be "http" or "https", depending on the <code>secure</code> flag value.
    *
    * @return The connector scheme.
    */
   public String getScheme() {
     return getProtocol();
   }
 
   /**
    * {@inheritDoc}
    *
    * WARNING: SJM. The RedundantServerPlugin has a copy of this class to read
    * the data of the ports of the server. That copy needs to be updated when
    * this class suffers changes that do affect the serialization of the port
    * list.
    */
   public String toString() {
     getProtocol();
     StringBuffer sb = new StringBuffer("Connector { ");
     try {
       Field[] fields = this.getClass().getDeclaredFields();
       boolean first = true;
       for (int i = 0; i < fields.length; i++) {
         if (fields[i].getName().equals("secure")) {
           continue;
         }
         if (!Modifier.isStatic(fields[i].getModifiers())) {
           if (!first) {
             sb.append("; ");
           } else {
             first = false;
           }
           sb.append(fields[i].getName()).append(":").append(fields[i].get(this));
         }
       }
     } catch (Exception e) {
       e.printStackTrace();
     }
     sb.append(" }");
     return sb.toString();
   }
 
   /**
    * Type-safe version of clone().
    *
    * @return  a copy of this instance
    */
   public Connector copy() {
     try {
       return (Connector)clone();
     } catch (Exception e) {
       return null;
     }
   }
   /**
    * Gets an XML fragment for insertion into a Tomcat server.xml file.
    *
    * WARNING: SJM. The RedundantServerPlugin has a copy of this class to read
    * the data of the ports of the server. That copy needs to be updated when
    * this class suffers changes that do affect the serialization of the port
    * list.
    *
    * @param keystore  the path to the keystore (for SSL connectors)
    * @param password  the keystore password (for SSL connectors)
    * @param truststore  the path to the truststore (optional, for SSL connectors)
    * @param trustpass  the truststore password (optional, for SSL connectors)
    * @return  a string with the XML representation of this object
    */
   public String toXML(String keystore, String password, String truststore,
     String trustpass) {
 
     if (!HTTP.equals(getProtocol()) && !HTTPS.equals(getProtocol())) {
       return "";
     }
     String nl = System.getProperty("line.separator");
 
     StringBuffer sb = new StringBuffer();
     sb.append("<Connector");
     sb.append(" acceptCount='").append(this.acceptCount);
     sb.append("' bufferSize='").append(this.bufferSize);
     if (this.address != null && this.address.length() > 0) {
       sb.append("' address='").append(this.address);
     }
     if (this.compression != null && this.compression.length() > 0) {
       sb.append("' compression='").append(this.compression);
     }
     sb.append("' connectionLinger='").append(this.connectionLinger);
     sb.append("' connectionTimeout='").append(this.connectionTimeout);
     sb.append("' enableLookups='").append(this.enableLookups);
     sb.append("' maxProcessors='").append(this.maxProcessors);
     sb.append("' minProcessors='").append(this.minProcessors);
     sb.append("' port='").append(this.port);
     sb.append("' scheme='").append(this.getProtocol());
     sb.append("' secure='").append(HTTPS.equals(this.getProtocol()));
     sb.append("' useURIValidationHack='false' debug='0");
     sb.append("' disableUploadTimeout='false' tcpNoDelay='true");
     if (HTTPS.equals(getProtocol())) {
       sb.append("' sslProtocol='TLS");
       sb.append("' clientAuth='").append(clientAuth);
       sb.append("' algorithm='").append(ALGORITHM);
       sb.append("' keystoreFile='").append(keystore);
       sb.append("' keystorePass='").append(password);
       if (truststore != null && trustpass != null) {
         sb.append("' truststoreFile='").append(truststore);
         sb.append("' truststorePass='").append(trustpass);
       }
     }
     sb.append("' />").append(nl).append(nl);
 
     return sb.toString();
   }
 
   /**
    * Converts a list of connectors into an XML string.
    *
    * WARNING: SJM. The RedundantServerPlugin has a copy of this class to read
    * the data of the ports of the server. That copy needs to be updated when
    * this class suffers changes that do affect the serialization of the port
    * list.
    *
    * @param conns     the list of connectors
    * @param keystore  the keystore path
    * @param password  the keystore password
    * @param trustStore the trust store
    * @param trustPaswd the trust store password
    * @return  the xml for a Tomcat server.xml configuration file
    */
   public static String toXML(List conns, String keystore, String password,
       String trustStore, String trustPaswd) {
     // Merges all connectors with the same port
     HashMap<String, Connector> map = new HashMap<String, Connector>();
     for (Iterator it = conns.iterator(); it.hasNext();) {
       Connector c = (Connector)it.next();
       String addr = c.getAddress() + ":" + c.getPort();
       Connector cc = (Connector)map.get(addr);
       if (cc != null) {
         c = merge(cc, c);
       }
       map.put(addr, c);
     }
 
     StringBuffer sb = new StringBuffer();
     for (Iterator it = map.values().iterator(); it.hasNext();) {
       Connector c = (Connector)it.next();
       sb.append(c.toXML(keystore, password, trustStore, trustPaswd));
     }
     return sb.toString();
   }
 
   /**
    * Merges two instances in a new one.
    * <p>
    * The created instance will have its attributes set to appropriate values for serving
    * both Connectors.
    *
    * @param c1  The first connector
    * @param c2  The second connector
    * @return  A connector with merged attributes
    */
   public static Connector merge(Connector c1, Connector c2) {
     Connector c = new Connector();
     c.setName("Merged connector");
     c.setPort(c1.getPort());
     c.setAcceptCount(c1.getAcceptCount() + c2.getAcceptCount());
     c.setAddress(c1.getAddress());
     c.setBufferSize(Math.max(c1.getBufferSize(), c2.getBufferSize()));
     c.setCompression(minCompression(c1.getCompression(), c2.getCompression()));
     int maxLinger = Math.max(c1.getConnectionLinger(), c2.getConnectionLinger());
     c.setConnectionLinger(maxLinger);
     long maxTimeout = Math.max(c1.getConnectionTimeout(), c2.getConnectionTimeout());
     c.setConnectionTimeout(maxTimeout);
     c.setEnableLookups(c1.isEnableLookups() || c2.isEnableLookups());
     c.setMaxProcessors(c1.getMaxProcessors() + c2.getMaxProcessors());
     c.setMinProcessors(c1.getMinProcessors() + c2.getMinProcessors());
     c.setProtocol(c1.getProtocol());
     return c;
   }
 
   /**
    * Gets the minimum compression level of the specified ones.
    *
    * @param c1  the first compression level to compare
    * @param c2  the second compression level to compare
    * @return  the minimum level between c1 and c2, or "off", if c1 and c2 are not valid
    */
   private static String minCompression(String c1, String c2) {
     if (c1 == c2) {
       return c1;
     } else if (c1 == null || c2 == null) {
       return "off";
     } else {
       String combo = c1 + " " + c2;
       String[] levels = { "off", "on", "force" };
       for (int i = 0; i < levels.length; i++) {
         if (combo.indexOf(levels[i]) != -1) {
           return levels[i];
         }
       }
       return "off";
     }
   }
 
   /**
    * Factory method that creates a Connector instance by parsing the specified string.
    *
    * WARNING: SJM. The RedundantServerPlugin has a copy of this class to read
    * the data of the ports of the server. That copy needs to be updated when
    * this class suffers changes that do affect the serialization of the port
    * list.
    *
    * @param s  the string to parse
    * @return   a Connector instance
    * @throws ParseException if a syntax error is detected
    */
   public static Connector fromString(String s) throws ParseException {
     if (s.matches("^Connector \\{ .+ \\}$")) {
       Connector c = new Connector();
       // Strips leading and trailling characters
       String ss = s.substring("Connector { ".length(), s.length() - 2);
       String[] sfields = ss.split(";");
       Class cl = Connector.class;
       for (int i = 0; i < sfields.length; i++) {
         String[] pair = sfields[i].split(":");
         try {
           Field f = cl.getDeclaredField(pair[0].trim());
           setValue(c, f, pair[1].trim());
         } catch (NoSuchFieldException e) {
           throw new ParseException(sfields[i], 0);
         }
       }
       return c;
     } else {
       throw new ParseException(s, 0);
     }
   }
 
   /**
    * Reads a list of Connector instance from a text file, and returns it into an
    * ArrayList instance.
    *
    * @param f  the file to read from
    * @return   the list
    * @throws IOException If a read error occurs
    * @throws ParseException If a syntax error occurs
    */
   public static List<Connector> loadFromFile(File f) throws IOException, ParseException {
     ArrayList<Connector> list = new ArrayList<Connector>();
 
     BufferedReader reader = null;
     try {
       reader = new BufferedReader(new FileReader(f));
       String line = reader.readLine();
       while (line != null) {
         line = line.trim();
         if (!line.startsWith("#")) {
           try {
             list.add(fromString(line));
           } catch (Exception skipLine) { }
         }
         line = reader.readLine();
       }
     } finally {
       try {
         if (reader != null) {
           reader.close();
         }
       } catch (Exception ignore) { }
     }
 
     return list;
   }
 
   /**
    * Saves to a text file the list of connectors.
    *
    * @param f     the destination file
    * @param list  the list of connectors
    * @throws IOException If a write error occurs
    * @throws ClassCastException If an element of the list is not a Connector instance
    */
   public static void saveToFile(File f, List list) throws IOException {
     PrintWriter writer = null;
     try {
       writer = new PrintWriter(new FileWriter(f), false);
 
       if (list != null) {
         for (Iterator it = list.iterator(); it.hasNext();) {
           Connector c = (Connector)it.next();
           writer.println(c.toString());
         }
       }
     } finally {
       try {
         if (writer != null) {
           writer.flush();
           writer.close();
         }
       } catch (Exception ignore) { }
     }
   }
 
   /**
    * Helper method for setting the value of an internal field through reflection.
    *
    * @param target   the instance whose field must be set
    * @param f        the field
    * @param value    the field value
    */
   private static void setValue(Object target, Field f, String value) {
     try {
       if (value.equals("null")) {
         f.set(target, null);
       } else {
         Class type = f.getType();
 
         if (String.class.isAssignableFrom(type)) {
           f.set(target, value);
         } else if (Boolean.TYPE.isAssignableFrom(type)) {
           f.setBoolean(target, "true".equals(value));
         } else if (Integer.TYPE.isAssignableFrom(type)) {
           f.setInt(target, Integer.parseInt(value));
         } else if (Long.TYPE.isAssignableFrom(type)) {
           f.setLong(target, Long.parseLong(value));
         }
       }
     } catch (IllegalAccessException e) {
       // This cannot happen, because only fields of this class are set
     }
   }
 
   /**
    * @return Returns the protocol.
    */
   public String getProtocol() {
     if (protocol == null) {
       if (secure) {
         protocol = Connector.HTTPS;
       } else {
         protocol = Connector.HTTP;
       }
     }
     return protocol;
   }
 
   /**
    * @param protocol The protocol to set.
    */
   public void setProtocol(String protocol) {
     this.protocol = protocol;
     getProtocol();
   }
 
   /**
    * List of available protocols.
    */
   private static ArrayList<String> availableProtocols = new ArrayList<String>();
 
   static {
     availableProtocols.add(HTTP);
     availableProtocols.add(HTTPS);
   }
 
   /**
    * Add to list of available protocols a new protocol.
    * @param  protocol New protocol to add.
    */
   public static void addNewProtocol(String protocol) {
     availableProtocols.add(protocol.toLowerCase());
   }
 
   /**
    * Return list of available protocols.
    * @return List of available protocols.
    */
   public static String[] getAvailableProtocols() {
     return availableProtocols.toArray(new String[availableProtocols.size()]);
   }
 }