/*

  * Copyright 2007-2008 The Kuali Foundation

  *

  * Licensed under the Educational Community License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  * http://www.opensource.org/licenses/ecl2.php

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.kuali.rice.test.lifecycles;

 import java.net.BindException;

 import java.util.HashMap;

 import java.util.Map;

 import java.util.Set;

 import org.apache.log4j.Logger;

 import org.kuali.rice.core.api.config.property.Config;

 import org.kuali.rice.core.api.config.property.ConfigContext;

 import org.kuali.rice.core.api.lifecycle.Lifecycle;

 import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;

 import org.kuali.rice.core.api.resourceloader.ResourceLoader;

 import org.kuali.rice.core.api.util.RiceUtilities;

 import org.kuali.rice.core.web.jetty.JettyServer;

 import org.mortbay.jetty.webapp.WebAppClassLoader;

 /**

  * A lifecycle for running a jetty web server.

  * @author Kuali Rice Team (rice.collab@kuali.org)

  */

 public class JettyServerLifecycle implements Lifecycle {

     private static final Logger LOG = Logger.getLogger(JettyServerLifecycle.class);

     private static final HashMap<Integer, Config> WEBAPP_CONFIGS = new HashMap<Integer, Config>();

     public static Config getWebappConfig(int port) {

         return WEBAPP_CONFIGS.get(port);

     }

     /**

      * Enum for dealing with the webapp's Config

      */

     public static enum ConfigMode {

         /**

          * Do nothing

          */

         NONE,

         /**

          * Override the Config for the context class loader

          */

         OVERRIDE,

         /**

          * Merge the webapp's Config into the existing context class loader config

          */

         MERGE

     }

     /**

      * By default we set the JettyServer to test mode

      */

     private boolean testMode = true;

     private boolean started;

     private ConfigMode configMode = ConfigMode.OVERRIDE;

     private boolean addWebappResourceLoaders = true;

         protected JettyServer jettyServer;

         public JettyServerLifecycle() {

                 this(8080, null);

         }

         public JettyServerLifecycle(int port) {

                 this(port, null, null);

         }

         public JettyServerLifecycle(int port, String contextName) {

                 this(port, contextName, null);

         }

         public JettyServerLifecycle(int port, String contextName, String relativeWebappRoot) {

                 jettyServer = new JettyServer(port, contextName, relativeWebappRoot);

                 jettyServer.setFailOnContextFailure(true);

                 jettyServer.setTestMode(testMode);

         }        

     public void setTestMode(boolean t) {

         this.testMode = t;

     }

     public boolean isTestMode() {

         return testMode;

     }

     public ConfigMode getConfigMode() {

         return this.configMode;

     }

     public void setConfigMode(ConfigMode configMode) {

         this.configMode = configMode;

     }

     public boolean isAddWebappResourceLoaders() {

         return this.addWebappResourceLoaders;

     }

     public void setAddWebappResourceLoaders(boolean addWebappResourceLoaders) {

         this.addWebappResourceLoaders = addWebappResourceLoaders;

     }

         public boolean isStarted() {

                 return started;

         }

         public void start() throws Exception {

             try {

                 jettyServer.start();

             } catch (RuntimeException re) {

                 // add some handling to make port conflicts more easily identified

                 if (RiceUtilities.findExceptionInStack(re, BindException.class) != null) {

                     LOG.error("JettyServerLifecycle encountered BindException on port: " + jettyServer.getPort() + "; check logs for test failures or and the config for duplicate port specifications.");

                 }

                 throw re;

             }

             ClassLoader webappClassLoader = jettyServer.getContext().getClassLoader();

             if (addWebappResourceLoaders) {

                 ResourceLoader rl = GlobalResourceLoader.getResourceLoader(webappClassLoader);

             if (rl == null) {

                 throw new RuntimeException("Could not find resource loader for workflow test harness web app for: " + webappClassLoader);

             }

             GlobalResourceLoader.addResourceLoader(rl);

             }

         // TODO: RICE-2.0 UPGRADE had to jump through hoops with M8 because getConfig was made private.  Uncomment the following and remove the next block

             // Config webappConfig = ConfigContext.getConfig(webappClassLoader);

         Config webappConfig = null;

         for (Map.Entry<ClassLoader, Config> configEntry : ConfigContext.getConfigs()) {

             if (configEntry.getKey() instanceof WebAppClassLoader) {

                 webappConfig = configEntry.getValue();

             }

         }

         WEBAPP_CONFIGS.put(jettyServer.getPort(), webappConfig);

             if (ConfigMode.OVERRIDE == configMode) {

             // this overrides the test harness classloader config with the webapp's config...

             ConfigContext.overrideConfig(Thread.currentThread().getContextClassLoader(), webappConfig);

         } else if (ConfigMode.MERGE == configMode) {

             Config curCtxConfig = ConfigContext.getCurrentContextConfig();

             if (webappConfig != null) {

                 curCtxConfig.putProperties(webappConfig.getProperties());

                 curCtxConfig.putObjects(webappConfig.getObjects());

             }

         }

                 started = true;

         }

         public void stop() throws Exception {

             LOG.info("Shutting down jetty: " + jettyServer);

             try {

                     if (jettyServer != null && jettyServer.isStarted()) {

                             jettyServer.stop();

                             WEBAPP_CONFIGS.remove(jettyServer.getPort());

                     }

             } catch (Exception e) {

                 LOG.error("Error shutting down Jetty " + jettyServer.getContextName() + " " + jettyServer.getRelativeWebappRoot(), e);

             }

                 started = false;

         }

 }