Java > Open Source Codes > com > jcorporate > expresso > services > dbobj > Setup


1 /* ====================================================================
2  * The Jcorporate Apache Style Software License, Version 1.2 05-07-2002
3  *
4  * Copyright (c) 1995-2002 Jcorporate Ltd. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  * notice, this list of conditions and the following disclaimer.
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright
14  * notice, this list of conditions and the following disclaimer in
15  * the documentation and/or other materials provided with the
16  * distribution.
17  *
18  * 3. The end-user documentation included with the redistribution,
19  * if any, must include the following acknowledgment:
20  * "This product includes software developed by Jcorporate Ltd.
21  * (http://www.jcorporate.com/)."
22  * Alternately, this acknowledgment may appear in the software itself,
23  * if and wherever such third-party acknowledgments normally appear.
24  *
25  * 4. "Jcorporate" and product names such as "Expresso" must
26  * not be used to endorse or promote products derived from this
27  * software without prior written permission. For written permission,
28  * please contact info@jcorporate.com.
29  *
30  * 5. Products derived from this software may not be called "Expresso",
31  * or other Jcorporate product names; nor may "Expresso" or other
32  * Jcorporate product names appear in their name, without prior
33  * written permission of Jcorporate Ltd.
34  *
35  * 6. No product derived from this software may compete in the same
36  * market space, i.e. framework, without prior written permission
37  * of Jcorporate Ltd. For written permission, please contact
38  * partners@jcorporate.com.
39  *
40  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
41  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
42  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
43  * DISCLAIMED. IN NO EVENT SHALL JCORPORATE LTD OR ITS CONTRIBUTORS
44  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
45  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
46  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
47  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
48  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
49  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
50  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * ====================================================================
53  *
54  * This software consists of voluntary contributions made by many
55  * individuals on behalf of the Jcorporate Ltd. Contributions back
56  * to the project(s) are encouraged when you make modifications.
57  * Please send them to support@jcorporate.com. For more information
58  * on Jcorporate Ltd. and its products, please see
59  * <http://www.jcorporate.com/>.
60  *
61  * Portions of this software are based upon other open source
62  * products and are subject to their respective licenses.
63  */
64
65 package com.jcorporate.expresso.services.dbobj;
66
67 import com.jcorporate.expresso.core.ExpressoSchema;
68 import com.jcorporate.expresso.core.cache.CacheException;
69 import com.jcorporate.expresso.core.cache.CacheManager;
70 import com.jcorporate.expresso.core.cache.CacheSystem;
71 import com.jcorporate.expresso.core.controller.ControllerRequest;
72 import com.jcorporate.expresso.core.db.DBConnection;
73 import com.jcorporate.expresso.core.db.DBConnectionPool;
74 import com.jcorporate.expresso.core.db.DBException;
75 import com.jcorporate.expresso.core.dbobj.SecuredDBObject;
76 import com.jcorporate.expresso.core.dbobj.ValidValue;
77 import com.jcorporate.expresso.core.misc.ConfigManager;
78 import com.jcorporate.expresso.core.misc.ConfigurationException;
79 import com.jcorporate.expresso.core.misc.StringUtil;
80 import org.apache.log4j.Logger;
81
82 import java.util.Enumeration ;
83 import java.util.HashSet ;
84 import java.util.Iterator ;
85
86
87 /**
88  * <p>Copyright 1999, 2000, 2001 Jcorporate Ltd.</p>
89  * <p>Setup is a generic configuration/setup value table. Each schema can
90  * define a number of default setup values that are created when the
91  * schema is initialized. The user can then customize these values.</p>
92  *
93  * @author Michael Nash
94  */
95 public class Setup
96         extends SecuredDBObject {
97
98     /**
99      * Is the setup cache initialized?
100      */
101     private static boolean cacheInitialized = false;
102
103     /**
104      * Name of the setup cache file.
105      */
106     public static final String CACHE_NAME = Setup.class.getName() + ".setupCache";
107
108     /**
109      * The Log4J Logger Instance
110      */
111     private static Logger log = Logger.getLogger(Setup.class);
112
113
114     /**
115      * Contains a list of tableExists objects
116      */
117     private static HashSet tableNotExists = new HashSet ();
118     public static final String SETUP_CODE = "SetupCode";
119     public static final String SETUP_DESCRIP = "Descrip";
120     public static final String SETUP_VALUE = "SetupValue";
121     public static final String SCHEMA_CLASS = "SchemaClass";
122
123     /**
124      * Constructor
125      *
126      * @throws DBException upon error
127      */
128     public Setup()
129             throws DBException {
130         super();
131     } /* Setup() */
132
133
134     /**
135      * Initializes Setup with proper user context
136      *
137      * @param uid the Owning user's uid
138      * @throws DBException upon error
139      */
140     public Setup(int uid)
141             throws DBException {
142         super(uid);
143     }
144
145     /**
146      * For using DBObjects within Controllers. Initializes based upon the
147      * current user and the requested db. [Of course this can be modified later]
148      *
149      * @param request - The controller request handed to you by the framework.
150      * @throws DBException upon error
151      */
152     public Setup(ControllerRequest request)
153             throws DBException {
154         super(request);
155     }
156
157     /**
158      * Extend add to call updatepool
159      *
160      * @throws DBException upon error
161      */
162     public synchronized void add()
163             throws DBException {
164         super.add();
165         updateCache();
166     } /* add() */
167
168
169     /**
170      * Extend update to call updatepool
171      *
172      * @throws DBException upon error
173      */
174     public synchronized void delete()
175             throws DBException {
176         super.delete();
177         updateCache();
178     } /* delete() */
179
180
181     /**
182      * @return boolean true if something was indeed found.
183      * @throws DBException upon error
184      */
185     public boolean find()
186             throws DBException {
187         if (getField(SCHEMA_CLASS).equals("")) {
188             setField(SCHEMA_CLASS, ExpressoSchema.class.getName());
189         }
190
191         return super.find();
192     } /* find() */
193
194
195     /**
196      * Get a config value for the default schema
197      * Config values are like INI file variables or registry entries - except
198      * stored in a database. There is one database connection held open for
199      * accessing these values from the connection pool. This function simply
200      * references the Expresso Schema's setup values. For your own application
201      * you will want to call the getValue that names your Schema
202      *
203      * @param dbName The data context to get the value for
204      * @param setupCode The code string of the setup code required
205      * @return String value stored in the given config value
206      * @throws DBException If the value cannot be retrieved
207      */
208     public static String getValue(String dbName, String setupCode)
209             throws DBException {
210
211         if (tableNotExists.contains(dbName)) {
212             if (log.isDebugEnabled()) {
213                 log.debug("No setup info yet for db " + dbName);
214             }
215
216             return "";
217         }
218
219         return getValue(dbName, "com.jcorporate.expresso.core.ExpressoSchema",
220                 setupCode);
221     } /* getValue(String, String) */
222
223
224     /**
225      * Get a config value for the default schema
226      * Config values are like INI file variables or registry entries - except
227      * stored in a database. There is one database connection held open for
228      * accessing these values from the connection pool
229      *
230      * @param dbName The data context name
231      * @param schemaName The name of the schema
232      * @param setupCode The code string of the setup code required
233      * @return String value stored in the given config value
234      * @throws DBException If the value cannot be retrieved
235      */
236     public static String getValue(String dbName, String schemaName,
237                                   String setupCode)
238             throws DBException {
239         if (StringUtil.notNull(dbName).equals("")) {
240             dbName = DBConnection.DEFAULT_DB_CONTEXT_NAME;
241         }
242
243
244         // handle case where caching is turned off
245 boolean isCaching = false;
246         try {
247             isCaching = ConfigManager.getJdbc(dbName).cache();
248         } catch (ConfigurationException e) {
249             throw new DBException(e);
250         }
251
252         if (!isCaching) {
253             Setup sl = new Setup(SecuredDBObject.SYSTEM_ACCOUNT);
254             sl.setDataContext(dbName);
255             sl.setField(SETUP_CODE, setupCode);
256             sl.setField(SCHEMA_CLASS, schemaName);
257             sl.retrieve();
258
259             return ConfigManager.expandValue(StringUtil.notNull(sl.getField(SETUP_VALUE)));
260         }
261
262
263         // handle case where caching is on
264 CacheManager.getInstance(); // must precede access
265
266         if (tableNotExists.contains(dbName)) {
267             if (log.isDebugEnabled()) {
268                 log.debug("No setup info yet for db " + dbName);
269             }
270
271             return ("");
272         }
273         if (StringUtil.notNull(schemaName).equals("")) {
274             throw new DBException("Schema name may not be null or blank");
275         }
276         if (StringUtil.notNull(setupCode).equals("")) {
277             throw new DBException("Setup code may not be null or blank");
278         }
279
280         if (!CacheManager.existsCache(dbName, CACHE_NAME) && isCaching) {
281             log.info("Setup cache did not exist - reading setup values");
282             readSetups();
283         }
284
285         /**
286          * If there are no items in the cache, re-read them
287          * (as it probably got cleared by the cache manager)
288          */
289         int itemCount = CacheManager.getItemCount(dbName, CACHE_NAME);
290
291         if (itemCount == 0) {
292
293             if (isCaching) {
294                 log.info("Setup cache did not exist - reading setup values");
295                 readSetups();
296             }
297
298             itemCount = CacheManager.getItemCount(dbName, CACHE_NAME);
299
300             if (itemCount == 0) {
301                 log.error("For context: " + dbName + ", Setup cache still has zero items after re-reading");
302             }
303         }
304
305         ValidValue oneItem = (ValidValue) CacheManager.getItem(dbName,
306                 CACHE_NAME,
307                 schemaName + "|" + setupCode);
308
309         if (oneItem == null) {
310             return null;
311         }
312
313         return ConfigManager.expandValue(StringUtil.notNull(oneItem.getDescription()));
314     } /* getValue(String, String, String) */
315
316
317     /**
318      * Get a value from the configuration values. The value must be
319      * valid (not null) or the method throws an exception
320      *
321      * @param dbName The datacontext name
322      * @param setupCode Code of the required setup value
323      * @return java.lang.String
324      * @throws DBException if the value does not exist or is null
325      */
326     public static String getValueRequired(String dbName, String setupCode)
327             throws DBException {
328         String setupValue = null;
329
330         if (tableNotExists.contains(dbName)) {
331             throw new DBException("No Setup Value '" + setupCode +
332                     "' for default schema, db '" + dbName + "'" +
333                     " Table does not yet exist");
334         }
335
336         setupValue = getValue(dbName, setupCode);
337
338         if (setupValue == null) {
339             throw new DBException("No value supplied in setup for '" +
340                     setupCode + "' for default schema, db '" +
341                     dbName + "'");
342         } else {
343             return setupValue;
344         }
345     } /* getValueRequired(String, String) */
346
347
348     /**
349      * Get a value from the configuration values. Return null (no exception) if value doesn't exist
350      *
351      * @param dbName The datacontext name
352      * @param setupCode Code of the required setup value
353      * @return java.lang.String of value, or null if not found
354      */
355     public static String getValueUnrequired(String dbName, String setupCode) {
356         String setupValue = null;
357
358         try {
359             setupValue = getValue(dbName, setupCode);
360             // getvalue can return "" for some error cases
361 if ("".equals(setupValue)) {
362                 setupValue = null;
363             }
364         } catch (DBException e) {
365             // no problem
366 }
367
368         return setupValue;
369     } /* getValueRequired(String, String) */
370
371     /**
372      * Get a value from the configuration values. Return null (no exception) if value doesn't exist
373      *
374      * @param dbName The datacontext name
375      * @param setupCode Code of the required setup value
376      * @param schema name of schema
377      * @return java.lang.String of value, or null if not found
378      */
379     public static String getValueUnrequired(String dbName, String schema, String setupCode) {
380         String setupValue = null;
381
382         try {
383             setupValue = getValue(dbName, schema, setupCode);
384             // getvalue can return "" for some error cases
385 if ("".equals(setupValue)) {
386                 setupValue = null;
387             }
388         } catch (DBException e) {
389             // no problem
390 }
391
392         return setupValue;
393     } /* getValueRequired(String, String) */
394
395
396     /**
397      * Get a value from the configuration values. The value must be
398      * valid or the method throws an exception
399      *
400      * @param dbName The data context for the value
401      * @param schema The schema class for this setup code
402      * @param setupCode Code of the required setup value
403      * @return String
404      * @throws DBException if the value does not exist or is null
405      */
406     public static String getValueRequired(String dbName, String schema,
407                                           String setupCode)
408             throws DBException {
409
410         if (tableNotExists.contains(dbName)) {
411             throw new DBException("No Setup Value '" + setupCode +
412                     "' for default schema, db '" + dbName + "'" +
413                     " Table does not yet exist");
414         }
415         if (schema.equals("")) {
416             return getValueRequired(dbName, setupCode);
417         }
418         if (StringUtil.notNull(dbName).equals("")) {
419             dbName = "default";
420         }
421
422         String setupValue = getValue(dbName, schema, setupCode);
423
424         if (setupValue == null) {
425             throw new DBException("No value supplied in setup for '" +
426                     setupCode + "' for schema '" + schema +
427                     "', db '" + dbName + "'");
428         } else {
429             return setupValue;
430         }
431     } /* getValueRequired(String, String, String) */
432
433
434     /**
435      * Check if this setup value is a directory
436      *
437      * @throws DBException upon error
438      */
439     private void isDirectory()
440             throws DBException {
441
442         /* It's OK for the value to be blank */
443         if (ConfigManager.expandValue(getField(SETUP_VALUE)).equals("")) {
444             return;
445         }
446         /* if it's not blank, it must be a directory name */
447         if (!ConfigManager.expandValue(getField(SETUP_VALUE)).endsWith("/")) {
448             throw new DBException("Setup value '" + getField(SETUP_VALUE) +
449                     "' for code '" + getField(SETUP_CODE) +
450                     "' (" + getField(SETUP_DESCRIP) +
451                     ") is not a valid directory name. Must use '/' as " +
452                     "path seperator and end with '/'");
453         }
454     } /* isDirectory() */
455
456
457     /**
458      * @param forceRead - Tries to reread the setup values even if the db tables
459      * don't exist yet.
460      * @throws DBException if there's an error reading the setups
461      */
462     public static synchronized void readSetups(boolean forceRead)
463             throws DBException {
464
465         if (!ConfigManager.isInitialized()) {
466             throw new DBException("ConfigManager was not initialized",
467                     ConfigManager.getConfigurationFailureException());
468         }
469
470         log.info("Reading setup values for all databases/contexts");
471
472         CacheManager.getInstance(); // must precede accesses
473 int keyCount = 0;
474         String oneConfigKey = null;
475         for (Enumeration e = ConfigManager.getAllConfigKeys();
476              e.hasMoreElements();) {
477             keyCount++;
478
479             /* We do an inner try here so that if we can't read
480             setup values for one */
481             /* database, we continue & try to */
482             /* read values for the rest of the databases */
483             boolean skipThisContext = false;
484
485             try {
486                 oneConfigKey = (String ) e.nextElement();
487
488                 /* If the table doesn't exist, unless we're told to force
489                 read, don't do it */
490                 skipThisContext = false;
491
492                 if (tableNotExists.contains(oneConfigKey)) {
493                     skipThisContext = true;
494                 }
495                 if (forceRead) {
496                     skipThisContext = false;
497                 }
498                 /* If we're specifically told in the expresso-config.xml file
499                 * that a particular context is NOT an "expresso"
500                 * context - e.g. doesn't contain Expresso tables, then don't
501                 * try to read setup values from it.
502                 */
503                 try {
504                     if (!ConfigManager.getContext(oneConfigKey)
505                             .hasSetupTables()) {
506                         skipThisContext = true;
507                     }
508                 } catch (ConfigurationException ce) {
509                     throw new DBException(ce);
510                 }
511                 if (!skipThisContext) {
512                     CacheSystem cs = CacheManager.getCacheSystem(oneConfigKey);
513                     if (log.isInfoEnabled()) {
514                         log.info("Reading setup values for '" + oneConfigKey +
515                                 "'");
516                     }
517
518                     if (!cs.existsCache(CACHE_NAME)) {
519                         cs.createCache(CACHE_NAME,
520                                 false);
521                     }
522
523                     Setup sl = new Setup(SecuredDBObject.SYSTEM_ACCOUNT);
524                     sl.setDataContext(oneConfigKey);
525
526                     Setup oneSetup = null;
527                     int setupCount = 0;
528
529                     for (Iterator ek = sl.searchAndRetrieveList().iterator();
530                          ek.hasNext();) {
531                         setupCount++;
532                         oneSetup = (Setup) ek.next();
533                         CacheManager.addItem(oneConfigKey, CACHE_NAME,
534                                 new ValidValue(oneSetup.getField(SCHEMA_CLASS) + "|" +
535                                 oneSetup.getField(SETUP_CODE),
536                                         oneSetup.getField(SETUP_VALUE)));
537                     }
538                     if (setupCount == 0) {
539                         throw new DBException("No setup values were read" +
540                                 "in db '" + oneConfigKey +
541                                 "'. Run DBCreate to setup default " +
542                                 "setup values.");
543                     } else {
544                         log.info(setupCount + " setup entries read in db '" +
545                                 oneConfigKey + "'");
546                     }
547
548                     DBConnectionPool onePool = DBConnectionPool.getInstance(oneConfigKey);
549
550                     String maxConnect = StringUtil.notNull(getValue(oneConfigKey, "MaxConnections"));
551
552                     if (!maxConnect.equals("")) {
553                         try {
554                             int newMax = new Integer (maxConnect).intValue();
555                             onePool.setMaxConnections(newMax);
556                         } catch (NumberFormatException ne) {
557                             throw new DBException("Value for MaxConnections" +
558                                     "must be a number");
559                         }
560                     }
561                     try {
562                         String timeOut = StringUtil.notNull(getValue(oneConfigKey,
563                                 "ConnTimeOut"));
564                         int interval = 30;
565
566                         if (!timeOut.equals("")) {
567                             interval = new Integer (getValue(oneConfigKey,
568                                     "ConnTimeOut")).intValue();
569                         }
570
571                         onePool.setTimeOutInterval(interval);
572                     } catch (NumberFormatException ne) {
573                         throw new DBException("Value for ConnTimeOut is " +
574                                 "not a number. Check setup values");
575                     }
576                 } /* End if Force Read */
577
578             } catch (DBException de) {
579                 log.error("WARNING: Unable to read setup values for db '"
580                         + oneConfigKey + "'", de);
581
582                 /* Assume that the table is unreadable right now,
583                 try after a DBCreate */
584                 tableNotExists.add(oneConfigKey);
585             } catch (CacheException ce) {
586                 log.error("WARNING: Cache error reading setup values for db '"
587                         + oneConfigKey + "'", ce);
588             }
589         }
590         /* for each config key */
591         if (keyCount == 0) {
592             throw new DBException("No config keys to read setup values"
593                     + "for - there must be at least the " +
594                     "default config key/db");
595         }
596
597         cacheInitialized = true;
598     }
599
600     /**
601      * Read the setup/config values into a hashtable for cached access
602      *
603      * @throws DBException upon error
604      */
605     public static synchronized void readSetups()
606             throws DBException {
607         readSetups(false);
608     } /* readSetups() */
609
610
611     /**
612      * Extend retrieve to supply a defeult for the schemaclass field
613      *
614      * @throws DBException If the retrieve fails
615      */
616     public synchronized void retrieve()
617             throws DBException {
618         if (getField(SCHEMA_CLASS).equals("")) {
619             setField(SCHEMA_CLASS, ExpressoSchema.class.getName());
620         }
621
622         super.retrieve();
623     } /* retrieve() */
624
625
626     /**
627      * DB Tool calls this when the Expresso Setup Values are finally able to be
628      * read
629      *
630      * @param dbName the data context that setup tables now exist for
631      */
632     public static synchronized void setTableExists(String dbName) {
633         if (tableNotExists.contains(dbName)) {
634             tableNotExists.remove(dbName);
635         }
636     }
637
638     /**
639      * @see com.jcorporate.expresso.core.dbobj.SecuredDBObject#setupFields
640      */
641     protected synchronized void setupFields()
642             throws DBException {
643         setTargetTable("SETUP");
644         setDescription("DBsetup");
645         setCharset("ISO-8859-1");
646         addField(SCHEMA_CLASS, "char", 128, false, "schema");
647         addField(SETUP_CODE, "char", 30, false, SETUP_CODE);
648         addField(SETUP_DESCRIP, "char", 80, false, "description");
649         addField(SETUP_VALUE, "varchar", 255, true, SETUP_VALUE);
650         setStringFilter(SCHEMA_CLASS, "stripFilter");
651         setStringFilter(SETUP_CODE, "stripFilter");
652         setStringFilter(SETUP_DESCRIP, "stripFilter");
653         setStringFilter(SETUP_VALUE, "rawFilter");
654         addKey(SCHEMA_CLASS);
655         addKey(SETUP_CODE);
656         setMultiValued(SCHEMA_CLASS);
657         setLookupObject(SCHEMA_CLASS, SchemaList.class.getName());
658     } /* setupFields() */
659
660
661     /**
662      * Extend update to validate some setup values
663      *
664      * @throws DBException upon error
665      */
666     public synchronized void update()
667             throws DBException {
668
669         /* Verify the field has a valid value */
670         if (getField(SETUP_CODE).equals("BaseDir")) {
671             isDirectory();
672         } else if (getField(SETUP_CODE).equals("QueueDirectory")) {
673             isDirectory();
674         } else if (getField(SETUP_CODE).equals("ReportRoot")) {
675             isDirectory();
676         } else if (getField(SETUP_CODE).equals("TempDir")) {
677             isDirectory();
678         }
679
680         super.update();
681         updateCache();
682     } /* update() */
683
684
685     /**
686      * updateCache is called when we've updated setup values,
687      * so they must be read into the cache again
688      *
689      * @throws DBException upon error
690      */
691     private void updateCache()
692             throws DBException {
693
694         /* If we've already read a cache, read it again */
695         if (cacheInitialized) {
696             readSetups();
697         }
698     } /* updateCache() */
699
700     /**
701      * convenience setter for code
702      *
703      * @param code new code to set
704      */
705     public void setCode(String code) throws DBException {
706         setField(SETUP_CODE, code);
707     }
708
709     /**
710      * convenience setter for value
711      *
712      * @param value new value to set
713      */
714     public void setValue(String value) throws DBException {
715         setField(SETUP_VALUE, value);
716     }
717
718     /**
719      * convenience setter for description of Setup item
720      *
721      * @param descrip new description to set
722      */
723     public void setDescrip(String descrip) throws DBException {
724         setField(SETUP_DESCRIP, descrip);
725     }
726
727     /**
728      * convenience setter for schema class; schema is optional; if not provided, find() will default to Expresso
729      *
730      * @param schemaclassname new name to set
731      */
732     public void setSchemaClass(String schemaclassname) throws DBException {
733         setField(SCHEMA_CLASS, schemaclassname);
734     }
735
736 } /* Setup */
737

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags