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.broker;
    20
    21  import org.codehaus.activemq.message.ActiveMQMessage;
    22  import org.codehaus.activemq.message.ActiveMQXid;
    23  import org.codehaus.activemq.message.ConnectionInfo;
    24  import org.codehaus.activemq.message.ConsumerInfo;
    25  import org.codehaus.activemq.message.DurableUnsubscribe;
    26  import org.codehaus.activemq.message.MessageAck;
    27  import org.codehaus.activemq.message.ProducerInfo;
    28  import org.codehaus.activemq.message.SessionInfo;
    29  import org.codehaus.activemq.message.WireFormat;
    30  import org.codehaus.activemq.security.SecurityAdapter;
    31  import org.codehaus.activemq.service.Service;
    32  import org.codehaus.activemq.store.PersistenceAdapter;
    33  import org.codehaus.activemq.transport.DiscoveryAgent;
    34  import org.codehaus.activemq.transport.NetworkConnector;
    35  import org.codehaus.activemq.transport.TransportServerChannel;
    36
    37  import javax.jms.InvalidClientIDException;
    38  import javax.jms.JMSException;
    39  import javax.jms.JMSSecurityException;
    40  import javax.transaction.xa.XAException;
    41  import java.util.List;
    42
    43  /***
    44   * The ActiveMQ JMS Broker Container which contains a {@link Broker} and one or more
    45   * {@ BrokerConnector} instances talking over some {@link org.codehaus.activemq.transport.TransportChannel}
    46   * <p/>
    47   * <b>Note</b> that  once a broker container has been stopped it should be discarded and a new service
    48   * instance created again. Calling start() on a stopped broker will not usually work.
    49   *
    50   * @version $Revision: 1.9 $
    51   */
    52  public interface BrokerContainer extends Service {
    53
    54      /***
    55       * registers a new Connection
    56       *
    57       * @param client
    58       * @param info   infomation about the client-side Connection
    59       * @throws InvalidClientIDException if the ClientID of the Connection is a duplicate
    60       */
    61      public void registerConnection(BrokerClient client, ConnectionInfo info) throws JMSException;
    62
    63      /***
    64       * un-registers a Connection
    65       *
    66       * @param client
    67       * @param info   infomation about the client-side Connection
    68       * @throws JMSException
    69       */
    70      public void deregisterConnection(BrokerClient client, ConnectionInfo info) throws JMSException;
    71
    72      /***
    73       * Registers a MessageConsumer
    74       *
    75       * @param client
    76       * @param info
    77       * @throws JMSException
    78       * @throws JMSSecurityException if client authentication fails for the Destination the
    79       *                              Consumer applies for
    80       */
    81      public void registerMessageConsumer(BrokerClient client, ConsumerInfo info) throws JMSException;
    82
    83      /***
    84       * De-register a MessageConsumer from the Broker
    85       *
    86       * @param client
    87       * @param info
    88       * @throws JMSException
    89       */
    90      public void deregisterMessageConsumer(BrokerClient client, ConsumerInfo info) throws JMSException;
    91
    92      /***
    93       * Registers a MessageProducer
    94       *
    95       * @param client
    96       * @param info
    97       * @throws JMSException
    98       * @throws JMSSecurityException if client authentication fails for the Destination the
    99       *                              Consumer applies for
    100      */
    101
    102     public void registerMessageProducer(BrokerClient client, ProducerInfo info) throws JMSException;
    103
    104     /***
    105      * De-register a MessageProducer from the Broker
    106      *
    107      * @param client
    108      * @param info
    109      * @throws JMSException
    110      */
    111     public void deregisterMessageProducer(BrokerClient client, ProducerInfo info) throws JMSException;
    112
    113     /***
    114      * Register a client-side Session (used for Monitoring)
    115      *
    116      * @param client
    117      * @param info
    118      * @throws JMSException
    119      */
    120
    121     public void registerSession(BrokerClient client, SessionInfo info) throws JMSException;
    122
    123     /***
    124      * De-register a client-side Session from the Broker (used for monitoring)
    125      *
    126      * @param client
    127      * @param info
    128      * @throws JMSException
    129      */
    130     public void deregisterSession(BrokerClient client, SessionInfo info) throws JMSException;
    131
    132     /***
    133      * Start a transaction from the Client session
    134      *
    135      * @param client
    136      * @param transactionId
    137      * @throws JMSException
    138      */
    139     public void startTransaction(BrokerClient client, String transactionId) throws JMSException;
    140
    141     /***
    142      * Rollback a transacton
    143      *
    144      * @param client
    145      * @param transactionId
    146      * @throws JMSException
    147      */
    148     public void rollbackTransaction(BrokerClient client, String transactionId) throws JMSException;
    149
    150     /***
    151      * Commit a transaction
    152      *
    153      * @param client
    154      * @param transactionId
    155      * @throws JMSException
    156      */
    157     public void commitTransaction(BrokerClient client, String transactionId) throws JMSException;
    158
    159     /***
    160      * send message with a transaction context
    161      *
    162      * @param client
    163      * @param transactionId
    164      * @param message
    165      * @throws JMSException
    166      */
    167     public void sendTransactedMessage(BrokerClient client, String transactionId, ActiveMQMessage message)
    168             throws JMSException;
    169
    170     /***
    171      * Acknowledge receipt of a message within a transaction context
    172      *
    173      * @param client
    174      * @param transactionId
    175      * @param ack
    176      * @throws JMSException
    177      */
    178     public void acknowledgeTransactedMessage(BrokerClient client, String transactionId, MessageAck ack)
    179             throws JMSException;
    180
    181     /***
    182      * Send a non-transacted message to the Broker
    183      *
    184      * @param client
    185      * @param message
    186      * @throws JMSException
    187      */
    188
    189     public void sendMessage(BrokerClient client, ActiveMQMessage message) throws JMSException;
    190
    191     /***
    192      * Acknowledge reciept of a message
    193      *
    194      * @param client
    195      * @param ack
    196      * @throws JMSException
    197      */
    198     public void acknowledgeMessage(BrokerClient client, MessageAck ack) throws JMSException;
    199
    200     /***
    201      * Command to delete a durable topic subscription
    202      *
    203      * @param client
    204      * @param ds
    205      * @throws JMSException
    206      */
    207
    208     public void durableUnsubscribe(BrokerClient client, DurableUnsubscribe ds) throws JMSException;
    209
    210     /***
    211      * Start an XA transaction.
    212      *
    213      * @param client
    214      * @param xid
    215      */
    216     public void startTransaction(BrokerClient client, ActiveMQXid xid) throws XAException;
    217
    218     /***
    219      * Gets the prepared XA transactions.
    220      *
    221      * @param client
    222      * @return
    223      */
    224     public ActiveMQXid[] getPreparedTransactions(BrokerClient client) throws XAException;
    225
    226     /***
    227      * Prepare an XA transaction.
    228      *
    229      * @param client
    230      * @param xid
    231      */
    232     public int prepareTransaction(BrokerClient client, ActiveMQXid xid) throws XAException;
    233
    234     /***
    235      * Rollback an XA transaction.
    236      *
    237      * @param client
    238      * @param xid
    239      */
    240     public void rollbackTransaction(BrokerClient client, ActiveMQXid xid) throws XAException;
    241
    242     /***
    243      * Commit an XA transaction.
    244      *
    245      * @param client
    246      * @param xid
    247      * @param onePhase
    248      */
    249     public void commitTransaction(BrokerClient client, ActiveMQXid xid, boolean onePhase) throws XAException;
    250
    251     /***
    252      * Called when a new connector is added to this container
    253      *
    254      * @param connector
    255      */
    256     public void addConnector(BrokerConnector connector);
    257
    258     /***
    259      * Called when a connector is removed to this container
    260      *
    261      * @param connector
    262      */
    263     public void removeConnector(BrokerConnector connector);
    264
    265
    266     /***
    267      * @return the Broker for the Container
    268      */
    269     public Broker getBroker();
    270
    271     /***
    272      * Returns the transport connectors used to communicate with
    273      * clients
    274      */
    275     public List getTransportConnectors();
    276
    277     public void setTransportConnectors(List transportConnectors);
    278
    279     /***
    280      * Returns a list of {@link org.codehaus.activemq.transport.NetworkConnector}
    281      * instances used to communicate with the network of {@link Broker} instances
    282      */
    283     public List getNetworkConnectors();
    284
    285     public void setNetworkConnectors(List networkConnectors);
    286
    287
    288     /***
    289      * Returns the persistence adapter
    290      */
    291     public PersistenceAdapter getPersistenceAdapter();
    292
    293     public void setPersistenceAdapter(PersistenceAdapter persistenceAdapter);
    294
    295     /***
    296      * Returns the discovery agent if one is available or null if discovery is not
    297      * enabled
    298      */
    299     public DiscoveryAgent getDiscoveryAgent();
    300
    301     public void setDiscoveryAgent(DiscoveryAgent discoveryAgent);
    302
    303     /***
    304      * Returns the security adapter used to authenticate and authorize access to JMS resources
    305      */
    306     public SecurityAdapter getSecurityAdapter();
    307
    308     /***
    309      * Sets the security adapter used to authenticate and authorize access to JMS resources
    310      */
    311     public void setSecurityAdapter(SecurityAdapter securityAdapter);
    312
    313     /***
    314      * Adds a new network connector for the given URI
    315      */
    316     NetworkConnector addNetworkConnector(String uri);
    317
    318     /***
    319      * Adds a new network connector
    320      *
    321      * @return the newly created network connector
    322      */
    323     NetworkConnector addNetworkConnector();
    324
    325     /***
    326      * Adds a new network connector
    327      */
    328     void addNetworkConnector(NetworkConnector connector);
    329
    330     /***
    331      * Removes the given network connector
    332      */
    333     void removeNetworkConnector(NetworkConnector connector);
    334
    335     /***
    336      * Adds a new transport connector for the given bind address
    337      */
    338     void addConnector(String bindAddress) throws JMSException;
    339
    340     /***
    341      * Adds a new transport connector for the given bind address and wire format
    342      */
    343     void addConnector(String bindAddress, WireFormat wireFormat) throws JMSException;
    344
    345     /***
    346      * Adds a new transport connector for the given transportConnector
    347      */
    348     void addConnector(TransportServerChannel transportConnector);
    349 }