* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

*

* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.

*

* The contents of this file are subject to the terms of either the GNU

* General Public License Version 2 only ("GPL") or the Common Development

* and Distribution License("CDDL") (collectively, the "License").  You

* may not use this file except in compliance with the License. You can obtain

* a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html

* or glassfish/bootstrap/legal/LICENSE.txt.  See the License for the specific

* language governing permissions and limitations under the License.

*

* When distributing the software, include this License Header Notice in each

* file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.

* Sun designates this particular file as subject to the "Classpath" exception

* as provided by Sun in the GPL Version 2 section of the License file that

* accompanied this code.  If applicable, add the following below the License

* Header, with the fields enclosed by brackets [] replaced by your own

* identifying information: "Portions Copyrighted [year]

* [name of copyright owner]"

*

* Contributor(s):

*

* If you wish your version of this file to be governed by only the CDDL or

* only the GPL Version 2, indicate your decision by adding "[Contributor]

* elects to include this software in this distribution under the [CDDL or GPL

* Version 2] license."  If you don't indicate a single choice of license, a

* recipient has the option to distribute your version of this file under

* either the CDDL, the GPL Version 2 or to extend the choice of license to

* its licensees as provided above.  However, if you add GPL Version 2 code

* and therefore, elected the GPL Version 2 license, then the option applies

* only if the new code is made subject to such option by the copyright

* holder.

*/

* Represents the web container for PE and EE (since 9.0)

