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: OfflineConnection.java,v 1.3 2003/08/17 01:32:27 tanderson Exp $ 44 * 45 * Date Author Changes 46 * $Date jimm Created 47 */ 48 49 50 package org.exolab.jms.tools.admin; 51 52 import java.awt.Component; 53 import java.sql.Connection; 54 import java.util.Enumeration; 55 import java.util.Hashtable; 56 57 import javax.naming.Context; 58 import javax.naming.InitialContext; 59 import javax.swing.JFileChooser; 60 import javax.swing.JOptionPane; 61 import javax.transaction.TransactionManager; 62 63 import org.exolab.jms.authentication.User; 64 import org.exolab.jms.client.JmsDestination; 65 import org.exolab.jms.client.JmsQueue; 66 import org.exolab.jms.client.JmsTopic; 67 import org.exolab.jms.config.Configuration; 68 import org.exolab.jms.config.ConfigurationManager; 69 import org.exolab.jms.config.DatabaseConfiguration; 70 import org.exolab.jms.persistence.DatabaseService; 71 import org.exolab.jms.persistence.PersistenceException; 72 73 74 /*** 75 * Connect directly to the Persistent store to retrieve information and perfrom 76 * updates. 77 * 78 * <P> Note: If the OpenJMSServer is active, this connection will fail, since 79 * it requires and exclusive lock on the database to avoid database corruption. 80 * Similarly, if this connection is active the OpenJMSServer cannot be started 81 * for the same reasons. 82 * 83 * @version $Revision: 1.3 $ $Date: 2003/08/17 01:32:27 $ 84 * @author <a href="mailto:mourikis@exolab.org">Jim Mourikis</a> 85 * @see AbstractAdminConnection 86 * @see AdminMgr 87 */ 88 public class OfflineConnection extends AbstractAdminConnection { 89 90 // The parent Gui 91 private Component _parent; 92 93 // The deafult JNDI context. 94 private Context _context = null; 95 96 /*** 97 * Connect to the RMIAdmin Server if in online mode, or open 98 * the database and update the data directly in offline mode. 99 * 100 * @param online Indicates if we are connecting in online or offline mode. 101 * @param parent The component parent. 102 * @throws IllegalStateException if {@link ConfigurationManager} has not 103 * been initialised 104 * @throws OfflineConnectionException When the database cannot be opened 105 */ 106 public OfflineConnection(Component parent) 107 throws OfflineConnectionException { 108 try { 109 if (_instance == null) { 110 _parent = parent; 111 112 Configuration config = ConfigurationManager.getConfig(); 113 114 DatabaseConfiguration dbconfig = 115 config.getDatabaseConfiguration(); 116 117 // determine the database type and instantiate the appropriate 118 // database adapter 119 if (dbconfig.getRdbmsDatabaseConfiguration() != null) { 120 DatabaseService.instance().getAdapter(); 121 _instance = this; 122 } else { 123 JFileChooser chooser = new JFileChooser("."); 124 chooser.setDialogTitle 125 ("Select OpenJMS Database to connect to"); 126 chooser.setFileFilter(new DatabaseFilter()); 127 int returnVal = chooser.showOpenDialog(parent); 128 129 if (returnVal == JFileChooser.APPROVE_OPTION) { 130 DatabaseService.instance().getAdapter(); 131 _instance = this; 132 } 133 } 134 } else { 135 throw new org.exolab.jms.tools.admin.OfflineConnectionException("Already connected"); 136 } 137 } catch (Exception err) { 138 throw new org.exolab.jms.tools.admin.OfflineConnectionException 139 ("Database Error: " + err.getMessage()); 140 } 141 } 142 143 // implementation of AbstractAdminConnection.close 144 public void close() { 145 DatabaseService.getAdapter().close(); 146 _instance = null; 147 } 148 149 // implementation of AbstractAdminConnection.addDurableConsumer 150 public boolean addDurableConsumer(String topic, String name) { 151 boolean result = false; 152 Connection connection = null; 153 154 try { 155 connection = DatabaseService.getConnection(); 156 DatabaseService.getAdapter().addDurableConsumer(connection, topic, 157 name); 158 connection.commit(); 159 result = true; 160 161 } catch (PersistenceException exception) { 162 try { 163 connection.rollback(); 164 } catch (Exception nested) { 165 // ignore 166 } 167 } catch (Exception exception) { 168 // ignore for the moment 169 } finally { 170 if (connection != null) { 171 try { 172 connection.close(); 173 } catch (Exception nested) { 174 // ignore 175 } 176 } 177 } 178 179 return result; 180 } 181 182 // implementation of AbstractAdminConnection.removeDurableConsumer 183 public boolean removeDurableConsumer(String name) { 184 boolean result = false; 185 Connection connection = null; 186 187 try { 188 connection = DatabaseService.getConnection(); 189 190 DatabaseService.getAdapter().removeDurableConsumer(connection, name); 191 connection.commit(); 192 result = true; 193 194 } catch (PersistenceException exception) { 195 try { 196 connection.rollback(); 197 } catch (Exception nested) { 198 // ignore 199 } 200 } catch (Exception exception) { 201 // ignore for the moment 202 } finally { 203 if (connection != null) { 204 try { 205 connection.close(); 206 } catch (Exception nested) { 207 // ignore 208 } 209 } 210 } 211 212 return result; 213 } 214 215 // implementation of AbstractAdminConnection.unregisterConsumer 216 public boolean unregisterConsumer(String name) { 217 return false; 218 } 219 220 // implementation of AbstractAdminConnection.isConnected 221 public boolean isConnected(String name) { 222 return false; 223 } 224 225 // implementation of AbstractAdminConnection.getAllDestinations 226 public Enumeration getAllDestinations() { 227 Enumeration result = null; 228 Connection connection = null; 229 230 try { 231 connection = DatabaseService.getConnection(); 232 233 result = DatabaseService.getAdapter().getAllDestinations( 234 connection); 235 connection.commit(); 236 } catch (PersistenceException exception) { 237 try { 238 connection.rollback(); 239 } catch (Exception nested) { 240 // ignore 241 } 242 } catch (Exception exception) { 243 // ignore for the moment 244 } finally { 245 if (connection != null) { 246 try { 247 connection.close(); 248 } catch (Exception nested) { 249 // ignore 250 } 251 } 252 } 253 254 return result; 255 } 256 257 // implementation of AbstractAdminConnection.addDestination 258 public boolean addDestination(String destination, boolean isQueue) { 259 Connection connection = null; 260 boolean success = false; 261 262 try { 263 connection = DatabaseService.getConnection(); 264 265 DatabaseService.getAdapter().addDestination(connection, 266 destination, isQueue); 267 if (_context == null) { 268 // connect to the JNDI server and get a reference to 269 // root context 270 Hashtable props = new Hashtable(); 271 props.put(Context.INITIAL_CONTEXT_FACTORY, 272 "org.exolab.jms.jndi.intravm.IntravmJndiServer"); 273 _context = new InitialContext(props); 274 } 275 276 Object ob = (isQueue ? (Object) (new JmsQueue(destination)) : 277 (Object) (new JmsTopic(destination))); 278 279 if (ob instanceof JmsQueue) { 280 ((JmsDestination) ob).setPersistent(true); 281 } 282 283 _context.rebind(destination, ob); 284 connection.commit(); 285 success = true; 286 } catch (PersistenceException exception) { 287 System.err.println("Failed to add destination " + destination + 288 " b/c " + exception.toString()); 289 try { 290 connection.rollback(); 291 } catch (Exception nested) { 292 // ignore 293 } 294 } catch (javax.naming.NamingException err) { 295 System.err.println("Failed to add " + destination + 296 " in JNDI context"); 297 try { 298 connection.rollback(); 299 } catch (Exception nested) { 300 // ignore 301 } 302 } catch (Exception exception) { 303 // ignore for the moment 304 } finally { 305 if (connection != null) { 306 try { 307 connection.close(); 308 } catch (Exception nested) { 309 // ignore 310 } 311 } 312 } 313 314 return success; 315 } 316 317 // implementation of AbstractAdminConnection.getDurableConsumerMessageCount 318 public int getDurableConsumerMessageCount(String topic, String name) { 319 int count = -1; 320 Connection connection = null; 321 322 try { 323 connection = DatabaseService.getConnection(); 324 325 count = DatabaseService.getAdapter().getDurableConsumerMessageCount( 326 connection, topic, name); 327 connection.commit(); 328 } catch (PersistenceException exception) { 329 System.err.println("Failed to get message count for " + topic + 330 " b/c " + exception.toString()); 331 try { 332 connection.rollback(); 333 } catch (Exception nested) { 334 // ignore 335 } 336 } catch (Exception exception) { 337 // ignore for the moment 338 } finally { 339 if (connection != null) { 340 try { 341 connection.close(); 342 } catch (Exception nested) { 343 // ignore 344 } 345 } 346 } 347 348 return count; 349 } 350 351 // implementation of AbstractAdminConnection.getQueueMessageCount 352 public int getQueueMessageCount(String queue) { 353 int count = -1; 354 Connection connection = null; 355 356 try { 357 connection = DatabaseService.getConnection(); 358 359 count = DatabaseService.getAdapter().getQueueMessageCount( 360 connection, queue); 361 connection.commit(); 362 } catch (PersistenceException exception) { 363 System.err.println("Failed to get message count for " + queue + 364 " b/c " + exception.toString()); 365 try { 366 connection.rollback(); 367 } catch (Exception nested) { 368 // ignore 369 } 370 } catch (Exception exception) { 371 // ignore for the moment 372 } finally { 373 if (connection != null) { 374 try { 375 connection.close(); 376 } catch (Exception nested) { 377 // ignore 378 } 379 } 380 } 381 382 return count; 383 } 384 385 // implementation of AbstractAdminConnection.durableConsumerExists 386 public boolean durableConsumerExists(String name) { 387 boolean result = false; 388 Connection connection = null; 389 390 try { 391 connection = DatabaseService.getConnection(); 392 393 result = DatabaseService.getAdapter().durableConsumerExists( 394 connection, name); 395 connection.commit(); 396 } catch (PersistenceException exception) { 397 System.err.println("Failed on consumer exists for " + name + 398 " b/c " + exception.toString()); 399 try { 400 connection.rollback(); 401 } catch (Exception nested) { 402 // ignore 403 } 404 } catch (Exception exception) { 405 // ignore for the moment 406 } finally { 407 if (connection != null) { 408 try { 409 connection.close(); 410 } catch (Exception nested) { 411 // ignore 412 } 413 } 414 } 415 416 return result; 417 } 418 419 // implementation of AbstractAdminConnection.getDurableConsumers 420 public Enumeration getDurableConsumers(String topic) { 421 Enumeration result = null; 422 Connection connection = null; 423 424 try { 425 connection = DatabaseService.getConnection(); 426 427 result = DatabaseService.getAdapter().getDurableConsumers( 428 connection, topic); 429 connection.commit(); 430 } catch (PersistenceException exception) { 431 System.err.println("Failed on getDurableConsumers for " + topic + 432 " b/c " + exception.toString()); 433 try { 434 connection.rollback(); 435 } catch (Exception nested) { 436 // ignore 437 } 438 } catch (Exception exception) { 439 // ignore for the moment 440 } finally { 441 if (connection != null) { 442 try { 443 connection.close(); 444 } catch (Exception nested) { 445 // ignore 446 } 447 } 448 } 449 450 return result; 451 } 452 453 // implementation of AbstractAdminConnection.removeDestination 454 public boolean removeDestination(String destination) { 455 boolean result = false; 456 Connection connection = null; 457 458 try { 459 connection = DatabaseService.getConnection(); 460 461 DatabaseService.getAdapter().removeDestination(connection, 462 destination); 463 if (_context == null) { 464 // connect to the JNDI server and get a reference to 465 // root context 466 Hashtable props = new Hashtable(); 467 props.put(Context.INITIAL_CONTEXT_FACTORY, 468 "org.exolab.jms.jndi.intravm.IntravmJndiServer"); 469 _context = new InitialContext(props); 470 } 471 _context.unbind(destination); 472 connection.commit(); 473 result = true; 474 } catch (PersistenceException exception) { 475 System.err.println("Failed on getDurableConsumers for " + 476 destination + " b/c " + exception.toString()); 477 try { 478 connection.rollback(); 479 } catch (Exception nested) { 480 // ignore 481 } 482 } catch (javax.naming.NamingException err) { 483 System.err.println("Failed to removeDestination " + destination + 484 " b/c" + err.toString()); 485 try { 486 connection.rollback(); 487 } catch (Exception nested) { 488 // ignore 489 } 490 } catch (Exception exception) { 491 // ignore for the moment 492 } finally { 493 if (connection != null) { 494 try { 495 connection.close(); 496 } catch (Exception nested) { 497 // ignore 498 } 499 } 500 } 501 502 return result; 503 } 504 505 // implementation of AbstractAdminConnection.purgeMessages 506 public int purgeMessages() { 507 return DatabaseService.getAdapter().purgeMessages(); 508 } 509 510 // implementation of AbstractAdminConnection.stopServer 511 public void stopServer() { 512 JOptionPane.showMessageDialog 513 (_parent, "Not available in offline mode", 514 "Shutdown Error", JOptionPane.ERROR_MESSAGE); 515 } 516 517 // implementation of AbstractAdminConnection.addUser 518 public boolean addUser(String username, String password) { 519 Connection connection = null; 520 boolean success = false; 521 522 try { 523 connection = DatabaseService.getConnection(); 524 525 DatabaseService.getAdapter().addUser(connection, 526 new User(username, password)); 527 connection.commit(); 528 success = true; 529 } catch (PersistenceException exception) { 530 System.err.println("Failed to add user " + username + 531 exception.toString()); 532 try { 533 connection.rollback(); 534 } catch (Exception nested) { 535 // ignore 536 } 537 } catch (Exception exception) { 538 // ignore for the moment 539 } finally { 540 if (connection != null) { 541 try { 542 connection.close(); 543 } catch (Exception nested) { 544 // ignore 545 } 546 } 547 } 548 549 return success; 550 } 551 552 // implementation of AbstractAdminConnection.changePassord 553 public boolean changePassword(String username, String password) { 554 Connection connection = null; 555 boolean success = false; 556 557 try { 558 connection = DatabaseService.getConnection(); 559 560 DatabaseService.getAdapter().updateUser(connection, 561 new User(username, password)); 562 connection.commit(); 563 success = true; 564 } catch (PersistenceException exception) { 565 System.err.println("Failed to add user " + username + 566 exception.toString()); 567 try { 568 connection.rollback(); 569 } catch (Exception nested) { 570 // ignore 571 } 572 } catch (Exception exception) { 573 // ignore for the moment 574 } finally { 575 if (connection != null) { 576 try { 577 connection.close(); 578 } catch (Exception nested) { 579 // ignore 580 } 581 } 582 } 583 584 return success; 585 } 586 587 // implementation of AbstractAdminConnection.removeUser 588 public boolean removeUser(String username) { 589 boolean result = false; 590 Connection connection = null; 591 592 try { 593 connection = DatabaseService.getConnection(); 594 595 DatabaseService.getAdapter().removeUser(connection, 596 new User(username, null)); 597 connection.commit(); 598 result = true; 599 } catch (PersistenceException exception) { 600 System.err.println("Failed on remove user for " + 601 username + exception.toString()); 602 try { 603 connection.rollback(); 604 } catch (Exception nested) { 605 // ignore 606 } 607 } catch (Exception exception) { 608 // ignore for the moment 609 } finally { 610 if (connection != null) { 611 try { 612 connection.close(); 613 } catch (Exception nested) { 614 // ignore 615 } 616 } 617 } 618 619 return result; 620 } 621 622 // implementation of AbstractAdminConnection.getAllUsers 623 public Enumeration getAllUsers() { 624 Enumeration result = null; 625 Connection connection = null; 626 627 try { 628 connection = DatabaseService.getConnection(); 629 630 result = DatabaseService.getAdapter().getAllUsers( 631 connection); 632 connection.commit(); 633 } catch (PersistenceException exception) { 634 System.err.println("Failed on getAllUsers " 635 + exception.toString()); 636 try { 637 connection.rollback(); 638 } catch (Exception nested) { 639 // ignore 640 } 641 } catch (Exception exception) { 642 // ignore for the moment 643 } finally { 644 if (connection != null) { 645 try { 646 connection.close(); 647 } catch (Exception nested) { 648 // ignore 649 } 650 } 651 } 652 653 return result; 654 } 655 } //-- OfflineConnection

This page was automatically generated by Maven