View Javadoc
1 /*** 2 * Redistribution and use of this software and associated documentation 3 * ("Software"), with or without modification, are permitted provided 4 * that the following conditions are met: 5 * 6 * 1. Redistributions of source code must retain copyright 7 * statements and notices. Redistributions must also contain a 8 * copy of this document. 9 * 10 * 2. Redistributions in binary form must reproduce the 11 * above copyright notice, this list of conditions and the 12 * following disclaimer in the documentation and/or other 13 * materials provided with the distribution. 14 * 15 * 3. The name "Exolab" must not be used to endorse or promote 16 * products derived from this Software without prior written 17 * permission of Exoffice Technologies. For written permission, 18 * please contact info@exolab.org. 19 * 20 * 4. Products derived from this Software may not be called "Exolab" 21 * nor may "Exolab" appear in their names without prior written 22 * permission of Exoffice Technologies. Exolab is a registered 23 * trademark of Exoffice Technologies. 24 * 25 * 5. Due credit should be given to the Exolab Project 26 * (http://www.exolab.org/). 27 * 28 * THIS SOFTWARE IS PROVIDED BY EXOFFICE TECHNOLOGIES AND CONTRIBUTORS 29 * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT 30 * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 31 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 32 * EXOFFICE TECHNOLOGIES OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 33 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 34 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 35 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 36 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 37 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 38 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 39 * OF THE POSSIBILITY OF SUCH DAMAGE. 40 * 41 * Copyright 2000-2003 (C) Exoffice Technologies Inc. All Rights Reserved. 42 * 43 * $Id: IntravmJmsSessionStub.java,v 1.25 2003/08/07 13:32:52 tanderson Exp $ 44 * 45 * Date Author Changes 46 * 04/18/2000 jima Created 47 */ 48 package org.exolab.jms.client.intravm; 49 50 import java.util.Iterator; 51 import java.util.Vector; 52 53 import javax.jms.JMSException; 54 import javax.jms.Message; 55 import javax.transaction.xa.XAException; 56 import javax.transaction.xa.XAResource; 57 import javax.transaction.xa.Xid; 58 59 import org.apache.commons.logging.Log; 60 import org.apache.commons.logging.LogFactory; 61 62 import org.exolab.jms.client.JmsMessageListener; 63 import org.exolab.jms.client.JmsQueue; 64 import org.exolab.jms.client.JmsSessionStubIfc; 65 import org.exolab.jms.client.JmsTopic; 66 import org.exolab.jms.message.MessageImpl; 67 import org.exolab.jms.server.JmsServerSession; 68 69 70 /*** 71 * The client stub implementation for the intra-JVM JMS server. 72 * <p> 73 * This delegates directly to a {@link org.exolab.jms.server.JmsServerSession 74 * JmsServerSession} instance. 75 * 76 * @version $Revision: 1.25 $ $Date: 2003/08/07 13:32:52 $ 77 * @author <a href="mailto:jima@exoffice.com">Jim Alateras</a> 78 */ 79 public class IntravmJmsSessionStub 80 implements JmsSessionStubIfc, JmsMessageListener { 81 82 /*** 83 * This is the message listener for JMS messages. The MessageListener is 84 * then responsible for delivering it to the actual consumer. The listener 85 * must be set by the client session after construction using 86 * {@link #setMessageListener} 87 */ 88 private JmsMessageListener _listener = null; 89 90 /*** 91 * This is a remote reference to the session which is initialised at 92 * construction. 93 */ 94 private JmsServerSession _delegate = null; 95 96 /*** 97 * The logger 98 */ 99 private static final Log _log = 100 LogFactory.getLog(IntravmJmsSessionStub.class); 101 102 103 /*** 104 * Create an instance of this class using the specified session stub. 105 * A {@link JmsMessageListener} must be registered after construction 106 * using {@link #setMessageListener} in order for client session to 107 * receive messages. 108 * 109 * @param session the server session to delegate to 110 * @throws JMSException 111 */ 112 IntravmJmsSessionStub(JmsServerSession session) throws JMSException { 113 if (session != null) { 114 _delegate = session; 115 } else { 116 throw new JMSException( 117 "Cannot create session stub with a null session"); 118 } 119 } 120 121 // implementation of JmsSessionStubIfc.getClientId 122 public String getClientId() throws JMSException { 123 return _delegate.getClientId(); 124 } 125 126 // implementation of JmsSessionStubIfc.getSessionId 127 public String getSessionId() throws JMSException { 128 return _delegate.getSessionId(); 129 } 130 131 // implementation of JmsSessionStubIfc.beforeClose 132 public void beforeClose() throws JMSException { 133 } 134 135 // implementation of JmsSessionStubIfc.close 136 public void close() throws JMSException { 137 _delegate.close(); 138 } 139 140 // implementation of JmsSessionStubIfc.acknowledgeMessage 141 public void acknowledgeMessage(long clientId, String messageId) 142 throws JMSException { 143 // Send back the ack to the consumer endpoint that forwarded the 144 // message. 145 _delegate.acknowledgeMessage(clientId, messageId); 146 } 147 148 // implementation of JmsSessionStubIfc.sendMessage 149 public void sendMessage(Message message) throws JMSException { 150 // As the server resides in the same VM as the client, the message 151 // must be copied to allow the client to modify the original after 152 // it is sent. The limitation of this is that for transacted sessions, 153 // the message will ultimately be copied twice. 154 Message copy = null; 155 try { 156 copy = (Message) ((MessageImpl) message).clone(); 157 } catch (CloneNotSupportedException exception) { 158 JMSException error = new JMSException(exception.getMessage()); 159 error.setLinkedException(exception); 160 throw error; 161 } 162 _delegate.sendMessage(copy); 163 } 164 165 // implementation of JmsSessionStubIfc.sendMessages 166 public void sendMessages(Vector messages) throws JMSException { 167 // messages are already cloned 168 _delegate.sendMessages(messages); 169 } 170 171 // implementation of JmsSessionStubIfc.receiveMessage 172 public Message receiveMessage(long clientId, long wait) 173 throws JMSException { 174 // As the server resides in the same VM as the client, any returned 175 // message must be copied so that if the client modifies it, the 176 // server instance is not affected. 177 Message message = _delegate.receiveMessage(clientId, wait); 178 Message copy = null; 179 if (message != null) { 180 try { 181 copy = (Message) ((MessageImpl) message).clone(); 182 } catch (CloneNotSupportedException exception) { 183 JMSException error = new JMSException(exception.getMessage()); 184 error.setLinkedException(exception); 185 throw error; 186 } 187 } 188 return copy; 189 } 190 191 // implementation of JmsSessionStubIfc.receiveMessages 192 public Vector receiveMessages(long clientId, int count) 193 throws JMSException { 194 // As the server resides in the same VM as the client, any returned 195 // messages must be copied so that if the client modifies it, the 196 // server instance is not affected. 197 Vector messages = _delegate.receiveMessages(clientId, count); 198 Vector copied = new Vector(); 199 if (messages.size() > 0) { 200 for (int index = 0; index < messages.size(); index++) { 201 Message copy = null; 202 Message message = (MessageImpl) messages.elementAt(index); 203 try { 204 copy = (MessageImpl) ((MessageImpl) message).clone(); 205 copied.addElement(copy); 206 } catch (CloneNotSupportedException exception) { 207 JMSException error = new JMSException(exception.getMessage()); 208 error.setLinkedException(exception); 209 throw error; 210 } 211 } 212 } 213 214 return copied; 215 } 216 217 // implementation of JmsSessionStubIfc.createQueue 218 public void createQueue(JmsQueue queue) throws JMSException { 219 _delegate.createQueue(queue); 220 } 221 222 // implementation of JmsSessionStubIfc.createTopic 223 public void createTopic(JmsTopic topic) throws JMSException { 224 _delegate.createTopic(topic); 225 } 226 227 // implementation of JmsSessionStubIfc.createReceiver 228 public void createReceiver(JmsQueue queue, long clientId, String selector) 229 throws JMSException { 230 _delegate.createReceiver(queue, clientId, selector); 231 } 232 233 // implementation of JmsSessionStubIfc.createSender 234 public void createSender(JmsQueue queue) throws JMSException { 235 _delegate.createSender(queue); 236 } 237 238 // implementation of JmsSessionStubIfc.createBrowser 239 public void createBrowser(JmsQueue queue, long clientId, String selector) 240 throws JMSException { 241 _delegate.createBrowser(queue, clientId, selector); 242 } 243 244 // implementation of JmsSessionStubIfc.deleteReceiver 245 public void deleteReceiver(long clientId) throws JMSException { 246 _delegate.deleteReceiver(clientId); 247 } 248 249 // implementation of JmsSessionStubIfc.deleteBrowser 250 public void deleteBrowser(long clientId) throws JMSException { 251 _delegate.deleteBrowser(clientId); 252 } 253 254 // implementation of JmsSessionStubIfc.createSubscriber 255 public void createSubscriber(JmsTopic topic, String name, long clientId, 256 String selector, boolean noLocal) 257 throws JMSException { 258 _delegate.createSubscriber(topic, name, clientId, selector, noLocal); 259 } 260 261 // implementation of JmsSessionStubIfc.createPublisher 262 public void createPublisher(JmsTopic topic) throws JMSException { 263 _delegate.createPublisher(topic); 264 } 265 266 // implementation of JmsSessionStubIfc.deleteSubscriber 267 public void deleteSubscriber(long clientId) throws JMSException { 268 _delegate.deleteSubscriber(clientId); 269 } 270 271 // implementation of JmsSessionStubIfc.unsubscribe 272 public void unsubscribe(String name) throws JMSException { 273 _delegate.unsubscribe(name); 274 } 275 276 // implementation of JmsSessionStubIfc.stopMessageDelivery 277 public void stopMessageDelivery() throws JMSException { 278 _delegate.stopMessageDelivery(); 279 } 280 281 // implementation of JmsSessionStubIfc.startMessageDelivery 282 public void startMessageDelivery() throws JMSException { 283 _delegate.startMessageDelivery(); 284 } 285 286 // implementation of JmsSessionStubIfc.setMessageListener 287 public void setMessageListener(JmsMessageListener listener) { 288 _listener = listener; 289 } 290 291 // implementation of JmsSessionStubIfc.enableAsynchronousDelivery 292 public void enableAsynchronousDelivery(long clientId, String id, 293 boolean enable) 294 throws JMSException { 295 _delegate.enableAsynchronousDelivery(clientId, id, enable); 296 } 297 298 // implementation of JmsSessionStubIfc.recover 299 public void recover() throws JMSException { 300 _delegate.recover(); 301 } 302 303 // implementation of JmsSessionStubIfc.commit 304 public void commit() throws JMSException { 305 _delegate.commit(); 306 } 307 308 // implementation of JmsSessionStubIfc.rollback 309 public void rollback() throws JMSException { 310 _delegate.rollback(); 311 } 312 313 // implementation of JmsSessionStubIfc.commit 314 public void commit(Xid xid, boolean onePhase) 315 throws XAException { 316 _delegate.commit(xid, onePhase); 317 } 318 319 // implementation of JmsSessionStubIfc.end 320 public void end(Xid xid, int flags) 321 throws XAException { 322 _delegate.end(xid, flags); 323 } 324 325 // implementation of JmsSessionStubIfc.forget 326 public void forget(Xid xid) 327 throws XAException { 328 _delegate.forget(xid); 329 } 330 331 // implementation of JmsSessionStubIfc.getResourceManagerId 332 public String getResourceManagerId() throws XAException { 333 return _delegate.getResourceManagerId(); 334 } 335 336 // implementation of JmsSessionStubIfc.getTransactionTimeout 337 public int getTransactionTimeout() 338 throws XAException { 339 return _delegate.getTransactionTimeout(); 340 } 341 342 // implementation of JmsSessionStubIfc.prepare 343 public int prepare(Xid xid) 344 throws XAException { 345 return _delegate.prepare(xid); 346 } 347 348 // implementation of JmsSessionStubIfc.recover 349 public Xid[] recover(int flag) 350 throws XAException { 351 return _delegate.recover(flag); 352 } 353 354 // implementation of JmsSessionStubIfc.rollback 355 public void rollback(Xid xid) 356 throws XAException { 357 _delegate.rollback(xid); 358 } 359 360 // implementation of JmsSessionStubIfc.setTransactionTimeout 361 public boolean setTransactionTimeout(int seconds) 362 throws XAException { 363 return _delegate.setTransactionTimeout(seconds); 364 } 365 366 // implementation of JmsSessionStubIfc.start 367 public void start(Xid xid, int flags) 368 throws XAException { 369 _delegate.start(xid, flags); 370 } 371 372 // implementation of JmsMessageListener.onMessage 373 public void onMessage(Message message) { 374 // As the server resides in the same VM as the client, the message 375 // must be copied to allow the client to modify it after it is 376 // received. 377 if (message != null) { 378 // ignore null messages generated by 379 // JmsServerSession.isClientEndpointActive() 380 Message copy = null; 381 try { 382 copy = (Message) ((MessageImpl) message).clone(); 383 } catch (CloneNotSupportedException exception) { 384 _log.error(exception); 385 } 386 _listener.onMessage(copy); 387 } 388 } 389 390 // implementation of JmsMessageListener.onMessages 391 public void onMessages(Vector messages) { 392 // As the server resides in the same VM as the client, the messages 393 // must be copied to allow the client to modify them after they are 394 // received. 395 Vector copy = new Vector(); 396 try { 397 Iterator iter = messages.iterator(); 398 while (iter.hasNext()) { 399 MessageImpl message = (MessageImpl) iter.next(); 400 copy.add(message.clone()); 401 } 402 } catch (CloneNotSupportedException exception) { 403 _log.error(exception); 404 } 405 _listener.onMessages(copy); 406 } 407 408 // implementation of JmsMessageListener.onMessageAvailable 409 public void onMessageAvailable(long clientId) { 410 _listener.onMessageAvailable(clientId); 411 } 412 413 } //-- IntravmJmsSessionStub

This page was automatically generated by Maven