/*
* Adito
*
* Copyright (C) 2003-2006 3SP LTD. All Rights Reserved
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
package com.adito.webforwards;
import java.io.File;
import java.io.Serializable;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.StringTokenizer;
import org.apache.commons.cache.Cache;
import org.apache.commons.cache.MemoryStash;
import org.apache.commons.cache.SimpleCache;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.maverick.http.HttpAuthenticatorFactory;
import com.adito.boot.ContextHolder;
import com.adito.boot.PropertyList;
import com.adito.boot.SystemProperties;
import com.adito.boot.Util;
import com.adito.core.CoreEvent;
import com.adito.core.CoreListener;
import com.adito.core.CoreServlet;
import com.adito.extensions.store.ExtensionStore;
import com.adito.extensions.types.PluginDefinition;
import com.adito.jdbc.DBUpgrader;
import com.adito.jdbc.JDBCDatabaseEngine;
import com.adito.jdbc.JDBCPreparedStatement;
import com.adito.jdbc.JDBCUtil;
import com.adito.replacementproxy.DefaultReplacement;
import com.adito.replacementproxy.Replacement;
import com.adito.security.User;
/**
* Implementation of a {@link com.adito.security.SystemDatabase} that uses
* a JDBC compliant database to store Adito's web forward configuration
* and resources.
*/
public class JDBCWebForwardDatabase implements WebForwardDatabase, CoreListener {
private static final Log log = LogFactory.getLog(JDBCWebForwardDatabase.class);
private JDBCDatabaseEngine db;
private Cache replacementsCache;
/**
* Constructor
*/
public JDBCWebForwardDatabase() {
int maxObjects = 1000;
try {
maxObjects = Integer.parseInt(SystemProperties.get("adito.jdbcSystemDatabase.replacementsCache", "10000"));
} catch (Exception e) {
}
replacementsCache = new SimpleCache(new MemoryStash(maxObjects));
}
/*
* (non-Javadoc)
*
* @see com.adito.boot.Database#close()
*/
public void close() throws Exception {
}
/*
* (non-Javadoc)
*
* @see com.adito.core.Database#open(com.adito.core.CoreServlet)
*/
public void open(CoreServlet controllingServlet) throws Exception {
throw new Exception("Plugin databases need a PluginDefinition.");
}
/*
* (non-Javadoc)
*
* @see com.adito.boot.Database#cleanup()
*/
public void cleanup() throws Exception {
}
/*
* (non-Javadoc)
*
* @see com.adito.core.CoreListener#coreEvent(com.adito.core.CoreEvent)
*/
public void coreEvent(CoreEvent evt) {
// The removeUser() method is not user anymore
// if (evt.getId() == CoreEventConstants.USER_REMOVED) {
// User user = (User) evt.getParameter();
//
// // LDP - Fix as null user might be passed?
// if (user == null)
// return;
//
// try {
// removeUser(user.getPrincipalName());
// } catch (Exception e) {
// log.error("Failed to remove user from system database.", e);
// }
// }
}
/*
* (non-Javadoc)
*
* @see com.adito.webforwards.WebForwardDatabase#getReverseProxyWebForward(com.adito.security.User,
* java.lang.String)
*/
public WebForward getReverseProxyWebForward(User user, String pathInContext) throws Exception {
JDBCPreparedStatement ps = db.getStatement("getReverseProxyWebForward.select");
ps.setString(1, "");
ps.setString(2, user == null ? "" : user.getPrincipalName());
ps.setString(3, pathInContext);
try {
ResultSet rs = ps.executeQuery();
try {
if (rs.next()) {
return getWebForward(rs.getInt("webforward_id"));
}
} finally {
if (rs != null) {
rs.close();
}
}
} finally {
ps.releasePreparedStatement();
}
return null;
}
/*
* (non-Javadoc)
*
* @see com.adito.webforwards.WebForwardDatabase#getWebForward(int)
*/
public WebForward getWebForward(int id) throws Exception {
JDBCPreparedStatement ps = db.getStatement("getWebForward.selectById");
ps.setInt(1, id);
try {
ResultSet rs = ps.executeQuery();
try {
if (rs.next()) {
return buildWebForward(rs);
}
} finally {
rs.close();
}
} finally {
ps.releasePreparedStatement();
}
return null;
}
/*
* (non-Javadoc)
*
* @see com.adito.webforwards.WebForwardDatabase#getWebForwards(int)
*/
public List<WebForward> getWebForwards(int realmID) throws Exception {
JDBCPreparedStatement ps = null;
ps = db.getStatement("getWebForwards.realm.select");
ps.setInt(1, realmID);
try {
ResultSet rs = ps.executeQuery();
try {
List<WebForward> v = new ArrayList<WebForward>();
while (rs.next()) {
v.add(buildWebForward(rs));
}
return v;
} finally {
if (rs != null) {
rs.close();
}
}
} finally {
ps.releasePreparedStatement();
}
}
/*
* (non-Javadoc)
*
* @see com.adito.webforwards.WebForwardDatabase#getWebForwards()
*/
public List<WebForward> getWebForwards() throws Exception {
JDBCPreparedStatement ps = db.getStatement("getWebForwards.select.allTypes");
try {
ResultSet rs = ps.executeQuery();
try {
List<WebForward> v = new ArrayList<WebForward>();
while (rs.next()) {
v.add(buildWebForward(rs));
}
return v;
} finally {
if (rs != null) {
rs.close();
}
}
} finally {
ps.releasePreparedStatement();
}
}
/* (non-Javadoc)
* @see com.adito.webforwards.WebForwardDatabase#getWebForward(java.lang.String, int)
*/
public WebForward getWebForward(String name, int realmID) throws Exception {
JDBCPreparedStatement ps = null;
try {
ps = db.getStatement("getWebForward.select.name");
ps.setString(1, name);
ps.setInt(2, realmID);
ResultSet rs = ps.executeQuery();
try {
if (rs.next()) {
return buildWebForward(rs);
}
} finally {
rs.close();
}
} finally {
ps.releasePreparedStatement();
}
return null;
}
/*
* (non-Javadoc)
*
* @see com.adito.webforwards.WebForwardDatabase#reverseProxyPathExists(java.lang.String)
*/
public boolean reverseProxyPathExists(String path) throws Exception {
JDBCPreparedStatement ps = null;
try {
ps = db.getStatement("createWebForward.reverseProxy.path.exists");
ps.setString(1, path);
ResultSet rs = ps.executeQuery();
try {
if (rs.next()) {
return true;
} else {
return false;
}
} finally {
rs.close();
}
} finally {
ps.releasePreparedStatement();
}
}
/*
* (non-Javadoc)
*
* @see com.adito.webforwards.WebForwardDatabase#reverseProxyPathExists(java.lang.String,
* int)
*/
public boolean reverseProxyPathExists(String path, int webforward_id) throws Exception {
JDBCPreparedStatement ps = null;
try {
ps = db.getStatement("createWebForward.reverseProxy.path.already.exists");
ps.setString(1, path);
ps.setInt(2, webforward_id);
ResultSet rs = ps.executeQuery();
try {
if (rs.next()) {
return true;
} else {
return false;
}
} finally {
rs.close();
}
} finally {
ps.releasePreparedStatement();
}
}
/*
* (non-Javadoc)
*
* @see com.adito.webforwards.WebForwardDatabase#createWebForward(com.adito.webforwards.WebForward)
*/
public WebForward createWebForward(WebForward webForward) throws Exception {
JDBCPreparedStatement ps = db.getStatement("createWebForward.insert");
/*
* For this method, we could get errors when inserting proxy paths (if
* path already exists). To deal with this the whole operation is run as
* a transaction.
*/
ps.startTransaction();
try {
int id = -1;
ps.setString(1, webForward.getDestinationURL());
ps.setInt(2, webForward.getType());
ps.setString(3, webForward.getResourceName());
ps.setString(4, webForward.getResourceDescription());
ps.setString(5, webForward.getCategory());
ps.setInt(6, webForward.isAutoStart() ? 1 : 0);
Calendar now = Calendar.getInstance();
ps.setString(7, db.formatTimestamp(now));
ps.setString(8, db.formatTimestamp(now));
ps.setInt(9, webForward.getRealmID());
ps.execute();
webForward.setResourceId(id = db.getLastInsertId(ps, "createWebForward.lastInsertId"));
if (webForward instanceof ReverseProxyWebForward) {
ps = db.getStatement(ps, "createWebForward.reverseProxy.insert");
StringTokenizer t = new StringTokenizer(((ReverseProxyWebForward) webForward).getPaths(), "\n\r");
while (t.hasMoreTokens()) {
String path = t.nextToken();
ps.setString(1, path);
ps.setInt(2, id);
ps.execute();
ps.reset();
}
ps = db.getStatement(ps, "createWebForward.reverseProxyOptions.insert");
ps.setInt(1, webForward.getResourceId());
ps.setString(2, ((ReverseProxyWebForward) webForward).getAuthenticationUsername());
ps.setString(3, Util.emptyWhenNull(((ReverseProxyWebForward) webForward).getAuthenticationPassword()));
ps.setString(4, ((ReverseProxyWebForward) webForward).getPreferredAuthenticationScheme());
ps.setInt(5, ((ReverseProxyWebForward) webForward).getActiveDNS() ? 1 : 0);
ps.setString(6, ((ReverseProxyWebForward) webForward).getHostHeader());
ps.setString(7, ((ReverseProxyWebForward) webForward).getFormType());
ps.setString(8, ((ReverseProxyWebForward) webForward).getFormParameters());
ps.setString(9, ((ReverseProxyWebForward) webForward).getCharset());
ps.execute();
}
if (webForward instanceof ReplacementProxyWebForward) {
ps = db.getStatement(ps, "createWebForward.replacementProxyOptions.insert");
ps.setInt(1, webForward.getResourceId());
ps.setString(2, ((ReplacementProxyWebForward) webForward).getAuthenticationUsername());
ps.setString(3, Util.emptyWhenNull(((ReplacementProxyWebForward) webForward).getAuthenticationPassword()));
ps.setString(4, ((ReplacementProxyWebForward) webForward).getPreferredAuthenticationScheme());
ps.setString(5, ((ReplacementProxyWebForward) webForward).getEncoding());
ps.setString(6, ((ReplacementProxyWebForward) webForward).getRestrictToHosts().getAsPropertyText());
ps.setString(7, ((ReplacementProxyWebForward) webForward).getFormType());
ps.setString(8, ((ReplacementProxyWebForward) webForward).getFormParameters());
ps.execute();
}
ps.commit();
} catch (Exception e) {
ps.rollback();
throw e;
} finally {
ps.releasePreparedStatement();
ps.endTransaction();
}
return getWebForward(webForward.getResourceId());
}
/*
* (non-Javadoc)
*
* @see com.adito.webforwards.WebForwardDatabase#updateWebForward(com.adito.webforwards.WebForward)
*/
public void updateWebForward(WebForward webForward) throws Exception {
JDBCPreparedStatement ps = db.getStatement("updateWebForward.update");
/*
* For this method, we could get errors when inserting proxy paths (if
* path already exists). To deal with this the whole operation is run as
* a transaction.
*/
ps.startTransaction();
try {
ps.setInt(1, webForward.getType());
ps.setString(2, webForward.getResourceName());
ps.setString(3, webForward.getDestinationURL());
ps.setString(4, webForward.getResourceDescription());
ps.setString(5, webForward.getCategory());
ps.setInt(6, webForward.isAutoStart() ? 1 : 0);
Calendar c = Calendar.getInstance();
ps.setString(7, db.formatTimestamp(c));
ps.setInt(8, webForward.getResourceId());
ps.execute();
if (webForward instanceof ReverseProxyWebForward) {
ps = db.getStatement(ps, "updateWebForward.reverseProxy.delete");
ps.setInt(1, webForward.getResourceId());
ps.execute();
ps = db.getStatement(ps, "updateWebForward.reverseProxy.insert");
StringTokenizer t = new StringTokenizer(((ReverseProxyWebForward) webForward).getPaths(), "\n\r");
while (t.hasMoreTokens()) {
String path = t.nextToken();
ps.setString(1, path);
ps.setInt(2, webForward.getResourceId());
ps.execute();
ps.reset();
}
ps = db.getStatement(ps, "updateWebForward.reverseProxyOptions.update");
ps.setString(1, ((ReverseProxyWebForward) webForward).getAuthenticationUsername());
ps.setString(2, ((ReverseProxyWebForward) webForward).getAuthenticationPassword());
ps.setString(3, ((ReverseProxyWebForward) webForward).getPreferredAuthenticationScheme());
ps.setInt(4, ((ReverseProxyWebForward) webForward).getActiveDNS() ? 1 : 0);
ps.setString(5, ((ReverseProxyWebForward) webForward).getHostHeader());
ps.setString(6, ((ReverseProxyWebForward) webForward).getFormType());
ps.setString(7, ((ReverseProxyWebForward) webForward).getFormParameters());
ps.setString(8, ((ReverseProxyWebForward) webForward).getCharset());
ps.setInt(9, webForward.getResourceId());
ps.execute();
}
if (webForward instanceof ReplacementProxyWebForward) {
ps = db.getStatement(ps, "updateWebForward.replacementProxyOptions.update");
ps.setString(1, ((ReplacementProxyWebForward) webForward).getEncoding());
ps.setString(2, ((ReplacementProxyWebForward) webForward).getRestrictToHosts().getAsPropertyText());
ps.setString(3, ((ReplacementProxyWebForward) webForward).getAuthenticationUsername());
ps.setString(4, ((ReplacementProxyWebForward) webForward).getAuthenticationPassword());
ps.setString(5, ((ReplacementProxyWebForward) webForward).getPreferredAuthenticationScheme());
ps.setString(6, ((ReplacementProxyWebForward) webForward).getFormType());
ps.setString(7, ((ReplacementProxyWebForward) webForward).getFormParameters());
ps.setInt(8, webForward.getResourceId());
ps.execute();
}
ps.commit();
} catch (Exception e) {
ps.rollback();
throw e;
} finally {
ps.releasePreparedStatement();
ps.endTransaction();
}
}
/*
* (non-Javadoc)
*
* @see com.adito.webforwards.WebForwardDatabase#deleteWebForward(int)
*/
public WebForward deleteWebForward(int webForwardId) throws Exception {
WebForward wf = getWebForward(webForwardId);
if (wf == null) {
throw new Exception("No web forward with id of " + webForwardId);
}
JDBCPreparedStatement ps = db.getStatement("deleteWebForward.delete.favorites");
try {
ps.setInt(1, WebForwardPlugin.WEBFORWARD_RESOURCE_TYPE_ID);
ps.setString(2, String.valueOf(webForwardId));
ps.execute();
} finally {
ps.releasePreparedStatement();
}
ps = db.getStatement("deleteWebForward.delete.webForward");
try {
ps.setInt(1, webForwardId);
ps.execute();
} finally {
ps.releasePreparedStatement();
}
if (wf.getType() == WebForward.TYPE_REPLACEMENT_PROXY) {
ps = db.getStatement("deleteWebForward.delete.replacementProxy.options");
try {
ps.setInt(1, wf.getResourceId());
ps.execute();
} finally {
ps.releasePreparedStatement();
}
}
if (wf.getType() == WebForward.TYPE_PATH_BASED_REVERSE_PROXY || wf.getType() == WebForward.TYPE_HOST_BASED_REVERSE_PROXY) {
ps = db.getStatement("deleteWebForward.delete.reverseProxy");
try {
ps.setInt(1, wf.getResourceId());
ps.execute();
} finally {
ps.releasePreparedStatement();
}
ps = db.getStatement("deleteWebForward.delete.reverseProxy.options");
try {
ps.setInt(1, wf.getResourceId());
ps.execute();
} finally {
ps.releasePreparedStatement();
}
}
return wf;
}
/**
* @param rs
* @return WebForward
* @throws Exception
*/
WebForward buildWebForward(ResultSet rs) throws Exception {
int id = rs.getInt("id");
int type = rs.getInt("type");
String category = rs.getString("category");
String name = rs.getString("short_name");
String description = rs.getString("description");
String url = rs.getString("destination_url");
boolean autoStart = rs.getBoolean("auto_start");
Calendar created = JDBCUtil.getCalendar(rs, "date_created");
Calendar amended = JDBCUtil.getCalendar(rs, "date_amended");
int realmID = rs.getInt("realm_id");
if (type == WebForward.TYPE_PATH_BASED_REVERSE_PROXY || type == WebForward.TYPE_HOST_BASED_REVERSE_PROXY) {
JDBCPreparedStatement ps2 = db.getStatement("getWebForward.reverseProxy.selectById");
try {
ps2.setInt(1, id);
ResultSet rs2 = ps2.executeQuery();
try {
StringBuffer paths = new StringBuffer();
String hostHeader = "";
while (rs2.next()) {
if (paths.length() > 0) {
paths.append('\n');
}
paths.append(rs2.getString("path"));
}
JDBCPreparedStatement ps3 = db.getStatement("getWebForward.reverseProxyOptions.selectById");
try {
ps3.setInt(1, id);
ResultSet rs3 = ps3.executeQuery();
try {
String authUsername = "";
String authPassword = "";
String preferredAuthScheme = HttpAuthenticatorFactory.BASIC;
boolean activeDNS = false;
String formType = "";
String formParameters = "";
String charset = null;
if (rs3.next()) {
authUsername = rs3.getString("authentication_username");
authPassword = rs3.getString("authentication_password");
preferredAuthScheme = rs3.getString("preferred_authentication_scheme");
activeDNS = rs3.getInt("active_dns") == 1;
hostHeader = rs3.getString("host_header");
formType = rs3.getString("form_type");
formParameters = rs3.getString("form_parameters");
charset = rs3.getString("charset");
}
return new ReverseProxyWebForward(realmID, id, type, url, name, description, category, authUsername, authPassword,
preferredAuthScheme, formType, formParameters, paths.toString(), hostHeader, activeDNS, autoStart,
created, amended, charset);
} finally {
rs3.close();
}
} finally {
ps3.releasePreparedStatement();
}
} finally {
rs2.close();
}
} finally {
ps2.releasePreparedStatement();
}
} else if (type == WebForward.TYPE_REPLACEMENT_PROXY) {
JDBCPreparedStatement ps3 = db.getStatement("getWebForward.replacementProxyOptions.selectById");
try {
ps3.setInt(1, id);
ResultSet rs3 = ps3.executeQuery();
try {
String authUsername = "";
String authPassword = "";
String preferredAuthScheme = HttpAuthenticatorFactory.BASIC;
String encoding = "";
String formType = "";
String formParameters = "";
PropertyList restrictToHosts = new PropertyList();
if (rs3.next()) {
authUsername = rs3.getString("authentication_username");
authPassword = rs3.getString("authentication_password");
preferredAuthScheme = rs3.getString("preferred_authentication_scheme");
encoding = rs3.getString("encoding");
restrictToHosts.setAsPropertyText(rs3.getString("restrict_to_hosts"));
formType = rs3.getString("form_type");
formParameters = rs3.getString("form_parameters");
}
return new ReplacementProxyWebForward(realmID, id, url, name, description, category, authUsername, authPassword,
preferredAuthScheme, encoding, restrictToHosts, formType, formParameters, autoStart, created, amended);
} finally {
rs3.close();
}
} finally {
ps3.releasePreparedStatement();
}
} else {
return new TunneledSiteWebForward(realmID, id, url, name, description, category, autoStart, created, amended);
}
}
/* (non-Javadoc)
* @see com.adito.plugin.PluginDatabase#open(com.adito.core.CoreServlet, com.adito.plugin.PluginDefinition)
*/
public void open(CoreServlet controllingServlet, PluginDefinition def) throws Exception {
String dbName = SystemProperties.get("adito.systemDatabase.jdbc.dbName", "explorer_configuration");
controllingServlet.addDatabase(dbName, ContextHolder.getContext().getDBDirectory());
String jdbcUser = SystemProperties.get("adito.jdbc.username", "sa");
String jdbcPassword = SystemProperties.get("adito.jdbc.password", "");
String vendorDB = SystemProperties.get("adito.jdbc.vendorClass", "com.adito.jdbc.hsqldb.HSQLDBDatabaseEngine");
if (log.isInfoEnabled()) {
log.info("System database is being opened...");
log.info("JDBC vendor class implementation is " + vendorDB);
}
db = (JDBCDatabaseEngine) Class.forName(vendorDB).newInstance();
db.init("webForwardsDatabase", dbName, jdbcUser, jdbcPassword, null);
File upgradeDir = new File(def.getDescriptor().getApplicationBundle().getBaseDir(), "upgrade");
DBUpgrader upgrader = new DBUpgrader(ExtensionStore.getInstance()
.getExtensionBundle(WebForwardPlugin.BUNDLE_ID)
.getVersion(), db, ContextHolder.getContext()
.getDBDirectory(), upgradeDir);
upgrader.upgrade();
CoreServlet.getServlet().addCoreListener(this);
}
//
// Replacements
//
/*
* (non-Javadoc)
*
* @see com.adito.security.SystemDatabase#getReplacementsForContent(java.lang.String,
* int, java.lang.String, java.lang.String)
*/
public List getReplacementsForContent(String username, int replaceType, String mimeType, String site) throws Exception {
String cacheKey = (username == null ? "" : username) + "_" + replaceType + "_" + (mimeType == null ? "" : mimeType) + "_"
+ (site == null ? "" : site);
synchronized (replacementsCache) {
List cachedReplacements = (List) replacementsCache.retrieve(cacheKey);
if (replacementsCache.contains(cacheKey)) {
return cachedReplacements;
}
}
JDBCPreparedStatement ps = null;
// global=SELECT * FROM replacements WHERE username=? AND mime_type=?
// AND replace_type=? AND MATCHES(?,site_pattern=?) = ?
// ORDER BY username,replace_type,mime_type,sequence ASC
// user=SELECT * FROM replacements WHERE ( username=? OR username=? )
// AND mime_type=? AND replace_type=? AND MATCHES(?,site_pattern=?) = ?
// ORDER BY username,replace_type,mime_type,sequence ASC
String sitePattern = site == null || site.equals("") ? ".*" : site;
if (site == null || site.equals("")) {
ps = db.getStatement("getReplacementsForContent.select.allSites");
ps.setString(3, "");
} else {
ps = db.getStatement("getReplacementsForContent.select");
ps.setString(3, sitePattern);
ps.setString(4, sitePattern);
}
ps.setString(1, mimeType == null ? "" : mimeType);
ps.setInt(2, replaceType);
try {
ResultSet rs = ps.executeQuery();
CacheList v = new CacheList();
try {
while (rs.next()) {
v.add(new DefaultReplacement(rs.getString("mime_type"), replaceType, rs.getInt("sequence"), rs
.getString("site_pattern"), rs.getString("match_pattern"), rs.getString("replace_pattern")));
}
replacementsCache.store(cacheKey, v, new Long(Long.MAX_VALUE), null);
return v;
} finally {
rs.close();
}
} finally {
ps.releasePreparedStatement();
}
}
/*
* (non-Javadoc)
*
* @see com.adito.security.SystemDatabase#deleteReplacement(int)
*/
public void deleteReplacement(int sequence) throws Exception {
JDBCPreparedStatement ps = db.getStatement("deleteReplacements.delete");
try {
ps.setInt(1, sequence);
ps.execute();
} finally {
ps.releasePreparedStatement();
}
replacementsCache.clear();
}
/*
* (non-Javadoc)
*
* @see com.adito.security.SystemDatabase#updateReplacement(com.adito.services.Replacement)
*/
public void updateReplacement(Replacement replacement) throws Exception {
JDBCPreparedStatement ps = db.getStatement("updateReplacements.update");
try {
ps.setString(1, replacement.getMimeType());
ps.setString(2, replacement.getSitePattern());
ps.setString(3, replacement.getMatchPattern());
ps.setString(4, replacement.getReplacePattern());
ps.setInt(5, replacement.getReplaceType());
ps.setInt(6, replacement.getSequence());
ps.execute();
} finally {
ps.releasePreparedStatement();
}
replacementsCache.clear();
}
/*
* (non-Javadoc)
*
* @see com.adito.security.SystemDatabase#createReplacement(com.adito.services.Replacement)
*/
public Replacement createReplacement(Replacement replacement) throws Exception {
JDBCPreparedStatement ps = db.getStatement("createReplacement.insert");
try {
ps.setInt(1, replacement.getReplaceType());
ps.setString(2, replacement.getMimeType());
ps.setString(3, replacement.getSitePattern());
ps.setString(4, replacement.getMatchPattern());
ps.setString(5, replacement.getReplacePattern());
ps.execute();
return new DefaultReplacement(replacement.getMimeType(), replacement.getReplaceType(), db.getLastInsertId(ps,
"createReplacement.lastInsertId"), replacement.getSitePattern(), replacement.getMatchPattern(), replacement
.getReplacePattern());
} finally {
replacementsCache.clear();
ps.releasePreparedStatement();
}
}
/*
* (non-Javadoc)
*
* @see com.adito.security.SystemDatabase#getReplacements()
*/
public List<Replacement> getReplacements() throws Exception {
JDBCPreparedStatement ps = db.getStatement("getReplacements.select");
try {
ResultSet rs = ps.executeQuery();
try {
List<Replacement> v = new ArrayList<Replacement>();
while (rs.next()) {
v.add(new DefaultReplacement(rs.getString("mime_type"), rs.getInt("replace_type"), rs.getInt("sequence"), rs
.getString("site_pattern"), rs.getString("match_pattern"), rs.getString("replace_pattern")));
}
return v;
} finally {
rs.close();
}
} finally {
ps.releasePreparedStatement();
}
}
/*
* (non-Javadoc)
*
* @see com.adito.security.SystemDatabase#getReplacement(int)
*/
public Replacement getReplacement(int sequence) throws Exception {
JDBCPreparedStatement ps = db.getStatement("getReplacement.select");
ps.setInt(1, sequence);
try {
ResultSet rs = ps.executeQuery();
try {
if (rs.next()) {
return new DefaultReplacement(rs.getString("mime_type"), rs.getInt("replace_type"), rs.getInt("sequence"), rs
.getString("site_pattern"), rs.getString("match_pattern"), rs.getString("replace_pattern"));
}
} finally {
rs.close();
}
} finally {
ps.releasePreparedStatement();
}
return null;
}
//
// Supporting classes
//
class CacheList extends ArrayList<Replacement> implements Serializable {
private static final long serialVersionUID = 6613983448357872637L;
}
}