View Javadoc

1   /*** 
2    * 
3    * Copyright 2004 Hiram Chirino
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  package org.codehaus.activemq.ra;
19  
20  import javax.jms.Connection;
21  import javax.jms.ConnectionConsumer;
22  import javax.jms.ConnectionMetaData;
23  import javax.jms.Destination;
24  import javax.jms.ExceptionListener;
25  import javax.jms.JMSException;
26  import javax.jms.Queue;
27  import javax.jms.QueueConnection;
28  import javax.jms.QueueSession;
29  import javax.jms.ServerSessionPool;
30  import javax.jms.Session;
31  import javax.jms.Topic;
32  import javax.jms.TopicConnection;
33  import javax.jms.TopicSession;
34  import java.util.ArrayList;
35  import java.util.Iterator;
36  
37  
38  /***
39   * Acts as a pass through proxy for a JMS Connection object.
40   * It intercepts events that are of interest of the ActiveMQManagedConnection.
41   *
42   * @version $Revision: 1.8 $
43   */
44  public class JMSConnectionProxy implements Connection, QueueConnection, TopicConnection {
45  
46      private ActiveMQManagedConnection managedConnection;
47      private ArrayList sessions = new ArrayList();
48  
49      public JMSConnectionProxy(ActiveMQManagedConnection managedConnection) {
50          this.managedConnection = managedConnection;
51      }
52  
53      /***
54       * Used to let the ActiveMQManagedConnection that this connection
55       * handel is not needed by the app.
56       *
57       * @throws JMSException
58       */
59      public void close() throws JMSException {
60          managedConnection.proxyClosedEvent(this);
61      }
62  
63      /***
64       * Called by the ActiveMQManagedConnection to invalidate this proxy.
65       */
66      public void cleanup() {
67          managedConnection = null;
68          for (Iterator iter = sessions.iterator(); iter.hasNext();) {
69              JMSSessionProxy p = (JMSSessionProxy) iter.next();
70              p.cleanup();
71              iter.remove();
72          }
73      }
74  
75      /***
76       * 
77       */
78      private Connection getConnection() throws JMSException {
79          if (managedConnection == null) {
80              throw new JMSException("Connection is closed.");
81          }
82          return managedConnection.getPhysicalConnection();
83      }
84  
85      /***
86       * @param transacted
87       * @param acknowledgeMode
88       * @return
89       * @throws JMSException
90       */
91      public Session createSession(boolean transacted, int acknowledgeMode)
92              throws JMSException {
93          return createSessionProxy();
94      }
95  
96      /***
97       * @return
98       */
99      private JMSSessionProxy createSessionProxy() {
100         JMSSessionProxy p = new JMSSessionProxy(managedConnection);
101         sessions.add(p);
102         return p;
103     }
104 
105     /***
106      * @param transacted
107      * @param acknowledgeMode
108      * @return
109      * @throws JMSException
110      */
111     public QueueSession createQueueSession(boolean transacted,
112                                            int acknowledgeMode) throws JMSException {
113         return createSessionProxy();
114     }
115 
116     /***
117      * @param transacted
118      * @param acknowledgeMode
119      * @return
120      * @throws JMSException
121      */
122     public TopicSession createTopicSession(boolean transacted,
123                                            int acknowledgeMode) throws JMSException {
124         return createSessionProxy();
125     }
126 
127     /***
128      * @return
129      * @throws JMSException
130      */
131     public String getClientID() throws JMSException {
132         return getConnection().getClientID();
133     }
134 
135     /***
136      * @return
137      * @throws JMSException
138      */
139     public ExceptionListener getExceptionListener() throws JMSException {
140         return getConnection().getExceptionListener();
141     }
142 
143     /***
144      * @return
145      * @throws JMSException
146      */
147     public ConnectionMetaData getMetaData() throws JMSException {
148         return getConnection().getMetaData();
149     }
150 
151     /***
152      * @param clientID
153      * @throws JMSException
154      */
155     public void setClientID(String clientID) throws JMSException {
156         //getConnection().setClientID(clientID);
157     }
158 
159     /***
160      * @param listener
161      * @throws JMSException
162      */
163     public void setExceptionListener(ExceptionListener listener)
164             throws JMSException {
165         getConnection().setExceptionListener(listener);
166     }
167 
168     /***
169      * @throws JMSException
170      */
171     public void start() throws JMSException {
172         //getConnection().start();
173     }
174 
175     /***
176      * @throws JMSException
177      */
178     public void stop() throws JMSException {
179         //getConnection().stop();
180     }
181 
182 
183     /***
184      * @param queue
185      * @param messageSelector
186      * @param sessionPool
187      * @param maxMessages
188      * @return
189      * @throws JMSException
190      */
191     public ConnectionConsumer createConnectionConsumer(Queue queue,
192                                                        String messageSelector, ServerSessionPool sessionPool,
193                                                        int maxMessages) throws JMSException {
194         throw new JMSException("Not Supported.");
195     }
196 
197     /***
198      * @param topic
199      * @param messageSelector
200      * @param sessionPool
201      * @param maxMessages
202      * @return
203      * @throws JMSException
204      */
205     public ConnectionConsumer createConnectionConsumer(Topic topic,
206                                                        String messageSelector, ServerSessionPool sessionPool,
207                                                        int maxMessages) throws JMSException {
208         throw new JMSException("Not Supported.");
209     }
210 
211     /***
212      * @param destination
213      * @param messageSelector
214      * @param sessionPool
215      * @param maxMessages
216      * @return
217      * @throws JMSException
218      */
219     public ConnectionConsumer createConnectionConsumer(Destination destination,
220                                                        String messageSelector, ServerSessionPool sessionPool,
221                                                        int maxMessages) throws JMSException {
222         throw new JMSException("Not Supported.");
223     }
224 
225     /***
226      * @param topic
227      * @param subscriptionName
228      * @param messageSelector
229      * @param sessionPool
230      * @param maxMessages
231      * @return
232      * @throws JMSException
233      */
234     public ConnectionConsumer createDurableConnectionConsumer(Topic topic,
235                                                               String subscriptionName, String messageSelector,
236                                                               ServerSessionPool sessionPool, int maxMessages) throws JMSException {
237         throw new JMSException("Not Supported.");
238     }
239 
240     /***
241      * @return Returns the managedConnection.
242      */
243     public ActiveMQManagedConnection getManagedConnection() {
244         return managedConnection;
245     }
246 
247 }