*/

    implements MonitoringLevelListener {

    private PECoyoteConnector jkConnector;

    /**

     * Maps http-listener id to Tomcat Connector

     */

    private HashMap<String,PECoyoteConnector> connectorMap;

   

  

    /**

     * Allow disabling accessLog mechanism

     */

    private boolean globalAccessLoggingEnabled = true;

   

   

   /**

    * AccessLog buffer size for storing logs.

    */

   private String globalAccessLogBufferSize = null;

  

  

   /**

    * AccessLog interval before the valve flush its buffer to the disk.

    */

   private String globalAccessLogWriteInterval = null; 

  

    /**

     * The default-redirect port.

     */

    protected int defaultRedirectPort = -1;

    private static final String DEFAULT_KEYSTORE_TYPE = "JKS";

    private static final String DEFAULT_TRUSTSTORE_TYPE = "JKS";

   // --------------------------------------------------------- Constructor

    /**

     * This creates the embedded Catalina/Jasper container

     * and sets the config properties on the container.

     */

    protected PEWebContainer(String id, ServerContext context) {

        super(id, context);

    }

    /**

     * Initialize Tomcat internal objects.

     */

    protected void init(ServerContext context){

        connectorMap = new HashMap<String,PECoyoteConnector>();

        ConfigContext configContext = context.getConfigContext();

        try {

            Config config = ServerBeansFactory.getConfigBean(configContext);

            Server serverBean = ServerBeansFactory.getServerBean(configContext);

            // Create Tomcat Engine

            createEngine();

            HttpService httpService = config.getHttpService();

            configureNotSupported(httpService);

            createConnectors(httpService);

            createJKConnector(httpService);

            createHosts(httpService, config.getSecurityService(),

                        globalAccessLoggingEnabled, serverBean);

       

            checkDefaultVirtualServerPort(httpService);

            registerReconfigListeners(this);

        } catch (ConfigException e) {

            _logger.log(Level.SEVERE, "webcontainer.configError", e);

        }      

    }

    /**

     * Starts the AJP connector that will listen to call from Apache using

     * mod_jk, mod_jk2 or mod_ajp.

     */

    private void createJKConnector(HttpService httpService) {

        String portString = System.getProperty("com.sun.enterprise.web.connector.enableJK");

        if (portString == null) {

            // do not create JK Connector if property is not set

            return;

        } else {

            int port = 8009;

            try {

                port = Integer.parseInt(portString);

            } catch (NumberFormatException ex) {

                // use default port 8009

                port = 8009;

            }

            jkConnector = (PECoyoteConnector)

                ((Embedded)_embedded).createConnector("0.0.0.0", port,

                                                      "ajp");

            configureJKProperties(jkConnector);

            String defaultHost = "server";

            jkConnector.setDefaultHost(defaultHost);       

            jkConnector.setDomain(_serverContext.getDefaultDomainName());

            jkConnector.setLogger(_logger);

            jkConnector.setName("httpd-listener");

       

            configureHttpProtocol(jkConnector, httpService.getHttpProtocol());

            _logger.log(Level.INFO, "Apache mod_jk/jk2 attached to virtual-server "

                                + defaultHost + " listening on port: "

                                + portString);

            _embedded.addConnector(jkConnector);      

        }

    }

    /**

     * Enumerates the http-listener subelements of the given http-service

     * element, and creates a corresponding Tomcat Connector for each.

     *

     * @param httpService The http-service element

     */

    public void createConnectors(HttpService httpService) {

        HttpListener[] httpListeners = httpService.getHttpListener();

       

        // Attach http-listeners to Engine

        if (httpListeners != null){

            for (int i=0; i< httpListeners.length; i++) {

                if (!httpListeners[i].isEnabled()) {

                    continue;

                }

                createConnector(httpListeners[i],httpService);              

            }

        }

        setDefaultRedirectPort(defaultRedirectPort);

    }

   

    /**

     * Use an http-listener subelements and creates a corresponding

     * Tomcat Connector for each.

     *

     * @param httpService The http-service element

     * @param httpListener the configuration element.

     */      

    public PECoyoteConnector createConnector(HttpListener httpListener,

                                             HttpService httpService){

                                

        int port = 8080;

        PECoyoteConnector connector;

       

        checkHostnameUniqueness(httpListener.getId(), httpService);

        try {

            port = Integer.parseInt(httpListener.getPort());

        } catch (NumberFormatException nfe) {

            String msg = _rb.getString("pewebcontainer.http_listener.invalid_port");

            msg = MessageFormat.format(msg,

                                       new Object[] {httpListener.getPort(),

                                       httpListener.getId() });

            throw new IllegalArgumentException(msg);

        }

        /*

         * Create Connector. Connector is SSL-enabled if

         * 'security-enabled' attribute in <http-listener>

         * element is set to TRUE.

         */

        boolean isSecure = httpListener.isSecurityEnabled();

        if (isSecure && defaultRedirectPort == -1) {

            defaultRedirectPort = port;

        }

        String address = httpListener.getAddress();

        if ("any".equals(address) || "ANY".equals(address)

                || "INADDR_ANY".equals(address)) {

            address = null;

            /*

             * Setting 'address' to NULL will cause Tomcat to pass a

             * NULL InetAddress argument to the java.net.ServerSocket

             * constructor, meaning that the server socket will accept

             * connections on any/all local addresses.

             */

        }

        connector =

            (PECoyoteConnector)_embedded.createConnector(address,port,

                                                         isSecure);

        connector.setName(httpListener.getId());

        configureConnector(connector,httpListener,isSecure,httpService);

        if ( _logger.isLoggable(Level.FINE)){

            _logger.log(Level.FINE, "create.listenerport",

                new Object[] {Integer.valueOf(port), connector});

        }

        _embedded.addConnector(connector);

        connectorMap.put(httpListener.getId(), connector);      

        // If we already know the redirect port, then set it now

        // This situation will occurs when dynamic reconfiguration occurs

        if ( defaultRedirectPort != -1 ){

            connector.setRedirectPort(defaultRedirectPort);

        }

        return connector;

    }

   

    /**

     * Assigns the given redirect port to each Connector whose corresponding

     * http-listener element in domain.xml does not specify its own

     * redirect-port attribute.

     *

     * The given defaultRedirectPort corresponds to the port number of the

     * first security-enabled http-listener in domain.xml.

     *

     * This method does nothing if none of the http-listener elements is

     * security-enabled, in which case Tomcat's default redirect port (443)

     * will be used.

     *

     * @param defaultRedirectPort The redirect port to be assigned to any

     * Connector object that doesn't specify its own

     */

    private void setDefaultRedirectPort(int defaultRedirectPort) {

        if (defaultRedirectPort != -1) {

            Connector[] connectors = _embedded.getConnectors();

            for (int i=0; i<connectors.length; i++) {

                if (connectors[i].getRedirectPort() == -1) {

                    connectors[i].setRedirectPort(defaultRedirectPort);

                }

            }

        }

    }

    /**

     * Makes sure that for each http-listener, the virtual server referenced

     * as the http-listener's default-virtual-server actually contains the

     * referencing http-listener in its http-listeners attribute

     */

    private void checkDefaultVirtualServerPort(HttpService httpService) {

        HttpListener[] httpListeners = httpService.getHttpListener();

        if (httpListeners == null) {

            return;

        }

        for (HttpListener httpListener : httpListeners) {

            if (!httpListener.isEnabled()) {

                continue;

            }

            int port = Integer.parseInt(httpListener.getPort());

            String defaultVsName = httpListener.getDefaultVirtualServer();

            VirtualServer defaultVs = (VirtualServer)

                _embedded.getEngines()[0].findChild(defaultVsName);

            if (defaultVs == null) {

                _logger.log(Level.SEVERE,

                            "pewebcontainer.defaultVsMissing",

                            new Object[] { defaultVsName, httpListener.getId()});

            }

            boolean found = false;

            int[] ports = defaultVs.getPorts();

            for (int i=0; i<ports.length; i++) {

                if (ports[i] == port) {

                    found = true;

                    break;

                }

            }

            if (!found) {

                _logger.log(Level.SEVERE,

                            "pewebcontainer.defaultVsHttpListenerDisconnect",

                            new Object[] { defaultVsName, httpListener.getId() });

            }

        }

    }

    /*

     * Creates Tomcat Engine.

     */

    protected void createEngine(){

        String engineName = "com.sun.appserv";

        Engine engine = _embedded.createEngine();

        _embedded.addEngine(engine);

        ((StandardEngine)engine).setName(engineName);

        if (isTomcatUsingDefaultDomain()) {

            ((StandardEngine)engine).setDomain(

                        _serverContext.getDefaultDomainName());

        } else {

            ((StandardEngine)engine).setDomain(engineName);

        }

        _logger.log(Level.FINE, "Creating Engine " + engineName);

    }

   

   

    /**

     * Enumerates the virtual-server subelements of the given http-service

     * element, and creates a corresponding Tomcat Host for each.

     */

    public void createHost(

                    com.sun.enterprise.config.serverbeans.VirtualServer vse,

                    ConfigContext configContext,

                    boolean enableMonitoring) throws ConfigException{

           

        Config config = ServerBeansFactory.getConfigBean(configContext);

        Server serverBean = null;

        try {

            serverBean = ServerBeansFactory.getServerBean(configContext);

        } catch (ConfigException e) {

            _logger.log(Level.SEVERE, "webcontainer.configError", e);

        }

      

        VirtualServer vs = createHost(config.getHttpService(),

                                      config.getSecurityService(),

                                      vse,

                                      globalAccessLoggingEnabled,

                                      serverBean);

        if ( enableMonitoring ){            

            enableVirtualServerMonitoring(vs);

        }

    } 

   

   

    /**

     * Enumerates the virtual-server subelements of the given http-service

     * element, and creates a corresponding Tomcat Host for each.

     *

     * @param httpService The http-service element

     * @param securityService The security-service element

     * @param globalAccessLoggingEnabled The value of the accessLoggingEnabled

     * property of <http-service>

     */

    protected void createHosts(HttpService httpService,

                               SecurityService securityService,

                               boolean globalAccessLoggingEnabled,

                               Server serverBean) {

        com.sun.enterprise.config.serverbeans.VirtualServer[] vses

            = httpService.getVirtualServer();

        for (int j = 0; j < vses.length; j++) {

            createHost(httpService, securityService, vses[j],

                       globalAccessLoggingEnabled, serverBean);

        }

    }

         

   

    /**

     * Creates a corresponding Tomcat Host from a virtual-server config bean.

     *

     * Note: if you add supports for a new property, you MUST also add the

     *       logic in the updateHostProperties method.

     *

     * @param httpService The http-service element

     * @param securityService The security-service element

     * @param vse The virtual-server configuration bean.

     * @param globalAccessLoggingEnabled The value of the accessLoggingEnabled

     * property of <http-service>

     */           

    protected VirtualServer createHost(

                       HttpService httpService,

                       SecurityService securityService,

                       com.sun.enterprise.config.serverbeans.VirtualServer vse,

                       boolean globalAccessLoggingEnabled,

                       Server serverBean){

           

        Engine[] engines = _embedded.getEngines();

        String docroot = null;

        MimeMap mm = null;

        String vs_id = vse.getId();

        ElementProperty element = vse.getElementPropertyByName("docroot");

        if (element != null) {

            docroot = element.getValue();

        } else {

            docroot = vse.getDocroot();

        }

       

        validateDocroot(docroot,

                        vs_id,

                        vse.getDefaultWebModule());

        VirtualServer vs = createVS(vs_id, vse, docroot,

                                    vse.getLogFile(), mm,

                                    httpService.getHttpProtocol());

        // cache control

        ElementProperty cacheProp = vse.getElementPropertyByName(

                                                    "setCacheControl");

        if ( cacheProp != null ){

            vs.configureCacheControl(cacheProp.getValue());  

        }

        PEAccessLogValve accessLogValve = vs.getAccessLogValve();

        boolean startAccessLog = accessLogValve.configure(

            vs_id, vse, httpService, domain, instance,

            _serverContext.getPluggableFeatureFactory().

                getWebContainerFeatureFactory(),

            globalAccessLogBufferSize, globalAccessLogWriteInterval);

        if (startAccessLog

                && vs.isAccessLoggingEnabled(globalAccessLoggingEnabled)) {

            vs.addValve(accessLogValve);

        }

        if (_logger.isLoggable(Level.FINEST)) {

            _logger.log(Level.FINEST, "Created virtual server " + vs_id);

        }

        /*

         * We must configure the Host with its associated port numbers and

         * alias names before adding it as an engine child and thereby

         * starting it, because a MapperListener, which is associated with

         * an HTTP listener and receives notifications about Host

         * registrations, relies on these Host properties in order to determine

         * whether a new Host needs to be added to the HTTP listener's Mapper.

         */

        configureHost(vs, httpService, securityService);

        // Add Host to Engine

        engines[0].addChild(vs);

        return vs;

    }

   

   

    /**

     * Validate the docroot properties of a virtual-server.

     */

    protected boolean validateDocroot(String docroot, String vs_id,

                                      String defaultWebModule){

       

        // docroot vs default-web-module

        if (docroot != null ) {

            // If the docroot is invalid and there is no default module,

            // stop the process.

            boolean isValid = new File(docroot).exists();

            if ( !isValid && defaultWebModule == null){

                String msg =

                    _rb.getString("pewebcontainer.virtual_server.invalid_docroot");

                msg = MessageFormat.format(msg,

                                        new Object[] { vs_id , docroot});

                throw new IllegalArgumentException(msg);

            } else if (!isValid) {

                _logger.log(Level.WARNING, "virtual-server " + vs_id

                            + " has an invalid docroot: " + docroot );

            }

        } else if (defaultWebModule == null) {

            String msg = _rb.getString("pewebcontainer.virtual_server.missing_docroot");

            msg = MessageFormat.format(msg, new Object[] { vs_id });

            throw new IllegalArgumentException(msg);

        }

        return true;

    }

   

    /**

     * Configures the given virtual server.

     *

     * @param vs The virtual server to be configured

     * @param httpService The http-service element of which the given

     * virtual server is a subelement

     * @param securityService The security-service element

     */

    protected void configureHost(VirtualServer vs,

                                 HttpService httpService,

                                 SecurityService securityService) {

        com.sun.enterprise.config.serverbeans.VirtualServer vsBean

            = vs.getBean();

      

        vs.configureAliases();

        // Set the ports with which this virtual server is associated

        List<String> listeners = StringUtils.parseStringList(

                                                vsBean.getHttpListeners(), ",");

        if (listeners == null) {

            return;

        }

       

        HttpListener[] httpListeners = new HttpListener[listeners.size()];

        for (int i=0; i < listeners.size(); i++){

            httpListeners[i] = httpService.getHttpListenerById(listeners.get(i));

        }

               

        configureHostPortNumbers(vs, httpListeners);

        vs.configureCatalinaProperties();

        vs.configureAuthRealm(securityService);

    }

   

   

    /**

     * Configures the given virtual server with the port numbers of its

     * associated http listeners.

     *

     * @param vs The virtual server to configure

     * @param httpListeners The http listeners with which the given virtual

     * server is associated

     */

    protected void configureHostPortNumbers(VirtualServer vs,

                                            HttpListener[] httpListeners){

      

        boolean addJkListenerPort = (jkConnector != null

            && !vs.getName().equalsIgnoreCase(VirtualServer.ADMIN_VS));

        ArrayList<Integer> portsList = new ArrayList();

      

        for (int i=0; i < httpListeners.length; i++){

            if (httpListeners[i].isEnabled()){

                PECoyoteConnector conn = connectorMap.get(

                    httpListeners[i].getId());

                if (conn != null) {

                    portsList.add(Integer.valueOf(conn.getPort()));

                }

            } else {

                if ((vs.getName().equalsIgnoreCase(VirtualServer.ADMIN_VS))) {

                    String msg = _rb.getString(

                        "pewebcontainer.httpListener.mustNotDisable");

                    msg = MessageFormat.format(

                        msg,

                        new Object[] { httpListeners[i].getId(),

                                       vs.getName() });

                    throw new IllegalArgumentException(msg);

                }

            }           

        }

        int numPorts = portsList.size();

        if (addJkListenerPort) {

            numPorts++;

        }

        if (numPorts > 0) {

            int[] ports = new int[numPorts];

            int i=0;

            for (i=0; i<portsList.size(); i++) {

                ports[i] = portsList.get(i).intValue();

            }

            if (addJkListenerPort) {

                ports[i] = jkConnector.getPort();

            }

            vs.setPorts(ports);

        }

    }

   

   

    /**

     * Log any unsupported domain.xml attribute or element.

     */

    private final void configureNotSupported(HttpService httpService){

        if (!_logger.isLoggable(Level.FINE)) {

            return;

        }

       

        if ( httpService.getHttpFileCache() != null ) {       

            if ( httpService.getHttpFileCache().getHashInitSize() != null) {

                _logger.log(Level.FINE,

                            "pewebcontainer.unsupportedAttribute.hash-init-size");

            }

        }

        HttpListener[] httpListeners = httpService.getHttpListener();

        for ( HttpListener httpListener: httpListeners){

            if ( httpListener.getFamily() != null ){

                _logger.log(Level.FINE,

                            "pewebcontainer.unsupportedAttribute.family");

            }

            if ( httpListener.getExternalPort() != null ){

                _logger.log(

                    Level.FINE,

                    "pewebcontainer.unsupportedAttribute.external-port");

            }

        }

       

        if ( httpService.getHttpProtocol() != null ){

            if ( httpService.getHttpProtocol().getVersion() != null) {

                _logger.log(

                    Level.FINE,

                    "pewebcontainer.unsupportedAttribute.version");

            }

            if ( httpService.getHttpProtocol().getAttributeValue("ssl-enabled")

                    != null) {

                _logger.log(Level.FINE,

                            "pewebcontainer.unsupportedAttribute.ssl-enabled");

            }  

        }

    }

   

   

   

    /**

     * Create a PEWebContainer object

     */

    public static WebContainer createInstance(ServerContext context) {

        // Create the web container associated with this configuration

        webContainer = new PEWebContainer(new String("0"), context);

        _logger.log(Level.FINE, "Creating new instance of PEWebContainer.");

       

        // Initialize the Tomcat internal's object.

        ((PEWebContainer)webContainer).init(context);

        _logger.log(Level.FINE, "Initialization of PEWebContainer."); 

        return webContainer;

    }

    /**

     * Start the web container

     */

    public void startInstance() throws ServerLifecycleException {

        _logger.log(Level.INFO, "pewebcontainer.start",

                    ServerInfo.getServerInfo());

        try {

            super.start();

         } catch (LifecycleException le) {

             // check if there is an embedded exception, if so, throw that

             Throwable ex = le.getThrowable();

             if (ex == null)

                 ex = le;

             String msg = _rb.getString("webcontainer.startError");

             throw new ServerLifecycleException(msg, ex);

        }

        // the server has started up, now enable monitoring.

        enableVirtualServerMonitoring();

        enableHttpMonitoring();

    }

    /**

     * Stop the web container

     */

    public void stopInstance() throws ServerLifecycleException {

        _logger.log(Level.INFO, "pewebcontainer.stop",

                    ServerInfo.getServerInfo());

        try {

            super.stop();

        } catch (LifecycleException le) {

            // check if there is an embedded exception, if so, throw that

            Throwable ex = le.getThrowable();

            if (ex == null)

                ex = le;

            String msg = _rb.getString("webcontainer.stopError");

            throw new ServerLifecycleException(msg, ex);

        }

    }

    public static PEWebContainer getPEWebContainer() {        

        return (PEWebContainer)webContainer;

    }

    /*

     * Configures the given connector.

     *

     * @param connector The connector to configure

     * @param httpListener The http-listener that corresponds to the given

     * connector

     * @param isSecure true if the connector is security-enabled, false

     * otherwise

     * @param httpServiceProps The http-service properties

     */

    private void configureConnector(PECoyoteConnector connector,

                                    HttpListener httpListener,

                                    boolean isSecure,

                                    HttpService httpService) {

        configureConnectionPool(connector, httpService.getConnectionPool());

        String sslImplementationName =

            webFeatureFactory.getSSLImplementationName();