/*
    * Copyright (C) The Apache Software Foundation. All rights reserved.
    *
    * This software is published under the terms of the Apache Software License
    * version 1.1, a copy of which has been included with this distribution in
    * the LICENSE file.
    * 
    * $Id: ManagerServlet.java 155459 2005-02-26 13:24:44Z dirkv $
    */
  package org.apache.commons.messagelet;
  
  import java.net.URL;
  import java.util.Iterator;
  
  import javax.jms.JMSException;
  import javax.servlet.GenericServlet;
  import javax.servlet.ServletException;
  import javax.servlet.ServletRequest;
  import javax.servlet.ServletResponse;
  
  import org.apache.commons.messagelet.model.SubscriptionDigester;
  import org.apache.commons.messagelet.model.SubscriptionList;
  import org.apache.commons.messenger.Messenger;
  import org.apache.commons.messenger.MessengerManager;
  
  /** <p><code>ManagerServlet</code> manages the 
    * initialisation and destruction of the Messenger connections
    * and use of MessageListener beans for a given ServletContext.</p>
    *
    * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
    * @version $Revision: 155459 $
    */
  public class ManagerServlet extends GenericServlet {
  
      /** Should HTTP servlets be used or generic servlets. If true then JSP can be dispatched to easily */
      private static final boolean USE_HTTP_SERVLETS = true;
  
      private static final String KEY_CONNECTIONS = "connections";
      private static final String KEY_SUBSCRIPTIONS = "subscriptions";
  
      /** 
       * Whether exceptions occurring during subscriptions on startup should 
       * terminate the initialization
       */
      private boolean continueOnSubscribeException;
      
      public ManagerServlet() {
      }
      
      public SubscriptionManager getSubscriptionManager() {
          SubscriptionManager answer = (SubscriptionManager) getServletContext().getAttribute( "subscriptionManager" );
          if (answer == null) {
              answer = new SubscriptionManager();
              getServletContext().setAttribute( "subscriptionManager", answer );
          }
          return answer;
      }
  
      // Servlet methods
      //-------------------------------------------------------------------------    
      
      public synchronized void init() throws ServletException {        
          String text = getServletContext().getInitParameter( "continueOnSubscribeException" );
          if ( text != null && text.equals( "true" ) ) {
              continueOnSubscribeException = true;
          }
          
          // ensure Messenger is initialised
          try {
              SubscriptionManager subscriber = getSubscriptionManager();
              MessengerManager manager = subscriber.getMessengerManager();
              if ( manager == null ) {
                  manager = createMessengerManager();
      
                  subscriber.setMessengerManager( manager );
                  subscriber.setSubscriptionList( createSubscriptionList() );
                  subscriber.setServletContext( getServletContext() );
                  
                  // load the subscriptions....
                  subscriber.subscribe();
                  
                  // now lets start all the connections...
                  for (Iterator iter = manager.getMessengerNames(); iter.hasNext(); ) {
                      String name = (String) iter.next();
                      Messenger messenger = manager.getMessenger( name );
                      try {
                          messenger.getConnection().start();
                      }
                      catch (JMSException e) {
                          log( "Caught exception trying to start messenger: " + name + ". Exception: " + e, e );
                      }
                  }
              }
          }
          catch (JMSException e) {
              throw new ServletException("Failed to initialize: " + e, e );
          }
      }
      
     public void destroy() {
         try {
             getSubscriptionManager().unsubscribe();
         }
         catch (Exception e) {
             log( "Failed to destrory the MBOs: " + e, e );
         }
 
         try {        
             MessengerManager manager = getSubscriptionManager().getMessengerManager();
             if ( manager != null ) {
                 log( "Closing the Messenger connections" );
                 manager.close();
             }
         }
         catch (Exception e) {
             log( "Failed to close the Messenger Manager: " + e, e );
         }
         getSubscriptionManager().setMessengerManager( null );
     }
     
     public void service(ServletRequest request, ServletResponse response) throws ServletException {
     }
 
 
     // Properties
     //-------------------------------------------------------------------------    
     public boolean isContinueOnSubscriptionException() {
         return continueOnSubscribeException;
     }
     
     /** 
      * Sets whether exceptions occurring during subscriptions on startup should 
      * terminate the initialization
      */
     public void setContinueOnSubscribeException(boolean continueOnSubscribeException) {
         this.continueOnSubscribeException = continueOnSubscribeException;
     }
 
     
     // Implementation methods
     //-------------------------------------------------------------------------    
     protected MessengerManager createMessengerManager() throws ServletException {
         String config = getURLResource( KEY_CONNECTIONS, "The Messenger connections XML deployment document" );
 
         log( "Creating the Messenger connections from the file: " + config );
         
         try {
             return MessengerManager.load( config );
         }
         catch (JMSException e) {
             log( "Could not parse Messenger connection XML deployment document for URL: " + config, e );
             
             throw new ServletException(
                 "Could not parse Messenger connection XML deployment document for URL: " + config
                 + " reason: " + e, e
             );
         }
     }
     
     protected SubscriptionList createSubscriptionList() throws ServletException {
         String config = getURLResource( KEY_SUBSCRIPTIONS, "The Messenger subscriptions XML deployment document" );
         
         log( "Loading the Messenger subscriptions from: " + config );
         
         try {
             SubscriptionDigester digester = new SubscriptionDigester();
             return (SubscriptionList) digester.parse( config );
         }
         catch (Exception e) {
             log( "Could not parse Messenger subscription XML deployment document for URL: " + config, e );
             
             throw new ServletException(
                 "Could not parse Messenger subscription XML deployment document for URL: " + config
                 + " reason: " + e, e
             );
         }
     }
 
     protected String getURLResource(String key, String description) throws ServletException {
         String config = getInitParameter( key );
         if ( config == null || config.length() == 0 ) {
             throw new ServletException( 
                 "No initialization parameter for parameter: " + key 
                 + " description: " + description 
             );
         }
         try {
             URL url = getServletContext().getResource( config );
             config = url.toString();
         }
         catch (Exception e) {
             // ignore, must be an absolute URL
         }
         return config;
     }
 
     /**
      * Allows derived servlets to handle JMS exceptions differently, such as ignoring certain kinds of
      * exceptions or performing custom logging etc.
      */
     protected void handleJMSException(String message, JMSException exception) throws ServletException {    
         log( message, exception );
         
         if ( ! isContinueOnSubscriptionException() ) {
             throw new ServletException( message, exception );
         }
     }
 }