DatabasesParser


1   /**
2    * Sequoia: Database clustering technology.
3    * Copyright (C) 2002-2004 French National Institute For Research In Computer
4    * Science And Control (INRIA).
5    * Copyright (C) 2005 AmicoSoft, Inc. dba Emic Networks
6    * Copyright (C) 2005-2006 Continuent, Inc.
7    * Contact: sequoia@continuent.org
8    * 
9    * Licensed under the Apache License, Version 2.0 (the "License");
10   * you may not use this file except in compliance with the License.
11   * You may obtain a copy of the License at
12   * 
13   * http://www.apache.org/licenses/LICENSE-2.0
14   * 
15   * Unless required by applicable law or agreed to in writing, software
16   * distributed under the License is distributed on an "AS IS" BASIS,
17   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18   * See the License for the specific language governing permissions and
19   * limitations under the License. 
20   *
21   * Initial developer(s): Emmanuel Cecchet.
22   * Contributor(s): Mathieu Peltier, Sara Bouchenakm Nicolas Modrzyk
23   */
24  
25  package org.continuent.sequoia.controller.xml;
26  
27  import java.io.IOException  ;
28  import java.io.InputStream  ;
29  import java.io.StringReader  ;
30  import java.util.ArrayList  ;
31  import java.util.Hashtable  ;
32  import java.util.List  ;
33  import java.util.SortedSet  ;
34  import java.util.StringTokenizer  ;
35  import java.util.TreeSet  ;
36  
37  import javax.management.ObjectName  ;
38  
39  import org.continuent.sequoia.common.exceptions.BackupException;
40  import org.continuent.sequoia.common.exceptions.VirtualDatabaseException;
41  import org.continuent.sequoia.common.i18n.Translate;
42  import org.continuent.sequoia.common.jmx.JmxConstants;
43  import org.continuent.sequoia.common.log.Trace;
44  import org.continuent.sequoia.common.users.AbstractDatabaseUser;
45  import org.continuent.sequoia.common.users.AdminUser;
46  import org.continuent.sequoia.common.users.DatabaseBackendUser;
47  import org.continuent.sequoia.common.users.VirtualDatabaseUser;
48  import org.continuent.sequoia.common.xml.DatabasesXmlTags;
49  import org.continuent.sequoia.common.xml.XmlValidator;
50  import org.continuent.sequoia.controller.authentication.AccessControl;
51  import org.continuent.sequoia.controller.authentication.AccessControlRule;
52  import org.continuent.sequoia.controller.authentication.AuthenticationManager;
53  import org.continuent.sequoia.controller.authentication.AuthenticationManagerException;
54  import org.continuent.sequoia.controller.backend.DatabaseBackend;
55  import org.continuent.sequoia.controller.backend.rewriting.AbstractRewritingRule;
56  import org.continuent.sequoia.controller.backend.rewriting.PatternRewritingRule;
57  import org.continuent.sequoia.controller.backend.rewriting.ReplaceAllRewritingRule;
58  import org.continuent.sequoia.controller.backend.rewriting.SimpleRewritingRule;
59  import org.continuent.sequoia.controller.backup.BackupManager;
60  import org.continuent.sequoia.controller.backup.Backuper;
61  import org.continuent.sequoia.controller.cache.metadata.MetadataCache;
62  import org.continuent.sequoia.controller.cache.parsing.ParsingCache;
63  import org.continuent.sequoia.controller.cache.parsing.ParsingCacheControl;
64  import org.continuent.sequoia.controller.cache.result.AbstractResultCache;
65  import org.continuent.sequoia.controller.cache.result.CachingGranularities;
66  import org.continuent.sequoia.controller.cache.result.ResultCacheFactory;
67  import org.continuent.sequoia.controller.cache.result.ResultCacheRule;
68  import org.continuent.sequoia.controller.cache.result.rules.EagerCaching;
69  import org.continuent.sequoia.controller.connection.FailFastPoolConnectionManager;
70  import org.continuent.sequoia.controller.connection.RandomWaitPoolConnectionManager;
71  import org.continuent.sequoia.controller.connection.SimpleConnectionManager;
72  import org.continuent.sequoia.controller.connection.VariablePoolConnectionManager;
73  import org.continuent.sequoia.controller.core.Controller;
74  import org.continuent.sequoia.controller.core.ControllerConstants;
75  import org.continuent.sequoia.controller.jmx.MBeanServerManager;
76  import org.continuent.sequoia.controller.loadbalancer.AbstractLoadBalancer;
77  import org.continuent.sequoia.controller.loadbalancer.paralleldb.ParallelDB;
78  import org.continuent.sequoia.controller.loadbalancer.paralleldb.ParallelDB_LPRF;
79  import org.continuent.sequoia.controller.loadbalancer.paralleldb.ParallelDB_RR;
80  import org.continuent.sequoia.controller.loadbalancer.policies.WaitForCompletionPolicy;
81  import org.continuent.sequoia.controller.loadbalancer.policies.createtable.CreateTableAll;
82  import org.continuent.sequoia.controller.loadbalancer.policies.createtable.CreateTablePolicy;
83  import org.continuent.sequoia.controller.loadbalancer.policies.createtable.CreateTableRandom;
84  import org.continuent.sequoia.controller.loadbalancer.policies.createtable.CreateTableRoundRobin;
85  import org.continuent.sequoia.controller.loadbalancer.policies.createtable.CreateTableRule;
86  import org.continuent.sequoia.controller.loadbalancer.raidb0.RAIDb0;
87  import org.continuent.sequoia.controller.loadbalancer.raidb1.RAIDb1_LPRF;
88  import org.continuent.sequoia.controller.loadbalancer.raidb1.RAIDb1_RR;
89  import org.continuent.sequoia.controller.loadbalancer.raidb1.RAIDb1_WRR;
90  import org.continuent.sequoia.controller.loadbalancer.raidb2.RAIDb2_LPRF;
91  import org.continuent.sequoia.controller.loadbalancer.raidb2.RAIDb2_RR;
92  import org.continuent.sequoia.controller.loadbalancer.raidb2.RAIDb2_WRR;
93  import org.continuent.sequoia.controller.loadbalancer.singledb.SingleDB;
94  import org.continuent.sequoia.controller.monitoring.SQLMonitoring;
95  import org.continuent.sequoia.controller.monitoring.SQLMonitoringRule;
96  import org.continuent.sequoia.controller.recoverylog.HSQLEmbeddedRecoveryLog;
97  import org.continuent.sequoia.controller.recoverylog.RecoveryLog;
98  import org.continuent.sequoia.controller.recoverylog.RecoveryLogControl;
99  import org.continuent.sequoia.controller.requestmanager.RAIDbLevels;
100 import org.continuent.sequoia.controller.requestmanager.RequestManager;
101 import org.continuent.sequoia.controller.requestmanager.distributed.RAIDb1DistributedRequestManager;
102 import org.continuent.sequoia.controller.requestmanager.distributed.RAIDb2DistributedRequestManager;
103 import org.continuent.sequoia.controller.scheduler.AbstractScheduler;
104 import org.continuent.sequoia.controller.scheduler.AbstractSchedulerControl;
105 import org.continuent.sequoia.controller.scheduler.raidb0.RAIDb0PassThroughLevelScheduler;
106 import org.continuent.sequoia.controller.scheduler.raidb0.RAIDb0PessimisticTransactionLevelScheduler;
107 import org.continuent.sequoia.controller.scheduler.raidb1.RAIDb1PassThroughScheduler;
108 import org.continuent.sequoia.controller.scheduler.raidb2.RAIDb2PassThroughScheduler;
109 import org.continuent.sequoia.controller.scheduler.singledb.SingleDBPassThroughScheduler;
110 import org.continuent.sequoia.controller.scheduler.singledb.SingleDBPessimisticTransactionLevelScheduler;
111 import org.continuent.sequoia.controller.semantic.AbstractSemantic;
112 import org.continuent.sequoia.controller.semantic.RequestSemantic;
113 import org.continuent.sequoia.controller.semantic.SemanticBehavior;
114 import org.continuent.sequoia.controller.semantic.StoredProcedureSemantic;
115 import org.continuent.sequoia.controller.semantic.TriggerSemantic;
116 import org.continuent.sequoia.controller.semantic.ViewSemantic;
117 import org.continuent.sequoia.controller.sql.macros.DateMacro;
118 import org.continuent.sequoia.controller.sql.macros.MacrosHandler;
119 import org.continuent.sequoia.controller.sql.macros.RandomMacro;
120 import org.continuent.sequoia.controller.sql.schema.DynamicDatabaseSchema;
121 import org.continuent.sequoia.controller.virtualdatabase.DistributedVirtualDatabase;
122 import org.continuent.sequoia.controller.virtualdatabase.VirtualDatabase;
123 import org.continuent.sequoia.controller.virtualdatabase.protocol.MessageTimeouts;
124 import org.xml.sax.Attributes  ;
125 import org.xml.sax.InputSource  ;
126 import org.xml.sax.SAXException  ;
127 import org.xml.sax.SAXParseException  ;
128 import org.xml.sax.XMLReader  ;
129 import org.xml.sax.helpers.DefaultHandler  ;
130 import org.xml.sax.helpers.XMLReaderFactory  ;
131 
132 /**
133  * Parses an XML content conforming to sequoia.dtd and configure the given
134  * Sequoia Controller accordingly.
135  * 
136  * @author <a HREF="mailto:Emmanuel.Cecchet@inria.fr">Emmanuel Cecchet </a>
137  * @author <a HREF="mailto:Mathieu.Peltier@inrialpes.fr">Mathieu Peltier </a>
138  * @author <a HREF="mailto:Nicolas.Modrzyk@inrialpes.fr">Nicolas Modrzyk </a>
139  * @version 1.0
140  */
141 public class DatabasesParser extends DefaultHandler  
142 {
143 
144   private static final WaitForCompletionPolicy DEFAULT_WAIT_FOR_ALL_COMPLETION = new WaitForCompletionPolicy(
145                                                                                    WaitForCompletionPolicy.FIRST,
146                                                                                    false,
147                                                                                    30000);
148 
149   /** XML parser. */
150   private XMLReader                              parser;
151 
152   /** Logger instance. */
153   static Trace                                 logger                          = Trace
154                                                                                    .getLogger(DatabasesParser.class
155                                                                                        .getName());
156   static Trace                                 endUserLogger                   = Trace
157                                                                                    .getLogger("org.continuent.sequoia.enduser");
158 
159   /** Sequoia controller to setup. */
160   private Controller                           controller;
161 
162   /** dbToPrepare is used if only a specified database has to be loaded */
163   private Hashtable                              dbToPrepare                     = null;
164   /** setter for jumping from one VirtualDatabase definition to the next one */
165   private boolean                              skipDatabase                    = false;
166 
167   private VirtualDatabase                      currentVirtualDatabase          = null;
168   private BackupManager                        currentBackupManager            = null;
169   private DatabaseBackend                      currentBackend;
170   private DatabaseBackendUser                  currentDatabaseBackendUser;
171   private AuthenticationManager                currentAuthenticationManager;
172   private AbstractSemantic                     currentSemantic;
173 
174   private AbstractScheduler                    currentRequestScheduler;
175   private AbstractResultCache                  currentResultCache;
176   private MetadataCache                        currentMetadataCache            = null;
177   private ParsingCache                         currentParsingCache             = null;
178   private ResultCacheRule                      currentResultCacheRule;
179   private MacrosHandler                        currentMacroHandler;
180   private AbstractLoadBalancer                 currentLoadBalancer;
181   private RecoveryLog                          currentRecoveryLog;
182   private AbstractDatabaseUser                 currentUser;
183   private AccessControl                        currentAccessControl;
184 
185   private String                                 connectionManagerVLogin;
186   private WaitForCompletionPolicy              currentWaitForCompletionPolicy  = DEFAULT_WAIT_FOR_ALL_COMPLETION;
187 
188   private long                                 beginTimeout;
189   private long                                 commitTimeout;
190   private long                                 rollbackTimeout;
191   private int                                  requestTimeout;
192 
193   private boolean                              caseSensitiveParsing;
194 
195   private CreateTablePolicy                    currentCreateTablePolicy;
196   private CreateTableRule                      currentCreateTableRule;
197   private ArrayList                              backendNameList;
198 
199   private int                                  defaultTransactionIsolation;
200 
201   /**
202    * We are setting the default connection manager rather than a 'normal'
203    * connection manager.
204    */
205   private boolean                              settingDefaultConnectionManager;
206 
207   /**
208    * Creates a new <code>DatabasesParser</code> instance. This method
209    * Instanciates also a new <code>DatabasesParser</code>.
210    * 
211    * @param controller <code>Controller</code> to load the Virtual Database
212    *          into
213    * @throws SAXException if an error occurs
214    */
215   public DatabasesParser(Controller controller) throws SAXException  
216   {
217     prepareHandler(controller);
218   }
219 
220   /**
221    * Creates a new <code>DatabasesParser</code> instance. This method
222    * Instanciates also a new <code>DatabasesParser</code>. This instance will
223    * look only for the specified database.
224    * 
225    * @param controller <code>Controller</code> to load the Virtual Database
226    *          into
227    * @param virtualName the specified <code>VirtualDatabase</code> to load.
228    * @param autoLoad autoenable switch
229    * @throws SAXException if an error occurs
230    */
231   public DatabasesParser(Controller controller, String   virtualName, int autoLoad)
232       throws SAXException  
233   {
234     prepareHandler(controller);
235     // Test if a name has been specified. Otherwise skip.
236     if (virtualName != null)
237       prepareDB(virtualName, autoLoad);
238   }
239 
240   private void prepareHandler(Controller controller) throws SAXException  
241   {
242     // Instantiate a new parser
243     parser = XMLReaderFactory.createXMLReader();
244 
245     this.controller = controller;
246 
247     // Activate validation
248     parser.setFeature("http://xml.org/sax/features/validation", true);
249 
250     // Install error handler
251     parser.setErrorHandler(this);
252 
253     // Install document handler
254     parser.setContentHandler(this);
255 
256     // Install local entity resolver
257     parser.setEntityResolver(this);
258   }
259 
260   /**
261    * Parses an XML content according to Sequoia DTD.
262    * 
263    * @param xml a <code>String</code> containing the XML content to parse
264    * @exception SAXException if an error occurs
265    * @exception IOException if an error occurs
266    */
267   public void readXML(String   xml) throws IOException  , SAXException  
268   {
269     InputSource   input = new InputSource  (new StringReader  (xml));
270     parser.parse(input);
271   }
272 
273   /**
274    * Validate an XML content according to Sequoia DTD.
275    * 
276    * @param xml content
277    * @param validateBeforeParsing if true validate the document before the
278    *          parsing
279    * @throws IOException if an error occurs
280    * @throws SAXException if an error occurs
281    */
282   public void readXML(String   xml, boolean validateBeforeParsing)
283       throws IOException  , SAXException  
284   {
285     if (validateBeforeParsing)
286     {
287       XmlValidator validator = new XmlValidator(
288           ControllerConstants.SEQUOIA_DTD_FILE, xml);
289       if (logger.isDebugEnabled())
290       {
291         if (validator.isDtdValid())
292           logger.debug(Translate.get("virtualdatabase.xml.dtd.validated"));
293         if (validator.isXmlValid())
294           logger.debug(Translate.get("virtualdatabase.xml.document.validated"));
295       }
296 
297       if (validator.getWarnings().size() > 0)
298       {
299         ArrayList   warnings = validator.getWarnings();
300         for (int i = 0; i < warnings.size(); i++)
301           logger.warn(Translate.get("virtualdatabase.xml.parsing.warning",
302               warnings.get(i)));
303       }
304 
305       if (!validator.isDtdValid())
306         logger.error(Translate.get("virtualdatabase.xml.dtd.not.validated"));
307       if (!validator.isXmlValid())
308         logger.error(Translate
309             .get("virtualdatabase.xml.document.not.validated"));
310 
311       ArrayList   errors = validator.getExceptions();
312       for (int i = 0; i < errors.size(); i++)
313         logger.error(((Exception  ) errors.get(i)).getMessage());
314 
315       if (!validator.isValid())
316         throw new SAXException  (Translate
317             .get("virtualdatabase.xml.document.not.valid"));
318     }
319     this.readXML(xml);
320   }
321 
322   /**
323    * Handles notification of a non-recoverable parser error.
324    * 
325    * @param e the warning information encoded as an exception.
326    * @exception SAXException any SAX exception, possibly wrapping another
327    *              exception.
328    */
329   public void fatalError(SAXParseException   e) throws SAXException  
330   {
331     String   msg = Translate.get("virtualdatabase.xml.parsing.fatal",
332         new String  []{e.getPublicId(), String.valueOf(e.getLineNumber()),
333             String.valueOf(e.getColumnNumber()), e.getMessage()});
334     logger.error(msg);
335     endUserLogger.fatal(msg);
336     throw e;
337   }
338 
339   /**
340    * Handles notification of a recoverable parser error.
341    * 
342    * @param e the warning information encoded as an exception.
343    * @exception SAXException any SAX exception, possibly wrapping another
344    *              exception
345    */
346   public void error(SAXParseException   e) throws SAXException  
347   {
348     logger.error(Translate.get("virtualdatabase.xml.parsing.error",
349         new String  []{e.getPublicId(), String.valueOf(e.getLineNumber()),
350             String.valueOf(e.getColumnNumber()), e.getMessage()}));
351     throw e;
352   }
353 
354   /**
355    * Allows to parse the document with a local copy of the DTD whatever the
356    * original <code>DOCTYPE</code> found. Warning, this method is called only
357    * if the XML document contains a <code>DOCTYPE</code>.
358    * 
359    * @see org.xml.sax.EntityResolver#resolveEntity(java.lang.String,
360    *      java.lang.String)
361    */
362   public InputSource   resolveEntity(String   publicId, String   systemId)
363       throws SAXException  
364   {
365     InputStream   stream = DatabasesXmlTags.class.getResourceAsStream("/"
366         + ControllerConstants.SEQUOIA_DTD_FILE);
367     if (stream == null)
368       throw new SAXException  ("Cannot find Sequoia DTD file '"
369           + ControllerConstants.SEQUOIA_DTD_FILE + "' in classpath");
370 
371     return new InputSource  (stream);
372   }
373 
374   /**
375    * If this method is called. Only the specified DB of the Xml file will be
376    * loaded.
377    * 
378    * @param virtualName <code>VirtualDatabase</code> name
379    * @param autoLoad autoenable switch
380    */
381   public void prepareDB(String   virtualName, int autoLoad)
382   {
383     dbToPrepare = new Hashtable  (2);
384     dbToPrepare.put("virtualName", virtualName);
385     dbToPrepare.put("autoEnable", String.valueOf(autoLoad));
386   }
387 
388   /**
389    * Initializes parsing of a document.
390    * 
391    * @exception SAXException unspecialized error
392    */
393   public void startDocument() throws SAXException  
394   {
395     logger.info(Translate.get("virtualdatabase.xml.start"));
396   }
397 
398   /**
399    * Finalizes parsing of a document.
400    * 
401    * @exception SAXException unspecialized error
402    */
403   public void endDocument() throws SAXException  
404   {
405     logger.info(Translate.get("virtualdatabase.xml.done"));
406   }
407 
408   /**
409    * Analyzes an element first line.
410    * 
411    * @param uri name space URI
412    * @param localName local name
413    * @param name element raw name
414    * @param atts element attributes
415    * @exception SAXException if an error occurs
416    */
417   public void startElement(String   uri, String   localName, String   name,
418       Attributes   atts) throws SAXException  
419   {
420     logger.debug(Translate.get("virtualdatabase.xml.parsing.start", name));
421 
422     // Virtual database
423     if (name.equals(DatabasesXmlTags.ELT_VirtualDatabase))
424     {
425       if (dbToPrepare == null)
426       {
427         // Prepare all databases
428         newVirtualDatabase(atts);
429       }
430       else
431       {
432         // Only prepare one database
433         String   virtualName = atts.getValue(DatabasesXmlTags.ATT_name);
434         if (virtualName.equalsIgnoreCase((String  ) dbToPrepare
435             .get("virtualName")))
436         {
437           // This is the database that we want to prepare
438           skipDatabase = false;
439           newVirtualDatabase(atts);
440         }
441         else
442         {
443           // Skip to next one
444           skipDatabase = true;
445         }
446       }
447     }
448     // Skip to next definition of a virtualDatabase ?
449     if (skipDatabase)
450       return;
451 
452     // Distribution
453     else if (name.equals(DatabasesXmlTags.ELT_Distribution))
454       newDistribution(atts);
455     else if (name.equals(DatabasesXmlTags.ELT_MessageTimeouts))
456       newMessageTimeouts(atts);
457 
458     // Monitoring
459     else if (name.equals(DatabasesXmlTags.ELT_SQLMonitoring))
460       newSQLMonitoring(atts);
461     else if (name.equals(DatabasesXmlTags.ELT_SQLMonitoringRule))
462       newSQLMonitoringRule(atts);
463 
464     // Backup
465     else if (name.equals(DatabasesXmlTags.ELT_Backup))
466       newBackupManager();
467     else if (name.equals(DatabasesXmlTags.ELT_Backuper))
468       newBackuper(atts);
469 
470     // Database backend
471     else if (name.equals(DatabasesXmlTags.ELT_DatabaseBackend))
472       newDatabaseBackend(atts);
473     else if (name.equals(DatabasesXmlTags.ELT_RewritingRule))
474       newRewritingRule(atts);
475 
476     // Authentication manager
477     else if (name.equals(DatabasesXmlTags.ELT_AuthenticationManager))
478       newAuthenticationManager(atts);
479     else if (name.equals(DatabasesXmlTags.ELT_AdminUser))
480       newAdminUser(atts);
481     else if (name.equals(DatabasesXmlTags.ELT_VirtualUser))
482       newVirtualUser(atts);
483     else if (name.equals(DatabasesXmlTags.ELT_AccessControl))
484       newAccessControl(atts);
485     else if (name.equals(DatabasesXmlTags.ELT_Accept))
486       newAccept(atts);
487     else if (name.equals(DatabasesXmlTags.ELT_Deny))
488       newDeny(atts);
489 
490     // Request manager
491     else if (name.equals(DatabasesXmlTags.ELT_RequestManager))
492       newRequestManager(atts);
493 
494     // Macro Handler
495     else if (name.equals(DatabasesXmlTags.ELT_MacroHandling))
496       newMacroHandler(atts);
497     else if (name.equals(DatabasesXmlTags.ELT_DateMacro))
498       newDateMacro(atts);
499     else if (name.equals(DatabasesXmlTags.ELT_RandomMacro))
500       newRandomMacro(atts);
501 
502     // Request schedulers
503     else if (name.equals(DatabasesXmlTags.ELT_SingleDBScheduler))
504       newSingleDBScheduler(atts);
505     else if (name.equals(DatabasesXmlTags.ELT_RAIDb0Scheduler))
506       newRAIDb0Scheduler(atts);
507     else if (name.equals(DatabasesXmlTags.ELT_RAIDb1Scheduler))
508       newRAIDb1Scheduler(atts);
509     else if (name.equals(DatabasesXmlTags.ELT_RAIDb2Scheduler))
510       newRAIDb2Scheduler(atts);
511 
512     // Request caches
513     else if (name.equals(DatabasesXmlTags.ELT_MetadataCache))
514       newMetadataCache(atts);
515     else if (name.equals(DatabasesXmlTags.ELT_ParsingCache))
516       newParsingCache(atts);
517     else if (name.equals(DatabasesXmlTags.ELT_ResultCache))
518       newResultCache(atts);
519     else if (name.equals(DatabasesXmlTags.ELT_DefaultResultCacheRule))
520       newDefaultResultCacheRule(atts);
521     else if (name.equals(DatabasesXmlTags.ELT_ResultCacheRule))
522       newResultCacheRule(atts);
523     else if (name.equals(DatabasesXmlTags.ELT_NoCaching))
524       currentResultCacheRule.setCacheBehavior(ResultCacheFactory
525           .getCacheBehaviorInstance(DatabasesXmlTags.ELT_NoCaching, null));
526     else if (name.equals(DatabasesXmlTags.ELT_EagerCaching))
527       newEagerCaching(atts);
528     else if (name.equals(DatabasesXmlTags.ELT_RelaxedCaching))
529       newRelaxedCaching(atts);
530 
531     // Request load balancers
532     else if (name.equals(DatabasesXmlTags.ELT_LoadBalancer))
533       newLoadBalancer(atts);
534     else if (name.equals(DatabasesXmlTags.ELT_SingleDB))
535       newSingleDBRequestLoadBalancer();
536     else if (name.equals(DatabasesXmlTags.ELT_ParallelDB_RoundRobin))
537       newParallelDBRoundRobinLoadBalancer();
538     else if (name
539         .equals(DatabasesXmlTags.ELT_ParallelDB_LeastPendingRequestsFirst))
540       newParallelDBLeastPendingRequestsFirst();
541     else if (name.equals(DatabasesXmlTags.ELT_RAIDb_0))
542       newRAIDb0LoadBalancer();
543     else if (name.equals(DatabasesXmlTags.ELT_RAIDb_1))
544       newRAIDb1LoadBalancer();
545     else if (name.equals(DatabasesXmlTags.ELT_RAIDb_1_RoundRobin))
546       newRAIDb1RoundRobinLoadBalancer();
547     else if (name.equals(DatabasesXmlTags.ELT_RAIDb_1_WeightedRoundRobin))
548       newRAIDb1WeightedRoundRobinLoadBalancer();
549     else if (name
550         .equals(DatabasesXmlTags.ELT_RAIDb_1_LeastPendingRequestsFirst))
551       newRAIDb1LeastPendingRequestsFirst();
552     else if (name.equals(DatabasesXmlTags.ELT_RAIDb_2))
553       newRAIDb2LoadBalancer();
554     else if (name.equals(DatabasesXmlTags.ELT_RAIDb_2_RoundRobin))
555       newRAIDb2RoundRobinLoadBalancer();
556     else if (name.equals(DatabasesXmlTags.ELT_RAIDb_2_WeightedRoundRobin))
557       newRAIDb2WeightedRoundRobinLoadBalancer();
558     else if (name
559         .equals(DatabasesXmlTags.ELT_RAIDb_2_LeastPendingRequestsFirst))
560       newRAIDb2LeastPendingRequestsFirst();
561 
562     // Policies
563     else if (name.equals(DatabasesXmlTags.ELT_WaitForCompletion))
564       newWaitForCompletion(atts);
565     else if (name.equals(DatabasesXmlTags.ELT_CreateTable))
566       newCreateTable(atts);
567     else if (name.equals(DatabasesXmlTags.ELT_BackendName))
568       newBackendName(atts);
569     else if (name.equals(DatabasesXmlTags.ELT_BackendWeight))
570       newBackendWeight(atts);
571 
572     // Recovery log
573     else if (name.equals(DatabasesXmlTags.ELT_EmbeddedRecoveryLog))
574       newEmbeddedRecoveryLog(atts);
575     else if (name.equals(DatabasesXmlTags.ELT_RecoveryLog))
576       newRecoveryLog(atts);
577     else if (name.equals(DatabasesXmlTags.ELT_RecoveryLogTable))
578       newRecoveryLogTable(atts);
579     else if (name.equals(DatabasesXmlTags.ELT_CheckpointTable))
580       newRecoveryCheckpointTable(atts);
581     else if (name.equals(DatabasesXmlTags.ELT_BackendTable))
582       newRecoveryBackendTable(atts);
583     else if (name.equals(DatabasesXmlTags.ELT_DumpTable))
584       newRecoveryDumpTable(atts);
585 
586     // Connection managers
587     else if (name.equals(DatabasesXmlTags.ELT_ConnectionManager))
588       newConnectionManager(atts);
589     else if (name.equals(DatabasesXmlTags.ELT_DefaultConnectionManager))
590       newDefaultConnectionManager();
591     else if (name.equals(DatabasesXmlTags.ELT_SimpleConnectionManager))
592       newSimpleConnectionManager();
593     else if (name.equals(DatabasesXmlTags.ELT_FailFastPoolConnectionManager))
594       newFailFastPoolConnectionManager(atts);
595     else if (name.equals(DatabasesXmlTags.ELT_RandomWaitPoolConnectionManager))
596       newRandomWaitPoolConnectionManager(atts);
597     else if (name.equals(DatabasesXmlTags.ELT_VariablePoolConnectionManager))
598       newVariablePoolConnectionManager(atts);
599 
600     // Database schema
601     else if (name.equals(DatabasesXmlTags.ELT_DatabaseSchema))
602       newDatabaseSchema(atts);
603 
604     // Semantic
605     else if (name.equals(DatabasesXmlTags.ELT_SemanticBehavior))
606       newSemanticBehavior(atts);
607     else if (name.equals(DatabasesXmlTags.ELT_RequestSemantic))
608       newRequestSemantic(atts);
609     else if (name.equals(DatabasesXmlTags.ELT_DefaultStoredProcedureSemantic))
610       newDefaultStoredProcedureSemantic();
611     else if (name.equals(DatabasesXmlTags.ELT_StoredProcedureSemantic))
612       newStoredProcedureSemantic(atts);
613     else if (name.equals(DatabasesXmlTags.ELT_TriggerSemantic))
614       newTriggerSemantic(atts);
615     else if (name.equals(DatabasesXmlTags.ELT_ViewSemantic))
616       newViewSemantic(atts);
617   }
618 
619   /**
620    * DatabasesParser for end of element.
621    * 
622    * @param uri name space URI
623    * @param localName local name
624    * @param name element raw name
625    * @exception SAXException if an error occurs
626    */
627   public void endElement(String   uri, String   localName, String   name)
628       throws SAXException  
629   {
630     logger.debug(Translate.get("virtualdatabase.xml.parsing.end", name));
631     // Test if skip is needed
632     if (skipDatabase)
633       return;
634 
635     // Virtual database
636     if (name.equals(DatabasesXmlTags.ELT_VirtualDatabase))
637     {
638       if (logger.isDebugEnabled())
639         logger.debug(Translate.get("virtualdatabase.xml.add.virtualdatabase"));
640 
641       if (currentVirtualDatabase != null)
642       {
643         try
644         {
645           if (currentVirtualDatabase instanceof DistributedVirtualDatabase)
646             ((DistributedVirtualDatabase) currentVirtualDatabase).joinGroup();
647           if (dbToPrepare == null)
648           { // Just add the virtual database without auto-enabling backends
649             controller.addVirtualDatabase(currentVirtualDatabase);
650           }
651           else
652           {
653             int autoLoad = Integer.parseInt((String  ) dbToPrepare
654                 .get("autoEnable"));
655             controller.addVirtualDatabase(currentVirtualDatabase, autoLoad);
656           }
657         }
658         catch (Exception   e)
659         {
660           unregisterRelatedMBeans(currentVirtualDatabase);
661 
662           String   msg = Translate.get("controller.add.virtualdatabase.failed",
663               new String  []{currentVirtualDatabase.getVirtualDatabaseName(),
664                   e.getMessage()});
665           if (logger.isErrorEnabled())
666           {
667             logger.error(msg, e);
668           }
669           throw new SAXException  (msg);
670         }
671       }
672       currentVirtualDatabase = null;
673     }
674 
675     // Request manager
676     else if (name.equals(DatabasesXmlTags.ELT_RequestManager))
677     {
678       if (logger.isDebugEnabled())
679         logger.debug(Translate.get("virtualdatabase.xml.requestmanager.set"));
680 
681       if (currentVirtualDatabase != null)
682       {
683         RequestManager requestManager = null;
684 
685         // We consider that SingleDB and ParallelDB balancers don't need macros
686         // handler
687         if (currentLoadBalancer == null)
688           throw new SAXException  ("virtualdatabase.xml.loadbalancer.not.set");
689         if (!(currentLoadBalancer instanceof SingleDB || currentLoadBalancer instanceof ParallelDB))
690         {
691           // If no macros handling has been specified, create an empty one
692           if (currentMacroHandler == null)
693             currentMacroHandler = new MacrosHandler();
694           currentLoadBalancer.setMacroHandler(currentMacroHandler);
695         }
696 
697         try
698         {
699           if (currentVirtualDatabase.isDistributed())
700           {
701             switch (currentLoadBalancer.getRAIDbLevel())
702             {
703               case RAIDbLevels.SingleDB :
704                 String   smsg = Translate.get(
705                     "virtualdatabase.xml.no.single.distributed.requestmanager",
706                     currentLoadBalancer.getRAIDbLevel());
707                 logger.error(smsg);
708                 throw new SAXException  (smsg);
709               case RAIDbLevels.RAIDb1 :
710                 requestManager = new RAIDb1DistributedRequestManager(
711                     (DistributedVirtualDatabase) currentVirtualDatabase,
712                     currentRequestScheduler, currentResultCache,
713                     currentLoadBalancer, currentRecoveryLog, beginTimeout,
714                     commitTimeout, rollbackTimeout);
715                 break;
716               case RAIDbLevels.RAIDb2 :
717                 requestManager = new RAIDb2DistributedRequestManager(
718                     (DistributedVirtualDatabase) currentVirtualDatabase,
719                     currentRequestScheduler, currentResultCache,
720                     currentLoadBalancer, currentRecoveryLog, beginTimeout,
721                     commitTimeout, rollbackTimeout);
722                 break;
723               default :
724                 String   msg = Translate.get(
725                     "virtualdatabase.xml.no.distributed.requestmanager",
726                     currentLoadBalancer.getRAIDbLevel());
727                 logger.error(msg);
728                 throw new SAXException  (msg);
729             }
730           }
731           else
732             requestManager = new RequestManager(currentVirtualDatabase,
733                 currentRequestScheduler, currentResultCache,
734                 currentLoadBalancer, currentRecoveryLog, beginTimeout,
735                 commitTimeout, rollbackTimeout);
736 
737           if (requestManager != null)
738           {
739             if (currentParsingCache != null)
740               requestManager.setParsingCache(currentParsingCache);
741             if (currentMetadataCache != null)
742               requestManager.setMetadataCache(currentMetadataCache);
743             requestManager.setCaseSensitiveParsing(caseSensitiveParsing);
744           }
745 
746           currentVirtualDatabase.setRequestManager(requestManager);
747           if (currentBackupManager == null)
748             currentBackupManager = new BackupManager();
749           requestManager.setBackupManager(currentBackupManager);
750         }
751         catch (Exception   e)
752         {
753           String   msg = Translate
754               .get("virtualdatabase.xml.requestmanager.creation.failed");
755           logger.error(msg, e);
756           throw new SAXException  (msg, e);
757         }
758       }
759       if (currentRequestScheduler != null)
760       {
761         try
762         {
763           MBeanServerManager.registerMBean(new AbstractSchedulerControl(
764               currentRequestScheduler), JmxConstants
765               .getAbstractSchedulerObjectName(currentVirtualDatabase
766                   .getVirtualDatabaseName()));
767         }
768         catch (Exception   e)
769         {
770           if (logger.isWarnEnabled())
771           {
772             logger
773                 .warn(
774                     Translate
775                         .get(
776                             "virtualdatabase.xml.scheduler.jmx.failed", currentVirtualDatabase.getVirtualDatabaseName()), e); //$NON-NLS-1$
777           }
778         }
779         if (currentParsingCache != null)
780         {
781           try
782           {
783             MBeanServerManager.registerMBean(new ParsingCacheControl(
784                 currentParsingCache), JmxConstants
785                 .getParsingCacheObjectName(currentVirtualDatabase
786                     .getVirtualDatabaseName()));
787           }
788           catch (Exception   e)
789           {
790             if (logger.isWarnEnabled())
791             {
792               logger
793                   .warn(
794                       Translate
795                           .get(
796                               "virtualdatabase.xml.parsing.cache.jmx.failed", currentVirtualDatabase.getVirtualDatabaseName()), e); //$NON-NLS-1$
797             }
798           }
799         }
800       }
801     }
802 
803     // Database backend
804     else if (name.equals(DatabasesXmlTags.ELT_DatabaseBackend))
805     {
806       if (currentBackend != null)
807       {
808         try
809         {
810           currentVirtualDatabase.addBackend(currentBackend, false);
811         }
812         catch (Exception   e)
813         {
814           String   msg = Translate.get("virtualdatabase.xml.backend.add.failed");
815           logger.error(msg, e);
816           throw new SAXException  (msg, e);
817         }
818       }
819       currentBackend = null;
820     }
821 
822     // Authentication manager
823     else if (name.equals(DatabasesXmlTags.ELT_AuthenticationManager))
824     {
825       if (currentVirtualDatabase != null)
826       {
827         currentVirtualDatabase
828             .setAuthenticationManager(currentAuthenticationManager);
829       }
830     }
831 
832     // Request cache
833     else if (name.equals(DatabasesXmlTags.ELT_RequestCache))
834     {
835       if (currentResultCache != null)
836       { // Set default result cache rule if missing
837         if (currentResultCache.getDefaultRule() == null)
838         {
839           ResultCacheRule defaultRule = null;
840           defaultRule = new ResultCacheRule("", false, false, 1000);
841           defaultRule.setCacheBehavior(new EagerCaching(0));
842           currentResultCache.setDefaultRule(defaultRule);
843         }
844       }
845     }
846     else if (name.equals(DatabasesXmlTags.ELT_DefaultResultCacheRule))
847     {
848       currentResultCache.setDefaultRule(currentResultCacheRule);
849     }
850 
851     // CreateTable rule
852     else if (name.equals(DatabasesXmlTags.ELT_CreateTable))
853     {
854       if (currentCreateTablePolicy != null)
855       {
856         if (logger.isDebugEnabled())
857           logger.debug(Translate.get("virtualdatabase.xml.create.table.add",
858               currentCreateTableRule.getInformation()));
859         currentCreateTablePolicy.addRule(currentCreateTableRule);
860       }
861     }
862 
863     else if (name.equals(DatabasesXmlTags.ELT_LoadBalancer))
864     {
865       if (logger.isDebugEnabled())
866         logger.debug(Translate.get(
867             "virtualdatabase.xml.loadbalancer.transaction.isolation.set",
868             defaultTransactionIsolation));
869 
870       currentLoadBalancer
871           .setDefaultTransactionIsolationLevel(defaultTransactionIsolation);
872     }
873 
874     // RAIDb-0 load balancer
875     else if (name.equals(DatabasesXmlTags.ELT_RAIDb_0))
876     {
877       if (logger.isDebugEnabled())
878         logger.debug(Translate
879             .get("virtualdatabase.xml.loadbalancer.raidb0.set"));
880 
881       if (currentCreateTablePolicy.getDefaultRule() == null)
882       {
883         if (logger.isDebugEnabled())
884           logger.debug(Translate
885               .get("virtualdatabase.xml.create.table.default"));
886         CreateTableRule rule = new CreateTableRoundRobin();
887         currentCreateTablePolicy.addRule(rule);
888       }
889       try
890       {
891         currentLoadBalancer = new RAIDb0(currentVirtualDatabase,
892             currentCreateTablePolicy);
893       }
894       catch (Exception   e)
895       {
896         String   msg = Translate
897             .get("virtualdatabase.xml.loadbalancer.raidb0.failed");
898         logger.error(msg, e);
899         throw new SAXException  (msg, e);
900       }
901     }
902 
903     // Recovery Log
904     else if (name.equals(DatabasesXmlTags.ELT_RecoveryLog)
905         || name.equals(DatabasesXmlTags.ELT_EmbeddedRecoveryLog))
906     {
907       if (logger.isDebugEnabled())
908         logger.debug(Translate
909             .get("virtualdatabase.xml.recoverylog.cheking.tables"));
910       try
911       {
912         currentRecoveryLog.checkRecoveryLogTables();
913       }
914       catch (Exception   e)
915       {
916         String   msg = Translate
917             .get("virtualdatabase.xml.recoverylog.cheking.tables.failed");
918         logger.error(msg, e);
919         throw new SAXException  (msg);
920       }
921       try
922       {
923         MBeanServerManager.registerMBean(new RecoveryLogControl(
924             currentRecoveryLog), JmxConstants
925             .getRecoveryLogObjectName(currentVirtualDatabase
926                 .getVirtualDatabaseName()));
927       }
928       catch (Exception   e)
929       {
930         if (logger.isWarnEnabled())
931         {
932           logger
933               .warn(
934                   Translate
935                       .get(
936                           "virtualdatabase.xml.recoverylog.jmx.failed", currentVirtualDatabase.getVirtualDatabaseName()), e); //$NON-NLS-1$
937         }
938       }
939     }
940 
941     // Semantic information
942     else if (name.equals(DatabasesXmlTags.ELT_RequestSemantic))
943       currentVirtualDatabase.getSemanticManager().addRequestSemantic(
944           (RequestSemantic) currentSemantic);
945     else if (name.equals(DatabasesXmlTags.ELT_DefaultStoredProcedureSemantic))
946       currentVirtualDatabase.getSemanticManager()
947           .setDefaultStoredProcedureSemantic(
948               (StoredProcedureSemantic) currentSemantic);
949     else if (name.equals(DatabasesXmlTags.ELT_StoredProcedureSemantic))
950       currentVirtualDatabase.getSemanticManager().addStoredProcedureSemantic(
951           (StoredProcedureSemantic) currentSemantic);
952     else if (name.equals(DatabasesXmlTags.ELT_TriggerSemantic))
953       currentVirtualDatabase.getSemanticManager().addTriggerSemantic(
954           (TriggerSemantic) currentSemantic);
955     // Views are added right away to the semantic manager
956   }
957 
958   /**
959    * Unregisters MBeans associated to the vdb.
960    */
961   private void unregisterRelatedMBeans(VirtualDatabase vdb)
962   {
963     try
964     {
965       MBeanServerManager.unregister(JmxConstants
966           .getVirtualDataBaseObjectName(vdb.getVirtualDatabaseName()));
967     }
968     catch (Exception   ee)
969     {
970     }
971     try
972     {
973       MBeanServerManager.unregister(JmxConstants
974           .getAbstractSchedulerObjectName(vdb.getVirtualDatabaseName()));
975     }
976     catch (Exception   ee)
977     {
978     }
979     try
980     {
981       MBeanServerManager.unregister(JmxConstants.getRecoveryLogObjectName(vdb
982           .getVirtualDatabaseName()));
983     }
984     catch (Exception   ee)
985     {
986     }
987     try
988     {
989       MBeanServerManager.unregister(JmxConstants.getLoadBalancerObjectName(vdb
990           .getVirtualDatabaseName()));
991     }
992     catch (Exception   ee)
993     {
994     }
995     try
996     {
997       MBeanServerManager.unregister(JmxConstants
998           .getRequestManagerObjectName(vdb.getVirtualDatabaseName()));
999     }
1000    catch (Exception   ee)
1001    {
1002    }
1003    try
1004    {
1005      MBeanServerManager.unregister(JmxConstants.getParsingCacheObjectName(vdb
1006          .getVirtualDatabaseName()));
1007    }
1008    catch (Exception   ee)
1009    {
1010    }
1011    List   backendNames = new ArrayList  ();
1012    try
1013    {
1014      backendNames = vdb.getAllBackendNames();
1015    }
1016    catch (VirtualDatabaseException ee)
1017    {
1018    }
1019    for (int i = 0; i < backendNames.size(); i++)
1020    {
1021      String   backendName = (String  ) backendNames.get(i);
1022      try
1023      {
1024        MBeanServerManager.unregister(JmxConstants
1025            .getDatabaseBackendObjectName(vdb.getVirtualDatabaseName(),
1026                backendName));
1027      }
1028      catch (Exception   ee)
1029      {
1030      }
1031    }
1032  }
1033
1034  /* Virtual database */
1035
1036  /**
1037   * Sets {@link #currentVirtualDatabase}as a new <code> VirtualDatabase
1038   * </code>
1039   * using the parsed attributes. An exception is thrown in particular if a
1040   * virtual database with the same name is already registered in the
1041   * controller.
1042   * 
1043   * @param atts parsed attributes
1044   * @exception SAXException if an error occurs
1045   */
1046  private void newVirtualDatabase(Attributes   atts) throws SAXException  
1047  {
1048    String   name = atts.getValue(DatabasesXmlTags.ATT_name);
1049    String   maxNbOfConnections = atts
1050        .getValue(DatabasesXmlTags.ATT_maxNbOfConnections);
1051    String   poolThreads = atts.getValue(DatabasesXmlTags.ATT_poolThreads);
1052    String   minNbOfThreads = atts.getValue(DatabasesXmlTags.ATT_minNbOfThreads);
1053    String   maxNbOfThreads = atts.getValue(DatabasesXmlTags.ATT_maxNbOfThreads);
1054    String   maxThreadIdleTime = atts
1055        .getValue(DatabasesXmlTags.ATT_maxThreadIdleTime);
1056    String   sqlDumpLength = atts.getValue(DatabasesXmlTags.ATT_sqlDumpLength);
1057    String   useStaticResultSetMetaData = atts
1058        .getValue(DatabasesXmlTags.ATT_useStaticResultSetMetaData);
1059
1060    if (controller.hasVirtualDatabase(name))
1061    {
1062      String   msg = Translate.get(
1063          "virtualdatabase.xml.virtualdatabase.already.exists", name);
1064      logger.error(msg);
1065      throw new SAXException  (msg);
1066    }
1067
1068    try
1069    {
1070      // Process the attributes
1071      int maxConnections = Integer.parseInt(maxNbOfConnections);
1072      boolean pool = poolThreads.equals(DatabasesXmlTags.VAL_true);
1073      int minThreads = Integer.parseInt(minNbOfThreads);
1074      int maxThreads = Integer.parseInt(maxNbOfThreads);
1075      // converts in ms
1076      long threadIdleTime = Long.parseLong(maxThreadIdleTime) * 1000L;
1077      int dumpLength = Integer.parseInt(sqlDumpLength);
1078      boolean staticMetadata = useStaticResultSetMetaData
1079          .equals(DatabasesXmlTags.VAL_true);
1080      if (logger.isDebugEnabled())
1081        logger.debug(Translate.get(
1082            "virtualdatabase.xml.virtualdatabase.create", name));
1083      currentVirtualDatabase = new VirtualDatabase(controller, name,
1084          maxConnections, pool, minThreads, maxThreads, threadIdleTime,
1085          dumpLength, staticMetadata);
1086      org.continuent.sequoia.controller.virtualdatabase.management.VirtualDatabase virtualDatabase = new org.continuent.sequoia.controller.virtualdatabase.management.VirtualDatabase(
1087          currentVirtualDatabase);
1088      ObjectName   objectName = JmxConstants.getVirtualDataBaseObjectName(name);
1089      MBeanServerManager.registerMBean(virtualDatabase, objectName);
1090      currentVirtualDatabase.setNotificationBroadcasterSupport(virtualDatabase
1091          .getBroadcaster());
1092
1093    }
1094    catch (Exception   e)
1095    {
1096      String   msg = Translate.get("virtualdatabase.xml.virtualdatabase.failed");
1097      logger.error(msg, e);
1098      throw new SAXException  (msg, e);
1099    }
1100  }
1101
1102  /* Distribution */
1103
1104  /**
1105   * Sets {@link #currentVirtualDatabase} as a new
1106   * <code>DistributedVirtalDatabase</code> using the parsed attributes.
1107   * 
1108   * @param atts parsed attributes
1109   */
1110  private void newDistribution(Attributes   atts) throws SAXException  
1111  {
1112    String   groupName = atts.getValue(DatabasesXmlTags.ATT_groupName);
1113    String   hederaPropertiesFile = atts
1114        .getValue(DatabasesXmlTags.ATT_hederaPropertiesFile);
1115    String   clientFailoverTimeoutString = atts
1116        .getValue(DatabasesXmlTags.ATT_clientFailoverTimeout);
1117
1118    if (groupName == null)
1119      groupName = currentVirtualDatabase.getVirtualDatabaseName();
1120
1121    long clientFailoverTimeout;
1122    try
1123    {
1124      clientFailoverTimeout = Long.parseLong(clientFailoverTimeoutString);
1125    }
1126    catch (NumberFormatException   e)
1127    {
1128      throw new SAXException  (
1129          "Invalid long value for clientFailoverTimeout in Distribution element");
1130    }
1131
1132    if (logger.isDebugEnabled())
1133      logger.debug(Translate.get(
1134          "virtualdatabase.xml.virtualdatabase.distributed.create",
1135          new String  []{currentVirtualDatabase.getVirtualDatabaseName(),
1136              groupName}));
1137    try
1138    {
1139      // we need to replace previous database mbean
1140      ObjectName   objectName = JmxConstants
1141          .getVirtualDataBaseObjectName(currentVirtualDatabase
1142              .getVirtualDatabaseName());
1143      MBeanServerManager.unregister(objectName);
1144
1145      // Create the distributed virtual database (does not join the group now)
1146      currentVirtualDatabase = new DistributedVirtualDatabase(controller,
1147          currentVirtualDatabase.getVirtualDatabaseName(), groupName,
1148          currentVirtualDatabase.getMaxNbOfConnections(),
1149          currentVirtualDatabase.isPoolConnectionThreads(),
1150          currentVirtualDatabase.getMinNbOfThreads(), currentVirtualDatabase
1151              .getMaxNbOfThreads(), currentVirtualDatabase
1152              .getMaxThreadIdleTime(), currentVirtualDatabase
1153              .getSqlShortFormLength(), clientFailoverTimeout,
1154          currentVirtualDatabase.useStaticResultSetMetaData(),
1155          hederaPropertiesFile);
1156      org.continuent.sequoia.controller.virtualdatabase.management.VirtualDatabase virtualDatabase = new org.continuent.sequoia.controller.virtualdatabase.management.VirtualDatabase(
1157          currentVirtualDatabase);
1158      MBeanServerManager.registerMBean(virtualDatabase, objectName);
1159      currentVirtualDatabase.setNotificationBroadcasterSupport(virtualDatabase
1160          .getBroadcaster());
1161    }
1162    catch (Exception   e)
1163    {
1164      String   msg = Translate
1165          .get("virtualdatabase.xml.virtualdatabase.distributed.failed");
1166      logger.error(msg, e);
1167      throw new SAXException  (msg, e);
1168    }
1169  }
1170
1171  /**
1172   * Sets a new <code>MessageTimeouts</code> to the current distributed
1173   * virtual database.
1174   * 
1175   * @param atts parsed attributes
1176   */
1177  private void newMessageTimeouts(Attributes   atts)
1178  {
1179    MessageTimeouts messageTimeouts = new MessageTimeouts(getTimeout(atts
1180        .getValue(DatabasesXmlTags.ATT_defaultTimeout)));
1181
1182    messageTimeouts.setBackendStatusTimeout(getTimeout(atts
1183        .getValue(DatabasesXmlTags.ATT_backendStatusTimeout)));
1184    messageTimeouts.setBackendTransferTimeout(getTimeout(atts
1185        .getValue(DatabasesXmlTags.ATT_backendTransferTimeout)));
1186    messageTimeouts.setCacheInvalidateTimeout(getTimeout(atts
1187        .getValue(DatabasesXmlTags.ATT_cacheInvalidateTimeout)));
1188    messageTimeouts.setCommitTimeout(getTimeout(atts
1189        .getValue(DatabasesXmlTags.ATT_commitTimeout)));
1190    messageTimeouts.setControllerNameTimeout(getTimeout(atts
1191        .getValue(DatabasesXmlTags.ATT_controllerNameTimeout)));
1192    messageTimeouts.setCopyLogEntryTimeout(getTimeout(atts
1193        .getValue(DatabasesXmlTags.ATT_copyLogEntryTimeout)));
1194    messageTimeouts.setDisableBackendTimeout(getTimeout(atts
1195        .getValue(DatabasesXmlTags.ATT_disableBackendTimeout)));
1196    messageTimeouts.setEnableBackendTimeout(getTimeout(atts
1197        .getValue(DatabasesXmlTags.ATT_enableBackendTimeout)));
1198    messageTimeouts.setExecReadRequestTimeout(getTimeout(atts
1199        .getValue(DatabasesXmlTags.ATT_execReadRequestTimeout)));
1200    messageTimeouts.setExecReadStoredProcedureTimeout(getTimeout(atts
1201        .getValue(DatabasesXmlTags.ATT_execReadStoredProcedureTimeout)));
1202    messageTimeouts.setExecWriteRequestTimeout(getTimeout(atts
1203        .getValue(DatabasesXmlTags.ATT_execWriteRequestTimeout)));
1204    messageTimeouts.setExecWriteRequestWithKeysTimeout(getTimeout(atts
1205        .getValue(DatabasesXmlTags.ATT_execWriteRequestWithKeysTimeout)));
1206    messageTimeouts.setExecWriteStoredProcedureTimeout(getTimeout(atts
1207        .getValue(DatabasesXmlTags.ATT_execWriteStoredProcedureTimeout)));
1208    messageTimeouts.setInitiateDumpCopyTimeout(getTimeout(atts
1209        .getValue(DatabasesXmlTags.ATT_initiateDumpCopyTimeout)));
1210    messageTimeouts.setNotifyCompletionTimeout(getTimeout(atts
1211        .getValue(DatabasesXmlTags.ATT_notifyCompletionTimeout)));
1212    messageTimeouts.setReleaseSavepointTimeout(getTimeout(atts
1213        .getValue(DatabasesXmlTags.ATT_releaseSavepointTimeout)));
1214    messageTimeouts.setReplicateLogEntriesTimeout(getTimeout(atts
1215        .getValue(DatabasesXmlTags.ATT_replicateLogEntriesTimeout)));
1216    messageTimeouts.setRollbackTimeout(getTimeout(atts
1217        .getValue(DatabasesXmlTags.ATT_rollbackTimeout)));
1218    messageTimeouts.setRollbackToSavepointTimeout(getTimeout(atts
1219        .getValue(DatabasesXmlTags.ATT_rollbackToSavepointTimeout)));
1220    messageTimeouts.setSetCheckpointTimeout(getTimeout(atts
1221        .getValue(DatabasesXmlTags.ATT_setCheckpointTimeout)));
1222    messageTimeouts.setSetSavepointTimeout(getTimeout(atts
1223        .getValue(DatabasesXmlTags.ATT_setSavepointTimeout)));
1224    messageTimeouts.setUnlogCommitTimeout(getTimeout(atts
1225        .getValue(DatabasesXmlTags.ATT_unlogCommitTimeout)));
1226    messageTimeouts.setUnlogRequestTimeout(getTimeout(atts
1227        .getValue(DatabasesXmlTags.ATT_unlogRequestTimeout)));
1228    messageTimeouts.setUnlogRollbackTimeout(getTimeout(atts
1229        .getValue(DatabasesXmlTags.ATT_unlogRollbackTimeout)));
1230    messageTimeouts.setVirtualDatabaseConfigurationTimeout(getTimeout(atts
1231        .getValue(DatabasesXmlTags.ATT_virtualDatabaseConfigurationTimeout)));
1232
1233    // Set the message timeouts
1234    ((DistributedVirtualDatabase) currentVirtualDatabase)
1235        .setMessageTimeouts(messageTimeouts);
1236  }
1237
1238  private static final int DEFAULT_TIMEOUT = 0;
1239
1240  private long getTimeout(String   timeoutAsString)
1241  {
1242    if (timeoutAsString == null)
1243      return DEFAULT_TIMEOUT;
1244    long timeout;
1245    try
1246    {
1247      timeout = Long.parseLong(timeoutAsString);
1248    }
1249    catch (NumberFormatException   e1)
1250    {
1251      timeout = DEFAULT_TIMEOUT; // Default is no timeout
1252    }
1253    return timeout;
1254  }
1255
1256  //
1257  // Monitoring
1258  //
1259
1260  /**
1261   * Sets a new <code>SQLMonitoring</code> to the current virtual database.
1262   * 
1263   * @param atts parsed attributes
1264   */
1265  private void newSQLMonitoring(Attributes   atts)
1266  {
1267    String   monitoringString = atts
1268        .getValue(DatabasesXmlTags.ATT_defaultMonitoring);
1269    boolean monitoring;
1270    if (monitoringString != null)
1271      monitoring = monitoringString.equals(DatabasesXmlTags.VAL_on);
1272    else
1273      monitoring = false;
1274
1275    SQLMonitoring sqlMonitor = new SQLMonitoring(currentVirtualDatabase
1276        .getVirtualDatabaseName());
1277    sqlMonitor.setDefaultRule(monitoring);
1278    currentVirtualDatabase.setSQLMonitor(sqlMonitor);
1279  }
1280
1281  /**
1282   * Add a new <code>SQLMonitoringRule</code> to the current SQL monitor.
1283   * 
1284   * @param atts parsed attributes
1285   */
1286  private void newSQLMonitoringRule(Attributes   atts)
1287  {
1288    String   queryPattern = atts.getValue(DatabasesXmlTags.ATT_queryPattern);
1289    String   caseSensitiveString = atts
1290        .getValue(DatabasesXmlTags.ATT_caseSensitive);
1291    String   applyToSkeletonString = atts
1292        .getValue(DatabasesXmlTags.ATT_applyToSkeleton);
1293    String   monitoringString = atts.getValue(DatabasesXmlTags.ATT_monitoring);
1294
1295    boolean caseSensitive;
1296    if (caseSensitiveString != null)
1297      caseSensitive = caseSensitiveString.equals(DatabasesXmlTags.VAL_true);
1298    else
1299      caseSensitive = false;
1300    boolean applyToSkeleton;
1301    if (applyToSkeletonString != null)
1302      applyToSkeleton = applyToSkeletonString.equals(DatabasesXmlTags.VAL_true);
1303    else
1304      applyToSkeleton = false;
1305    boolean monitoring;
1306    if (monitoringString != null)
1307      monitoring = monitoringString.equals(DatabasesXmlTags.VAL_on);
1308    else
1309      monitoring = false;
1310
1311    // Create the rule and add it
1312    SQLMonitoringRule rule = new SQLMonitoringRule(queryPattern, caseSensitive,
1313        applyToSkeleton, monitoring);
1314
1315    if (logger.isDebugEnabled())
1316      logger.debug(Translate.get("virtualdatabase.xml.sqlmonitoring.rule.add",
1317          new String  []{queryPattern, String.valueOf(caseSensitive),
1318              applyToSkeletonString, String.valueOf(monitoring)}));
1319    currentVirtualDatabase.getSQLMonitor().addRule(rule);
1320  }
1321
1322  //
1323  // Backup
1324  //
1325
1326  /**
1327   * Adds a new <code>BackupManager</code>
1328   */
1329  private void newBackupManager()
1330  {
1331    currentBackupManager = new BackupManager();
1332  }
1333
1334  /**
1335   * Adds a new <code>Backuper</code> to the currentBackupManager
1336   * 
1337   * @param atts parsed attributes
1338   */
1339  private void newBackuper(Attributes   atts)
1340  {
1341    String   name = atts.getValue(DatabasesXmlTags.ATT_backuperName);
1342    String   className = atts.getValue(DatabasesXmlTags.ATT_className);
1343    String   options = atts.getValue(DatabasesXmlTags.ATT_options);
1344
1345    Backuper backuper = null;
1346    try
1347    {
1348      backuper = (Backuper) Class.forName(className).newInstance();
1349      backuper.setOptions(options);
1350    }
1351    catch (Exception   e)
1352    {
1353      String   msg = "Failed to load backuper " + name + " from class "
1354          + className + " (" + e + ")";
1355      if (logger.isDebugEnabled())
1356        logger.error(msg, e);
1357      else
1358        logger.error(e);
1359      return;
1360    }
1361
1362    try
1363    {
1364      currentBackupManager.registerBackuper(name, backuper);
1365    }
1366    catch (BackupException e)
1367    {
1368      logger.error("Failed to load backuper" + name + "(" + e + ")");
1369    }
1370  }
1371
1372  //
1373  // Database backend
1374  //
1375
1376  /**
1377   * Sets {@link #currentBackend}as a new <code> DatabaseBackend</code> using
1378   * the parsed attributes.
1379   * 
1380   * @param atts parsed attributes
1381   * @throws SAXException
1382   */
1383  private void newDatabaseBackend(Attributes   atts) throws SAXException  
1384  {
1385    String   name = atts.getValue(DatabasesXmlTags.ATT_name);
1386    String   driverClassName = atts.getValue(DatabasesXmlTags.ATT_driver);
1387    String   driverPath = atts.getValue(DatabasesXmlTags.ATT_driverPath);
1388    String   url = atts.getValue(DatabasesXmlTags.ATT_url);
1389    String   connectionTestStatement = atts
1390        .getValue(DatabasesXmlTags.ATT_connectionTestStatement);
1391    String   nbOfWorkerThreadsString = atts
1392        .getValue(DatabasesXmlTags.ATT_nbOfBackendWorkerThreads);
1393
1394    int nbOfWorkerThreads;
1395    try
1396    {
1397      nbOfWorkerThreads = Integer.parseInt(nbOfWorkerThreadsString);
1398    }
1399    catch (Exception   e)
1400    {
1401      String   msg = Translate.get("virtualdatabase.xml.virtualdatabase.failed");
1402      logger.error(msg, e);
1403      throw new SAXException  (msg, e);
1404    }
1405
1406    if (logger.isDebugEnabled())
1407    {
1408      logger.debug(Translate.get("virtualdatabase.xml.backend.create",
1409          new String  []{name, driverClassName, url, connectionTestStatement}));
1410      if (driverPath == null)
1411      {
1412        logger.debug("no driver path defined for backend.");
1413      }
1414      else
1415      {
1416        logger.debug("using driver path " + driverPath);
1417      }
1418    }
1419    currentBackend = new DatabaseBackend(currentVirtualDatabase, name,
1420        driverPath, driverClassName, url, true, connectionTestStatement,
1421        nbOfWorkerThreads);
1422  }
1423
1424  /**
1425   * Adds a <code>AbstractRewritingRule</code> to the current DatabaseBackend.
1426   * 
1427   * @param atts parsed attributes
1428   */
1429  private void newRewritingRule(Attributes   atts) throws SAXException  
1430  {
1431    String   queryPattern = atts.getValue(DatabasesXmlTags.ATT_queryPattern);
1432    String   rewrite = atts.getValue(DatabasesXmlTags.ATT_rewrite);
1433    String   matchingType = atts.getValue(DatabasesXmlTags.ATT_matchingType);
1434    String   caseSensitiveString = atts
1435        .getValue(DatabasesXmlTags.ATT_caseSensitive);
1436    String   stopOnMatchString = atts.getValue(DatabasesXmlTags.ATT_stopOnMatch);
1437
1438    boolean caseSensitive;
1439    if (caseSensitiveString != null)
1440      caseSensitive = caseSensitiveString.equals(DatabasesXmlTags.VAL_true);
1441    else
1442      caseSensitive = false;
1443    boolean stopOnMatch;
1444    if (stopOnMatchString != null)
1445      stopOnMatch = stopOnMatchString.equals(DatabasesXmlTags.VAL_true);
1446    else
1447      stopOnMatch = false;
1448
1449    // Create the rule and add it
1450    AbstractRewritingRule rule;
1451    if (matchingType.equals(DatabasesXmlTags.VAL_simple))
1452      rule = new SimpleRewritingRule(queryPattern, rewrite, caseSensitive,
1453          stopOnMatch);
1454    else if (matchingType.equals(DatabasesXmlTags.VAL_pattern))
1455      rule = new PatternRewritingRule(queryPattern, rewrite, caseSensitive,
1456          stopOnMatch);
1457    else if (matchingType.equals(DatabasesXmlTags.VAL_replaceAll))
1458      rule = new ReplaceAllRewritingRule(queryPattern, rewrite, caseSensitive,
1459          stopOnMatch);
1460    else
1461      throw new SAXException  (Translate.get(
1462          "virtualdatabase.xml.rewritingrule.unsupported.matching",
1463          matchingType));
1464
1465    if (logger.isDebugEnabled())
1466      logger.debug(Translate.get("virtualdatabase.xml.rewritingrule.add",
1467          new String  []{queryPattern, rewrite, String.valueOf(caseSensitive),
1468              String.valueOf(stopOnMatch)}));
1469    currentBackend.addRewritingRule(rule);
1470  }
1471
1472  /* Authentication manager */
1473
1474  /**
1475   * Sets {@link #currentAuthenticationManager}as a new <code>
1476   * AuthenticationManager</code>.
1477   */
1478  private void newAuthenticationManager(Attributes   atts)
1479  {
1480    String   transparentLogin = atts
1481        .getValue(DatabasesXmlTags.ATT_transparentLogin);
1482    currentAuthenticationManager = new AuthenticationManager(transparentLogin
1483        .equals(DatabasesXmlTags.VAL_on));
1484  }
1485
1486  /**
1487   * Sets the administrator user of the {@link #currentAuthenticationManager}
1488   * using the parsed attributs.
1489   * 
1490   * @param atts parsed attributes
1491   */
1492  private void newAdminUser(Attributes   atts)
1493  {
1494    String   aLogin = atts.getValue(DatabasesXmlTags.ATT_username);
1495    String   aPassword = atts.getValue(DatabasesXmlTags.ATT_password);
1496
1497    if (logger.isDebugEnabled())
1498      logger.debug(Translate.get(
1499          "virtualdatabase.xml.authentication.login.admin.add", new String  []{
1500              aLogin, aPassword}));
1501    currentUser = new AdminUser(aLogin, aPassword);
1502    currentAuthenticationManager.addAdminUser((AdminUser) currentUser);
1503  }
1504
1505  /**
1506   * Sets {@link #currentUser}as a new <code> VirtualDatabaseUser
1507   * </code> using
1508   * the parsed attributes and adds this new virtual database user to the
1509   * {@link #currentAuthenticationManager}.
1510   * 
1511   * @param atts parsed attributes
1512   */
1513  private void newVirtualUser(Attributes   atts)
1514  {
1515    String   vLogin = atts.getValue(DatabasesXmlTags.ATT_vLogin);
1516    String   vPassword = atts.getValue(DatabasesXmlTags.ATT_vPassword);
1517    currentUser = new VirtualDatabaseUser(vLogin, vPassword);
1518
1519    if (logger.isDebugEnabled())
1520      logger.debug(Translate.get(
1521          "virtualdatabase.xml.authentication.login.virtual.add", new String  []{
1522              vLogin, vPassword}));
1523    currentAuthenticationManager
1524        .addVirtualUser((VirtualDatabaseUser) currentUser);
1525  }
1526
1527  /*
1528   * Access control
1529   */
1530
1531  /**
1532   * Adds a new AccessControl rule to the current user using the parsed
1533   * attributed.
1534   * 
1535   * @param atts element attributes
1536   */
1537  private void newAccessControl(Attributes   atts)
1538  {
1539    currentAccessControl = new AccessControl(DatabasesXmlTags.VAL_true
1540        .equals(atts.getValue(DatabasesXmlTags.ATT_defaultPolicy)));
1541    currentUser.setAccessControl(currentAccessControl);
1542  }
1543
1544  /**
1545   * Adds a new AccessControlRule to the current access control to accept a
1546   * connection from the parsed address.
1547   * 
1548   * @param atts element attributes
1549   */
1550  private void newAccept(Attributes   atts)
1551  {
1552    AccessControlRule rule = new AccessControlRule(true, atts
1553        .getValue(DatabasesXmlTags.ATT_address));
1554    currentAccessControl.addAccessControlRule(rule);
1555  }
1556
1557  /**
1558   * Adds a new AccessControlRule to the current access control to deny a
1559   * connection from the parsed address.
1560   * 
1561   * @param atts element attributes
1562   */
1563  private void newDeny(Attributes   atts)
1564  {
1565    AccessControlRule rule = new AccessControlRule(false, atts
1566        .getValue(DatabasesXmlTags.ATT_address));
1567    currentAccessControl.addAccessControlRule(rule);
1568  }
1569
1570  //
1571  // Request manager
1572  //
1573
1574  /**
1575   * Sets the {@link #beginTimeout},{@link #commitTimeout}and
1576   * {@link #rollbackTimeout}timeouts (in ms) using the parsed attributes.
1577   * 
1578   * @param atts element attributes
1579   * @exception SAXException if an error occurs
1580   */
1581  private void newRequestManager(Attributes   atts) throws SAXException  
1582  {
1583    try
1584    {
1585      String   begin = atts.getValue(DatabasesXmlTags.ATT_beginTimeout);
1586      String   commit = atts.getValue(DatabasesXmlTags.ATT_commitTimeout);
1587      String   rollback = atts.getValue(DatabasesXmlTags.ATT_rollbackTimeout);
1588      String   caseSensitiveParsingString = atts
1589          .getValue(DatabasesXmlTags.ATT_caseSensitiveParsing);
1590
1591      // Convert to ms
1592      beginTimeout = Long.parseLong(begin) * 1000L;
1593      commitTimeout = Long.parseLong(commit) * 1000L;
1594      rollbackTimeout = Long.parseLong(rollback) * 1000L;
1595
1596      if (caseSensitiveParsingString != null)
1597        caseSensitiveParsing = caseSensitiveParsingString
1598            .equals(DatabasesXmlTags.VAL_true);
1599      else
1600        caseSensitiveParsing = false;
1601
1602      if (logger.isDebugEnabled())
1603        logger.debug(Translate.get(
1604            "virtualdatabase.xml.requestmanager.parameters", new String  []{
1605                String.valueOf(beginTimeout), String.valueOf(commitTimeout),
1606                String.valueOf(rollbackTimeout)}));
1607    }
1608    catch (NumberFormatException   e)
1609    {
1610      String   msg = Translate
1611          .get("virtualdatabase.xml.requestmanager.timeout.failed");
1612      logger.error(msg, e);
1613      throw new SAXException  (msg, e);
1614    }
1615  }
1616
1617  /* Macro Handling */
1618
1619  /**
1620   * Adds a new <code>MacrosHandler</code> using the parsed attributes.
1621   * 
1622   * @param atts parsed attributes
1623   */
1624  private void newMacroHandler(Attributes   atts)
1625  {
1626    currentMacroHandler = new MacrosHandler();
1627  }
1628
1629  /**
1630   * Adds a new <code>DateMacro</code> to the current macro handler using the
1631   * parsed attributes.
1632   * 
1633   * @param atts parsed attributes
1634   */
1635  private void newDateMacro(Attributes   atts)
1636  {
1637    try
1638    {
1639      String   macroName = atts.getValue(DatabasesXmlTags.ATT_macroName);
1640      String   dateFormat = atts.getValue(DatabasesXmlTags.ATT_dateFormat);
1641      int iFormat = DateMacro.getDateFormat(dateFormat);
1642      String   timeResolution = atts
1643          .getValue(DatabasesXmlTags.ATT_timeResolution);
1644      long ltimeResolution = Long.parseLong(timeResolution);
1645      DateMacro macro = new DateMacro(macroName, iFormat, ltimeResolution);
1646      currentMacroHandler.addMacro(macro);
1647    }
1648    catch (RuntimeException   e)
1649    {
1650      logger.warn(Translate.get(
1651          "virtualdatabase.xml.invalid.macroshandler.settings", e));
1652    }
1653  }
1654
1655  /**
1656   * Adds a new <code>RandomMacro</code> to the current macro handler using
1657   * the parsed attributes.
1658   * 
1659   * @param atts parsed attributes
1660   */
1661  private void newRandomMacro(Attributes   atts)
1662  {
1663    try
1664    {
1665      String   macroName = atts.getValue(DatabasesXmlTags.ATT_macroName);
1666      String   numberFormat = atts.getValue(DatabasesXmlTags.ATT_numberFormat);
1667      int iFormat = RandomMacro.getRandNumberFormat(numberFormat);
1668      RandomMacro macro = new RandomMacro(macroName, iFormat);
1669      currentMacroHandler.addMacro(macro);
1670    }
1671    catch (RuntimeException   e)
1672    {
1673      logger.warn(Translate.get(
1674          "virtualdatabase.xml.invalid.macroshandler.settings", e));
1675    }
1676  }
1677
1678  /* Request scheduler */
1679
1680  /**
1681   * Sets {@link #currentRequestScheduler}as a new <code>
1682   * SingleDBPassThroughScheduler</code>
1683   * using the parsed attributes.
1684   * 
1685   * @param atts parsed attributes
1686   * @exception SAXException if an error occurs
1687   */
1688  private void newSingleDBScheduler(Attributes   atts) throws SAXException  
1689  {
1690    String   level = atts.getValue(DatabasesXmlTags.ATT_level);
1691
1692    // SingleDB Query Level
1693    if (level.equals(DatabasesXmlTags.VAL_passThrough))
1694    {
1695      if (logger.isDebugEnabled())
1696        logger.debug(Translate
1697            .get("virtualdatabase.xml.scheduler.singledb.create.passthrough"));
1698      currentRequestScheduler = new SingleDBPassThroughScheduler();
1699    }
1700
1701    // SingleDB Pessimistic Transaction Level
1702    else if (level.equals(DatabasesXmlTags.VAL_pessimisticTransaction))
1703    {
1704      if (logger.isDebugEnabled())
1705        logger.debug(Translate
1706            .get("virtualdatabase.xml.scheduler.singledb.create.pessimistic"));
1707      currentRequestScheduler = new SingleDBPessimisticTransactionLevelScheduler();
1708    }
1709    else
1710    {
1711      throw new SAXException  (Translate.get(
1712          "virtualdatabase.xml.scheduler.singledb.unsupported", level));
1713    }
1714  }
1715
1716  /**
1717   * Sets {@link #currentRequestScheduler}as a new <code>
1718   * RAIDb0PassThroughLevelScheduler</code>
1719   * or <code>RAIDb0PessimisticTransactionLevelScheduler</code> using the
1720   * parsed attributes.
1721   * 
1722   * @param atts parsed attributes
1723   * @exception SAXException if an error occurs
1724   */
1725  private void newRAIDb0Scheduler(Attributes   atts) throws SAXException  
1726  {
1727    String   level = atts.getValue(DatabasesXmlTags.ATT_level);
1728
1729    if (level.equals(DatabasesXmlTags.VAL_passThrough))
1730    {
1731      if (logger.isDebugEnabled())
1732        logger.debug(Translate
1733            .get("virtualdatabase.xml.scheduler.raidb0.create.passthrough"));
1734      currentRequestScheduler = new RAIDb0PassThroughLevelScheduler();
1735    }
1736    else if (level.equals(DatabasesXmlTags.VAL_pessimisticTransaction))
1737    {
1738      if (logger.isDebugEnabled())
1739        logger.debug(Translate
1740            .get("virtualdatabase.xml.scheduler.raidb0.create.pessimistic"));
1741      currentRequestScheduler = new RAIDb0PessimisticTransactionLevelScheduler();
1742    }
1743    else
1744      throw new SAXException  (Translate.get(
1745          "virtualdatabase.xml.scheduler.raidb0.unsupported", level));
1746  }
1747
1748  /**
1749   * Sets {@link #currentRequestScheduler}as a new
1750   * <code>RAIDb1PassThroughScheduler</code>,<code>
1751   * RAIDb1QueryLevelScheduler</code>,
1752   * <code>RAIDb1OptimisticQueryLevelScheduler</code> or
1753   * <code>RAIDb1PessimisticTransactionLevelScheduler</code> using the parsed
1754   * attributes.
1755   * 
1756   * @param atts parsed attributes
1757   * @exception SAXException if an error occurs
1758   */
1759  private void newRAIDb1Scheduler(Attributes   atts) throws SAXException  
1760  {
1761    String   level = atts.getValue(DatabasesXmlTags.ATT_level);
1762
1763    // RAIDb-1 Pass Through level
1764    if (level.equals(DatabasesXmlTags.VAL_passThrough))
1765    {
1766      if (logger.isDebugEnabled())
1767        logger.debug(Translate
1768            .get("virtualdatabase.xml.scheduler.raidb1.create.passthrough"));
1769      currentRequestScheduler = new RAIDb1PassThroughScheduler(
1770          currentVirtualDatabase);
1771    }
1772    else
1773    {
1774      throw new SAXException  (Translate.get(
1775          "virtualdatabase.xml.scheduler.raidb1.unsupported", level));
1776    }
1777  }
1778
1779  /**
1780   * Sets {@link #currentRequestScheduler}as a new
1781   * <code>RAIDb2PassThroughScheduler</code>,<code>
1782   * RAIDb2QueryLevelScheduler</code>
1783   * or <code>RAIDb2PessimisticTransactionLevelScheduler</code> using the
1784   * parsed attributes.
1785   * 
1786   * @param atts parsed attributes
1787   * @exception SAXException if an error occurs
1788   */
1789  private void newRAIDb2Scheduler(Attributes   atts) throws SAXException  
1790  {
1791    String   level = atts.getValue(DatabasesXmlTags.ATT_level);
1792
1793    // RAIDb-2 Pass-through
1794    if (level.equals(DatabasesXmlTags.VAL_passThrough))
1795    {
1796      if (logger.isDebugEnabled())
1797        logger.debug(Translate
1798            .get("virtualdatabase.xml.scheduler.raidb2.create.passthrough"));
1799      currentRequestScheduler = new RAIDb2PassThroughScheduler(
1800          currentVirtualDatabase);
1801    }
1802    else
1803    {
1804      throw new SAXException  (Translate.get(
1805          "virtualdatabase.xml.scheduler.raidb2.unsupported", level));
1806    }
1807  }
1808
1809  /* ********************** */
1810  /* *** Request caches *** */
1811  /* ********************** */
1812
1813  /**
1814   * Sets {@link #currentMetadataCache}as a new <code>MetadataCache</code>
1815   * using the parsed attributes.
1816   * 
1817   * @param atts parsed attributes
1818   * @exception SAXException if an error occurs
1819   */
1820  private void newMetadataCache(Attributes   atts) throws SAXException  
1821  {
1822    try
1823    {
1824      int maxMetadata = Integer.parseInt(atts
1825          .getValue(DatabasesXmlTags.ATT_maxNbOfMetadata));
1826      int maxField = Integer.parseInt(atts
1827          .getValue(DatabasesXmlTags.ATT_maxNbOfField));
1828      currentMetadataCache = new MetadataCache(maxMetadata, maxField);
1829    }
1830    catch (Exception   e)
1831    {
1832      String   msg = Translate.get(
1833          "virtualdatabase.xml.metadata.cache.create.failed", e);
1834      logger.error(msg, e);
1835      throw new SAXException  (msg, e);
1836    }
1837  }
1838
1839  /**
1840   * Sets {@link #currentParsingCache}as a new <code>ParsingCache</code>
1841   * using the parsed attributes.
1842   * 
1843   * @param atts parsed attributes
1844   * @exception SAXException if an error occurs
1845   */
1846  private void newParsingCache(Attributes   atts) throws SAXException  
1847  {
1848    String   backgroundParsingString = atts
1849        .getValue(DatabasesXmlTags.ATT_backgroundParsing);
1850    boolean backgroundParsing;
1851
1852    if (backgroundParsingString != null)
1853      backgroundParsing = backgroundParsingString
1854          .equals(DatabasesXmlTags.VAL_true);
1855    else
1856      backgroundParsing = false;
1857
1858    String   maxEntriesString = atts
1859        .getValue(DatabasesXmlTags.ATT_maxNbOfEntries);
1860    int maxEntries = Integer.parseInt(maxEntriesString);
1861
1862    try
1863    {
1864      currentParsingCache = new ParsingCache(currentVirtualDatabase
1865          .getSemanticManager(), maxEntries, backgroundParsing);
1866    }
1867    catch (Exception   e)
1868    {
1869      String   msg = Translate.get(
1870          "virtualdatabase.xml.parsing.cache.create.failed", e);
1871      logger.error(msg, e);
1872      throw new SAXException  (msg, e);
1873    }
1874  }
1875
1876  /**
1877   * Sets {@link #currentResultCache}as a new <code> ResultCache</code> using
1878   * the parsed attributes.
1879   * 
1880   * @param atts parsed attributes
1881   * @exception SAXException if an error occurs
1882   */
1883  private void newResultCache(Attributes   atts) throws SAXException  
1884  {
1885    String   granularity = atts.getValue(DatabasesXmlTags.ATT_granularity);
1886    String   maxEntriesString = atts
1887        .getValue(DatabasesXmlTags.ATT_maxNbOfEntries);
1888    String   pendingTimeoutString = atts
1889        .getValue(DatabasesXmlTags.ATT_pendingTimeout);
1890
1891    if (logger.isDebugEnabled())
1892      logger.debug(Translate.get("virtualdatabase.xml.cache.create",
1893          granularity));
1894
1895    try
1896    {
1897      int maxEntries = Integer.parseInt(maxEntriesString);
1898      int pendingTimeout = Integer.parseInt(pendingTimeoutString);
1899
1900      int granularityValue;
1901      if (granularity.equals(DatabasesXmlTags.VAL_table))
1902        granularityValue = CachingGranularities.TABLE;
1903      else if (granularity.equals(DatabasesXmlTags.VAL_database))
1904        granularityValue = CachingGranularities.DATABASE;
1905      else if (granularity.equals(DatabasesXmlTags.VAL_column))
1906        granularityValue = CachingGranularities.COLUMN;
1907      else if (granularity.equals(DatabasesXmlTags.VAL_columnUnique))
1908        granularityValue = CachingGranularities.COLUMN_UNIQUE;
1909      else
1910        throw new InstantiationException  (Translate.get(
1911            "virtualdatabase.xml.cache.unsupported", granularity));
1912
1913      currentResultCache = ResultCacheFactory.getCacheInstance(
1914          granularityValue, maxEntries, pendingTimeout);
1915
1916    }
1917    catch (Exception   e)
1918    {
1919      String   msg = Translate.get("virtualdatabase.xml.cache.create.failed",
1920          granularity);
1921      logger.error(msg, e);
1922      throw new SAXException  (msg, e);
1923    }
1924  }
1925
1926  /**
1927   * Add a new <code>ResultCacheRule</code> using the parsed attributes.
1928   * 
1929   * @param atts parsed attributes
1930   */
1931  private void newResultCacheRule(Attributes   atts)
1932  {
1933    String   queryString = atts.getValue(DatabasesXmlTags.ATT_queryPattern);
1934
1935    String   caseSensitiveString = atts
1936        .getValue(DatabasesXmlTags.ATT_caseSensitive);
1937    String   applyToSkeletonString = atts
1938        .getValue(DatabasesXmlTags.ATT_applyToSkeleton);
1939    long timestampResolution;
1940    try
1941    {
1942      timestampResolution = Long.parseLong(atts
1943          .getValue(DatabasesXmlTags.ATT_timestampResolution));
1944      timestampResolution *= 1000;
1945    }
1946    catch (Exception   e)
1947    {
1948      logger
1949          .warn(Translate.get("virtualdatabase.invalid.timestamp.resolution"));
1950      timestampResolution = 1000;
1951    }
1952
1953    boolean caseSensitive;
1954    if (caseSensitiveString != null)
1955      caseSensitive = caseSensitiveString.equals(DatabasesXmlTags.VAL_true);
1956    else
1957      caseSensitive = false;
1958    boolean applyToSkeleton;
1959    if (applyToSkeletonString != null)
1960      applyToSkeleton = applyToSkeletonString.equals(DatabasesXmlTags.VAL_true);
1961    else
1962      applyToSkeleton = false;
1963
1964    // Create the rule
1965    currentResultCacheRule = new ResultCacheRule(queryString, caseSensitive,
1966        applyToSkeleton, timestampResolution);
1967
1968    if (logger.isDebugEnabled())
1969      logger.debug(Translate.get("virtualdatabase.xml.cache.rule.add",
1970          new String  []{atts.getValue(DatabasesXmlTags.ATT_queryPattern),
1971              String.valueOf(caseSensitive), applyToSkeletonString,
1972              String.valueOf(timestampResolution)}));
1973    currentResultCache.addCachingRule(currentResultCacheRule);
1974  }
1975
1976  /**
1977   * Set the <code>DefaultResultCacheRule</code> using the parsed attributes.
1978   * 
1979   * @param atts parsed attributes
1980   */
1981  private void newDefaultResultCacheRule(Attributes   atts)
1982  {
1983    long currentTimestampResolution;
1984    try
1985    {
1986      currentTimestampResolution = Long.parseLong(atts
1987          .getValue(DatabasesXmlTags.ATT_timestampResolution)) / 1000;
1988    }
1989    catch (Exception   e)
1990    {
1991      String   msg = Translate
1992          .get("virtualdatabase.invalid.timestamp.resolution");
1993      logger.warn(msg);
1994      currentTimestampResolution = 1000;
1995    }
1996    // Create a fake rule
1997    currentResultCacheRule = new ResultCacheRule("", false, false,
1998        currentTimestampResolution);
1999  }
2000
2001  /**
2002   * Add a new <code>EagerCaching</code> behavior to the current
2003   * <code>ResultCacheRule</code>.
2004   * 
2005   * @param atts parsed attributes
2006   * @exception SAXException if an error occurs
2007   */
2008  private void newEagerCaching(Attributes   atts)
2009  {
2010    Hashtable   options = new Hashtable  ();
2011    for (int i = 0; i < atts.getLength(); i++)
2012      options.put(atts.getQName(i), atts.getValue(i));
2013    currentResultCacheRule.setCacheBehavior(ResultCacheFactory
2014        .getCacheBehaviorInstance(DatabasesXmlTags.ELT_EagerCaching, options));
2015  }
2016
2017  /**
2018   * Add a new <code>RelaxedCaching</code> behavior to the current
2019   * <code>ResultCacheRule</code>.
2020   * 
2021   * @param atts parsed attributes
2022   */
2023  private void newRelaxedCaching(Attributes   atts)
2024  {
2025    Hashtable   options = new Hashtable  ();
2026    for (int i = 0; i < atts.getLength(); i++)
2027      options.put(atts.getQName(i), atts.getValue(i));
2028    currentResultCacheRule
2029        .setCacheBehavior(ResultCacheFactory.getCacheBehaviorInstance(
2030            DatabasesXmlTags.ELT_RelaxedCaching, options));
2031  }
2032
2033  /* Load balancers */
2034
2035  /**
2036   * Get the transaction isolation level for the load balancer. This will be set
2037   * at the end of the parsing of this element.
2038   */
2039  private void newLoadBalancer(Attributes   atts)
2040  {
2041    String   transactionIsolation = atts
2042        .getValue(DatabasesXmlTags.ATT_transactionIsolation);
2043
2044    if (transactionIsolation.equals(DatabasesXmlTags.VAL_readUncommitted))
2045      defaultTransactionIsolation = java.sql.Connection.TRANSACTION_READ_UNCOMMITTED;
2046    else if (transactionIsolation.equals(DatabasesXmlTags.VAL_readCommitted))
2047      defaultTransactionIsolation = java.sql.Connection.TRANSACTION_READ_COMMITTED;
2048    else if (transactionIsolation.equals(DatabasesXmlTags.VAL_repeatableRead))
2049      defaultTransactionIsolation = java.sql.Connection.TRANSACTION_REPEATABLE_READ;
2050    else if (transactionIsolation.equals(DatabasesXmlTags.VAL_serializable))
2051      defaultTransactionIsolation = java.sql.Connection.TRANSACTION_SERIALIZABLE;
2052    else
2053      // if (transactionIsolation.equals(DatabasesXmlTags.VAL_databaseDefault))
2054      defaultTransactionIsolation = org.continuent.sequoia.driver.Connection.DEFAULT_TRANSACTION_ISOLATION_LEVEL;
2055  }
2056
2057  /**
2058   * Sets {@link #currentLoadBalancer}as a new <code> SingleDB</code> using
2059   * the parsed attributes.
2060   * 
2061   * @exception SAXException if an error occurs
2062   */
2063  private void newSingleDBRequestLoadBalancer() throws SAXException  
2064  {
2065    if (logger.isDebugEnabled())
2066      logger.debug(Translate
2067          .get("virtualdatabase.xml.loadbalancer.singledb.set"));
2068
2069    try
2070    {
2071      currentLoadBalancer = new SingleDB(currentVirtualDatabase);
2072    }
2073    catch (Exception   e)
2074    {
2075      String   msg = Translate
2076          .get("virtualdatabase.xml.loadbalancer.singledb.failed");
2077      logger.error(msg, e);
2078      throw new SAXException  (msg, e);
2079    }
2080  }
2081
2082  //
2083  // ParallelDB load balancers
2084  //
2085
2086  /**
2087   * Sets {@link #currentLoadBalancer}as a new <code>ParallelDB_RR</code>
2088   * using the parsed attributes.
2089   * 
2090   * @exception SAXException if an error occurs
2091   */
2092  private void newParallelDBLeastPendingRequestsFirst() throws SAXException  
2093  {
2094    if (logger.isDebugEnabled())
2095      logger.debug(Translate
2096          .get("virtualdatabase.xml.loadbalancer.paralleldb_rr.set"));
2097
2098    try
2099    {
2100      currentLoadBalancer = new ParallelDB_RR(currentVirtualDatabase);
2101    }
2102    catch (Exception   e)
2103    {
2104      String   msg = Translate
2105          .get("virtualdatabase.xml.loadbalancer.paralleldb_rr.failed");
2106      logger.error(msg, e);
2107      throw new SAXException  (msg, e);
2108    }
2109  }
2110
2111  /**
2112   * Sets {@link #currentLoadBalancer}as a new <code>ParallelDB_LPRF</code>
2113   * using the parsed attributes.
2114   * 
2115   * @exception SAXException if an error occurs
2116   */
2117  private void newParallelDBRoundRobinLoadBalancer() throws SAXException  
2118  {
2119    if (logger.isDebugEnabled())
2120      logger.debug(Translate
2121          .get("virtualdatabase.xml.loadbalancer.paralleldb_lprf.set"));
2122
2123    try
2124    {
2125      currentLoadBalancer = new ParallelDB_LPRF(currentVirtualDatabase);
2126    }
2127    catch (Exception   e)
2128    {
2129      String   msg = Translate
2130          .get("virtualdatabase.xml.loadbalancer.paralleldb_lprf.failed");
2131      logger.error(msg, e);
2132      throw new SAXException  (msg, e);
2133    }
2134  }
2135
2136  //
2137  // RAIDb-0 load balancers
2138  //
2139
2140  /**
2141   * Sets {@link #currentLoadBalancer}as a new <code> RAIDb0</code> using the
2142   * parsed attributes.
2143   */
2144  private void newRAIDb0LoadBalancer()
2145  {
2146    currentCreateTablePolicy = new CreateTablePolicy();
2147    currentCreateTableRule = null;
2148  }
2149
2150  //
2151  // RAIDb-1 load balancers
2152  //
2153
2154  /**
2155   * Sets {@link #currentLoadBalancer}as a new <code> RAIDb1</code> using the
2156   * parsed attributes.
2157   */
2158  private void newRAIDb1LoadBalancer()
2159  {
2160    currentWaitForCompletionPolicy = DEFAULT_WAIT_FOR_ALL_COMPLETION;
2161  }
2162
2163  /**
2164   * Sets {@link #currentLoadBalancer}as a new <code> RAIDb1_RR</code> using
2165   * the parsed attributes.
2166   * 
2167   * @exception SAXException if an error occurs
2168   */
2169  private void newRAIDb1RoundRobinLoadBalancer() throws SAXException  
2170  {
2171    if (logger.isDebugEnabled())
2172    {
2173      logger.debug(Translate
2174          .get("virtualdatabase.xml.loadbalancer.raidb1_rr.set"));
2175      logger.debug(Translate.get(
2176          "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
2177          currentWaitForCompletionPolicy.getInformation()));
2178    }
2179
2180    try
2181    {
2182      currentLoadBalancer = new RAIDb1_RR(currentVirtualDatabase,
2183          currentWaitForCompletionPolicy);
2184    }
2185    catch (Exception   e)
2186    {
2187      String   msg = Translate
2188          .get("virtualdatabase.xml.loadbalancer.raidb1_rr.failed");
2189      logger.error(msg, e);
2190      throw new SAXException  (msg, e);
2191    }
2192  }
2193
2194  /**
2195   * Sets {@link #currentLoadBalancer}as a new <code> RAIDb1_WRR</code> using
2196   * the parsed attributes.
2197   * 
2198   * @exception SAXException if an error occurs
2199   */
2200  private void newRAIDb1WeightedRoundRobinLoadBalancer() throws SAXException  
2201  {
2202    if (logger.isDebugEnabled())
2203    {
2204      logger.debug(Translate
2205          .get("virtualdatabase.xml.loadbalancer.raidb1_wrr.set"));
2206      logger.debug(Translate.get(
2207          "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
2208          currentWaitForCompletionPolicy.getInformation()));
2209    }
2210
2211    try
2212    {
2213      currentLoadBalancer = new RAIDb1_WRR(currentVirtualDatabase,
2214          currentWaitForCompletionPolicy);
2215    }
2216    catch (Exception   e)
2217    {
2218      String   msg = Translate
2219          .get("virtualdatabase.xml.loadbalancer.raidb1_wrr.failed");
2220      logger.error(msg, e);
2221      throw new SAXException  (msg, e);
2222    }
2223  }
2224
2225  /**
2226   * Sets {@link #currentLoadBalancer}as a new <code> RAIDb1_LPRF</code> using
2227   * the parsed attributes.
2228   * 
2229   * @exception SAXException if an error occurs
2230   */
2231  private void newRAIDb1LeastPendingRequestsFirst() throws SAXException  
2232  {
2233    if (logger.isDebugEnabled())
2234    {
2235      logger.debug(Translate
2236          .get("virtualdatabase.xml.loadbalancer.raidb1_lprf.set"));
2237      logger.debug(Translate.get(
2238          "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
2239          currentWaitForCompletionPolicy.getInformation()));
2240    }
2241
2242    try
2243    {
2244      currentLoadBalancer = new RAIDb1_LPRF(currentVirtualDatabase,
2245          currentWaitForCompletionPolicy);
2246    }
2247    catch (Exception   e)
2248    {
2249      String   msg = Translate
2250          .get("virtualdatabase.xml.loadbalancer.raidb1_lprf.failed");
2251      logger.error(msg, e);
2252      throw new SAXException  (msg, e);
2253    }
2254  }
2255
2256  //
2257  // RAIDb-2 load balancers
2258  //
2259
2260  /**
2261   * Sets {@link #currentLoadBalancer}as a new <code> RAIDb2</code> using the
2262   * parsed attributes.
2263   */
2264  private void newRAIDb2LoadBalancer()
2265  {
2266    currentWaitForCompletionPolicy = DEFAULT_WAIT_FOR_ALL_COMPLETION;
2267    currentCreateTablePolicy = new CreateTablePolicy();
2268    // Add a default rule to create table on all nodes
2269    currentCreateTablePolicy.addRule(new CreateTableAll());
2270    currentCreateTableRule = null;
2271  }
2272
2273  /**
2274   * Sets {@link #currentLoadBalancer}as a new <code> RAIDb2_RR</code> using
2275   * the parsed attributes.
2276   * 
2277   * @exception SAXException if an error occurs
2278   */
2279  private void newRAIDb2RoundRobinLoadBalancer() throws SAXException  
2280  {
2281    if (logger.isDebugEnabled())
2282    {
2283      logger.debug(Translate
2284          .get("virtualdatabase.xml.loadbalancer.raidb2_rr.set"));
2285      logger.debug(Translate.get(
2286          "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
2287          currentWaitForCompletionPolicy.getInformation()));
2288    }
2289
2290    try
2291    {
2292      currentLoadBalancer = new RAIDb2_RR(currentVirtualDatabase,
2293          currentWaitForCompletionPolicy, currentCreateTablePolicy);
2294    }
2295    catch (Exception   e)
2296    {
2297      String   msg = Translate
2298          .get("virtualdatabase.xml.loadbalancer.raidb2_rr.failed");
2299      logger.error(msg, e);
2300      throw new SAXException  (msg, e);
2301    }
2302  }
2303
2304  /**
2305   * Sets {@link #currentLoadBalancer}as a new <code> RAIDb2_WRR</code> using
2306   * the parsed attributes.
2307   * 
2308   * @exception SAXException if an error occurs
2309   */
2310  private void newRAIDb2WeightedRoundRobinLoadBalancer() throws SAXException  
2311  {
2312    if (logger.isDebugEnabled())
2313    {
2314      logger.debug(Translate
2315          .get("virtualdatabase.xml.loadbalancer.raidb2_wrr.set"));
2316      logger.debug(Translate.get(
2317          "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
2318          currentWaitForCompletionPolicy.getInformation()));
2319    }
2320
2321    try
2322    {
2323      currentLoadBalancer = new RAIDb2_WRR(currentVirtualDatabase,
2324          currentWaitForCompletionPolicy, currentCreateTablePolicy);
2325    }
2326    catch (Exception   e)
2327    {
2328      String   msg = Translate
2329          .get("virtualdatabase.xml.loadbalancer.raidb2_wrr.failed");
2330      logger.error(msg, e);
2331      throw new SAXException  (msg, e);
2332    }
2333  }
2334
2335  /**
2336   * Sets {@link #currentLoadBalancer}as a new <code> RAIDb2_LPRF</code> using
2337   * the parsed attributes.
2338   * 
2339   * @exception SAXException if an error occurs
2340   */
2341  private void newRAIDb2LeastPendingRequestsFirst() throws SAXException  
2342  {
2343    if (logger.isDebugEnabled())
2344    {
2345      logger.debug(Translate
2346          .get("virtualdatabase.xml.loadbalancer.raidb2_lprf.set"));
2347      logger.debug(Translate.get(
2348          "virtualdatabase.xml.loadbalancer.waitforcompletion.rule",
2349          currentWaitForCompletionPolicy.getInformation()));
2350    }
2351
2352    try
2353    {
2354      currentLoadBalancer = new RAIDb2_LPRF(currentVirtualDatabase,
2355          currentWaitForCompletionPolicy, currentCreateTablePolicy);
2356    }
2357    catch (Exception   e)
2358    {
2359      String   msg = Translate
2360          .get("virtualdatabase.xml.loadbalancer.raidb2_lprf.failed");
2361      logger.error(msg, e);
2362      throw new SAXException  (msg, e);
2363    }
2364  }
2365
2366  //
2367  // Load balancer policies
2368  //
2369
2370  /**
2371   * Set the WaitForCompletion policy.
2372   * 
2373   * @param atts parsed attributes
2374   * @exception SAXException if an error occurs
2375   */
2376  private void newWaitForCompletion(Attributes   atts) throws SAXException  
2377  {
2378    String   policy = atts.getValue(DatabasesXmlTags.ATT_policy);
2379    String   enforceTableLocking = atts
2380        .getValue(DatabasesXmlTags.ATT_enforceTableLocking);
2381    String   deadlockTimeoutInMsString = atts
2382        .getValue(DatabasesXmlTags.ATT_deadlockTimeoutInMs);
2383    long deadlockTimeoutInMs;
2384    try
2385    {
2386      deadlockTimeoutInMs = Long.parseLong(deadlockTimeoutInMsString);
2387    }
2388    catch (Exception   e)
2389    {
2390      String   msg = Translate.get("virtualdatabase.xml.virtualdatabase.failed");
2391      logger.error(msg, e);
2392      throw new SAXException  (msg, e);
2393    }
2394
2395    if (policy.equals(DatabasesXmlTags.VAL_first))
2396      currentWaitForCompletionPolicy = new WaitForCompletionPolicy(
2397          WaitForCompletionPolicy.FIRST, "true".equals(enforceTableLocking),
2398          deadlockTimeoutInMs);
2399    else if (policy.equals(DatabasesXmlTags.VAL_majority))
2400      currentWaitForCompletionPolicy = new WaitForCompletionPolicy(
2401          WaitForCompletionPolicy.MAJORITY, "true".equals(enforceTableLocking),
2402          deadlockTimeoutInMs);
2403    else if (policy.equals(DatabasesXmlTags.VAL_all))
2404      currentWaitForCompletionPolicy = new WaitForCompletionPolicy(
2405          WaitForCompletionPolicy.ALL, "true".equals(enforceTableLocking),
2406          deadlockTimeoutInMs);
2407    else
2408      throw new SAXException  (Translate.get(
2409          "virtualdatabase.xml.loadbalancer.waitforcompletion.unsupported",
2410          policy));
2411  }
2412
2413  /**
2414   * Add a CreateTable rule.
2415   * 
2416   * @param atts parsed attributes
2417   * @exception SAXException if an error occurs
2418   */
2419  private void newCreateTable(Attributes   atts) throws SAXException  
2420  {
2421    String   tableName = atts.getValue(DatabasesXmlTags.ATT_tableName);
2422    String   nbOfNodes = atts.getValue(DatabasesXmlTags.ATT_numberOfNodes);
2423    String   policy = atts.getValue(DatabasesXmlTags.ATT_policy);
2424    backendNameList = new ArrayList  ();
2425    if (policy.equals(DatabasesXmlTags.VAL_random))
2426      currentCreateTableRule = new CreateTableRandom(backendNameList);
2427    else if (policy.equals(DatabasesXmlTags.VAL_roundRobin))
2428      currentCreateTableRule = new CreateTableRoundRobin(backendNameList);
2429    else if (policy.equals(DatabasesXmlTags.VAL_all))
2430      currentCreateTableRule = new CreateTableAll(backendNameList);
2431    else
2432      throw new SAXException  (Translate.get(
2433          "virtualdatabase.xml.create.table.unsupported", policy));
2434
2435    currentCreateTableRule.setNumberOfNodes(Integer.parseInt(nbOfNodes));
2436    currentCreateTableRule.setTableName(tableName);
2437  }
2438
2439  /**
2440   * Adds a backend name to the current backendNameList.
2441   * 
2442   * @param atts parsed attributes
2443   */
2444  private void newBackendName(Attributes   atts)
2445  {
2446    String   name = atts.getValue(DatabasesXmlTags.ATT_name);
2447    if (logger.isDebugEnabled())
2448      logger.debug(Translate
2449          .get("virtualdatabase.xml.backend.policy.add", name));
2450    backendNameList.add(name);
2451  }
2452
2453  /**
2454   * Sets the weight of the {@link #currentLoadBalancer}using the parsed
2455   * attributes.
2456   * 
2457   * @param atts parsed attributes
2458   * @exception SAXException if an error occurs
2459   */
2460  private void newBackendWeight(Attributes   atts) throws SAXException  
2461  {
2462    String   name = atts.getValue(DatabasesXmlTags.ATT_name);
2463    try
2464    {
2465      int weight = Integer.parseInt(atts.getValue(DatabasesXmlTags.ATT_weight));
2466
2467      if (logger.isDebugEnabled())
2468        logger.debug(Translate.get("virtualdatabase.xml.backend.weigth.set",
2469            new String  []{String.valueOf(weight), name}));
2470
2471      currentLoadBalancer.setWeight(name, weight);
2472    }
2473    catch (Exception   e)
2474    {
2475      String   msg = Translate.get("virtualdatabase.xml.backend.weigth.failed",
2476          name);
2477      logger.error(msg, e);
2478      throw new SAXException  (msg, e);
2479    }
2480  }
2481
2482  /*
2483   * Recovery log
2484   */
2485
2486  /**
2487   * Sets the currentRecoveryLog as new <code>HSQLEmbeddedRecoveryLog</code>
2488   * using the parsed attributes.
2489   * 
2490   * @param atts parsed attributes
2491   * @exception SAXException if an error occurs
2492   */
2493  private void newEmbeddedRecoveryLog(Attributes   atts) throws SAXException  
2494  {
2495    String   dataPath = atts.getValue(DatabasesXmlTags.ATT_dataPath);
2496
2497    // Default is vdbName/recoverylog
2498    if (dataPath == null)
2499    {
2500      String   path = System.getProperty("sequoia.recoverylog");
2501      if (path == null)
2502        path = System.getProperty("sequoia.home") + "/recoverylog";
2503      dataPath = path + "/" + currentVirtualDatabase.getVirtualDatabaseName()
2504          + "/recoverylog";
2505    }
2506
2507    try
2508    {
2509      if (logger.isDebugEnabled())
2510        logger.debug(Translate.get(
2511            "virtualdatabase.xml.recoverylog.embedded.create", dataPath));
2512
2513      currentRecoveryLog = new HSQLEmbeddedRecoveryLog(dataPath);
2514    }
2515    catch (Exception   e)
2516    {
2517      String   msg = Translate
2518          .get("virtualdatabase.xml.recoverylog.embedded.failed");
2519      logger.error(msg, e);
2520      throw new SAXException  (msg, e);
2521    }
2522  }
2523
2524  /**
2525   * Sets the currentRecoveryLog as new <code>RecoveryLog</code> using the
2526   * parsed attributes.
2527   * 
2528   * @param atts parsed attributes
2529   * @exception SAXException if an error occurs
2530   */
2531  private void newRecoveryLog(Attributes   atts) throws SAXException  
2532  {
2533    try
2534    {
2535      String   driverClassName = atts.getValue(DatabasesXmlTags.ATT_driver);
2536      String   driverPath = atts.getValue(DatabasesXmlTags.ATT_driverPath);
2537      String   url = atts.getValue(DatabasesXmlTags.ATT_url);
2538      String   login = atts.getValue(DatabasesXmlTags.ATT_login);
2539      String   password = atts.getValue(DatabasesXmlTags.ATT_password);
2540      String   timeout = atts.getValue(DatabasesXmlTags.ATT_requestTimeout);
2541      int recoveryBatchSize = Integer.parseInt(atts
2542          .getValue(DatabasesXmlTags.ATT_recoveryBatchSize));
2543      // Convert to ms
2544      requestTimeout = Integer.parseInt(timeout) * 1000;
2545
2546      if (logger.isDebugEnabled())
2547        logger.debug(Translate.get(
2548            "virtualdatabase.xml.recoverylog.jdbc.create", new String  []{
2549                driverClassName, url, login, password,
2550                String.valueOf(requestTimeout)}));
2551
2552      currentRecoveryLog = new RecoveryLog(driverPath, driverClassName, url,
2553          login, password, requestTimeout, recoveryBatchSize);
2554    }
2555    catch (Exception   e)
2556    {
2557      String   msg = Translate.get("virtualdatabase.xml.recoverylog.jdbc.failed");
2558      logger.error(msg, e);
2559      throw new SAXException  (msg, e);
2560    }
2561  }
2562
2563  /**
2564   * Sets the recovery log table create statement for the current
2565   * <code>RecoveryLog</code> using the <code>RecoveryLogTable</code> parsed
2566   * attributes.
2567   * 
2568   * @param atts parsed attributes
2569   * @exception SAXException if an error occurs
2570   */
2571  private void newRecoveryLogTable(Attributes   atts) throws SAXException  
2572  {
2573    try
2574    {
2575      String   createTable = atts.getValue(DatabasesXmlTags.ATT_createTable);
2576      String   tableName = atts.getValue(DatabasesXmlTags.ATT_tableName);
2577      String   idType = atts.getValue(DatabasesXmlTags.ATT_logIdColumnType);
2578      String   vloginType = atts.getValue(DatabasesXmlTags.ATT_vloginColumnType);
2579      String   sqlName = atts.getValue(DatabasesXmlTags.ATT_sqlColumnName);
2580      String   sqlType = atts.getValue(DatabasesXmlTags.ATT_sqlColumnType);
2581      String   sqlParamType = atts
2582          .getValue(DatabasesXmlTags.ATT_sqlParamColumnType);
2583      String   autoConnTrans = atts
2584          .getValue(DatabasesXmlTags.ATT_autoConnTranColumnType);
2585      String   transactionIdType = atts
2586          .getValue(DatabasesXmlTags.ATT_transactionIdColumnType);
2587      String   requestIdColumnType = atts
2588          .getValue(DatabasesXmlTags.ATT_requestIdColumnType);
2589      String   execTimeColumnType = atts
2590          .getValue(DatabasesXmlTags.ATT_execTimeColumnType);
2591      String   updateCountColumnType = atts
2592          .getValue(DatabasesXmlTags.ATT_updateCountColumnType);
2593      String   extraStatement = atts
2594          .getValue(DatabasesXmlTags.ATT_extraStatementDefinition);
2595
2596      if (idType == null)
2597        throw new SAXException  ("Invalid null column type for logId column");
2598      if (vloginType == null)
2599        throw new SAXException  ("Invalid null column type for vlogin column");
2600      if (sqlType == null)
2601        throw new SAXException  ("Invalid null column type for sql column");
2602      if (sqlParamType == null)
2603        throw new SAXException  ("Invalid null column type for sql_param column");
2604      if (transactionIdType == null)
2605        throw new SAXException  (
2606            "Invalid null column type for transaction_id column");
2607      if (requestIdColumnType == null)
2608        throw new SAXException  ("Invalid null column type for request_id column");
2609      if (execTimeColumnType == null)
2610        throw new SAXException  ("Invalid null column type for exec_time column");
2611      if (updateCountColumnType == null)
2612        throw new SAXException  (
2613            "Invalid null column type for udpate_count column");
2614
2615      if (currentRecoveryLog == null)
2616      {
2617        String   msg = Translate
2618            .get("virtualdatabase.xml.recoverylog.jdbc.recoverytable.setnull");
2619        logger.error(msg);
2620        throw new SAXException  (msg);
2621      }
2622      else
2623        currentRecoveryLog.setLogTableCreateStatement(createTable, tableName,
2624            idType, vloginType, sqlName, sqlType, sqlParamType, autoConnTrans,
2625            transactionIdType, requestIdColumnType, execTimeColumnType,
2626            updateCountColumnType, extraStatement);
2627    }
2628    catch (Exception   e)
2629    {
2630      String   msg = Translate
2631          .get("virtualdatabase.xml.recoverylog.jdbc.recoverytable.failed");
2632      logger.error(msg, e);
2633      throw new SAXException  (msg, e);
2634    }
2635  }
2636
2637  /**
2638   * Sets the checkpoint table create statement for the current
2639   * <code>RecoveryLog</code> using the <code>CheckpointTable</code> parsed
2640   * attributes.
2641   * 
2642   * @param atts parsed attributes
2643   * @exception SAXException if an error occurs
2644   */
2645  private void newRecoveryCheckpointTable(Attributes   atts) throws SAXException  
2646  {
2647    try
2648    {
2649      String   createTable = atts.getValue(DatabasesXmlTags.ATT_createTable);
2650      String   tableName = atts.getValue(DatabasesXmlTags.ATT_tableName);
2651      String   nameType = atts
2652          .getValue(DatabasesXmlTags.ATT_checkpointNameColumnType);
2653      String   logIdType = atts.getValue(DatabasesXmlTags.ATT_logIdColumnType);
2654      String   extraStatement = atts
2655          .getValue(DatabasesXmlTags.ATT_extraStatementDefinition);
2656
2657      if (currentRecoveryLog == null)
2658      {
2659        String   msg = Translate
2660            .get("virtualdatabase.xml.recoverylog.jdbc.checkpointtable.setnull");
2661        logger.error(msg);
2662        throw new SAXException  (msg);
2663      }
2664      else
2665        currentRecoveryLog.setCheckpointTableCreateStatement(createTable,
2666            tableName, nameType, logIdType, extraStatement);
2667    }
2668    catch (Exception   e)
2669    {
2670      String   msg = Translate
2671          .get("virtualdatabase.xml.recoverylog.jdbc.checkpointtable.failed");
2672      logger.error(msg, e);
2673      throw new SAXException  (msg, e);
2674    }
2675  }
2676
2677  /**
2678   * Sets the backend table create statement for the current
2679   * <code>RecoveryLog</code> using the <code>BackendTable</code> parsed
2680   * attributes.
2681   * 
2682   * @param atts parsed attributes
2683   * @exception SAXException if an error occurs
2684   */
2685  private void newRecoveryBackendTable(Attributes   atts) throws SAXException  
2686  {
2687    try
2688    {
2689      String   createTable = atts.getValue(DatabasesXmlTags.ATT_createTable);
2690      String   tableName = atts.getValue(DatabasesXmlTags.ATT_tableName);
2691      String   checkpointNameType = atts
2692          .getValue(DatabasesXmlTags.ATT_checkpointNameColumnType);
2693      String   databaseNameType = atts
2694          .getValue(DatabasesXmlTags.ATT_databaseNameColumnType);
2695      String   backendNameType = atts
2696          .getValue(DatabasesXmlTags.ATT_backendNameColumnType);
2697      String   backendStateType = atts
2698          .getValue(DatabasesXmlTags.ATT_backendStateColumnType);
2699      String   extraStatement = atts
2700          .getValue(DatabasesXmlTags.ATT_extraStatementDefinition);
2701
2702      if (currentRecoveryLog == null)
2703      {
2704        String   msg = Translate
2705            .get("virtualdatabase.xml.recoverylog.jdbc.backendtable.setnull");
2706        logger.error(msg);
2707        throw new SAXException  (msg);
2708      }
2709      else
2710        currentRecoveryLog.setBackendTableCreateStatement(createTable,
2711            tableName, checkpointNameType, backendNameType, backendStateType,
2712            databaseNameType, extraStatement);
2713    }
2714    catch (Exception   e)
2715    {
2716      String   msg = Translate
2717          .get("virtualdatabase.xml.recoverylog.jdbc.backendtable.failed");
2718      logger.error(msg, e);
2719      throw new SAXException  (msg, e);
2720    }
2721  }
2722
2723  /**
2724   * Sets the dump table create statement for the current
2725   * <code>RecoveryLog</code> using the <code>DumpTable</code> parsed
2726   * attributes.
2727   * 
2728   * @param atts parsed attributes
2729   * @exception SAXException if an error occurs
2730   */
2731  private void newRecoveryDumpTable(Attributes   atts) throws SAXException  
2732  {
2733    try
2734    {
2735      String   createTable = atts.getValue(DatabasesXmlTags.ATT_createTable);
2736      String   tableName = atts.getValue(DatabasesXmlTags.ATT_tableName);
2737      String   dumpNameColumnType = atts
2738          .getValue(DatabasesXmlTags.ATT_dumpNameColumnType);
2739      String   dumpDateColumnType = atts
2740          .getValue(DatabasesXmlTags.ATT_dumpDateColumnType);
2741      String   dumpPathColumnType = atts
2742          .getValue(DatabasesXmlTags.ATT_dumpPathColumnType);
2743      String   dumpTypeColumnType = atts
2744          .getValue(DatabasesXmlTags.ATT_dumpFormatColumnType);
2745      String   checkpointNameColumnType = atts
2746          .getValue(DatabasesXmlTags.ATT_checkpointNameColumnType);
2747      String   backendNameColumnType = atts
2748          .getValue(DatabasesXmlTags.ATT_backendNameColumnType);
2749      String   tablesColumnName = atts
2750          .getValue(DatabasesXmlTags.ATT_tablesColumnName);
2751      String   tablesColumnType = atts
2752          .getValue(DatabasesXmlTags.ATT_tablesColumnType);
2753
2754      String   extraStatement = atts
2755          .getValue(DatabasesXmlTags.ATT_extraStatementDefinition);
2756
2757      if (currentRecoveryLog == null)
2758      {
2759        String   msg = Translate
2760            .get("virtualdatabase.xml.recoverylog.jdbc.dumptable.setnull");
2761        logger.error(msg);
2762        throw new SAXException  (msg);
2763      }
2764      else
2765        currentRecoveryLog.setDumpTableCreateStatement(createTable, tableName,
2766            dumpNameColumnType, dumpDateColumnType, dumpPathColumnType,
2767            dumpTypeColumnType, checkpointNameColumnType,
2768            backendNameColumnType, tablesColumnName, tablesColumnType,
2769            extraStatement);
2770    }
2771    catch (Exception   e)
2772    {
2773      String   msg = Translate
2774          .get("virtualdatabase.xml.recoverylog.jdbc.dumptable.failed");
2775      logger.error(msg, e);
2776      throw new SAXException  (msg, e);
2777    }
2778  }
2779
2780  /* Connection manager */
2781
2782  /**
2783   * Sets the currentRecoveryLog as new <code>RecoveryLog</code> using the
2784   * parsed attributes.
2785   * 
2786   * @param atts parsed attributes
2787   * @exception SAXException if an error occurs
2788   */
2789  private void newConnectionManager(Attributes   atts) throws SAXException  
2790  {
2791    settingDefaultConnectionManager = false;
2792    connectionManagerVLogin = atts.getValue(DatabasesXmlTags.ATT_vLogin);
2793    String   connectionManagerRLogin = atts.getValue(DatabasesXmlTags.ATT_rLogin);
2794    String   connectionManagerRPassword = atts
2795        .getValue(DatabasesXmlTags.ATT_rPassword);
2796    String   backendName = currentBackend.getName();
2797
2798    // Check that the virtual login has been defined
2799    if (!currentAuthenticationManager
2800        .isValidVirtualLogin(connectionManagerVLogin))
2801    {
2802      String   msg = Translate.get(
2803          "virtualdatabase.xml.connectionmanager.vlogin.undefined",
2804          new String  []{connectionManagerVLogin, currentBackend.getName()});
2805      logger.error(msg);
2806      throw new SAXException  (msg);
2807    }
2808
2809    // If values are missing, we default to the virtual login/password
2810    if (connectionManagerRLogin == null)
2811      connectionManagerRLogin = connectionManagerVLogin;
2812    if (connectionManagerRPassword == null)
2813      connectionManagerRPassword = currentAuthenticationManager
2814          .getVirtualPassword(connectionManagerVLogin);
2815
2816    // Add Real user for the database
2817    currentDatabaseBackendUser = new DatabaseBackendUser(backendName,
2818        connectionManagerRLogin, connectionManagerRPassword);
2819
2820    if (logger.isDebugEnabled())
2821      logger.debug(Translate
2822          .get("virtualdatabase.xml.authentication.login.real.add",
2823              new String  []{connectionManagerRLogin, connectionManagerRPassword,
2824                  backendName}));
2825
2826    try
2827    {
2828      currentAuthenticationManager.addRealUser(connectionManagerVLogin,
2829          currentDatabaseBackendUser);
2830    }
2831    catch (AuthenticationManagerException e)
2832    {
2833      String   msg = Translate
2834          .get("virtualdatabase.xml.authentication.login.real.add.failed");
2835      logger.error(msg, e);
2836      throw new SAXException  (msg, e);
2837    }
2838  }
2839
2840  /**
2841   * TODO: newDefaultConnectionManager definition.
2842   */
2843  private void newDefaultConnectionManager()
2844  {
2845    settingDefaultConnectionManager = true;
2846  }
2847
2848  /**
2849   * Adds a new <code>SimpleConnectionManager</code> to
2850   * {@link #currentBackend}using the parsed attributes.
2851   */
2852  private void newSimpleConnectionManager()
2853  {
2854    if (settingDefaultConnectionManager)
2855    {
2856      if (logger.isDebugEnabled())
2857      {
2858        logger
2859            .debug("Setting a SimpleConnectionManager as default connection manager");
2860      }
2861      currentBackend.setDefaultConnectionManager(new SimpleConnectionManager(
2862          currentBackend.getURL(), currentBackend.getName(),
2863          currentDatabaseBackendUser.getLogin(), currentDatabaseBackendUser
2864              .getPassword(), currentBackend.getDriverPath(), currentBackend
2865              .getDriverClassName()));
2866    }
2867    else
2868    {
2869      if (logger.isDebugEnabled())
2870        logger.debug(Translate.get(
2871            "virtualdatabase.xml.connectionmanager.simple.add", new String  []{
2872                currentBackend.getName(), connectionManagerVLogin,
2873                currentDatabaseBackendUser.getLogin(),
2874                currentDatabaseBackendUser.getPassword()}));
2875
2876      currentBackend.addConnectionManager(connectionManagerVLogin,
2877          new SimpleConnectionManager(currentBackend.getURL(), currentBackend
2878              .getName(), currentDatabaseBackendUser.getLogin(),
2879              currentDatabaseBackendUser.getPassword(), currentBackend
2880                  .getDriverPath(), currentBackend.getDriverClassName()));
2881    }
2882  }
2883
2884  /**
2885   * Adds a new <code>FailFastPoolConnectionManager</code> to
2886   * {@link #currentBackend}using the parsed attributes.
2887   * 
2888   * @param atts parsed attributes
2889   * @exception SAXException if an error occurs
2890   */
2891  private void newFailFastPoolConnectionManager(Attributes   atts)
2892      throws SAXException  
2893  {
2894    try
2895    {
2896      int poolSize = Integer.parseInt(atts
2897          .getValue(DatabasesXmlTags.ATT_poolSize));
2898
2899      // sanity check
2900      if (poolSize < 1)
2901        throw new IllegalArgumentException  (
2902            Translate
2903                .get("virtualdatabase.xml.connectionmanager.failfast.failed.parameter"));
2904
2905      if (settingDefaultConnectionManager)
2906      {
2907        if (logger.isDebugEnabled())
2908        {
2909          logger
2910              .debug("Setting a FailFastPoolConnectionManager as default connection manager");
2911        }
2912        currentBackend
2913            .setDefaultConnectionManager(new FailFastPoolConnectionManager(
2914                currentBackend.getURL(), currentBackend.getName(),
2915                currentDatabaseBackendUser.getLogin(),
2916                currentDatabaseBackendUser.getPassword(), currentBackend
2917                    .getDriverPath(), currentBackend.getDriverClassName(),
2918                poolSize));
2919      }
2920      else
2921      {
2922        if (logger.isDebugEnabled())
2923          logger.debug(Translate.get(
2924              "virtualdatabase.xml.connectionmanager.failfast.add",
2925              new String  []{currentBackend.getName(), connectionManagerVLogin,
2926                  String.valueOf(poolSize),
2927                  currentDatabaseBackendUser.getLogin(),
2928                  currentDatabaseBackendUser.getPassword()}));
2929
2930        currentBackend.addConnectionManager(connectionManagerVLogin,
2931            new FailFastPoolConnectionManager(currentBackend.getURL(),
2932                currentBackend.getName(),
2933                currentDatabaseBackendUser.getLogin(),
2934                currentDatabaseBackendUser.getPassword(), currentBackend
2935                    .getDriverPath(), currentBackend.getDriverClassName(),
2936                poolSize));
2937      }
2938    }
2939    catch (Exception   e)
2940    {
2941      String   msg = Translate.get(
2942          "virtualdatabase.xml.connectionmanager.failfast.failed",
2943          currentBackend.getName());
2944      logger.error(msg, e);
2945      throw new SAXException  (msg, e);
2946    }
2947  }
2948
2949  /**
2950   * Adds a new <code>RandomWaitPoolConnectionManager</code> to
2951   * {@link #currentBackend}using the parsed attributes.
2952   * 
2953   * @param atts parsed attributes
2954   * @exception SAXException if an error occurs
2955   */
2956  private void newRandomWaitPoolConnectionManager(Attributes   atts)
2957      throws SAXException  
2958  {
2959    try
2960    {
2961      int poolSize = Integer.parseInt(atts
2962          .getValue(DatabasesXmlTags.ATT_poolSize));
2963      int timeout = Integer.parseInt(atts
2964          .getValue(DatabasesXmlTags.ATT_timeout));
2965
2966      // sanity check
2967      if (timeout < 0 || poolSize < 1)
2968        throw new IllegalArgumentException  (
2969            Translate
2970                .get("virtualdatabase.xml.connectionmanager.randomwait.failed.parameter"));
2971
2972      if (settingDefaultConnectionManager)
2973      {
2974        if (logger.isDebugEnabled())
2975        {
2976          logger
2977              .debug("Setting a RandomWaitPoolConnectionManager as default connection manager");
2978        }
2979        currentBackend
2980            .setDefaultConnectionManager(new RandomWaitPoolConnectionManager(
2981                currentBackend.getURL(), currentBackend.getName(),
2982                currentDatabaseBackendUser.getLogin(),
2983                currentDatabaseBackendUser.getPassword(), currentBackend
2984                    .getDriverPath(), currentBackend.getDriverClassName(),
2985                poolSize, timeout));
2986      }
2987      else
2988      {
2989        if (logger.isDebugEnabled())
2990          logger.debug(Translate.get(
2991              "virtualdatabase.xml.connectionmanager.randomwait.add",
2992              new String  []{currentBackend.getName(), connectionManagerVLogin,
2993                  String.valueOf(poolSize), String.valueOf(timeout),
2994                  currentDatabaseBackendUser.getLogin(),
2995                  currentDatabaseBackendUser.getPassword()}));
2996
2997        currentBackend.addConnectionManager(connectionManagerVLogin,
2998            new RandomWaitPoolConnectionManager(currentBackend.getURL(),
2999                currentBackend.getName(),
3000                currentDatabaseBackendUser.getLogin(),
3001                currentDatabaseBackendUser.getPassword(), currentBackend
3002                    .getDriverPath(), currentBackend.getDriverClassName(),
3003                poolSize, timeout));
3004      }
3005    }
3006    catch (Exception   e)
3007    {
3008      String   msg = Translate.get(
3009          "virtualdatabase.xml.connectionmanager.randomwait.failed",
3010          currentBackend.getName());
3011      logger.error(msg, e);
3012      throw new SAXException  (msg, e);
3013    }
3014  }
3015
3016  /**
3017   * Adds a new <code>VariablePoolConnectionManager</code> to
3018   * {@link #currentBackend}using the parsed attributes.
3019   * 
3020   * @param atts parsed attributes
3021   * @exception SAXException if an error occurs
3022   */
3023  private void newVariablePoolConnectionManager(Attributes   atts)
3024      throws SAXException  
3025  {
3026    try
3027    {
3028      int initPoolSize = Integer.parseInt(atts
3029          .getValue(DatabasesXmlTags.ATT_initPoolSize));
3030
3031      int minPoolSize = initPoolSize;
3032      // minPoolSize is IMPLIED and may be null
3033      String   attr = atts.getValue(DatabasesXmlTags.ATT_minPoolSize);
3034      if (attr != null)
3035        minPoolSize = Integer.parseInt(attr);
3036
3037      int maxPoolSize = Integer.parseInt(atts
3038          .getValue(DatabasesXmlTags.ATT_maxPoolSize));
3039      int idleTimeout = Integer.parseInt(atts
3040          .getValue(DatabasesXmlTags.ATT_idleTimeout));
3041      int waitTimeout = Integer.parseInt(atts
3042          .getValue(DatabasesXmlTags.ATT_waitTimeout));
3043
3044      // sanity checks
3045      if (minPoolSize < 0 || maxPoolSize < 0
3046          || (maxPoolSize != 0 && minPoolSize > maxPoolSize)
3047          || (maxPoolSize != 0 && initPoolSize > maxPoolSize)
3048          || initPoolSize < minPoolSize)
3049        throw new IllegalArgumentException  (
3050            Translate
3051                .get("virtualdatabase.xml.connectionmanager.variable.failed.parameter"));
3052
3053      if (settingDefaultConnectionManager)
3054      {
3055        if (logger.isDebugEnabled())
3056        {
3057          logger
3058              .debug("Setting a VariablePoolConnectionManager as default connection manager");
3059        }
3060        currentBackend
3061            .setDefaultConnectionManager(new VariablePoolConnectionManager(
3062                currentBackend.getURL(), currentBackend.getName(),
3063                currentDatabaseBackendUser.getLogin(),
3064                currentDatabaseBackendUser.getPassword(), currentBackend
3065                    .getDriverPath(), currentBackend.getDriverClassName(),
3066                initPoolSize, minPoolSize, maxPoolSize, idleTimeout,
3067                waitTimeout));
3068      }
3069      else
3070      {
3071        if (logger.isDebugEnabled())
3072          logger.debug(Translate.get(
3073              "virtualdatabase.xml.connectionmanager.randomwait.add",
3074              new String  []{currentBackend.getName(), connectionManagerVLogin,
3075                  String.valueOf(initPoolSize), String.valueOf(minPoolSize),
3076                  String.valueOf(maxPoolSize), String.valueOf(idleTimeout),
3077                  String.valueOf(waitTimeout),
3078                  currentDatabaseBackendUser.getLogin(),
3079                  currentDatabaseBackendUser.getPassword()}));
3080
3081        currentBackend.addConnectionManager(connectionManagerVLogin,
3082            new VariablePoolConnectionManager(currentBackend.getURL(),
3083                currentBackend.getName(),
3084                currentDatabaseBackendUser.getLogin(),
3085                currentDatabaseBackendUser.getPassword(), currentBackend
3086                    .getDriverPath(), currentBackend.getDriverClassName(),
3087                initPoolSize, minPoolSize, maxPoolSize, idleTimeout,
3088                waitTimeout));
3089      }
3090    }
3091    catch (Exception   e)
3092    {
3093      String   msg = Translate.get(
3094          "virtualdatabase.xml.connectionmanager.variable.failed",
3095          currentBackend.getName());
3096      logger.error(msg, e);
3097      throw new SAXException  (msg, e);
3098    }
3099  }
3100
3101  /*
3102   * Database schema
3103   */
3104
3105  /**
3106   * Set the dynamic schema fetching options on the current backend.
3107   * 
3108   * @param atts parsed attributes
3109   */
3110  private void newDatabaseSchema(Attributes   atts)
3111  {
3112    String   useStoredProcedures = atts
3113        .getValue(DatabasesXmlTags.ATT_useStoredProcedures);
3114    String   useViews = atts.getValue(DatabasesXmlTags.ATT_useViews);
3115    String   gatherSystemTable = atts
3116        .getValue(DatabasesXmlTags.ATT_gatherSystemTables);
3117    String   schemaName = atts.getValue(DatabasesXmlTags.ATT_schemaName);
3118
3119    DynamicDatabaseSchema dds = new DynamicDatabaseSchema(
3120        DatabasesXmlTags.VAL_true.equals(useStoredProcedures),
3121        DatabasesXmlTags.VAL_true.equals(useViews), DatabasesXmlTags.VAL_true
3122            .equals(gatherSystemTable), schemaName);
3123    currentVirtualDatabase.setDynamicDatabaseSchema(dds);
3124  }
3125
3126  //
3127  // Semantic information
3128  //
3129
3130  /**
3131   * Set the current semantic behavior using the parsed attributes.
3132   * 
3133   * @param atts parsed attributes
3134   */
3135  private void newSemanticBehavior(Attributes   atts)
3136  {
3137    String   readSet = atts.getValue(DatabasesXmlTags.ATT_readSet);
3138    String   writeSet = atts.getValue(DatabasesXmlTags.ATT_writeSet);
3139    String   proceduresReferenced = atts
3140        .getValue(DatabasesXmlTags.ATT_proceduresReferenced);
3141    String   altersDatabaseSchema = atts
3142        .getValue(DatabasesXmlTags.ATT_altersDatabaseSchema);
3143    String   altersMetaDataCache = atts
3144        .getValue(DatabasesXmlTags.ATT_altersMetaDataCache);
3145    String   altersQueryResultCache = atts
3146        .getValue(DatabasesXmlTags.ATT_altersQueryResultCache);
3147    String   altersUsers = atts.getValue(DatabasesXmlTags.ATT_altersUsers);
3148    String   isReadOnly = atts.getValue(DatabasesXmlTags.ATT_isReadOnly);
3149    String   needsMacroProcessing = atts
3150        .getValue(DatabasesXmlTags.ATT_needsMacroProcessing);
3151    String   ordering = atts.getValue(DatabasesXmlTags.ATT_ordering);
3152    String   requiresConnectionPoolFlush = atts
3153        .getValue(DatabasesXmlTags.ATT_requiresConnectionPoolFlush);
3154
3155    SortedSet   readTables = new TreeSet  ();
3156    if (readSet != null)
3157    {
3158      StringTokenizer   st = new StringTokenizer  (readSet, ",");
3159      while (st.hasMoreTokens())
3160      {
3161        readTables.add(st.nextToken().trim());
3162      }
3163    }
3164
3165    SortedSet   writeTables = new TreeSet  ();
3166    if (writeSet != null)
3167    {
3168      StringTokenizer   st2 = new StringTokenizer  (writeSet, ",");
3169      while (st2.hasMoreTokens())
3170      {
3171        writeTables.add(st2.nextToken().trim());
3172      }
3173    }
3174
3175    SortedSet   procList = new TreeSet  ();
3176    if (proceduresReferenced != null)
3177    {
3178      StringTokenizer   st3 = new StringTokenizer  (proceduresReferenced, ",");
3179      while (st3.hasMoreTokens())
3180      {
3181        procList.add(st3.nextToken().trim());
3182      }
3183    }
3184
3185    int orderingVal;
3186    if (DatabasesXmlTags.VAL_serializable.equals(ordering))
3187      orderingVal = SemanticBehavior.SERIALIZABLE_ORDER;
3188    else if (DatabasesXmlTags.VAL_outOfOrder.equals(ordering))
3189      orderingVal = SemanticBehavior.OUT_OF_ORDER;
3190    else
3191      throw new IllegalArgumentException  (
3192          "Unsupported ordering value in semantic behavior: " + ordering);
3193
3194    int requiresConnectionPoolFlushVal;
3195    if (DatabasesXmlTags.VAL_currentUser.equals(requiresConnectionPoolFlush))
3196      requiresConnectionPoolFlushVal = SemanticBehavior.FLUSH_CURRENT_USER;
3197    else if (DatabasesXmlTags.VAL_allUsers.equals(requiresConnectionPoolFlush))
3198      requiresConnectionPoolFlushVal = SemanticBehavior.FLUSH_ALL_USERS;
3199    else if (DatabasesXmlTags.VAL_none.equals(requiresConnectionPoolFlush))
3200      requiresConnectionPoolFlushVal = SemanticBehavior.FLUSH_NONE;
3201    else
3202      throw new IllegalArgumentException  (
3203          "Unsupported requiresConnectionPoolFlush value in semantic behavior: "
3204              + requiresConnectionPoolFlush);
3205
3206    currentSemantic.setSemanticBehavior(new SemanticBehavior(readTables,
3207        writeTables, procList, DatabasesXmlTags.VAL_true
3208            .equals(altersDatabaseSchema), DatabasesXmlTags.VAL_true
3209            .equals(altersMetaDataCache), DatabasesXmlTags.VAL_true
3210            .equals(altersQueryResultCache), DatabasesXmlTags.VAL_true
3211            .equals(altersUsers), DatabasesXmlTags.VAL_true.equals(isReadOnly),
3212        DatabasesXmlTags.VAL_true.equals(needsMacroProcessing), orderingVal,
3213        requiresConnectionPoolFlushVal));
3214  }
3215
3216  /**
3217   * Set the current semantic with a new request semantic.
3218   * 
3219   * @param atts parsed attributes
3220   * @exception SAXException if error occurs
3221   */
3222  private void newRequestSemantic(Attributes   atts)
3223  {
3224    String   sqlPattern = atts.getValue(DatabasesXmlTags.ATT_sqlPattern);
3225    currentSemantic = new RequestSemantic(sqlPattern);
3226  }
3227
3228  /**
3229   * Set the current semantic with a new default stored procedure semantic.
3230   */
3231  private void newDefaultStoredProcedureSemantic()
3232  {
3233    currentSemantic = new StoredProcedureSemantic(
3234        "Default stored procedure semantic", 0);
3235  }
3236
3237  /**
3238   * Set the current semantic with a new stored procedure semantic.
3239   * 
3240   * @param atts parsed attributes
3241   * @exception SAXException if error occurs
3242   */
3243  private void newStoredProcedureSemantic(Attributes   atts) throws SAXException  
3244  {
3245    String   procedureName = atts.getValue(DatabasesXmlTags.ATT_procedureName);
3246    String   parameterCountAttr = atts
3247        .getValue(DatabasesXmlTags.ATT_parameterCount);
3248    if (parameterCountAttr == null)
3249    {
3250      currentSemantic = new StoredProcedureSemantic(procedureName);
3251      return;
3252    }
3253
3254    int parameterCount;
3255    try
3256    {
3257      parameterCount = Integer.valueOf(parameterCountAttr).intValue();
3258    }
3259    catch (NumberFormatException   e)
3260    {
3261      parameterCount = -1;
3262    }
3263    if (parameterCount < 0)
3264      throw new SAXException  (
3265          "Invalid parameter count for stored procedure semantic "
3266              + procedureName);
3267
3268    currentSemantic = new StoredProcedureSemantic(procedureName, parameterCount);
3269  }
3270
3271  /**
3272   * Set the current semantic with a new trigger semantic.
3273   * 
3274   * @param atts parsed attributes
3275   * @exception SAXException if error occurs
3276   */
3277  private void newTriggerSemantic(Attributes   atts)
3278  {
3279    String   triggerName = atts.getValue(DatabasesXmlTags.ATT_triggerName);
3280    String   onTableOrVie = atts.getValue(DatabasesXmlTags.ATT_onTableOrView);
3281    currentSemantic = new TriggerSemantic(triggerName, onTableOrVie);
3282  }
3283
3284  /**
3285   * Adds a new view semantic using the parsed attributes.
3286   * 
3287   * @param atts parsed attributes
3288   */
3289  private void newViewSemantic(Attributes   atts)
3290  {
3291    String   viewName = atts.getValue(DatabasesXmlTags.ATT_viewName);
3292    String   readSet = atts.getValue(DatabasesXmlTags.ATT_readSet);
3293    String   writeSet = atts.getValue(DatabasesXmlTags.ATT_writeSet);
3294
3295    SortedSet   readTables = new TreeSet  ();
3296    StringTokenizer   st = new StringTokenizer  (readSet, ",");
3297    while (st.hasMoreTokens())
3298    {
3299      readTables.add(st.nextToken().trim());
3300    }
3301
3302    SortedSet   writeTables = new TreeSet  ();
3303    StringTokenizer   st2 = new StringTokenizer  (writeSet, ",");
3304    while (st2.hasMoreTokens())
3305    {
3306      writeTables.add(st2.nextToken().trim());
3307    }
3308
3309    currentVirtualDatabase.getSemanticManager().addViewSemantic(
3310        new ViewSemantic(viewName, readTables, writeTables));
3311  }
3312
3313}
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags