KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sslexplorer > webforwards > JDBCWebForwardDatabase


1 /*
2  * SSL-Explorer
3  *
4  * Copyright (C) 2003-2006 3SP LTD. All Rights Reserved
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2 of
9  * the License, or (at your option) any later version.
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public
16  * License along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  */

19             
20 package com.sslexplorer.webforwards;
21
22 import java.io.File JavaDoc;
23 import java.io.Serializable JavaDoc;
24 import java.sql.ResultSet JavaDoc;
25 import java.sql.Timestamp JavaDoc;
26 import java.util.ArrayList JavaDoc;
27 import java.util.Calendar JavaDoc;
28 import java.util.List JavaDoc;
29 import java.util.StringTokenizer JavaDoc;
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 /**
54  * Implementation of a {@link com.sslexplorer.security.SystemDatabase} that uses
55  * a JDBC compliant database to store SSL-Explorer's web forward configuration
56  * and resources.
57  *
58  * @author James D Robinson <a HREF="mailto:james@3sp.com">&lt;james@3sp.com&gt;</a>
59  */

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     /**
67      * Constructor
68      */

69     public JDBCWebForwardDatabase() {
70         int maxObjects = 1000;
71         try {
72             maxObjects = Integer.parseInt(System.getProperty("sslexplorer.jdbcSystemDatabase.replacementsCache", "10000"));
73         } catch (Exception JavaDoc e) {
74         }
75         replacementsCache = new SimpleCache(new MemoryStash(maxObjects));
76     }
77
78     /*
79      * (non-Javadoc)
80      *
81      * @see com.sslexplorer.boot.Database#close()
82      */

83     public void close() throws Exception JavaDoc {
84     }
85
86     /*
87      * (non-Javadoc)
88      *
89      * @see com.sslexplorer.core.Database#open(com.sslexplorer.core.CoreServlet)
90      */

91     public void open(CoreServlet controllingServlet) throws Exception JavaDoc {
92         throw new Exception JavaDoc("Plugin databases need a PluginDefinition.");
93     }
94
95     /*
96      * (non-Javadoc)
97      *
98      * @see com.sslexplorer.boot.Database#cleanup()
99      */

100     public void cleanup() throws Exception JavaDoc {
101     }
102
103     /*
104      * (non-Javadoc)
105      *
106      * @see com.sslexplorer.core.CoreListener#coreEvent(com.sslexplorer.core.CoreEvent)
107      */

108     public void coreEvent(CoreEvent evt) {
109         // The removeUser() method is not user anymore
110
// if (evt.getId() == CoreEventConstants.USER_REMOVED) {
111
// User user = (User) evt.getParameter();
112
//
113
// // LDP - Fix as null user might be passed?
114
// if (user == null)
115
// return;
116
//
117
// try {
118
// removeUser(user.getPrincipalName());
119
// } catch (Exception e) {
120
// log.error("Failed to remove user from system database.", e);
121
// }
122
// }
123
}
124
125     /*
126      * (non-Javadoc)
127      *
128      * @see com.sslexplorer.webforwards.WebForwardDatabase#getReverseProxyWebForward(com.sslexplorer.security.User,
129      * java.lang.String)
130      */

