/***
    * Redistribution and use of this software and associated documentation
    * ("Software"), with or without modification, are permitted provided
    * that the following conditions are met:
    *
    * 1. Redistributions of source code must retain copyright
    *    statements and notices.  Redistributions must also contain a
    *    copy of this document.
    *
   * 2. Redistributions in binary form must reproduce the
   *    above copyright notice, this list of conditions and the
   *    following disclaimer in the documentation and/or other
   *    materials provided with the distribution.
   *
   * 3. The name "Exolab" must not be used to endorse or promote
   *    products derived from this Software without prior written
   *    permission of Exoffice Technologies.  For written permission,
   *    please contact info@exolab.org.
   *
   * 4. Products derived from this Software may not be called "Exolab"
   *    nor may "Exolab" appear in their names without prior written
   *    permission of Exoffice Technologies. Exolab is a registered
   *    trademark of Exoffice Technologies.
   *
   * 5. Due credit should be given to the Exolab Project
   *    (http://www.exolab.org/).
   *
   * THIS SOFTWARE IS PROVIDED BY EXOFFICE TECHNOLOGIES AND CONTRIBUTORS
   * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
   * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
   * EXOFFICE TECHNOLOGIES OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
   * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * Copyright 2001-2003 (C) Exoffice Technologies Inc. All Rights Reserved.
   *
   * $Id: DurableConsumerEndpoint.java,v 1.22 2003/09/25 11:24:16 tanderson Exp $
   *
   * Date         Author  Changes
   * 3/1/2001     jima    Created
   */
  package org.exolab.jms.messagemgr;
  
  import java.sql.Connection;
  import java.util.Enumeration;
  import java.util.Vector;
  
  import javax.jms.JMSException;
  import javax.jms.Session;
  import javax.transaction.TransactionManager;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import org.exolab.jms.client.JmsTopic;
  import org.exolab.jms.message.MessageHandle;
  import org.exolab.jms.message.MessageImpl;
  import org.exolab.jms.persistence.DatabaseService;
  import org.exolab.jms.persistence.PersistenceException;
  import org.exolab.jms.scheduler.Scheduler;
  import org.exolab.jms.server.JmsServerSession;
  
  
  /***
   * A durable subscriber extends {@link ConsumerEndpoint} and is only associated
   * with a Topic destination. The state of the durable subscriber is
   * maintained across server invocations by the persistent layer
   *
   * @version     $Revision: 1.22 $ $Date: 2003/09/25 11:24:16 $
   * @author      <a href="mailto:jima@exoffice.com">Jim Alateras</a>
   */
  public class DurableConsumerEndpoint
      extends TopicConsumerEndpoint {
  
      /***
       * The well-known name of the durable subscriber
       */
      private String _name = null;
  
      /***
       * The logger
       */
      private static final Log _log =
          LogFactory.getLog(DurableConsumerEndpoint.class);
  
  
      /***
       * Create an durable consumer endpoint. This is a well-known
       * endpoint which can only be activated by one client at any one time.
       * <p>
       * DurableConsumerEndpoints are always loaded in memory, whether they
       * are active or inactive. When they are inactive they simply process
       * persistent messages. Non-persistent message are ignored when the
      * durable consumer is inactive.
      *
      * @param session - the creating session
      * @param clientId - uniquely identifies the remote client within session
      * @param topic - destination it is subscribing too
      * @param name - the well known name of the durable subscriber
      * @param selector - the selector attached to the consumer, if any.
      * @param scheduler - entity that will delivery messages asynch.
      * @throws JMSException
      */
     DurableConsumerEndpoint(JmsServerSession session, long clientId,
                             JmsTopic topic, String name, String selector,
                             Scheduler scheduler) throws JMSException {
         super(session, clientId, topic, selector, scheduler);
         _name = name;
 
         // call the persistence adapter to retrieve the state of  this
         // durable consumer. The adaptor will return a linked list of
         // PersistentHandle objects which represent unsent and sent
         // messages.
         Connection connection = null;
         try {
             connection = DatabaseService.getConnection();
 
             // remove expired messages
             DatabaseService.getAdapter().removeExpiredMessageHandles(
                 connection, _name);
             Vector handles = DatabaseService.getAdapter().getMessageHandles(
                 connection, getDestination(), _name);
             connection.commit();
             // iterate over each handle and add them to the list of messages
             // for the durable consumer
             Enumeration iter = handles.elements();
             while (iter.hasMoreElements()) {
                 addMessage((MessageHandle) iter.nextElement());
             }
         } catch (PersistenceException exception) {
             if (connection != null) {
                 try {
                     connection.rollback();
                 } catch (Exception nested) {
                     // ignore
                 }
             }
             throw new JMSException("DurableConusmerEndpoint not activated " +
                 exception);
         } catch (Exception exception) {
             // rethrow as a JMSException
             throw new JMSException("DurableConusmerEndpoint not activated " +
                 exception);
         } finally {
             if (connection != null) {
                 try {
                     connection.close();
                 } catch (Exception nested) {
                     // ignore
                 }
             }
         }
     }
 
     /***
      * Returns the persistent identifier for this consumer.<p/>
      * This is the identity of the consumer which is persistent across
      * subscriptions and server restarts. <p/>
      *
      * This implementation returns the consumer name.
      *
      * @return the persistent identifier for this consumer
      */
     public String getPersistentId() {
         return getName();
     }
 
     /***
      * Returns the durable subscription name
      *
      * @return the durable subscription name
      */
     public String getName() {
         return _name;
     }
 
 } //-- DurableConsumerEndpoint