1 19 20 package com.sslexplorer.webforwards; 21 22 import java.io.File ; 23 import java.io.Serializable ; 24 import java.sql.ResultSet ; 25 import java.sql.Timestamp ; 26 import java.util.ArrayList ; 27 import java.util.Calendar ; 28 import java.util.List ; 29 import java.util.StringTokenizer ; 30 31 import org.apache.commons.cache.Cache; 32 import org.apache.commons.cache.MemoryStash; 33 import org.apache.commons.cache.SimpleCache; 34 import org.apache.commons.logging.Log; 35 import org.apache.commons.logging.LogFactory; 36 37 import com.maverick.http.HttpAuthenticatorFactory; 38 import com.sslexplorer.boot.ContextHolder; 39 import com.sslexplorer.boot.PropertyList; 40 import com.sslexplorer.boot.Util; 41 import com.sslexplorer.core.CoreEvent; 42 import com.sslexplorer.core.CoreListener; 43 import com.sslexplorer.core.CoreServlet; 44 import com.sslexplorer.extensions.store.ExtensionStore; 45 import com.sslexplorer.extensions.types.PluginDefinition; 46 import com.sslexplorer.jdbc.DBUpgrader; 47 import com.sslexplorer.jdbc.JDBCDatabaseEngine; 48 import com.sslexplorer.jdbc.JDBCPreparedStatement; 49 import com.sslexplorer.replacementproxy.DefaultReplacement; 50 import com.sslexplorer.replacementproxy.Replacement; 51 import com.sslexplorer.security.User; 52 53 60 public class JDBCWebForwardDatabase implements WebForwardDatabase, CoreListener { 61 private static final Log log = LogFactory.getLog(JDBCWebForwardDatabase.class); 62 63 private JDBCDatabaseEngine db; 64 private Cache replacementsCache; 65 66 69 public JDBCWebForwardDatabase() { 70 int maxObjects = 1000; 71 try { 72 maxObjects = Integer.parseInt(System.getProperty("sslexplorer.jdbcSystemDatabase.replacementsCache", "10000")); 73 } catch (Exception e) { 74 } 75 replacementsCache = new SimpleCache(new MemoryStash(maxObjects)); 76 } 77 78 83 public void close() throws Exception { 84 } 85 86 91 public void open(CoreServlet controllingServlet) throws Exception { 92 throw new Exception ("Plugin databases need a PluginDefinition."); 93 } 94 95 100 public void cleanup() throws Exception { 101 } 102 103 108 public void coreEvent(CoreEvent evt) { 109 } 124 125 131 public WebForward getReverseProxyWebForward(User user, String pathInContext) throws Exception { 132 JDBCPreparedStatement ps = db.getStatement("getReverseProxyWebForward.select"); 133 ps.setString(1, ""); 134 ps.setString(2, user == null ? "" : user.getPrincipalName()); 135 ps.setString(3, pathInContext); 136 137 try { 138 ResultSet rs = ps.executeQuery(); 139 try { 140 if (rs.next()) { 141 return getWebForward(rs.getInt("webforward_id")); 142 } 143 } finally { 144 if (rs != null) { 145 rs.close(); 146 } 147 } 148 } finally { 149 ps.releasePreparedStatement(); 150 } 151 return null; 152 } 153 154 159 public WebForward getWebForward(int id) throws Exception { 160 JDBCPreparedStatement ps = db.getStatement("getWebForward.selectById"); 161 ps.setInt(1, id); 162 try { 163 ResultSet rs = ps.executeQuery(); 164 try { 165 if (rs.next()) { 166 return buildWebForward(rs); 167 } 168 } finally { 169 rs.close(); 170 } 171 } finally { 172 ps.releasePreparedStatement(); 173 } 174 return null; 175 } 176 177 182 public List <WebForward> getWebForwards(int realmID) throws Exception { 183 JDBCPreparedStatement ps = null; 184 ps = db.getStatement("getWebForwards.realm.select"); 185 ps.setInt(1, realmID); 186 try { 187 ResultSet rs = ps.executeQuery(); 188 try { 189 List <WebForward> v = new ArrayList <WebForward>(); 190 while (rs.next()) { 191 v.add(buildWebForward(rs)); 192 } 193 return v; 194 } finally { 195 if (rs != null) { 196 rs.close(); 197 } 198 } 199 } finally { 200 ps.releasePreparedStatement(); 201 } 202 } 203 204 209 public List <WebForward> getWebForwards() throws Exception { 210 JDBCPreparedStatement ps = db.getStatement("getWebForwards.select.allTypes"); 211 try { 212 ResultSet rs = ps.executeQuery(); 213 try { 214 List <WebForward> v = new ArrayList <WebForward>(); 215 while (rs.next()) { 216 v.add(buildWebForward(rs)); 217 } 218 return v; 219 } finally { 220 if (rs != null) { 221 rs.close(); 222 } 223 } 224 } finally { 225 ps.releasePreparedStatement(); 226 } 227 } 228 229 232 public WebForward getWebForward(String name, int realmID) throws Exception { 233 JDBCPreparedStatement ps = null; 234 try { 235 ps = db.getStatement("getWebForward.select.name"); 236 ps.setString(1, name); 237 ps.setInt(2, realmID); 238 ResultSet rs = ps.executeQuery(); 239 try { 240 if (rs.next()) { 241 return buildWebForward(rs); 242 } 243 } finally { 244 rs.close(); 245 } 246 } finally { 247 ps.releasePreparedStatement(); 248 } 249 return null; 250 } 251 252 257 public boolean reverseProxyPathExists(String path) throws Exception { 258 JDBCPreparedStatement ps = null; 259 try { 260 ps = db.getStatement("createWebForward.reverseProxy.path.exists"); 261 ps.setString(1, path); 262 ResultSet rs = ps.executeQuery(); 263 try { 264 if (rs.next()) { 265 return true; 266 } else { 267 return false; 268 } 269 } finally { 270 rs.close(); 271 } 272 } finally { 273 ps.releasePreparedStatement(); 274 } 275 } 276 277 283 public boolean reverseProxyPathExists(String path, int webforward_id) throws Exception { 284 JDBCPreparedStatement ps = null; 285 try { 286 ps = db.getStatement("createWebForward.reverseProxy.path.already.exists"); 287 ps.setString(1, path); 288 ps.setInt(2, webforward_id); 289 ResultSet rs = ps.executeQuery(); 290 try { 291 if (rs.next()) { 292 return true; 293 } else { 294 return false; 295 } 296 } finally { 297 rs.close(); 298 } 299 } finally { 300 ps.releasePreparedStatement(); 301 } 302 } 303 304 309 public WebForward createWebForward(WebForward webForward) throws Exception { 310 JDBCPreparedStatement ps = db.getStatement("createWebForward.insert"); 311 312 317 ps.startTransaction(); 318 319 try { 320 int id = -1; 321 ps.setString(1, webForward.getDestinationURL()); 322 ps.setInt(2, webForward.getType()); 323 ps.setString(3, webForward.getResourceName()); 324 ps.setString(4, webForward.getResourceDescription()); 325 ps.setString(5, webForward.getCategory()); 326 Calendar now = Calendar.getInstance(); 327 ps.setString(6, db.formatTimestamp(now)); 328 ps.setString(7, db.formatTimestamp(now)); 329 ps.setInt(8, webForward.getRealmID()); 330 ps.execute(); 331 webForward.setResourceId(id = db.getLastInsertId(ps, "createWebForward.lastInsertId")); 332 333 if (webForward instanceof ReverseProxyWebForward) { 334 ps = db.getStatement(ps, "createWebForward.reverseProxy.insert"); 335 StringTokenizer t = new StringTokenizer (((ReverseProxyWebForward) webForward).getPaths(), "\n\r"); 336 while (t.hasMoreTokens()) { 337 String path = t.nextToken(); 338 ps.setString(1, path); 339 ps.setInt(2, id); 340 ps.execute(); 341 ps.reset(); 342 } 343 ps = db.getStatement(ps, "createWebForward.reverseProxyOptions.insert"); 344 ps.setInt(1, webForward.getResourceId()); 345 ps.setString(2, ((ReverseProxyWebForward) webForward).getAuthenticationUsername()); 346 ps.setString(3, Util.emptyWhenNull(((ReverseProxyWebForward) webForward).getAuthenticationPassword())); 347 ps.setString(4, ((ReverseProxyWebForward) webForward).getPreferredAuthenticationScheme()); 348 ps.setInt(5, ((ReverseProxyWebForward) webForward).getActiveDNS() ? 1 : 0); 349 ps.setString(6, ((ReverseProxyWebForward) webForward).getHostHeader()); 350 ps.setString(7, ((ReverseProxyWebForward) webForward).getFormType()); 351 ps.setString(8, ((ReverseProxyWebForward) webForward).getFormParameters()); 352 ps.setString(9, ((ReverseProxyWebForward) webForward).getCharset()); 353 ps.execute(); 354 } 355 356 if (webForward instanceof ReplacementProxyWebForward) { 357 ps = db.getStatement(ps, "createWebForward.replacementProxyOptions.insert"); 358 ps.setInt(1, webForward.getResourceId()); 359 ps.setString(2, ((ReplacementProxyWebForward) webForward).getAuthenticationUsername()); 360 ps.setString(3, Util.emptyWhenNull(((ReplacementProxyWebForward) webForward).getAuthenticationPassword())); 361 ps.setString(4, ((ReplacementProxyWebForward) webForward).getPreferredAuthenticationScheme()); 362 ps.setString(5, ((ReplacementProxyWebForward) webForward).getEncoding()); 363 ps.setString(6, ((ReplacementProxyWebForward) webForward).getRestrictToHosts().getAsPropertyText()); 364 ps.setString(7, ((ReplacementProxyWebForward) webForward).getFormType()); 365 ps.setString(8, ((ReplacementProxyWebForward) webForward).getFormParameters()); 366 ps.execute(); 367 } 368 369 ps.commit(); 370 } catch (Exception e) { 371 ps.rollback(); 372 throw e; 373 } finally { 374 ps.releasePreparedStatement(); 375 ps.endTransaction(); 376 } 377 return getWebForward(webForward.getResourceId()); 378 } 379 380 385 public void updateWebForward(WebForward webForward) throws Exception { 386 JDBCPreparedStatement ps = db.getStatement("updateWebForward.update"); 387 388 393 ps.startTransaction(); 394 395 try { 396 397 ps.setInt(1, webForward.getType()); 398 ps.setString(2, webForward.getResourceName()); 399 ps.setString(3, webForward.getDestinationURL()); 400 ps.setString(4, webForward.getResourceDescription()); 401 ps.setString(5, webForward.getCategory()); 402 Calendar c = Calendar.getInstance(); 403 ps.setString(6, db.formatTimestamp(c)); 404 ps.setInt(7, webForward.getResourceId()); 405 ps.execute(); 406 407 if (webForward instanceof ReverseProxyWebForward) { 408 ps = db.getStatement(ps, "updateWebForward.reverseProxy.delete"); 409 ps.setInt(1, webForward.getResourceId()); 410 ps.execute(); 411 ps = db.getStatement(ps, "updateWebForward.reverseProxy.insert"); 412 StringTokenizer t = new StringTokenizer (((ReverseProxyWebForward) webForward).getPaths(), "\n\r"); 413 while (t.hasMoreTokens()) { 414 String path = t.nextToken(); 415 ps.setString(1, path); 416 ps.setInt(2, webForward.getResourceId()); 417 ps.execute(); 418 ps.reset(); 419 } 420 ps = db.getStatement(ps, "updateWebForward.reverseProxyOptions.update"); 421 ps.setString(1, ((ReverseProxyWebForward) webForward).getAuthenticationUsername()); 422 ps.setString(2, ((ReverseProxyWebForward) webForward).getAuthenticationPassword()); 423 ps.setString(3, ((ReverseProxyWebForward) webForward).getPreferredAuthenticationScheme()); 424 ps.setInt(4, ((ReverseProxyWebForward) webForward).getActiveDNS() ? 1 : 0); 425 ps.setString(5, ((ReverseProxyWebForward) webForward).getHostHeader()); 426 ps.setString(6, ((ReverseProxyWebForward) webForward).getFormType()); 427 ps.setString(7, ((ReverseProxyWebForward) webForward).getFormParameters()); 428 ps.setString(8, ((ReverseProxyWebForward) webForward).getCharset()); 429 ps.setInt(9, webForward.getResourceId()); 430 431 ps.execute(); 432 } 433 434 if (webForward instanceof ReplacementProxyWebForward) { 435 ps = db.getStatement(ps, "updateWebForward.replacementProxyOptions.update"); 436 ps.setString(1, ((ReplacementProxyWebForward) webForward).getEncoding()); 437 ps.setString(2, ((ReplacementProxyWebForward) webForward).getRestrictToHosts().getAsPropertyText()); 438 ps.setString(3, ((ReplacementProxyWebForward) webForward).getAuthenticationUsername()); 439 ps.setString(4, ((ReplacementProxyWebForward) webForward).getAuthenticationPassword()); 440 ps.setString(5, ((ReplacementProxyWebForward) webForward).getPreferredAuthenticationScheme()); 441 ps.setString(6, ((ReplacementProxyWebForward) webForward).getFormType()); 442 ps.setString(7, ((ReplacementProxyWebForward) webForward).getFormParameters()); 443 ps.setInt(8, webForward.getResourceId()); 444 ps.execute(); 445 } 446 447 ps.commit(); 448 } catch (Exception e) { 449 ps.rollback(); 450 throw e; 451 } finally { 452 ps.releasePreparedStatement(); 453 ps.endTransaction(); 454 } 455 } 456 457 462 public WebForward deleteWebForward(int webForwardId) throws Exception { 463 WebForward wf = getWebForward(webForwardId); 464 if (wf == null) { 465 throw new Exception ("No web forward with id of " + webForwardId); 466 } 467 JDBCPreparedStatement ps = db.getStatement("deleteWebForward.delete.favorites"); 468 try { 469 ps.setInt(1, WebForwardPlugin.WEBFORWARD_RESOURCE_TYPE_ID); 470 ps.setString(2, String.valueOf(webForwardId)); 471 ps.execute(); 472 } finally { 473 ps.releasePreparedStatement(); 474 } 475 ps = db.getStatement("deleteWebForward.delete.webForward"); 476 try { 477 ps.setInt(1, webForwardId); 478 ps.execute(); 479 } finally { 480 ps.releasePreparedStatement(); 481 } 482 if (wf.getType() == WebForward.TYPE_REPLACEMENT_PROXY) { 483 ps = db.getStatement("deleteWebForward.delete.replacementProxy.options"); 484 try { 485 ps.setInt(1, wf.getResourceId()); 486 ps.execute(); 487 } finally { 488 ps.releasePreparedStatement(); 489 } 490 } 491 if (wf.getType() == WebForward.TYPE_PATH_BASED_REVERSE_PROXY || wf.getType() == WebForward.TYPE_HOST_BASED_REVERSE_PROXY) { 492 ps = db.getStatement("deleteWebForward.delete.reverseProxy"); 493 try { 494 ps.setInt(1, wf.getResourceId()); 495 ps.execute(); 496 } finally { 497 ps.releasePreparedStatement(); 498 } 499 ps = db.getStatement("deleteWebForward.delete.reverseProxy.options"); 500 try { 501 ps.setInt(1, wf.getResourceId()); 502 ps.execute(); 503 } finally { 504 ps.releasePreparedStatement(); 505 } 506 } 507 return wf; 508 } 509 510 515 WebForward buildWebForward(ResultSet rs) throws Exception { 516 517 int type = rs.getInt("type"); 518 int id = rs.getInt("id"); 519 int realmID = rs.getInt("realm_id"); 520 Timestamp cd = rs.getTimestamp("date_created"); 521 Calendar created = Calendar.getInstance(); 522 created.setTimeInMillis(cd == null ? System.currentTimeMillis() : cd.getTime()); 523 Timestamp ad = rs.getTimestamp("date_amended"); 524 Calendar amended = Calendar.getInstance(); 525 amended.setTimeInMillis(ad == null ? System.currentTimeMillis() : ad.getTime()); 526 String category = rs.getString("category"); 527 String name = rs.getString("short_name"); 528 String description = rs.getString("description"); 529 String url = rs.getString("destination_url"); 530 if (type == WebForward.TYPE_PATH_BASED_REVERSE_PROXY || type == WebForward.TYPE_HOST_BASED_REVERSE_PROXY) { 531 JDBCPreparedStatement ps2 = db.getStatement("getWebForward.reverseProxy.selectById"); 532 try { 533 ps2.setInt(1, id); 534 ResultSet rs2 = ps2.executeQuery(); 535 try { 536 StringBuffer paths = new StringBuffer (); 537 String hostHeader = ""; 538 while (rs2.next()) { 539 if (paths.length() > 0) { 540 paths.append('\n'); 541 } 542 paths.append(rs2.getString("path")); 543 } 544 JDBCPreparedStatement ps3 = db.getStatement("getWebForward.reverseProxyOptions.selectById"); 545 try { 546 ps3.setInt(1, id); 547 ResultSet rs3 = ps3.executeQuery(); 548 try { 549 String authUsername = ""; 550 String authPassword = ""; 551 String preferredAuthScheme = HttpAuthenticatorFactory.BASIC; 552 boolean activeDNS = false; 553 String formType = ""; 554 String formParameters = ""; 555 String charset = null; 556 if (rs3.next()) { 557 authUsername = rs3.getString("authentication_username"); 558 authPassword = rs3.getString("authentication_password"); 559 preferredAuthScheme = rs3.getString("preferred_authentication_scheme"); 560 activeDNS = rs3.getInt("active_dns") == 1; 561 hostHeader = rs3.getString("host_header"); 562 formType = rs3.getString("form_type"); 563 formParameters = rs3.getString("form_parameters"); 564 charset = rs3.getString("charset"); 565 } 566 return new ReverseProxyWebForward(realmID, id, type, url, name, description, category, authUsername, authPassword, 567 preferredAuthScheme, formType, formParameters, paths.toString(), hostHeader, activeDNS, 568 created, amended, charset); 569 } finally { 570 rs3.close(); 571 } 572 } finally { 573 ps3.releasePreparedStatement(); 574 } 575 } finally { 576 rs2.close(); 577 } 578 } finally { 579 ps2.releasePreparedStatement(); 580 } 581 582 } else if (type == WebForward.TYPE_REPLACEMENT_PROXY) { 583 JDBCPreparedStatement ps3 = db.getStatement("getWebForward.replacementProxyOptions.selectById"); 584 try { 585 ps3.setInt(1, id); 586 ResultSet rs3 = ps3.executeQuery(); 587 try { 588 String authUsername = ""; 589 String authPassword = ""; 590 String preferredAuthScheme = HttpAuthenticatorFactory.BASIC; 591 String encoding = ""; 592 String formType = ""; 593 String formParameters = ""; 594 PropertyList restrictToHosts = new PropertyList(); 595 if (rs3.next()) { 596 authUsername = rs3.getString("authentication_username"); 597 authPassword = rs3.getString("authentication_password"); 598 preferredAuthScheme = rs3.getString("preferred_authentication_scheme"); 599 encoding = rs3.getString("encoding"); 600 restrictToHosts.setAsPropertyText(rs3.getString("restrict_to_hosts")); 601 formType = rs3.getString("form_type"); 602 formParameters = rs3.getString("form_parameters"); 603 } 604 return new ReplacementProxyWebForward(realmID, id, url, name, description, category, authUsername, authPassword, 605 preferredAuthScheme, encoding, restrictToHosts, formType, formParameters, created, amended); 606 } finally { 607 rs3.close(); 608 } 609 } finally { 610 ps3.releasePreparedStatement(); 611 } 612 613 } else { 614 return new TunneledSiteWebForward(realmID, id, url, name, description, category, created, amended); 615 } 616 617 } 618 619 622 public void open(CoreServlet controllingServlet, PluginDefinition def) throws Exception { 623 String dbName = System.getProperty("sslexplorer.systemDatabase.jdbc.dbName", "explorer_configuration"); 624 controllingServlet.addDatabase(dbName, ContextHolder.getContext().getDBDirectory()); 625 String jdbcUser = System.getProperty("sslexplorer.jdbc.username", "sa"); 626 String jdbcPassword = System.getProperty("sslexplorer.jdbc.password", ""); 627 String vendorDB = System.getProperty("sslexplorer.jdbc.vendorClass", "com.sslexplorer.jdbc.hsqldb.HSQLDBDatabaseEngine"); 628 629 if (log.isInfoEnabled()) { 630 log.info("System database is being opened..."); 631 log.info("JDBC vendor class implementation is " + vendorDB); 632 } 633 634 db = (JDBCDatabaseEngine) Class.forName(vendorDB).newInstance(); 635 db.init("webForwardsDatabase", dbName, jdbcUser, jdbcPassword, null); 636 637 File upgradeDir = new File (def.getDescriptor().getApplicationBundle().getBaseDir(), "upgrade"); 638 DBUpgrader upgrader = new DBUpgrader(ExtensionStore.getInstance() 639 .getExtensionBundle(WebForwardPlugin.BUNDLE_ID) 640 .getVersion(), db, ContextHolder.getContext() 641 .getDBDirectory(), upgradeDir); 642 upgrader.upgrade(); 643 644 CoreServlet.getServlet().addCoreListener(this); 645 } 646 647 651 657 public List getReplacementsForContent(String username, int replaceType, String mimeType, String site) throws Exception { 658 String cacheKey = (username == null ? "" : username) + "_" + replaceType + "_" + (mimeType == null ? "" : mimeType) + "_" 659 + (site == null ? "" : site); 660 synchronized (replacementsCache) { 661 if (replacementsCache.contains(cacheKey)) { 662 return (List ) replacementsCache.retrieve(cacheKey); 663 } 664 } 665 JDBCPreparedStatement ps = null; 666 667 674 String sitePattern = site == null || site.equals("") ? ".*" : site; 675 if (site == null || site.equals("")) { 676 ps = db.getStatement("getReplacementsForContent.select.allSites"); 677 ps.setString(3, ""); 678 679 } else { 680 ps = db.getStatement("getReplacementsForContent.select"); 681 ps.setString(3, sitePattern); 682 ps.setString(4, sitePattern); 683 } 684 ps.setString(1, mimeType == null ? "" : mimeType); 685 ps.setInt(2, replaceType); 686 687 try { 688 ResultSet rs = ps.executeQuery(); 689 CacheList v = new CacheList(); 690 try { 691 while (rs.next()) { 692 v.add(new DefaultReplacement(rs.getString("mime_type"), replaceType, rs.getInt("sequence"), rs 693 .getString("site_pattern"), rs.getString("match_pattern"), rs.getString("replace_pattern"))); 694 } 695 replacementsCache.store(cacheKey, v, new Long (Long.MAX_VALUE), null); 696 return v; 697 } finally { 698 rs.close(); 699 } 700 } finally { 701 ps.releasePreparedStatement(); 702 } 703 } 704 705 710 public void deleteReplacement(int sequence) throws Exception { 711 JDBCPreparedStatement ps = db.getStatement("deleteReplacements.delete"); 712 try { 713 ps.setInt(1, sequence); 714 ps.execute(); 715 } finally { 716 ps.releasePreparedStatement(); 717 } 718 replacementsCache.clear(); 719 } 720 721 726 public void updateReplacement(Replacement replacement) throws Exception { 727 JDBCPreparedStatement ps = db.getStatement("updateReplacements.update"); 728 try { 729 ps.setString(1, replacement.getMimeType()); 730 ps.setString(2, replacement.getSitePattern()); 731 ps.setString(3, replacement.getMatchPattern()); 732 ps.setString(4, replacement.getReplacePattern()); 733 ps.setInt(5, replacement.getReplaceType()); 734 ps.setInt(6, replacement.getSequence()); 735 ps.execute(); 736 } finally { 737 ps.releasePreparedStatement(); 738 } 739 replacementsCache.clear(); 740 } 741 742 747 public Replacement createReplacement(Replacement replacement) throws Exception { 748 JDBCPreparedStatement ps = db.getStatement("createReplacement.insert"); 749 try { 750 ps.setInt(1, replacement.getReplaceType()); 751 ps.setString(2, replacement.getMimeType()); 752 ps.setString(3, replacement.getSitePattern()); 753 ps.setString(4, replacement.getMatchPattern()); 754 ps.setString(5, replacement.getReplacePattern()); 755 ps.execute(); 756 return new DefaultReplacement(replacement.getMimeType(), replacement.getReplaceType(), db.getLastInsertId(ps, 757 "createReplacement.lastInsertId"), replacement.getSitePattern(), replacement.getMatchPattern(), replacement 758 .getReplacePattern()); 759 } finally { 760 replacementsCache.clear(); 761 ps.releasePreparedStatement(); 762 } 763 } 764 765 770 public List <Replacement> getReplacements() throws Exception { 771 JDBCPreparedStatement ps = db.getStatement("getReplacements.select"); 772 try { 773 ResultSet rs = ps.executeQuery(); 774 try { 775 List <Replacement> v = new ArrayList <Replacement>(); 776 while (rs.next()) { 777 v.add(new DefaultReplacement(rs.getString("mime_type"), rs.getInt("replace_type"), rs.getInt("sequence"), rs 778 .getString("site_pattern"), rs.getString("match_pattern"), rs.getString("replace_pattern"))); 779 } 780 return v; 781 } finally { 782 rs.close(); 783 } 784 } finally { 785 ps.releasePreparedStatement(); 786 } 787 } 788 789 794 public Replacement getReplacement(int sequence) throws Exception { 795 JDBCPreparedStatement ps = db.getStatement("getReplacement.select"); 796 ps.setInt(1, sequence); 797 try { 798 ResultSet rs = ps.executeQuery(); 799 try { 800 if (rs.next()) { 801 return new DefaultReplacement(rs.getString("mime_type"), rs.getInt("replace_type"), rs.getInt("sequence"), rs 802 .getString("site_pattern"), rs.getString("match_pattern"), rs.getString("replace_pattern")); 803 } 804 } finally { 805 rs.close(); 806 } 807 } finally { 808 ps.releasePreparedStatement(); 809 } 810 return null; 811 } 812 813 817 class CacheList extends ArrayList <Replacement> implements Serializable { 818 private static final long serialVersionUID = 6613983448357872637L; 819 } 820 821 } 822 | Popular Tags |