00001
00025
package org.objectweb.cjdbc.controller.xml;
00026
00027
import java.io.IOException;
00028
import java.io.InputStream;
00029
import java.io.StringReader;
00030
import java.sql.SQLException;
00031
import java.util.ArrayList;
00032
import java.util.Hashtable;
00033
00034
import javax.management.NotCompliantMBeanException;
00035
import javax.management.ObjectName;
00036
00037
import org.apache.regexp.RESyntaxException;
00038
import org.objectweb.cjdbc.common.exceptions.ControllerException;
00039
import org.objectweb.cjdbc.common.exceptions.ExceptionTypes;
00040
import org.objectweb.cjdbc.common.i18n.Translate;
00041
import org.objectweb.cjdbc.common.jmx.JmxConstants;
00042
import org.objectweb.cjdbc.common.log.Trace;
00043
import org.objectweb.cjdbc.common.sql.filters.AbstractBlobFilter;
00044
import org.objectweb.cjdbc.common.sql.filters.MacrosHandler;
00045
import org.objectweb.cjdbc.common.sql.schema.DatabaseColumn;
00046
import org.objectweb.cjdbc.common.sql.schema.DatabaseProcedure;
00047
import org.objectweb.cjdbc.common.sql.schema.DatabaseProcedureParameter;
00048
import org.objectweb.cjdbc.common.sql.schema.DatabaseSchema;
00049
import org.objectweb.cjdbc.common.sql.schema.DatabaseTable;
00050
import org.objectweb.cjdbc.common.users.AdminUser;
00051
import org.objectweb.cjdbc.common.users.DatabaseBackendUser;
00052
import org.objectweb.cjdbc.common.users.VirtualDatabaseUser;
00053
import org.objectweb.cjdbc.common.xml.DatabasesXmlTags;
00054
import org.objectweb.cjdbc.common.xml.XmlValidator;
00055
import org.objectweb.cjdbc.controller.authentication.AuthenticationManager;
00056
import org.objectweb.cjdbc.controller.authentication.AuthenticationManagerException;
00057
import org.objectweb.cjdbc.controller.backend.BackendRecoveryPolicy;
00058
import org.objectweb.cjdbc.controller.backend.DatabaseBackend;
00059
import org.objectweb.cjdbc.controller.backend.DatabaseBackendSchemaConstants;
00060
import org.objectweb.cjdbc.controller.backend.rewriting.AbstractRewritingRule;
00061
import org.objectweb.cjdbc.controller.backend.rewriting.PatternRewritingRule;
00062
import org.objectweb.cjdbc.controller.backend.rewriting.ReplaceAllRewritingRule;
00063
import org.objectweb.cjdbc.controller.backend.rewriting.SimpleRewritingRule;
00064
import org.objectweb.cjdbc.controller.backup.BackupManager;
00065
import org.objectweb.cjdbc.controller.cache.metadata.MetadataCache;
00066
import org.objectweb.cjdbc.controller.cache.parsing.ParsingCache;
00067
import org.objectweb.cjdbc.controller.cache.result.AbstractResultCache;
00068
import org.objectweb.cjdbc.controller.cache.result.CachingGranularities;
00069
import org.objectweb.cjdbc.controller.cache.result.ResultCacheFactory;
00070
import org.objectweb.cjdbc.controller.cache.result.ResultCacheRule;
00071
import org.objectweb.cjdbc.controller.cache.result.rules.EagerCaching;
00072
import org.objectweb.cjdbc.controller.connection.FailFastPoolConnectionManager;
00073
import org.objectweb.cjdbc.controller.connection.RandomWaitPoolConnectionManager;
00074
import org.objectweb.cjdbc.controller.connection.SimpleConnectionManager;
00075
import org.objectweb.cjdbc.controller.connection.VariablePoolConnectionManager;
00076
import org.objectweb.cjdbc.controller.core.Controller;
00077
import org.objectweb.cjdbc.controller.core.ControllerConstants;
00078
import org.objectweb.cjdbc.controller.jmx.MBeanServerManager;
00079
import org.objectweb.cjdbc.controller.loadbalancer.AbstractLoadBalancer;
00080
import org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB;
00081
import org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_LPRF;
00082
import org.objectweb.cjdbc.controller.loadbalancer.paralleldb.ParallelDB_RR;
00083
import org.objectweb.cjdbc.controller.loadbalancer.policies.WaitForCompletionPolicy;
00084
import org.objectweb.cjdbc.controller.loadbalancer.policies.createtable.CreateTableAll;
00085
import org.objectweb.cjdbc.controller.loadbalancer.policies.createtable.CreateTablePolicy;
00086
import org.objectweb.cjdbc.controller.loadbalancer.policies.createtable.CreateTableRandom;
00087
import org.objectweb.cjdbc.controller.loadbalancer.policies.createtable.CreateTableRoundRobin;
00088
import org.objectweb.cjdbc.controller.loadbalancer.policies.createtable.CreateTableRule;
00089
import org.objectweb.cjdbc.controller.loadbalancer.policies.errorchecking.ErrorCheckingAll;
00090
import org.objectweb.cjdbc.controller.loadbalancer.policies.errorchecking.ErrorCheckingPolicy;
00091
import org.objectweb.cjdbc.controller.loadbalancer.policies.errorchecking.ErrorCheckingRandom;
00092
import org.objectweb.cjdbc.controller.loadbalancer.policies.errorchecking.ErrorCheckingRoundRobin;
00093
import org.objectweb.cjdbc.controller.loadbalancer.raidb0.RAIDb0;
00094
import org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_LPRF;
00095
import org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_RR;
00096
import org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1_WRR;
00097
import org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1ec_RR;
00098
import org.objectweb.cjdbc.controller.loadbalancer.raidb1.RAIDb1ec_WRR;
00099
import org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_LPRF;
00100
import org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_RR;
00101
import org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2_WRR;
00102
import org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2ec_RR;
00103
import org.objectweb.cjdbc.controller.loadbalancer.raidb2.RAIDb2ec_WRR;
00104
import org.objectweb.cjdbc.controller.loadbalancer.singledb.SingleDB;
00105
import org.objectweb.cjdbc.controller.monitoring.SQLMonitoring;
00106
import org.objectweb.cjdbc.controller.monitoring.SQLMonitoringRule;
00107
import org.objectweb.cjdbc.controller.recoverylog.JDBCRecoveryLog;
00108
import org.objectweb.cjdbc.controller.requestmanager.RAIDbLevels;
00109
import org.objectweb.cjdbc.controller.requestmanager.RequestManager;
00110
import org.objectweb.cjdbc.controller.requestmanager.distributed.RAIDb1DistributedRequestManager;
00111
import org.objectweb.cjdbc.controller.requestmanager.distributed.RAIDb2DistributedRequestManager;
00112
import org.objectweb.cjdbc.controller.scheduler.AbstractScheduler;
00113
import org.objectweb.cjdbc.controller.scheduler.raidb0.RAIDb0PessimisticTransactionLevelScheduler;
00114
import org.objectweb.cjdbc.controller.scheduler.raidb0.RAIDb0QueryLevelScheduler;
00115
import org.objectweb.cjdbc.controller.scheduler.raidb1.RAIDb1OptimisticQueryLevelScheduler;
00116
import org.objectweb.cjdbc.controller.scheduler.raidb1.RAIDb1OptimisticTransactionLevelScheduler;
00117
import org.objectweb.cjdbc.controller.scheduler.raidb1.RAIDb1PessimisticTransactionLevelScheduler;
00118
import org.objectweb.cjdbc.controller.scheduler.raidb1.RAIDb1QueryLevelScheduler;
00119
import org.objectweb.cjdbc.controller.scheduler.raidb2.RAIDb2PessimisticTransactionLevelScheduler;
00120
import org.objectweb.cjdbc.controller.scheduler.raidb2.RAIDb2QueryLevelScheduler;
00121
import org.objectweb.cjdbc.controller.scheduler.singledb.SingleDBPessimisticTransactionLevelScheduler;
00122
import org.objectweb.cjdbc.controller.scheduler.singledb.SingleDBQueryLevelScheduler;
00123
import org.objectweb.cjdbc.controller.virtualdatabase.DistributedVirtualDatabase;
00124
import org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabase;
00125
import org.objectweb.cjdbc.controller.virtualdatabase.protocol.CJDBCGroupMessage;
00126
import org.xml.sax.Attributes;
00127
import org.xml.sax.InputSource;
00128
import org.xml.sax.SAXException;
00129
import org.xml.sax.SAXParseException;
00130
import org.xml.sax.XMLReader;
00131
import org.xml.sax.helpers.DefaultHandler;
00132
import org.xml.sax.helpers.XMLReaderFactory;
00133
00143 public class DatabasesParser extends DefaultHandler
00144 {
00145
00147 private XMLReader
parser;
00148
00150 static Trace
logger = Trace
00151 .getLogger(
DatabasesParser.class
00152 .getName());
00153
00155 private Controller
controller;
00156
00158 private Hashtable
dbToPrepare = null;
00160 private boolean skipDatabase =
false;
00161
00166 private boolean parsingAdminUsers =
false;
00167
00168 private VirtualDatabase
currentVirtualDatabase = null;
00169 private BackupManager
currentBackupManager = null;
00170 private DatabaseBackend
currentBackend;
00171 private DatabaseBackendUser
currentDatabaseBackendUser;
00172 private AuthenticationManager
currentAuthenticationManager;
00173 private AbstractScheduler
currentRequestScheduler;
00174 private AbstractResultCache
currentResultCache;
00175 private MetadataCache
currentMetadataCache = null;
00176 private ParsingCache
currentParsingCache = null;
00177 private ResultCacheRule
currentResultCacheRule;
00178 private MacrosHandler
currentMacroHandler;
00179 private AbstractLoadBalancer
currentLoadBalancer;
00180 private JDBCRecoveryLog
currentRecoveryLog;
00181 private VirtualDatabaseUser
currentVirtualUser;
00182 private DatabaseSchema
currentDatabaseSchema;
00183 private DatabaseTable
currentTable;
00184 private DatabaseProcedure
currentProcedure;
00185 private int numberOfColumns;
00186
00187 private String
connectionManagerVLogin;
00188 private WaitForCompletionPolicy
currentWaitForCompletionPolicy;
00189
00190 private long beginTimeout;
00191 private long commitTimeout;
00192 private long rollbackTimeout;
00193 private int requestTimeout;
00194
00195 private boolean caseSensitiveParsing;
00196
00197 private CreateTablePolicy
currentCreateTablePolicy;
00198 private CreateTableRule
currentCreateTableRule;
00199 private ArrayList
backendNameList;
00200 private ErrorCheckingPolicy
currentErrorCheckingPolicy;
00201
00202 private int currentNbOfConcurrentReads;
00203
00204 private BackendRecoveryPolicy
currentBackendRecoveryPolicy;
00205
00214 public DatabasesParser(Controller controller)
throws SAXException
00215 {
00216
prepareHandler(
controller);
00217 }
00218
00231 public DatabasesParser(Controller controller, String virtualName,
00232
int autoLoad, String checkPoint)
throws SAXException
00233 {
00234
prepareHandler(
controller);
00235
00236
if (virtualName != null)
00237
prepareDB(virtualName, autoLoad, checkPoint);
00238 }
00239
00240 private void prepareHandler(Controller controller)
throws SAXException
00241 {
00242
00243
parser = XMLReaderFactory.createXMLReader();
00244
00245
this.controller =
controller;
00246
00247
00248
parser.setFeature(
"http://xml.org/sax/features/validation",
true);
00249
00250
00251
parser.setErrorHandler(
this);
00252
00253
00254
parser.setContentHandler(
this);
00255
00256
00257
parser.setEntityResolver(
this);
00258 }
00259
00267 public void readXML(String xml)
throws IOException, SAXException
00268 {
00269 InputSource input =
new InputSource(
new StringReader(xml));
00270
parser.parse(input);
00271 }
00272
00282 public void readXML(String xml,
boolean validateBeforeParsing)
00283
throws IOException, SAXException
00284 {
00285
if (validateBeforeParsing)
00286 {
00287
XmlValidator validator =
new XmlValidator(
00288
ControllerConstants.C_JDBC_DTD_FILE, xml);
00289
if (
logger.isDebugEnabled())
00290 {
00291
if (validator.
isDtdValid())
00292
logger.debug(
Translate.get(
"virtualdatabase.xml.dtd.validated"));
00293
if (validator.
isXmlValid())
00294
logger.debug(
Translate.get(
"virtualdatabase.xml.document.validated"));
00295 }
00296
00297
if (validator.
getWarnings().size() > 0)
00298 {
00299 ArrayList warnings = validator.
getWarnings();
00300
for (
int i = 0; i < warnings.size(); i++)
00301
logger.warn(
Translate.get(
"virtualdatabase.xml.parsing.warning",
00302 warnings.get(i)));
00303 }
00304
00305
if (!validator.
isDtdValid())
00306
logger.error(
Translate.get(
"virtualdatabase.xml.dtd.not.validated"));
00307
if (!validator.
isXmlValid())
00308
logger.error(
Translate
00309 .get(
"virtualdatabase.xml.document.not.validated"));
00310
00311 ArrayList errors = validator.
getExceptions();
00312
for (
int i = 0; i < errors.size(); i++)
00313
logger.error(((Exception) errors.get(i)).getMessage());
00314
00315
if (!validator.
isValid())
00316
throw new SAXException(
ExceptionTypes.XML_DOCUMENT_INVALID);
00317 }
00318
this.readXML(xml);
00319 }
00320
00328 public void fatalError(SAXParseException e)
throws SAXException
00329 {
00330
logger.error(
Translate.get(
"virtualdatabase.xml.parsing.fatal",
00331
new String[]{e.getPublicId(), String.valueOf(e.getLineNumber()),
00332 String.valueOf(e.getColumnNumber()), e.getMessage()}));
00333
throw e;
00334 }
00335
00343 public void error(SAXParseException e)
throws SAXException
00344 {
00345 logger.error(
Translate.get(
"virtualdatabase.xml.parsing.error",
00346
new String[]{e.getPublicId(), String.valueOf(e.getLineNumber()),
00347 String.valueOf(e.getColumnNumber()), e.getMessage()}));
00348
throw e;
00349 }
00350
00359 public InputSource resolveEntity(String publicId, String systemId)
00360
throws SAXException
00361 {
00362 InputStream stream =
DatabasesXmlTags.class.getResourceAsStream(
"/"
00363 +
ControllerConstants.C_JDBC_DTD_FILE);
00364
if (stream == null)
00365
throw new SAXException(
"Cannot find C-JDBC DTD file '"
00366 +
ControllerConstants.C_JDBC_DTD_FILE +
"' in classpath");
00367
00368
return new InputSource(stream);
00369 }
00370
00379 public void prepareDB(String virtualName,
int autoLoad, String checkPoint)
00380 {
00381 dbToPrepare =
new Hashtable(3);
00382 dbToPrepare.put(
"virtualName", virtualName);
00383 dbToPrepare.put(
"autoEnable",
"" + autoLoad);
00384 dbToPrepare.put(
"checkPoint", checkPoint);
00385 }
00386
00392 public void startDocument() throws SAXException
00393 {
00394 logger.info(
Translate.get(
"virtualdatabase.xml.start"));
00395 }
00396
00402 public void endDocument() throws SAXException
00403 {
00404 logger.info(
Translate.get(
"virtualdatabase.xml.done"));
00405 }
00406
00416 public void startElement(String uri, String localName, String name,
00417 Attributes atts)
throws SAXException
00418 {
00419 logger.debug(
Translate.get(
"virtualdatabase.xml.parsing.start", name));
00420
00421
00422
if (name.equals(
DatabasesXmlTags.ELT_VirtualDatabase))
00423 {
00424
if (dbToPrepare == null)
00425 {
00426
00427 newVirtualDatabase(atts);
00428 }
00429
else
00430 {
00431
00432 String virtualName = atts.getValue(
DatabasesXmlTags.ATT_name);
00433
if (virtualName.equalsIgnoreCase((String) dbToPrepare
00434 .get(
"virtualName")))
00435 {
00436
00437 skipDatabase =
false;
00438 newVirtualDatabase(atts);
00439 }
00440
else
00441 {
00442
00443 skipDatabase =
true;
00444 }
00445 }
00446 }
00447
00448
if (skipDatabase)
00449
return;
00450
00451
00452
else if (name.equals(
DatabasesXmlTags.ELT_Distribution))
00453 newDistribution(atts);
00454
else if (name.equals(
DatabasesXmlTags.ELT_BackendRecoveryPolicy))
00455 newBackendRecoveryPolicy(atts);
00456
else if (name.equals(
DatabasesXmlTags.ELT_ControllerName))
00457 newControllerName(atts);
00458
00459
00460
else if (name.equals(
DatabasesXmlTags.ELT_SQLMonitoring))
00461 newSQLMonitoring(atts);
00462
else if (name.equals(
DatabasesXmlTags.ELT_SQLMonitoringRule))
00463 newSQLMonitoringRule(atts);
00464
else if (name.equals(
DatabasesXmlTags.ELT_BACKUP))
00465 newBackupManager(atts);
00466
00467
00468
else if (name.equals(
DatabasesXmlTags.ELT_DatabaseBackend))
00469 newDatabaseBackend(atts);
00470
else if (name.equals(
DatabasesXmlTags.ELT_RewritingRule))
00471 newRewritingRule(atts);
00472
00473
00474
else if (name.equals(
DatabasesXmlTags.ELT_AuthenticationManager))
00475 newAuthenticationManager(atts);
00476
else if (name.equals(
DatabasesXmlTags.ELT_Admin))
00477 parsingAdminUsers =
true;
00478
else if (name.equals(
DatabasesXmlTags.ELT_User) && parsingAdminUsers)
00479 newAdminUser(atts);
00480
else if (name.equals(
DatabasesXmlTags.ELT_VirtualLogin))
00481 newVirtualLogin(atts);
00482
00483
00484
else if (name.equals(
DatabasesXmlTags.ELT_RequestManager))
00485 newRequestManager(atts);
00486
00487
00488
else if (name.equals(
DatabasesXmlTags.ELT_MacroHandling))
00489 newMacroHandler(atts);
00490
00491
00492
else if (name.equals(
DatabasesXmlTags.ELT_SingleDBScheduler))
00493 newSingleDBScheduler(atts);
00494
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb0Scheduler))
00495 newRAIDb0Scheduler(atts);
00496
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb1Scheduler))
00497 newRAIDb1Scheduler(atts);
00498
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb2Scheduler))
00499 newRAIDb2Scheduler(atts);
00500
00501
00502
else if (name.equals(
DatabasesXmlTags.ELT_MetadataCache))
00503 newMetadataCache(atts);
00504
else if (name.equals(
DatabasesXmlTags.ELT_ParsingCache))
00505 newParsingCache(atts);
00506
else if (name.equals(
DatabasesXmlTags.ELT_ResultCache))
00507 newResultCache(atts);
00508
else if (name.equals(
DatabasesXmlTags.ELT_DefaultResultCacheRule))
00509 newDefaultResultCacheRule(atts);
00510
else if (name.equals(
DatabasesXmlTags.ELT_ResultCacheRule))
00511 newResultCacheRule(atts);
00512
else if (name.equals(
DatabasesXmlTags.ELT_NoCaching))
00513 currentResultCacheRule.setCacheBehavior(
ResultCacheFactory
00514 .getCacheBehaviorInstance(
DatabasesXmlTags.ELT_NoCaching, null));
00515
else if (name.equals(
DatabasesXmlTags.ELT_EagerCaching))
00516 currentResultCacheRule.setCacheBehavior(
ResultCacheFactory
00517 .getCacheBehaviorInstance(
DatabasesXmlTags.ELT_EagerCaching, null));
00518
else if (name.equals(
DatabasesXmlTags.ELT_RelaxedCaching))
00519 newRelaxedCaching(atts);
00520
00521
00522
else if (name.equals(
DatabasesXmlTags.ELT_SingleDB))
00523 newSingleDBRequestLoadBalancer(atts);
00524
else if (name.equals(
DatabasesXmlTags.ELT_ParallelDB_RoundRobin))
00525 newParallelDBRoundRobinLoadBalancer(atts);
00526
else if (name
00527 .equals(
DatabasesXmlTags.ELT_ParallelDB_LeastPendingRequestsFirst))
00528 newParallelDBLeastPendingRequestsFirst(atts);
00529
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_0))
00530 newRAIDb0LoadBalancer(atts);
00531
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_1))
00532 newRAIDb1LoadBalancer(atts);
00533
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_1_RoundRobin))
00534 newRAIDb1RoundRobinLoadBalancer(atts);
00535
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_1_WeightedRoundRobin))
00536 newRAIDb1WeightedRoundRobinLoadBalancer(atts);
00537
else if (name
00538 .equals(
DatabasesXmlTags.ELT_RAIDb_1_LeastPendingRequestsFirst))
00539 newRAIDb1LeastPendingRequestsFirst(atts);
00540
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_1ec))
00541 newRAIDb1ecLoadBalancer(atts);
00542
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_1ec_RoundRobin))
00543 newRAIDb1ecRoundRobinLoadBalancer(atts);
00544
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_1ec_WeightedRoundRobin))
00545 newRAIDb1ecWeightedRoundRobinLoadBalancer(atts);
00546
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_2))
00547 newRAIDb2LoadBalancer(atts);
00548
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_2_RoundRobin))
00549 newRAIDb2RoundRobinLoadBalancer(atts);
00550
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_2_WeightedRoundRobin))
00551 newRAIDb2WeightedRoundRobinLoadBalancer(atts);
00552
else if (name
00553 .equals(
DatabasesXmlTags.ELT_RAIDb_2_LeastPendingRequestsFirst))
00554 newRAIDb2LeastPendingRequestsFirst(atts);
00555
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_2ec))
00556 newRAIDb2ecLoadBalancer(atts);
00557
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_2ec_RoundRobin))
00558 newRAIDb2ecRoundRobinLoadBalancer(atts);
00559
else if (name.equals(
DatabasesXmlTags.ELT_RAIDb_2ec_WeightedRoundRobin))
00560 newRAIDb2ecWeightedRoundRobinLoadBalancer(atts);
00561
00562
00563
else if (name.equals(
DatabasesXmlTags.ELT_WaitForCompletion))
00564 newWaitForCompletion(atts);
00565
else if (name.equals(
DatabasesXmlTags.ELT_ErrorChecking))
00566 newErrorChecking(atts);
00567
else if (name.equals(
DatabasesXmlTags.ELT_CreateTable))
00568 newCreateTable(atts);
00569
else if (name.equals(
DatabasesXmlTags.ELT_BackendName))
00570 newBackendName(atts);
00571
else if (name.equals(
DatabasesXmlTags.ELT_BackendWeight))
00572 newBackendWeight(atts);
00573
00574
00575
else if (name.equals(
DatabasesXmlTags.ELT_FileRecoveryLog))
00576 newFileRecoveryLog(atts);
00577
else if (name.equals(
DatabasesXmlTags.ELT_JDBCRecoveryLog))
00578 newJDBCRecoveryLog(atts);
00579
else if (name.equals(
DatabasesXmlTags.ELT_RecoveryLogTable))
00580 newJDBCRecoveryLogTable(atts);
00581
else if (name.equals(
DatabasesXmlTags.ELT_CheckpointTable))
00582 newJDBCRecoveryCheckpointTable(atts);
00583
else if (name.equals(
DatabasesXmlTags.ELT_BackendTable))
00584 newJDBCRecoveryBackendTable(atts);
00585
00586
00587
else if (name.equals(
DatabasesXmlTags.ELT_ConnectionManager))
00588 newConnectionManager(atts);
00589
else if (name.equals(
DatabasesXmlTags.ELT_SimpleConnectionManager))
00590 newSimpleConnectionManager(atts);
00591
else if (name.equals(
DatabasesXmlTags.ELT_FailFastPoolConnectionManager))
00592 newFailFastPoolConnectionManager(atts);
00593
else if (name.equals(
DatabasesXmlTags.ELT_RandomWaitPoolConnectionManager))
00594 newRandomWaitPoolConnectionManager(atts);
00595
else if (name.equals(
DatabasesXmlTags.ELT_VariablePoolConnectionManager))
00596 newVariablePoolConnectionManager(atts);
00597
00598
00599
else if (name.equals(
DatabasesXmlTags.ELT_DatabaseSchema))
00600 newDatabaseSchema(atts);
00601
else if (name.equals(
DatabasesXmlTags.ELT_DatabaseStaticSchema))
00602 {
00603
if (currentBackend.getDynamicPrecision() !=
DatabaseBackendSchemaConstants.DynamicPrecisionStatic)
00604 {
00605 String msg =
Translate.get(
00606
"virtualdatabase.xml.schema.static.incompatible.dynamic",
00607 currentBackend.getName());
00608 logger.error(msg);
00609
throw new SAXException(msg);
00610 }
00611 currentDatabaseSchema =
new DatabaseSchema();
00612 }
00613
00614
00615
else if (name.equals(
DatabasesXmlTags.ELT_DatabaseTable))
00616 newDatabaseTable(atts);
00617
00618
00619
else if (name.equals(
DatabasesXmlTags.ELT_DatabaseColumn))
00620 newDatabaseColumn(atts);
00621
00622
else if (name.equals(
DatabasesXmlTags.ELT_DatabaseProcedure))
00623 newDatabaseProcedure(atts);
00624
else if (name.equals(
DatabasesXmlTags.ELT_DatabaseProcedureColumn))
00625 newDatabaseProcedureColumn(atts);
00626 }
00627
00633 private void newBackupManager(Attributes atts)
00634 {
00635
boolean zip = (Boolean.valueOf(atts
00636 .getValue(
DatabasesXmlTags.ATT_BACKUP_ZIP))).booleanValue();
00637
boolean clean = (Boolean.valueOf(atts
00638 .getValue(
DatabasesXmlTags.ATT_BACKUP_CLEAN))).booleanValue();
00639
int number = -1;
00640 String dir = atts.getValue(
DatabasesXmlTags.ATT_BACKUP_DIR);
00641 currentBackupManager =
new BackupManager();
00642 currentBackupManager.setBackupDir(dir);
00643 currentBackupManager.setCleanBackupFiles(clean);
00644 currentBackupManager.setZipBackupFiles(zip);
00645 currentBackupManager.setNumberOfBackups(number);
00646 }
00647
00651 private void newMacroHandler(Attributes atts)
00652 {
00660 String rand = atts.getValue(
DatabasesXmlTags.ATT_rand);
00661 String now = atts.getValue(
DatabasesXmlTags.ATT_now);
00662 String currentDate = atts.getValue(
DatabasesXmlTags.ATT_currentDate);
00663 String currentTime = atts.getValue(
DatabasesXmlTags.ATT_currentTime);
00664 String currentTimestamp = atts
00665 .getValue(
DatabasesXmlTags.ATT_currentTimestamp);
00666 String timeResolution = atts.getValue(
DatabasesXmlTags.ATT_timeResolution);
00667 String timeOfDay = atts.getValue(
DatabasesXmlTags.ATT_timeOfDay);
00668
00669
int icurrentDate = MacrosHandler.getIntDateLevel(currentDate);
00670
int icurrentTime = MacrosHandler.getIntDateLevel(currentTime);
00671
int icurrentTimestamp = MacrosHandler.getIntDateLevel(currentTimestamp);
00672
int itimeOfDay = MacrosHandler.getIntDateLevel(timeOfDay);
00673
int inow = MacrosHandler.getIntDateLevel(now);
00674
int irand = MacrosHandler.getIntRandLevel(rand);
00675
long ltimeResolution = Long.parseLong(timeResolution);
00676
00677
try
00678 {
00679 currentMacroHandler =
new MacrosHandler(irand, ltimeResolution, inow,
00680 icurrentDate, icurrentTime, itimeOfDay, icurrentTimestamp);
00681 }
00682
catch (RuntimeException e)
00683 {
00684 logger.warn(
Translate.get(
00685
"virtualdatabase.xml.invalid.macroshandler.settings", e));
00686 }
00687
00688 }
00689
00698 public void endElement(String uri, String localName, String name)
00699
throws SAXException
00700 {
00701 logger.debug(
Translate.get(
"virtualdatabase.xml.parsing.end", name));
00702
00703
if (skipDatabase)
00704
return;
00705
00706
00707
if (name.equals(
DatabasesXmlTags.ELT_VirtualDatabase))
00708 {
00709
if (logger.isDebugEnabled())
00710 logger.debug(
Translate.get(
"virtualdatabase.xml.add.virtualdatabase"));
00711
00712
if (currentVirtualDatabase != null)
00713 {
00714
try
00715 {
00716
if (currentVirtualDatabase instanceof
DistributedVirtualDatabase)
00717 ((
DistributedVirtualDatabase) currentVirtualDatabase).joinGroup();
00718
if (dbToPrepare == null)
00719 {
00720 controller.addVirtualDatabase(currentVirtualDatabase);
00721 }
00722
else
00723 {
00724
int autoLoad = Integer.parseInt((String) dbToPrepare
00725 .get(
"autoEnable"));
00726 String checkPoint = (String) dbToPrepare.get(
"checkPoint");
00727
00728
00729
00730 checkPoint = checkPoint.equalsIgnoreCase(
"") ? null : checkPoint;
00731 controller.addVirtualDatabase(currentVirtualDatabase, autoLoad,
00732 checkPoint);
00733 }
00734 }
00735
catch (Exception e)
00736 {
00737 String msg =
Translate
00738 .get(
"controller.add.virtualdatabase.failed", e);
00739 logger.error(msg, e);
00740 }
00741 }
00742 currentVirtualDatabase = null;
00743 }
00744
00745
00746
else if (name.equals(
DatabasesXmlTags.ELT_RequestManager))
00747 {
00748
if (logger.isDebugEnabled())
00749 logger.debug(
Translate.get(
"virtualdatabase.xml.requestmanager.set"));
00750
00751
if (currentVirtualDatabase != null)
00752 {
00753
RequestManager requestManager = null;
00754
00755
00756
00757
if (currentLoadBalancer == null)
00758
throw new SAXException(
"virtualdatabase.xml.loadbalancer.not.set");
00759
if (!(currentLoadBalancer instanceof
SingleDB || currentLoadBalancer instanceof
ParallelDB))
00760 {
00761
00762
00763
if (currentMacroHandler == null)
00764 currentMacroHandler =
new MacrosHandler(MacrosHandler.RAND_FLOAT,
00765 1000, MacrosHandler.DATE_TIMESTAMP, MacrosHandler.DATE_DATE,
00766 MacrosHandler.DATE_TIME, MacrosHandler.DATE_TIMESTAMP,
00767 MacrosHandler.DATE_TIMESTAMP);
00768 currentLoadBalancer.setMacroHandler(currentMacroHandler);
00769 }
00770
00771
try
00772 {
00773
if (currentVirtualDatabase.isDistributed())
00774 {
00775
switch (currentLoadBalancer.getRAIDbLevel())
00776 {
00777
case RAIDbLevels.SingleDB :
00778 String smsg =
Translate.get(
00779
"virtualdatabase.xml.no.single.distributed.requestmanager",
00780 currentLoadBalancer.getRAIDbLevel());
00781 logger.error(smsg);
00782
throw new SAXException(smsg);
00783
case RAIDbLevels.RAIDb1 :
00784 requestManager =
new RAIDb1DistributedRequestManager(
00785 (
DistributedVirtualDatabase) currentVirtualDatabase,
00786 currentRequestScheduler, currentResultCache,
00787 currentLoadBalancer, currentRecoveryLog, beginTimeout,
00788 commitTimeout, rollbackTimeout);
00789
break;
00790
case RAIDbLevels.RAIDb2 :
00791 requestManager =
new RAIDb2DistributedRequestManager(
00792 (
DistributedVirtualDatabase) currentVirtualDatabase,
00793 currentRequestScheduler, currentResultCache,
00794 currentLoadBalancer, currentRecoveryLog, beginTimeout,
00795 commitTimeout, rollbackTimeout);
00796
break;
00797
default :
00798 String msg =
Translate.get(
00799
"virtualdatabase.xml.no.distributed.requestmanager",
00800 currentLoadBalancer.getRAIDbLevel());
00801 logger.error(msg);
00802
throw new SAXException(msg);
00803 }
00804 }
00805
else
00806 requestManager =
new RequestManager(currentVirtualDatabase,
00807 currentRequestScheduler, currentResultCache,
00808 currentLoadBalancer, currentRecoveryLog, beginTimeout,
00809 commitTimeout, rollbackTimeout);
00810
00811
if (requestManager != null)
00812 {
00813
if (currentParsingCache != null)
00814 requestManager.
setParsingCache(currentParsingCache);
00815
if (currentMetadataCache != null)
00816 requestManager.
setMetadataCache(currentMetadataCache);
00817 requestManager.
setCaseSensitiveParsing(caseSensitiveParsing);
00818 }
00819
00820 currentVirtualDatabase.setRequestManager(requestManager);
00821
if (currentBackupManager == null)
00822 currentBackupManager =
new BackupManager();
00823 requestManager.
setBackupManager(currentBackupManager);
00824 }
00825
catch (Exception e)
00826 {
00827 String msg =
Translate
00828 .get(
"virtualdatabase.xml.requestmanager.creation.failed");
00829 logger.error(msg, e);
00830
throw new SAXException(msg, e);
00831 }
00832 }
00833 }
00834
00835
00836
else if (name.equals(
DatabasesXmlTags.ELT_DatabaseBackend))
00837 {
00838
if (currentBackend != null)
00839 {
00840
try
00841 {
00842 currentVirtualDatabase.addBackend(currentBackend,
false);
00843 }
00844
catch (Exception e)
00845 {
00846 String msg =
Translate.get(
"virtualdatabase.xml.backend.add.failed");
00847 logger.error(msg, e);
00848
throw new SAXException(msg, e);
00849 }
00850 }
00851 currentBackend = null;
00852 }
00853
00854
00855
else if (name.equals(
DatabasesXmlTags.ELT_AuthenticationManager))
00856 {
00857
if (currentVirtualDatabase != null)
00858 {
00859 currentVirtualDatabase
00860 .setAuthenticationManager(currentAuthenticationManager);
00861 }
00862 }
00863
00864
00865
else if (name.equals(
DatabasesXmlTags.ELT_RequestCache))
00866 {
00867
if (currentResultCache != null)
00868 {
00869
if (currentResultCache.getDefaultRule() == null)
00870 {
00871 ResultCacheRule defaultRule = null;
00872
try
00873 {
00874 defaultRule =
new ResultCacheRule(
"",
false,
false, 1000);
00875 }
00876
catch (RESyntaxException impossible)
00877 {
00878 }
00879 defaultRule.setCacheBehavior(
new EagerCaching());
00880 currentResultCache.setDefaultRule(defaultRule);
00881 }
00882 }
00883 }
00884
else if (name.equals(
DatabasesXmlTags.ELT_DefaultResultCacheRule))
00885 {
00886 currentResultCache.setDefaultRule(currentResultCacheRule);
00887 }
00888
00889
00890
else if (name.equals(
DatabasesXmlTags.ELT_DatabaseStaticSchema))
00891 {
00892
if (currentDatabaseSchema != null)
00893 {
00894
if (currentBackend != null)
00895 {
00896
try
00897 {
00898 currentBackend.setDatabaseSchema(currentDatabaseSchema,
true);
00899 }
00900
catch (Exception e)
00901 {
00902 logger.error(
Translate
00903 .get(
"virtualdatabase.xml.backend.set.schema.failed"), e);
00904 }
00905 }
00906
else
00907 {
00908
try
00909 {
00910 currentVirtualDatabase.setDatabaseSchema(currentDatabaseSchema,
00911
true);
00912 }
00913
catch (Exception e)
00914 {
00915 logger.error(
Translate
00916 .get(
"virtualdatabase.xml.virtualdatabase.set.schema.failed"),
00917 e);
00918 }
00919 }
00920 currentDatabaseSchema = null;
00921 }
00922 }
00923
00924
00925
else if (name.equals(
DatabasesXmlTags.ELT_DatabaseTable))
00926 {
00927
if (currentTable != null)
00928 {
00929
try
00930 {
00931 ArrayList cols = currentTable.getColumns();
00932
if (cols == null)
00933 logger.warn(
Translate.get(
"virtualdatabase.xml.table.no.column",
00934 currentTable.getName()));
00935
else if (cols.size() != numberOfColumns)
00936 logger.warn(
Translate.get(
00937
"virtualdatabase.xml.table.column.mismatch",
new String[]{
00938 String.valueOf(numberOfColumns), currentTable.getName(),
00939 String.valueOf(cols.size())}));
00940
00941 currentDatabaseSchema.addTable(currentTable);
00942
if (logger.isDebugEnabled())
00943 logger.debug(
Translate.get(
"virtualdatabase.xml.table.add",
00944 currentTable.getName()));
00945 }
00946
catch (Exception e)
00947 {
00948 logger
00949 .error(
Translate.get(
"virtualdatabase.xml.table.add.failed"), e);
00950 }
00951 currentTable = null;
00952 }
00953 }
00954
00955
else if (name.equals(
DatabasesXmlTags.ELT_DatabaseProcedure))
00956 {
00957
if (currentProcedure != null)
00958 {
00959
try
00960 {
00961
00962 currentDatabaseSchema.addProcedure(currentProcedure);
00963
if (logger.isDebugEnabled())
00964 logger.debug(
Translate.get(
"virtualdatabase.xml.procedure.add",
00965 currentProcedure.getName()));
00966 }
00967
catch (Exception e)
00968 {
00969 logger.error(Translate
00970 .get(
"virtualdatabase.xml.procedure.add.failed"), e);
00971 }
00972 currentProcedure = null;
00973 }
00974 }
00975
00976
00977
else if (name.equals(DatabasesXmlTags.ELT_CreateTable))
00978 {
00979
if (currentCreateTablePolicy != null)
00980 {
00981
if (logger.isDebugEnabled())
00982 logger.debug(Translate.get(
"virtualdatabase.xml.create.table.add",
00983 currentCreateTableRule.getInformation()));
00984 currentCreateTablePolicy.addRule(currentCreateTableRule);
00985 }
00986 }
00987
00988
00989
else if (name.equals(DatabasesXmlTags.ELT_RAIDb_0))
00990 {
00991
if (logger.isDebugEnabled())
00992 logger.debug(Translate
00993 .get(
"virtualdatabase.xml.loadbalancer.raidb0.set"));
00994
00995
if (currentCreateTablePolicy.getDefaultRule() == null)
00996 {
00997
if (logger.isDebugEnabled())
00998 logger.debug(Translate
00999 .get(
"virtualdatabase.xml.create.table.default"));
01000 CreateTableRule rule =
new CreateTableRoundRobin();
01001 currentCreateTablePolicy.addRule(rule);
01002 }
01003
try
01004 {
01005 currentLoadBalancer =
new RAIDb0(currentVirtualDatabase,
01006 currentCreateTablePolicy);
01007 }
01008
catch (SQLException e)
01009 {
01010 String msg = Translate
01011 .get(
"virtualdatabase.xml.loadbalancer.raidb0.failed");
01012 logger.error(msg, e);
01013
throw new SAXException(msg, e);
01014 }
01015 }
01016
01017
01018
else if (name.equals(DatabasesXmlTags.ELT_RecoveryLog))
01019 {
01020
if (logger.isDebugEnabled())
01021 logger.debug(Translate
01022 .get(
"virtualdatabase.xml.recoverylog.cheking.tables"));
01023 {
01024
try
01025 {
01026 currentRecoveryLog.checkRecoveryLogTables();
01027 }
01028
catch (Exception e)
01029 {
01030 String msg = Translate
01031 .get(
"virtualdatabase.xml.recoverylog.cheking.tables.failed");
01032 logger.error(msg, e);
01033
throw new SAXException(msg);
01034 }
01035
01036
try
01037 {
01038 currentRequestScheduler.initializeTransactionId(currentRecoveryLog
01039 .getLastTransactionId() + 1);
01040 }
01041
catch (Exception e)
01042 {
01043 String msg = Translate
01044 .get(
"virtualdatabase.xml.scheduler.initialization.failed");
01045 logger.error(msg, e);
01046
throw new SAXException(msg);
01047 }
01048 }
01049 }
01050 }
01051
01052
01053
01064 private void newVirtualDatabase(Attributes atts)
throws SAXException
01065 {
01066 String name = atts.getValue(
DatabasesXmlTags.ATT_name);
01067 String maxNbOfConnections = atts
01068 .getValue(
DatabasesXmlTags.ATT_maxNbOfConnections);
01069 String poolThreads = atts.getValue(
DatabasesXmlTags.ATT_poolThreads);
01070 String minNbOfThreads = atts.getValue(
DatabasesXmlTags.ATT_minNbOfThreads);
01071 String maxNbOfThreads = atts.getValue(
DatabasesXmlTags.ATT_maxNbOfThreads);
01072 String maxThreadIdleTime = atts
01073 .getValue(
DatabasesXmlTags.ATT_maxThreadIdleTime);
01074 String sqlDumpLength = atts.getValue(
DatabasesXmlTags.ATT_sqlDumpLength);
01075 String blobEncodingMethod = atts
01076 .getValue(
DatabasesXmlTags.ATT_blobEncodingMethod);
01077
01078
if (controller.hasVirtualDatabase(name))
01079 {
01080 String msg =
Translate.get(
01081
"virtualdatabase.xml.virtualdatabase.already.exists", name);
01082 logger.error(msg);
01083
throw new SAXException(msg);
01084 }
01085
01086
try
01087 {
01088
01089
int maxConnections = Integer.parseInt(maxNbOfConnections);
01090
boolean pool = poolThreads.equals(
DatabasesXmlTags.VAL_true);
01091
int minThreads = Integer.parseInt(minNbOfThreads);
01092
int maxThreads = Integer.parseInt(maxNbOfThreads);
01093
01094
long threadIdleTime = Long.parseLong(maxThreadIdleTime) * 1000L;
01095
int dumpLength = Integer.parseInt(sqlDumpLength);
01096
AbstractBlobFilter blobFilter =
AbstractBlobFilter
01097 .getBlobFilterInstance(blobEncodingMethod);
01098
if (logger.isDebugEnabled())
01099 logger.debug(
Translate.get(
01100
"virtualdatabase.xml.virtualdatabase.create", name));
01101 currentVirtualDatabase =
new VirtualDatabase(controller, name,
01102 maxConnections, pool, minThreads, maxThreads, threadIdleTime,
01103 dumpLength, blobFilter);
01104
01105 }
01106
catch (Exception e)
01107 {
01108 String msg =
Translate.get(
"virtualdatabase.xml.virtualdatabase.failed");
01109 logger.error(msg, e);
01110
throw new SAXException(msg, e);
01111 }
01112 }
01113
01114
01115
01122 private void newDistribution(Attributes atts)
throws SAXException
01123 {
01124 String groupName = atts.getValue(
DatabasesXmlTags.ATT_groupName);
01125 String castTimeout = atts.getValue(
DatabasesXmlTags.ATT_castTimeout);
01126
long timeout;
01127
try
01128 {
01129 timeout = Long.parseLong(castTimeout);
01130
CJDBCGroupMessage.defaultCastTimeOut = timeout;
01131 }
01132
catch (NumberFormatException e1)
01133 {
01134
01135 }
01136
01137
if (groupName == null)
01138 groupName = currentVirtualDatabase.getName();
01139
01140
if (logger.isDebugEnabled())
01141 logger.debug(
Translate
01142 .get(
"virtualdatabase.xml.virtualdatabase.distributed.create",
01143
new String[]{currentVirtualDatabase.getName(), groupName,
01144 castTimeout}));
01145
try
01146 {
01147
01148 ObjectName objectName =
JmxConstants
01149 .getVirtualDbObjectName(currentVirtualDatabase.getName());
01150
MBeanServerManager.unregister(objectName);
01151
01152 currentVirtualDatabase =
new DistributedVirtualDatabase(controller,
01153 currentVirtualDatabase.getName(), groupName, currentVirtualDatabase
01154 .getMaxNbOfConnections(), currentVirtualDatabase
01155 .isPoolConnectionThreads(), currentVirtualDatabase
01156 .getMinNbOfThreads(), currentVirtualDatabase.getMaxNbOfThreads(),
01157 currentVirtualDatabase.getMaxThreadIdleTime(), currentVirtualDatabase
01158 .getSQLShortFormLength(), currentVirtualDatabase.getBlobFilter());
01159 }
01160
catch (Exception e)
01161 {
01162 String msg = Translate
01163 .get(
"virtualdatabase.xml.virtualdatabase.distributed.failed");
01164 logger.error(msg, e);
01165
throw new SAXException(msg, e);
01166 }
01167 }
01168
01176 private void newBackendRecoveryPolicy(Attributes atts)
throws SAXException
01177 {
01178 String backendName = atts.getValue(
DatabasesXmlTags.ATT_backendName);
01179 String recoveryPolicyString = atts
01180 .getValue(
DatabasesXmlTags.ATT_recoveryPolicy);
01181
01182
boolean recoveryPolicy;
01183
if (recoveryPolicyString.equals(
DatabasesXmlTags.VAL_on))
01184 recoveryPolicy =
true;
01185
else if (recoveryPolicyString.equals(
DatabasesXmlTags.VAL_off))
01186 recoveryPolicy =
false;
01187
else
01188
throw new SAXException(
01189
Translate
01190 .get(
01191
"virtualdatabase.xml.virtualdatabase.distributed.recoverOnFailure.bad.value",
01192 recoveryPolicyString));
01193
01194 currentBackendRecoveryPolicy =
new BackendRecoveryPolicy(backendName,
01195 recoveryPolicy);
01196 ((
DistributedVirtualDatabase) currentVirtualDatabase)
01197 .addBackendRecoveryPolicy(currentBackendRecoveryPolicy);
01198 }
01199
01207 private void newControllerName(Attributes atts)
throws SAXException
01208 {
01209 String name = atts.getValue(
DatabasesXmlTags.ATT_name);
01210
try
01211 {
01212 currentBackendRecoveryPolicy.addController(name);
01213 }
01214
catch (
ControllerException e)
01215 {
01216
throw new SAXException(e);
01217 }
01218 }
01219
01220
01221
01227 private void newSQLMonitoring(Attributes atts)
01228 {
01229 String monitoringString = atts
01230 .getValue(
DatabasesXmlTags.ATT_defaultMonitoring);
01231
boolean monitoring;
01232
if (monitoringString != null)
01233 monitoring = monitoringString.equals(
DatabasesXmlTags.VAL_on);
01234
else
01235 monitoring =
false;
01236
01237
SQLMonitoring sqlMonitor =
new SQLMonitoring(currentVirtualDatabase
01238 .getName());
01239 sqlMonitor.
setDefaultRule(monitoring);
01240 currentVirtualDatabase.setSQLMonitor(sqlMonitor);
01241 }
01242
01248 private void newSQLMonitoringRule(Attributes atts)
01249 {
01250 String queryPattern = atts.getValue(
DatabasesXmlTags.ATT_queryPattern);
01251 String caseSensitiveString = atts
01252 .getValue(
DatabasesXmlTags.ATT_caseSensitive);
01253 String applyToSkeletonString = atts
01254 .getValue(
DatabasesXmlTags.ATT_applyToSkeleton);
01255 String monitoringString = atts.getValue(
DatabasesXmlTags.ATT_monitoring);
01256
01257
boolean caseSensitive;
01258
if (caseSensitiveString != null)
01259 caseSensitive = caseSensitiveString.equals(
DatabasesXmlTags.VAL_true);
01260
else
01261 caseSensitive =
false;
01262
boolean applyToSkeleton;
01263
if (applyToSkeletonString != null)
01264 applyToSkeleton = applyToSkeletonString.equals(
DatabasesXmlTags.VAL_true);
01265
else
01266 applyToSkeleton =
false;
01267
boolean monitoring;
01268
if (monitoringString != null)
01269 monitoring = monitoringString.equals(
DatabasesXmlTags.VAL_on);
01270
else
01271 monitoring =
false;
01272
01273
01274
SQLMonitoringRule rule =
new SQLMonitoringRule(queryPattern, caseSensitive,
01275 applyToSkeleton, monitoring);
01276
01277
if (logger.isDebugEnabled())
01278 logger.debug(
Translate.get(
"virtualdatabase.xml.sqlmonitoring.rule.add",
01279
new String[]{queryPattern, String.valueOf(caseSensitive),
01280 applyToSkeletonString, String.valueOf(monitoring)}));
01281 currentVirtualDatabase.getSQLMonitor().addRule(rule);
01282 }
01283
01284
01285
01293 private void newDatabaseBackend(Attributes atts)
throws SAXException
01294 {
01295 String name = atts.getValue(
DatabasesXmlTags.ATT_name);
01296 String driverClassName = atts.getValue(
DatabasesXmlTags.ATT_driver);
01297 String driverPath = atts.getValue(
DatabasesXmlTags.ATT_driverPath);
01298 String url = atts.getValue(
DatabasesXmlTags.ATT_url);
01299 String connectionTestStatement = atts
01300 .getValue(
DatabasesXmlTags.ATT_connectionTestStatement);
01301
01302
if (logger.isDebugEnabled())
01303 {
01304 logger.debug(
Translate.get(
"virtualdatabase.xml.backend.create",
01305
new String[]{name, driverClassName, url, connectionTestStatement}));
01306
if (driverPath == null)
01307 {
01308 logger.debug(
"no driver path defined for backend.");
01309 }
01310
else
01311 {
01312 logger.debug(
"using driver path " + driverPath);
01313 }
01314 }
01315
try
01316 {
01317 currentBackend =
new DatabaseBackend(name, driverPath, driverClassName,
01318 url,
true, connectionTestStatement);
01319 }
01320
catch (NotCompliantMBeanException e)
01321 {
01322 logger.error(
"MBean is not compliant", e);
01323
throw new SAXException(
"mbean is not compliant");
01324 }
01325 }
01326
01332 private void newRewritingRule(Attributes atts)
throws SAXException
01333 {
01334 String queryPattern = atts.getValue(
DatabasesXmlTags.ATT_queryPattern);
01335 String rewrite = atts.getValue(
DatabasesXmlTags.ATT_rewrite);
01336 String matchingType = atts.getValue(
DatabasesXmlTags.ATT_matchingType);
01337 String caseSensitiveString = atts
01338 .getValue(
DatabasesXmlTags.ATT_caseSensitive);
01339 String stopOnMatchString = atts.getValue(
DatabasesXmlTags.ATT_stopOnMatch);
01340
01341
boolean caseSensitive;
01342
if (caseSensitiveString != null)
01343 caseSensitive = caseSensitiveString.equals(
DatabasesXmlTags.VAL_true);
01344
else
01345 caseSensitive =
false;
01346
boolean stopOnMatch;
01347
if (stopOnMatchString != null)
01348 stopOnMatch = stopOnMatchString.equals(
DatabasesXmlTags.VAL_true);
01349
else
01350 stopOnMatch =
false;
01351
01352
01353
AbstractRewritingRule rule;
01354
if (matchingType.equals(
DatabasesXmlTags.VAL_simple))
01355 rule =
new SimpleRewritingRule(queryPattern, rewrite, caseSensitive,
01356 stopOnMatch);
01357
else if (matchingType.equals(
DatabasesXmlTags.VAL_pattern))
01358 rule =
new PatternRewritingRule(queryPattern, rewrite, caseSensitive,
01359 stopOnMatch);
01360
else if (matchingType.equals(
DatabasesXmlTags.VAL_replaceAll))
01361 rule =
new ReplaceAllRewritingRule(queryPattern, rewrite, caseSensitive,
01362 stopOnMatch);
01363
else
01364
throw new SAXException(
Translate.get(
01365
"virtualdatabase.xml.rewritingrule.unsupported.matching",
01366 matchingType));
01367
01368
if (logger.isDebugEnabled())
01369 logger.debug(
Translate.get(
"virtualdatabase.xml.rewritingrule.add",
01370
new String[]{queryPattern, rewrite, String.valueOf(caseSensitive),
01371 String.valueOf(stopOnMatch)}));
01372 currentBackend.addRewritingRule(rule);
01373 }
01374
01375
01376
01383 private void newAuthenticationManager(Attributes atts)
01384 {
01385 currentAuthenticationManager =
new AuthenticationManager();
01386 }
01387
01394 private void newAdminUser(Attributes atts)
01395 {
01396 String aLogin = atts.getValue(
DatabasesXmlTags.ATT_username);
01397 String aPassword = atts.getValue(
DatabasesXmlTags.ATT_password);
01398
01399
if (logger.isDebugEnabled())
01400 logger.debug(
Translate.get(
01401
"virtualdatabase.xml.authentication.login.admin.add",
new String[]{
01402 aLogin, aPassword}));
01403 currentAuthenticationManager.addAdminUser(
new AdminUser(aLogin, aPassword));
01404 }
01405
01414 private void newVirtualLogin(Attributes atts)
01415 {
01416 String vLogin = atts.getValue(
DatabasesXmlTags.ATT_vLogin);
01417 String vPassword = atts.getValue(
DatabasesXmlTags.ATT_vPassword);
01418 currentVirtualUser =
new VirtualDatabaseUser(vLogin, vPassword);
01419
01420
if (logger.isDebugEnabled())
01421 logger.debug(
Translate.get(
01422
"virtualdatabase.xml.authentication.login.virtual.add",
new String[]{
01423 vLogin, vPassword}));
01424 currentAuthenticationManager.addVirtualUser(currentVirtualUser);
01425 }
01426
01427
01428
01436 private void newRequestManager(Attributes atts)
throws SAXException
01437 {
01438
try
01439 {
01440 String begin = atts.getValue(
DatabasesXmlTags.ATT_beginTimeout);
01441 String commit = atts.getValue(
DatabasesXmlTags.ATT_commitTimeout);
01442 String rollback = atts.getValue(
DatabasesXmlTags.ATT_rollbackTimeout);
01443 String caseSensitiveParsingString = atts
01444 .getValue(
DatabasesXmlTags.ATT_caseSensitiveParsing);
01445
01446
01447 beginTimeout = Long.parseLong(begin) * 1000L;
01448 commitTimeout = Long.parseLong(commit) * 1000L;
01449 rollbackTimeout = Long.parseLong(rollback) * 1000L;
01450
01451
if (caseSensitiveParsingString != null)
01452 caseSensitiveParsing = caseSensitiveParsingString
01453 .equals(
DatabasesXmlTags.VAL_true);
01454
else
01455 caseSensitiveParsing =
false;
01456
01457
if (logger.isDebugEnabled())
01458 logger.debug(
Translate.get(
01459
"virtualdatabase.xml.requestmanager.parameters",
new String[]{
01460 String.valueOf(beginTimeout), String.valueOf(commitTimeout),
01461 String.valueOf(rollbackTimeout)}));
01462 }
01463
catch (NumberFormatException e)
01464 {
01465 String msg =
Translate
01466 .get(
"virtualdatabase.xml.requestmanager.timeout.failed");
01467 logger.error(msg, e);
01468
throw new SAXException(msg, e);
01469 }
01470 }
01471
01472
01473
01482 private void newSingleDBScheduler(Attributes atts)
throws SAXException
01483 {
01484 String level = atts.getValue(
DatabasesXmlTags.ATT_level);
01485
01486
01487
if (level.equals(
DatabasesXmlTags.VAL_query))
01488 {
01489
if (logger.isDebugEnabled())
01490 logger.debug(
Translate
01491 .get(
"virtualdatabase.xml.scheduler.singledb.create.query"));
01492 currentRequestScheduler =
new SingleDBQueryLevelScheduler();
01493 }
01494
01495
01496
else if (level.equals(
DatabasesXmlTags.VAL_pessimisticTransaction))
01497 {
01498
if (logger.isDebugEnabled())
01499 logger.debug(
Translate
01500 .get(
"virtualdatabase.xml.scheduler.singledb.create.pessimistic"));
01501 currentRequestScheduler =
new SingleDBPessimisticTransactionLevelScheduler();
01502 }
01503
else
01504 {
01505
throw new SAXException(
Translate.get(
01506
"virtualdatabase.xml.scheduler.singledb.unsupported", level));
01507 }
01508 }
01509
01518 private void newRAIDb0Scheduler(Attributes atts)
throws SAXException
01519 {
01520 String level = atts.getValue(
DatabasesXmlTags.ATT_level);
01521
01522
if (level.equals(
DatabasesXmlTags.VAL_query))
01523 {
01524
if (logger.isDebugEnabled())
01525 logger.debug(
Translate
01526 .get(
"virtualdatabase.xml.scheduler.raidb0.create.query"));
01527 currentRequestScheduler =
new RAIDb0QueryLevelScheduler();
01528 }
01529
else if (level.equals(
DatabasesXmlTags.VAL_pessimisticTransaction))
01530 {
01531
if (logger.isDebugEnabled())
01532 logger.debug(
Translate
01533 .get(
"virtualdatabase.xml.scheduler.raidb0.create.pessimistic"));
01534 currentRequestScheduler =
new RAIDb0PessimisticTransactionLevelScheduler();
01535 }
01536
else
01537
throw new SAXException(
Translate.get(
01538
"virtualdatabase.xml.scheduler.raidb0.unsupported", level));
01539 }
01540
01549 private void newRAIDb1Scheduler(Attributes atts)
throws SAXException
01550 {
01551 String level = atts.getValue(
DatabasesXmlTags.ATT_level);
01552
01553
01554
if (level.equals(
DatabasesXmlTags.VAL_query))
01555 {
01556
if (logger.isDebugEnabled())
01557 logger.debug(
Translate
01558 .get(
"virtualdatabase.xml.scheduler.raidb1.create.query"));
01559 currentRequestScheduler =
new RAIDb1QueryLevelScheduler();
01560 }
01561
01562
else if (level.equals(
DatabasesXmlTags.VAL_optimisticQuery))
01563 {
01564
if (logger.isDebugEnabled())
01565 logger
01566 .debug(
Translate
01567 .get(
"virtualdatabase.xml.scheduler.raidb1.create.query.optimistic"));
01568 currentRequestScheduler =
new RAIDb1OptimisticQueryLevelScheduler();
01569 }
01570
01571
else if (level.equals(
DatabasesXmlTags.VAL_optimisticTransaction))
01572 {
01573
if (logger.isDebugEnabled())
01574 logger.debug(
Translate
01575 .get(
"virtualdatabase.xml.scheduler.raidb1.create.optimistic"));
01576 currentRequestScheduler =
new RAIDb1OptimisticTransactionLevelScheduler();
01577 }
01578
01579
else if (level.equals(
DatabasesXmlTags.VAL_pessimisticTransaction))
01580 {
01581
if (logger.isDebugEnabled())
01582 logger.debug(
Translate
01583 .get(
"virtualdatabase.xml.scheduler.raidb1.create.pessimistic"));
01584 currentRequestScheduler =
new RAIDb1PessimisticTransactionLevelScheduler();
01585 }
01586
else
01587 {
01588
throw new SAXException(
Translate.get(
01589
"virtualdatabase.xml.scheduler.raidb1.unsupported", level));
01590 }
01591 }
01592
01601 private void newRAIDb2Scheduler(Attributes atts)
throws SAXException
01602 {
01603 String level = atts.getValue(
DatabasesXmlTags.ATT_level);
01604
01605
01606
if (level.equals(
DatabasesXmlTags.VAL_query))
01607 {
01608
if (logger.isDebugEnabled())
01609 logger.debug(
Translate
01610 .get(
"virtualdatabase.xml.scheduler.raidb2.create.query"));
01611 currentRequestScheduler =
new RAIDb2QueryLevelScheduler();
01612 }
01613
01614
else if (level.equals(
DatabasesXmlTags.VAL_pessimisticTransaction))
01615 {
01616
if (logger.isDebugEnabled())
01617 logger.debug(
Translate
01618 .get(
"virtualdatabase.xml.scheduler.raidb2.create.pessimistic"));
01619 currentRequestScheduler =
new RAIDb2PessimisticTransactionLevelScheduler();
01620 }
01621
else
01622 {
01623
throw new SAXException(
Translate.get(
01624
"virtualdatabase.xml.scheduler.raidb2.unsupported", level));
01625 }
01626 }
01627
01628
01629
01630
01631
01639 private void newMetadataCache(Attributes atts)
throws SAXException
01640 {
01641
try
01642 {
01643
int maxMetadata = Integer.parseInt(atts
01644 .getValue(
DatabasesXmlTags.ATT_maxNbOfMetadata));
01645
int maxField = Integer.parseInt(atts
01646 .getValue(
DatabasesXmlTags.ATT_maxNbOfField));
01647 currentMetadataCache =
new MetadataCache(maxMetadata, maxField);
01648 }
01649
catch (Exception e)
01650 {
01651 String msg =
Translate.get(
01652
"virtualdatabase.xml.metadata.cache.create.failed", e);
01653 logger.error(msg, e);
01654
throw new SAXException(msg, e);
01655 }
01656 }
01657
01665 private void newParsingCache(Attributes atts)
throws SAXException
01666 {
01667 String backgroundParsingString = atts
01668 .getValue(
DatabasesXmlTags.ATT_backgroundParsing);
01669
boolean backgroundParsing;
01670
01671
if (backgroundParsingString != null)
01672 backgroundParsing = backgroundParsingString
01673 .equals(
DatabasesXmlTags.VAL_true);
01674
else
01675 backgroundParsing =
false;
01676
01677 String maxEntriesString = atts
01678 .getValue(
DatabasesXmlTags.ATT_maxNbOfEntries);
01679
int maxEntries = Integer.parseInt(maxEntriesString);
01680
01681
try
01682 {
01683 currentParsingCache =
new ParsingCache(maxEntries, backgroundParsing);
01684 }
01685
catch (Exception e)
01686 {
01687 String msg =
Translate.get(
01688
"virtualdatabase.xml.parsing.cache.create.failed", e);
01689 logger.error(msg, e);
01690
throw new SAXException(msg, e);
01691 }
01692 }
01693
01701 private void newResultCache(Attributes atts)
throws SAXException
01702 {
01703 String granularity = atts.getValue(
DatabasesXmlTags.ATT_granularity);
01704 String maxEntriesString = atts
01705 .getValue(
DatabasesXmlTags.ATT_maxNbOfEntries);
01706 String pendingTimeoutString = atts
01707 .getValue(
DatabasesXmlTags.ATT_pendingTimeout);
01708
01709
if (logger.isDebugEnabled())
01710 logger.debug(
Translate.get(
"virtualdatabase.xml.cache.create",
01711 granularity));
01712
01713
try
01714 {
01715
int maxEntries = Integer.parseInt(maxEntriesString);
01716
int pendingTimeout = Integer.parseInt(pendingTimeoutString);
01717
01718
int granularityValue;
01719
if (granularity.equals(
DatabasesXmlTags.VAL_table))
01720 granularityValue =
CachingGranularities.TABLE;
01721
else if (granularity.equals(
DatabasesXmlTags.VAL_database))
01722 granularityValue =
CachingGranularities.DATABASE;
01723
else if (granularity.equals(
DatabasesXmlTags.VAL_column))
01724 granularityValue =
CachingGranularities.COLUMN;
01725
else if (granularity.equals(
DatabasesXmlTags.VAL_columnUnique))
01726 granularityValue =
CachingGranularities.COLUMN_UNIQUE;
01727
else
01728
throw new InstantiationException(
Translate.get(
01729
"virtualdatabase.xml.cache.unsupported", granularity));
01730
01731 currentResultCache =
ResultCacheFactory.getCacheInstance(
01732 granularityValue, maxEntries, pendingTimeout);
01733
01734 }
01735
catch (Exception e)
01736 {
01737 String msg =
Translate.get(
"virtualdatabase.xml.cache.create.failed",
01738 granularity);
01739 logger.error(msg, e);
01740
throw new SAXException(msg, e);
01741 }
01742 }
01743
01750 private void newResultCacheRule(Attributes atts)
throws SAXException
01751 {
01752 String queryString = atts.getValue(
DatabasesXmlTags.ATT_queryPattern);
01753
01754 String caseSensitiveString = atts
01755 .getValue(
DatabasesXmlTags.ATT_caseSensitive);
01756 String applyToSkeletonString = atts
01757 .getValue(
DatabasesXmlTags.ATT_applyToSkeleton);
01758
long timestampResolution;
01759
try
01760 {
01761 timestampResolution = Long.parseLong(atts
01762 .getValue(
DatabasesXmlTags.ATT_timestampResolution));
01763 timestampResolution *= 1000;
01764 }
01765
catch (Exception e)
01766 {
01767 logger
01768 .warn(
Translate.get(
"virtualdatabase.invalid.timestamp.resolution"));
01769 timestampResolution = 1000;
01770 }
01771
01772
boolean caseSensitive;
01773
if (caseSensitiveString != null)
01774 caseSensitive = caseSensitiveString.equals(
DatabasesXmlTags.VAL_true);
01775
else
01776 caseSensitive =
false;
01777
boolean applyToSkeleton;
01778
if (applyToSkeletonString != null)
01779 applyToSkeleton = applyToSkeletonString.equals(
DatabasesXmlTags.VAL_true);
01780
else
01781 applyToSkeleton =
false;
01782
01783
01784
try
01785 {
01786 currentResultCacheRule =
new ResultCacheRule(queryString, caseSensitive,
01787 applyToSkeleton, timestampResolution);
01788 }
01789
catch (RESyntaxException e1)
01790 {
01791 String msg =
Translate.get(
"virtualdatabase.xml.cache.rule.invalid", e1);
01792 logger.error(msg);
01793
throw new SAXException(msg);
01794 }
01795
01796
if (logger.isDebugEnabled())
01797 logger.debug(
Translate.get(
"virtualdatabase.xml.cache.rule.add",
01798
new String[]{atts.getValue(
DatabasesXmlTags.ATT_queryPattern),
01799 String.valueOf(caseSensitive), applyToSkeletonString,
01800 String.valueOf(timestampResolution)}));
01801 currentResultCache.addCachingRule(currentResultCacheRule);
01802 }
01803
01810 private void newDefaultResultCacheRule(Attributes atts)
throws SAXException
01811 {
01812
long currentTimestampResolution;
01813
try
01814 {
01815 currentTimestampResolution = Long.parseLong(atts
01816 .getValue(
DatabasesXmlTags.ATT_timestampResolution)) / 1000;
01817 }
01818
catch (Exception e)
01819 {
01820 String msg =
Translate
01821 .get(
"virtualdatabase.invalid.timestamp.resolution");
01822 logger.warn(msg);
01823 currentTimestampResolution = 1000;
01824 }
01825
01826
try
01827 {
01828 currentResultCacheRule =
new ResultCacheRule(
"",
false,
false,
01829 currentTimestampResolution);
01830 }
01831
catch (RESyntaxException e)
01832 {
01833
throw new SAXException(
Translate.get(
01834
"virtualdatabase.xml.cache.rule.default.invalid", e));
01835 }
01836 }
01837
01845 private void newRelaxedCaching(Attributes atts)
01846 {
01847 Hashtable options =
new Hashtable();
01848
for (
int i = 0; i < atts.getLength(); i++)
01849 options.put(atts.getQName(i), atts.getValue(i));
01850 currentResultCacheRule
01851 .setCacheBehavior(
ResultCacheFactory.getCacheBehaviorInstance(
01852
DatabasesXmlTags.ELT_RelaxedCaching, options));
01853 }
01854
01855
01856
01864 private void newSingleDBRequestLoadBalancer(Attributes atts)
01865
throws SAXException
01866 {
01867
if (logger.isDebugEnabled())
01868 logger.debug(
Translate
01869 .get(
"virtualdatabase.xml.loadbalancer.singledb.set"));
01870
01871
try
01872 {
01873 currentLoadBalancer =
new SingleDB(currentVirtualDatabase);
01874 }
01875
catch (SQLException e)
01876 {
01877 String msg =
Translate
01878 .get(
"virtualdatabase.xml.loadbalancer.singledb.failed");
01879 logger.error(msg, e);
01880
throw new SAXException(msg, e);
01881 }
01882 }
01883
01884
01885
01886
01887
01895 private void newParallelDBLeastPendingRequestsFirst(Attributes atts)
01896
throws SAXException
01897 {
01898
if (logger.isDebugEnabled())
01899 logger.debug(
Translate
01900 .get(
"virtualdatabase.xml.loadbalancer.paralleldb_rr.set"));
01901
01902
try
01903 {
01904 currentLoadBalancer =
new ParallelDB_RR(currentVirtualDatabase);
01905 }
01906
catch (SQLException e)
01907 {
01908 String msg =
Translate
01909 .get(
"virtualdatabase.xml.loadbalancer.paralleldb_rr.failed");
01910 logger.error(msg, e);
01911
throw new SAXException(msg, e);
01912 }
01913 }
01914
01922 private void newParallelDBRoundRobinLoadBalancer(Attributes atts)
01923
throws SAXException
01924 {
01925
if (logger.isDebugEnabled())
01926 logger.debug(
Translate
01927 .get(
"virtualdatabase.xml.loadbalancer.paralleldb_lprf.set"));
01928
01929
try
01930 {
01931 currentLoadBalancer =
new ParallelDB_LPRF(currentVirtualDatabase);
01932 }
01933
catch (SQLException e)
01934 {
01935 String msg =
Translate
01936 .get(
"virtualdatabase.xml.loadbalancer.paralleldb_lprf.failed");
01937 logger.error(msg, e);
01938
throw new SAXException(msg, e);
01939 }
01940 }
01941
01942
01943
01944
01945
01952 private void newRAIDb0LoadBalancer(Attributes atts)
01953 {
01954 currentCreateTablePolicy =
new CreateTablePolicy();
01955 currentCreateTableRule = null;
01956 }
01957
01958
01959
01960
01961
01968 private void newRAIDb1LoadBalancer(Attributes atts)
01969 {
01970 currentWaitForCompletionPolicy = null;
01971 }
01972
01980 private void newRAIDb1RoundRobinLoadBalancer(Attributes atts)
01981
throws SAXException
01982 {
01983
if (currentWaitForCompletionPolicy == null)
01984 currentWaitForCompletionPolicy =
new WaitForCompletionPolicy();
01985
01986
if (logger.isDebugEnabled())
01987 {
01988 logger.debug(
Translate
01989 .get(
"virtualdatabase.xml.loadbalancer.raidb1_rr.set"));
01990 logger.debug(
Translate.get(
01991
"virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
01992 currentWaitForCompletionPolicy.getInformation()));
01993 }
01994
01995
try
01996 {
01997 currentLoadBalancer =
new RAIDb1_RR(currentVirtualDatabase,
01998 currentWaitForCompletionPolicy);
01999 }
02000
catch (SQLException e)
02001 {
02002 String msg =
Translate
02003 .get(
"virtualdatabase.xml.loadbalancer.raidb1_rr.failed");
02004 logger.error(msg, e);
02005
throw new SAXException(msg, e);
02006 }
02007 }
02008
02016 private void newRAIDb1WeightedRoundRobinLoadBalancer(Attributes atts)
02017
throws SAXException
02018 {
02019
if (currentWaitForCompletionPolicy == null)
02020 currentWaitForCompletionPolicy =
new WaitForCompletionPolicy();
02021
02022
if (logger.isDebugEnabled())
02023 {
02024 logger.debug(
Translate
02025 .get(
"virtualdatabase.xml.loadbalancer.raidb1_wrr.set"));
02026 logger.debug(
Translate.get(
02027
"virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02028 currentWaitForCompletionPolicy.getInformation()));
02029 }
02030
02031
try
02032 {
02033 currentLoadBalancer =
new RAIDb1_WRR(currentVirtualDatabase,
02034 currentWaitForCompletionPolicy);
02035 }
02036
catch (SQLException e)
02037 {
02038 String msg =
Translate
02039 .get(
"virtualdatabase.xml.loadbalancer.raidb1_wrr.failed");
02040 logger.error(msg, e);
02041
throw new SAXException(msg, e);
02042 }
02043 }
02044
02052 private void newRAIDb1LeastPendingRequestsFirst(Attributes atts)
02053
throws SAXException
02054 {
02055
if (currentWaitForCompletionPolicy == null)
02056 currentWaitForCompletionPolicy =
new WaitForCompletionPolicy();
02057
02058
if (logger.isDebugEnabled())
02059 {
02060 logger.debug(
Translate
02061 .get(
"virtualdatabase.xml.loadbalancer.raidb1_lprf.set"));
02062 logger.debug(
Translate.get(
02063
"virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02064 currentWaitForCompletionPolicy.getInformation()));
02065 }
02066
02067
try
02068 {
02069 currentLoadBalancer =
new RAIDb1_LPRF(currentVirtualDatabase,
02070 currentWaitForCompletionPolicy);
02071 }
02072
catch (SQLException e)
02073 {
02074 String msg =
Translate
02075 .get(
"virtualdatabase.xml.loadbalancer.raidb1_lprf.failed");
02076 logger.error(msg, e);
02077
throw new SAXException(msg, e);
02078 }
02079 }
02080
02081
02082
02083
02084
02091 private void newRAIDb1ecLoadBalancer(Attributes atts)
02092 {
02093 String nbOfConcurrentReads = atts
02094 .getValue(
DatabasesXmlTags.ATT_nbOfConcurrentReads);
02095 currentNbOfConcurrentReads = Integer.parseInt(nbOfConcurrentReads);
02096 currentErrorCheckingPolicy = null;
02097 currentWaitForCompletionPolicy = null;
02098 }
02099
02107 private void newRAIDb1ecRoundRobinLoadBalancer(Attributes atts)
02108
throws SAXException
02109 {
02110
if (currentWaitForCompletionPolicy == null)
02111 currentWaitForCompletionPolicy =
new WaitForCompletionPolicy();
02112
02113
if (logger.isDebugEnabled())
02114 {
02115 logger.debug(
Translate
02116 .get(
"virtualdatabase.xml.loadbalancer.raidb1ec_rr.set"));
02117 logger.debug(
Translate.get(
02118
"virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02119 currentWaitForCompletionPolicy.getInformation()));
02120 }
02121
02122
try
02123 {
02124 currentLoadBalancer =
new RAIDb1ec_RR(currentVirtualDatabase,
02125 currentWaitForCompletionPolicy, currentErrorCheckingPolicy,
02126 currentNbOfConcurrentReads);
02127
if (logger.isDebugEnabled())
02128 logger.debug(
Translate.get(
02129
"virtualdatabase.xml.loadbalancer.errorchecking.policy",
02130 currentErrorCheckingPolicy.getInformation()));
02131 }
02132
catch (SQLException e)
02133 {
02134 String msg =
Translate
02135 .get(
"virtualdatabase.xml.loadbalancer.raidb1ec_rr.failed");
02136 logger.error(msg, e);
02137
throw new SAXException(msg, e);
02138 }
02139 }
02140
02148 private void newRAIDb1ecWeightedRoundRobinLoadBalancer(Attributes atts)
02149
throws SAXException
02150 {
02151
if (currentWaitForCompletionPolicy == null)
02152 currentWaitForCompletionPolicy =
new WaitForCompletionPolicy();
02153
02154
if (logger.isDebugEnabled())
02155 {
02156 logger.debug(
Translate
02157 .get(
"virtualdatabase.xml.loadbalancer.raidb1ec_wrr.set"));
02158 logger.debug(
Translate.get(
02159
"virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02160 currentWaitForCompletionPolicy.getInformation()));
02161 }
02162
02163
try
02164 {
02165 currentLoadBalancer =
new RAIDb1ec_WRR(currentVirtualDatabase,
02166 currentWaitForCompletionPolicy, currentErrorCheckingPolicy,
02167 currentNbOfConcurrentReads);
02168
if (logger.isDebugEnabled())
02169 logger.debug(
Translate.get(
02170
"virtualdatabase.xml.loadbalancer.errorchecking.policy",
02171 currentErrorCheckingPolicy.getInformation()));
02172 }
02173
catch (SQLException e)
02174 {
02175 String msg =
Translate
02176 .get(
"virtualdatabase.xml.loadbalancer.raidb1ec_wrr.failed");
02177 logger.error(msg, e);
02178
throw new SAXException(msg, e);
02179 }
02180 }
02181
02182
02183
02184
02185
02192 private void newRAIDb2LoadBalancer(Attributes atts)
02193 {
02194 currentWaitForCompletionPolicy = null;
02195 currentCreateTablePolicy =
new CreateTablePolicy();
02196
02197 currentCreateTablePolicy.addRule(
new CreateTableAll());
02198 currentCreateTableRule = null;
02199 }
02200
02208 private void newRAIDb2RoundRobinLoadBalancer(Attributes atts)
02209
throws SAXException
02210 {
02211
if (currentWaitForCompletionPolicy == null)
02212 currentWaitForCompletionPolicy =
new WaitForCompletionPolicy();
02213
02214
if (logger.isDebugEnabled())
02215 {
02216 logger.debug(
Translate
02217 .get(
"virtualdatabase.xml.loadbalancer.raidb2_rr.set"));
02218 logger.debug(
Translate.get(
02219
"virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02220 currentWaitForCompletionPolicy.getInformation()));
02221 }
02222
02223
try
02224 {
02225 currentLoadBalancer =
new RAIDb2_RR(currentVirtualDatabase,
02226 currentWaitForCompletionPolicy, currentCreateTablePolicy);
02227 }
02228
catch (SQLException e)
02229 {
02230 String msg =
Translate
02231 .get(
"virtualdatabase.xml.loadbalancer.raidb2_rr.failed");
02232 logger.error(msg, e);
02233
throw new SAXException(msg, e);
02234 }
02235 }
02236
02244 private void newRAIDb2WeightedRoundRobinLoadBalancer(Attributes atts)
02245
throws SAXException
02246 {
02247
if (currentWaitForCompletionPolicy == null)
02248 currentWaitForCompletionPolicy =
new WaitForCompletionPolicy();
02249
02250
if (logger.isDebugEnabled())
02251 {
02252 logger.debug(
Translate
02253 .get(
"virtualdatabase.xml.loadbalancer.raidb2_wrr.set"));
02254 logger.debug(
Translate.get(
02255
"virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02256 currentWaitForCompletionPolicy.getInformation()));
02257 }
02258
02259
try
02260 {
02261 currentLoadBalancer =
new RAIDb2_WRR(currentVirtualDatabase,
02262 currentWaitForCompletionPolicy, currentCreateTablePolicy);
02263 }
02264
catch (SQLException e)
02265 {
02266 String msg =
Translate
02267 .get(
"virtualdatabase.xml.loadbalancer.raidb2_wrr.failed");
02268 logger.error(msg, e);
02269
throw new SAXException(msg, e);
02270 }
02271 }
02272
02280 private void newRAIDb2LeastPendingRequestsFirst(Attributes atts)
02281
throws SAXException
02282 {
02283
if (currentWaitForCompletionPolicy == null)
02284 currentWaitForCompletionPolicy =
new WaitForCompletionPolicy();
02285
if (logger.isDebugEnabled())
02286 {
02287 logger.debug(
Translate
02288 .get(
"virtualdatabase.xml.loadbalancer.raidb2_lprf.set"));
02289 logger.debug(
Translate.get(
02290
"virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02291 currentWaitForCompletionPolicy.getInformation()));
02292 }
02293
02294
try
02295 {
02296 currentLoadBalancer =
new RAIDb2_LPRF(currentVirtualDatabase,
02297 currentWaitForCompletionPolicy, currentCreateTablePolicy);
02298 }
02299
catch (SQLException e)
02300 {
02301 String msg =
Translate
02302 .get(
"virtualdatabase.xml.loadbalancer.raidb2_lprf.failed");
02303 logger.error(msg, e);
02304
throw new SAXException(msg, e);
02305 }
02306 }
02307
02308
02309
02310
02311
02318 private void newRAIDb2ecLoadBalancer(Attributes atts)
02319 {
02320 currentErrorCheckingPolicy = null;
02321 currentWaitForCompletionPolicy = null;
02322 currentCreateTablePolicy =
new CreateTablePolicy();
02323 currentCreateTableRule = null;
02324 }
02325
02333 private void newRAIDb2ecRoundRobinLoadBalancer(Attributes atts)
02334
throws SAXException
02335 {
02336
if (currentWaitForCompletionPolicy == null)
02337 currentWaitForCompletionPolicy =
new WaitForCompletionPolicy();
02338
02339
if (logger.isDebugEnabled())
02340 {
02341 logger.debug(
Translate
02342 .get(
"virtualdatabase.xml.loadbalancer.raidb2_rr.set"));
02343 logger.debug(
Translate.get(
02344
"virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02345 currentWaitForCompletionPolicy.getInformation()));
02346 }
02347
02348
try
02349 {
02350 currentLoadBalancer =
new RAIDb2ec_RR(currentVirtualDatabase,
02351 currentWaitForCompletionPolicy, currentCreateTablePolicy,
02352 currentErrorCheckingPolicy, currentNbOfConcurrentReads);
02353
if (logger.isDebugEnabled())
02354 logger.debug(
Translate.get(
02355
"virtualdatabase.xml.loadbalancer.errorchecking.policy",
02356 currentErrorCheckingPolicy.getInformation()));
02357 }
02358
catch (SQLException e)
02359 {
02360 String msg =
Translate
02361 .get(
"virtualdatabase.xml.loadbalancer.raidb2ec_rr.failed");
02362 logger.error(msg, e);
02363
throw new SAXException(msg, e);
02364 }
02365 }
02366
02374 private void newRAIDb2ecWeightedRoundRobinLoadBalancer(Attributes atts)
02375
throws SAXException
02376 {
02377
if (currentWaitForCompletionPolicy == null)
02378 currentWaitForCompletionPolicy =
new WaitForCompletionPolicy();
02379
02380
if (logger.isDebugEnabled())
02381 {
02382 logger.debug(
Translate
02383 .get(
"virtualdatabase.xml.loadbalancer.raidb2_wrr.set"));
02384 logger.debug(
Translate.get(
02385
"virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02386 currentWaitForCompletionPolicy.getInformation()));
02387 }
02388
02389
try
02390 {
02391 currentLoadBalancer =
new RAIDb2ec_WRR(currentVirtualDatabase,
02392 currentWaitForCompletionPolicy, currentCreateTablePolicy,
02393 currentErrorCheckingPolicy, currentNbOfConcurrentReads);
02394
if (logger.isDebugEnabled())
02395 logger.debug(
Translate.get(
02396
"virtualdatabase.xml.loadbalancer.errorchecking.policy",
02397 currentErrorCheckingPolicy.getInformation()));
02398 }
02399
catch (SQLException e)
02400 {
02401 String msg =
Translate
02402 .get(
"virtualdatabase.xml.loadbalancer.raidb2ec_wrr.failed");
02403 logger.error(msg, e);
02404
throw new SAXException(msg, e);
02405 }
02406 }
02407
02408
02409
02410
02411
02418 private void newWaitForCompletion(Attributes atts)
throws SAXException
02419 {
02420 String policy = atts.getValue(
DatabasesXmlTags.ATT_policy);
02421 currentWaitForCompletionPolicy =
new WaitForCompletionPolicy();
02422
02423
if (policy.equals(
DatabasesXmlTags.VAL_first))
02424 currentWaitForCompletionPolicy.setPolicy(WaitForCompletionPolicy.FIRST);
02425
else if (policy.equals(
DatabasesXmlTags.VAL_majority))
02426 currentWaitForCompletionPolicy
02427 .setPolicy(WaitForCompletionPolicy.MAJORITY);
02428
else if (policy.equals(
DatabasesXmlTags.VAL_all))
02429 currentWaitForCompletionPolicy.setPolicy(WaitForCompletionPolicy.ALL);
02430
else
02431
throw new SAXException(
Translate.get(
02432
"virtualdatabase.xml.loadbalancer.waitforcompletion.unsupported",
02433 policy));
02434 }
02435
02442 private void newErrorChecking(Attributes atts)
throws SAXException
02443 {
02444 String nbOfNodes = atts.getValue(
DatabasesXmlTags.ATT_numberOfNodes);
02445 String policy = atts.getValue(
DatabasesXmlTags.ATT_policy);
02446
if (policy.equals(
DatabasesXmlTags.VAL_random))
02447 currentErrorCheckingPolicy =
new ErrorCheckingRandom(Integer
02448 .parseInt(nbOfNodes));
02449
else if (policy.equals(
DatabasesXmlTags.VAL_roundRobin))
02450 currentErrorCheckingPolicy =
new ErrorCheckingRoundRobin(Integer
02451 .parseInt(nbOfNodes));
02452
else if (policy.equals(
DatabasesXmlTags.VAL_all))
02453 currentErrorCheckingPolicy =
new ErrorCheckingAll();
02454
else
02455
throw new SAXException(
Translate.get(
02456
"virtualdatabase.xml.loadbalancer.errorchecking.unsupported", policy));
02457 }
02458
02465 private void newCreateTable(Attributes atts)
throws SAXException
02466 {
02467 String tableName = atts.getValue(
DatabasesXmlTags.ATT_tableName);
02468 String nbOfNodes = atts.getValue(
DatabasesXmlTags.ATT_numberOfNodes);
02469 String policy = atts.getValue(
DatabasesXmlTags.ATT_policy);
02470 backendNameList =
new ArrayList();
02471
if (policy.equals(
DatabasesXmlTags.VAL_random))
02472 currentCreateTableRule =
new CreateTableRandom(backendNameList);
02473
else if (policy.equals(
DatabasesXmlTags.VAL_roundRobin))
02474 currentCreateTableRule =
new CreateTableRoundRobin(backendNameList);
02475
else if (policy.equals(
DatabasesXmlTags.VAL_all))
02476 currentCreateTableRule =
new CreateTableAll(backendNameList);
02477
else
02478
throw new SAXException(
Translate.get(
02479
"virtualdatabase.xml.create.table.unsupported", policy));
02480
02481 currentCreateTableRule.setNumberOfNodes(Integer.parseInt(nbOfNodes));
02482 currentCreateTableRule.setTableName(tableName);
02483 }
02484
02490 private void newBackendName(Attributes atts)
02491 {
02492 String name = atts.getValue(
DatabasesXmlTags.ATT_name);
02493
if (logger.isDebugEnabled())
02494 logger.debug(
Translate
02495 .get(
"virtualdatabase.xml.backend.policy.add", name));
02496 backendNameList.add(name);
02497 }
02498
02506 private void newBackendWeight(Attributes atts)
throws SAXException
02507 {
02508 String name = atts.getValue(
DatabasesXmlTags.ATT_name);
02509
try
02510 {
02511
int weight = Integer.parseInt(atts.getValue(
DatabasesXmlTags.ATT_weight));
02512
02513
if (logger.isDebugEnabled())
02514 logger.debug(
Translate.get(
"virtualdatabase.xml.backend.weigth.set",
02515
new String[]{String.valueOf(weight), name}));
02516
02517 currentLoadBalancer.setWeight(name, weight);
02518 }
02519
catch (Exception e)
02520 {
02521 String msg =
Translate.get(
"virtualdatabase.xml.backend.weigth.failed",
02522 name);
02523 logger.error(msg, e);
02524
throw new SAXException(msg, e);
02525 }
02526 }
02527
02528
02529
02537 private void newJDBCRecoveryLog(Attributes atts)
throws SAXException
02538 {
02539
try
02540 {
02541 String driverClassName = atts.getValue(
DatabasesXmlTags.ATT_driver);
02542 String driverPath = atts.getValue(
DatabasesXmlTags.ATT_driverPath);
02543 String url = atts.getValue(
DatabasesXmlTags.ATT_url);
02544 String login = atts.getValue(
DatabasesXmlTags.ATT_login);
02545 String password = atts.getValue(
DatabasesXmlTags.ATT_password);
02546 String timeout = atts.getValue(
DatabasesXmlTags.ATT_requestTimeout);
02547
02548 requestTimeout = Integer.parseInt(timeout) * 1000;
02549
02550
if (logger.isDebugEnabled())
02551 logger.debug(
Translate.get(
02552
"virtualdatabase.xml.recoverylog.jdbc.create",
new String[]{
02553 driverClassName, url, login, password,
02554 String.valueOf(requestTimeout)}));
02555
02556 currentRecoveryLog =
new JDBCRecoveryLog(driverPath, driverClassName,
02557 url, login, password, requestTimeout);
02558
02559 }
02560
catch (Exception e)
02561 {
02562 String msg =
Translate.get(
"virtualdatabase.xml.recoverylog.jdbc.failed");
02563 logger.error(msg, e);
02564
throw new SAXException(msg, e);
02565 }
02566 }
02567
02576 private void newJDBCRecoveryLogTable(Attributes atts)
throws SAXException
02577 {
02578
try
02579 {
02580 String tableName = atts.getValue(
DatabasesXmlTags.ATT_tableName);
02581 String idType = atts.getValue(
DatabasesXmlTags.ATT_idColumnType);
02582 String vloginType = atts.getValue(
DatabasesXmlTags.ATT_vloginColumnType);
02583 String sqlType = atts.getValue(
DatabasesXmlTags.ATT_sqlColumnType);
02584 String transactionIdType = atts
02585 .getValue(
DatabasesXmlTags.ATT_transactionIdColumnType);
02586 String extraStatement = atts
02587 .getValue(
DatabasesXmlTags.ATT_extraStatementDefinition);
02588
02589
if (currentRecoveryLog == null)
02590 {
02591 String msg =
Translate
02592 .get(
"virtualdatabase.xml.recoverylog.jdbc.recoverytable.setnull");
02593 logger.error(msg);
02594
throw new SAXException(msg);
02595 }
02596
else
02597 currentRecoveryLog.setLogTableCreateStatement(tableName, idType,
02598 vloginType, sqlType, transactionIdType, extraStatement);
02599 }
02600
catch (Exception e)
02601 {
02602 String msg =
Translate
02603 .get(
"virtualdatabase.xml.recoverylog.jdbc.recoverytable.failed");
02604 logger.error(msg, e);
02605
throw new SAXException(msg, e);
02606 }
02607 }
02608
02617 private void newJDBCRecoveryCheckpointTable(Attributes atts)
02618
throws SAXException
02619 {
02620
try
02621 {
02622 String tableName = atts.getValue(
DatabasesXmlTags.ATT_tableName);
02623 String nameType = atts
02624 .getValue(
DatabasesXmlTags.ATT_checkpointNameColumnType);
02625 String requestIdType = atts
02626 .getValue(
DatabasesXmlTags.ATT_requestIdColumnType);
02627 String extraStatement = atts
02628 .getValue(
DatabasesXmlTags.ATT_extraStatementDefinition);
02629
02630
if (currentRecoveryLog == null)
02631 {
02632 String msg =
Translate
02633 .get(
"virtualdatabase.xml.recoverylog.jdbc.checkpointtable.setnull");
02634 logger.error(msg);
02635
throw new SAXException(msg);
02636 }
02637
else
02638 currentRecoveryLog.setCheckpointTableCreateStatement(tableName,
02639 nameType, requestIdType, extraStatement);
02640 }
02641
catch (Exception e)
02642 {
02643 String msg =
Translate
02644 .get(
"virtualdatabase.xml.recoverylog.jdbc.checkpointtable.failed");
02645 logger.error(msg, e);
02646
throw new SAXException(msg, e);
02647 }
02648 }
02649
02658 private void newJDBCRecoveryBackendTable(Attributes atts)
throws SAXException
02659 {
02660
try
02661 {
02662 String tableName = atts.getValue(
DatabasesXmlTags.ATT_tableName);
02663 String checkpointNameType = atts
02664 .getValue(
DatabasesXmlTags.ATT_checkpointNameColumnType);
02665 String databaseNameType = atts
02666 .getValue(
DatabasesXmlTags.ATT_databaseNameColumnType);
02667 String backendNameType = atts
02668 .getValue(
DatabasesXmlTags.ATT_backendNameColumnType);
02669 String backendStateType = atts
02670 .getValue(
DatabasesXmlTags.ATT_backendStateColumnType);
02671 String extraStatement = atts
02672 .getValue(
DatabasesXmlTags.ATT_extraStatementDefinition);
02673
02674
if (currentRecoveryLog == null)
02675 {
02676 String msg =
Translate
02677 .get(
"virtualdatabase.xml.recoverylog.jdbc.backendtable.setnull");
02678 logger.error(msg);
02679
throw new SAXException(msg);
02680 }
02681
else
02682 currentRecoveryLog.setBackendTableCreateStatement(tableName,
02683 checkpointNameType, backendNameType, backendStateType,
02684 databaseNameType, extraStatement);
02685 }
02686
catch (Exception e)
02687 {
02688 String msg =
Translate
02689 .get(
"virtualdatabase.xml.recoverylog.jdbc.backendtable.failed");
02690 logger.error(msg, e);
02691
throw new SAXException(msg, e);
02692 }
02693 }
02694
02702 private void newFileRecoveryLog(Attributes atts)
throws SAXException
02703 {
02704 String msg =
"FileRecoveryLog is not yet implemented";
02705 logger.error(msg);
02706
throw new SAXException(msg);
02707 }
02708
02709
02710
02718 private void newConnectionManager(Attributes atts)
throws SAXException
02719 {
02720 connectionManagerVLogin = atts.getValue(
DatabasesXmlTags.ATT_vLogin);
02721 String connectionManagerRLogin = atts.getValue(
DatabasesXmlTags.ATT_rLogin);
02722 String connectionManagerRPassword = atts
02723 .getValue(
DatabasesXmlTags.ATT_rPassword);
02724 String backendName = currentBackend.getName();
02725
02726
02727
if (!currentAuthenticationManager
02728 .isValidVirtualLogin(connectionManagerVLogin))
02729 {
02730 String msg =
Translate.get(
02731
"virtualdatabase.xml.connectionmanager.vlogin.undefined",
02732
new String[]{connectionManagerVLogin, currentBackend.getName()});
02733 logger.error(msg);
02734
throw new SAXException(msg);
02735 }
02736
02737 currentDatabaseBackendUser =
new DatabaseBackendUser(backendName,
02738 connectionManagerRLogin, connectionManagerRPassword);
02739
02740
if (logger.isDebugEnabled())
02741 logger.debug(
Translate
02742 .get(
"virtualdatabase.xml.authentication.login.real.add",
02743
new String[]{connectionManagerRLogin, connectionManagerRPassword,
02744 backendName}));
02745
02746
try
02747 {
02748 currentAuthenticationManager.addRealUser(connectionManagerVLogin,
02749 currentDatabaseBackendUser);
02750 }
02751
catch (AuthenticationManagerException e)
02752 {
02753 String msg = Translate
02754 .get(
"virtualdatabase.xml.authentication.login.real.add.failed");
02755 logger.error(msg, e);
02756
throw new SAXException(msg, e);
02757 }
02758
02759
02760
02761
02762
02763
02764
02765
02766
02767
02768
02769
02770
02771
02772 }
02773
02780 private void newSimpleConnectionManager(Attributes atts)
02781 {
02782
if (logger.isDebugEnabled())
02783 logger.debug(
Translate.get(
02784
"virtualdatabase.xml.connectionmanager.simple.add",
new String[]{
02785 currentBackend.getName(), connectionManagerVLogin,
02786 currentDatabaseBackendUser.getLogin(),
02787 currentDatabaseBackendUser.getPassword()}));
02788
02789 currentBackend.addConnectionManager(connectionManagerVLogin,
02790
new SimpleConnectionManager(currentBackend.getURL(), currentBackend
02791 .getName(), currentDatabaseBackendUser.getLogin(),
02792 currentDatabaseBackendUser.getPassword(), currentBackend
02793 .getDriverPath(), currentBackend.getDriverClassName()));
02794 }
02795
02803 private void newFailFastPoolConnectionManager(Attributes atts)
02804
throws SAXException
02805 {
02806
try
02807 {
02808
int poolSize = Integer.parseInt(atts
02809 .getValue(
DatabasesXmlTags.ATT_poolSize));
02810
02811
02812
if (poolSize < 1)
02813
throw new IllegalArgumentException(
02814
Translate
02815 .get(
"virtualdatabase.xml.connectionmanager.failfast.failed.parameter"));
02816
02817
if (logger.isDebugEnabled())
02818 logger.debug(
Translate.get(
02819
"virtualdatabase.xml.connectionmanager.failfast.add",
new String[]{
02820 currentBackend.getName(), connectionManagerVLogin,
02821 String.valueOf(poolSize),
02822 currentDatabaseBackendUser.getLogin(),
02823 currentDatabaseBackendUser.getPassword()}));
02824
02825 currentBackend.addConnectionManager(connectionManagerVLogin,
02826
new FailFastPoolConnectionManager(currentBackend.getURL(),
02827 currentBackend.getName(), currentDatabaseBackendUser.getLogin(),
02828 currentDatabaseBackendUser.getPassword(), currentBackend
02829 .getDriverPath(), currentBackend.getDriverClassName(),
02830 poolSize));
02831 }
02832
catch (Exception e)
02833 {
02834 String msg =
Translate.get(
02835
"virtualdatabase.xml.connectionmanager.failfast.failed",
02836 currentBackend.getName());
02837 logger.error(msg, e);
02838
throw new SAXException(msg, e);
02839 }
02840 }
02841
02849 private void newRandomWaitPoolConnectionManager(Attributes atts)
02850
throws SAXException
02851 {
02852
try
02853 {
02854
int poolSize = Integer.parseInt(atts
02855 .getValue(
DatabasesXmlTags.ATT_poolSize));
02856 String timeoutString = atts.getValue(
DatabasesXmlTags.ATT_timeout);
02857
int timeout = 0;
02858
02859
if (timeoutString != null)
02860
02861 timeout = Integer.parseInt(timeoutString);
02862
02863
02864
if (timeout < 0 || poolSize < 1)
02865
throw new IllegalArgumentException(
02866
Translate
02867 .get(
"virtualdatabase.xml.connectionmanager.randomwait.failed.parameter"));
02868
02869
if (logger.isDebugEnabled())
02870 logger.debug(
Translate.get(
02871
"virtualdatabase.xml.connectionmanager.randomwait.add",
02872
new String[]{currentBackend.getName(), connectionManagerVLogin,
02873 String.valueOf(poolSize), String.valueOf(timeout),
02874 currentDatabaseBackendUser.getLogin(),
02875 currentDatabaseBackendUser.getPassword()}));
02876
02877 currentBackend.addConnectionManager(connectionManagerVLogin,
02878
new RandomWaitPoolConnectionManager(currentBackend.getURL(),
02879 currentBackend.getName(), currentDatabaseBackendUser.getLogin(),
02880 currentDatabaseBackendUser.getPassword(), currentBackend
02881 .getDriverPath(), currentBackend.getDriverClassName(),
02882 poolSize, timeout));
02883 }
02884
catch (Exception e)
02885 {
02886 String msg =
Translate.get(
02887
"virtualdatabase.xml.connectionmanager.randomwait.failed",
02888 currentBackend.getName());
02889 logger.error(msg, e);
02890
throw new SAXException(msg, e);
02891 }
02892 }
02893
02901 private void newVariablePoolConnectionManager(Attributes atts)
02902
throws SAXException
02903 {
02904
try
02905 {
02906
int initPoolSize = Integer.parseInt(atts
02907 .getValue(
DatabasesXmlTags.ATT_initPoolSize));
02908
02909
int minPoolSize = initPoolSize;
02910
02911 String attr = atts.getValue(
DatabasesXmlTags.ATT_minPoolSize);
02912
if (attr != null)
02913 minPoolSize = Integer.parseInt(attr);
02914
02915
02916
int maxPoolSize =
VariablePoolConnectionManager.DEFAULT_MAX_POOL_SIZE;
02917 attr = atts.getValue(
DatabasesXmlTags.ATT_maxPoolSize);
02918
if (attr != null)
02919 maxPoolSize = Integer.parseInt(attr);
02920
02921 String timeoutString = atts.getValue(
DatabasesXmlTags.ATT_idleTimeout);
02922
int idleTimeout =
VariablePoolConnectionManager.DEFAULT_IDLE_TIMEOUT;
02923
if (timeoutString != null)
02924
02925 idleTimeout = Integer.parseInt(timeoutString);
02926
02927 timeoutString = atts.getValue(
DatabasesXmlTags.ATT_waitTimeout);
02928
int waitTimeout =
VariablePoolConnectionManager.DEFAULT_WAIT_TIMEOUT;
02929
if (timeoutString != null)
02930
02931 waitTimeout = Integer.parseInt(timeoutString);
02932
02933
02934
if (minPoolSize < 0 || maxPoolSize < 0
02935 || (maxPoolSize != 0 && minPoolSize > maxPoolSize)
02936 || (maxPoolSize != 0 && initPoolSize > maxPoolSize)
02937 || initPoolSize < minPoolSize)
02938
throw new IllegalArgumentException(
02939
Translate
02940 .get(
"virtualdatabase.xml.connectionmanager.variable.failed.parameter"));
02941
02942
if (logger.isDebugEnabled())
02943 logger.debug(
Translate.get(
02944
"virtualdatabase.xml.connectionmanager.randomwait.add",
02945
new String[]{currentBackend.getName(), connectionManagerVLogin,
02946 String.valueOf(initPoolSize), String.valueOf(minPoolSize),
02947 String.valueOf(maxPoolSize), String.valueOf(idleTimeout),
02948 String.valueOf(waitTimeout),
02949 currentDatabaseBackendUser.getLogin(),
02950 currentDatabaseBackendUser.getPassword()}));
02951
02952 currentBackend
02953 .addConnectionManager(connectionManagerVLogin,
02954
new VariablePoolConnectionManager(currentBackend.getURL(),
02955 currentBackend.getName(), currentDatabaseBackendUser
02956 .getLogin(), currentDatabaseBackendUser.getPassword(),
02957 currentBackend.getDriverPath(), currentBackend
02958 .getDriverClassName(), initPoolSize, minPoolSize,
02959 maxPoolSize, idleTimeout, waitTimeout));
02960 }
02961
catch (Exception e)
02962 {
02963 String msg =
Translate.get(
02964
"virtualdatabase.xml.connectionmanager.variable.failed",
02965 currentBackend.getName());
02966 logger.error(msg, e);
02967
throw new SAXException(msg, e);
02968 }
02969 }
02970
02971
02972
02980 private void newDatabaseTable(Attributes atts)
throws SAXException
02981 {
02982 String tableName = atts.getValue(
DatabasesXmlTags.ATT_tableName);
02983 String nbOfColumns = atts.getValue(
DatabasesXmlTags.ATT_nbOfColumns);
02984
02985
if (logger.isDebugEnabled())
02986 logger.debug(
Translate.get(
"virtualdatabase.xml.schema.table.add",
02987
new String[]{tableName, String.valueOf(nbOfColumns)}));
02988
02989 numberOfColumns = Integer.parseInt(nbOfColumns);
02990
02991
try
02992 {
02993 currentTable =
new DatabaseTable(tableName, numberOfColumns);
02994 }
02995
catch (NumberFormatException e)
02996 {
02997 String msg = Translate.get(
"virtualdatabase.xml.schema.table.failed",
02998 tableName);
02999 logger.error(msg, e);
03000
throw new SAXException(msg, e);
03001 }
03002 }
03003
03004 private void newDatabaseSchema(Attributes atts)
03005 {
03006 String dynamicLevel = atts.getValue(
DatabasesXmlTags.ATT_dynamicPrecision);
03007 String gatherSystemTable = atts
03008 .getValue(
DatabasesXmlTags.ATT_gatherSystemTables);
03009
if (dynamicLevel == null)
03010 dynamicLevel =
DatabasesXmlTags.VAL_all;
03011
if (gatherSystemTable == null)
03012 gatherSystemTable =
DatabasesXmlTags.VAL_false;
03013 currentBackend.setDynamicPrecision(
DatabaseBackendSchemaConstants
03014 .getDynamicSchemaLevel(dynamicLevel),
DatabasesXmlTags.VAL_true
03015 .equals(gatherSystemTable));
03016 }
03017
03024 private void newDatabaseColumn(Attributes atts)
03025 {
03026 String columnName = atts.getValue(
DatabasesXmlTags.ATT_columnName);
03027 String isUnique = atts.getValue(
DatabasesXmlTags.ATT_isUnique);
03028
03029
if (logger.isDebugEnabled())
03030 logger.debug(
Translate.get(
"virtualdatabase.xml.schema.column.add",
03031
new String[]{columnName, String.valueOf(isUnique)}));
03032
03033 currentTable.addColumn(
new DatabaseColumn(columnName, isUnique
03034 .equals(
DatabasesXmlTags.VAL_true)));
03035 }
03036
03037 private void newDatabaseProcedure(Attributes atts)
03038 {
03039 String procedureName = atts.getValue(
DatabasesXmlTags.ATT_name);
03040 String returnType = atts.getValue(
DatabasesXmlTags.ATT_returnType);
03041
if (logger.isDebugEnabled())
03042 logger.debug(
Translate.get(
"virtualdatabase.xml.schema.procedure.add",
03043
new String[]{procedureName, returnType}));
03044
03045 currentProcedure =
new DatabaseProcedure(procedureName,
"",
03046
DatabaseProcedure.getTypeFromString(returnType));
03047 }
03048
03049 private void newDatabaseProcedureColumn(Attributes atts)
03050 {
03051 String paramName = atts.getValue(
DatabasesXmlTags.ATT_name);
03052 String nullable = atts.getValue(
DatabasesXmlTags.ATT_nullable);
03053 String type = atts.getValue(
DatabasesXmlTags.ATT_paramType);
03054
if (logger.isDebugEnabled())
03055 logger.debug(
Translate.get(
03056
"virtualdatabase.xml.schema.procedure.parameter.add",
new String[]{
03057 paramName, nullable, type}));
03058 currentProcedure.addParameter(
new DatabaseProcedureParameter(paramName,
03059
DatabaseProcedureParameter.getColumnTypeFromString(type),
03060
DatabaseProcedureParameter.getNullFromString(nullable)));
03061 }
03062 }
