org.objectweb.cjdbc.controller.requestmanager.RequestManager Class Reference

Inheritance diagram for org.objectweb.cjdbc.controller.requestmanager.RequestManager:

[legend]List of all members.

Public Member Functions
	RequestManager (VirtualDatabase vdb, AbstractScheduler scheduler, AbstractResultCache cache, AbstractLoadBalancer loadBalancer, AbstractRecoveryLog recoveryLog, long beginTimeout, long commitTimeout, long rollbackTimeout) throws SQLException, NotCompliantMBeanException
ControllerResultSet	execReadRequest (SelectRequest request) throws SQLException
int	execWriteRequest (AbstractWriteRequest request) throws SQLException
ControllerResultSet	execWriteRequestWithKeys (AbstractWriteRequest request) throws SQLException
void	scheduleExecWriteRequest (AbstractWriteRequest request) throws SQLException
ControllerResultSet	loadBalanceExecWriteRequestWithKeys (AbstractWriteRequest request) throws AllBackendsFailedException, SQLException
int	loadBalanceExecWriteRequest (AbstractWriteRequest request) throws AllBackendsFailedException, SQLException
void	updateAndNotifyExecWriteRequest (AbstractWriteRequest request, boolean notifyRecoveryLogAndScheduler) throws SQLException
ControllerResultSet	execReadStoredProcedure (StoredProcedure proc) throws SQLException
int	execWriteStoredProcedure (StoredProcedure proc) throws SQLException
long	begin (String login) throws SQLException
void	abort (long transactionId) throws SQLException
TransactionMarkerMetaData	getTransactionMarker (Long tid) throws SQLException
void	completeTransaction (Long tid)
void	commit (long transactionId) throws SQLException
void	rollback (long transactionId) throws SQLException
void	enableBackend (DatabaseBackend db) throws SQLException
JDBCRecoverThread	enableBackendFromCheckpoint (DatabaseBackend db, String checkpointName) throws SQLException
void	disableBackend (DatabaseBackend db) throws SQLException
void	disableBackendForCheckpoint (DatabaseBackend db, String checkpointName) throws SQLException
void	disableBackendsForCheckpoint (ArrayList backendsArrayList, String checkpointName) throws SQLException
void	callBackupManager (boolean backup, DatabaseBackend db, String checkpoint, ArrayList tables, boolean enableAfter, BackupListener listener) throws Exception
void	backupBackendWithCheckpoint (DatabaseBackend backend, String checkpointName, ArrayList tables, boolean enableAfter, boolean wait4Result, BackupListener listener) throws SQLException
void	restoreBackendFromBackupCheckpoint (DatabaseBackend db, String checkpointName, boolean wait4Result, BackupListener listener) throws OctopusException, BackupException
void	storeBackendsInfo (String databaseName, ArrayList backends)
void	removeCheckpoint (String checkpointName) throws SQLException
VirtualDatabase	getVirtualDatabase ()
void	setDatabaseSchema (DatabaseSchema schema, boolean isStatic)
void	mergeDatabaseSchema (DatabaseSchema backendSchema)
void	setBackupManager (BackupManager currentBackupManager)
BackupManager	getBackupManager ()
DatabaseSchema	getDatabaseSchema ()
AbstractLoadBalancer	getLoadBalancer ()
void	setLoadBalancer (AbstractLoadBalancer loadBalancer)
AbstractResultCache	getResultCache ()
MetadataCache	getMetadataCache ()
void	setMetadataCache (MetadataCache metadataCache)
void	setParsingCache (ParsingCache parsingCache)
AbstractRecoveryLog	getRecoveryLog ()
void	setRecoveryLog (AbstractRecoveryLog recoveryLog)
void	setResultCache (AbstractResultCache cache)
AbstractScheduler	getScheduler ()
void	setScheduler (AbstractScheduler scheduler)
void	setCaseSensitiveParsing (boolean isCaseSensitiveParsing)
int	getRequiredParsingGranularity ()
String	getXml ()
BackendStateListener	getBackendStateListener ()
long	getBeginTimeout ()
void	setBeginTimeout (long beginTimeout)
int	getCacheParsingranularity ()
void	setCacheParsingranularity (int cacheParsingranularity)
long	getCommitTimeout ()
void	setCommitTimeout (long commitTimeout)
int	getLoadBalancerParsingranularity ()
void	setLoadBalancerParsingranularity (int loadBalancerParsingranularity)
int	getRequiredGranularity ()
void	setRequiredGranularity (int requiredGranularity)
long	getRollbackTimeout ()
void	setRollbackTimeout (long rollbackTimeout)
int	getSchedulerParsingranularity ()
void	setSchedulerParsingranularity (int schedulerParsingranularity)
boolean	isSchemaIsStatic ()
void	setSchemaIsStatic (boolean schemaIsStatic)
boolean	isCaseSensitiveParsing ()
String	getAssociatedString ()
Protected Attributes
long	beginTimeout
long	commitTimeout
long	rollbackTimeout
VirtualDatabase	vdb
AbstractScheduler	scheduler
AbstractResultCache	resultCache
AbstractLoadBalancer	loadBalancer
AbstractRecoveryLog	recoveryLog
BackupManager	backupManager
DatabaseSchema	dbs
ParsingCache	parsingCache = null
int	schedulerParsingranularity = ParsingGranularities.NO_PARSING
int	requiredGranularity = ParsingGranularities.NO_PARSING
Hashtable	tidLoginTable
Static Protected Attributes
Trace	logger = null

---

Detailed Description

This class defines the Request Manager.

The RM is composed of a Request Scheduler, an optional Query Cache, and a Load Balancer and an optional Recovery Log.

Author:

Emmanuel Cecchet

Julie Marguerite

Nicolas Modrzyk

Vadim Kassin

Version:

1.0

Definition at line 86 of file RequestManager.java.

---

Constructor & Destructor Documentation

org.objectweb.cjdbc.controller.requestmanager.RequestManager.RequestManager (  VirtualDatabase  vdb, AbstractScheduler  scheduler, AbstractResultCache  cache, AbstractLoadBalancer  loadBalancer, AbstractRecoveryLog  recoveryLog, long  beginTimeout, long  commitTimeout, long  rollbackTimeout )  throws SQLException, NotCompliantMBeanException

