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: RmiJmsSessionStub.java,v 1.28 2003/08/07 13:32:55 tanderson Exp $ 44 * 45 * Date Author Changes 46 * 04/18/2000 jima Created 47 */ 48 package org.exolab.jms.client.rmi; 49 50 51 import java.rmi.RemoteException; 52 import java.rmi.server.UnicastRemoteObject; 53 import java.util.Vector; 54 55 import javax.jms.JMSException; 56 import javax.jms.Message; 57 import javax.transaction.xa.XAException; 58 import javax.transaction.xa.XAResource; 59 import javax.transaction.xa.Xid; 60 61 import org.exolab.jms.client.JmsMessageListener; 62 import org.exolab.jms.client.JmsQueue; 63 import org.exolab.jms.client.JmsSessionStubIfc; 64 import org.exolab.jms.client.JmsTopic; 65 import org.exolab.jms.server.rmi.RemoteJmsServerSessionIfc; 66 67 68 /*** 69 * This class is repsonsible for managing a reference to a remote session 70 * object in additon to registering itself as an object, with the RMI 71 * registry. This object is called back by the JMS Server when it has messages 72 * for it. 73 * <p> 74 * The act that it extends UnicastRemoteObject means that it is a server as 75 * well as a client to other RMI objects 76 * 77 * @version $Revision: 1.28 $ $Date: 2003/08/07 13:32:55 $ 78 * @author <a href="mailto:jima@exoffice.com">Jim Alateras</a> 79 **/ 80 public class RmiJmsSessionStub 81 extends UnicastRemoteObject 82 implements JmsSessionStubIfc, RemoteJmsMessageListenerIfc { 83 84 /*** 85 * This is the message listener for JMS messages. The MessageListener is 86 * then responsible for delivering it to the actual consumer. The listener 87 * is initialised during object construction time 88 */ 89 private JmsMessageListener _listener = null; 90 91 /*** 92 * This is a remote reference to the session which is initialised at object 93 * construction time. 94 */ 95 private RemoteJmsServerSessionIfc _delegate = null; 96 97 98 /*** 99 * Instantiate an instance of this class using the specified session stub. 100 * It must then, immediately following, make a call to set the message 101 * listener for this session 102 * 103 * @param RmiJmsServerSession 104 * @throws JMSException 105 * @throws RemoteException 106 */ 107 protected RmiJmsSessionStub(RemoteJmsServerSessionIfc session) 108 throws JMSException, RemoteException { 109 if (session != null) { 110 _delegate = session; 111 } else { 112 throw new JMSException( 113 "Cannot create session stub with a null session"); 114 } 115 } 116 117 // implementation of JmsSessionStubIfc.getClientId 118 public String getClientId() throws JMSException { 119 try { 120 return _delegate.getClientId(); 121 } catch (RemoteException exception) { 122 // rethrow as a JMSException 123 throw new JMSException("Failed to getClientId " + exception); 124 } 125 } 126 127 // implementation of JmsSessionStubIfc.getSessionId 128 public String getSessionId() throws JMSException { 129 try { 130 return _delegate.getSessionId(); 131 } catch (RemoteException exception) { 132 // rethrow as a JMSException 133 throw new JMSException("Failed to getSessionId " + exception); 134 } 135 } 136 137 // implementation of JmsSessionStubIfc.beforeClose 138 public void beforeClose() throws JMSException { 139 } 140 141 // implementation of JmsSessionStubIfc.close 142 public void close() throws JMSException { 143 try { 144 _delegate.close(); 145 UnicastRemoteObject.unexportObject(this, true); 146 _delegate = null; 147 _listener = null; 148 // todo. Jimbo to sort these out. 149 // _delegate = null; 150 // _listener = null; 151 } catch (RemoteException exception) { 152 // rethrow as a JMSException 153 throw new JMSException("Failed to close " + exception); 154 } 155 } 156 157 // implementation of JmsSessionStubIfc.acknowledgeMessage 158 public void acknowledgeMessage(long clientId, String messageId) 159 throws JMSException { 160 try { 161 // Send back the ack to the consumer endpoint that forwarded the 162 // message. 163 _delegate.acknowledgeMessage(clientId, messageId); 164 } catch (RemoteException exception) { 165 // rethrow as a JMSException 166 throw new JMSException("Failed to acknowledgeMessage " + 167 exception); 168 } 169 } 170 171 // implementation of JmsSessionStubIfc.sendMessage 172 public void sendMessage(Message message) throws JMSException { 173 try { 174 _delegate.sendMessage(message); 175 } catch (RemoteException exception) { 176 // rethrow as a JMSException 177 throw new JMSException("Failed to sendMessage " + exception); 178 } 179 } 180 181 // implementation of JmsSessionStubIfc.sendMessages 182 public void sendMessages(Vector messages) throws JMSException { 183 try { 184 _delegate.sendMessages(messages); 185 } catch (RemoteException exception) { 186 // rethrow as a JMSException 187 exception.printStackTrace(); 188 throw new JMSException("Failed to sendMessages " + exception); 189 } 190 } 191 192 // implementation of JmsSessionStubIfc.sendMessage 193 public Message receiveMessage(long clientId, long wait) 194 throws JMSException { 195 try { 196 return _delegate.receiveMessage(clientId, wait); 197 } catch (RemoteException exception) { 198 // rethrow the JMSException 199 throw new JMSException("Failed to receiveMessage " + exception); 200 } 201 } 202 203 // implementation of JmsSessionStubIfc.receiveMessages 204 public Vector receiveMessages(long clientId, int count) 205 throws JMSException { 206 try { 207 return _delegate.receiveMessages(clientId, count); 208 } catch (RemoteException exception) { 209 // rethrow the JMSException 210 throw new JMSException("Failed to receiveMessages " + exception); 211 } 212 } 213 214 // implementation of JmsSessionStubIfc.createQueue 215 public void createQueue(JmsQueue queue) throws JMSException { 216 try { 217 _delegate.createQueue(queue); 218 } catch (RemoteException exception) { 219 // rethrow as a JMSException 220 throw new JMSException("Failed to createQueue " + exception); 221 } 222 } 223 224 // implementation of JmsSessionStubIfc.createTopic 225 public void createTopic(JmsTopic topic) throws JMSException { 226 try { 227 _delegate.createTopic(topic); 228 } catch (RemoteException exception) { 229 // rethrow as a JMSException 230 throw new JMSException("Failed to createTopic " + exception); 231 } 232 } 233 234 // implementation of JmsSessionStubIfc.createReceiver 235 public void createReceiver(JmsQueue queue, long clientId, String selector) 236 throws JMSException { 237 try { 238 _delegate.createReceiver(queue, clientId, selector); 239 } catch (RemoteException exception) { 240 // rethrow as a JMSException 241 throw new JMSException("Failed to createReceiver " + exception); 242 } 243 } 244 245 // implementation of JmsSessionStubIfc.createSender 246 public void createSender(JmsQueue queue) throws JMSException { 247 try { 248 _delegate.createSender(queue); 249 } catch (RemoteException exception) { 250 // rethrow as a JMSException 251 throw new JMSException("Failed to createReceiver " + exception); 252 } 253 } 254 255 // implementation of JmsSessionStubIfc.createBrowser 256 public void createBrowser(JmsQueue queue, long clientId, String selector) 257 throws JMSException { 258 try { 259 _delegate.createBrowser(queue, clientId, selector); 260 } catch (RemoteException exception) { 261 // rethrow as a JMSException 262 throw new JMSException("Failed to createBrowser " + exception); 263 } 264 } 265 266 // implementation of JmsSessionStubIfc.deleteReceiver 267 public void deleteReceiver(long clientId) throws JMSException { 268 try { 269 _delegate.deleteReceiver(clientId); 270 } catch (RemoteException exception) { 271 // rethrow as a JMSException 272 throw new JMSException("Failed to deleteReceiver " + exception); 273 } 274 } 275 276 // implementation of JmsSessionStubIfc.deleteSender 277 public void deleteSender(long clientId) throws JMSException { 278 try { 279 _delegate.deleteSender(clientId); 280 } catch (RemoteException exception) { 281 // rethrow as a JMSException 282 throw new JMSException("Failed to deleteSender " + exception); 283 } 284 } 285 286 // implementation of JmsSessionStubIfc.deleteBrowser 287 public void deleteBrowser(long clientId) throws JMSException { 288 try { 289 _delegate.deleteBrowser(clientId); 290 } catch (RemoteException exception) { 291 // rethrow as a JMSException 292 throw new JMSException("Failed to deleteBrowser " + exception); 293 } 294 } 295 296 // implementation of JmsSessionStubIfc.createSubscriber 297 public void createSubscriber(JmsTopic topic, String name, long clientId, 298 String selector, boolean noLocal) throws JMSException { 299 try { 300 _delegate.createSubscriber(topic, name, clientId, selector, 301 noLocal); 302 } catch (RemoteException exception) { 303 // rethrow as a JMSException 304 throw new JMSException("Failed to createSubscriber " + exception); 305 } 306 } 307 308 // implementation of JmsSessionStubIfc.createPublisher 309 public void createPublisher(JmsTopic topic) throws JMSException { 310 try { 311 _delegate.createPublisher(topic); 312 } catch (RemoteException exception) { 313 // rethrow as a JMSException 314 throw new JMSException("Failed to createPublisher " + exception); 315 } 316 } 317 318 // implementation of JmsSessionStubIfc.deleteSubscriber 319 public void deleteSubscriber(long clientId) throws JMSException { 320 try { 321 _delegate.deleteSubscriber(clientId); 322 } catch (RemoteException exception) { 323 // rethrow as a JMSException 324 throw new JMSException("Failed to deleteSubscriber " + exception); 325 } 326 } 327 328 // implementation of JmsSessionStubIfc.deletePublisher 329 public void deletePublisher(JmsTopic topic) throws JMSException { 330 try { 331 _delegate.deletePublisher(topic); 332 } catch (RemoteException exception) { 333 // rethrow as a JMSException 334 throw new JMSException("Failed to deletePublisher " + exception); 335 } 336 } 337 338 // implementation of JmsSessionStubIfc.unsubscribe 339 public void unsubscribe(String name) throws JMSException { 340 try { 341 _delegate.unsubscribe(name); 342 } catch (RemoteException exception) { 343 // rethrow as a JMSException 344 throw new JMSException("Failed to unsubscribe " + exception); 345 } 346 } 347 348 // implementation of JmsSessionStubIfc.stopMessageDelivery 349 public void stopMessageDelivery() throws JMSException { 350 try { 351 _delegate.stopMessageDelivery(); 352 } catch (RemoteException exception) { 353 // rethrow as a JMSException 354 throw new JMSException("Failed to stopMessageDelivery " + 355 exception); 356 } 357 } 358 359 // implementation of JmsSessionStubIfc.startMessageDelivery 360 public void startMessageDelivery() throws JMSException { 361 try { 362 _delegate.startMessageDelivery(); 363 } catch (RemoteException exception) { 364 // rethrow as a JMSException 365 throw new JMSException("Failed to startMessageDelivery " + 366 exception); 367 } 368 } 369 370 // implementation of JmsSessionStubIfc.setMessageListener 371 public void setMessageListener(JmsMessageListener listener) { 372 _listener = listener; 373 } 374 375 // implementation of JmsSessionStubIfc.enableAsynchronousDelivery 376 public void enableAsynchronousDelivery(long clientId, String id, 377 boolean enable) 378 throws JMSException { 379 try { 380 _delegate.enableAsynchronousDelivery(clientId, id, enable); 381 } catch (RemoteException exception) { 382 // rethrow as a JMSException 383 throw new JMSException("Failed to enableAsynchronousDelivery " + 384 exception); 385 } 386 } 387 388 // implementation of JmsSessionStubIfc.recover 389 public void recover() throws JMSException { 390 try { 391 _delegate.recover(); 392 } catch (RemoteException exception) { 393 // rethrow as a JMSException 394 throw new JMSException("Failed to recover session " + 395 exception); 396 } 397 } 398 399 // implementation of JmsSessionStubIfc.commit 400 public void commit() throws JMSException { 401 try { 402 _delegate.commit(); 403 } catch (RemoteException exception) { 404 // rethrow as a JMSException 405 throw new JMSException("Failed to commit session " + 406 exception); 407 } 408 } 409 410 // implementation of JmsSessionStubIfc.rollback 411 public void rollback() throws JMSException { 412 try { 413 _delegate.rollback(); 414 } catch (RemoteException exception) { 415 // rethrow as a JMSException 416 throw new JMSException("Failed to rollback session " + 417 exception); 418 } 419 } 420 421 // implementation of JmsSessionStubIfc.commit 422 public void commit(Xid xid, boolean onePhase) throws XAException { 423 try { 424 _delegate.commit(xid, onePhase); 425 } catch (RemoteException exception) { 426 // rethrow as a XAException 427 throw new XAException("Failed to commit session " + 428 exception); 429 } 430 } 431 432 // implementation of JmsSessionStubIfc.end 433 public void end(Xid xid, int flags) throws XAException { 434 try { 435 _delegate.end(xid, flags); 436 } catch (RemoteException exception) { 437 // rethrow as a XAException 438 throw new XAException("Failed to end session " + 439 exception); 440 } 441 } 442 443 // implementation of JmsSessionStubIfc.forget 444 public void forget(Xid xid) throws XAException { 445 try { 446 _delegate.forget(xid); 447 } catch (RemoteException exception) { 448 // rethrow as a XAException 449 throw new XAException("Failed to forget session " + 450 exception); 451 } 452 } 453 454 // implementation of JmsSessionStubIfc.getResourceManagerId 455 public String getResourceManagerId() throws XAException { 456 try { 457 return _delegate.getResourceManagerId(); 458 } catch (RemoteException exception) { 459 // rethrow as a XAException 460 throw new XAException("Failed to getResourceManagerId " + 461 exception); 462 } 463 } 464 465 // implementation of JmsSessionStubIfc.getTransactionTimeout 466 public int getTransactionTimeout() throws XAException { 467 try { 468 return _delegate.getTransactionTimeout(); 469 } catch (RemoteException exception) { 470 // rethrow as a XAException 471 throw new XAException("Failed to getTransactionTimeout " + 472 exception); 473 } 474 } 475 476 // implementation of JmsSessionStubIfc.prepare 477 public int prepare(Xid xid) throws XAException { 478 try { 479 return _delegate.prepare(xid); 480 } catch (RemoteException exception) { 481 // rethrow as a XAException 482 throw new XAException("Failed to prepare session " + 483 exception); 484 } 485 } 486 487 // implementation of JmsSessionStubIfc.recover 488 public Xid[] recover(int flag) throws XAException { 489 try { 490 return _delegate.recover(flag); 491 } catch (RemoteException exception) { 492 // rethrow as a XAException 493 throw new XAException("Failed to recover session " + 494 exception); 495 } 496 } 497 498 // implementation of JmsSessionStubIfc.rollback 499 public void rollback(Xid xid) throws XAException { 500 try { 501 _delegate.rollback(xid); 502 } catch (RemoteException exception) { 503 // rethrow as a XAException 504 throw new XAException("Failed to rollback session " + 505 exception); 506 } 507 } 508 509 // implementation of JmsSessionStubIfc.setTransactionTimeout 510 public boolean setTransactionTimeout(int seconds) throws XAException { 511 try { 512 return _delegate.setTransactionTimeout(seconds); 513 } catch (RemoteException exception) { 514 // rethrow as a XAException 515 throw new XAException("Failed to setTransactionTimeout " + 516 exception); 517 } 518 } 519 520 // implementation of JmsSessionStubIfc.start 521 public void start(Xid xid, int flags) throws XAException { 522 try { 523 _delegate.start(xid, flags); 524 } catch (RemoteException exception) { 525 // rethrow as a XAException 526 throw new XAException("Failed to start session " + 527 exception); 528 } 529 } 530 531 // implementation of RmiJmsMessageListenerIfc.onMessages 532 public void onMessage(Message message) throws RemoteException { 533 // do not process if the message is null. This is also used by the 534 // server to determine whether the client is still active. 535 if (message == null) { 536 return; 537 } 538 539 _listener.onMessage(message); 540 } 541 542 // implementation of RmiJmsMessageListenerIfc.onMessages 543 public void onMessages(Vector messages) throws RemoteException { 544 _listener.onMessages(messages); 545 } 546 547 // implementation of RmiJmsMessageListenerIfc.onMessageAvailable 548 public void onMessageAvailable(long clientId) throws RemoteException { 549 _listener.onMessageAvailable(clientId); 550 } 551 552 } //-- RmiJmsSessionStub

This page was automatically generated by Maven