DatabasesParser.java の 133 行で定義されています。
Public メソッド | |
| DatabasesParser (Controller controller) throws SAXException | |
| DatabasesParser (Controller controller, String virtualName, boolean autoEnable, String checkPoint) throws SAXException | |
| void | readXML (String xml) throws IOException, SAXException |
| void | readXML (String xml, boolean validateBeforeParsing) throws IOException, SAXException |
| void | fatalError (SAXParseException e) throws SAXException |
| void | error (SAXParseException e) throws SAXException |
| InputSource | resolveEntity (String publicId, String systemId) throws SAXException |
| void | prepareDB (String virtualName, boolean autoEnable, String checkPoint) |
| void | startDocument () throws SAXException |
| void | endDocument () throws SAXException |
| void | startElement (String uri, String localName, String name, Attributes atts) throws SAXException |
| void | endElement (String uri, String localName, String name) throws SAXException |
スタティック変数 | |
| Trace | logger |
Private メソッド | |
| void | prepareHandler (Controller controller) throws SAXException |
| void | newVirtualDatabase (Attributes atts) throws SAXException |
| void | newDistribution (Attributes atts) throws SAXException |
| void | newBackendRecoveryPolicy (Attributes atts) throws SAXException |
| void | newControllerName (Attributes atts) throws SAXException |
| void | newSQLMonitoring (Attributes atts) |
| void | newSQLMonitoringRule (Attributes atts) throws SAXException |
| void | newDatabaseBackend (Attributes atts) |
| void | newRewritingRule (Attributes atts) throws SAXException |
| void | newAuthenticationManager (Attributes atts) |
| void | newAdminLogin (Attributes atts) |
| void | newVirtualLogin (Attributes atts) |
| void | newRealLogin (Attributes atts) throws SAXException |
| void | newRequestManager (Attributes atts) throws SAXException |
| void | newSingleDBScheduler (Attributes atts) throws SAXException |
| void | newRAIDb0Scheduler (Attributes atts) throws SAXException |
| void | newRAIDb1Scheduler (Attributes atts) throws SAXException |
| void | newRAIDb2Scheduler (Attributes atts) throws SAXException |
| void | newMetadataCache (Attributes atts) throws SAXException |
| void | newParsingCache (Attributes atts) throws SAXException |
| void | newResultCache (Attributes atts) throws SAXException |
| void | newResultCacheRule (Attributes atts) throws SAXException |
| void | newDefaultResultCacheRule (Attributes atts) throws SAXException |
| void | newRelaxedCaching (Attributes atts) |
| void | newSingleDBRequestLoadBalancer (Attributes atts) throws SAXException |
| void | newParallelDBLeastPendingRequestsFirst (Attributes atts) throws SAXException |
| void | newParallelDBRoundRobinLoadBalancer (Attributes atts) throws SAXException |
| void | newRAIDb0LoadBalancer (Attributes atts) throws SAXException |
| void | newRAIDb1LoadBalancer (Attributes atts) throws SAXException |
| void | newRAIDb1RoundRobinLoadBalancer (Attributes atts) throws SAXException |
| void | newRAIDb1WeightedRoundRobinLoadBalancer (Attributes atts) throws SAXException |
| void | newRAIDb1LeastPendingRequestsFirst (Attributes atts) throws SAXException |
| void | newRAIDb1ecLoadBalancer (Attributes atts) throws SAXException |
| void | newRAIDb1ecRoundRobinLoadBalancer (Attributes atts) throws SAXException |
| void | newRAIDb1ecWeightedRoundRobinLoadBalancer (Attributes atts) throws SAXException |
| void | newRAIDb2LoadBalancer (Attributes atts) throws SAXException |
| void | newRAIDb2RoundRobinLoadBalancer (Attributes atts) throws SAXException |
| void | newRAIDb2WeightedRoundRobinLoadBalancer (Attributes atts) throws SAXException |
| void | newRAIDb2LeastPendingRequestsFirst (Attributes atts) throws SAXException |
| void | newRAIDb2ecLoadBalancer (Attributes atts) |
| void | newRAIDb2ecRoundRobinLoadBalancer (Attributes atts) throws SAXException |
| void | newRAIDb2ecWeightedRoundRobinLoadBalancer (Attributes atts) throws SAXException |
| void | newWaitForCompletion (Attributes atts) throws SAXException |
| void | newErrorChecking (Attributes atts) throws SAXException |
| void | newCreateTable (Attributes atts) throws SAXException |
| void | newBackendName (Attributes atts) throws SAXException |
| void | newBackendWeight (Attributes atts) throws SAXException |
| void | newJDBCRecoveryLog (Attributes atts) throws SAXException |
| void | newJDBCRecoveryLogTable (Attributes atts) throws SAXException |
| void | newJDBCRecoveryCheckpointTable (Attributes atts) throws SAXException |
| void | newJDBCRecoveryBackendTable (Attributes atts) throws SAXException |
| void | newFileRecoveryLog (Attributes atts) throws SAXException |
| void | newConnectionManager (Attributes atts) throws SAXException |
| void | newSimpleConnectionManager (Attributes atts) |
| void | newFailFastPoolConnectionManager (Attributes atts) throws SAXException |
| void | newRandomWaitPoolConnectionManager (Attributes atts) throws SAXException |
| void | newVariablePoolConnectionManager (Attributes atts) throws SAXException |
| void | newDatabaseTable (Attributes atts) throws SAXException |
| void | newDatabaseSchema (Attributes atts) |
| void | newDatabaseColumn (Attributes atts) |
| void | newDatabaseProcedure (Attributes atts) |
| void | newDatabaseProcedureColumn (Attributes atts) |
Private 変数 | |
| XMLReader | parser |
| Controller | controller |
| Hashtable | dbToPrepare = null |
| boolean | skipDatabase = false |
| VirtualDatabase | currentVirtualDatabase = null |
| DatabaseBackend | currentBackend |
| DatabaseBackendUser | currentDatabaseBackendUser |
| AuthenticationManager | currentAuthenticationManager |
| AbstractScheduler | currentRequestScheduler |
| AbstractResultCache | currentResultCache |
| MetadataCache | currentMetadataCache = null |
| ParsingCache | currentParsingCache = null |
| ResultCacheRule | currentResultCacheRule |
| String | currentQueryPattern |
| AbstractLoadBalancer | currentLoadBalancer |
| long | currentTimestampResolution |
| JDBCRecoveryLog | currentRecoveryLog |
| VirtualDatabaseUser | currentVirtualUser |
| String | databaseSchemaDynamicLevel |
| DatabaseSchema | currentDatabaseSchema |
| DatabaseTable | currentTable |
| DatabaseProcedure | currentProcedure |
| int | numberOfColumns |
| String | connectionManagerVLogin |
| WaitForCompletionPolicy | currentWaitForCompletionPolicy |
| long | beginTimeout |
| long | commitTimeout |
| long | rollbackTimeout |
| int | requestTimeout |
| boolean | caseSensitiveParsing |
| CreateTablePolicy | currentCreateTablePolicy |
| CreateTableRule | currentCreateTableRule |
| ArrayList | backendNameList |
| ErrorCheckingPolicy | currentErrorCheckingPolicy |
| int | currentNbOfConcurrentReads |
| BackendRecoveryPolicy | currentBackendRecoveryPolicy |
Static Private 変数 | |
| final String | C_JDBC_DTD_FILE = "c-jdbc.dtd" |
|
|
Creates a new
DatabasesParser.java の 201 行で定義されています。 参照先 org.objectweb.cjdbc.controller.xml.DatabasesParser.prepareHandler().
00202 {
00203 prepareHandler(controller);
00204 }
|
|
||||||||||||||||||||
|
Creates a new
DatabasesParser.java の 218 行で定義されています。 参照先 org.objectweb.cjdbc.controller.xml.DatabasesParser.prepareDB(), と org.objectweb.cjdbc.controller.xml.DatabasesParser.prepareHandler().
00220 {
00221 prepareHandler(controller);
00222 // Test if a name has been specified. Otherwise skip.
00223 if (virtualName != null)
00224 prepareDB(virtualName, autoEnable, checkPoint);
00225 }
|
|
|
Finalizes parsing of a document.
DatabasesParser.java の 380 行で定義されています。
00381 {
00382 logger.info(Translate.get("virtualdatabase.xml.done"));
00383 }
|
|
||||||||||||||||
|
DatabasesParser for end of element.
DatabasesParser.java の 598 行で定義されています。 参照先 org.objectweb.cjdbc.controller.cache.result.ResultCacheRule.setCacheBehavior(), org.objectweb.cjdbc.controller.requestmanager.RequestManager.setCaseSensitiveParsing(), org.objectweb.cjdbc.controller.requestmanager.RequestManager.setMetadataCache(), と org.objectweb.cjdbc.controller.requestmanager.RequestManager.setParsingCache().
00600 {
00601 logger.debug(Translate.get("virtualdatabase.xml.parsing.end", name));
00602 // Test if skip is needed
00603 if (skipDatabase)
00604 return;
00605
00606 // Virtual database
00607 if (name.equals(DatabasesXmlTags.ELT_VirtualDatabase))
00608 {
00609 if (logger.isDebugEnabled())
00610 logger.debug(Translate.get("virtualdatabase.xml.add.virtualdatabase"));
00611
00612 if (currentVirtualDatabase != null)
00613 {
00614 try
00615 {
00616 if (currentVirtualDatabase instanceof DistributedVirtualDatabase)
00617 ((DistributedVirtualDatabase) currentVirtualDatabase).joinGroup();
00618 if (dbToPrepare == null)
00619 {
00620 controller.addVirtualDatabase(currentVirtualDatabase);
00621 }
00622 else
00623 {
00624 boolean autoEnable = new Boolean((String) dbToPrepare
00625 .get("autoEnable")).booleanValue();
00626 String checkPoint = (String) dbToPrepare.get("checkPoint");
00627 // checkPoint is store as "" in Hashtable
00628 // but methods to enable backend requires checkPoint to be null
00629 // if no recovery from checkpoint
00630 checkPoint = checkPoint.equalsIgnoreCase("") ? null : checkPoint;
00631 controller.addVirtualDatabase(currentVirtualDatabase, autoEnable,
00632 checkPoint);
00633 }
00634 }
00635 catch (Exception e)
00636 {
00637 String msg = Translate.get("controller.add.virtualdatabase.failed");
00638 if (e instanceof RuntimeException)
00639 logger.error(msg, e);
00640 else
00641 logger.error(msg);
00642 }
00643 }
00644 currentVirtualDatabase = null;
00645 }
00646
00647 // Request manager
00648 else if (name.equals(DatabasesXmlTags.ELT_RequestManager))
00649 {
00650 if (logger.isDebugEnabled())
00651 logger.debug(Translate.get("virtualdatabase.xml.requestmanager.set"));
00652
00653 if (currentVirtualDatabase != null)
00654 {
00655 RequestManager requestManager = null;
00656
00657 try
00658 {
00659 if (currentVirtualDatabase.isDistributed())
00660 {
00661 switch (currentLoadBalancer.getRAIDbLevel())
00662 {
00663 case RAIDbLevels.SingleDB :
00664 requestManager = new SingleDBDistributedRequestManager(
00665 (DistributedVirtualDatabase) currentVirtualDatabase,
00666 currentRequestScheduler, currentResultCache,
00667 currentLoadBalancer, currentRecoveryLog, beginTimeout,
00668 commitTimeout, rollbackTimeout);
00669 break;
00670 case RAIDbLevels.RAIDb1 :
00671 requestManager = new RAIDb1DistributedRequestManager(
00672 (DistributedVirtualDatabase) currentVirtualDatabase,
00673 currentRequestScheduler, currentResultCache,
00674 currentLoadBalancer, currentRecoveryLog, beginTimeout,
00675 commitTimeout, rollbackTimeout);
00676 break;
00677 case RAIDbLevels.RAIDb2 :
00678 requestManager = new RAIDb2DistributedRequestManager(
00679 (DistributedVirtualDatabase) currentVirtualDatabase,
00680 currentRequestScheduler, currentResultCache,
00681 currentLoadBalancer, currentRecoveryLog, beginTimeout,
00682 commitTimeout, rollbackTimeout);
00683 break;
00684 default :
00685 String msg = Translate.get(
00686 "virtualdatabase.xml.no.distributed.requestmanager",
00687 currentLoadBalancer.getRAIDbLevel());
00688 logger.error(msg);
00689 throw new SAXException(msg);
00690 }
00691 }
00692 else
00693 requestManager = new RequestManager(currentVirtualDatabase,
00694 currentRequestScheduler, currentResultCache,
00695 currentLoadBalancer, currentRecoveryLog, beginTimeout,
00696 commitTimeout, rollbackTimeout);
00697
00698 if (requestManager != null)
00699 {
00700 if (currentParsingCache != null)
00701 requestManager.setParsingCache(currentParsingCache);
00702 if (currentMetadataCache != null)
00703 requestManager.setMetadataCache(currentMetadataCache);
00704 requestManager.setCaseSensitiveParsing(caseSensitiveParsing);
00705 }
00706
00707 currentVirtualDatabase.setRequestManager(requestManager);
00708 }
00709 catch (Exception e)
00710 {
00711 String msg = Translate
00712 .get("virtualdatabase.xml.requestmanager.creation.failed");
00713 logger.error(msg, e);
00714 throw new SAXException(msg, e);
00715 }
00716 }
00717 }
00718
00719 // Database backend
00720 else if (name.equals(DatabasesXmlTags.ELT_DatabaseBackend))
00721 {
00722 if (currentBackend != null)
00723 {
00724 try
00725 {
00726 currentVirtualDatabase.addBackend(currentBackend, false);
00727 }
00728 catch (Exception e)
00729 {
00730 String msg = Translate.get("virtualdatabase.xml.backend.add.failed");
00731 logger.error(msg + " (" + e + ")");
00732 throw new SAXException(msg, e);
00733 }
00734 }
00735 currentBackend = null;
00736 }
00737
00738 // Authentication manager
00739 else if (name.equals(DatabasesXmlTags.ELT_AuthenticationManager))
00740 {
00741 if (currentVirtualDatabase != null)
00742 {
00743 currentVirtualDatabase
00744 .setAuthenticationManager(currentAuthenticationManager);
00745 }
00746 }
00747
00748 // Request cache
00749 else if (name.equals(DatabasesXmlTags.ELT_RequestCache))
00750 {
00751 if (currentResultCache != null)
00752 { // Set default result cache rule if missing
00753 if (currentResultCache.getDefaultRule() == null)
00754 {
00755 ResultCacheRule defaultRule = null;
00756 try
00757 {
00758 defaultRule = new ResultCacheRule("", false, false, 1000);
00759 }
00760 catch (RESyntaxException impossible)
00761 {
00762 }
00763 defaultRule.setCacheBehavior(new EagerCaching());
00764 currentResultCache.setDefaultRule(defaultRule);
00765 }
00766 }
00767 }
00768 else if (name.equals(DatabasesXmlTags.ELT_DefaultResultCacheRule))
00769 {
00770 currentResultCache.setDefaultRule(currentResultCacheRule);
00771 }
00772
00773 // Database schema
00774 else if (name.equals(DatabasesXmlTags.ELT_DatabaseStaticSchema))
00775 {
00776 if (currentDatabaseSchema != null)
00777 {
00778 if (currentBackend != null)
00779 {
00780 try
00781 {
00782 currentBackend.setDatabaseSchema(currentDatabaseSchema, true);
00783 }
00784 catch (Exception e)
00785 {
00786 logger.error(Translate
00787 .get("virtualdatabase.xml.backend.set.schema.failed"), e);
00788 }
00789 }
00790 else
00791 {
00792 try
00793 {
00794 currentVirtualDatabase.setDatabaseSchema(currentDatabaseSchema,
00795 true);
00796 }
00797 catch (Exception e)
00798 {
00799 logger.error(Translate
00800 .get("virtualdatabase.xml.virtualdatabase.set.schema.failed"),
00801 e);
00802 }
00803 }
00804 currentDatabaseSchema = null;
00805 }
00806 }
00807
00808 // Database table
00809 else if (name.equals(DatabasesXmlTags.ELT_DatabaseTable))
00810 {
00811 if (currentTable != null)
00812 {
00813 try
00814 {
00815 ArrayList cols = currentTable.getColumns();
00816 if (cols == null)
00817 logger.warn(Translate.get("virtualdatabase.xml.table.no.column",
00818 currentTable.getName()));
00819 else if (cols.size() != numberOfColumns)
00820 logger.warn(Translate.get(
00821 "virtualdatabase.xml.table.column.mismatch", new String[]{
00822 String.valueOf(numberOfColumns), currentTable.getName(),
00823 String.valueOf(cols.size())}));
00824
00825 currentDatabaseSchema.addTable(currentTable);
00826 if (logger.isDebugEnabled())
00827 logger.debug(Translate.get("virtualdatabase.xml.table.add",
00828 currentTable.getName()));
00829 }
00830 catch (Exception e)
00831 {
00832 logger
00833 .error(Translate.get("virtualdatabase.xml.table.add.failed"), e);
00834 }
00835 currentTable = null;
00836 }
00837 }
00838
00839 else if (name.equals(DatabasesXmlTags.ELT_DatabaseProcedure))
00840 {
00841 if (currentProcedure != null)
00842 {
00843 try
00844 {
00845
00846 currentDatabaseSchema.addProcedure(currentProcedure);
00847 if (logger.isDebugEnabled())
00848 logger.debug(Translate.get("virtualdatabase.xml.procedure.add",
00849 currentProcedure.getName()));
00850 }
00851 catch (Exception e)
00852 {
00853 logger.error(Translate
00854 .get("virtualdatabase.xml.procedure.add.failed"), e);
00855 }
00856 currentProcedure = null;
00857 }
00858 }
00859
00860 // CreateTable rule
00861 else if (name.equals(DatabasesXmlTags.ELT_CreateTable))
00862 {
00863 if (currentCreateTablePolicy != null)
00864 {
00865 if (logger.isDebugEnabled())
00866 logger.debug(Translate.get("virtualdatabase.xml.create.table.add",
00867 currentCreateTableRule.getInformation()));
00868 currentCreateTablePolicy.addRule(currentCreateTableRule);
00869 }
00870 }
00871
00872 // RAIDb-0 load balancer
00873 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_0))
00874 {
00875 if (logger.isDebugEnabled())
00876 logger.debug(Translate
00877 .get("virtualdatabase.xml.loadbalancer.raidb0.set"));
00878
00879 if (currentCreateTablePolicy.getDefaultRule() == null)
00880 {
00881 if (logger.isDebugEnabled())
00882 logger.debug(Translate
00883 .get("virtualdatabase.xml.create.table.default"));
00884 CreateTableRule rule = new CreateTableRoundRobin();
00885 currentCreateTablePolicy.addRule(rule);
00886 }
00887 try
00888 {
00889 currentLoadBalancer = new RAIDb0(currentVirtualDatabase,
00890 currentCreateTablePolicy);
00891 }
00892 catch (SQLException e)
00893 {
00894 String msg = Translate
00895 .get("virtualdatabase.xml.loadbalancer.raidb0.failed");
00896 logger.error(msg, e);
00897 throw new SAXException(msg, e);
00898 }
00899 }
00900
00901 // JDBC Recovery Log
00902 else if (name.equals(DatabasesXmlTags.ELT_RecoveryLog))
00903 {
00904 if (logger.isDebugEnabled())
00905 logger.debug(Translate
00906 .get("virtualdatabase.xml.recoverylog.cheking.tables"));
00907 {
00908 currentRecoveryLog.checkRecoveryLogTables();
00909 // Set the last transaction id of the scheduler from the recovery logs
00910 try
00911 {
00912 currentRequestScheduler.initializeTransactionId(currentRecoveryLog
00913 .getLastTransactionId() + 1);
00914 }
00915 catch (Exception e)
00916 {
00917 String msg = Translate
00918 .get("virtualdatabase.xml.scheduler.initialization.failed");
00919 logger.error(msg, e);
00920 throw new SAXException(msg);
00921 }
00922 }
00923 }
00924 }
|
|
|
Handles notification of a recoverable parser error.
DatabasesParser.java の 320 行で定義されています。
00321 {
00322 logger.error(Translate.get("virtualdatabase.xml.parsing.error",
00323 new String[]{e.getPublicId(), String.valueOf(e.getLineNumber()),
00324 String.valueOf(e.getColumnNumber()), e.getMessage()}));
00325 throw e;
00326 }
|
|
|
Handles notification of a non-recoverable parser error.
DatabasesParser.java の 305 行で定義されています。 参照先 org.objectweb.cjdbc.common.log.Trace.error().
00306 {
00307 logger.error(Translate.get("virtualdatabase.xml.parsing.fatal",
00308 new String[]{e.getPublicId(), String.valueOf(e.getLineNumber()),
00309 String.valueOf(e.getColumnNumber()), e.getMessage()}));
00310 throw e;
00311 }
|
|
|
Sets the administrator user of the currentAuthenticationManager using the parsed attributs.
DatabasesParser.java の 1249 行で定義されています。
01250 {
01251 String aLogin = atts.getValue(DatabasesXmlTags.ATT_aLogin);
01252 String aPassword = atts.getValue(DatabasesXmlTags.ATT_aPassword);
01253
01254 if (logger.isDebugEnabled())
01255 logger.debug(Translate.get(
01256 "virtualdatabase.xml.authentication.login.admin.add", new String[]{
01257 aLogin, aPassword}));
01258 currentAuthenticationManager.setAdminUser(new VirtualDatabaseUser(aLogin,
01259 aPassword));
01260 }
|
|
|
Sets currentAuthenticationManageras a new
DatabasesParser.java の 1238 行で定義されています。
01239 {
01240 currentAuthenticationManager = new AuthenticationManager();
01241 }
|
|
|
Adds a backend name to the current backendNameList.
DatabasesParser.java の 2429 行で定義されています。
02430 {
02431 String name = atts.getValue(DatabasesXmlTags.ATT_name);
02432 if (logger.isDebugEnabled())
02433 logger.debug(Translate
02434 .get("virtualdatabase.xml.backend.policy.add", name));
02435 backendNameList.add(name);
02436 }
|
|
|
Adds a new
DatabasesParser.java の 1043 行で定義されています。
01044 {
01045 String backendName = atts.getValue(DatabasesXmlTags.ATT_backendName);
01046 String recoveryPolicyString = atts
01047 .getValue(DatabasesXmlTags.ATT_recoveryPolicy);
01048
01049 boolean recoveryPolicy;
01050 if (recoveryPolicyString.equals(DatabasesXmlTags.VAL_on))
01051 recoveryPolicy = true;
01052 else if (recoveryPolicyString.equals(DatabasesXmlTags.VAL_off))
01053 recoveryPolicy = false;
01054 else
01055 throw new SAXException(
01056 Translate
01057 .get(
01058 "virtualdatabase.xml.virtualdatabase.distributed.recoverOnFailure.bad.value",
01059 recoveryPolicyString));
01060
01061 currentBackendRecoveryPolicy = new BackendRecoveryPolicy(backendName,
01062 recoveryPolicy);
01063 ((DistributedVirtualDatabase) currentVirtualDatabase)
01064 .addBackendRecoveryPolicy(currentBackendRecoveryPolicy);
01065 }
|
|
|
Sets the weight of the currentLoadBalancerusing the parsed attributes.
DatabasesParser.java の 2445 行で定義されています。
02446 {
02447 String name = atts.getValue(DatabasesXmlTags.ATT_name);
02448 try
02449 {
02450 int weight = Integer.parseInt(atts.getValue(DatabasesXmlTags.ATT_weight));
02451
02452 if (logger.isDebugEnabled())
02453 logger.debug(Translate.get("virtualdatabase.xml.backend.weigth.set",
02454 new String[]{String.valueOf(weight), name}));
02455
02456 currentLoadBalancer.setWeight(name, weight);
02457 }
02458 catch (Exception e)
02459 {
02460 String msg = Translate.get("virtualdatabase.xml.backend.weigth.failed",
02461 name);
02462 logger.error(msg, e);
02463 throw new SAXException(msg, e);
02464 }
02465 }
|
|
|
Sets the currentRecoveryLog as new
DatabasesParser.java の 2655 行で定義されています。
02656 {
02657 connectionManagerVLogin = atts.getValue(DatabasesXmlTags.ATT_vLogin);
02658
02659 // Check that the virtual login has been defined
02660 if (!currentAuthenticationManager
02661 .isValidVirtualLogin(connectionManagerVLogin))
02662 {
02663 String msg = Translate.get(
02664 "virtualdatabase.xml.connectionmanager.vlogin.undefined",
02665 new String[]{connectionManagerVLogin, currentBackend.getName()});
02666 logger.error(msg);
02667 throw new SAXException(msg);
02668 }
02669
02670 // Get database real user
02671 currentDatabaseBackendUser = currentAuthenticationManager
02672 .getDatabaseBackendUser(connectionManagerVLogin, currentBackend
02673 .getName());
02674
02675 if (currentDatabaseBackendUser == null)
02676 {
02677 String msg = Translate.get(
02678 "virtualdatabase.xml.connectionmanager.rlogin.undefined",
02679 new String[]{currentBackend.getName(), connectionManagerVLogin});
02680 logger.error(msg);
02681 throw new SAXException(msg);
02682 }
02683 }
|
|
|
Adds a new
DatabasesParser.java の 1074 行で定義されています。
01075 {
01076 String name = atts.getValue(DatabasesXmlTags.ATT_name);
01077 try
01078 {
01079 currentBackendRecoveryPolicy.addController(name);
01080 }
01081 catch (ControllerException e)
01082 {
01083 throw new SAXException(e);
01084 }
01085 }
|
|
|
Add a CreateTable rule.
DatabasesParser.java の 2403 行で定義されています。
02404 {
02405 String tableName = atts.getValue(DatabasesXmlTags.ATT_tableName);
02406 String nbOfNodes = atts.getValue(DatabasesXmlTags.ATT_numberOfNodes);
02407 String policy = atts.getValue(DatabasesXmlTags.ATT_policy);
02408 backendNameList = new ArrayList();
02409 if (policy.equals(DatabasesXmlTags.VAL_random))
02410 currentCreateTableRule = new CreateTableRandom(backendNameList);
02411 else if (policy.equals(DatabasesXmlTags.VAL_roundRobin))
02412 currentCreateTableRule = new CreateTableRoundRobin(backendNameList);
02413 else if (policy.equals(DatabasesXmlTags.VAL_all))
02414 currentCreateTableRule = new CreateTableAll(backendNameList);
02415 else
02416 throw new SAXException(Translate.get(
02417 "virtualdatabase.xml.create.table.unsupported", policy));
02418
02419 currentCreateTableRule.setNumberOfNodes(Integer.parseInt(nbOfNodes));
02420 currentCreateTableRule.setTableName(tableName);
02421 }
|
|
|
Sets currentBackendas a new
DatabasesParser.java の 1159 行で定義されています。
01160 {
01161 String name = atts.getValue(DatabasesXmlTags.ATT_name);
01162 String driverClassName = atts.getValue(DatabasesXmlTags.ATT_driver);
01163 String driverPath = atts.getValue(DatabasesXmlTags.ATT_driverPath);
01164 String url = atts.getValue(DatabasesXmlTags.ATT_url);
01165 String connectionTestStatement = atts
01166 .getValue(DatabasesXmlTags.ATT_connectionTestStatement);
01167
01168 if (logger.isDebugEnabled())
01169 {
01170 logger.debug(Translate.get("virtualdatabase.xml.backend.create",
01171 new String[]{name, driverClassName, url, connectionTestStatement}));
01172 if (driverPath == null)
01173 {
01174 logger.debug("no driver path defined for backend.");
01175 }
01176 else
01177 {
01178 logger.debug("using driver path " + driverPath);
01179 }
01180 }
01181 currentBackend = new DatabaseBackend(name, driverPath, driverClassName,
01182 url, connectionTestStatement);
01183 }
|
|
|
Adds to currentTablea new
DatabasesParser.java の 2928 行で定義されています。
02929 {
02930 String columnName = atts.getValue(DatabasesXmlTags.ATT_columnName);
02931 String isUnique = atts.getValue(DatabasesXmlTags.ATT_isUnique);
02932
02933 if (logger.isDebugEnabled())
02934 logger.debug(Translate.get("virtualdatabase.xml.schema.column.add",
02935 new String[]{columnName, String.valueOf(isUnique)}));
02936
02937 currentTable.addColumn(new DatabaseColumn(columnName, isUnique
02938 .equals(DatabasesXmlTags.VAL_true)));
02939 }
|
|
|
DatabasesParser.java の 2941 行で定義されています。
02942 {
02943 String procedureName = atts.getValue(DatabasesXmlTags.ATT_name);
02944 String returnType = atts.getValue(DatabasesXmlTags.ATT_returnType);
02945 if (logger.isDebugEnabled())
02946 logger.debug(Translate.get("virtualdatabase.xml.schema.procedure.add",
02947 new String[]{procedureName, returnType}));
02948
02949 currentProcedure = new DatabaseProcedure(procedureName, "",
02950 DatabaseProcedure.getTypeFromString(returnType));
02951 }
|
|
|
DatabasesParser.java の 2953 行で定義されています。
02954 {
02955 String paramName = atts.getValue(DatabasesXmlTags.ATT_name);
02956 String nullable = atts.getValue(DatabasesXmlTags.ATT_nullable);
02957 String type = atts.getValue(DatabasesXmlTags.ATT_paramType);
02958 if (logger.isDebugEnabled())
02959 logger.debug(Translate.get(
02960 "virtualdatabase.xml.schema.procedure.parameter.add", new String[]{
02961 paramName, nullable, type}));
02962 currentProcedure.addParameter(new DatabaseProcedureParameter(paramName,
02963 DatabaseProcedureParameter.getColumnTypeFromString(type),
02964 DatabaseProcedureParameter.getNullFromString(nullable)));
02965 }
|
|
|
DatabasesParser.java の 2915 行で定義されています。
02916 {
02917 String dynamicLevel = atts.getValue(DatabasesXmlTags.ATT_dynamicPrecision);
02918 currentBackend.setDynamicPrecision(DatabaseBackendSchemaConstants
02919 .getDynamicSchemaLevel(dynamicLevel));
02920 }
|
|
|
Sets currentTableas a new
DatabasesParser.java の 2891 行で定義されています。
02892 {
02893 String tableName = atts.getValue(DatabasesXmlTags.ATT_tableName);
02894 String nbOfColumns = atts.getValue(DatabasesXmlTags.ATT_nbOfColumns);
02895
02896 if (logger.isDebugEnabled())
02897 logger.debug(Translate.get("virtualdatabase.xml.schema.table.add",
02898 new String[]{tableName, String.valueOf(nbOfColumns)}));
02899
02900 numberOfColumns = Integer.parseInt(nbOfColumns);
02901
02902 try
02903 {
02904 currentTable = new DatabaseTable(tableName, numberOfColumns);
02905 }
02906 catch (NumberFormatException e)
02907 {
02908 String msg = Translate.get("virtualdatabase.xml.schema.table.failed",
02909 tableName);
02910 logger.error(msg, e);
02911 throw new SAXException(msg, e);
02912 }
02913 }
|
|
|
Set the
DatabasesParser.java の 1702 行で定義されています。
01703 {
01704 try
01705 {
01706 currentTimestampResolution = Long.parseLong(atts
01707 .getValue(DatabasesXmlTags.ATT_timestampResolution)) / 1000;
01708 }
01709 catch (Exception e)
01710 {
01711 String msg = Translate
01712 .get("virtualdatabase.invalid.timestamp.resolution");
01713 currentTimestampResolution = 1000;
01714 }
01715 // Create a fake rule
01716 try
01717 {
01718 currentResultCacheRule = new ResultCacheRule("", false, false,
01719 currentTimestampResolution);
01720 }
01721 catch (RESyntaxException e)
01722 {
01723 throw new SAXException(Translate.get(
01724 "virtualdatabase.xml.cache.rule.default.invalid", e));
01725 }
01726 }
|
|
|
Sets currentVirtualDatabaseas a new
DatabasesParser.java の 1007 行で定義されています。
01008 {
01009 String groupName = atts.getValue(DatabasesXmlTags.ATT_groupName);
01010 if (groupName == null)
01011 groupName = currentVirtualDatabase.getName();
01012
01013 if (logger.isDebugEnabled())
01014 logger.debug(Translate.get(
01015 "virtualdatabase.xml.virtualdatabase.distributed.create",
01016 new String[]{currentVirtualDatabase.getName(), groupName}));
01017 try
01018 {
01019 currentVirtualDatabase = new DistributedVirtualDatabase(controller
01020 .getName(), currentVirtualDatabase.getName(), groupName,
01021 currentVirtualDatabase.getMaxNbOfConnections(),
01022 currentVirtualDatabase.isPoolConnectionThreads(),
01023 currentVirtualDatabase.getMinNbOfThreads(), currentVirtualDatabase
01024 .getMaxNbOfThreads(), currentVirtualDatabase
01025 .getMaxThreadIdleTime(), currentVirtualDatabase.getBlobFilter());
01026 }
01027 catch (Exception e)
01028 {
01029 String msg = Translate
01030 .get("virtualdatabase.xml.virtualdatabase.distributed.failed");
01031 logger.error(msg, e);
01032 throw new SAXException(msg, e);
01033 }
01034 }
|
|
|
Add an ErrorChecking policy.
DatabasesParser.java の 2380 行で定義されています。
02381 {
02382 String nbOfNodes = atts.getValue(DatabasesXmlTags.ATT_numberOfNodes);
02383 String policy = atts.getValue(DatabasesXmlTags.ATT_policy);
02384 if (policy.equals(DatabasesXmlTags.VAL_random))
02385 currentErrorCheckingPolicy = new ErrorCheckingRandom(Integer
02386 .parseInt(nbOfNodes));
02387 else if (policy.equals(DatabasesXmlTags.VAL_roundRobin))
02388 currentErrorCheckingPolicy = new ErrorCheckingRoundRobin(Integer
02389 .parseInt(nbOfNodes));
02390 else if (policy.equals(DatabasesXmlTags.VAL_all))
02391 currentErrorCheckingPolicy = new ErrorCheckingAll();
02392 else
02393 throw new SAXException(Translate.get(
02394 "virtualdatabase.xml.loadbalancer.errorchecking.unsupported", policy));
02395 }
|
|
|
Adds a new
DatabasesParser.java の 2714 行で定義されています。
02716 {
02717 try
02718 {
02719 int poolSize = Integer.parseInt(atts
02720 .getValue(DatabasesXmlTags.ATT_poolSize));
02721
02722 // sanity check
02723 if (poolSize < 1)
02724 throw new IllegalArgumentException(
02725 Translate
02726 .get("virtualdatabase.xml.connectionmanager.failfast.failed.parameter"));
02727
02728 if (logger.isDebugEnabled())
02729 logger.debug(Translate.get(
02730 "virtualdatabase.xml.connectionmanager.failfast.add", new String[]{
02731 currentBackend.getName(), connectionManagerVLogin,
02732 String.valueOf(poolSize),
02733 currentDatabaseBackendUser.getLogin(),
02734 currentDatabaseBackendUser.getPassword()}));
02735
02736 currentBackend.addConnectionManager(connectionManagerVLogin,
02737 new FailFastPoolConnectionManager(currentBackend.getURL(),
02738 currentBackend.getName(), currentDatabaseBackendUser.getLogin(),
02739 currentDatabaseBackendUser.getPassword(), currentBackend
02740 .getDriverPath(), currentBackend.getDriverClassName(),
02741 poolSize));
02742 }
02743 catch (Exception e)
02744 {
02745 String msg = Translate.get(
02746 "virtualdatabase.xml.connectionmanager.failfast.failed",
02747 currentBackend.getName());
02748 logger.error(msg, e);
02749 throw new SAXException(msg, e);
02750 }
02751 }
|
|
|
Sets the currentRecoveryLog as new
DatabasesParser.java の 2639 行で定義されています。
02640 {
02641 String msg = "FileRecoveryLog is not yet implemented";
02642 logger.error(msg);
02643 throw new SAXException(msg);
02644 }
|
|
|
Sets the backend log table create statement for the current
DatabasesParser.java の 2597 行で定義されています。
02598 {
02599 try
02600 {
02601 String tableName = atts.getValue(DatabasesXmlTags.ATT_tableName);
02602 String checkpointNameType = atts
02603 .getValue(DatabasesXmlTags.ATT_checkpointNameColumnType);
02604 String databaseNameType = atts
02605 .getValue(DatabasesXmlTags.ATT_databaseNameColumnType);
02606 String backendNameType = atts
02607 .getValue(DatabasesXmlTags.ATT_backendNameColumnType);
02608 String extraStatement = atts
02609 .getValue(DatabasesXmlTags.ATT_extraStatementDefinition);
02610
02611 if (currentRecoveryLog == null)
02612 {
02613 String msg = Translate
02614 .get("virtualdatabase.xml.recoverylog.jdbc.backendtable.setnull");
02615 logger.error(msg);
02616 throw new SAXException(msg);
02617 }
02618 else
02619 currentRecoveryLog.setBackendTableCreateStatement(tableName,
02620 checkpointNameType, backendNameType, databaseNameType,
02621 extraStatement);
02622 }
02623 catch (Exception e)
02624 {
02625 String msg = Translate
02626 .get("virtualdatabase.xml.recoverylog.jdbc.backendtable.failed");
02627 logger.error(msg, e);
02628 throw new SAXException(msg, e);
02629 }
02630 }
|
|
|
Sets the recovery log table create statement for the current
DatabasesParser.java の 2556 行で定義されています。
02558 {
02559 try
02560 {
02561 String tableName = atts.getValue(DatabasesXmlTags.ATT_tableName);
02562 String nameType = atts
02563 .getValue(DatabasesXmlTags.ATT_checkpointNameColumnType);
02564 String requestIdType = atts
02565 .getValue(DatabasesXmlTags.ATT_requestIdColumnType);
02566 String extraStatement = atts
02567 .getValue(DatabasesXmlTags.ATT_extraStatementDefinition);
02568
02569 if (currentRecoveryLog == null)
02570 {
02571 String msg = Translate
02572 .get("virtualdatabase.xml.recoverylog.jdbc.checkpointtable.setnull");
02573 logger.error(msg);
02574 throw new SAXException(msg);
02575 }
02576 else
02577 currentRecoveryLog.setCheckpointTableCreateStatement(tableName,
02578 nameType, requestIdType, extraStatement);
02579 }
02580 catch (Exception e)
02581 {
02582 String msg = Translate
02583 .get("virtualdatabase.xml.recoverylog.jdbc.checkpointtable.failed");
02584 logger.error(msg, e);
02585 throw new SAXException(msg, e);
02586 }
02587 }
|
|
|
Sets the currentRecoveryLog as new
DatabasesParser.java の 2476 行で定義されています。
02477 {
02478 try
02479 {
02480 String driverClassName = atts.getValue(DatabasesXmlTags.ATT_driver);
02481 String driverPath = atts.getValue(DatabasesXmlTags.ATT_driverPath);
02482 String url = atts.getValue(DatabasesXmlTags.ATT_url);
02483 String login = atts.getValue(DatabasesXmlTags.ATT_login);
02484 String password = atts.getValue(DatabasesXmlTags.ATT_password);
02485 String timeout = atts.getValue(DatabasesXmlTags.ATT_requestTimeout);
02486 // Convert to ms
02487 requestTimeout = Integer.parseInt(timeout) * 1000;
02488
02489 if (logger.isDebugEnabled())
02490 logger.debug(Translate.get(
02491 "virtualdatabase.xml.recoverylog.jdbc.create", new String[]{
02492 driverClassName, url, login, password,
02493 String.valueOf(requestTimeout)}));
02494
02495 currentRecoveryLog = new JDBCRecoveryLog(driverPath,
02496 driverClassName, url, login, password, requestTimeout);
02497 //currentRecoveryLog.setBackendTableCreateStatement();
02498 }
02499 catch (Exception e)
02500 {
02501 String msg = Translate.get("virtualdatabase.xml.recoverylog.jdbc.failed");
02502 logger.error(msg, e);
02503 throw new SAXException(msg, e);
02504 }
02505 }
|
|
|
Sets the recovery log table create statement for the current
DatabasesParser.java の 2515 行で定義されています。
02516 {
02517 try
02518 {
02519 String tableName = atts.getValue(DatabasesXmlTags.ATT_tableName);
02520 String idType = atts.getValue(DatabasesXmlTags.ATT_idColumnType);
02521 String vloginType = atts.getValue(DatabasesXmlTags.ATT_vloginColumnType);
02522 String sqlType = atts.getValue(DatabasesXmlTags.ATT_sqlColumnType);
02523 String transactionIdType = atts
02524 .getValue(DatabasesXmlTags.ATT_transactionIdColumnType);
02525 String extraStatement = atts
02526 .getValue(DatabasesXmlTags.ATT_extraStatementDefinition);
02527
02528 if (currentRecoveryLog == null)
02529 {
02530 String msg = Translate
02531 .get("virtualdatabase.xml.recoverylog.jdbc.recoverytable.setnull");
02532 logger.error(msg);
02533 throw new SAXException(msg);
02534 }
02535 else
02536 currentRecoveryLog.setLogTableCreateStatement(tableName, idType,
02537 vloginType, sqlType, transactionIdType, extraStatement);
02538 }
02539 catch (Exception e)
02540 {
02541 String msg = Translate
02542 .get("virtualdatabase.xml.recoverylog.jdbc.recoverytable.failed");
02543 logger.error(msg, e);
02544 throw new SAXException(msg, e);
02545 }
02546 }
|
|
|
Sets currentMetadataCacheas a new
DatabasesParser.java の 1530 行で定義されています。
01531 {
01532 try
01533 {
01534 int maxMetadata = Integer.parseInt(atts
01535 .getValue(DatabasesXmlTags.ATT_maxNbOfMetadata));
01536 int maxField = Integer.parseInt(atts
01537 .getValue(DatabasesXmlTags.ATT_maxNbOfField));
01538 currentMetadataCache = new MetadataCache(maxMetadata, maxField);
01539 }
01540 catch (Exception e)
01541 {
01542 String msg = Translate.get(
01543 "virtualdatabase.xml.metadata.cache.create.failed", e);
01544 logger.error(msg, e);
01545 throw new SAXException(msg, e);
01546 }
01547 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 1785 行で定義されています。
01787 {
01788 if (logger.isDebugEnabled())
01789 logger.debug(Translate
01790 .get("virtualdatabase.xml.loadbalancer.paralleldb_rr.set"));
01791
01792 try
01793 {
01794 currentLoadBalancer = new ParallelDB_RR(currentVirtualDatabase);
01795 }
01796 catch (SQLException e)
01797 {
01798 String msg = Translate
01799 .get("virtualdatabase.xml.loadbalancer.paralleldb_rr.failed");
01800 logger.error(msg, e);
01801 throw new SAXException(msg, e);
01802 }
01803 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 1812 行で定義されています。
01814 {
01815 if (logger.isDebugEnabled())
01816 logger.debug(Translate
01817 .get("virtualdatabase.xml.loadbalancer.paralleldb_lprf.set"));
01818
01819 try
01820 {
01821 currentLoadBalancer = new ParallelDB_LPRF(currentVirtualDatabase);
01822 }
01823 catch (SQLException e)
01824 {
01825 String msg = Translate
01826 .get("virtualdatabase.xml.loadbalancer.paralleldb_lprf.failed");
01827 logger.error(msg, e);
01828 throw new SAXException(msg, e);
01829 }
01830 }
|
|
|
Sets currentParsingCacheas a new
DatabasesParser.java の 1556 行で定義されています。
01557 {
01558 String backgroundParsingString = atts
01559 .getValue(DatabasesXmlTags.ATT_backgroundParsing);
01560 boolean backgroundParsing;
01561
01562 if (backgroundParsingString != null)
01563 backgroundParsing = backgroundParsingString
01564 .equals(DatabasesXmlTags.VAL_true);
01565 else
01566 backgroundParsing = false;
01567
01568 String maxEntriesString = atts
01569 .getValue(DatabasesXmlTags.ATT_maxNbOfEntries);
01570 int maxEntries = Integer.parseInt(maxEntriesString);
01571
01572 try
01573 {
01574 currentParsingCache = new ParsingCache(maxEntries, backgroundParsing);
01575 }
01576 catch (Exception e)
01577 {
01578 String msg = Translate.get(
01579 "virtualdatabase.xml.parsing.cache.create.failed", e);
01580 logger.error(msg, e);
01581 throw new SAXException(msg, e);
01582 }
01583 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 1843 行で定義されています。
01844 {
01845 currentCreateTablePolicy = new CreateTablePolicy();
01846 currentCreateTableRule = null;
01847 }
|
|
|
Sets currentRequestScheduleras a new
DatabasesParser.java の 1409 行で定義されています。
01410 {
01411 String level = atts.getValue(DatabasesXmlTags.ATT_level);
01412
01413 if (level.equals(DatabasesXmlTags.VAL_query))
01414 {
01415 if (logger.isDebugEnabled())
01416 logger.debug(Translate
01417 .get("virtualdatabase.xml.scheduler.raidb0.create.query"));
01418 currentRequestScheduler = new RAIDb0QueryLevelScheduler();
01419 }
01420 else if (level.equals(DatabasesXmlTags.VAL_pessimisticTransaction))
01421 {
01422 if (logger.isDebugEnabled())
01423 logger.debug(Translate
01424 .get("virtualdatabase.xml.scheduler.raidb0.create.pessimistic"));
01425 currentRequestScheduler = new RAIDb0PessimisticTransactionLevelScheduler();
01426 }
01427 else
01428 throw new SAXException(Translate.get(
01429 "virtualdatabase.xml.scheduler.raidb0.unsupported", level));
01430 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 1996 行で定義されています。
01997 {
01998 String nbOfConcurrentReads = atts
01999 .getValue(DatabasesXmlTags.ATT_nbOfConcurrentReads);
02000 currentNbOfConcurrentReads = Integer.parseInt(nbOfConcurrentReads);
02001 currentErrorCheckingPolicy = null;
02002 currentWaitForCompletionPolicy = null;
02003 try
02004 {
02005 currentTimestampResolution = Long.parseLong(atts
02006 .getValue(DatabasesXmlTags.ATT_timestampResolution));
02007 }
02008 catch (Exception e)
02009 {
02010 String msg = Translate
02011 .get("virtualdatabase.invalid.timestamp.resolution");
02012 logger.error(msg);
02013 throw new SAXException(msg);
02014 }
02015
02016 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 2025 行で定義されています。
02027 {
02028 if (currentWaitForCompletionPolicy == null)
02029 currentWaitForCompletionPolicy = new WaitForCompletionPolicy();
02030
02031 if (logger.isDebugEnabled())
02032 {
02033 logger.debug(Translate
02034 .get("virtualdatabase.xml.loadbalancer.raidb1ec_rr.set"));
02035 logger.debug(Translate.get(
02036 "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02037 currentWaitForCompletionPolicy.getInformation()));
02038 }
02039
02040 try
02041 {
02042 currentLoadBalancer = new RAIDb1ec_RR(currentVirtualDatabase,
02043 currentWaitForCompletionPolicy, currentErrorCheckingPolicy,
02044 currentNbOfConcurrentReads, currentTimestampResolution);
02045 if (logger.isDebugEnabled())
02046 logger.debug(Translate.get(
02047 "virtualdatabase.xml.loadbalancer.errorchecking.policy",
02048 currentErrorCheckingPolicy.getInformation()));
02049 }
02050 catch (SQLException e)
02051 {
02052 String msg = Translate
02053 .get("virtualdatabase.xml.loadbalancer.raidb1ec_rr.failed");
02054 logger.error(msg, e);
02055 throw new SAXException(msg, e);
02056 }
02057 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 2066 行で定義されています。
02068 {
02069 if (currentWaitForCompletionPolicy == null)
02070 currentWaitForCompletionPolicy = new WaitForCompletionPolicy();
02071
02072 if (logger.isDebugEnabled())
02073 {
02074 logger.debug(Translate
02075 .get("virtualdatabase.xml.loadbalancer.raidb1ec_wrr.set"));
02076 logger.debug(Translate.get(
02077 "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02078 currentWaitForCompletionPolicy.getInformation()));
02079 }
02080
02081 try
02082 {
02083 currentLoadBalancer = new RAIDb1ec_WRR(currentVirtualDatabase,
02084 currentWaitForCompletionPolicy, currentErrorCheckingPolicy,
02085 currentNbOfConcurrentReads, currentTimestampResolution);
02086 if (logger.isDebugEnabled())
02087 logger.debug(Translate.get(
02088 "virtualdatabase.xml.loadbalancer.errorchecking.policy",
02089 currentErrorCheckingPolicy.getInformation()));
02090 }
02091 catch (SQLException e)
02092 {
02093 String msg = Translate
02094 .get("virtualdatabase.xml.loadbalancer.raidb1ec_wrr.failed");
02095 logger.error(msg, e);
02096 throw new SAXException(msg, e);
02097 }
02098 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 1956 行で定義されています。
01958 {
01959 if (currentWaitForCompletionPolicy == null)
01960 currentWaitForCompletionPolicy = new WaitForCompletionPolicy();
01961
01962 if (logger.isDebugEnabled())
01963 {
01964 logger.debug(Translate
01965 .get("virtualdatabase.xml.loadbalancer.raidb1_lprf.set"));
01966 logger.debug(Translate.get(
01967 "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
01968 currentWaitForCompletionPolicy.getInformation()));
01969 }
01970
01971 try
01972 {
01973 currentLoadBalancer = new RAIDb1_LPRF(currentVirtualDatabase,
01974 currentWaitForCompletionPolicy, currentTimestampResolution);
01975 }
01976 catch (SQLException e)
01977 {
01978 String msg = Translate
01979 .get("virtualdatabase.xml.loadbalancer.raidb1_lprf.failed");
01980 logger.error(msg, e);
01981 throw new SAXException(msg, e);
01982 }
01983 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 1860 行で定義されています。
01861 {
01862 currentWaitForCompletionPolicy = null;
01863 try
01864 {
01865 currentTimestampResolution = Long.parseLong(atts
01866 .getValue(DatabasesXmlTags.ATT_timestampResolution));
01867 }
01868 catch (Exception e)
01869 {
01870 String msg = Translate
01871 .get("virtualdatabase.invalid.timestamp.resolution");
01872 logger.error(msg);
01873 throw new SAXException(msg);
01874 }
01875 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 1884 行で定義されています。
01886 {
01887 if (currentWaitForCompletionPolicy == null)
01888 currentWaitForCompletionPolicy = new WaitForCompletionPolicy();
01889
01890 if (logger.isDebugEnabled())
01891 {
01892 logger.debug(Translate
01893 .get("virtualdatabase.xml.loadbalancer.raidb1_rr.set"));
01894 logger.debug(Translate.get(
01895 "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
01896 currentWaitForCompletionPolicy.getInformation()));
01897 }
01898
01899 try
01900 {
01901 currentLoadBalancer = new RAIDb1_RR(currentVirtualDatabase,
01902 currentWaitForCompletionPolicy, currentTimestampResolution);
01903 }
01904 catch (SQLException e)
01905 {
01906 String msg = Translate
01907 .get("virtualdatabase.xml.loadbalancer.raidb1_rr.failed");
01908 logger.error(msg, e);
01909 throw new SAXException(msg, e);
01910 }
01911 }
|
|
|
Sets currentRequestScheduleras a new
DatabasesParser.java の 1440 行で定義されています。
01441 {
01442 String level = atts.getValue(DatabasesXmlTags.ATT_level);
01443
01444 // RAIDb-1 Query level
01445 if (level.equals(DatabasesXmlTags.VAL_query))
01446 {
01447 if (logger.isDebugEnabled())
01448 logger.debug(Translate
01449 .get("virtualdatabase.xml.scheduler.raidb1.create.query"));
01450 currentRequestScheduler = new RAIDb1QueryLevelScheduler();
01451 }
01452 // RAIDb-1 Optimistic Query level
01453 else if (level.equals(DatabasesXmlTags.VAL_optimisticQuery))
01454 {
01455 if (logger.isDebugEnabled())
01456 logger
01457 .debug(Translate
01458 .get("virtualdatabase.xml.scheduler.raidb1.create.query.optimistic"));
01459 currentRequestScheduler = new RAIDb1OptimisticQueryLevelScheduler();
01460 }
01461 // RAIDb-1 Optimistic Transaction level
01462 else if (level.equals(DatabasesXmlTags.VAL_optimisticTransaction))
01463 {
01464 if (logger.isDebugEnabled())
01465 logger.debug(Translate
01466 .get("virtualdatabase.xml.scheduler.raidb1.create.optimistic"));
01467 currentRequestScheduler = new RAIDb1OptimisticTransactionLevelScheduler();
01468 }
01469 // RAIDb-1 Pessimistic Transaction level
01470 else if (level.equals(DatabasesXmlTags.VAL_pessimisticTransaction))
01471 {
01472 if (logger.isDebugEnabled())
01473 logger.debug(Translate
01474 .get("virtualdatabase.xml.scheduler.raidb1.create.pessimistic"));
01475 currentRequestScheduler = new RAIDb1PessimisticTransactionLevelScheduler();
01476 }
01477 else
01478 {
01479 throw new SAXException(Translate.get(
01480 "virtualdatabase.xml.scheduler.raidb1.unsupported", level));
01481 }
01482 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 1920 行で定義されています。
01922 {
01923 if (currentWaitForCompletionPolicy == null)
01924 currentWaitForCompletionPolicy = new WaitForCompletionPolicy();
01925
01926 if (logger.isDebugEnabled())
01927 {
01928 logger.debug(Translate
01929 .get("virtualdatabase.xml.loadbalancer.raidb1_wrr.set"));
01930 logger.debug(Translate.get(
01931 "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
01932 currentWaitForCompletionPolicy.getInformation()));
01933 }
01934
01935 try
01936 {
01937 currentLoadBalancer = new RAIDb1_WRR(currentVirtualDatabase,
01938 currentWaitForCompletionPolicy, currentTimestampResolution);
01939 }
01940 catch (SQLException e)
01941 {
01942 String msg = Translate
01943 .get("virtualdatabase.xml.loadbalancer.raidb1_wrr.failed");
01944 logger.error(msg, e);
01945 throw new SAXException(msg, e);
01946 }
01947 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 2254 行で定義されています。
02255 {
02256 currentErrorCheckingPolicy = null;
02257 currentWaitForCompletionPolicy = null;
02258 currentCreateTablePolicy = new CreateTablePolicy();
02259 currentCreateTableRule = null;
02260 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 2269 行で定義されています。
02271 {
02272 if (currentWaitForCompletionPolicy == null)
02273 currentWaitForCompletionPolicy = new WaitForCompletionPolicy();
02274
02275 if (logger.isDebugEnabled())
02276 {
02277 logger.debug(Translate
02278 .get("virtualdatabase.xml.loadbalancer.raidb2_rr.set"));
02279 logger.debug(Translate.get(
02280 "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02281 currentWaitForCompletionPolicy.getInformation()));
02282 }
02283
02284 try
02285 {
02286 currentLoadBalancer = new RAIDb2ec_RR(currentVirtualDatabase,
02287 currentWaitForCompletionPolicy, currentCreateTablePolicy,
02288 currentErrorCheckingPolicy, currentNbOfConcurrentReads,
02289 currentTimestampResolution);
02290 if (logger.isDebugEnabled())
02291 logger.debug(Translate.get(
02292 "virtualdatabase.xml.loadbalancer.errorchecking.policy",
02293 currentErrorCheckingPolicy.getInformation()));
02294 }
02295 catch (SQLException e)
02296 {
02297 String msg = Translate
02298 .get("virtualdatabase.xml.loadbalancer.raidb2ec_rr.failed");
02299 logger.error(msg, e);
02300 throw new SAXException(msg, e);
02301 }
02302 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 2311 行で定義されています。
02313 {
02314 if (currentWaitForCompletionPolicy == null)
02315 currentWaitForCompletionPolicy = new WaitForCompletionPolicy();
02316
02317 if (logger.isDebugEnabled())
02318 {
02319 logger.debug(Translate
02320 .get("virtualdatabase.xml.loadbalancer.raidb2_wrr.set"));
02321 logger.debug(Translate.get(
02322 "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02323 currentWaitForCompletionPolicy.getInformation()));
02324 }
02325
02326 try
02327 {
02328 currentLoadBalancer = new RAIDb2ec_WRR(currentVirtualDatabase,
02329 currentWaitForCompletionPolicy, currentCreateTablePolicy,
02330 currentErrorCheckingPolicy, currentNbOfConcurrentReads,
02331 currentTimestampResolution);
02332 if (logger.isDebugEnabled())
02333 logger.debug(Translate.get(
02334 "virtualdatabase.xml.loadbalancer.errorchecking.policy",
02335 currentErrorCheckingPolicy.getInformation()));
02336 }
02337 catch (SQLException e)
02338 {
02339 String msg = Translate
02340 .get("virtualdatabase.xml.loadbalancer.raidb2ec_wrr.failed");
02341 logger.error(msg, e);
02342 throw new SAXException(msg, e);
02343 }
02344 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 2214 行で定義されています。
02216 {
02217 if (currentWaitForCompletionPolicy == null)
02218 currentWaitForCompletionPolicy = new WaitForCompletionPolicy();
02219 Translate.get("jgfqsdfkjhsdlfhj");
02220 if (logger.isDebugEnabled())
02221 {
02222 logger.debug(Translate
02223 .get("virtualdatabase.xml.loadbalancer.raidb2_lprf.set"));
02224 logger.debug(Translate.get(
02225 "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02226 currentWaitForCompletionPolicy.getInformation()));
02227 }
02228
02229 try
02230 {
02231 currentLoadBalancer = new RAIDb2_LPRF(currentVirtualDatabase,
02232 currentWaitForCompletionPolicy, currentCreateTablePolicy,
02233 currentTimestampResolution);
02234 }
02235 catch (SQLException e)
02236 {
02237 String msg = Translate
02238 .get("virtualdatabase.xml.loadbalancer.raidb2_lprf.failed");
02239 logger.error(msg, e);
02240 throw new SAXException(msg, e);
02241 }
02242 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 2111 行で定義されています。
02112 {
02113 currentWaitForCompletionPolicy = null;
02114 currentCreateTablePolicy = new CreateTablePolicy();
02115 // Add a default rule to create table on all nodes
02116 currentCreateTablePolicy.addRule(new CreateTableAll());
02117 currentCreateTableRule = null;
02118 try
02119 {
02120 currentTimestampResolution = Long.parseLong(atts
02121 .getValue(DatabasesXmlTags.ATT_timestampResolution));
02122 }
02123 catch (Exception e)
02124 {
02125 String msg = Translate
02126 .get("virtualdatabase.invalid.timestamp.resolution");
02127 logger.error(msg);
02128 throw new SAXException(msg);
02129 }
02130
02131 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 2140 行で定義されています。
02142 {
02143 if (currentWaitForCompletionPolicy == null)
02144 currentWaitForCompletionPolicy = new WaitForCompletionPolicy();
02145
02146 if (logger.isDebugEnabled())
02147 {
02148 logger.debug(Translate
02149 .get("virtualdatabase.xml.loadbalancer.raidb2_rr.set"));
02150 logger.debug(Translate.get(
02151 "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02152 currentWaitForCompletionPolicy.getInformation()));
02153 }
02154
02155 try
02156 {
02157 currentLoadBalancer = new RAIDb2_RR(currentVirtualDatabase,
02158 currentWaitForCompletionPolicy, currentCreateTablePolicy,
02159 currentTimestampResolution);
02160 }
02161 catch (SQLException e)
02162 {
02163 String msg = Translate
02164 .get("virtualdatabase.xml.loadbalancer.raidb2_rr.failed");
02165 logger.error(msg, e);
02166 throw new SAXException(msg, e);
02167 }
02168 }
|
|
|
Sets currentRequestScheduleras a new
DatabasesParser.java の 1492 行で定義されています。
01493 {
01494 String level = atts.getValue(DatabasesXmlTags.ATT_level);
01495
01496 // RAIDb-2 Query level
01497 if (level.equals(DatabasesXmlTags.VAL_query))
01498 {
01499 if (logger.isDebugEnabled())
01500 logger.debug(Translate
01501 .get("virtualdatabase.xml.scheduler.raidb2.create.query"));
01502 currentRequestScheduler = new RAIDb2QueryLevelScheduler();
01503 }
01504 // RAIDb-2 Pessimistic Transaction level
01505 else if (level.equals(DatabasesXmlTags.VAL_pessimisticTransaction))
01506 {
01507 if (logger.isDebugEnabled())
01508 logger.debug(Translate
01509 .get("virtualdatabase.xml.scheduler.raidb2.create.pessimistic"));
01510 currentRequestScheduler = new RAIDb2PessimisticTransactionLevelScheduler();
01511 }
01512 else
01513 {
01514 throw new SAXException(Translate.get(
01515 "virtualdatabase.xml.scheduler.raidb2.unsupported", level));
01516 }
01517 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 2177 行で定義されています。
02179 {
02180 if (currentWaitForCompletionPolicy == null)
02181 currentWaitForCompletionPolicy = new WaitForCompletionPolicy();
02182
02183 if (logger.isDebugEnabled())
02184 {
02185 logger.debug(Translate
02186 .get("virtualdatabase.xml.loadbalancer.raidb2_wrr.set"));
02187 logger.debug(Translate.get(
02188 "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
02189 currentWaitForCompletionPolicy.getInformation()));
02190 }
02191
02192 try
02193 {
02194 currentLoadBalancer = new RAIDb2_WRR(currentVirtualDatabase,
02195 currentWaitForCompletionPolicy, currentCreateTablePolicy,
02196 currentTimestampResolution);
02197 }
02198 catch (SQLException e)
02199 {
02200 String msg = Translate
02201 .get("virtualdatabase.xml.loadbalancer.raidb2_wrr.failed");
02202 logger.error(msg, e);
02203 throw new SAXException(msg, e);
02204 }
02205 }
|
|
|
Adds a new
DatabasesParser.java の 2760 行で定義されています。
02762 {
02763 try
02764 {
02765 int poolSize = Integer.parseInt(atts
02766 .getValue(DatabasesXmlTags.ATT_poolSize));
02767 String timeoutString = atts.getValue(DatabasesXmlTags.ATT_timeout);
02768 int timeout = 0;
02769
02770 if (timeoutString != null) // Timeout is IMPLIED and
02771 // may be null
02772 timeout = Integer.parseInt(timeoutString);
02773
02774 // sanity check
02775 if (timeout < 0 || poolSize < 1)
02776 throw new IllegalArgumentException(
02777 Translate
02778 .get("virtualdatabase.xml.connectionmanager.randomwait.failed.parameter"));
02779
02780 if (logger.isDebugEnabled())
02781 logger.debug(Translate.get(
02782 "virtualdatabase.xml.connectionmanager.randomwait.add",
02783 new String[]{currentBackend.getName(), connectionManagerVLogin,
02784 String.valueOf(poolSize), String.valueOf(timeout),
02785 currentDatabaseBackendUser.getLogin(),
02786 currentDatabaseBackendUser.getPassword()}));
02787
02788 currentBackend.addConnectionManager(connectionManagerVLogin,
02789 new RandomWaitPoolConnectionManager(currentBackend.getURL(),
02790 currentBackend.getName(), currentDatabaseBackendUser.getLogin(),
02791 currentDatabaseBackendUser.getPassword(), currentBackend
02792 .getDriverPath(), currentBackend.getDriverClassName(),
02793 poolSize, timeout));
02794 }
02795 catch (Exception e)
02796 {
02797 String msg = Translate.get(
02798 "virtualdatabase.xml.connectionmanager.randomwait.failed",
02799 currentBackend.getName());
02800 logger.error(msg, e);
02801 throw new SAXException(msg, e);
02802 }
02803 }
|
|
|
Associates a new real database backend user to the virtual database user currentVirtualUserin the currentAuthenticationManager using the parsed attributes.
DatabasesParser.java の 1291 行で定義されています。
01292 {
01293 String backendName = atts.getValue(DatabasesXmlTags.ATT_backendName);
01294 String rLogin = atts.getValue(DatabasesXmlTags.ATT_rLogin);
01295 String rPassword = atts.getValue(DatabasesXmlTags.ATT_rPassword);
01296 DatabaseBackendUser user = new DatabaseBackendUser(backendName, rLogin,
01297 rPassword);
01298
01299 if (logger.isDebugEnabled())
01300 logger.debug(Translate.get(
01301 "virtualdatabase.xml.authentication.login.real.add", new String[]{
01302 rLogin, rPassword, backendName}));
01303
01304 try
01305 {
01306 currentAuthenticationManager.addRealUser(currentVirtualUser.getLogin(),
01307 user);
01308 }
01309 catch (AuthenticationManagerException e)
01310 {
01311 String msg = Translate
01312 .get("virtualdatabase.xml.authentication.login.real.add.failed");
01313 logger.error(msg, e);
01314 throw new SAXException(msg, e);
01315 }
01316 }
|
|
|
Add a new
DatabasesParser.java の 1735 行で定義されています。
01736 {
01737 Hashtable options = new Hashtable();
01738 for (int i = 0; i < atts.getLength(); i++)
01739 options.put(atts.getQName(i), atts.getValue(i));
01740 currentResultCacheRule
01741 .setCacheBehavior(ResultCacheFactory.getCacheBehaviorInstance(
01742 DatabasesXmlTags.ELT_RelaxedCaching, options));
01743 }
|
|
|
Sets the beginTimeout,commitTimeoutand rollbackTimeouttimeouts (in ms) using the parsed attributes.
DatabasesParser.java の 1327 行で定義されています。
01328 {
01329 try
01330 {
01331 String begin = atts.getValue(DatabasesXmlTags.ATT_beginTimeout);
01332 String commit = atts.getValue(DatabasesXmlTags.ATT_commitTimeout);
01333 String rollback = atts.getValue(DatabasesXmlTags.ATT_rollbackTimeout);
01334 String caseSensitiveParsingString = atts
01335 .getValue(DatabasesXmlTags.ATT_caseSensitiveParsing);
01336
01337 // Convert to ms
01338 beginTimeout = Long.parseLong(begin) * 1000L;
01339 commitTimeout = Long.parseLong(commit) * 1000L;
01340 rollbackTimeout = Long.parseLong(rollback) * 1000L;
01341
01342 if (caseSensitiveParsingString != null)
01343 caseSensitiveParsing = caseSensitiveParsingString
01344 .equals(DatabasesXmlTags.VAL_true);
01345 else
01346 caseSensitiveParsing = false;
01347
01348 if (logger.isDebugEnabled())
01349 logger.debug(Translate.get(
01350 "virtualdatabase.xml.requestmanager.parameters", new String[]{
01351 String.valueOf(beginTimeout), String.valueOf(commitTimeout),
01352 String.valueOf(rollbackTimeout)}));
01353 }
01354 catch (NumberFormatException e)
01355 {
01356 String msg = Translate
01357 .get("virtualdatabase.xml.requestmanager.timeout.failed");
01358 logger.error(msg, e);
01359 throw new SAXException(msg, e);
01360 }
01361 }
|
|
|
Sets currentResultCacheas a new
DatabasesParser.java の 1592 行で定義されています。
01593 {
01594 String granularity = atts.getValue(DatabasesXmlTags.ATT_granularity);
01595 String maxEntriesString = atts
01596 .getValue(DatabasesXmlTags.ATT_maxNbOfEntries);
01597 String pendingTimeoutString = atts
01598 .getValue(DatabasesXmlTags.ATT_pendingTimeout);
01599
01600 if (logger.isDebugEnabled())
01601 logger.debug(Translate.get("virtualdatabase.xml.cache.create",
01602 granularity));
01603
01604 try
01605 {
01606 int maxEntries = Integer.parseInt(maxEntriesString);
01607 int pendingTimeout = Integer.parseInt(pendingTimeoutString);
01608
01609 int granularityValue;
01610 if (granularity.equals(DatabasesXmlTags.VAL_table))
01611 granularityValue = CachingGranularities.TABLE;
01612 else if (granularity.equals(DatabasesXmlTags.VAL_database))
01613 granularityValue = CachingGranularities.DATABASE;
01614 else if (granularity.equals(DatabasesXmlTags.VAL_column))
01615 granularityValue = CachingGranularities.COLUMN;
01616 else if (granularity.equals(DatabasesXmlTags.VAL_columnUnique))
01617 granularityValue = CachingGranularities.COLUMN_UNIQUE;
01618 else
01619 throw new InstantiationException(Translate.get(
01620 "virtualdatabase.xml.cache.unsupported", granularity));
01621
01622 currentResultCache = ResultCacheFactory.getCacheInstance(
01623 granularityValue, maxEntries, pendingTimeout);
01624
01625 }
01626 catch (Exception e)
01627 {
01628 String msg = Translate.get("virtualdatabase.xml.cache.create.failed",
01629 granularity);
01630 logger.error(msg, e);
01631 throw new SAXException(msg, e);
01632 }
01633 }
|
|
|
Add a new
DatabasesParser.java の 1641 行で定義されています。
01642 {
01643 String queryString = atts.getValue(DatabasesXmlTags.ATT_queryPattern);
01644
01645 String caseSensitiveString = atts
01646 .getValue(DatabasesXmlTags.ATT_caseSensitive);
01647 String applyToSkeletonString = atts
01648 .getValue(DatabasesXmlTags.ATT_applyToSkeleton);
01649 long timestampResolution;
01650 try
01651 {
01652 timestampResolution = Long.parseLong(atts
01653 .getValue(DatabasesXmlTags.ATT_timestampResolution));
01654 timestampResolution *= 1000;
01655 }
01656 catch (Exception e)
01657 {
01658 logger
01659 .warn(Translate.get("virtualdatabase.invalid.timestamp.resolution"));
01660 timestampResolution = 1000;
01661 }
01662
01663 boolean caseSensitive;
01664 if (caseSensitiveString != null)
01665 caseSensitive = caseSensitiveString.equals(DatabasesXmlTags.VAL_true);
01666 else
01667 caseSensitive = false;
01668 boolean applyToSkeleton;
01669 if (applyToSkeletonString != null)
01670 applyToSkeleton = applyToSkeletonString.equals(DatabasesXmlTags.VAL_true);
01671 else
01672 applyToSkeleton = false;
01673 boolean monitoring;
01674
01675 // Create the rule
01676 try
01677 {
01678 currentResultCacheRule = new ResultCacheRule(queryString, caseSensitive,
01679 applyToSkeleton, timestampResolution);
01680 }
01681 catch (RESyntaxException e1)
01682 {
01683 String msg = Translate.get("virtualdatabase.xml.cache.rule.invalid", e1);
01684 logger.error(msg);
01685 throw new SAXException(msg);
01686 }
01687
01688 if (logger.isDebugEnabled())
01689 logger.debug(Translate.get("virtualdatabase.xml.cache.rule.add",
01690 new String[]{atts.getValue(DatabasesXmlTags.ATT_queryPattern),
01691 String.valueOf(caseSensitive), applyToSkeletonString,
01692 String.valueOf(timestampResolution)}));
01693 currentResultCache.addCachingRule(currentResultCacheRule);
01694 }
|
|
|
Adds a
DatabasesParser.java の 1190 行で定義されています。
01191 {
01192 String queryPattern = atts.getValue(DatabasesXmlTags.ATT_queryPattern);
01193 String rewrite = atts.getValue(DatabasesXmlTags.ATT_rewrite);
01194 String matchingType = atts.getValue(DatabasesXmlTags.ATT_matchingType);
01195 String caseSensitiveString = atts
01196 .getValue(DatabasesXmlTags.ATT_caseSensitive);
01197 String stopOnMatchString = atts.getValue(DatabasesXmlTags.ATT_stopOnMatch);
01198
01199 boolean caseSensitive;
01200 if (caseSensitiveString != null)
01201 caseSensitive = caseSensitiveString.equals(DatabasesXmlTags.VAL_true);
01202 else
01203 caseSensitive = false;
01204 boolean stopOnMatch;
01205 if (stopOnMatchString != null)
01206 stopOnMatch = stopOnMatchString.equals(DatabasesXmlTags.VAL_true);
01207 else
01208 stopOnMatch = false;
01209
01210 // Create the rule and add it
01211 AbstractRewritingRule rule;
01212 if (matchingType.equals(DatabasesXmlTags.VAL_simple))
01213 rule = new SimpleRewritingRule(queryPattern, rewrite, caseSensitive,
01214 stopOnMatch);
01215 else if (matchingType.equals(DatabasesXmlTags.VAL_pattern))
01216 rule = new PatternRewritingRule(queryPattern, rewrite, caseSensitive,
01217 stopOnMatch);
01218 else
01219 throw new SAXException(Translate.get(
01220 "virtualdatabase.xml.rewritingrule.unsupported.matching",
01221 matchingType));
01222
01223 if (logger.isDebugEnabled())
01224 logger.debug(Translate.get("virtualdatabase.xml.rewritingrule.add",
01225 new String[]{queryPattern, rewrite, String.valueOf(caseSensitive),
01226 String.valueOf(stopOnMatch)}));
01227 currentBackend.addRewritingRule(rule);
01228 }
|
|
|
Adds a new
DatabasesParser.java の 2691 行で定義されています。
02692 {
02693 if (logger.isDebugEnabled())
02694 logger.debug(Translate.get(
02695 "virtualdatabase.xml.connectionmanager.simple.add", new String[]{
02696 currentBackend.getName(), connectionManagerVLogin,
02697 currentDatabaseBackendUser.getLogin(),
02698 currentDatabaseBackendUser.getPassword()}));
02699
02700 currentBackend.addConnectionManager(connectionManagerVLogin,
02701 new SimpleConnectionManager(currentBackend.getURL(), currentBackend
02702 .getName(), currentDatabaseBackendUser.getLogin(),
02703 currentDatabaseBackendUser.getPassword(), currentBackend
02704 .getDriverPath(), currentBackend.getDriverClassName()));
02705 }
|
|
|
Sets currentLoadBalanceras a new
DatabasesParser.java の 1754 行で定義されています。
01756 {
01757 if (logger.isDebugEnabled())
01758 logger.debug(Translate
01759 .get("virtualdatabase.xml.loadbalancer.singledb.set"));
01760
01761 try
01762 {
01763 currentLoadBalancer = new SingleDB(currentVirtualDatabase);
01764 }
01765 catch (SQLException e)
01766 {
01767 String msg = Translate
01768 .get("virtualdatabase.xml.loadbalancer.singledb.failed");
01769 logger.error(msg, e);
01770 throw new SAXException(msg, e);
01771 }
01772 }
|
|
|
Sets currentRequestScheduleras a new
DatabasesParser.java の 1373 行で定義されています。
01374 {
01375 String level = atts.getValue(DatabasesXmlTags.ATT_level);
01376
01377 // SingleDB Query Level
01378 if (level.equals(DatabasesXmlTags.VAL_query))
01379 {
01380 if (logger.isDebugEnabled())
01381 logger.debug(Translate
01382 .get("virtualdatabase.xml.scheduler.singledb.create.query"));
01383 currentRequestScheduler = new SingleDBQueryLevelScheduler();
01384 }
01385
01386 // SingleDB Pessimistic Transaction Level
01387 else if (level.equals(DatabasesXmlTags.VAL_pessimisticTransaction))
01388 {
01389 if (logger.isDebugEnabled())
01390 logger.debug(Translate
01391 .get("virtualdatabase.xml.scheduler.singledb.create.pessimistic"));
01392 currentRequestScheduler = new SingleDBPessimisticTransactionLevelScheduler();
01393 }
01394 else
01395 {
01396 throw new SAXException(Translate.get(
01397 "virtualdatabase.xml.scheduler.singledb.unsupported", level));
01398 }
01399 }
|
|
|
Sets a new
DatabasesParser.java の 1094 行で定義されています。 参照先 org.objectweb.cjdbc.controller.monitoring.SQLMonitoring.setDefaultRule().
01095 {
01096 String monitoringString = atts
01097 .getValue(DatabasesXmlTags.ATT_defaultMonitoring);
01098 boolean monitoring;
01099 if (monitoringString != null)
01100 monitoring = monitoringString.equals(DatabasesXmlTags.VAL_on);
01101 else
01102 monitoring = false;
01103
01104 SQLMonitoring sqlMonitor = new SQLMonitoring(currentVirtualDatabase
01105 .getName());
01106 sqlMonitor.setDefaultRule(monitoring);
01107 currentVirtualDatabase.setSQLMonitor(sqlMonitor);
01108 }
|
|
|
Add a new
DatabasesParser.java の 1115 行で定義されています。
01116 {
01117 String queryPattern = atts.getValue(DatabasesXmlTags.ATT_queryPattern);
01118 String caseSensitiveString = atts
01119 .getValue(DatabasesXmlTags.ATT_caseSensitive);
01120 String applyToSkeletonString = atts
01121 .getValue(DatabasesXmlTags.ATT_applyToSkeleton);
01122 String monitoringString = atts.getValue(DatabasesXmlTags.ATT_monitoring);
01123
01124 boolean caseSensitive;
01125 if (caseSensitiveString != null)
01126 caseSensitive = caseSensitiveString.equals(DatabasesXmlTags.VAL_true);
01127 else
01128 caseSensitive = false;
01129 boolean applyToSkeleton;
01130 if (applyToSkeletonString != null)
01131 applyToSkeleton = applyToSkeletonString.equals(DatabasesXmlTags.VAL_true);
01132 else
01133 applyToSkeleton = false;
01134 boolean monitoring;
01135 if (monitoringString != null)
01136 monitoring = monitoringString.equals(DatabasesXmlTags.VAL_on);
01137 else
01138 monitoring = false;
01139
01140 // Create the rule and add it
01141 SQLMonitoringRule rule = new SQLMonitoringRule(queryPattern, caseSensitive,
01142 applyToSkeleton, monitoring);
01143
01144 if (logger.isDebugEnabled())
01145 logger.debug(Translate.get("virtualdatabase.xml.sqlmonitoring.rule.add",
01146 new String[]{queryPattern, String.valueOf(caseSensitive),
01147 applyToSkeletonString, String.valueOf(monitoring)}));
01148 currentVirtualDatabase.getSQLMonitor().addRule(rule);
01149 }
|
|
|
Adds a new
DatabasesParser.java の 2812 行で定義されています。
02814 {
02815 try
02816 {
02817 int initPoolSize = Integer.parseInt(atts
02818 .getValue(DatabasesXmlTags.ATT_initPoolSize));
02819
02820 int minPoolSize = initPoolSize;
02821 // minPoolSize is IMPLIED and may be null
02822 String attr = atts.getValue(DatabasesXmlTags.ATT_minPoolSize);
02823 if (attr != null)
02824 minPoolSize = Integer.parseInt(attr);
02825
02826 // maxPoolSize is IMPLIED and may be null
02827 int maxPoolSize = VariablePoolConnectionManager.DEFAULT_MAX_POOL_SIZE;
02828 attr = atts.getValue(DatabasesXmlTags.ATT_maxPoolSize);
02829 if (attr != null)
02830 maxPoolSize = Integer.parseInt(attr);
02831
02832 String timeoutString = atts.getValue(DatabasesXmlTags.ATT_idleTimeout);
02833 int idleTimeout = VariablePoolConnectionManager.DEFAULT_IDLE_TIMEOUT;
02834 if (timeoutString != null) // idleTimeout is IMPLIED
02835 // and may be null
02836 idleTimeout = Integer.parseInt(timeoutString);
02837
02838 timeoutString = atts.getValue(DatabasesXmlTags.ATT_waitTimeout);
02839 int waitTimeout = VariablePoolConnectionManager.DEFAULT_WAIT_TIMEOUT;
02840 if (timeoutString != null) // waitTimeout is IMPLIED
02841 // and may be null
02842 waitTimeout = Integer.parseInt(timeoutString);
02843
02844 // sanity checks
02845 if (minPoolSize < 0 || maxPoolSize < 0
02846 || (maxPoolSize != 0 && minPoolSize > maxPoolSize)
02847 || (maxPoolSize != 0 && initPoolSize > maxPoolSize)
02848 || initPoolSize < minPoolSize)
02849 throw new IllegalArgumentException(
02850 Translate
02851 .get("virtualdatabase.xml.connectionmanager.variable.failed.parameter"));
02852
02853 if (logger.isDebugEnabled())
02854 logger.debug(Translate.get(
02855 "virtualdatabase.xml.connectionmanager.randomwait.add",
02856 new String[]{currentBackend.getName(), connectionManagerVLogin,
02857 String.valueOf(initPoolSize), String.valueOf(minPoolSize),
02858 String.valueOf(maxPoolSize), String.valueOf(idleTimeout),
02859 String.valueOf(waitTimeout),
02860 currentDatabaseBackendUser.getLogin(),
02861 currentDatabaseBackendUser.getPassword()}));
02862
02863 currentBackend
02864 .addConnectionManager(connectionManagerVLogin,
02865 new VariablePoolConnectionManager(currentBackend.getURL(),
02866 currentBackend.getName(), currentDatabaseBackendUser
02867 .getLogin(), currentDatabaseBackendUser.getPassword(),
02868 currentBackend.getDriverPath(), currentBackend
02869 .getDriverClassName(), initPoolSize, minPoolSize,
02870 maxPoolSize, idleTimeout, waitTimeout));
02871 }
02872 catch (Exception e)
02873 {
02874 String msg = Translate.get(
02875 "virtualdatabase.xml.connectionmanager.variable.failed",
02876 currentBackend.getName());
02877 logger.error(msg, e);
02878 throw new SAXException(msg, e);
02879 }
02880 }
|
|
|
Sets currentVirtualDatabaseas a new
DatabasesParser.java の 938 行で定義されています。
00939 {
00940 String name = atts.getValue(DatabasesXmlTags.ATT_name);
00941 String maxNbOfConnections = atts
00942 .getValue(DatabasesXmlTags.ATT_maxNbOfConnections);
00943 String poolThreads = atts.getValue(DatabasesXmlTags.ATT_poolThreads);
00944 String minNbOfThreads = atts.getValue(DatabasesXmlTags.ATT_minNbOfThreads);
00945 String maxNbOfThreads = atts.getValue(DatabasesXmlTags.ATT_maxNbOfThreads);
00946 String maxThreadIdleTime = atts
00947 .getValue(DatabasesXmlTags.ATT_maxThreadIdleTime);
00948 String sqlDumpLength = atts.getValue(DatabasesXmlTags.ATT_sqlDumpLength);
00949 String blobEncodingMethod = atts
00950 .getValue(DatabasesXmlTags.ATT_blobEncodingMethod);
00951
00952 if (controller.hasVirtualDatabase(name))
00953 {
00954 String msg = Translate.get(
00955 "virtualdatabase.xml.virtualdatabase.already.exists", name);
00956 logger.error(msg);
00957 throw new SAXException(msg);
00958 }
00959
00960 try
00961 {
00962 // Process the attributes
00963 int maxConnections = Integer.parseInt(maxNbOfConnections);
00964 boolean pool = poolThreads.equals(DatabasesXmlTags.VAL_true);
00965 int minThreads = Integer.parseInt(minNbOfThreads);
00966 int maxThreads = Integer.parseInt(maxNbOfThreads);
00967 // converts in ms
00968 long threadIdleTime = Long.parseLong(maxThreadIdleTime) * 1000L;
00969 int dumpLength = Integer.parseInt(sqlDumpLength);
00970 AbstractBlobFilter blobFilter = null;
00971 if (blobEncodingMethod.equals(DatabasesXmlTags.VAL_none))
00972 blobFilter = new NoneBlobFilter();
00973 else if (blobEncodingMethod.equals(DatabasesXmlTags.VAL_hexa))
00974 blobFilter = new HexaBlobFilter();
00975 else
00976 {
00977 String msg = Translate.get(
00978 "virtualdatabase.xml.virtualdatabase.blobfilter.unsupported",
00979 blobEncodingMethod);
00980 logger.error(msg);
00981 throw new SAXException(msg);
00982 }
00983 if (logger.isDebugEnabled())
00984 logger.debug(Translate.get(
00985 "virtualdatabase.xml.virtualdatabase.create", name));
00986 currentVirtualDatabase = new VirtualDatabase(controller.getName(), name,
00987 maxConnections, pool, minThreads, maxThreads, threadIdleTime,
00988 dumpLength, blobFilter);
00989
00990 }
00991 catch (Exception e)
00992 {
00993 String msg = Translate.get("virtualdatabase.xml.virtualdatabase.failed");
00994 logger.error(msg, e);
00995 throw new SAXException(msg, e);
00996 }
00997 }
|
|
|
Sets currentVirtualUseras a new
DatabasesParser.java の 1270 行で定義されています。
01271 {
01272 String vLogin = atts.getValue(DatabasesXmlTags.ATT_vLogin);
01273 String vPassword = atts.getValue(DatabasesXmlTags.ATT_vPassword);
01274 currentVirtualUser = new VirtualDatabaseUser(vLogin, vPassword);
01275
01276 if (logger.isDebugEnabled())
01277 logger.debug(Translate.get(
01278 "virtualdatabase.xml.authentication.login.virtual.add", new String[]{
01279 vLogin, vPassword}));
01280 currentAuthenticationManager.addVirtualUser(currentVirtualUser);
01281 }
|
|
|
Set the WaitForCompletion policy.
DatabasesParser.java の 2356 行で定義されています。
02357 {
02358 String policy = atts.getValue(DatabasesXmlTags.ATT_policy);
02359 currentWaitForCompletionPolicy = new WaitForCompletionPolicy();
02360
02361 if (policy.equals(DatabasesXmlTags.VAL_first))
02362 currentWaitForCompletionPolicy.setPolicy(WaitForCompletionPolicy.FIRST);
02363 else if (policy.equals(DatabasesXmlTags.VAL_majority))
02364 currentWaitForCompletionPolicy
02365 .setPolicy(WaitForCompletionPolicy.MAJORITY);
02366 else if (policy.equals(DatabasesXmlTags.VAL_all))
02367 currentWaitForCompletionPolicy.setPolicy(WaitForCompletionPolicy.ALL);
02368 else
02369 throw new SAXException(Translate.get(
02370 "virtualdatabase.xml.loadbalancer.waitforcompletion.unsupported",
02371 policy));
02372 }
|
|
||||||||||||||||
|
If this method is called. Only the specified DB of the Xml file will be loaded.
DatabasesParser.java の 356 行で定義されています。 参照元 org.objectweb.cjdbc.controller.xml.DatabasesParser.DatabasesParser().
00358 {
00359 dbToPrepare = new Hashtable(3);
00360 dbToPrepare.put("virtualName", virtualName);
00361 dbToPrepare.put("autoEnable", "" + autoEnable);
00362 dbToPrepare.put("checkPoint", checkPoint);
00363 }
|
|
|
DatabasesParser.java の 227 行で定義されています。 参照元 org.objectweb.cjdbc.controller.xml.DatabasesParser.DatabasesParser().
00228 {
00229 // Instantiate a new parser
00230 parser = XMLReaderFactory.createXMLReader();
00231
00232 this.controller = controller;
00233
00234 // Activate validation
00235 parser.setFeature("http://xml.org/sax/features/validation", true);
00236
00237 // Install error handler
00238 parser.setErrorHandler(this);
00239
00240 // Install document handler
00241 parser.setContentHandler(this);
00242
00243 // Install local entity resolver
00244 parser.setEntityResolver(this);
00245 }
|
|
||||||||||||
|
Validate an XML content according to C-JDBC DTD.
DatabasesParser.java の 269 行で定義されています。 参照先 org.objectweb.cjdbc.controller.xml.DatabasesParser.C_JDBC_DTD_FILE, org.objectweb.cjdbc.common.log.Trace.debug(), org.objectweb.cjdbc.common.log.Trace.error(), org.objectweb.cjdbc.common.xml.XmlValidator.getExceptions(), org.objectweb.cjdbc.common.log.Trace.isDebugEnabled(), org.objectweb.cjdbc.common.xml.XmlValidator.isDtdValid, org.objectweb.cjdbc.common.xml.XmlValidator.isValid(), と org.objectweb.cjdbc.common.xml.XmlValidator.isXmlValid.
00271 {
00272 if (validateBeforeParsing)
00273 {
00274 XmlValidator validator = new XmlValidator(C_JDBC_DTD_FILE, xml);
00275 if (logger.isDebugEnabled())
00276 {
00277 if (validator.isDtdValid())
00278 logger.debug(Translate.get("virtualdatabase.xml.dtd.validated"));
00279 if (validator.isXmlValid())
00280 logger.debug(Translate.get("virtualdatabase.xml.document.validated"));
00281 }
00282 if (!validator.isDtdValid())
00283 logger.error(Translate.get("virtualdatabase.xml.dtd.not.validated"));
00284 if (!validator.isXmlValid())
00285 logger.error(Translate
00286 .get("virtualdatabase.xml.document.not.validated"));
00287
00288 ArrayList errors = validator.getExceptions();
00289 for (int i = 0; i < errors.size(); i++)
00290 logger.error(((Exception) errors.get(i)).getMessage());
00291
00292 if (!validator.isValid())
00293 throw new SAXException(ExceptionTypes.XML_DOCUMENT_INVALID);
00294 }
00295 this.readXML(xml);
00296 }
|
|
|
Parses an XML content according to C-JDBC DTD.
DatabasesParser.java の 254 行で定義されています。 参照元 org.objectweb.cjdbc.controller.core.Controller.addVirtualDatabases().
00255 {
00256 InputSource input = new InputSource(new StringReader(xml));
00257 parser.parse(input);
00258 }
|
|
||||||||||||
|
Allows to parse the document with a local copy of the DTD whatever the original
DatabasesParser.java の 336 行で定義されています。
00338 {
00339 InputStream stream = DatabasesXmlTags.class.getResourceAsStream("/"
00340 + C_JDBC_DTD_FILE);
00341 if (stream == null)
00342 throw new SAXException("Cannot find C-JDBC DTD file '" + C_JDBC_DTD_FILE
00343 + "' in classpath");
00344
00345 return new InputSource(stream);
00346 }
|
|
|
Initializes parsing of a document.
DatabasesParser.java の 370 行で定義されています。
00371 {
00372 logger.info(Translate.get("virtualdatabase.xml.start"));
00373 }
|
|
||||||||||||||||||||
|
Analyzes an element first line.
DatabasesParser.java の 394 行で定義されています。
00396 {
00397 logger.debug(Translate.get("virtualdatabase.xml.parsing.start", name));
00398
00399 // Virtual database
00400 if (name.equals(DatabasesXmlTags.ELT_VirtualDatabase))
00401 {
00402 if (dbToPrepare == null)
00403 {
00404 // Prepare all databases
00405 newVirtualDatabase(atts);
00406 }
00407 else
00408 {
00409 // Only prepare one database
00410 String virtualName = atts.getValue(DatabasesXmlTags.ATT_name);
00411 if (virtualName.equalsIgnoreCase((String) dbToPrepare
00412 .get("virtualName")))
00413 {
00414 // This is the database that we want to prepare
00415 skipDatabase = false;
00416 newVirtualDatabase(atts);
00417 }
00418 else
00419 {
00420 // Skip to next one
00421 skipDatabase = true;
00422 }
00423 }
00424 }
00425 // Skip to next definition of a virtualDatabase ?
00426 if (skipDatabase)
00427 return;
00428
00429 // Distribution
00430 else if (name.equals(DatabasesXmlTags.ELT_Distribution))
00431 newDistribution(atts);
00432 else if (name.equals(DatabasesXmlTags.ELT_BackendRecoveryPolicy))
00433 newBackendRecoveryPolicy(atts);
00434 else if (name.equals(DatabasesXmlTags.ELT_ControllerName))
00435 newControllerName(atts);
00436
00437 // Monitoring
00438 else if (name.equals(DatabasesXmlTags.ELT_SQLMonitoring))
00439 newSQLMonitoring(atts);
00440 else if (name.equals(DatabasesXmlTags.ELT_SQLMonitoringRule))
00441 newSQLMonitoringRule(atts);
00442
00443 // Database backend
00444 else if (name.equals(DatabasesXmlTags.ELT_DatabaseBackend))
00445 newDatabaseBackend(atts);
00446 else if (name.equals(DatabasesXmlTags.ELT_RewritingRule))
00447 newRewritingRule(atts);
00448
00449 // Authentication manager
00450 else if (name.equals(DatabasesXmlTags.ELT_AuthenticationManager))
00451 newAuthenticationManager(atts);
00452 else if (name.equals(DatabasesXmlTags.ELT_AdminLogin))
00453 newAdminLogin(atts);
00454 else if (name.equals(DatabasesXmlTags.ELT_VirtualLogin))
00455 newVirtualLogin(atts);
00456 else if (name.equals(DatabasesXmlTags.ELT_RealLogin))
00457 newRealLogin(atts);
00458
00459 // Request manager
00460 else if (name.equals(DatabasesXmlTags.ELT_RequestManager))
00461 newRequestManager(atts);
00462
00463 // Request schedulers
00464 else if (name.equals(DatabasesXmlTags.ELT_SingleDBScheduler))
00465 newSingleDBScheduler(atts);
00466 else if (name.equals(DatabasesXmlTags.ELT_RAIDb0Scheduler))
00467 newRAIDb0Scheduler(atts);
00468 else if (name.equals(DatabasesXmlTags.ELT_RAIDb1Scheduler))
00469 newRAIDb1Scheduler(atts);
00470 else if (name.equals(DatabasesXmlTags.ELT_RAIDb2Scheduler))
00471 newRAIDb2Scheduler(atts);
00472
00473 // Request caches
00474 else if (name.equals(DatabasesXmlTags.ELT_MetadataCache))
00475 newMetadataCache(atts);
00476 else if (name.equals(DatabasesXmlTags.ELT_ParsingCache))
00477 newParsingCache(atts);
00478 else if (name.equals(DatabasesXmlTags.ELT_ResultCache))
00479 newResultCache(atts);
00480 else if (name.equals(DatabasesXmlTags.ELT_DefaultResultCacheRule))
00481 newDefaultResultCacheRule(atts);
00482 else if (name.equals(DatabasesXmlTags.ELT_ResultCacheRule))
00483 newResultCacheRule(atts);
00484 else if (name.equals(DatabasesXmlTags.ELT_NoCaching))
00485 currentResultCacheRule.setCacheBehavior(ResultCacheFactory
00486 .getCacheBehaviorInstance(DatabasesXmlTags.ELT_NoCaching, null));
00487 else if (name.equals(DatabasesXmlTags.ELT_EagerCaching))
00488 currentResultCacheRule.setCacheBehavior(ResultCacheFactory
00489 .getCacheBehaviorInstance(DatabasesXmlTags.ELT_EagerCaching, null));
00490 else if (name.equals(DatabasesXmlTags.ELT_RelaxedCaching))
00491 newRelaxedCaching(atts);
00492
00493 // Request load balancers
00494 else if (name.equals(DatabasesXmlTags.ELT_SingleDB))
00495 newSingleDBRequestLoadBalancer(atts);
00496 else if (name.equals(DatabasesXmlTags.ELT_ParallelDB_RoundRobin))
00497 newParallelDBRoundRobinLoadBalancer(atts);
00498 else if (name
00499 .equals(DatabasesXmlTags.ELT_ParallelDB_LeastPendingRequestsFirst))
00500 newParallelDBLeastPendingRequestsFirst(atts);
00501 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_0))
00502 newRAIDb0LoadBalancer(atts);
00503 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_1))
00504 newRAIDb1LoadBalancer(atts);
00505 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_1_RoundRobin))
00506 newRAIDb1RoundRobinLoadBalancer(atts);
00507 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_1_WeightedRoundRobin))
00508 newRAIDb1WeightedRoundRobinLoadBalancer(atts);
00509 else if (name
00510 .equals(DatabasesXmlTags.ELT_RAIDb_1_LeastPendingRequestsFirst))
00511 newRAIDb1LeastPendingRequestsFirst(atts);
00512 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_1ec))
00513 newRAIDb1ecLoadBalancer(atts);
00514 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_1ec_RoundRobin))
00515 newRAIDb1ecRoundRobinLoadBalancer(atts);
00516 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_1ec_WeightedRoundRobin))
00517 newRAIDb1ecWeightedRoundRobinLoadBalancer(atts);
00518 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_2))
00519 newRAIDb2LoadBalancer(atts);
00520 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_2_RoundRobin))
00521 newRAIDb2RoundRobinLoadBalancer(atts);
00522 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_2_WeightedRoundRobin))
00523 newRAIDb2WeightedRoundRobinLoadBalancer(atts);
00524 else if (name
00525 .equals(DatabasesXmlTags.ELT_RAIDb_2_LeastPendingRequestsFirst))
00526 newRAIDb2LeastPendingRequestsFirst(atts);
00527 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_2ec))
00528 newRAIDb2ecLoadBalancer(atts);
00529 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_2ec_RoundRobin))
00530 newRAIDb2ecRoundRobinLoadBalancer(atts);
00531 else if (name.equals(DatabasesXmlTags.ELT_RAIDb_2ec_WeightedRoundRobin))
00532 newRAIDb2ecWeightedRoundRobinLoadBalancer(atts);
00533
00534 // Policies
00535 else if (name.equals(DatabasesXmlTags.ELT_WaitForCompletion))
00536 newWaitForCompletion(atts);
00537 else if (name.equals(DatabasesXmlTags.ELT_ErrorChecking))
00538 newErrorChecking(atts);
00539 else if (name.equals(DatabasesXmlTags.ELT_CreateTable))
00540 newCreateTable(atts);
00541 else if (name.equals(DatabasesXmlTags.ELT_BackendName))
00542 newBackendName(atts);
00543 else if (name.equals(DatabasesXmlTags.ELT_BackendWeight))
00544 newBackendWeight(atts);
00545
00546 // Recovery log
00547 else if (name.equals(DatabasesXmlTags.ELT_FileRecoveryLog))
00548 newFileRecoveryLog(atts);
00549 else if (name.equals(DatabasesXmlTags.ELT_JDBCRecoveryLog))
00550 newJDBCRecoveryLog(atts);
00551 else if (name.equals(DatabasesXmlTags.ELT_RecoveryLogTable))
00552 newJDBCRecoveryLogTable(atts);
00553 else if (name.equals(DatabasesXmlTags.ELT_CheckpointTable))
00554 newJDBCRecoveryCheckpointTable(atts);
00555 else if (name.equals(DatabasesXmlTags.ELT_BackendTable))
00556 newJDBCRecoveryBackendTable(atts);
00557
00558 // Connection managers
00559 else if (name.equals(DatabasesXmlTags.ELT_ConnectionManager))
00560 newConnectionManager(atts);
00561 else if (name.equals(DatabasesXmlTags.ELT_SimpleConnectionManager))
00562 newSimpleConnectionManager(atts);
00563 else if (name.equals(DatabasesXmlTags.ELT_FailFastPoolConnectionManager))
00564 newFailFastPoolConnectionManager(atts);
00565 else if (name.equals(DatabasesXmlTags.ELT_RandomWaitPoolConnectionManager))
00566 newRandomWaitPoolConnectionManager(atts);
00567 else if (name.equals(DatabasesXmlTags.ELT_VariablePoolConnectionManager))
00568 newVariablePoolConnectionManager(atts);
00569
00570 // Database schema
00571 else if (name.equals(DatabasesXmlTags.ELT_DatabaseSchema))
00572 newDatabaseSchema(atts);
00573 else if (name.equals(DatabasesXmlTags.ELT_DatabaseStaticSchema))
00574 currentDatabaseSchema = new DatabaseSchema();
00575
00576 // Database table (inside a DatabaseSchema)
00577 else if (name.equals(DatabasesXmlTags.ELT_DatabaseTable))
00578 newDatabaseTable(atts);
00579
00580 // Table column (inside a DatabaseSchema/DatabaseTable)
00581 else if (name.equals(DatabasesXmlTags.ELT_DatabaseColumn))
00582 newDatabaseColumn(atts);
00583
00584 else if (name.equals(DatabasesXmlTags.ELT_DatabaseProcedure))
00585 newDatabaseProcedure(atts);
00586 else if (name.equals(DatabasesXmlTags.ELT_DatabaseProcedureColumn))
00587 newDatabaseProcedureColumn(atts);
00588 }
|
|
|
DatabasesParser.java の 186 行で定義されています。 |
|
|
DatabasesParser.java の 177 行で定義されています。 |
|
|
C-JDBC DTD file name (must be found in classpath). DatabasesParser.java の 136 行で定義されています。 参照元 org.objectweb.cjdbc.controller.xml.DatabasesParser.readXML(). |
|
|
DatabasesParser.java の 182 行で定義されています。 |
|
|
DatabasesParser.java の 178 行で定義されています。 |
|
|
DatabasesParser.java の 174 行で定義されています。 |
|
|
C-JDBC controller to setup. DatabasesParser.java の 147 行で定義されています。 |
|
|
DatabasesParser.java の 157 行で定義されています。 |
|
|
DatabasesParser.java の 155 行で定義されています。 |
|
|
DatabasesParser.java の 191 行で定義されています。 |
|
|
DatabasesParser.java の 184 行で定義されています。 |
|
|
DatabasesParser.java の 185 行で定義されています。 |
|
|
DatabasesParser.java の 156 行で定義されています。 |
|
|
DatabasesParser.java の 169 行で定義されています。 |
|
|
DatabasesParser.java の 187 行で定義されています。 |
|
|
DatabasesParser.java の 164 行で定義されています。 |
|
|
DatabasesParser.java の 160 行で定義されています。 |
|
|
DatabasesParser.java の 189 行で定義されています。 |
|
|
DatabasesParser.java の 161 行で定義されています。 |
|
|
DatabasesParser.java の 171 行で定義されています。 |
|
|
DatabasesParser.java の 163 行で定義されています。 |
|
|
DatabasesParser.java の 166 行で定義されています。 |
|
|
DatabasesParser.java の 158 行で定義されています。 |
|
|
DatabasesParser.java の 159 行で定義されています。 |
|
|
DatabasesParser.java の 162 行で定義されています。 |
|
|
DatabasesParser.java の 170 行で定義されています。 |
|
|
DatabasesParser.java の 165 行で定義されています。 |
|
|
DatabasesParser.java の 154 行で定義されています。 |
|
|
DatabasesParser.java の 167 行で定義されています。 |
|
|
DatabasesParser.java の 175 行で定義されています。 |
|
|
DatabasesParser.java の 168 行で定義されています。 |
|
|
dbToPrepare is used if only a specified database has to be loaded DatabasesParser.java の 150 行で定義されています。 |
|
|
初期値: Trace
.getLogger(DatabasesParser.class
.getName())
DatabasesParser.java の 142 行で定義されています。 |
|
|
DatabasesParser.java の 172 行で定義されています。 |
|
|
XML parser. DatabasesParser.java の 139 行で定義されています。 |
|
|
DatabasesParser.java の 180 行で定義されています。 |
|
|
DatabasesParser.java の 179 行で定義されています。 |
|
|
setter for jumping from one VirtualDatabase definition to the next one DatabasesParser.java の 152 行で定義されています。 |
1.3.6