View Javadoc

    1   /***
    2    *
    3    * Copyright 2004 Protique Ltd
    4    *
    5    * Licensed under the Apache License, Version 2.0 (the "License");
    6    * you may not use this file except in compliance with the License.
    7    * You may obtain a copy of the License at
    8    *
    9    * http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   *
    17   **/
    18
    19  package org.codehaus.activemq.service;
    20
    21  import org.codehaus.activemq.message.ActiveMQDestination;
    22  import org.codehaus.activemq.message.ActiveMQMessage;
    23  import org.codehaus.activemq.message.ConsumerInfo;
    24  import org.codehaus.activemq.message.MessageAck;
    25
    26  import javax.jms.JMSException;
    27
    28
    29  /***
    30   * A Subscription holds messages to be dispatched to a a Client Consumer
    31   *
    32   * @version $Revision: 1.13 $
    33   */
    34  public interface Subscription {
    35
    36
    37      /***
    38       * Set the active consumer info
    39       *
    40       * @param info
    41       */
    42      public void setActiveConsumer(ConsumerInfo info);
    43
    44      /***
    45       * Called when the Subscription is discarded
    46       *
    47       * @throws JMSException
    48       */
    49      public void clear() throws JMSException;
    50
    51      /***
    52       * Called when an active message consumer has closed.
    53       *
    54       * @throws JMSException
    55       */
    56
    57      public void reset() throws JMSException;
    58
    59      /***
    60       * @return Returns the clientId.
    61       */
    62      public String getClientId();
    63
    64      /***
    65       * @return Returns the subscriberName.
    66       */
    67      public String getSubscriberName();
    68
    69      /***
    70       * @return Returns the destination.
    71       */
    72      public ActiveMQDestination getDestination();
    73
    74      /***
    75       * @return Returns the selector.
    76       */
    77      public String getSelector();
    78
    79      /***
    80       * @return Returns true if an active message consumer is associated with this
    81       */
    82      public boolean isActive();
    83
    84      /***
    85       * set the state of the Subscription
    86       *
    87       * @param newActive
    88       */
    89      public void setActive(boolean newActive) throws JMSException;
    90
    91      /***
    92       * @return Returns the consumerNumber.
    93       */
    94      public int getConsumerNumber();
    95
    96      /***
    97       * @return the consumer Id for the active consumer
    98       */
    99      public String getConsumerId();
    100
    101     /***
    102      * determines if the Subscription is interested in the message
    103      *
    104      * @param message
    105      * @return
    106      * @throws JMSException
    107      */
    108     public boolean isTarget(ActiveMQMessage message) throws JMSException;
    109
    110
    111     /***
    112      * If the Subscription is a target for the message, the subscription will add a reference to
    113      * the message and register an interest in the message to the container
    114      *
    115      * @param container
    116      * @param message
    117      * @throws JMSException
    118      */
    119
    120     public void addMessage(MessageContainer container, ActiveMQMessage message) throws JMSException;
    121
    122     /***
    123      * Indicates a message has been delivered to a MessageConsumer
    124      * which is typically called for topic based subscriptions
    125      *
    126      * @param ack
    127      * @throws JMSException
    128      */
    129
    130     public void messageConsumed(MessageAck ack) throws JMSException;
    131
    132     /***
    133      * Forces the given message to be redelivered
    134      *
    135      * @param container
    136      * @param ack
    137      */
    138     public void redeliverMessage(MessageContainer container, MessageAck ack) throws JMSException;
    139
    140     /***
    141      * Retrieve messages to dispatch
    142      *
    143      * @return
    144      * @throws JMSException
    145      */
    146
    147     public ActiveMQMessage[] getMessagesToDispatch() throws JMSException;
    148
    149     /***
    150      * Indicates if this Subscription has more messages to send to the
    151      * Consumer
    152      *
    153      * @return true if more messages available to dispatch
    154      * @throws JMSException
    155      */
    156     public boolean isReadyToDispatch() throws JMSException;
    157
    158     /***
    159      * Indicates the Subscription it's reached it's pre-fetch limit
    160      *
    161      * @return true/false
    162      * @throws JMSException
    163      */
    164     public boolean isAtPrefetchLimit() throws JMSException;
    165
    166
    167     /***
    168      * Indicates the Consumer is a Durable Subscriber
    169      *
    170      * @return
    171      * @throws JMSException
    172      */
    173     public boolean isDurableTopic() throws JMSException;
    174
    175     /***
    176      * Indicates the consumer is a browser only
    177      *
    178      * @return true if a Browser
    179      * @throws JMSException
    180      */
    181     public boolean isBrowser() throws JMSException;
    182
    183
    184     /***
    185      * Retreives the messageIdentity of the last message sent to this
    186      * Queue based Subscription
    187      *
    188      * @return the messageId of the last message or null
    189      * @throws JMSException
    190      */
    191     public MessageIdentity getLastMessageIdentity() throws JMSException;
    192
    193
    194     /***
    195      * Used for a Queue based Subscription to set the last acknowledged
    196      * message ID
    197      *
    198      * @param messageIdentity
    199      * @throws JMSException
    200      */
    201     public void setLastMessageIdentifier(MessageIdentity messageIdentity) throws JMSException;
    202
    203
    204     public boolean isWildcard();
    205
    206     /***
    207      * Returns the persistent key used to uniquely identify this durable topic subscription
    208      *
    209      * @return
    210      */
    211     public String getPersistentKey();
    212
    213     /***
    214      * Checks if this subscription is a duplicate durable subscription of the given consumer info
    215      *
    216      * @param info
    217      * @return true if this subscription is a durable topic subscription and the clientID and consumer
    218      *         names match
    219      */
    220     public boolean isSameDurableSubscription(ConsumerInfo info) throws JMSException;
    221
    222     /***
    223      * We have not yet committed and so the message acknowledgement has not really occurred yet
    224      * but we need to let the dispatcher know that we can commence dispatching more messages
    225      * to the client. This is so that we can have a prefetch value of 1 yet we can still consume
    226      * 1000 messages inside a transaction, with all the acks coming after the commit() on the client.
    227      *
    228      * @param ack
    229      */
    230     public void onAcknowledgeTransactedMessageBeforeCommit(MessageAck ack) throws JMSException;
    231 }