Creates a new RequestManager instance. Parameters: vdb  the virtual database this request manager belongs to scheduler  the Request Scheduler to use cache  a Query Cache implementation loadBalancer  the Request Load Balancer to use recoveryLog  the Log Recovery to use beginTimeout  timeout in seconds for begin commitTimeout  timeout in seconds for commit rollbackTimeout  timeout in seconds for rollback Exceptions: SQLException  if an error occurs NotCompliantMBeanException  if the MBean is not JMX compliant Definition at line 176 of file RequestManager.java. References org.objectweb.cjdbc.controller.requestmanager.RequestManager.beginTimeout, org.objectweb.cjdbc.controller.requestmanager.RequestManager.commitTimeout, org.objectweb.cjdbc.controller.requestmanager.RequestManager.loadBalancer, org.objectweb.cjdbc.controller.requestmanager.RequestManager.recoveryLog, org.objectweb.cjdbc.controller.requestmanager.RequestManager.resultCache, org.objectweb.cjdbc.controller.requestmanager.RequestManager.rollbackTimeout, org.objectweb.cjdbc.controller.requestmanager.RequestManager.scheduler, org.objectweb.cjdbc.controller.requestmanager.RequestManager.setRecoveryLog(), and org.objectweb.cjdbc.controller.requestmanager.RequestManager.vdb. { super(RequestManagerMBean.class); this.vdb = vdb; assignAndCheckSchedulerLoadBalancerValidity(scheduler, loadBalancer); // requiredGranularity is the maximum of each component granularity this.resultCache = cache; if (resultCache != null) { cacheParsingranularity = cache.getParsingGranularity(); if (cacheParsingranularity > requiredGranularity) requiredGranularity = cacheParsingranularity; } setRecoveryLog(recoveryLog); initRequestManagerVariables(vdb, beginTimeout, commitTimeout, rollbackTimeout); setBackendsLastKnownCheckpointFromRecoveryLog(); logger.info(Translate.get("requestmanager.parsing.granularity", ParsingGranularities.getInformation(requiredGranularity))); if (MBeanServerManager.isJmxEnabled()) { try { MBeanServerManager.registerMBean(this, JmxConstants .getRequestManagerObjectName(vdb.getVirtualDatabaseName())); } catch (Exception e) { logger.error(Translate.get("jmx.failed.register.mbean.requestmanager")); } } }

---

Member Function Documentation

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.abort (  long  transactionId  )  throws SQLException

Abort a transaction that has been started but in which no query was executed. As we use lazy transaction begin, there is no need to rollback such transaction but just to cleanup the metadata associated with this not effectively started transaction. Parameters: transactionId  id of the transaction to abort Exceptions: SQLException  if an error occurs Definition at line 1066 of file RequestManager.java. { try { Long tid = new Long(transactionId); TransactionMarkerMetaData tm = getTransactionMarker(tid); if (logger.isDebugEnabled()) logger.debug(Translate.get("transaction.abort", String .valueOf(transactionId))); try { // Notify the scheduler to abort which is the same as a rollback // from a // scheduler point of view. scheduler.rollback(tm); // Notify the recovery log manager if (recoveryLog != null) { recoveryLog.abort(tm); } } catch (SQLException e) { throw e; } finally { // Notify scheduler for completion scheduler.rollbackCompleted(transactionId); completeTransaction(tid); } } catch (RuntimeException e) { logger.fatal(Translate .get("fatal.runtime.exception.requestmanager.rollback"), e); throw new SQLException(e.getMessage()); } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.backupBackendWithCheckpoint (  DatabaseBackend  backend, String  checkpointName, ArrayList  tables, boolean  enableAfter, boolean  wait4Result, BackupListener  listener )  throws SQLException

Creates a new backup with the corresponding checkpoint Note that this will disable the backend for the time of the backup Parameters: backend  the backend to backup checkpointName  the checkpoint to insert in the log tables  to copy or null for copy all enableAfter  if the backend should be enable after backup wait4Result  if the method should block until the backup is over listener  object for callback Exceptions: SQLException  if fails Definition at line 1505 of file RequestManager.java. { if (backend.isReadEnabled()) { // Disable backend and store checkpoint disableBackendForCheckpoint(backend, checkpointName); logger.info(Translate.get("backend.state.disabled", backend.getName())); } // else backend is already disabled, no checkpoint is stored here, it should // have been done at disable time. try { logger.info(Translate.get("controller.backup.octopus.start", backend .getName())); backupManager.backup(backend, checkpointName, tables, listener); if (wait4Result) backupManager.getResult(backend, 0); } catch (OctopusException e) { logger.error(Translate.get("controller.backup.octopus.failed"), e); throw new SQLException(e.getMessage()); } catch (BackupException be) { logger.error(Translate.get("controller.backup.failed"), be); throw new SQLException(be.getMessage()); } logger.info(Translate.get("controller.backup.complete", backend.getName())); if (enableAfter) { JDBCRecoverThread thread = enableBackendFromCheckpoint(backend, checkpointName); if (wait4Result) try { thread.join(); } catch (InterruptedException e) { logger.error("Recovery thread has been interrupted", e); } } }

long org.objectweb.cjdbc.controller.requestmanager.RequestManager.begin (  String  login  )  throws SQLException

Begin a new transaction and return the corresponding transaction identifier. This method is called from the driver when setAutoCommit(false) is called. Parameters: login  the login used by the connection Returns: int a unique transaction identifier Exceptions: SQLException  if an error occurs Reimplemented in org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager. Definition at line 1011 of file RequestManager.java. References org.objectweb.cjdbc.controller.requestmanager.TransactionMarkerMetaData.setTransactionId(). { try { TransactionMarkerMetaData tm = new TransactionMarkerMetaData(0, beginTimeout, login); // Wait for the scheduler to give us the authorization to execute long tid = scheduler.begin(tm); tm.setTransactionId(tid); if (logger.isDebugEnabled()) logger.debug(Translate.get("transaction.begin", String.valueOf(tid))); try { // Send to load balancer loadBalancer.begin(tm); // Log the begin if (recoveryLog != null) { recoveryLog.begin(tm); } } catch (SQLException e) { throw e; } finally { // Notify scheduler for completion in any case scheduler.beginCompleted(tid); } tidLoginTable.put(new Long(tid), tm); return tid; } catch (RuntimeException e) { logger.fatal(Translate.get( "fatal.runtime.exception.requestmanager.begin", e)); throw new SQLException(e.getMessage()); } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.callBackupManager (  boolean  backup, DatabaseBackend  db, String  checkpoint, ArrayList  tables, boolean  enableAfter, BackupListener  listener )  throws Exception

Call the backup manager on the given backend. Start a fire and forget thread for backup or recovery. The only way to get the results is to wait for jmx notifications Parameters: backup  true if this is a backup, false if this is a restore process db  backend object checkpoint  the name of the checkpoint associated with the process tables  the tables to consider while performing the copy enableAfter  should be enable the backend automatically after listener  backup listener for callback Exceptions: Exception  if fails Definition at line 1482 of file RequestManager.java. { if (backup) backupBackendWithCheckpoint(db, checkpoint, tables, enableAfter, false, listener); else restoreBackendFromBackupCheckpoint(db, checkpoint, false, listener); }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.commit (  long  transactionId  )  throws SQLException

Commit a transaction given its id. Parameters: transactionId  the transaction id Exceptions: SQLException  if an error occurs Reimplemented in org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager. Definition at line 1147 of file RequestManager.java. References org.objectweb.cjdbc.controller.requestmanager.TransactionMarkerMetaData.getTransactionId(). { try { Long tid = new Long(transactionId); TransactionMarkerMetaData tm = getTransactionMarker(tid); // Wait for the scheduler to give us the authorization to execute scheduler.commit(tm); if (logger.isDebugEnabled()) logger.debug(Translate.get("transaction.commit", String.valueOf(tid))); try { // Send to load balancer loadBalancer.commit(tm); // Notify the cache if (resultCache != null) resultCache.commit(tm.getTransactionId()); // Notify the recovery log manager if (recoveryLog != null) recoveryLog.commit(tm); } catch (SQLException e) { throw e; } catch (AllBackendsFailedException e) { String msg = "All backends failed to commit transaction " + transactionId + " (" + e + ")"; logger.error(msg); throw new SQLException(msg); } finally { // Notify scheduler for completion scheduler.commitCompleted(transactionId); completeTransaction(tid); } } catch (RuntimeException e) { logger.fatal(Translate.get( "fatal.runtime.exception.requestmanager.commit", e)); throw new SQLException(e.getMessage()); } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.completeTransaction (  Long  tid  )

Complete the transaction by removing it from the tidLoginTable. Parameters: tid  transaction id Definition at line 1136 of file RequestManager.java. { tidLoginTable.remove(tid); }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.disableBackend (  DatabaseBackend  db  )  throws SQLException

Disable a backend that is currently enabled on this virtual database. The backend is disabled without further check. The load balancer disabled method is called on the specified backend. Parameters: db  The database backend to disable Exceptions: SQLException  if an error occurs Definition at line 1337 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.virtualdatabase.DistributedVirtualDatabase.transferBackend(). { if (db.isReadEnabled() || db.isWriteEnabled()) { loadBalancer.disableBackend(db); logger.info(Translate.get("backend.state.disabled", db.getName())); } else { throw new SQLException(Translate.get("backend.already.disabled", db .getName())); } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.disableBackendForCheckpoint (  DatabaseBackend  db, String  checkpointName )  throws SQLException

The backend must belong to this virtual database and be in the enabled state. The backend is disabled once all the pending write queries are executed. A checkpoint is inserted in the recovery log. Parameters: db  The database backend to enable checkpointName  The checkpoint name to restart from Exceptions: SQLException  if an error occurs Definition at line 1362 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.virtualdatabase.DistributedVirtualDatabase.transferBackend(). { // Sanity checks if (recoveryLog == null) { String msg = Translate.get("recovery.store.checkpoint.failed.cause.null", checkpointName); logger.error(msg); throw new SQLException(msg); } // Wait for all pending writes to finish logger.info(Translate.get("requestmanager.wait.pending.writes")); scheduler.suspendWrites(); // Store checkpoint recoveryLog.storeCheckpoint(checkpointName); logger.info(Translate.get("recovery.checkpoint.stored", checkpointName)); // Signal the backend should not begin any new transaction db.setState(BackendState.DISABLING); logger.info(Translate.get("backend.state.disabling", db.getName())); // Resume writes logger.info(Translate.get("requestmanager.resume.pending.writes")); scheduler.resumeWrites(); // Wait for all current transactions on the backend to finish db.waitForAllTransactionsToComplete(); // Now we can safely disable the backend db.setLastKnownCheckpoint(checkpointName); loadBalancer.disableBackend(db); logger.info(Translate.get("backend.state.disabled", db.getName())); }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.disableBackendsForCheckpoint (  ArrayList  backendsArrayList, String  checkpointName )  throws SQLException

Disable a list of backends. Only to store only one checkpoint, and to disable all the backends at the same time so the the system is in a coherent state. Consider only the backends that were enabled. The others are left in the state they were before. Parameters: backendsArrayList  backends to disable checkpointName  to store Exceptions: SQLException  if an error occurs Definition at line 1409 of file RequestManager.java. References org.objectweb.cjdbc.controller.backend.DatabaseBackend.getName(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.isWriteEnabled(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.setLastKnownCheckpoint(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.setState(), and org.objectweb.cjdbc.controller.backend.DatabaseBackend.waitForAllTransactionsToComplete(). { // Sanity checks if (recoveryLog == null) { String msg = Translate.get("recovery.store.checkpoint.failed.cause.null", checkpointName); logger.error(msg); throw new SQLException(msg); } // Wait for all pending writes to finish logger.info(Translate.get("requestmanager.wait.pending.writes")); scheduler.suspendWrites(); // Store checkpoint recoveryLog.storeCheckpoint(checkpointName); logger.info(Translate.get("recovery.checkpoint.stored", checkpointName)); // Copy the list and consider only the backends that are enabled DatabaseBackend db; ArrayList backendList = (ArrayList) backendsArrayList.clone(); for (int i = 0; i < backendList.size(); i++) { db = (DatabaseBackend) backendList.get(i); if (!db.isWriteEnabled()) backendList.remove(i); } // Signal all backends that they should not begin any new transaction int size = backendList.size(); for (int i = 0; i < size; i++) { db = (DatabaseBackend) backendList.get(i); db.setState(BackendState.DISABLING); logger.info(Translate.get("backend.state.disabling", db.getName())); } // Resume writes logger.info(Translate.get("requestmanager.resume.pending.writes")); scheduler.resumeWrites(); // Wait for all current transactions on backends to finish for (int i = 0; i < size; i++) { db = (DatabaseBackend) backendList.get(i); db.waitForAllTransactionsToComplete(); } // Now we can safely disable all backends for (int i = 0; i < size; i++) { db = (DatabaseBackend) backendList.get(i); db.setLastKnownCheckpoint(checkpointName); loadBalancer.disableBackend(db); logger.info(Translate.get("backend.state.disabled", db.getName())); } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.enableBackend (  DatabaseBackend  db  )  throws SQLException

Enable a backend that has been previously added to this virtual database and that is in the disabled state. The backend is enabled without further check. The enableBackend method of the load balancer is called. Parameters: db  The database backend to enable Exceptions: SQLException  if an error occurs Reimplemented in org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager. Definition at line 1277 of file RequestManager.java. { loadBalancer.enableBackend(db, true); logger.info(Translate.get("backend.state.enabled", db.getName())); }

JDBCRecoverThread org.objectweb.cjdbc.controller.requestmanager.RequestManager.enableBackendFromCheckpoint (  DatabaseBackend  db, String  checkpointName )  throws SQLException

The backend must have been previously added to this virtual database and be in the disabled state. All the queries since the given checkpoint are played and the backend state is set to enabled when it is completely synchronized. Note that the job is performed in background by a JDBCRecoverThread. You can synchronize on thread termination if you need to wait for completion of this task and listen to JMX notifications for the success status. Parameters: db  The database backend to enable checkpointName  The checkpoint name to restart from Returns: the JDBC reocver thread synchronizing the backend Exceptions: SQLException  if an error occurs Definition at line 1300 of file RequestManager.java. { // Sanity check if (recoveryLog == null) { String msg = Translate.get( "recovery.restore.checkpoint.failed.cause.null", checkpointName); logger.error(msg); throw new SQLException(msg); } if (db.getStateValue() == BackendState.REPLAYING || db.getStateValue() == BackendState.RECOVERING) throw new SQLException(Translate.get( "recovery.restore.backend.state.invalid", db.getName())); JDBCRecoverThread recoverThread = new JDBCRecoverThread(scheduler, recoveryLog, db, loadBalancer, checkpointName); // fire the thread and forget // exception will be reported in a jmx notification on the // backend. recoverThread.start(); return recoverThread; }

ControllerResultSet org.objectweb.cjdbc.controller.requestmanager.RequestManager.execReadRequest (  SelectRequest  request  )  throws SQLException

Perform a read request and return the reply. Call first the scheduler, then the cache (if defined) and finally the load balancer. Parameters: request  the request to execute Returns: a ControllerResultSet value Exceptions: SQLException  if an error occurs Reimplemented in org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager. Definition at line 312 of file RequestManager.java. { // Sanity check if (!request.isAutoCommit()) { // Check that the transaction has been // started long tid = request.getTransactionId(); if (!tidLoginTable.containsKey(new Long(tid))) throw new SQLException(Translate.get("transaction.not.started", tid)); } // If we need to parse the request, try to get the parsing from the // cache. // Note that if we have a cache miss but backgroundParsing has been // turned // on, then this call will start a ParsedThread in background. if ((requiredGranularity != ParsingGranularities.NO_PARSING) && (!request.isParsed())) { if (parsingCache == null) request.parse(dbs, requiredGranularity, isCaseSensitiveParsing); else parsingCache.getParsingFromCache(request); } // // SCHEDULER // // Get the parsing now if the request is not yet parsed. The parsing is // handled by the ParsingCache that may already have parsed the request // in background (if backgroundParsing is set). if ((schedulerParsingranularity != ParsingGranularities.NO_PARSING) && !request.isParsed()) { if (parsingCache == null) request.parse(dbs, requiredGranularity, isCaseSensitiveParsing); else parsingCache.getParsingFromCacheAndParseIfMissing(request); } if (logger.isDebugEnabled()) logger.debug(Translate.get("requestmanager.read.request.schedule", new String[]{String.valueOf(request.getId()), request.getSQLShortForm(vdb.getSQLShortFormLength())})); // Wait for the scheduler to give us the authorization to execute scheduler.scheduleReadRequest(request); // // CACHE // ControllerResultSet result = null; try { // Check cache if any if (resultCache != null) { if (logger.isDebugEnabled()) logger.debug(Translate.get("requestmanager.read.request.cache.get", new String[]{String.valueOf(request.getId()), request.getSQLShortForm(vdb.getSQLShortFormLength())})); CacheEntry qce = resultCache.getFromCache(request, true); if (qce != null) { result = qce.getResult(); if (result != null) { // Cache hit ! if (vdb.getSQLMonitor() != null) vdb.getSQLMonitor().logCacheHit(request); scheduler.readCompleted(request); return result; } } } // // LOAD BALANCER // if (logger.isDebugEnabled()) logger.debug(Translate.get("requestmanager.read.request.balance", new String[]{String.valueOf(request.getId()), request.getSQLShortForm(vdb.getSQLShortFormLength())})); // At this point, we have a result cache miss. // If we had a parsing cache miss too, wait for the parsing to be // done if // needed. if ((loadBalancerParsingranularity != ParsingGranularities.NO_PARSING) && !request.isParsed()) { if (parsingCache == null) request.parse(dbs, requiredGranularity, isCaseSensitiveParsing); else parsingCache.getParsingFromCacheAndParseIfMissing(request); } // Send the request to the load balancer result = loadBalancer.execReadRequest(request, metadataCache); // // UPDATES & NOTIFICATIONS // // Update cache if ((resultCache != null) && (request.getCacheAbility() != RequestType.UNCACHEABLE)) { if (logger.isDebugEnabled()) logger.debug(Translate.get( "requestmanager.read.request.cache.update", new String[]{ String.valueOf(request.getId()), request.getSQLShortForm(vdb.getSQLShortFormLength())})); if (!request.isParsed() && (cacheParsingranularity != ParsingGranularities.NO_PARSING)) { // The cache was the only one to need parsing and the request was not // previously in the cache { if (parsingCache == null) request.parse(dbs, requiredGranularity, isCaseSensitiveParsing); else parsingCache.getParsingFromCacheAndParseIfMissing(request); } } resultCache.addToCache(request, result); } } catch (Exception failed) { if (resultCache != null) resultCache.removeFromPendingQueries(request); scheduler.readCompleted(request); if (failed instanceof NoMoreBackendException) throw (NoMoreBackendException) failed; String msg = Translate.get("requestmanager.request.failed", new String[]{ request.getSQLShortForm(vdb.getSQLShortFormLength()), failed.getMessage()}); if (failed instanceof RuntimeException) logger.warn(msg, failed); else logger.warn(msg); if (failed instanceof SQLException) throw (SQLException) failed; throw new SQLException(msg); } // Notify scheduler of completion scheduler.readCompleted(request); return result; }

ControllerResultSet org.objectweb.cjdbc.controller.requestmanager.RequestManager.execReadStoredProcedure (  StoredProcedure  proc  )  throws SQLException

Call a stored procedure that returns a ResultSet. Parameters: proc  the stored procedure call Returns: a ControllerResultSet value Exceptions: SQLException  if an error occurs Reimplemented in org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager. Definition at line 802 of file RequestManager.java. References org.objectweb.cjdbc.common.sql.SelectRequest.debug(). { // Sanity check if (!proc.isAutoCommit()) { // Check that the transaction has been // started long tid = proc.getTransactionId(); if (!tidLoginTable.containsKey(new Long(tid))) throw new SQLException(Translate.get("transaction.not.started", tid)); } // // SCHEDULER // // Note that no parsing is required for stored procedures. // We build a fake request that span over all tables to be sure // that the scheduler will lock everything. SelectRequest spanOnAllTables = null; if (requiredGranularity != ParsingGranularities.NO_PARSING) { String sql = "SELECT * FROM"; ArrayList tables = dbs.getTables(); int size = tables.size(); // The following code does not generate a syntaxically correct SQL // request (an extra coma at the beginning) but that is not an // issue. for (int i = 0; i < size; i++) sql += " ," + ((DatabaseTable) tables.get(i)).getName(); spanOnAllTables = new SelectRequest(sql, false, 0, proc .getLineSeparator()); } else spanOnAllTables = new SelectRequest("select * from x", false, 0, proc .getLineSeparator()); // Wait for the scheduler to give us the authorization to execute scheduler.scheduleReadRequest(spanOnAllTables); if (logger.isDebugEnabled()) logger.debug(Translate.get("requestmanager.read.store.procedure", new String[]{String.valueOf(proc.getId()), proc.getSQLShortForm(vdb.getSQLShortFormLength())})); // // CACHE // // Cache is always flushed unless the user has explicitely set the // connection to read-only mode in which case we assume that the // users deliberately forces the cache not to be flushed when calling // this stored procedure. if ((resultCache != null) && (!proc.isReadOnly())) resultCache.flushCache(); ControllerResultSet result = null; try { // // LOAD BALANCER // // Send the request to the load balancer if (proc.isReadOnly()) result = loadBalancer.execReadOnlyReadStoredProcedure(proc, metadataCache); else result = loadBalancer.execReadStoredProcedure(proc, metadataCache); // // RECOVERY LOG // if (recoveryLog != null) recoveryLog.logRequest(proc, true); } catch (Exception failed) { scheduler.readCompleted(spanOnAllTables); String msg = Translate.get("requestmanager.store.procedure.failed", new String[]{proc.getSQLShortForm(vdb.getSQLShortFormLength()), failed.getMessage()}); logger.warn(msg); if (failed instanceof SQLException) { throw (SQLException) failed; } throw new SQLException(msg); } // Notify scheduler of completion scheduler.readCompleted(spanOnAllTables); return result; }

int org.objectweb.cjdbc.controller.requestmanager.RequestManager.execWriteRequest (  AbstractWriteRequest  request  )  throws SQLException

Perform a write request and return the number of rows affected Call first the scheduler (if defined), then notify the cache (if defined) and finally call the load balancer. Parameters: request  the request to execute Returns: number of rows affected Exceptions: SQLException  if an error occurs Reimplemented in org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager. Definition at line 479 of file RequestManager.java. { scheduleExecWriteRequest(request); int execWriteRequestResult = 0; try { execWriteRequestResult = loadBalanceExecWriteRequest(request); } catch (AllBackendsFailedException e) { String msg = Translate .get("requestmanager.write.request.failed.unexpected"); logger.fatal(msg, e); throw new RuntimeException(msg, e); } updateAndNotifyExecWriteRequest(request, true); return execWriteRequestResult; }

ControllerResultSet org.objectweb.cjdbc.controller.requestmanager.RequestManager.execWriteRequestWithKeys (  AbstractWriteRequest  request  )  throws SQLException

Perform a write request and return the auto generated keys. Call first the scheduler (if defined), then notify the cache (if defined) and finally call the load balancer. Parameters: request  the request to execute Returns: auto generated keys. Exceptions: SQLException  if an error occurs Reimplemented in org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager. Definition at line 507 of file RequestManager.java. { scheduleExecWriteRequest(request); ControllerResultSet execWriteRequestWithKeysResult = null; try { execWriteRequestWithKeysResult = loadBalanceExecWriteRequestWithKeys(request); } catch (AllBackendsFailedException e) { String msg = Translate .get("requestmanager.write.request.keys.failed.unexpected"); logger.fatal(msg, e); throw new RuntimeException(msg, e); } updateAndNotifyExecWriteRequest(request, true); return execWriteRequestWithKeysResult; }

int org.objectweb.cjdbc.controller.requestmanager.RequestManager.execWriteStoredProcedure (  StoredProcedure  proc  )  throws SQLException

Call a stored procedure that performs an update. Parameters: proc  the stored procedure call Returns: number of rows affected Exceptions: SQLException  if an error occurs Reimplemented in org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager. Definition at line 908 of file RequestManager.java. References org.objectweb.cjdbc.common.sql.SelectRequest.debug(). { // Sanity check if (!proc.isAutoCommit()) { // Check that the transaction has been // started long tid = proc.getTransactionId(); if (!tidLoginTable.containsKey(new Long(tid))) throw new SQLException(Translate.get("transaction.not.started", String .valueOf(tid))); } // // SCHEDULER // // Note that no parsing is required for stored procedures. // We build a fake request that span over all tables to be sure // that the scheduler will lock everything. SelectRequest spanOnAllTables = null; if (requiredGranularity != ParsingGranularities.NO_PARSING) { String sql = "SELECT * FROM"; ArrayList tables = dbs.getTables(); int size = tables.size(); // The following code does not generate a syntaxically correct SQL // request (an extra coma at the beginning) but that is not an // issue. for (int i = 0; i < size; i++) sql += " ," + ((DatabaseTable) tables.get(i)).getName(); spanOnAllTables = new SelectRequest(sql, false, 0, proc .getLineSeparator()); } else spanOnAllTables = new SelectRequest("select * from x", false, 0, proc .getLineSeparator()); // Wait for the scheduler to give us the authorization to execute // We schedule a read even if it is a write because there is no // way to lock all tables for write in a single query. FIXME! scheduler.scheduleReadRequest(spanOnAllTables); if (logger.isDebugEnabled()) logger.debug(Translate.get("requestmanager.write.store.procedure", new String[]{String.valueOf(proc.getId()), proc.getSQLShortForm(vdb.getSQLShortFormLength())})); // // CACHE // // Flush cache if any if (resultCache != null) resultCache.flushCache(); int result; try { // // LOAD BALANCER // // Send the request to the load balancer result = loadBalancer.execWriteStoredProcedure(proc); // // RECOVERY LOG // if (recoveryLog != null) recoveryLog.logRequest(proc, false); } catch (Exception failed) { scheduler.readCompleted(spanOnAllTables); String msg = Translate.get("requestmanager.store.procedure.failed", new String[]{proc.getSQLShortForm(vdb.getSQLShortFormLength()), failed.getMessage()}); logger.warn(msg); throw new SQLException(msg); } // Notify scheduler of completion scheduler.readCompleted(spanOnAllTables); return result; }

String org.objectweb.cjdbc.controller.requestmanager.RequestManager.getAssociatedString (   )

See also: org.objectweb.cjdbc.controller.jmx.AbstractStandardMBean.getAssociatedString() Definition at line 2171 of file RequestManager.java. { return "requestmanager"; }

BackendStateListener org.objectweb.cjdbc.controller.requestmanager.RequestManager.getBackendStateListener (   )

Returns the backendStateListener value. Returns: Returns the backendStateListener. Definition at line 1992 of file RequestManager.java. { return backendStateListener; }

BackupManager org.objectweb.cjdbc.controller.requestmanager.RequestManager.getBackupManager (   )

Returns the backupManager value. Returns: Returns the backupManager. Definition at line 1743 of file RequestManager.java. { return backupManager; }

long org.objectweb.cjdbc.controller.requestmanager.RequestManager.getBeginTimeout (   )

Returns the beginTimeout value. Returns: Returns the beginTimeout. Definition at line 2002 of file RequestManager.java. { return beginTimeout; }

int org.objectweb.cjdbc.controller.requestmanager.RequestManager.getCacheParsingranularity (   )

Returns the cacheParsingranularity value. Returns: Returns the cacheParsingranularity. Definition at line 2022 of file RequestManager.java. { return cacheParsingranularity; }

long org.objectweb.cjdbc.controller.requestmanager.RequestManager.getCommitTimeout (   )

Returns the commitTimeout value. Returns: Returns the commitTimeout. Definition at line 2042 of file RequestManager.java. { return commitTimeout; }

DatabaseSchema org.objectweb.cjdbc.controller.requestmanager.RequestManager.getDatabaseSchema (   )

Get the DatabaseSchema used by this Request Manager. Returns: a DatabaseSchema value Definition at line 1753 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.virtualdatabase.protocol.VirtualDatabaseConfiguration.isCompatible(), and org.objectweb.cjdbc.controller.virtualdatabase.protocol.VirtualDatabaseConfiguration.VirtualDatabaseConfiguration(). { return dbs; }

AbstractLoadBalancer org.objectweb.cjdbc.controller.requestmanager.RequestManager.getLoadBalancer (   )

Get the Request Load Balancer used in this Request Controller. Returns: an AbstractLoadBalancer value Definition at line 1763 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.virtualdatabase.protocol.VirtualDatabaseConfiguration.isCompatible(), and org.objectweb.cjdbc.controller.virtualdatabase.protocol.VirtualDatabaseConfiguration.VirtualDatabaseConfiguration(). { return loadBalancer; }

int org.objectweb.cjdbc.controller.requestmanager.RequestManager.getLoadBalancerParsingranularity (   )

Returns the loadBalancerParsingranularity value. Returns: Returns the loadBalancerParsingranularity. Definition at line 2062 of file RequestManager.java. { return loadBalancerParsingranularity; }

MetadataCache org.objectweb.cjdbc.controller.requestmanager.RequestManager.getMetadataCache (   )

Returns the metadataCache value. Returns: Returns the metadataCache. Definition at line 1816 of file RequestManager.java. { return metadataCache; }

AbstractRecoveryLog org.objectweb.cjdbc.controller.requestmanager.RequestManager.getRecoveryLog (   )

Returns the Recovery Log Manager. Returns: AbstractRecoveryLog Definition at line 1849 of file RequestManager.java. { return recoveryLog; }

int org.objectweb.cjdbc.controller.requestmanager.RequestManager.getRequiredGranularity (   )

Returns the requiredGranularity value. Returns: Returns the requiredGranularity. Definition at line 2083 of file RequestManager.java. { return requiredGranularity; }

int org.objectweb.cjdbc.controller.requestmanager.RequestManager.getRequiredParsingGranularity (   )

Returns: the parsing granularity required by the current configuration Definition at line 1940 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabaseWorkerThread.run(). { return requiredGranularity; }

AbstractResultCache org.objectweb.cjdbc.controller.requestmanager.RequestManager.getResultCache (   )

Get the result cache (if any) used in this Request Manager. Returns: an AbstractResultCache value or null if no Reqsult Cache has been defined Definition at line 1806 of file RequestManager.java. { return resultCache; }

long org.objectweb.cjdbc.controller.requestmanager.RequestManager.getRollbackTimeout (   )

Returns the rollbackTimeout value. Returns: Returns the rollbackTimeout. Definition at line 2103 of file RequestManager.java. { return rollbackTimeout; }

AbstractScheduler org.objectweb.cjdbc.controller.requestmanager.RequestManager.getScheduler (   )

Get the Request Scheduler (if any) used in this Request Controller. Returns: an AbstractScheduler value or null if no Request Scheduler has been defined Definition at line 1905 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.virtualdatabase.protocol.VirtualDatabaseConfiguration.isCompatible(), and org.objectweb.cjdbc.controller.virtualdatabase.protocol.VirtualDatabaseConfiguration.VirtualDatabaseConfiguration(). { return scheduler; }

int org.objectweb.cjdbc.controller.requestmanager.RequestManager.getSchedulerParsingranularity (   )

Returns the schedulerParsingranularity value. Returns: Returns the schedulerParsingranularity. Definition at line 2123 of file RequestManager.java. { return schedulerParsingranularity; }

TransactionMarkerMetaData org.objectweb.cjdbc.controller.requestmanager.RequestManager.getTransactionMarker (  Long  tid  )  throws SQLException

Get the TransactionMarkerMetaData for the given transaction id. Parameters: tid  transaction id Returns: the TransactionMarkerMetaData Exceptions: SQLException  if no marker has been found for this transaction Definition at line 1117 of file RequestManager.java. References org.objectweb.cjdbc.controller.requestmanager.TransactionMarkerMetaData.setTimeout(). { TransactionMarkerMetaData tm = (TransactionMarkerMetaData) tidLoginTable .get(tid); if (tm == null) throw new SQLException(Translate.get("transaction.marker.not.found", "" + tid)); tm.setTimeout(commitTimeout); return tm; }

VirtualDatabase org.objectweb.cjdbc.controller.requestmanager.RequestManager.getVirtualDatabase (   )

Returns the vdb value. Returns: Returns the vdb. Reimplemented in org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager. Definition at line 1655 of file RequestManager.java. { return vdb; }

String org.objectweb.cjdbc.controller.requestmanager.RequestManager.getXml (   )

Get xml information about this Request Manager Returns: String in xml formatted text Definition at line 1954 of file RequestManager.java. References org.objectweb.cjdbc.controller.backend.DatabaseBackend.toString(). { StringBuffer info = new StringBuffer(); info.append("<" + DatabasesXmlTags.ELT_RequestManager + " " + DatabasesXmlTags.ATT_caseSensitiveParsing + "=\"" + isCaseSensitiveParsing + "\" " + DatabasesXmlTags.ATT_beginTimeout + "=\"" + beginTimeout / 1000 + "\" " + DatabasesXmlTags.ATT_commitTimeout + "=\"" + commitTimeout / 1000 + "\" " + DatabasesXmlTags.ATT_rollbackTimeout + "=\"" + rollbackTimeout / 1000 + "\">"); if (scheduler != null) info.append(scheduler.getXml()); if (metadataCache != null || parsingCache != null || resultCache != null) { info.append("<" + DatabasesXmlTags.ELT_RequestCache + ">"); if (metadataCache != null) info.append(metadataCache.getXml()); if (parsingCache != null) info.append(parsingCache.getXml()); if (resultCache != null) info.append(resultCache.getXml()); info.append("</" + DatabasesXmlTags.ELT_RequestCache + ">"); } if (loadBalancer != null) info.append(loadBalancer.getXml()); if (recoveryLog != null) info.append(this.recoveryLog.getXml()); info.append("</" + DatabasesXmlTags.ELT_RequestManager + ">"); return info.toString(); }

boolean org.objectweb.cjdbc.controller.requestmanager.RequestManager.isCaseSensitiveParsing (   )

Returns the isCaseSensitiveParsing value. Returns: Returns the isCaseSensitiveParsing. Definition at line 2163 of file RequestManager.java. { return isCaseSensitiveParsing; }

boolean org.objectweb.cjdbc.controller.requestmanager.RequestManager.isSchemaIsStatic (   )

Returns the schemaIsStatic value. Returns: Returns the schemaIsStatic. Definition at line 2143 of file RequestManager.java. { return schemaIsStatic; }

int org.objectweb.cjdbc.controller.requestmanager.RequestManager.loadBalanceExecWriteRequest (  AbstractWriteRequest  request  )  throws AllBackendsFailedException, SQLException

Send the given query to the load balancer. If the request fails, the scheduler is properly notified. Parameters: request  the request to execute Exceptions: AllBackendsFailedException  if all backends failed to execute the query SQLException  if an error occurs Returns: number of modified lines Definition at line 666 of file RequestManager.java. { if (logger.isDebugEnabled()) logger.debug(Translate.get("requestmanager.write.request.balance", new String[]{String.valueOf(request.getId()), request.getSQLShortForm(vdb.getSQLShortFormLength())})); try { // Send the request to the load balancer if (request.isUpdate() && (resultCache != null)) { // Try the optimization if we try to update values that are already // up-to-date. if (!resultCache.isUpdateNecessary((UpdateRequest) request)) return 0; } return loadBalancer.execWriteRequest(request); } catch (Exception failed) { scheduler.writeCompleted(request); String msg = Translate.get("requestmanager.request.failed", new String[]{ request.getSQLShortForm(vdb.getSQLShortFormLength()), failed.getMessage()}); if (failed instanceof RuntimeException) logger.warn(msg, failed); else logger.warn(msg); if (failed instanceof AllBackendsFailedException) throw (AllBackendsFailedException) failed; else if (failed instanceof SQLException) throw (SQLException) failed; else throw new SQLException(msg); } }

ControllerResultSet org.objectweb.cjdbc.controller.requestmanager.RequestManager.loadBalanceExecWriteRequestWithKeys (  AbstractWriteRequest  request  )  throws AllBackendsFailedException, SQLException

Send the given query to the load balancer. If the request fails, the scheduler is properly notified. Parameters: request  the request to execute Exceptions: AllBackendsFailedException  if all backends failed to execute the query SQLException  if an error occurs Returns: auto-generated keys Definition at line 626 of file RequestManager.java. { if (logger.isDebugEnabled()) logger.debug(Translate.get("requestmanager.write.request.balance", new String[]{String.valueOf(request.getId()), request.getSQLShortForm(vdb.getSQLShortFormLength())})); try { // Send the request to the load balancer return loadBalancer.execWriteRequestWithKeys(request, metadataCache); } catch (Exception failed) { scheduler.writeCompleted(request); String msg = Translate.get("requestmanager.request.failed", new String[]{ request.getSQLShortForm(vdb.getSQLShortFormLength()), failed.getMessage()}); if (failed instanceof RuntimeException) logger.warn(msg, failed); else logger.warn(msg); if (failed instanceof AllBackendsFailedException) throw (AllBackendsFailedException) failed; else throw new SQLException(msg); } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.mergeDatabaseSchema (  DatabaseSchema  backendSchema  )

Merge the given schema with the existing database schema. Parameters: backendSchema  The virtual database schema to merge. Definition at line 1702 of file RequestManager.java. { try { if (dbs == null) setDatabaseSchema(new DatabaseSchema(backendSchema), false); else { dbs.mergeSchema(backendSchema); logger.info(Translate .get("requestmanager.schema.virtualdatabase.merged.new")); if (schedulerParsingranularity != ParsingGranularities.NO_PARSING) scheduler.mergeDatabaseSchema(dbs); if (cacheParsingranularity != ParsingGranularities.NO_PARSING) resultCache.mergeDatabaseSchema(dbs); } } catch (SQLException e) { logger.error(Translate.get("requestmanager.schema.merge.failed", e .getMessage()), e); } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.removeCheckpoint (  String  checkpointName  )  throws SQLException

Remove a checkpoint and corresponding entries from the log table Parameters: checkpointName  to remove Exceptions: SQLException  if fails Definition at line 1641 of file RequestManager.java. { recoveryLog.removeCheckpoint(checkpointName); }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.restoreBackendFromBackupCheckpoint (  DatabaseBackend  db, String  checkpointName, boolean  wait4Result, BackupListener  listener )  throws OctopusException, BackupException

Recopy all the data of a previous dump recorded by octopus into the named backend. This disables the backend and leave it disable after recovery process. The user has to call the enableBackendFromCheckpoint after this. Parameters: db  the backend to restore checkpointName  the name of the checkpoint that has a dump wait4Result  should we blocked this method until the restore is finished listener  object for callback Exceptions: OctopusException  if backup failed while in octopus mode BackupException  if backup failed for other reasons Definition at line 1568 of file RequestManager.java. { try { // no check for disable as we are going to overwrite // all the database data if (db.isReadEnabled()) loadBalancer.disableBackend(db); backupManager.restore(db, checkpointName, null, listener); if (wait4Result) backupManager.getResult(db, 0); } catch (SQLException e1) { // This comes from the loadbalancer throw new BackupException(ExceptionTypes.BACKEND_CANNOT_BE_DISABLED); } catch (OctopusException e) { logger.error(Translate.get("controller.octopus.recovery.failed"), e); throw e; } catch (BackupException be) { logger.error(Translate.get("controller.backup.recovery.failed"), be); throw be; } finally { logger.info(Translate .get("controller.backup.recovery.done", db.getName())); } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.rollback (  long  transactionId  )  throws SQLException

Rollback a transaction given its id. Parameters: transactionId  the transaction id Exceptions: SQLException  if an error occurs Reimplemented in org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager. Definition at line 1206 of file RequestManager.java. { try { Long tid = new Long(transactionId); TransactionMarkerMetaData tm = getTransactionMarker(tid); // Wait for the scheduler to give us the authorization to execute scheduler.rollback(tm); if (logger.isDebugEnabled()) logger.debug(Translate.get("transaction.rollback", String .valueOf(transactionId))); try { // Send to load balancer loadBalancer.rollback(tm); // Send to cache if (this.resultCache != null) resultCache.rollback(transactionId); // Notify the recovery log manager if (recoveryLog != null) { recoveryLog.rollback(tm); } } catch (SQLException e) { throw e; } catch (AllBackendsFailedException e) { String msg = Translate.get("requestmanager.rollback.failed.all", new String[]{String.valueOf(transactionId), e.getMessage()}); logger.error(msg); throw new SQLException(msg); } finally { // Notify scheduler for completion scheduler.rollbackCompleted(transactionId); completeTransaction(tid); } } catch (RuntimeException e) { logger.fatal(Translate .get("fatal.runtime.exception.requestmanager.rollback"), e); throw new SQLException(e.getMessage()); } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.scheduleExecWriteRequest (  AbstractWriteRequest  request  )  throws SQLException

Schedule a request for execution. Parameters: request  the request to execute Exceptions: SQLException  if an error occurs Reimplemented in org.objectweb.cjdbc.controller.requestmanager.distributed.DistributedRequestManager. Definition at line 533 of file RequestManager.java. { // Sanity check if (!request.isAutoCommit()) { // Check that the transaction has been // started long tid = request.getTransactionId(); if (!tidLoginTable.containsKey(new Long(tid))) throw new SQLException(Translate.get("transaction.not.started", tid)); } // If we need to parse the request, try to get the parsing from the // cache. // Note that if we have a cache miss but backgroundParsing has been // turned // on, then this call will start a ParsedThread in background. if ((requiredGranularity != ParsingGranularities.NO_PARSING) && (!request.isParsed())) { if (parsingCache == null) request.parse(dbs, requiredGranularity, isCaseSensitiveParsing); else parsingCache.getParsingFromCache(request); } // // SCHEDULER // // Get the parsing now if the request is not yet parsed. The parsing is // handled by the ParsingCache that may already have parsed the request // in background (if backgroundParsing is set). if ((schedulerParsingranularity != ParsingGranularities.NO_PARSING) && !request.isParsed()) { if (parsingCache == null) request.parse(dbs, requiredGranularity, isCaseSensitiveParsing); else parsingCache.getParsingFromCacheAndParseIfMissing(request); } if (logger.isDebugEnabled()) logger.debug(Translate.get("requestmanager.write.request.schedule", new String[]{String.valueOf(request.getId()), request.getSQLShortForm(vdb.getSQLShortFormLength())})); // Wait for the scheduler to give us the authorization to execute try { scheduler.scheduleWriteRequest(request); } catch (RollbackException e) { // Something bad happened and we need to // rollback this transaction rollback(request.getTransactionId()); throw new SQLException(e.getMessage()); } // If we have a parsing cache miss, wait for the parsing to be done if // needed. Note that even if the cache was the only one to require // parsing, // we wait for the parsing result here, because if it fails, we must not // execute the query. try { if ((requiredGranularity != ParsingGranularities.NO_PARSING) && !request.isParsed()) { if (parsingCache == null) request.parse(dbs, requiredGranularity, isCaseSensitiveParsing); else parsingCache.getParsingFromCacheAndParseIfMissing(request); } } catch (SQLException e) { // If the parsing fail, we must release the lock acquired ... scheduler.writeCompleted(request); throw e; } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setBackupManager (  BackupManager  currentBackupManager  )

Sets the backup manager for this recovery log Parameters: currentBackupManager  an instance of BackupManager Definition at line 1733 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.xml.DatabasesParser.endElement(). { this.backupManager = currentBackupManager; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setBeginTimeout (  long  beginTimeout  )

Sets the beginTimeout value. Parameters: beginTimeout  The beginTimeout to set. Definition at line 2012 of file RequestManager.java. { this.beginTimeout = beginTimeout; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setCacheParsingranularity (  int  cacheParsingranularity  )

Sets the cacheParsingranularity value. Parameters: cacheParsingranularity  The cacheParsingranularity to set. Definition at line 2032 of file RequestManager.java. { this.cacheParsingranularity = cacheParsingranularity; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setCaseSensitiveParsing (  boolean  isCaseSensitiveParsing  )

Sets the parsing case sensitivity. If true the request are parsed in a case sensitive way (table/column name must match exactly the case of the names fetched from the database or enforced by a static schema). Parameters: isCaseSensitiveParsing  true if parsing is case sensitive Definition at line 1930 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.xml.DatabasesParser.endElement(). { this.isCaseSensitiveParsing = isCaseSensitiveParsing; if (parsingCache != null) parsingCache.setCaseSensitiveParsing(isCaseSensitiveParsing); }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setCommitTimeout (  long  commitTimeout  )

Sets the commitTimeout value. Parameters: commitTimeout  The commitTimeout to set. Definition at line 2052 of file RequestManager.java. { this.commitTimeout = commitTimeout; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setDatabaseSchema (  DatabaseSchema  schema, boolean  isStatic )

Sets the DatabaseSchema to be able to parse the requests and find dependencies. Parameters: schema  a DatabaseSchema value isStatic  true if the given schema is static Definition at line 1667 of file RequestManager.java. References org.objectweb.cjdbc.controller.backend.DatabaseBackend.setDatabaseSchema(). Referenced by org.objectweb.cjdbc.controller.xml.DatabasesParser.endElement(). { if (schemaIsStatic) { if (isStatic) { logger.warn(Translate .get("requestmanager.schema.replace.static.with.new")); this.dbs = schema; } else logger.info(Translate.get("requestmanager.schema.ignore.new.dynamic")); } else { schemaIsStatic = isStatic; this.dbs = schema; logger.info(Translate .get("requestmanager.schema.set.new.virtualdatabase")); } if (schedulerParsingranularity != ParsingGranularities.NO_PARSING) scheduler.setDatabaseSchema(dbs); if (cacheParsingranularity != ParsingGranularities.NO_PARSING) resultCache.setDatabaseSchema(dbs); // Load balancers do not have a specific database schema to update }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setLoadBalancer (  AbstractLoadBalancer  loadBalancer  )

Set the Request Load Balancer to use in this Request Controller. Parameters: loadBalancer  a Request Load Balancer implementation Definition at line 1773 of file RequestManager.java. { if (this.loadBalancer != null) throw new RuntimeException( "It is not possible to dynamically change a load balancer."); this.loadBalancer = loadBalancer; if (loadBalancer == null) return; loadBalancerParsingranularity = loadBalancer.getParsingGranularity(); if (loadBalancerParsingranularity > requiredGranularity) requiredGranularity = loadBalancerParsingranularity; if (MBeanServerManager.isJmxEnabled()) { try { MBeanServerManager.registerMBean(loadBalancer, JmxConstants .getLoadBalancerObjectName(vdb.getVirtualDatabaseName())); } catch (Exception e) { logger.error(Translate.get("jmx.failed.register.mbean.loadbalancer")); } } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setLoadBalancerParsingranularity (  int  loadBalancerParsingranularity  )

Sets the loadBalancerParsingranularity value. Parameters: loadBalancerParsingranularity  The loadBalancerParsingranularity to set. Definition at line 2073 of file RequestManager.java. { this.loadBalancerParsingranularity = loadBalancerParsingranularity; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setMetadataCache (  MetadataCache  metadataCache  )

Sets the metadataCache value. Parameters: metadataCache  The metadataCache to set. Definition at line 1826 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.xml.DatabasesParser.endElement(). { this.metadataCache = metadataCache; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setParsingCache (  ParsingCache  parsingCache  )

Sets the ParsingCache. Parameters: parsingCache  The parsingCache to set. Definition at line 1836 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.xml.DatabasesParser.endElement(). { parsingCache.setRequestManager(this); parsingCache.setGranularity(requiredGranularity); parsingCache.setCaseSensitiveParsing(isCaseSensitiveParsing); this.parsingCache = parsingCache; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setRecoveryLog (  AbstractRecoveryLog  recoveryLog  )

Sets the Recovery Log Manager. Parameters: recoveryLog  The log recovery to set Definition at line 1859 of file RequestManager.java. References org.objectweb.cjdbc.controller.backend.DatabaseBackend.setStateListener(). Referenced by org.objectweb.cjdbc.controller.requestmanager.RequestManager.RequestManager(). { if (recoveryLog == null) return; this.recoveryLog = recoveryLog; ArrayList backends = vdb.getBackends(); int size = backends.size(); backendStateListener = new BackendStateListener(vdb .getVirtualDatabaseName(), recoveryLog); for (int i = 0; i < size; i++) ((DatabaseBackend) backends.get(i)) .setStateListener(backendStateListener); if (MBeanServerManager.isJmxEnabled()) { try { MBeanServerManager.registerMBean(recoveryLog, JmxConstants .getRecoveryLogObjectName(vdb.getVirtualDatabaseName())); } catch (Exception e) { logger.error(Translate.get("jmx.failed.register.mbean.recoverylog")); } } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setRequiredGranularity (  int  requiredGranularity  )

Sets the requiredGranularity value. Parameters: requiredGranularity  The requiredGranularity to set. Definition at line 2093 of file RequestManager.java. { this.requiredGranularity = requiredGranularity; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setResultCache (  AbstractResultCache  cache  )

Set the Request Cache to use in this Request Controller. Parameters: cache  a Request Cache implementation Definition at line 1891 of file RequestManager.java. { resultCache = cache; cacheParsingranularity = cache.getParsingGranularity(); if (cacheParsingranularity > requiredGranularity) requiredGranularity = cacheParsingranularity; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setRollbackTimeout (  long  rollbackTimeout  )

Sets the rollbackTimeout value. Parameters: rollbackTimeout  The rollbackTimeout to set. Definition at line 2113 of file RequestManager.java. { this.rollbackTimeout = rollbackTimeout; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setScheduler (  AbstractScheduler  scheduler  )

Set the Request Scheduler to use in this Request Controller. Parameters: scheduler  a Request Scheduler implementation Definition at line 1915 of file RequestManager.java. { this.scheduler = scheduler; schedulerParsingranularity = scheduler.getParsingGranularity(); if (schedulerParsingranularity > requiredGranularity) requiredGranularity = schedulerParsingranularity; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setSchedulerParsingranularity (  int  schedulerParsingranularity  )

Sets the schedulerParsingranularity value. Parameters: schedulerParsingranularity  The schedulerParsingranularity to set. Definition at line 2133 of file RequestManager.java. { this.schedulerParsingranularity = schedulerParsingranularity; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.setSchemaIsStatic (  boolean  schemaIsStatic  )

Sets the schemaIsStatic value. Parameters: schemaIsStatic  The schemaIsStatic to set. Definition at line 2153 of file RequestManager.java. References org.objectweb.cjdbc.controller.backend.DatabaseBackend.schemaIsStatic. { this.schemaIsStatic = schemaIsStatic; }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.storeBackendsInfo (  String  databaseName, ArrayList  backends )

Store all the backends checkpoint in the recoverylog Parameters: databaseName  the virtual database name backends  the Arraylist of backends Definition at line 1611 of file RequestManager.java. References org.objectweb.cjdbc.controller.backend.DatabaseBackend.getLastKnownCheckpoint(), org.objectweb.cjdbc.controller.backend.DatabaseBackend.getName(), and org.objectweb.cjdbc.controller.backend.DatabaseBackend.getStateValue(). { if (recoveryLog == null) return; int size = backends.size(); DatabaseBackend backend; for (int i = 0; i < size; i++) { backend = (DatabaseBackend) backends.get(i); try { recoveryLog.storeBackendRecoveryInfo(databaseName, new BackendRecoveryInfo(backend.getName(), backend .getLastKnownCheckpoint(), backend.getStateValue(), databaseName)); } catch (SQLException e) { logger.error(Translate.get("recovery.store.checkpoint.failed", new String[]{backend.getName(), e.getMessage()}), e); } } }

void org.objectweb.cjdbc.controller.requestmanager.RequestManager.updateAndNotifyExecWriteRequest (  AbstractWriteRequest  request, boolean  notifyRecoveryLogAndScheduler )  throws SQLException

Update the cache, notify the recovery log and finally the scheduler. It is possible to disable scheduler notifications (unless an error occurs in which case the scheduler is always notified). This is especially useful for distributed schedulers when all backends failed at one controller but we have to wait for the confirmation that all other controllers failed. This piece of code is then generic and reusable. Parameters: request  the request to execute notifyRecoveryLogAndScheduler  true if the recovery log and the scheduler must be notified Exceptions: SQLException  if an error occurs Definition at line 716 of file RequestManager.java. { try { // Notify cache if any if (resultCache != null) { // Update cache if (logger.isDebugEnabled()) logger.debug(Translate.get( "requestmanager.write.request.cache.update", new String[]{ String.valueOf(request.getId()), request.getSQLShortForm(vdb.getSQLShortFormLength())})); resultCache.writeNotify(request); } // Log the request if (notifyRecoveryLogAndScheduler && (recoveryLog != null)) { if (logger.isDebugEnabled()) logger.debug(Translate.get("requestmanager.write.request.log", new String[]{String.valueOf(request.getId()), request.getSQLShortForm(vdb.getSQLShortFormLength())})); recoveryLog.logRequest(request); } // Update the schema if needed if (requiredGranularity != ParsingGranularities.NO_PARSING) { if (request.isCreate()) { // Add the table to the schema dbs.addTable(((CreateRequest) request).getDatabaseTable()); if (logger.isDebugEnabled()) logger.debug(Translate.get("requestmanager.schema.add.table", request.getTableName())); } else if (request.isDrop()) { // Delete the table from the // schema dbs.removeTable(dbs.getTable(request.getTableName())); if (logger.isDebugEnabled()) logger.debug(Translate.get("requestmanager.schema.remove.table", request.getTableName())); } else if (request.isAlter() && (requiredGranularity > ParsingGranularities.TABLE)) { // Add or drop the column from the table AlterRequest req = (AlterRequest) request; if (req.isDrop()) dbs.getTable(req.getTableName()).remove(req.getColumn().getName()); else if (req.isAdd()) { dbs.getTable(req.getTableName()).addColumn(req.getColumn()); } } } // Notify scheduler if (notifyRecoveryLogAndScheduler) scheduler.writeCompleted(request); } catch (Exception failed) { scheduler.writeCompleted(request); String msg = Translate.get("requestmanager.request.failed", new String[]{ request.getSQLShortForm(vdb.getSQLShortFormLength()), failed.getMessage()}); if (failed instanceof RuntimeException) logger.warn(msg, failed); else logger.warn(msg); throw new SQLException(msg); } }

---

Member Data Documentation

BackupManager org.objectweb.cjdbc.controller.requestmanager.RequestManager.backupManager [protected]

The backup manager responsible for backup and restore of backends Definition at line 128 of file RequestManager.java.

long org.objectweb.cjdbc.controller.requestmanager.RequestManager.beginTimeout [protected]

begin timeout in ms Definition at line 104 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.requestmanager.RequestManager.RequestManager().

long org.objectweb.cjdbc.controller.requestmanager.RequestManager.commitTimeout [protected]

commit timeout in ms Definition at line 107 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.requestmanager.RequestManager.RequestManager().

AbstractLoadBalancer org.objectweb.cjdbc.controller.requestmanager.RequestManager.loadBalancer [protected]

The request load balancer to use to send requests to the databases Definition at line 122 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.requestmanager.RequestManager.RequestManager().

AbstractRecoveryLog org.objectweb.cjdbc.controller.requestmanager.RequestManager.recoveryLog [protected]

An optional recovery log Definition at line 125 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.requestmanager.RequestManager.RequestManager().

AbstractResultCache org.objectweb.cjdbc.controller.requestmanager.RequestManager.resultCache [protected]

An optional request cache to cache responses to SQL requests Definition at line 119 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.requestmanager.RequestManager.RequestManager().

long org.objectweb.cjdbc.controller.requestmanager.RequestManager.rollbackTimeout [protected]

rollback timeout in ms Definition at line 110 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.requestmanager.RequestManager.RequestManager().

AbstractScheduler org.objectweb.cjdbc.controller.requestmanager.RequestManager.scheduler [protected]

The request scheduler to order and schedule requests Definition at line 116 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.requestmanager.RequestManager.RequestManager().

Hashtable org.objectweb.cjdbc.controller.requestmanager.RequestManager.tidLoginTable [protected]

Transaction id/Login mapping Definition at line 152 of file RequestManager.java.

VirtualDatabase org.objectweb.cjdbc.controller.requestmanager.RequestManager.vdb [protected]

The virtual database owning this Request Manager Definition at line 113 of file RequestManager.java. Referenced by org.objectweb.cjdbc.controller.requestmanager.RequestManager.RequestManager().

---

The documentation for this class was generated from the following file:

• RequestManager.java

---