Public Member Functions | |
| ParallelDB (VirtualDatabase vdb) throws SQLException, NotCompliantMBeanException | |
| ControllerResultSet | execReadRequest (SelectRequest request, MetadataCache metadataCache) throws SQLException |
| ControllerResultSet | execReadOnlyReadStoredProcedure (StoredProcedure proc, MetadataCache metadataCache) throws SQLException |
| ControllerResultSet | execReadStoredProcedure (StoredProcedure proc, MetadataCache metadataCache) throws SQLException |
| int | execWriteRequest (AbstractWriteRequest request) throws AllBackendsFailedException, SQLException |
| ControllerResultSet | execWriteRequestWithKeys (AbstractWriteRequest request, MetadataCache metadataCache) throws AllBackendsFailedException, SQLException |
| int | execWriteStoredProcedure (StoredProcedure proc) throws SQLException |
| void | begin (TransactionMarkerMetaData tm) throws SQLException |
| void | commit (TransactionMarkerMetaData tm) throws SQLException |
| void | rollback (TransactionMarkerMetaData tm) throws SQLException |
| void | enableBackend (DatabaseBackend db, boolean writeEnabled) throws SQLException |
| void | disableBackend (DatabaseBackend db) throws SQLException |
| String | getXmlImpl () |
| abstract String | getParallelDBXml () |
| abstract DatabaseBackend | chooseBackendForReadRequest (AbstractRequest request) throws SQLException |
| abstract DatabaseBackend | chooseBackendForWriteRequest (AbstractWriteRequest request) throws SQLException |
Read and write queries are load balanced on the backends without any replication (assuming that the underlying parallel database takes care of data replication). The load balancers provide failover for reads and writes.
Definition at line 71 of file ParallelDB.java.
|
|
Creates a new
Definition at line 84 of file ParallelDB.java. 00086 {
00087 super(vdb, RAIDbLevels.SingleDB, ParsingGranularities.NO_PARSING);
00088 }
|
|
|
Implements org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer. Definition at line 968 of file ParallelDB.java. References org.objectweb.cjdbc.controller.backend.DatabaseBackend.startTransaction(). 00969 {
00970 Long lTid = new Long(tm.getTransactionId());
00971 if (backendPerTransactionId.containsKey(lTid))
00972 throw new SQLException(Translate.get(
00973 "loadbalancer.transaction.already.started", lTid.toString()));
00974
00975 DatabaseBackend backend = chooseBackendForReadRequest(new UnknownRequest(
00976 "begin", false, 0, "\n"));
00977 backendPerTransactionId.put(lTid, backend);
00978 backend.startTransaction(lTid);
00979 }
|
|
|
Choose a backend using the implementation specific load balancing algorithm for read request execution.
Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_LPRF, and org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_RR. Referenced by org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB.execReadRequest(). |
|
|
Choose a backend using the implementation specific load balancing algorithm for write request execution.
Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_LPRF, and org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_RR. |
|
|
Implements org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer. Definition at line 984 of file ParallelDB.java. References org.objectweb.cjdbc.controller.backend.DatabaseBackend.getConnectionManager(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.getName(), org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.retrieveConnection(), and org.objectweb.cjdbc.controller.backend.DatabaseBackend.stopTransaction(). 00985 {
00986 long tid = tm.getTransactionId();
00987 Long lTid = new Long(tid);
00988 DatabaseBackend db = (DatabaseBackend) backendPerTransactionId.remove(lTid);
00989
00990 AbstractConnectionManager cm = db.getConnectionManager(tm.getLogin());
00991 Connection c = cm.retrieveConnection(tid);
00992
00993 // Sanity check
00994 if (c == null)
00995 { // Bad connection
00996 db.stopTransaction(lTid);
00997
00998 throw new SQLException(Translate.get(
00999 "loadbalancer.unable.retrieve.connection", new String[]{
01000 String.valueOf(tid), db.getName()}));
01001 }
01002
01003 // Execute Query
01004 try
01005 {
01006 c.commit();
01007 c.setAutoCommit(true);
01008 }
01009 catch (Exception e)
01010 {
01011 String msg = Translate.get("loadbalancer.commit.failed", new String[]{
01012 String.valueOf(tid), db.getName(), e.getMessage()});
01013 logger.error(msg);
01014 throw new SQLException(msg);
01015 }
01016 finally
01017 {
01018 cm.releaseConnection(tid);
01019 db.stopTransaction(lTid);
01020 }
01021 }
|
|
|
Disables a backend that was previously enabled. Asks the corresponding connection manager to finalize the connections if needed. No sanity checks are performed by this function.
Implements org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer. Definition at line 1095 of file ParallelDB.java. References org.objectweb.cjdbc.controller.backend.DatabaseBackend.disable(), and org.objectweb.cjdbc.controller.backend.DatabaseBackend.finalizeConnections(). 01096 {
01097 logger.info(Translate.get("loadbalancer.backend.disabling", db.getName()));
01098 db.disable();
01099 if (db.isInitialized())
01100 db.finalizeConnections();
01101 }
|
|
||||||||||||
|
Enables a backend that was previously disabled. Asks the corresponding connection manager to initialize the connections if needed. No sanity checks are performed by this function.
Implements org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer. Definition at line 1075 of file ParallelDB.java. References org.objectweb.cjdbc.controller.backend.DatabaseBackend.enableRead(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.enableWrite(), and org.objectweb.cjdbc.controller.backend.DatabaseBackend.initializeConnections(). 01077 {
01078 logger.info(Translate.get("loadbalancer.backend.enabling", db.getName()));
01079 if (!db.isInitialized())
01080 db.initializeConnections();
01081 db.enableRead();
01082 if (writeEnabled)
01083 db.enableWrite();
01084 }
|
|
||||||||||||
|
Implements org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer. Definition at line 144 of file ParallelDB.java. 00146 {
00147 return execReadStoredProcedure(proc, metadataCache);
00148 }
|
|
||||||||||||
|
Implements org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer. Definition at line 94 of file ParallelDB.java. References org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB.chooseBackendForReadRequest(), org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabase.getSQLShortFormLength(), org.objectweb.cjdbc.common.log.Trace.info(), and org.objectweb.cjdbc.common.log.Trace.isInfoEnabled(). 00096 {
00097 DatabaseBackend backend;
00098 if (request.isAutoCommit())
00099 backend = chooseBackendForReadRequest(request);
00100 else
00101 backend = (DatabaseBackend) backendPerTransactionId.get(new Long(request
00102 .getTransactionId()));
00103
00104 if (backend == null)
00105 throw new SQLException(Translate.get(
00106 "loadbalancer.execute.no.backend.found", request.getSQLShortForm(vdb
00107 .getSQLShortFormLength())));
00108
00109 ControllerResultSet rs = null;
00110 // Execute the request on the chosen backend
00111 try
00112 {
00113 rs = executeReadRequestOnBackend(request, backend, metadataCache);
00114 }
00115 catch (UnreachableBackendException urbe)
00116 {
00117 // Try to execute query on different backend
00118 return execReadRequest(request, metadataCache);
00119 }
00120 catch (SQLException se)
00121 {
00122 String msg = Translate.get("loadbalancer.request.failed", new String[]{
00123 String.valueOf(request.getId()), se.getMessage()});
00124 if (logger.isInfoEnabled())
00125 logger.info(msg);
00126 throw new SQLException(msg);
00127 }
00128 catch (RuntimeException e)
00129 {
00130 String msg = Translate.get("loadbalancer.request.failed.on.backend",
00131 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()),
00132 backend.getName(), e.getMessage()});
00133 logger.error(msg, e);
00134 throw new SQLException(msg);
00135 }
00136
00137 return rs;
00138 }
|
|
||||||||||||
|
Implements org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer. Definition at line 154 of file ParallelDB.java. 00156 {
00157 DatabaseBackend backend;
00158 if (proc.isAutoCommit())
00159 backend = chooseBackendForReadRequest(proc);
00160 else
00161 backend = (DatabaseBackend) backendPerTransactionId.get(new Long(proc
00162 .getTransactionId()));
00163
00164 if (backend == null)
00165 throw new SQLException(Translate.get(
00166 "loadbalancer.storedprocedure.no.backend.found", proc
00167 .getSQLShortForm(vdb.getSQLShortFormLength())));
00168
00169 ControllerResultSet rs = null;
00170 // Execute the request on the chosen backend
00171 try
00172 {
00173 rs = executeReadStoredProcedureOnBackend(proc, backend, metadataCache);
00174 }
00175 catch (UnreachableBackendException urbe)
00176 {
00177 // Try to execute query on different backend
00178 return execReadStoredProcedure(proc, metadataCache);
00179 }
00180 catch (SQLException se)
00181 {
00182 String msg = Translate.get("loadbalancer.storedprocedure.failed",
00183 new String[]{String.valueOf(proc.getId()), se.getMessage()});
00184 if (logger.isInfoEnabled())
00185 logger.info(msg);
00186 throw new SQLException(msg);
00187 }
00188 catch (RuntimeException e)
00189 {
00190 String msg = Translate.get(
00191 "loadbalancer.storedprocedure.failed.on.backend", new String[]{
00192 proc.getSQLShortForm(vdb.getSQLShortFormLength()),
00193 backend.getName(), e.getMessage()});
00194 logger.error(msg, e);
00195 throw new SQLException(msg);
00196 }
00197
00198 return rs;
00199 }
|
|
|
Implements org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer. Definition at line 204 of file ParallelDB.java. 00206 {
00207 DatabaseBackend backend;
00208 if (request.isAutoCommit())
00209 backend = chooseBackendForWriteRequest(request);
00210 else
00211 backend = (DatabaseBackend) backendPerTransactionId.get(new Long(request
00212 .getTransactionId()));
00213
00214 if (backend == null)
00215 throw new SQLException(Translate.get(
00216 "loadbalancer.execute.no.backend.found", request.getSQLShortForm(vdb
00217 .getSQLShortFormLength())));
00218
00219 int result;
00220 // Execute the request on the chosen backend
00221 try
00222 {
00223 result = executeWriteRequestOnBackend(request, backend);
00224 }
00225 catch (UnreachableBackendException urbe)
00226 {
00227 // Try to execute query on different backend
00228 return execWriteRequest(request);
00229 }
00230 catch (SQLException se)
00231 {
00232 String msg = Translate.get("loadbalancer.request.failed", new String[]{
00233 String.valueOf(request.getId()), se.getMessage()});
00234 if (logger.isInfoEnabled())
00235 logger.info(msg);
00236 throw new SQLException(msg);
00237 }
00238 catch (RuntimeException e)
00239 {
00240 String msg = Translate.get("loadbalancer.request.failed.on.backend",
00241 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()),
00242 backend.getName(), e.getMessage()});
00243 logger.error(msg, e);
00244 throw new SQLException(msg);
00245 }
00246
00247 return result;
00248 }
|
|
||||||||||||
|
Implements org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer. Definition at line 254 of file ParallelDB.java. 00257 {
00258 DatabaseBackend backend;
00259 if (request.isAutoCommit())
00260 backend = chooseBackendForWriteRequest(request);
00261 else
00262 backend = (DatabaseBackend) backendPerTransactionId.get(new Long(request
00263 .getTransactionId()));
00264
00265 if (backend == null)
00266 throw new SQLException(Translate.get(
00267 "loadbalancer.execute.no.backend.found", request.getSQLShortForm(vdb
00268 .getSQLShortFormLength())));
00269
00270 ControllerResultSet rs;
00271 // Execute the request on the chosen backend
00272 try
00273 {
00274 rs = executeWriteRequestWithKeysOnBackend(request, backend, metadataCache);
00275 }
00276 catch (UnreachableBackendException urbe)
00277 {
00278 // Try to execute query on different backend
00279 return execWriteRequestWithKeys(request, metadataCache);
00280 }
00281 catch (SQLException se)
00282 {
00283 String msg = Translate.get("loadbalancer.request.failed", new String[]{
00284 String.valueOf(request.getId()), se.getMessage()});
00285 if (logger.isInfoEnabled())
00286 logger.info(msg);
00287 throw new SQLException(msg);
00288 }
00289 catch (RuntimeException e)
00290 {
00291 String msg = Translate.get("loadbalancer.request.failed.on.backend",
00292 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()),
00293 backend.getName(), e.getMessage()});
00294 logger.error(msg, e);
00295 throw new SQLException(msg);
00296 }
00297
00298 return rs;
00299 }
|
|
|
Implements org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer. Definition at line 304 of file ParallelDB.java. 00305 {
00306 DatabaseBackend backend;
00307 if (proc.isAutoCommit())
00308 backend = chooseBackendForReadRequest(proc);
00309 else
00310 backend = (DatabaseBackend) backendPerTransactionId.get(new Long(proc
00311 .getTransactionId()));
00312
00313 if (backend == null)
00314 throw new SQLException(Translate.get(
00315 "loadbalancer.storedprocedure.no.backend.found", proc
00316 .getSQLShortForm(vdb.getSQLShortFormLength())));
00317
00318 int result;
00319 // Execute the request on the chosen backend
00320 try
00321 {
00322 result = executeWriteStoredProcedureOnBackend(proc, backend);
00323 }
00324 catch (UnreachableBackendException urbe)
00325 {
00326 // Try to execute query on different backend
00327 return execWriteStoredProcedure(proc);
00328 }
00329 catch (SQLException se)
00330 {
00331 String msg = Translate.get("loadbalancer.storedprocedure.failed",
00332 new String[]{String.valueOf(proc.getId()), se.getMessage()});
00333 if (logger.isInfoEnabled())
00334 logger.info(msg);
00335 throw new SQLException(msg);
00336 }
00337 catch (RuntimeException e)
00338 {
00339 String msg = Translate.get(
00340 "loadbalancer.storedprocedure.failed.on.backend", new String[]{
00341 proc.getSQLShortForm(vdb.getSQLShortFormLength()),
00342 backend.getName(), e.getMessage()});
00343 logger.error(msg, e);
00344 throw new SQLException(msg);
00345 }
00346
00347 return result;
00348 }
|
|
|
Return the XML tags of the ParallelDB load balancer implementation.
Implemented in org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_LPRF, and org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_RR. |
|
|
Implements org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer. Definition at line 1106 of file ParallelDB.java. References org.objectweb.cjdbc.controller.backend.DatabaseBackend.toString(). 01107 {
01108 StringBuffer info = new StringBuffer();
01109 info.append("<" + DatabasesXmlTags.ELT_ParallelDB + ">");
01110 info.append(getParallelDBXml());
01111 info.append("</" + DatabasesXmlTags.ELT_ParallelDB + ">");
01112 return info.toString();
01113 }
|
|
|
Implements org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer. Definition at line 1026 of file ParallelDB.java. References org.objectweb.cjdbc.controller.backend.DatabaseBackend.getConnectionManager(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.getName(), org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.retrieveConnection(), and org.objectweb.cjdbc.controller.backend.DatabaseBackend.stopTransaction(). 01027 {
01028 long tid = tm.getTransactionId();
01029 Long lTid = new Long(tid);
01030 DatabaseBackend db = (DatabaseBackend) backendPerTransactionId.remove(lTid);
01031
01032 AbstractConnectionManager cm = db.getConnectionManager(tm.getLogin());
01033 Connection c = cm.retrieveConnection(tid);
01034
01035 // Sanity check
01036 if (c == null)
01037 { // Bad connection
01038 db.stopTransaction(lTid);
01039
01040 throw new SQLException(Translate.get(
01041 "loadbalancer.unable.retrieve.connection", new String[]{
01042 String.valueOf(tid), db.getName()}));
01043 }
01044
01045 // Execute Query
01046 try
01047 {
01048 c.rollback();
01049 c.setAutoCommit(true);
01050 }
01051 catch (Exception e)
01052 {
01053 String msg = Translate.get("loadbalancer.rollback.failed", new String[]{
01054 String.valueOf(tid), db.getName(), e.getMessage()});
01055 logger.error(msg);
01056 throw new SQLException(msg);
01057 }
01058 finally
01059 {
01060 cm.releaseConnection(tid);
01061 db.stopTransaction(lTid);
01062 }
01063 }
|
1.3.9.1