131     public WebForward getReverseProxyWebForward(User user, String JavaDoc pathInContext) throws Exception JavaDoc {
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 JavaDoc 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     /*
155      * (non-Javadoc)
156      *
157      * @see com.sslexplorer.webforwards.WebForwardDatabase#getWebForward(int)
158      */

159     public WebForward getWebForward(int id) throws Exception JavaDoc {
160         JDBCPreparedStatement ps = db.getStatement("getWebForward.selectById");
161         ps.setInt(1, id);
162         try {
163             ResultSet JavaDoc 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     /*
178      * (non-Javadoc)
179      *
180      * @see com.sslexplorer.webforwards.WebForwardDatabase#getWebForwards(int)
181      */

182     public List JavaDoc<WebForward> getWebForwards(int realmID) throws Exception JavaDoc {
183         JDBCPreparedStatement ps = null;
184         ps = db.getStatement("getWebForwards.realm.select");
185         ps.setInt(1, realmID);
186         try {
187             ResultSet JavaDoc rs = ps.executeQuery();
188             try {
189                 List JavaDoc<WebForward> v = new ArrayList JavaDoc<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     /*
205      * (non-Javadoc)
206      *
207      * @see com.sslexplorer.webforwards.WebForwardDatabase#getWebForwards()
208      */

209     public List JavaDoc<WebForward> getWebForwards() throws Exception JavaDoc {
210         JDBCPreparedStatement ps = db.getStatement("getWebForwards.select.allTypes");
211         try {
212             ResultSet JavaDoc rs = ps.executeQuery();
213             try {
214                 List JavaDoc<WebForward> v = new ArrayList JavaDoc<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     /* (non-Javadoc)
230      * @see com.sslexplorer.webforwards.WebForwardDatabase#getWebForward(java.lang.String, int)
231      */

232     public WebForward getWebForward(String JavaDoc name, int realmID) throws Exception JavaDoc {
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 JavaDoc 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     /*
253      * (non-Javadoc)
254      *
255      * @see com.sslexplorer.webforwards.WebForwardDatabase#reverseProxyPathExists(java.lang.String)
256      */

257     public boolean reverseProxyPathExists(String JavaDoc path) throws Exception JavaDoc {
258         JDBCPreparedStatement ps = null;
259         try {
260             ps = db.getStatement("createWebForward.reverseProxy.path.exists");
261             ps.setString(1, path);
262             ResultSet JavaDoc 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     /*
278      * (non-Javadoc)
279      *
280      * @see com.sslexplorer.webforwards.WebForwardDatabase#reverseProxyPathExists(java.lang.String,
281      * int)
282      */

283     public boolean reverseProxyPathExists(String JavaDoc path, int webforward_id) throws Exception JavaDoc {
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 JavaDoc 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     /*
305      * (non-Javadoc)
306      *
307      * @see com.sslexplorer.webforwards.WebForwardDatabase#createWebForward(com.sslexplorer.webforwards.WebForward)
308      */

309     public WebForward createWebForward(WebForward webForward) throws Exception JavaDoc {
310         JDBCPreparedStatement ps = db.getStatement("createWebForward.insert");
311
312         /*
313          * For this method, we could get errors when inserting proxy paths (if
314          * path already exists). To deal with this the whole operation is run as
315          * a transaction.
316          */

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 JavaDoc 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 JavaDoc t = new StringTokenizer JavaDoc(((ReverseProxyWebForward) webForward).getPaths(), "\n\r");
336                 while (t.hasMoreTokens()) {
337                     String JavaDoc 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 JavaDoc e) {
371             ps.rollback();
372             throw e;
373         } finally {
374             ps.releasePreparedStatement();
375             ps.endTransaction();
376         }
377         return getWebForward(webForward.getResourceId());
378     }
379
380     /*
381      * (non-Javadoc)
382      *
383      * @see com.sslexplorer.webforwards.WebForwardDatabase#updateWebForward(com.sslexplorer.webforwards.WebForward)
384      */

385     public void updateWebForward(WebForward webForward) throws Exception JavaDoc {
386         JDBCPreparedStatement ps = db.getStatement("updateWebForward.update");
387
388         /*
389          * For this method, we could get errors when inserting proxy paths (if
390          * path already exists). To deal with this the whole operation is run as
391          * a transaction.
392          */

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 JavaDoc 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 JavaDoc t = new StringTokenizer JavaDoc(((ReverseProxyWebForward) webForward).getPaths(), "\n\r");
413                 while (t.hasMoreTokens()) {
414                     String JavaDoc 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 JavaDoc e) {
449             ps.rollback();
450             throw e;
451         } finally {
452             ps.releasePreparedStatement();
453             ps.endTransaction();
454         }
455     }
456
457     /*
458      * (non-Javadoc)
459      *
460      * @see com.sslexplorer.webforwards.WebForwardDatabase#deleteWebForward(int)
461      */

462     public WebForward deleteWebForward(int webForwardId) throws Exception JavaDoc {
463         WebForward wf = getWebForward(webForwardId);
464         if (wf == null) {
465             throw new Exception JavaDoc("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     /**
511      * @param rs
512      * @return WebForward
513      * @throws Exception
514      */

515     WebForward buildWebForward(ResultSet JavaDoc rs) throws Exception JavaDoc {
516
517         int type = rs.getInt("type");
518         int id = rs.getInt("id");
519         int realmID = rs.getInt("realm_id");
520         Timestamp JavaDoc cd = rs.getTimestamp("date_created");
521         Calendar JavaDoc created = Calendar.getInstance();
522         created.setTimeInMillis(cd == null ? System.currentTimeMillis() : cd.getTime());
523         Timestamp JavaDoc ad = rs.getTimestamp("date_amended");
524         Calendar JavaDoc amended = Calendar.getInstance();
525         amended.setTimeInMillis(ad == null ? System.currentTimeMillis() : ad.getTime());
526         String JavaDoc category = rs.getString("category");
527         String JavaDoc name = rs.getString("short_name");
528         String JavaDoc description = rs.getString("description");
529         String JavaDoc 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 JavaDoc rs2 = ps2.executeQuery();
535                 try {
536                     StringBuffer JavaDoc paths = new StringBuffer JavaDoc();
537                     String JavaDoc 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 JavaDoc rs3 = ps3.executeQuery();
548                         try {
549                             String JavaDoc authUsername = "";
550                             String JavaDoc authPassword = "";
551                             String JavaDoc preferredAuthScheme = HttpAuthenticatorFactory.BASIC;
552                             boolean activeDNS = false;
553                             String JavaDoc formType = "";
554                             String JavaDoc formParameters = "";
555                             String JavaDoc 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 JavaDoc rs3 = ps3.executeQuery();
587                 try {
588                     String JavaDoc authUsername = "";
589                     String JavaDoc authPassword = "";
590                     String JavaDoc preferredAuthScheme = HttpAuthenticatorFactory.BASIC;
591                     String JavaDoc encoding = "";
592                     String JavaDoc formType = "";
593                     String JavaDoc 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     /* (non-Javadoc)
620      * @see com.sslexplorer.plugin.PluginDatabase#open(com.sslexplorer.core.CoreServlet, com.sslexplorer.plugin.PluginDefinition)
621      */

622     public void open(CoreServlet controllingServlet, PluginDefinition def) throws Exception JavaDoc {
623         String JavaDoc dbName = System.getProperty("sslexplorer.systemDatabase.jdbc.dbName", "explorer_configuration");
624         controllingServlet.addDatabase(dbName, ContextHolder.getContext().getDBDirectory());
625         String JavaDoc jdbcUser = System.getProperty("sslexplorer.jdbc.username", "sa");
626         String JavaDoc jdbcPassword = System.getProperty("sslexplorer.jdbc.password", "");
627         String JavaDoc 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 JavaDoc upgradeDir = new File JavaDoc(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     //
648
// Replacements
649
//
650

651     /*
652      * (non-Javadoc)
653      *
654      * @see com.sslexplorer.security.SystemDatabase#getReplacementsForContent(java.lang.String,
655      * int, java.lang.String, java.lang.String)
656      */

657     public List JavaDoc getReplacementsForContent(String JavaDoc username, int replaceType, String JavaDoc mimeType, String JavaDoc site) throws Exception JavaDoc {
658         String JavaDoc cacheKey = (username == null ? "" : username) + "_" + replaceType + "_" + (mimeType == null ? "" : mimeType) + "_"
659                         + (site == null ? "" : site);
660         synchronized (replacementsCache) {
661             if (replacementsCache.contains(cacheKey)) {
662                 return (List JavaDoc) replacementsCache.retrieve(cacheKey);
663             }
664         }
665         JDBCPreparedStatement ps = null;
666
667         // global=SELECT * FROM replacements WHERE username=? AND mime_type=?
668
// AND replace_type=? AND MATCHES(?,site_pattern=?) = ?
669
// ORDER BY username,replace_type,mime_type,sequence ASC
670
// user=SELECT * FROM replacements WHERE ( username=? OR username=? )
671
// AND mime_type=? AND replace_type=? AND MATCHES(?,site_pattern=?) = ?
672
// ORDER BY username,replace_type,mime_type,sequence ASC
673

674         String JavaDoc 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 JavaDoc 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 JavaDoc(Long.MAX_VALUE), null);
696                 return v;
697             } finally {
698                 rs.close();
699             }
700         } finally {
701             ps.releasePreparedStatement();
702         }
703     }
704
705     /*
706      * (non-Javadoc)
707      *
708      * @see com.sslexplorer.security.SystemDatabase#deleteReplacement(int)
709      */

710     public void deleteReplacement(int sequence) throws Exception JavaDoc {
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     /*
722      * (non-Javadoc)
723      *
724      * @see com.sslexplorer.security.SystemDatabase#updateReplacement(com.sslexplorer.services.Replacement)
725      */

726     public void updateReplacement(Replacement replacement) throws Exception JavaDoc {
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     /*
743      * (non-Javadoc)
744      *
745      * @see com.sslexplorer.security.SystemDatabase#createReplacement(com.sslexplorer.services.Replacement)
746      */

747     public Replacement createReplacement(Replacement replacement) throws Exception JavaDoc {
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     /*
766      * (non-Javadoc)
767      *
768      * @see com.sslexplorer.security.SystemDatabase#getReplacements()
769      */

770     public List JavaDoc<Replacement> getReplacements() throws Exception JavaDoc {
771         JDBCPreparedStatement ps = db.getStatement("getReplacements.select");
772         try {
773             ResultSet JavaDoc rs = ps.executeQuery();
774             try {
775                 List JavaDoc<Replacement> v = new ArrayList JavaDoc<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     /*
790      * (non-Javadoc)
791      *
792      * @see com.sslexplorer.security.SystemDatabase#getReplacement(int)
793      */

794     public Replacement getReplacement(int sequence) throws Exception JavaDoc {
795         JDBCPreparedStatement ps = db.getStatement("getReplacement.select");
796         ps.setInt(1, sequence);
797         try {
798             ResultSet JavaDoc 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     //
814
// Supporting classes
815
//
816

817     class CacheList extends ArrayList JavaDoc<Replacement> implements Serializable JavaDoc {
818         private static final long serialVersionUID = 6613983448357872637L;
819     }
820
821 }
822
Popular Tags