The requests coming from the request controller are directly forwarded to the single backend. This load balancer does not support multiple backends.
SingleDB.java の 59 行で定義されています。
Public メソッド | |
| SingleDB (VirtualDatabase vdb) throws SQLException | |
| java.sql.ResultSet | execReadRequest (SelectRequest request) throws SQLException |
| int | execWriteRequest (AbstractWriteRequest request) throws SQLException |
| ResultSet | execWriteRequestWithKeys (AbstractWriteRequest request) throws SQLException |
| ResultSet | execReadOnlyReadStoredProcedure (StoredProcedure proc) throws SQLException |
| ResultSet | execReadStoredProcedure (StoredProcedure proc) throws 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 |
| void | setWeight (String name, int w) throws SQLException |
| String | getInformation () |
| String | getXmlImpl () |
| int | getRAIDbLevel () |
| void | setRAIDbLevel (int raidbLevel) |
| int | getParsingGranularity () |
| void | setParsingGranularity (int parsingGranularity) |
| String | getXml () |
Protected メソッド | |
| ResultSet | executeStatementOnBackend (SelectRequest request, DatabaseBackend backend, Connection c) throws SQLException, BadConnectionException |
Protected 変数 | |
| VirtualDatabase | vdb |
| int | raidbLevel |
| int | parsingGranularity |
Private 変数 | |
| DatabaseBackend | backend |
Static Private 変数 | |
| Trace | logger |
|
|
Creates a new
SingleDB.java の 83 行で定義されています。
00084 {
00085 // We don't need to parse the requests, just send them to the backend
00086 super(vdb, RAIDbLevels.SingleDB, ParsingGranularities.NO_PARSING);
00087 }
|
|
|
Begins a new transaction.
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 668 行で定義されています。
00669 {
00670 if (backend == null)
00671 throw new SQLException("No available backend to begin transaction "
00672 + tm.getTransactionId());
00673
00674 try
00675 {
00676 Connection c = backend.getConnectionManager(tm.getLogin()).getConnection(
00677 tm.getTransactionId());
00678
00679 if (c == null)
00680 throw new SQLException(Translate.get(
00681 "loadbalancer.backend.no.connection", backend.getName()));
00682
00683 c.setAutoCommit(false);
00684 }
00685 catch (Exception e)
00686 {
00687 throw new SQLException("Begin of transaction " + tm.getTransactionId()
00688 + " failed on backend " + backend.getURL() + " (" + e + ")");
00689 }
00690 }
|
|
|
Commits a transaction.
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 698 行で定義されています。 参照先 org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.retrieveConnection().
00699 {
00700 if (backend == null)
00701 throw new SQLException("No available backend to commit transaction "
00702 + tm.getTransactionId());
00703
00704 try
00705 {
00706 AbstractConnectionManager cm = backend
00707 .getConnectionManager(tm.getLogin());
00708 Connection c = cm.retrieveConnection(tm.getTransactionId());
00709
00710 if (c == null)
00711 throw new SQLException("No connection found for transaction "
00712 + tm.getTransactionId());
00713
00714 try
00715 {
00716 c.commit();
00717 c.setAutoCommit(true);
00718 }
00719 catch (SQLException e)
00720 {
00721 throw new SQLException(Translate.get("loadbalancer.commit.failed",
00722 new String[]{String.valueOf(tm.getTransactionId()),
00723 backend.getName(), e.getMessage()}));
00724 }
00725 finally
00726 {
00727 cm.releaseConnection(tm.getTransactionId());
00728 }
00729 }
00730 catch (RuntimeException e)
00731 {
00732 String msg = Translate.get("loadbalancer.commit.failed", new String[]{
00733 String.valueOf(tm.getTransactionId()), backend.getName(),
00734 e.getMessage()});
00735 logger.fatal(msg, e);
00736 throw new SQLException(msg);
00737 }
00738 }
|
|
|
Disables a backend that was previously enabled. Asks the corresponding connection manager to finalize the connections if needed.
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 827 行で定義されています。
00828 {
00829 if (backend.equals(db))
00830 {
00831 logger
00832 .info(Translate.get("loadbalancer.backend.disabling", db.getName()));
00833 backend.disable();
00834 if (backend.isInitialized())
00835 backend.finalizeConnections();
00836 backend = null;
00837 }
00838 else
00839 {
00840 String msg = "Trying to disable a non-existing backend " + db.getName();
00841 logger.warn(msg);
00842 throw new SQLException(msg);
00843 }
00844 }
|
|
||||||||||||
|
Enables a backend that was previously disabled. Asks the corresponding connection manager to initialize the connections if needed.
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 800 行で定義されています。
00802 {
00803 if (backend != null)
00804 {
00805 if (backend.isReadEnabled())
00806 throw new SQLException(
00807 "SingleDB load balancer accepts only one backend and "
00808 + backend.getName() + " is already enabled. Skipping "
00809 + db.getName() + " initialization.");
00810 }
00811 backend = db;
00812 logger.info(Translate.get("loadbalancer.backend.enabling", db.getName()));
00813 if (!backend.isInitialized())
00814 backend.initializeConnections();
00815 backend.enableRead();
00816 if (writeEnabled)
00817 backend.enableWrite();
00818 }
|
|
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 453 行で定義されています。
00455 {
00456 return execReadStoredProcedure(proc);
00457 }
|
|
|
Performs a read request. It is up to the implementation to choose to which backend node(s) this request should be sent.
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 101 行で定義されています。 参照先 org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.deleteConnection(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.disable(), org.objectweb.cjdbc.common.log.Trace.error(), org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.executeStatementOnBackend(), org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.getConnection(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.getConnectionManager(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.getName(), org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabase.getSQLShortFormLength(), と org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.releaseConnection().
00103 {
00104 if (backend == null)
00105 throw new SQLException(Translate.get(
00106 "loadbalancer.execute.no.backend.available", request.getId()));
00107
00108 try
00109 {
00110 AbstractConnectionManager cm = backend.getConnectionManager(request
00111 .getLogin());
00112 if (request.isAutoCommit())
00113 {
00114 ResultSet rs = null;
00115 boolean badConnection;
00116 do
00117 {
00118 badConnection = false;
00119 // Use a connection just for this request
00120 Connection c = null;
00121 try
00122 {
00123 c = cm.getConnection();
00124 }
00125 catch (UnreachableBackendException e1)
00126 {
00127 String backendName = backend.getName();
00128 logger.error(Translate.get(
00129 "loadbalancer.backend.disabling.unreachable", backendName));
00130 backend.disable();
00131 backend = null;
00132 throw new SQLException(Translate.get(
00133 "loadbalancer.backend.unreacheable", backendName));
00134 }
00135
00136 // Sanity check
00137 if (c == null)
00138 throw new SQLException(Translate.get(
00139 "loadbalancer.backend.no.connection", backend.getName()));
00140
00141 // Execute Query
00142 try
00143 {
00144 rs = executeStatementOnBackend(request, backend, c);
00145 cm.releaseConnection(c);
00146 }
00147 catch (SQLException e)
00148 {
00149 cm.releaseConnection(c);
00150 throw new SQLException(Translate.get(
00151 "loadbalancer.request.failed.on.backend", new String[]{
00152 request.getSQLShortForm(vdb.getSQLShortFormLength()),
00153 backend.getName(), e.getMessage()}));
00154 }
00155 catch (BadConnectionException e)
00156 { // Get rid of the bad connection
00157 cm.deleteConnection(c);
00158 badConnection = true;
00159 }
00160 }
00161 while (badConnection);
00162 return rs;
00163 }
00164 else
00165 {
00166 long tid = request.getTransactionId();
00167 // Re-use the connection used by this transaction
00168 Connection c = cm.retrieveConnection(tid);
00169
00170 // Sanity check
00171 if (c == null)
00172 throw new SQLException(Translate.get(
00173 "loadbalancer.unable.retrieve.connection", new String[]{
00174 String.valueOf(tid), backend.getName()}));
00175
00176 // Execute Query
00177 ResultSet rs = null;
00178 try
00179 {
00180 rs = executeStatementOnBackend(request, backend, c);
00181 }
00182 catch (SQLException e)
00183 {
00184 throw new SQLException(Translate.get(
00185 "loadbalancer.request.failed.on.backend", new String[]{
00186 request.getSQLShortForm(vdb.getSQLShortFormLength()),
00187 backend.getName(), e.getMessage()}));
00188 }
00189 catch (BadConnectionException e)
00190 { // Get rid of the bad connection
00191 cm.deleteConnection(tid);
00192 throw new SQLException(Translate
00193 .get("loadbalancer.connection.failed", new String[]{
00194 String.valueOf(tid), backend.getName(), e.getMessage()}));
00195 }
00196 return rs;
00197 }
00198 }
00199 catch (RuntimeException e)
00200 {
00201 String msg = "Request '"
00202 + request.getSQLShortForm(vdb.getSQLShortFormLength())
00203 + "' failed on backend " + backend.getURL() + " (" + e + ")";
00204 logger.fatal(msg, e);
00205 throw new SQLException(msg);
00206 }
00207 }
|
|
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 462 行で定義されています。 参照先 org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.getConnection(), と org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.releaseConnection().
00464 {
00465 if (backend == null)
00466 throw new SQLException(
00467 "No available backend to execute stored procedure " + proc.getId());
00468
00469 try
00470 {
00471 AbstractConnectionManager cm = backend.getConnectionManager(proc
00472 .getLogin());
00473 if (proc.isAutoCommit())
00474 { // Use a connection just for this request
00475 Connection c = null;
00476 try
00477 {
00478 c = cm.getConnection();
00479 }
00480 catch (UnreachableBackendException e1)
00481 {
00482 String backendName = backend.getName();
00483 logger.error(Translate.get(
00484 "loadbalancer.backend.disabling.unreachable", backendName));
00485 backend.disable();
00486 backend = null;
00487 throw new SQLException(Translate.get(
00488 "loadbalancer.backend.unreacheable", backendName));
00489 }
00490
00491 // Sanity check
00492 if (c == null)
00493 throw new SQLException(Translate.get(
00494 "loadbalancer.backend.no.connection", backend.getName()));
00495
00496 // Execute Query
00497 ResultSet rs = null;
00498 try
00499 {
00500 CallableStatement cs = c.prepareCall(proc.getSQL());
00501 if (backend.getDriverCompliance().supportSetQueryTimeout())
00502 cs.setQueryTimeout(proc.getTimeout());
00503 if ((proc.getMaxRows() > 0)
00504 && backend.getDriverCompliance().supportSetMaxRows())
00505 cs.setMaxRows(proc.getMaxRows());
00506 rs = cs.executeQuery();
00507 }
00508 catch (SQLException e)
00509 {
00510 throw new SQLException(Translate.get(
00511 "loadbalancer.storedprocedure.failed.on.backend", new String[]{
00512 proc.getSQLShortForm(vdb.getSQLShortFormLength()),
00513 backend.getName(), e.getMessage()}));
00514 }
00515 finally
00516 {
00517 cm.releaseConnection(c);
00518 }
00519 return rs;
00520 }
00521 else
00522 { // Re-use the connection used by this transaction
00523 Connection c = cm.retrieveConnection(proc.getTransactionId());
00524
00525 // Sanity check
00526 if (c == null)
00527 throw new SQLException(Translate.get(
00528 "loadbalancer.unable.retrieve.connection", new String[]{
00529 String.valueOf(proc.getTransactionId()), backend.getName()}));
00530
00531 // Execute Query
00532 try
00533 {
00534 CallableStatement cs = c.prepareCall(proc.getSQL());
00535 if (backend.getDriverCompliance().supportSetQueryTimeout())
00536 cs.setQueryTimeout(proc.getTimeout());
00537 if ((proc.getMaxRows() > 0)
00538 && backend.getDriverCompliance().supportSetMaxRows())
00539 cs.setMaxRows(proc.getMaxRows());
00540 return cs.executeQuery();
00541 }
00542 catch (SQLException e)
00543 {
00544 throw new SQLException(Translate.get(
00545 "loadbalancer.storedprocedure.failed.on.backend", new String[]{
00546 proc.getSQLShortForm(vdb.getSQLShortFormLength()),
00547 backend.getName(), e.getMessage()}));
00548 }
00549 }
00550 }
00551 catch (RuntimeException e)
00552 {
00553 String msg = Translate.get(
00554 "loadbalancer.storedprocedure.failed.on.backend", new String[]{
00555 proc.getSQLShortForm(vdb.getSQLShortFormLength()),
00556 backend.getName(), e.getMessage()});
00557 logger.fatal(msg, e);
00558 throw new SQLException(msg);
00559 }
00560 }
|
|
||||||||||||||||
|
Execute a statement on a backend. If the execution fails, the connection is checked for validity. If the connection was not valid, the query is automatically retried on a new connection.
AbstractLoadBalancer.java の 251 行で定義されています。 参照先 java.sql.Statement.executeQuery(), java.sql.Statement.setCursorName(), java.sql.Statement.setFetchSize(), java.sql.Statement.setMaxRows(), java.sql.Statement.setQueryTimeout(), org.objectweb.cjdbc.controller.backend.DriverCompliance.supportSetCursorName, org.objectweb.cjdbc.controller.backend.DriverCompliance.supportSetFetchSize, org.objectweb.cjdbc.controller.backend.DriverCompliance.supportSetMaxRows, と org.objectweb.cjdbc.controller.backend.DriverCompliance.supportSetQueryTimeout. 参照元 org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB.execReadRequest().
00254 {
00255 ResultSet rs = null;
00256 try
00257 {
00258 backend.addPendingReadRequest(request);
00259 String sql = request.getSQL();
00260 // Rewrite the query if needed
00261 sql = backend.rewriteQuery(sql);
00262 // Execute the query
00263 Statement s = c.createStatement();
00264 DriverCompliance driverCompliance = backend.getDriverCompliance();
00265 if (driverCompliance.supportSetQueryTimeout())
00266 s.setQueryTimeout(request.getTimeout());
00267 if ((request.getCursorName() != null)
00268 && (driverCompliance.supportSetCursorName()))
00269 s.setCursorName(request.getCursorName());
00270 if ((request.getFetchSize() != 0)
00271 && driverCompliance.supportSetFetchSize())
00272 s.setFetchSize(request.getFetchSize());
00273 if ((request.getMaxRows() > 0) && driverCompliance.supportSetMaxRows())
00274 s.setMaxRows(request.getMaxRows());
00275 rs = s.executeQuery(sql);
00276 }
00277 catch (SQLException e)
00278 { // Something bad happened
00279 if (backend.isValidConnection(c))
00280 throw e; // Connection is valid, throw the exception
00281 else
00282 throw new BadConnectionException();
00283 }
00284 finally
00285 {
00286 backend.removePendingRequest(request);
00287 }
00288 return rs;
00289 }
|
|
|
Performs a write request on the backend.
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 216 行で定義されています。 参照先 java.sql.Statement.executeUpdate(), org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.getConnection(), org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.releaseConnection(), と java.sql.Statement.setQueryTimeout().
00217 {
00218 if (backend == null)
00219 throw new SQLException(Translate.get(
00220 "loadbalancer.execute.no.backend.available", request.getId()));
00221
00222 try
00223 {
00224 AbstractConnectionManager cm = backend.getConnectionManager(request
00225 .getLogin());
00226 if (request.isAutoCommit())
00227 { // Use a connection just for this request
00228 Connection c = null;
00229 try
00230 {
00231 c = cm.getConnection();
00232 }
00233 catch (UnreachableBackendException e1)
00234 {
00235 String backendName = backend.getName();
00236 logger.error(Translate.get(
00237 "loadbalancer.backend.disabling.unreachable", backendName));
00238 backend.disable();
00239 backend = null;
00240 throw new SQLException(Translate.get(
00241 "loadbalancer.backend.unreacheable", backendName));
00242 }
00243
00244 // Sanity check
00245 if (c == null)
00246 throw new SQLException(Translate.get(
00247 "loadbalancer.backend.no.connection", backend.getName()));
00248
00249 // Execute Query
00250 int result;
00251 try
00252 {
00253 backend.addPendingWriteRequest(request);
00254 Statement s = c.createStatement();
00255 if (backend.getDriverCompliance().supportSetQueryTimeout())
00256 s.setQueryTimeout(request.getTimeout());
00257 String sql = request.getSQL();
00258 // Rewrite the query if needed
00259 sql = backend.rewriteQuery(sql);
00260 result = s.executeUpdate(sql);
00261 }
00262 catch (SQLException e)
00263 {
00264 throw new SQLException(Translate.get(
00265 "loadbalancer.request.failed.on.backend", new String[]{
00266 request.getSQLShortForm(vdb.getSQLShortFormLength()),
00267 backend.getName(), e.getMessage()}));
00268 }
00269 finally
00270 {
00271 backend.removePendingRequest(request);
00272 cm.releaseConnection(c);
00273 }
00274 return result;
00275 }
00276 else
00277 { // Re-use the connection used by this transaction
00278 Connection c = cm.retrieveConnection(request.getTransactionId());
00279
00280 // Sanity check
00281 if (c == null)
00282 throw new SQLException(Translate.get(
00283 "loadbalancer.unable.retrieve.connection",
00284 new String[]{String.valueOf(request.getTransactionId()),
00285 backend.getName()}));
00286
00287 // Execute Query
00288 try
00289 {
00290 backend.addPendingWriteRequest(request);
00291 Statement s = c.createStatement();
00292 if (backend.getDriverCompliance().supportSetQueryTimeout())
00293 s.setQueryTimeout(request.getTimeout());
00294 String sql = request.getSQL();
00295 // Rewrite the query if needed
00296 sql = backend.rewriteQuery(sql);
00297 return s.executeUpdate(sql);
00298 }
00299 catch (SQLException e)
00300 {
00301 throw new SQLException(Translate.get(
00302 "loadbalancer.request.failed.on.backend", new String[]{
00303 request.getSQLShortForm(vdb.getSQLShortFormLength()),
00304 backend.getName(), e.getMessage()}));
00305 }
00306 finally
00307 {
00308 backend.removePendingRequest(request);
00309 }
00310 }
00311 }
00312 catch (RuntimeException e)
00313 {
00314 String msg = Translate.get("loadbalancer.request.failed.on.backend",
00315 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()),
00316 backend.getName(), e.getMessage()});
00317 logger.fatal(msg, e);
00318 throw new SQLException(msg);
00319 }
00320 }
|
|
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 325 行で定義されています。 参照先 java.sql.Statement.executeUpdate(), org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.getConnection(), と java.sql.Statement.setQueryTimeout().
00327 {
00328 if (backend == null)
00329 throw new SQLException(Translate.get(
00330 "loadbalancer.execute.no.backend.available", request.getId()));
00331
00332 if (!backend.getDriverCompliance().supportGetGeneratedKeys())
00333 throw new SQLException(Translate.get(
00334 "loadbalancer.backend.autogeneratedkeys.unsupported", backend
00335 .getName()));
00336
00337 try
00338 {
00339 AbstractConnectionManager cm = backend.getConnectionManager(request
00340 .getLogin());
00341 if (request.isAutoCommit())
00342 { // Use a connection just for this request
00343 Connection c = null;
00344 try
00345 {
00346 c = cm.getConnection();
00347 }
00348 catch (UnreachableBackendException e1)
00349 {
00350 String backendName = backend.getName();
00351 logger.error(Translate.get(
00352 "loadbalancer.backend.disabling.unreachable", backendName));
00353 backend.disable();
00354 backend = null;
00355 throw new SQLException(Translate.get(
00356 "loadbalancer.backend.unreacheable", backendName));
00357 }
00358
00359 // Sanity check
00360 if (c == null)
00361 throw new SQLException(Translate.get(
00362 "loadbalancer.backend.no.connection", backend.getName()));
00363
00364 // Execute Query
00365 ResultSet result;
00366 try
00367 {
00368 backend.addPendingWriteRequest(request);
00369 Statement s = c.createStatement();
00370 if (backend.getDriverCompliance().supportSetQueryTimeout())
00371 s.setQueryTimeout(request.getTimeout());
00372 String sql = request.getSQL();
00373 // Rewrite the query if needed
00374 sql = backend.rewriteQuery(sql);
00375 int rows = s.executeUpdate(sql,
00376 java.sql.Statement.RETURN_GENERATED_KEYS);
00377 if (logger.isDebugEnabled())
00378 logger.debug(Translate.get("loadbalancer.request.affected",
00379 new String[]{String.valueOf(request.getId()),
00380 String.valueOf(rows)}));
00381 result = s.getGeneratedKeys();
00382 }
00383 catch (SQLException e)
00384 {
00385 throw new SQLException(Translate.get(
00386 "loadbalancer.request.failed.on.backend", new String[]{
00387 request.getSQLShortForm(vdb.getSQLShortFormLength()),
00388 backend.getName(), e.getMessage()}));
00389 }
00390 finally
00391 {
00392 backend.removePendingRequest(request);
00393 cm.releaseConnection(c);
00394 }
00395 return result;
00396 }
00397 else
00398 { // Re-use the connection used by this transaction
00399 Connection c = cm.retrieveConnection(request.getTransactionId());
00400
00401 // Sanity check
00402 if (c == null)
00403 throw new SQLException(Translate.get(
00404 "loadbalancer.unable.retrieve.connection",
00405 new String[]{String.valueOf(request.getTransactionId()),
00406 backend.getName()}));
00407
00408 // Execute Query
00409 ResultSet result;
00410 try
00411 {
00412 backend.addPendingWriteRequest(request);
00413 Statement s = c.createStatement();
00414 if (backend.getDriverCompliance().supportSetQueryTimeout())
00415 s.setQueryTimeout(request.getTimeout());
00416 String sql = request.getSQL();
00417 // Rewrite the query if needed
00418 sql = backend.rewriteQuery(sql);
00419 int rows = s.executeUpdate(sql,
00420 java.sql.Statement.RETURN_GENERATED_KEYS);
00421 if (logger.isDebugEnabled())
00422 logger.debug(Translate.get("loadbalancer.request.affected",
00423 new String[]{String.valueOf(request.getId()),
00424 String.valueOf(rows)}));
00425 return s.getGeneratedKeys();
00426 }
00427 catch (SQLException e)
00428 {
00429 throw new SQLException(Translate.get(
00430 "loadbalancer.request.failed.on.backend", new String[]{
00431 request.getSQLShortForm(vdb.getSQLShortFormLength()),
00432 backend.getName(), e.getMessage()}));
00433 }
00434 finally
00435 {
00436 backend.removePendingRequest(request);
00437 }
00438 }
00439 }
00440 catch (RuntimeException e)
00441 {
00442 String msg = Translate.get("loadbalancer.request.failed.on.backend",
00443 new String[]{request.getSQLShortForm(vdb.getSQLShortFormLength()),
00444 backend.getName(), e.getMessage()});
00445 logger.fatal(msg, e);
00446 throw new SQLException(msg);
00447 }
00448 }
|
|
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 565 行で定義されています。 参照先 org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.getConnection(), と org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.releaseConnection().
00566 {
00567 if (backend == null)
00568 throw new SQLException(
00569 "No available backend to execute stored procedure " + proc.getId());
00570
00571 try
00572 {
00573 AbstractConnectionManager cm = backend.getConnectionManager(proc
00574 .getLogin());
00575 if (proc.isAutoCommit())
00576 { // Use a connection just for this request
00577 Connection c = null;
00578 try
00579 {
00580 c = cm.getConnection();
00581 }
00582 catch (UnreachableBackendException e1)
00583 {
00584 String backendName = backend.getName();
00585 logger.error(Translate.get(
00586 "loadbalancer.backend.disabling.unreachable", backendName));
00587 backend.disable();
00588 backend = null;
00589 throw new SQLException(Translate.get(
00590 "loadbalancer.backend.unreacheable", backendName));
00591 }
00592
00593 // Sanity check
00594 if (c == null)
00595 throw new SQLException(Translate.get(
00596 "loadbalancer.backend.no.connection", backend.getName()));
00597
00598 // Execute Query
00599 int result;
00600 try
00601 {
00602 CallableStatement cs = c.prepareCall(proc.getSQL());
00603 if (backend.getDriverCompliance().supportSetQueryTimeout())
00604 cs.setQueryTimeout(proc.getTimeout());
00605 result = cs.executeUpdate();
00606 }
00607 catch (SQLException e)
00608 {
00609 throw new SQLException(Translate.get(
00610 "loadbalancer.storedprocedure.failed.on.backend", new String[]{
00611 proc.getSQLShortForm(vdb.getSQLShortFormLength()),
00612 backend.getName(), e.getMessage()}));
00613 }
00614 finally
00615 {
00616 cm.releaseConnection(c);
00617 }
00618 return result;
00619 }
00620 else
00621 { // Re-use the connection used by this transaction
00622 Connection c = cm.retrieveConnection(proc.getTransactionId());
00623
00624 // Sanity check
00625 if (c == null)
00626 throw new SQLException(Translate.get(
00627 "loadbalancer.unable.retrieve.connection", new String[]{
00628 String.valueOf(proc.getTransactionId()), backend.getName()}));
00629
00630 // Execute Query
00631 try
00632 {
00633 CallableStatement cs = c.prepareCall(proc.getSQL());
00634 if (backend.getDriverCompliance().supportSetQueryTimeout())
00635 cs.setQueryTimeout(proc.getTimeout());
00636 return cs.executeUpdate();
00637 }
00638 catch (SQLException e)
00639 {
00640 throw new SQLException(Translate.get(
00641 "loadbalancer.storedprocedure.failed.on.backend", new String[]{
00642 proc.getSQLShortForm(vdb.getSQLShortFormLength()),
00643 backend.getName(), e.getMessage()}));
00644 }
00645 }
00646 }
00647 catch (RuntimeException e)
00648 {
00649 String msg = Translate.get(
00650 "loadbalancer.storedprocedure.failed.on.backend", new String[]{
00651 proc.getSQLShortForm(vdb.getSQLShortFormLength()),
00652 backend.getName(), e.getMessage()});
00653 logger.fatal(msg, e);
00654 throw new SQLException(msg);
00655 }
00656 }
|
|
|
Gets information about the request load balancer
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 864 行で定義されています。
|
|
|
Get the needed query parsing granularity.
AbstractLoadBalancer.java の 151 行で定義されています。 参照元 org.objectweb.cjdbc.controller.requestmanager.RequestManager.setLoadBalancer().
00152 {
00153 return parsingGranularity;
00154 }
|
|
|
Returns the RAIDbLevel.
AbstractLoadBalancer.java の 131 行で定義されています。 参照先 org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.raidbLevel.
00132 {
00133 return raidbLevel;
00134 }
|
|
|
AbstractLoadBalancer.java の 385 行で定義されています。 参照先 org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.getXmlImpl().
00386 {
00387 StringBuffer info = new StringBuffer();
00388 info.append("<" + DatabasesXmlTags.ELT_LoadBalancer + ">");
00389 info.append(getXmlImpl());
00390 info.append("</" + DatabasesXmlTags.ELT_LoadBalancer + ">");
00391 return info.toString();
00392 }
|
|
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 875 行で定義されています。
00876 {
00877 return "<" + DatabasesXmlTags.ELT_SingleDB + "/>";
00878 }
|
|
|
Rollbacks a transaction.
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerに実装されています. SingleDB.java の 746 行で定義されています。 参照先 org.objectweb.cjdbc.controller.connection.AbstractConnectionManager.retrieveConnection().
00747 {
00748 if (backend == null)
00749 throw new SQLException("No available backend to rollback transaction "
00750 + tm.getTransactionId());
00751
00752 try
00753 {
00754 AbstractConnectionManager cm = backend
00755 .getConnectionManager(tm.getLogin());
00756 Connection c = cm.retrieveConnection(tm.getTransactionId());
00757
00758 if (c == null)
00759 throw new SQLException("No connection found for transaction "
00760 + tm.getTransactionId());
00761
00762 try
00763 {
00764 c.rollback();
00765 c.setAutoCommit(true);
00766 }
00767 catch (SQLException e)
00768 {
00769 throw new SQLException(Translate.get("loadbalancer.rollback.failed",
00770 new String[]{String.valueOf(tm.getTransactionId()),
00771 backend.getName(), e.getMessage()}));
00772 }
00773 finally
00774 {
00775 cm.releaseConnection(tm.getTransactionId());
00776 }
00777 }
00778 catch (RuntimeException e)
00779 {
00780 String msg = Translate.get("loadbalancer.rollback.failed", new String[]{
00781 String.valueOf(tm.getTransactionId()), backend.getName(),
00782 e.getMessage()});
00783 logger.fatal(msg, e);
00784 throw new SQLException(msg);
00785 }
00786 }
|
|
|
Set the needed query parsing granularity.
AbstractLoadBalancer.java の 161 行で定義されています。
00162 {
00163 this.parsingGranularity = parsingGranularity;
00164 }
|
|
|
Sets the RAIDbLevel.
AbstractLoadBalancer.java の 141 行で定義されています。
00142 {
00143 this.raidbLevel = raidbLevel;
00144 }
|
|
||||||||||||
|
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerを再定義しています。 SingleDB.java の 850 行で定義されています。
00851 {
00852 throw new SQLException("Weight is not supported with this load balancer");
00853 }
|
|
|
SingleDB.java の 67 行で定義されています。 |
|
|
初期値: Trace
.getLogger("org.objectweb.cjdbc.controller.loadbalancer.SingleDB")
org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancerを再定義しています。 SingleDB.java の 69 行で定義されています。 |
|
|
AbstractLoadBalancer.java の 74 行で定義されています。 |
|
|
|
AbstractLoadBalancer.java の 72 行で定義されています。 参照元 org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer.AbstractLoadBalancer(). |
1.3.6