roundup/instance.py

   1 #
   2 # Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
   3 # This module is free software, and you may redistribute it and/or modify
   4 # under the same terms as Python, so long as this copyright message and
   5 # disclaimer are retained in their original form.
   6 #
   7 # IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
   8 # DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
   9 # OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
  10 # POSSIBILITY OF SUCH DAMAGE.
  11 #
  12 # BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  13 # BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  14 # FOR A PARTICULAR PURPOSE.  THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
  15 # BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
  16 # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  17 #
  18
  19 """Tracker handling (open tracker).
  20
  21 Backwards compatibility for the old-style "imported" trackers.
  22 """
  23 __docformat__ = 'restructuredtext'
  24
  25 import os
  26 import sys
  27 from roundup import configuration, mailgw
  28 from roundup import hyperdb, backends, actions
  29 from roundup.cgi import client, templating
  30 from roundup.cgi import actions as cgi_actions
  31
  32 class Vars:
  33     def __init__(self, vars):
  34         self.__dict__.update(vars)
  35
  36 class Tracker:
  37     def __init__(self, tracker_home, optimize=0):
  38         """New-style tracker instance constructor
  39
  40         Parameters:
  41             tracker_home:
  42                 tracker home directory
  43             optimize:
  44                 if set, precompile html templates
  45
  46         """
  47         self.tracker_home = tracker_home
  48         self.optimize = optimize
  49         # if set, call schema_hook after executing schema.py will get
  50         # same variables (in particular db) as schema.py main purpose is
  51         # for regression tests
  52         self.schema_hook = None
  53         self.config = configuration.CoreConfig(tracker_home)
  54         self.actions = {}
  55         self.cgi_actions = {}
  56         self.templating_utils = {}
  57         self.load_interfaces()
  58         self.templates = templating.Templates(self.config["TEMPLATES"])
  59         self.backend = backends.get_backend(self.get_backend_name())
  60         if self.optimize:
  61             libdir = os.path.join(self.tracker_home, 'lib')
  62             if os.path.isdir(libdir):
  63                 sys.path.insert(1, libdir)
  64             self.templates.precompileTemplates()
  65             # initialize tracker extensions
  66             for extension in self.get_extensions('extensions'):
  67                 extension(self)
  68             # load database schema
  69             schemafilename = os.path.join(self.tracker_home, 'schema.py')
  70             # Note: can't use built-in open()
  71             #   because of the global function with the same name
  72             schemafile = file(schemafilename, 'rt')
  73             self.schema = compile(schemafile.read(), schemafilename, 'exec')
  74             schemafile.close()
  75             # load database detectors
  76             self.detectors = self.get_extensions('detectors')
  77             # db_open is set to True after first open()
  78             self.db_open = 0
  79             if libdir in sys.path:
  80                 sys.path.remove(libdir)
  81
  82     def get_backend_name(self):
  83         o = __builtins__['open']
  84         f = o(os.path.join(self.config.DATABASE, 'backend_name'))
  85         name = f.readline().strip()
  86         f.close()
  87         return name
  88
  89     def open(self, name=None):
  90         # load the database schema
  91         # we cannot skip this part even if self.optimize is set
  92         # because the schema has security settings that must be
  93         # applied to each database instance
  94         backend = self.backend
  95         vars = {
  96             'Class': backend.Class,
  97             'FileClass': backend.FileClass,
  98             'IssueClass': backend.IssueClass,
  99             'String': hyperdb.String,
 100             'Password': hyperdb.Password,
 101             'Date': hyperdb.Date,
 102             'Link': hyperdb.Link,
 103             'Multilink': hyperdb.Multilink,
 104             'Interval': hyperdb.Interval,
 105             'Boolean': hyperdb.Boolean,
 106             'Number': hyperdb.Number,
 107             'db': backend.Database(self.config, name)
 108         }
 109
 110         if self.optimize:
 111             # execute preloaded schema object
 112             exec(self.schema, vars)
 113             if callable (self.schema_hook):
 114                 self.schema_hook(**vars)
 115             # use preloaded detectors
 116             detectors = self.detectors
 117         else:
 118             libdir = os.path.join(self.tracker_home, 'lib')
 119             if os.path.isdir(libdir):
 120                 sys.path.insert(1, libdir)
 121             # execute the schema file
 122             self._load_python('schema.py', vars)
 123             if callable (self.schema_hook):
 124                 self.schema_hook(**vars)
 125             # reload extensions and detectors
 126             for extension in self.get_extensions('extensions'):
 127                 extension(self)
 128             detectors = self.get_extensions('detectors')
 129             if libdir in sys.path:
 130                 sys.path.remove(libdir)
 131         db = vars['db']
 132         # apply the detectors
 133         for detector in detectors:
 134             detector(db)
 135         # if we are running in debug mode
 136         # or this is the first time the database is opened,
 137         # do database upgrade checks
 138         if not (self.optimize and self.db_open):
 139             # As a consistency check, ensure that every link property is
 140             # pointing at a defined class.  Otherwise, the schema is
 141             # internally inconsistent.  This is an important safety
 142             # measure as it protects against an accidental schema change
 143             # dropping a table while there are still links to the table;
 144             # once the table has been dropped, there is no way to get it
 145             # back, so it is important to drop it only if we are as sure
 146             # as possible that it is no longer needed.
 147             classes = db.getclasses()
 148             for classname in classes:
 149                 cl = db.getclass(classname)
 150                 for propname, prop in cl.getprops().iteritems():
 151                     if not isinstance(prop, (hyperdb.Link,
 152                                              hyperdb.Multilink)):
 153                         continue
 154                     linkto = prop.classname
 155                     if linkto not in classes:
 156                         raise ValueError, \
 157                             ("property %s.%s links to non-existent class %s"
 158                              % (classname, propname, linkto))
 159
 160             db.post_init()
 161             self.db_open = 1
 162         return db
 163
 164     def load_interfaces(self):
 165         """load interfaces.py (if any), initialize Client and MailGW attrs"""
 166         vars = {}
 167         if os.path.isfile(os.path.join(self.tracker_home, 'interfaces.py')):
 168             self._load_python('interfaces.py', vars)
 169         self.Client = vars.get('Client', client.Client)
 170         self.MailGW = vars.get('MailGW', mailgw.MailGW)
 171
 172     def get_extensions(self, dirname):
 173         """Load python extensions
 174
 175         Parameters:
 176             dirname:
 177                 extension directory name relative to tracker home
 178
 179         Return value:
 180             list of init() functions for each extension
 181
 182         """
 183         extensions = []
 184         dirpath = os.path.join(self.tracker_home, dirname)
 185         if os.path.isdir(dirpath):
 186             sys.path.insert(1, dirpath)
 187             for name in os.listdir(dirpath):
 188                 if not name.endswith('.py'):
 189                     continue
 190                 vars = {}
 191                 self._load_python(os.path.join(dirname, name), vars)
 192                 extensions.append(vars['init'])
 193             sys.path.remove(dirpath)
 194         return extensions
 195
 196     def init(self, adminpw):
 197         db = self.open('admin')
 198         self._load_python('initial_data.py', {'db': db, 'adminpw': adminpw,
 199             'admin_email': self.config['ADMIN_EMAIL']})
 200         db.commit()
 201         db.close()
 202
 203     def exists(self):
 204         return self.backend.db_exists(self.config)
 205
 206     def nuke(self):
 207         self.backend.db_nuke(self.config)
 208
 209     def _load_python(self, file, vars):
 210         file = os.path.join(self.tracker_home, file)
 211         execfile(file, vars)
 212         return vars
 213
 214     def registerAction(self, name, action):
 215
 216         # The logic here is this:
 217         # * if `action` derives from actions.Action,
 218         #   it is executable as a generic action.
 219         # * if, moreover, it also derives from cgi.actions.Bridge,
 220         #   it may in addition be called via CGI
 221         # * in all other cases we register it as a CGI action, without
 222         #   any check (for backward compatibility).
 223         if issubclass(action, actions.Action):
 224             self.actions[name] = action
 225             if issubclass(action, cgi_actions.Bridge):
 226                 self.cgi_actions[name] = action
 227         else:
 228             self.cgi_actions[name] = action
 229
 230     def registerUtil(self, name, function):
 231         self.templating_utils[name] = function
 232
 233 class TrackerError(Exception):
 234     pass
 235
 236
 237 class OldStyleTrackers:
 238     def __init__(self):
 239         self.number = 0
 240         self.trackers = {}
 241
 242     def open(self, tracker_home, optimize=0):
 243         """Open the tracker.
 244
 245         Parameters:
 246             tracker_home:
 247                 tracker home directory
 248             optimize:
 249                 if set, precompile html templates
 250
 251         Raise ValueError if the tracker home doesn't exist.
 252
 253         """
 254         import imp
 255         # sanity check existence of tracker home
 256         if not os.path.exists(tracker_home):
 257             raise ValueError, 'no such directory: "%s"'%tracker_home
 258
 259         # sanity check tracker home contents
 260         for reqd in 'config dbinit select_db interfaces'.split():
 261             if not os.path.exists(os.path.join(tracker_home, '%s.py'%reqd)):
 262                 raise TrackerError, 'File "%s.py" missing from tracker '\
 263                     'home "%s"'%(reqd, tracker_home)
 264
 265         if self.trackers.has_key(tracker_home):
 266             return imp.load_package(self.trackers[tracker_home],
 267                 tracker_home)
 268         # register all available backend modules
 269         backends.list_backends()
 270         self.number = self.number + 1
 271         modname = '_roundup_tracker_%s'%self.number
 272         self.trackers[tracker_home] = modname
 273
 274         # load the tracker
 275         tracker = imp.load_package(modname, tracker_home)
 276
 277         # ensure the tracker has all the required bits
 278         for required in 'open init Client MailGW'.split():
 279             if not hasattr(tracker, required):
 280                 raise TrackerError, \
 281                     'Required tracker attribute "%s" missing'%required
 282
 283         # load and apply the config
 284         tracker.config = configuration.CoreConfig(tracker_home)
 285         tracker.dbinit.config = tracker.config
 286
 287         tracker.optimize = optimize
 288         tracker.templates = templating.Templates(tracker.config["TEMPLATES"])
 289         if optimize:
 290             tracker.templates.precompileTemplates()
 291
 292         return tracker
 293
 294 OldStyleTrackers = OldStyleTrackers()
 295 def open(tracker_home, optimize=0):
 296     if os.path.exists(os.path.join(tracker_home, 'dbinit.py')):
 297         # user should upgrade...
 298         return OldStyleTrackers.open(tracker_home, optimize=optimize)
 299
 300     return Tracker(tracker_home, optimize=optimize)
 301
 302 # vim: set filetype=python sts=4 sw=4 et si :