roundup/backends/back_gadfly.py

   1 # $Id: back_gadfly.py,v 1.1 2002-08-22 07:56:51 richard Exp $
   2 __doc__ = '''
   3 About Gadfly
   4 ============
   5
   6 Gadfly  is  a  collection  of  python modules that provides relational
   7 database  functionality  entirely implemented in Python. It supports a
   8 subset  of  the intergalactic standard RDBMS Structured Query Language
   9 SQL.
  10
  11
  12 Basic Structure
  13 ===============
  14
  15 We map roundup classes to relational tables. Automatically detect schema
  16 changes and modify the gadfly table schemas appropriately. Multilinks
  17 (which represent a many-to-many relationship) are handled through
  18 intermediate tables.
  19
  20 Journals are stored adjunct to the per-class tables.
  21
  22 Table columns for properties have "_" prepended so the names can't
  23 clash with restricted names (like "order"). Retirement is determined by the
  24 __retired__ column being true.
  25
  26 All columns are defined as VARCHAR, since it really doesn't matter what
  27 type they're defined as. We stuff all kinds of data in there ;) [as long as
  28 it's marshallable, gadfly doesn't care]
  29
  30
  31 Additional Instance Requirements
  32 ================================
  33
  34 The instance configuration must specify where the database is. It does this
  35 with GADFLY_DATABASE, which is used as the arguments to the gadfly.gadfly()
  36 method:
  37
  38 Using an on-disk database directly (not a good idea):
  39   GADFLY_DATABASE = (database name, directory)
  40
  41 Using a network database (much better idea):
  42   GADFLY_DATABASE = (policy, password, address, port)
  43
  44 Because multiple accesses directly to a gadfly database aren't handled, but
  45 multiple network accesses are, it's strongly advised that the latter setup be
  46 used.
  47
  48 '''
  49
  50 # standard python modules
  51 import sys, os, time, re, errno, weakref
  52
  53 # roundup modules
  54 from roundup import hyperdb, date, password, roundupdb, security
  55 from roundup.hyperdb import String, Password, Date, Interval, Link, \
  56     Multilink, DatabaseError, Boolean, Number
  57
  58 # the all-important gadfly :)
  59 import gadfly
  60 from gadfly import client
  61
  62 # support
  63 from blobfiles import FileStorage
  64 from roundup.indexer import Indexer
  65 from sessions import Sessions
  66
  67 class Database(FileStorage, hyperdb.Database, roundupdb.Database):
  68     # flag to set on retired entries
  69     RETIRED_FLAG = '__hyperdb_retired'
  70
  71     def __init__(self, config, journaltag=None):
  72         ''' Open the database and load the schema from it.
  73         '''
  74         self.config, self.journaltag = config, journaltag
  75         self.dir = config.DATABASE
  76         self.classes = {}
  77         self.indexer = Indexer(self.dir)
  78         self.sessions = Sessions(self.config)
  79         self.security = security.Security(self)
  80
  81         db = config.GADFLY_DATABASE
  82         if len(db) == 2:
  83             # ensure files are group readable and writable
  84             os.umask(0002)
  85             try:
  86                 self.conn = gadfly.gadfly(*db)
  87             except IOError, error:
  88                 if error.errno != errno.ENOENT:
  89                     raise
  90                 self.database_schema = {}
  91                 self.conn = gadfly.gadfly()
  92                 self.conn.startup(*db)
  93                 cursor = self.conn.cursor()
  94                 cursor.execute('create table schema (schema varchar)')
  95                 cursor.execute('create table ids (name varchar, num integer)')
  96             else:
  97                 cursor = self.conn.cursor()
  98                 cursor.execute('select schema from schema')
  99                 self.database_schema = cursor.fetchone()[0]
 100         else:
 101             self.conn = client.gfclient(*db)
 102             cursor = self.conn.cursor()
 103             cursor.execute('select schema from schema')
 104             self.database_schema = cursor.fetchone()[0]
 105
 106     def post_init(self):
 107         ''' Called once the schema initialisation has finished.
 108
 109             We should now confirm that the schema defined by our "classes"
 110             attribute actually matches the schema in the database.
 111         '''
 112         for classname, spec in self.classes.items():
 113             if self.database_schema.has_key(classname):
 114                 dbspec = self.database_schema[classname]
 115                 self.update_class(spec.schema(), dbspec)
 116                 self.database_schema[classname] = dbspec
 117             else:
 118                 self.create_class(spec)
 119                 self.database_schema[classname] = spec.schema()
 120
 121         for classname in self.database_schema.keys():
 122             if not self.classes.has_key(classname):
 123                 self.drop_class(classname)
 124
 125         # commit any changes
 126         cursor = self.conn.cursor()
 127         cursor.execute('delete from schema')
 128         cursor.execute('insert into schema values (?)', (self.database_schema,))
 129         self.conn.commit()
 130
 131     def determine_columns(self, spec):
 132         ''' Figure the column names and multilink properties from the spec
 133         '''
 134         cols = []
 135         mls = []
 136         # add the multilinks separately
 137         for col, prop in spec.properties.items():
 138             if isinstance(prop, Multilink):
 139                 mls.append(col)
 140             else:
 141                 cols.append('_'+col)
 142         cols.sort()
 143         return cols, mls
 144
 145     def update_class(self, spec, dbspec):
 146         ''' Determine the differences between the current spec and the
 147             database version of the spec, and update where necessary
 148         '''
 149         if spec == dbspec:
 150             return
 151         raise NotImplementedError
 152
 153     def create_class(self, spec):
 154         ''' Create a database table according to the given spec.
 155         '''
 156         cols, mls = self.determine_columns(spec)
 157
 158         # add on our special columns
 159         cols.append('id')
 160         cols.append('__retired__')
 161
 162         cursor = self.conn.cursor()
 163
 164         # create the base table
 165         cols = ','.join(['%s varchar'%x for x in cols])
 166         sql = 'create table %s (%s)'%(spec.classname, cols)
 167         if __debug__:
 168             print >>hyperdb.DEBUG, 'create_class', (self, sql)
 169         cursor.execute(sql)
 170
 171         # journal table
 172         cols = ','.join(['%s varchar'%x
 173             for x in 'nodeid date tag action params'.split()])
 174         sql = 'create table %s__journal (%s)'%(spec.classname, cols)
 175         if __debug__:
 176             print >>hyperdb.DEBUG, 'create_class', (self, sql)
 177         cursor.execute(sql)
 178
 179         # now create the multilink tables
 180         for ml in mls:
 181             sql = 'create table %s_%s (linkid varchar, nodeid varchar)'%(
 182                 spec.classname, ml)
 183             if __debug__:
 184                 print >>hyperdb.DEBUG, 'create_class', (self, sql)
 185             cursor.execute(sql)
 186
 187         # ID counter
 188         sql = 'insert into ids (name, num) values (?,?)'
 189         vals = (spec.classname, 1)
 190         if __debug__:
 191             print >>hyperdb.DEBUG, 'create_class', (self, sql, vals)
 192         cursor.execute(sql, vals)
 193
 194     def drop_class(self, spec):
 195         ''' Drop the given table from the database.
 196
 197             Drop the journal and multilink tables too.
 198         '''
 199         # figure the multilinks
 200         mls = []
 201         for col, prop in spec.properties.items():
 202             if isinstance(prop, Multilink):
 203                 mls.append(col)
 204         cursor = self.conn.cursor()
 205
 206         sql = 'drop table %s'%spec.classname
 207         if __debug__:
 208             print >>hyperdb.DEBUG, 'drop_class', (self, sql)
 209         cursor.execute(sql)
 210
 211         sql = 'drop table %s__journal'%spec.classname
 212         if __debug__:
 213             print >>hyperdb.DEBUG, 'drop_class', (self, sql)
 214         cursor.execute(sql)
 215
 216         for ml in mls:
 217             sql = 'drop table %s_%s'%(spec.classname, ml)
 218             if __debug__:
 219                 print >>hyperdb.DEBUG, 'drop_class', (self, sql)
 220             cursor.execute(sql)
 221
 222     #
 223     # Classes
 224     #
 225     def __getattr__(self, classname):
 226         ''' A convenient way of calling self.getclass(classname).
 227         '''
 228         if self.classes.has_key(classname):
 229             if __debug__:
 230                 print >>hyperdb.DEBUG, '__getattr__', (self, classname)
 231             return self.classes[classname]
 232         raise AttributeError, classname
 233
 234     def addclass(self, cl):
 235         ''' Add a Class to the hyperdatabase.
 236         '''
 237         if __debug__:
 238             print >>hyperdb.DEBUG, 'addclass', (self, cl)
 239         cn = cl.classname
 240         if self.classes.has_key(cn):
 241             raise ValueError, cn
 242         self.classes[cn] = cl
 243
 244     def getclasses(self):
 245         ''' Return a list of the names of all existing classes.
 246         '''
 247         if __debug__:
 248             print >>hyperdb.DEBUG, 'getclasses', (self,)
 249         l = self.classes.keys()
 250         l.sort()
 251         return l
 252
 253     def getclass(self, classname):
 254         '''Get the Class object representing a particular class.
 255
 256         If 'classname' is not a valid class name, a KeyError is raised.
 257         '''
 258         if __debug__:
 259             print >>hyperdb.DEBUG, 'getclass', (self, classname)
 260         return self.classes[classname]
 261
 262     def clear(self):
 263         ''' Delete all database contents.
 264
 265             Note: I don't commit here, which is different behaviour to the
 266             "nuke from orbit" behaviour in the *dbms.
 267         '''
 268         if __debug__:
 269             print >>hyperdb.DEBUG, 'clear', (self,)
 270         cursor = self.conn.cursor()
 271         for cn in self.classes.keys():
 272             sql = 'delete from %s'%cn
 273             if __debug__:
 274                 print >>hyperdb.DEBUG, 'clear', (self, sql)
 275             cursor.execute(sql)
 276
 277     #
 278     # Node IDs
 279     #
 280     def newid(self, classname):
 281         ''' Generate a new id for the given class
 282         '''
 283         # get the next ID
 284         cursor = self.conn.cursor()
 285         sql = 'select num from ids where name=?'
 286         if __debug__:
 287             print >>hyperdb.DEBUG, 'newid', (self, sql, classname)
 288         cursor.execute(sql, (classname, ))
 289         newid = cursor.fetchone()[0]
 290
 291         # update the counter
 292         sql = 'update ids set num=? where name=?'
 293         vals = (newid+1, classname)
 294         if __debug__:
 295             print >>hyperdb.DEBUG, 'newid', (self, sql, vals)
 296         cursor.execute(sql, vals)
 297
 298         # return as string
 299         return str(newid)
 300
 301     def setid(self, classname, setid):
 302         ''' Set the id counter: used during import of database
 303         '''
 304         cursor = self.conn.cursor()
 305         sql = 'update ids set num=? where name=?'
 306         vals = (setid, spec.classname)
 307         if __debug__:
 308             print >>hyperdb.DEBUG, 'setid', (self, sql, vals)
 309         cursor.execute(sql, vals)
 310
 311     #
 312     # Nodes
 313     #
 314
 315     def addnode(self, classname, nodeid, node):
 316         ''' Add the specified node to its class's db.
 317         '''
 318         # gadfly requires values for all non-multilink columns
 319         cl = self.classes[classname]
 320         cols, mls = self.determine_columns(cl)
 321
 322         # default the non-multilink columns
 323         for col, prop in cl.properties.items():
 324             if not isinstance(col, Multilink):
 325                 if not node.has_key(col):
 326                     node[col] = None
 327
 328         node = self.serialise(classname, node)
 329
 330         # make sure the ordering is correct for column name -> column value
 331         vals = tuple([node[col[1:]] for col in cols]) + (nodeid, 0)
 332         s = ','.join(['?' for x in cols]) + ',?,?'
 333         cols = ','.join(cols) + ',id,__retired__'
 334
 335         # perform the inserts
 336         cursor = self.conn.cursor()
 337         sql = 'insert into %s (%s) values (%s)'%(classname, cols, s)
 338         if __debug__:
 339             print >>hyperdb.DEBUG, 'addnode', (self, sql, vals)
 340         cursor.execute(sql, vals)
 341
 342         # insert the multilink rows
 343         for col in mls:
 344             t = '%s_%s'%(classname, col)
 345             for entry in node[col]:
 346                 sql = 'insert into %s (linkid, nodeid) values (?,?)'%t
 347                 vals = (entry, nodeid)
 348                 if __debug__:
 349                     print >>hyperdb.DEBUG, 'addnode', (self, sql, vals)
 350                 cursor.execute(sql, vals)
 351
 352     def setnode(self, classname, nodeid, node):
 353         ''' Change the specified node.
 354         '''
 355         node = self.serialise(classname, node)
 356
 357         cl = self.classes[classname]
 358         cols = []
 359         mls = []
 360         # add the multilinks separately
 361         for col in node.keys():
 362             prop = cl.properties[col]
 363             if isinstance(prop, Multilink):
 364                 mls.append(col)
 365             else:
 366                 cols.append('_'+col)
 367         cols.sort()
 368
 369         # make sure the ordering is correct for column name -> column value
 370         vals = tuple([node[col[1:]] for col in cols])
 371         s = ','.join(['?' for x in cols])
 372         cols = ','.join(cols)
 373
 374         # perform the update
 375         cursor = self.conn.cursor()
 376         sql = 'update %s (%s) values (%s)'%(classname, cols, s)
 377         if __debug__:
 378             print >>hyperdb.DEBUG, 'setnode', (self, sql, vals)
 379         cursor.execute(sql, vals)
 380
 381         # now the fun bit, updating the multilinks ;)
 382         # XXX TODO XXX
 383
 384     def getnode(self, classname, nodeid):
 385         ''' Get a node from the database.
 386         '''
 387         # figure the columns we're fetching
 388         cl = self.classes[classname]
 389         cols, mls = self.determine_columns(cl)
 390         cols = ','.join(cols)
 391
 392         # perform the basic property fetch
 393         cursor = self.conn.cursor()
 394         sql = 'select %s from %s where id=?'%(cols, classname)
 395         if __debug__:
 396             print >>hyperdb.DEBUG, 'getnode', (self, sql, nodeid)
 397         cursor.execute(sql, (nodeid,))
 398         values = cursor.fetchone()
 399
 400         # make up the node
 401         node = {}
 402         for col in range(len(cols)):
 403             node[col] = values[col]
 404
 405         # now the multilinks
 406         for col in mls:
 407             # get the link ids
 408             sql = 'select linkid from %s_%s where nodeid=?'%(classname, col)
 409             if __debug__:
 410                 print >>hyperdb.DEBUG, 'getnode', (self, sql, nodeid)
 411             cursor.execute(sql, (nodeid,))
 412             # extract the first column from the result
 413             node[col] = [x[0] for x in cursor.fetchall()]
 414
 415         return self.unserialise(classname, node)
 416
 417     def serialise(self, classname, node):
 418         '''Copy the node contents, converting non-marshallable data into
 419            marshallable data.
 420         '''
 421         if __debug__:
 422             print >>hyperdb.DEBUG, 'serialise', classname, node
 423         properties = self.getclass(classname).getprops()
 424         d = {}
 425         for k, v in node.items():
 426             # if the property doesn't exist, or is the "retired" flag then
 427             # it won't be in the properties dict
 428             if not properties.has_key(k):
 429                 d[k] = v
 430                 continue
 431
 432             # get the property spec
 433             prop = properties[k]
 434
 435             if isinstance(prop, Password):
 436                 d[k] = str(v)
 437             elif isinstance(prop, Date) and v is not None:
 438                 d[k] = v.serialise()
 439             elif isinstance(prop, Interval) and v is not None:
 440                 d[k] = v.serialise()
 441             else:
 442                 d[k] = v
 443         return d
 444
 445     def unserialise(self, classname, node):
 446         '''Decode the marshalled node data
 447         '''
 448         if __debug__:
 449             print >>hyperdb.DEBUG, 'unserialise', classname, node
 450         properties = self.getclass(classname).getprops()
 451         d = {}
 452         for k, v in node.items():
 453             # if the property doesn't exist, or is the "retired" flag then
 454             # it won't be in the properties dict
 455             if not properties.has_key(k):
 456                 d[k] = v
 457                 continue
 458
 459             # get the property spec
 460             prop = properties[k]
 461
 462             if isinstance(prop, Date) and v is not None:
 463                 d[k] = date.Date(v)
 464             elif isinstance(prop, Interval) and v is not None:
 465                 d[k] = date.Interval(v)
 466             elif isinstance(prop, Password):
 467                 p = password.Password()
 468                 p.unpack(v)
 469                 d[k] = p
 470             else:
 471                 d[k] = v
 472         return d
 473
 474     def hasnode(self, classname, nodeid):
 475         ''' Determine if the database has a given node.
 476         '''
 477         cursor = self.conn.cursor()
 478         sql = 'select count(*) from %s where nodeid=?'%classname
 479         if __debug__:
 480             print >>hyperdb.DEBUG, 'hasnode', (self, sql, nodeid)
 481         cursor.execute(sql, (nodeid,))
 482         return cursor.fetchone()[0]
 483
 484     def countnodes(self, classname):
 485         ''' Count the number of nodes that exist for a particular Class.
 486         '''
 487         cursor = self.conn.cursor()
 488         sql = 'select count(*) from %s'%classname
 489         if __debug__:
 490             print >>hyperdb.DEBUG, 'countnodes', (self, sql)
 491         cursor.execute(sql)
 492         return cursor.fetchone()[0]
 493
 494     def getnodeids(self, classname):
 495         ''' Retrieve all the ids of the nodes for a particular Class.
 496         '''
 497         cursor = self.conn.cursor()
 498         sql = 'select id from %s'%classname
 499         if __debug__:
 500             print >>hyperdb.DEBUG, 'getnodeids', (self, sql)
 501         cursor.execute(sql)
 502         return [x[0] for x in cursor.fetchall()]
 503
 504     def addjournal(self, classname, nodeid, action, params):
 505         ''' Journal the Action
 506         'action' may be:
 507
 508             'create' or 'set' -- 'params' is a dictionary of property values
 509             'link' or 'unlink' -- 'params' is (classname, nodeid, propname)
 510             'retire' -- 'params' is None
 511         '''
 512         if isinstance(params, type({})):
 513             if params.has_key('creator'):
 514                 journaltag = self.user.get(params['creator'], 'username')
 515                 del params['creator']
 516             else:
 517                 journaltag = self.journaltag
 518             if params.has_key('created'):
 519                 journaldate = params['created'].serialise()
 520                 del params['created']
 521             else:
 522                 journaldate = date.Date().serialise()
 523             if params.has_key('activity'):
 524                 del params['activity']
 525
 526             # serialise the parameters now
 527             if action in ('set', 'create'):
 528                 params = self.serialise(classname, params)
 529         else:
 530             journaltag = self.journaltag
 531             journaldate = date.Date().serialise()
 532
 533         # create the journal entry
 534         cols = ','.join('nodeid date tag action params'.split())
 535         entry = (nodeid, journaldate, journaltag, action, params)
 536
 537         if __debug__:
 538             print >>hyperdb.DEBUG, 'doSaveJournal', entry
 539
 540         # do the insert
 541         cursor = self.conn.cursor()
 542         sql = 'insert into %s__journal (%s) values (?,?,?,?,?)'%(classname,
 543             cols)
 544         if __debug__:
 545             print >>hyperdb.DEBUG, 'addjournal', (self, sql, entry)
 546         cursor.execute(sql, entry)
 547
 548     def getjournal(self, classname, nodeid):
 549         ''' get the journal for id
 550         '''
 551         cols = ','.join('nodeid date tag action params'.split())
 552         cursor = self.conn.cursor()
 553         sql = 'select %s from %s__journal where nodeid=?'%(cols, classname)
 554         if __debug__:
 555             print >>hyperdb.DEBUG, 'getjournal', (self, sql, nodeid)
 556         cursor.execute(sql, (nodeid,))
 557         res = []
 558         for nodeid, date_stamp, user, action, params in cursor.fetchall():
 559             res.append((nodeid, date.Date(date_stamp), user, action, params))
 560         return res
 561
 562     def pack(self, pack_before):
 563         ''' Pack the database, removing all journal entries before the
 564             "pack_before" date.
 565         '''
 566         # get a 'yyyymmddhhmmss' version of the date
 567         date_stamp = pack_before.serialise()
 568
 569         # do the delete
 570         cursor = self.conn.cursor()
 571         for classname in self.classes.keys():
 572             sql = 'delete from %s__journal where date<?'%classname
 573             if __debug__:
 574                 print >>hyperdb.DEBUG, 'pack', (self, sql, date_stamp)
 575             cursor.execute(sql, (date_stamp,))
 576
 577     def commit(self):
 578         ''' Commit the current transactions.
 579
 580         Save all data changed since the database was opened or since the
 581         last commit() or rollback().
 582         '''
 583         self.conn.commit()
 584
 585     def rollback(self):
 586         ''' Reverse all actions from the current transaction.
 587
 588         Undo all the changes made since the database was opened or the last
 589         commit() or rollback() was performed.
 590         '''
 591         self.conn.rollback()
 592
 593 #
 594 # The base Class class
 595 #
 596 class Class(hyperdb.Class):
 597     ''' The handle to a particular class of nodes in a hyperdatabase.
 598
 599         All methods except __repr__ and getnode must be implemented by a
 600         concrete backend Class.
 601     '''
 602
 603     def __init__(self, db, classname, **properties):
 604         '''Create a new class with a given name and property specification.
 605
 606         'classname' must not collide with the name of an existing class,
 607         or a ValueError is raised.  The keyword arguments in 'properties'
 608         must map names to property objects, or a TypeError is raised.
 609         '''
 610         if (properties.has_key('creation') or properties.has_key('activity')
 611                 or properties.has_key('creator')):
 612             raise ValueError, '"creation", "activity" and "creator" are '\
 613                 'reserved'
 614
 615         self.classname = classname
 616         self.properties = properties
 617         self.db = weakref.proxy(db)       # use a weak ref to avoid circularity
 618         self.key = ''
 619
 620         # should we journal changes (default yes)
 621         self.do_journal = 1
 622
 623         # do the db-related init stuff
 624         db.addclass(self)
 625
 626         self.auditors = {'create': [], 'set': [], 'retire': []}
 627         self.reactors = {'create': [], 'set': [], 'retire': []}
 628
 629     def schema(self):
 630         ''' A dumpable version of the schema that we can store in the
 631             database
 632         '''
 633         return (self.key, [(x, repr(y)) for x,y in self.properties.items()])
 634
 635     def enableJournalling(self):
 636         '''Turn journalling on for this class
 637         '''
 638         self.do_journal = 1
 639
 640     def disableJournalling(self):
 641         '''Turn journalling off for this class
 642         '''
 643         self.do_journal = 0
 644
 645     # Editing nodes:
 646     def create(self, **propvalues):
 647         ''' Create a new node of this class and return its id.
 648
 649         The keyword arguments in 'propvalues' map property names to values.
 650
 651         The values of arguments must be acceptable for the types of their
 652         corresponding properties or a TypeError is raised.
 653
 654         If this class has a key property, it must be present and its value
 655         must not collide with other key strings or a ValueError is raised.
 656
 657         Any other properties on this class that are missing from the
 658         'propvalues' dictionary are set to None.
 659
 660         If an id in a link or multilink property does not refer to a valid
 661         node, an IndexError is raised.
 662         '''
 663         if propvalues.has_key('id'):
 664             raise KeyError, '"id" is reserved'
 665
 666         if self.db.journaltag is None:
 667             raise DatabaseError, 'Database open read-only'
 668
 669         if propvalues.has_key('creation') or propvalues.has_key('activity'):
 670             raise KeyError, '"creation" and "activity" are reserved'
 671
 672         self.fireAuditors('create', None, propvalues)
 673
 674         # new node's id
 675         newid = self.db.newid(self.classname)
 676
 677         # validate propvalues
 678         num_re = re.compile('^\d+$')
 679         for key, value in propvalues.items():
 680             if key == self.key:
 681                 try:
 682                     self.lookup(value)
 683                 except KeyError:
 684                     pass
 685                 else:
 686                     raise ValueError, 'node with key "%s" exists'%value
 687
 688             # try to handle this property
 689             try:
 690                 prop = self.properties[key]
 691             except KeyError:
 692                 raise KeyError, '"%s" has no property "%s"'%(self.classname,
 693                     key)
 694
 695             if value is not None and isinstance(prop, Link):
 696                 if type(value) != type(''):
 697                     raise ValueError, 'link value must be String'
 698                 link_class = self.properties[key].classname
 699                 # if it isn't a number, it's a key
 700                 if not num_re.match(value):
 701                     try:
 702                         value = self.db.classes[link_class].lookup(value)
 703                     except (TypeError, KeyError):
 704                         raise IndexError, 'new property "%s": %s not a %s'%(
 705                             key, value, link_class)
 706                 elif not self.db.getclass(link_class).hasnode(value):
 707                     raise IndexError, '%s has no node %s'%(link_class, value)
 708
 709                 # save off the value
 710                 propvalues[key] = value
 711
 712                 # register the link with the newly linked node
 713                 if self.do_journal and self.properties[key].do_journal:
 714                     self.db.addjournal(link_class, value, 'link',
 715                         (self.classname, newid, key))
 716
 717             elif isinstance(prop, Multilink):
 718                 if type(value) != type([]):
 719                     raise TypeError, 'new property "%s" not a list of ids'%key
 720
 721                 # clean up and validate the list of links
 722                 link_class = self.properties[key].classname
 723                 l = []
 724                 for entry in value:
 725                     if type(entry) != type(''):
 726                         raise ValueError, '"%s" link value (%s) must be '\
 727                             'String'%(key, value)
 728                     # if it isn't a number, it's a key
 729                     if not num_re.match(entry):
 730                         try:
 731                             entry = self.db.classes[link_class].lookup(entry)
 732                         except (TypeError, KeyError):
 733                             raise IndexError, 'new property "%s": %s not a %s'%(
 734                                 key, entry, self.properties[key].classname)
 735                     l.append(entry)
 736                 value = l
 737                 propvalues[key] = value
 738
 739                 # handle additions
 740                 for nodeid in value:
 741                     if not self.db.getclass(link_class).hasnode(nodeid):
 742                         raise IndexError, '%s has no node %s'%(link_class,
 743                             nodeid)
 744                     # register the link with the newly linked node
 745                     if self.do_journal and self.properties[key].do_journal:
 746                         self.db.addjournal(link_class, nodeid, 'link',
 747                             (self.classname, newid, key))
 748
 749             elif isinstance(prop, String):
 750                 if type(value) != type(''):
 751                     raise TypeError, 'new property "%s" not a string'%key
 752
 753             elif isinstance(prop, Password):
 754                 if not isinstance(value, password.Password):
 755                     raise TypeError, 'new property "%s" not a Password'%key
 756
 757             elif isinstance(prop, Date):
 758                 if value is not None and not isinstance(value, date.Date):
 759                     raise TypeError, 'new property "%s" not a Date'%key
 760
 761             elif isinstance(prop, Interval):
 762                 if value is not None and not isinstance(value, date.Interval):
 763                     raise TypeError, 'new property "%s" not an Interval'%key
 764
 765             elif value is not None and isinstance(prop, Number):
 766                 try:
 767                     float(value)
 768                 except ValueError:
 769                     raise TypeError, 'new property "%s" not numeric'%key
 770
 771             elif value is not None and isinstance(prop, Boolean):
 772                 try:
 773                     int(value)
 774                 except ValueError:
 775                     raise TypeError, 'new property "%s" not boolean'%key
 776
 777         # make sure there's data where there needs to be
 778         for key, prop in self.properties.items():
 779             if propvalues.has_key(key):
 780                 continue
 781             if key == self.key:
 782                 raise ValueError, 'key property "%s" is required'%key
 783             if isinstance(prop, Multilink):
 784                 propvalues[key] = []
 785             else:
 786                 propvalues[key] = None
 787
 788         # done
 789         self.db.addnode(self.classname, newid, propvalues)
 790         if self.do_journal:
 791             self.db.addjournal(self.classname, newid, 'create', propvalues)
 792
 793         self.fireReactors('create', newid, None)
 794
 795         return newid
 796
 797     _marker = []
 798     def get(self, nodeid, propname, default=_marker, cache=1):
 799         '''Get the value of a property on an existing node of this class.
 800
 801         'nodeid' must be the id of an existing node of this class or an
 802         IndexError is raised.  'propname' must be the name of a property
 803         of this class or a KeyError is raised.
 804
 805         'cache' indicates whether the transaction cache should be queried
 806         for the node. If the node has been modified and you need to
 807         determine what its values prior to modification are, you need to
 808         set cache=0.
 809         '''
 810         if propname == 'id':
 811             return nodeid
 812
 813         if propname == 'creation':
 814             if not self.do_journal:
 815                 raise ValueError, 'Journalling is disabled for this class'
 816             journal = self.db.getjournal(self.classname, nodeid)
 817             if journal:
 818                 return self.db.getjournal(self.classname, nodeid)[0][1]
 819             else:
 820                 # on the strange chance that there's no journal
 821                 return date.Date()
 822         if propname == 'activity':
 823             if not self.do_journal:
 824                 raise ValueError, 'Journalling is disabled for this class'
 825             journal = self.db.getjournal(self.classname, nodeid)
 826             if journal:
 827                 return self.db.getjournal(self.classname, nodeid)[-1][1]
 828             else:
 829                 # on the strange chance that there's no journal
 830                 return date.Date()
 831         if propname == 'creator':
 832             if not self.do_journal:
 833                 raise ValueError, 'Journalling is disabled for this class'
 834             journal = self.db.getjournal(self.classname, nodeid)
 835             if journal:
 836                 name = self.db.getjournal(self.classname, nodeid)[0][2]
 837             else:
 838                 return None
 839             return self.db.user.lookup(name)
 840
 841         # get the property (raises KeyErorr if invalid)
 842         prop = self.properties[propname]
 843
 844         # get the node's dict
 845         d = self.db.getnode(self.classname, nodeid) #, cache=cache)
 846
 847         if not d.has_key(propname):
 848             if default is _marker:
 849                 if isinstance(prop, Multilink):
 850                     return []
 851                 else:
 852                     return None
 853             else:
 854                 return default
 855
 856         return d[propname]
 857
 858     def getnode(self, nodeid, cache=1):
 859         ''' Return a convenience wrapper for the node.
 860
 861         'nodeid' must be the id of an existing node of this class or an
 862         IndexError is raised.
 863
 864         'cache' indicates whether the transaction cache should be queried
 865         for the node. If the node has been modified and you need to
 866         determine what its values prior to modification are, you need to
 867         set cache=0.
 868         '''
 869         return Node(self, nodeid, cache=cache)
 870
 871     def set(self, nodeid, **propvalues):
 872         '''Modify a property on an existing node of this class.
 873
 874         'nodeid' must be the id of an existing node of this class or an
 875         IndexError is raised.
 876
 877         Each key in 'propvalues' must be the name of a property of this
 878         class or a KeyError is raised.
 879
 880         All values in 'propvalues' must be acceptable types for their
 881         corresponding properties or a TypeError is raised.
 882
 883         If the value of the key property is set, it must not collide with
 884         other key strings or a ValueError is raised.
 885
 886         If the value of a Link or Multilink property contains an invalid
 887         node id, a ValueError is raised.
 888         '''
 889         raise NotImplementedError
 890
 891     def retire(self, nodeid):
 892         '''Retire a node.
 893
 894         The properties on the node remain available from the get() method,
 895         and the node's id is never reused.
 896
 897         Retired nodes are not returned by the find(), list(), or lookup()
 898         methods, and other nodes may reuse the values of their key properties.
 899         '''
 900         cursor = self.db.conn.cursor()
 901         sql = 'update %s set __retired__=1 where id=?'%self.classname
 902         if __debug__:
 903             print >>hyperdb.DEBUG, 'retire', (self, sql, nodeid)
 904         cursor.execute(sql, (nodeid,))
 905
 906     def is_retired(self, nodeid):
 907         '''Return true if the node is rerired
 908         '''
 909         cursor = self.db.conn.cursor()
 910         sql = 'select __retired__ from %s where id=?'%self.classname
 911         if __debug__:
 912             print >>hyperdb.DEBUG, 'is_retired', (self, sql, nodeid)
 913         cursor.execute(sql, (nodeid,))
 914         return cursor.fetchone()[0]
 915
 916     def destroy(self, nodeid):
 917         '''Destroy a node.
 918
 919         WARNING: this method should never be used except in extremely rare
 920                  situations where there could never be links to the node being
 921                  deleted
 922         WARNING: use retire() instead
 923         WARNING: the properties of this node will not be available ever again
 924         WARNING: really, use retire() instead
 925
 926         Well, I think that's enough warnings. This method exists mostly to
 927         support the session storage of the cgi interface.
 928
 929         The node is completely removed from the hyperdb, including all journal
 930         entries. It will no longer be available, and will generally break code
 931         if there are any references to the node.
 932         '''
 933         raise NotImplementedError
 934
 935     def history(self, nodeid):
 936         '''Retrieve the journal of edits on a particular node.
 937
 938         'nodeid' must be the id of an existing node of this class or an
 939         IndexError is raised.
 940
 941         The returned list contains tuples of the form
 942
 943             (date, tag, action, params)
 944
 945         'date' is a Timestamp object specifying the time of the change and
 946         'tag' is the journaltag specified when the database was opened.
 947         '''
 948         raise NotImplementedError
 949
 950     # Locating nodes:
 951     def hasnode(self, nodeid):
 952         '''Determine if the given nodeid actually exists
 953         '''
 954         return self.db.hasnode(self.classname, nodeid)
 955
 956     def setkey(self, propname):
 957         '''Select a String property of this class to be the key property.
 958
 959         'propname' must be the name of a String property of this class or
 960         None, or a TypeError is raised.  The values of the key property on
 961         all existing nodes must be unique or a ValueError is raised.
 962         '''
 963         # XXX create an index on the key prop column
 964         prop = self.getprops()[propname]
 965         if not isinstance(prop, String):
 966             raise TypeError, 'key properties must be String'
 967         self.key = propname
 968
 969     def getkey(self):
 970         '''Return the name of the key property for this class or None.'''
 971         return self.key
 972
 973     def labelprop(self, default_to_id=0):
 974         ''' Return the property name for a label for the given node.
 975
 976         This method attempts to generate a consistent label for the node.
 977         It tries the following in order:
 978             1. key property
 979             2. "name" property
 980             3. "title" property
 981             4. first property from the sorted property name list
 982         '''
 983         raise NotImplementedError
 984
 985     def lookup(self, keyvalue):
 986         '''Locate a particular node by its key property and return its id.
 987
 988         If this class has no key property, a TypeError is raised.  If the
 989         'keyvalue' matches one of the values for the key property among
 990         the nodes in this class, the matching node's id is returned;
 991         otherwise a KeyError is raised.
 992         '''
 993         if not self.key:
 994             raise TypeError, 'No key property set'
 995
 996         cursor = self.db.conn.cursor()
 997         sql = 'select id from %s where _%s=?'%(self.classname, self.key)
 998         if __debug__:
 999             print >>hyperdb.DEBUG, 'lookup', (self, sql, keyvalue)
1000         cursor.execute(sql, (keyvalue,))
1001
1002         # see if there was a result
1003         l = cursor.fetchall()
1004         if not l:
1005             raise KeyError, keyvalue
1006
1007         # return the id
1008         return l[0][0]
1009
1010     def find(self, **propspec):
1011         '''Get the ids of nodes in this class which link to the given nodes.
1012
1013         'propspec' consists of keyword args propname={nodeid:1,}
1014         'propname' must be the name of a property in this class, or a
1015         KeyError is raised.  That property must be a Link or Multilink
1016         property, or a TypeError is raised.
1017
1018         Any node in this class whose 'propname' property links to any of the
1019         nodeids will be returned. Used by the full text indexing, which knows
1020         that "foo" occurs in msg1, msg3 and file7, so we have hits on these
1021         issues:
1022
1023             db.issue.find(messages={'1':1,'3':1}, files={'7':1})
1024         '''
1025         raise NotImplementedError
1026
1027     def filter(self, search_matches, filterspec, sort, group,
1028             num_re = re.compile('^\d+$')):
1029         ''' Return a list of the ids of the active nodes in this class that
1030             match the 'filter' spec, sorted by the group spec and then the
1031             sort spec
1032         '''
1033         raise NotImplementedError
1034
1035     def count(self):
1036         '''Get the number of nodes in this class.
1037
1038         If the returned integer is 'numnodes', the ids of all the nodes
1039         in this class run from 1 to numnodes, and numnodes+1 will be the
1040         id of the next node to be created in this class.
1041         '''
1042         return self.db.countnodes(self.classname)
1043
1044     # Manipulating properties:
1045     def getprops(self, protected=1):
1046         '''Return a dictionary mapping property names to property objects.
1047            If the "protected" flag is true, we include protected properties -
1048            those which may not be modified.
1049         '''
1050         d = self.properties.copy()
1051         if protected:
1052             d['id'] = String()
1053             d['creation'] = hyperdb.Date()
1054             d['activity'] = hyperdb.Date()
1055             d['creator'] = hyperdb.Link("user")
1056         return d
1057
1058     def addprop(self, **properties):
1059         '''Add properties to this class.
1060
1061         The keyword arguments in 'properties' must map names to property
1062         objects, or a TypeError is raised.  None of the keys in 'properties'
1063         may collide with the names of existing properties, or a ValueError
1064         is raised before any properties have been added.
1065         '''
1066         for key in properties.keys():
1067             if self.properties.has_key(key):
1068                 raise ValueError, key
1069         self.properties.update(properties)
1070
1071     def index(self, nodeid):
1072         '''Add (or refresh) the node to search indexes
1073         '''
1074         # find all the String properties that have indexme
1075         for prop, propclass in self.getprops().items():
1076             if isinstance(propclass, String) and propclass.indexme:
1077                 try:
1078                     value = str(self.get(nodeid, prop))
1079                 except IndexError:
1080                     # node no longer exists - entry should be removed
1081                     self.db.indexer.purge_entry((self.classname, nodeid, prop))
1082                 else:
1083                     # and index them under (classname, nodeid, property)
1084                     self.db.indexer.add_text((self.classname, nodeid, prop),
1085                         value)
1086
1087
1088     #
1089     # Detector interface
1090     #
1091     def audit(self, event, detector):
1092         '''Register a detector
1093         '''
1094         l = self.auditors[event]
1095         if detector not in l:
1096             self.auditors[event].append(detector)
1097
1098     def fireAuditors(self, action, nodeid, newvalues):
1099         '''Fire all registered auditors.
1100         '''
1101         for audit in self.auditors[action]:
1102             audit(self.db, self, nodeid, newvalues)
1103
1104     def react(self, event, detector):
1105         '''Register a detector
1106         '''
1107         l = self.reactors[event]
1108         if detector not in l:
1109             self.reactors[event].append(detector)
1110
1111     def fireReactors(self, action, nodeid, oldvalues):
1112         '''Fire all registered reactors.
1113         '''
1114         for react in self.reactors[action]:
1115             react(self.db, self, nodeid, oldvalues)
1116
1117 class FileClass(Class):
1118     '''This class defines a large chunk of data. To support this, it has a
1119        mandatory String property "content" which is typically saved off
1120        externally to the hyperdb.
1121
1122        The default MIME type of this data is defined by the
1123        "default_mime_type" class attribute, which may be overridden by each
1124        node if the class defines a "type" String property.
1125     '''
1126     default_mime_type = 'text/plain'
1127
1128     def create(self, **propvalues):
1129         ''' snaffle the file propvalue and store in a file
1130         '''
1131         content = propvalues['content']
1132         del propvalues['content']
1133         newid = Class.create(self, **propvalues)
1134         self.db.storefile(self.classname, newid, None, content)
1135         return newid
1136
1137     def import_list(self, propnames, proplist):
1138         ''' Trap the "content" property...
1139         '''
1140         # dupe this list so we don't affect others
1141         propnames = propnames[:]
1142
1143         # extract the "content" property from the proplist
1144         i = propnames.index('content')
1145         content = proplist[i]
1146         del propnames[i]
1147         del proplist[i]
1148
1149         # do the normal import
1150         newid = Class.import_list(self, propnames, proplist)
1151
1152         # save off the "content" file
1153         self.db.storefile(self.classname, newid, None, content)
1154         return newid
1155
1156     _marker = []
1157     def get(self, nodeid, propname, default=_marker, cache=1):
1158         ''' trap the content propname and get it from the file
1159         '''
1160
1161         poss_msg = 'Possibly a access right configuration problem.'
1162         if propname == 'content':
1163             try:
1164                 return self.db.getfile(self.classname, nodeid, None)
1165             except IOError, (strerror):
1166                 # BUG: by catching this we donot see an error in the log.
1167                 return 'ERROR reading file: %s%s\n%s\n%s'%(
1168                         self.classname, nodeid, poss_msg, strerror)
1169         if default is not _marker:
1170             return Class.get(self, nodeid, propname, default, cache=cache)
1171         else:
1172             return Class.get(self, nodeid, propname, cache=cache)
1173
1174     def getprops(self, protected=1):
1175         ''' In addition to the actual properties on the node, these methods
1176             provide the "content" property. If the "protected" flag is true,
1177             we include protected properties - those which may not be
1178             modified.
1179         '''
1180         d = Class.getprops(self, protected=protected).copy()
1181         if protected:
1182             d['content'] = hyperdb.String()
1183         return d
1184
1185     def index(self, nodeid):
1186         ''' Index the node in the search index.
1187
1188             We want to index the content in addition to the normal String
1189             property indexing.
1190         '''
1191         # perform normal indexing
1192         Class.index(self, nodeid)
1193
1194         # get the content to index
1195         content = self.get(nodeid, 'content')
1196
1197         # figure the mime type
1198         if self.properties.has_key('type'):
1199             mime_type = self.get(nodeid, 'type')
1200         else:
1201             mime_type = self.default_mime_type
1202
1203         # and index!
1204         self.db.indexer.add_text((self.classname, nodeid, 'content'), content,
1205             mime_type)
1206
1207 # XXX deviation from spec - was called ItemClass
1208 class IssueClass(Class, roundupdb.IssueClass):
1209     # Overridden methods:
1210     def __init__(self, db, classname, **properties):
1211         '''The newly-created class automatically includes the "messages",
1212         "files", "nosy", and "superseder" properties.  If the 'properties'
1213         dictionary attempts to specify any of these properties or a
1214         "creation" or "activity" property, a ValueError is raised.
1215         '''
1216         if not properties.has_key('title'):
1217             properties['title'] = hyperdb.String(indexme='yes')
1218         if not properties.has_key('messages'):
1219             properties['messages'] = hyperdb.Multilink("msg")
1220         if not properties.has_key('files'):
1221             properties['files'] = hyperdb.Multilink("file")
1222         if not properties.has_key('nosy'):
1223             properties['nosy'] = hyperdb.Multilink("user")
1224         if not properties.has_key('superseder'):
1225             properties['superseder'] = hyperdb.Multilink(classname)
1226         Class.__init__(self, db, classname, **properties)
1227
1228 #
1229 # $Log: not supported by cvs2svn $
1230 # Revision 1.80  2002/08/16 04:28:13  richard
1231 # added is_retired query to Class
1232 #
1233 # Revision 1.79  2002/07/29 23:30:14  richard
1234 # documentation reorg post-new-security
1235 #
1236 # Revision 1.78  2002/07/21 03:26:37  richard
1237 # Gordon, does this help?
1238 #
1239 # Revision 1.77  2002/07/18 11:27:47  richard
1240 # ws
1241 #
1242 # Revision 1.76  2002/07/18 11:17:30  gmcm
1243 # Add Number and Boolean types to hyperdb.
1244 # Add conversion cases to web, mail & admin interfaces.
1245 # Add storage/serialization cases to back_anydbm & back_metakit.
1246 #
1247 # Revision 1.75  2002/07/14 02:05:53  richard
1248 # . all storage-specific code (ie. backend) is now implemented by the backends
1249 #
1250 # Revision 1.74  2002/07/10 00:24:10  richard
1251 # braino
1252 #
1253 # Revision 1.73  2002/07/10 00:19:48  richard
1254 # Added explicit closing of backend database handles.
1255 #
1256 # Revision 1.72  2002/07/09 21:53:38  gmcm
1257 # Optimize Class.find so that the propspec can contain a set of ids to match.
1258 # This is used by indexer.search so it can do just one find for all the index matches.
1259 # This was already confusing code, but for common terms (lots of index matches),
1260 # it is enormously faster.
1261 #
1262 # Revision 1.71  2002/07/09 03:02:52  richard
1263 # More indexer work:
1264 # - all String properties may now be indexed too. Currently there's a bit of
1265 #   "issue" specific code in the actual searching which needs to be
1266 #   addressed. In a nutshell:
1267 #   + pass 'indexme="yes"' as a String() property initialisation arg, eg:
1268 #         file = FileClass(db, "file", name=String(), type=String(),
1269 #             comment=String(indexme="yes"))
1270 #   + the comment will then be indexed and be searchable, with the results
1271 #     related back to the issue that the file is linked to
1272 # - as a result of this work, the FileClass has a default MIME type that may
1273 #   be overridden in a subclass, or by the use of a "type" property as is
1274 #   done in the default templates.
1275 # - the regeneration of the indexes (if necessary) is done once the schema is
1276 #   set up in the dbinit.
1277 #
1278 # Revision 1.70  2002/06/27 12:06:20  gmcm
1279 # Improve an error message.
1280 #
1281 # Revision 1.69  2002/06/17 23:15:29  richard
1282 # Can debug to stdout now
1283 #
1284 # Revision 1.68  2002/06/11 06:52:03  richard
1285 #  . #564271 ] find() and new properties
1286 #
1287 # Revision 1.67  2002/06/11 05:02:37  richard
1288 #  . #565979 ] code error in hyperdb.Class.find
1289 #
1290 # Revision 1.66  2002/05/25 07:16:24  rochecompaan
1291 # Merged search_indexing-branch with HEAD
1292 #
1293 # Revision 1.65  2002/05/22 04:12:05  richard
1294 #  . applied patch #558876 ] cgi client customization
1295 #    ... with significant additions and modifications ;)
1296 #    - extended handling of ML assignedto to all places it's handled
1297 #    - added more NotFound info
1298 #
1299 # Revision 1.64  2002/05/15 06:21:21  richard
1300 #  . node caching now works, and gives a small boost in performance
1301 #
1302 # As a part of this, I cleaned up the DEBUG output and implemented TRACE
1303 # output (HYPERDBTRACE='file to trace to') with checkpoints at the start of
1304 # CGI requests. Run roundup with python -O to skip all the DEBUG/TRACE stuff
1305 # (using if __debug__ which is compiled out with -O)
1306 #
1307 # Revision 1.63  2002/04/15 23:25:15  richard
1308 # . node ids are now generated from a lockable store - no more race conditions
1309 #
1310 # We're using the portalocker code by Jonathan Feinberg that was contributed
1311 # to the ASPN Python cookbook. This gives us locking across Unix and Windows.
1312 #
1313 # Revision 1.62  2002/04/03 07:05:50  richard
1314 # d'oh! killed retirement of nodes :(
1315 # all better now...
1316 #
1317 # Revision 1.61  2002/04/03 06:11:51  richard
1318 # Fix for old databases that contain properties that don't exist any more.
1319 #
1320 # Revision 1.60  2002/04/03 05:54:31  richard
1321 # Fixed serialisation problem by moving the serialisation step out of the
1322 # hyperdb.Class (get, set) into the hyperdb.Database.
1323 #
1324 # Also fixed htmltemplate after the showid changes I made yesterday.
1325 #
1326 # Unit tests for all of the above written.
1327 #
1328 # Revision 1.59.2.2  2002/04/20 13:23:33  rochecompaan
1329 # We now have a separate search page for nodes.  Search links for
1330 # different classes can be customized in instance_config similar to
1331 # index links.
1332 #
1333 # Revision 1.59.2.1  2002/04/19 19:54:42  rochecompaan
1334 # cgi_client.py
1335 #     removed search link for the time being
1336 #     moved rendering of matches to htmltemplate
1337 # hyperdb.py
1338 #     filtering of nodes on full text search incorporated in filter method
1339 # roundupdb.py
1340 #     added paramater to call of filter method
1341 # roundup_indexer.py
1342 #     added search method to RoundupIndexer class
1343 #
1344 # Revision 1.59  2002/03/12 22:52:26  richard
1345 # more pychecker warnings removed
1346 #
1347 # Revision 1.58  2002/02/27 03:23:16  richard
1348 # Ran it through pychecker, made fixes
1349 #
1350 # Revision 1.57  2002/02/20 05:23:24  richard
1351 # Didn't accomodate new values for new properties
1352 #
1353 # Revision 1.56  2002/02/20 05:05:28  richard
1354 #  . Added simple editing for classes that don't define a templated interface.
1355 #    - access using the admin "class list" interface
1356 #    - limited to admin-only
1357 #    - requires the csv module from object-craft (url given if it's missing)
1358 #
1359 # Revision 1.55  2002/02/15 07:27:12  richard
1360 # Oops, precedences around the way w0rng.
1361 #
1362 # Revision 1.54  2002/02/15 07:08:44  richard
1363 #  . Alternate email addresses are now available for users. See the MIGRATION
1364 #    file for info on how to activate the feature.
1365 #
1366 # Revision 1.53  2002/01/22 07:21:13  richard
1367 # . fixed back_bsddb so it passed the journal tests
1368 #
1369 # ... it didn't seem happy using the back_anydbm _open method, which is odd.
1370 # Yet another occurrance of whichdb not being able to recognise older bsddb
1371 # databases. Yadda yadda. Made the HYPERDBDEBUG stuff more sane in the
1372 # process.
1373 #
1374 # Revision 1.52  2002/01/21 16:33:19  rochecompaan
1375 # You can now use the roundup-admin tool to pack the database
1376 #
1377 # Revision 1.51  2002/01/21 03:01:29  richard
1378 # brief docco on the do_journal argument
1379 #
1380 # Revision 1.50  2002/01/19 13:16:04  rochecompaan
1381 # Journal entries for link and multilink properties can now be switched on
1382 # or off.
1383 #
1384 # Revision 1.49  2002/01/16 07:02:57  richard
1385 #  . lots of date/interval related changes:
1386 #    - more relaxed date format for input
1387 #
1388 # Revision 1.48  2002/01/14 06:32:34  richard
1389 #  . #502951 ] adding new properties to old database
1390 #
1391 # Revision 1.47  2002/01/14 02:20:15  richard
1392 #  . changed all config accesses so they access either the instance or the
1393 #    config attriubute on the db. This means that all config is obtained from
1394 #    instance_config instead of the mish-mash of classes. This will make
1395 #    switching to a ConfigParser setup easier too, I hope.
1396 #
1397 # At a minimum, this makes migration a _little_ easier (a lot easier in the
1398 # 0.5.0 switch, I hope!)
1399 #
1400 # Revision 1.46  2002/01/07 10:42:23  richard
1401 # oops
1402 #
1403 # Revision 1.45  2002/01/02 04:18:17  richard
1404 # hyperdb docstrings
1405 #
1406 # Revision 1.44  2002/01/02 02:31:38  richard
1407 # Sorry for the huge checkin message - I was only intending to implement #496356
1408 # but I found a number of places where things had been broken by transactions:
1409 #  . modified ROUNDUPDBSENDMAILDEBUG to be SENDMAILDEBUG and hold a filename
1410 #    for _all_ roundup-generated smtp messages to be sent to.
1411 #  . the transaction cache had broken the roundupdb.Class set() reactors
1412 #  . newly-created author users in the mailgw weren't being committed to the db
1413 #
1414 # Stuff that made it into CHANGES.txt (ie. the stuff I was actually working
1415 # on when I found that stuff :):
1416 #  . #496356 ] Use threading in messages
1417 #  . detectors were being registered multiple times
1418 #  . added tests for mailgw
1419 #  . much better attaching of erroneous messages in the mail gateway
1420 #
1421 # Revision 1.43  2001/12/20 06:13:24  rochecompaan
1422 # Bugs fixed:
1423 #   . Exception handling in hyperdb for strings-that-look-like numbers got
1424 #     lost somewhere
1425 #   . Internet Explorer submits full path for filename - we now strip away
1426 #     the path
1427 # Features added:
1428 #   . Link and multilink properties are now displayed sorted in the cgi
1429 #     interface
1430 #
1431 # Revision 1.42  2001/12/16 10:53:37  richard
1432 # take a copy of the node dict so that the subsequent set
1433 # operation doesn't modify the oldvalues structure
1434 #
1435 # Revision 1.41  2001/12/15 23:47:47  richard
1436 # Cleaned up some bare except statements
1437 #
1438 # Revision 1.40  2001/12/14 23:42:57  richard
1439 # yuck, a gdbm instance tests false :(
1440 # I've left the debugging code in - it should be removed one day if we're ever
1441 # _really_ anal about performace :)
1442 #
1443 # Revision 1.39  2001/12/02 05:06:16  richard
1444 # . We now use weakrefs in the Classes to keep the database reference, so
1445 #   the close() method on the database is no longer needed.
1446 #   I bumped the minimum python requirement up to 2.1 accordingly.
1447 # . #487480 ] roundup-server
1448 # . #487476 ] INSTALL.txt
1449 #
1450 # I also cleaned up the change message / post-edit stuff in the cgi client.
1451 # There's now a clearly marked "TODO: append the change note" where I believe
1452 # the change note should be added there. The "changes" list will obviously
1453 # have to be modified to be a dict of the changes, or somesuch.
1454 #
1455 # More testing needed.
1456 #
1457 # Revision 1.38  2001/12/01 07:17:50  richard
1458 # . We now have basic transaction support! Information is only written to
1459 #   the database when the commit() method is called. Only the anydbm
1460 #   backend is modified in this way - neither of the bsddb backends have been.
1461 #   The mail, admin and cgi interfaces all use commit (except the admin tool
1462 #   doesn't have a commit command, so interactive users can't commit...)
1463 # . Fixed login/registration forwarding the user to the right page (or not,
1464 #   on a failure)
1465 #
1466 # Revision 1.37  2001/11/28 21:55:35  richard
1467 #  . login_action and newuser_action return values were being ignored
1468 #  . Woohoo! Found that bloody re-login bug that was killing the mail
1469 #    gateway.
1470 #  (also a minor cleanup in hyperdb)
1471 #
1472 # Revision 1.36  2001/11/27 03:16:09  richard
1473 # Another place that wasn't handling missing properties.
1474 #
1475 # Revision 1.35  2001/11/22 15:46:42  jhermann
1476 # Added module docstrings to all modules.
1477 #
1478 # Revision 1.34  2001/11/21 04:04:43  richard
1479 # *sigh* more missing value handling
1480 #
1481 # Revision 1.33  2001/11/21 03:40:54  richard
1482 # more new property handling
1483 #
1484 # Revision 1.32  2001/11/21 03:11:28  richard
1485 # Better handling of new properties.
1486 #
1487 # Revision 1.31  2001/11/12 22:01:06  richard
1488 # Fixed issues with nosy reaction and author copies.
1489 #
1490 # Revision 1.30  2001/11/09 10:11:08  richard
1491 #  . roundup-admin now handles all hyperdb exceptions
1492 #
1493 # Revision 1.29  2001/10/27 00:17:41  richard
1494 # Made Class.stringFind() do caseless matching.
1495 #
1496 # Revision 1.28  2001/10/21 04:44:50  richard
1497 # bug #473124: UI inconsistency with Link fields.
1498 #    This also prompted me to fix a fairly long-standing usability issue -
1499 #    that of being able to turn off certain filters.
1500 #
1501 # Revision 1.27  2001/10/20 23:44:27  richard
1502 # Hyperdatabase sorts strings-that-look-like-numbers as numbers now.
1503 #
1504 # Revision 1.26  2001/10/16 03:48:01  richard
1505 # admin tool now complains if a "find" is attempted with a non-link property.
1506 #
1507 # Revision 1.25  2001/10/11 00:17:51  richard
1508 # Reverted a change in hyperdb so the default value for missing property
1509 # values in a create() is None and not '' (the empty string.) This obviously
1510 # breaks CSV import/export - the string 'None' will be created in an
1511 # export/import operation.
1512 #
1513 # Revision 1.24  2001/10/10 03:54:57  richard
1514 # Added database importing and exporting through CSV files.
1515 # Uses the csv module from object-craft for exporting if it's available.
1516 # Requires the csv module for importing.
1517 #
1518 # Revision 1.23  2001/10/09 23:58:10  richard
1519 # Moved the data stringification up into the hyperdb.Class class' get, set
1520 # and create methods. This means that the data is also stringified for the
1521 # journal call, and removes duplication of code from the backends. The
1522 # backend code now only sees strings.
1523 #
1524 # Revision 1.22  2001/10/09 07:25:59  richard
1525 # Added the Password property type. See "pydoc roundup.password" for
1526 # implementation details. Have updated some of the documentation too.
1527 #
1528 # Revision 1.21  2001/10/05 02:23:24  richard
1529 #  . roundup-admin create now prompts for property info if none is supplied
1530 #    on the command-line.
1531 #  . hyperdb Class getprops() method may now return only the mutable
1532 #    properties.
1533 #  . Login now uses cookies, which makes it a whole lot more flexible. We can
1534 #    now support anonymous user access (read-only, unless there's an
1535 #    "anonymous" user, in which case write access is permitted). Login
1536 #    handling has been moved into cgi_client.Client.main()
1537 #  . The "extended" schema is now the default in roundup init.
1538 #  . The schemas have had their page headings modified to cope with the new
1539 #    login handling. Existing installations should copy the interfaces.py
1540 #    file from the roundup lib directory to their instance home.
1541 #  . Incorrectly had a Bizar Software copyright on the cgitb.py module from
1542 #    Ping - has been removed.
1543 #  . Fixed a whole bunch of places in the CGI interface where we should have
1544 #    been returning Not Found instead of throwing an exception.
1545 #  . Fixed a deviation from the spec: trying to modify the 'id' property of
1546 #    an item now throws an exception.
1547 #
1548 # Revision 1.20  2001/10/04 02:12:42  richard
1549 # Added nicer command-line item adding: passing no arguments will enter an
1550 # interactive more which asks for each property in turn. While I was at it, I
1551 # fixed an implementation problem WRT the spec - I wasn't raising a
1552 # ValueError if the key property was missing from a create(). Also added a
1553 # protected=boolean argument to getprops() so we can list only the mutable
1554 # properties (defaults to yes, which lists the immutables).
1555 #
1556 # Revision 1.19  2001/08/29 04:47:18  richard
1557 # Fixed CGI client change messages so they actually include the properties
1558 # changed (again).
1559 #
1560 # Revision 1.18  2001/08/16 07:34:59  richard
1561 # better CGI text searching - but hidden filter fields are disappearing...
1562 #
1563 # Revision 1.17  2001/08/16 06:59:58  richard
1564 # all searches use re now - and they're all case insensitive
1565 #
1566 # Revision 1.16  2001/08/15 23:43:18  richard
1567 # Fixed some isFooTypes that I missed.
1568 # Refactored some code in the CGI code.
1569 #
1570 # Revision 1.15  2001/08/12 06:32:36  richard
1571 # using isinstance(blah, Foo) now instead of isFooType
1572 #
1573 # Revision 1.14  2001/08/07 00:24:42  richard
1574 # stupid typo
1575 #
1576 # Revision 1.13  2001/08/07 00:15:51  richard
1577 # Added the copyright/license notice to (nearly) all files at request of
1578 # Bizar Software.
1579 #
1580 # Revision 1.12  2001/08/02 06:38:17  richard
1581 # Roundupdb now appends "mailing list" information to its messages which
1582 # include the e-mail address and web interface address. Templates may
1583 # override this in their db classes to include specific information (support
1584 # instructions, etc).
1585 #
1586 # Revision 1.11  2001/08/01 04:24:21  richard
1587 # mailgw was assuming certain properties existed on the issues being created.
1588 #
1589 # Revision 1.10  2001/07/30 02:38:31  richard
1590 # get() now has a default arg - for migration only.
1591 #
1592 # Revision 1.9  2001/07/29 09:28:23  richard
1593 # Fixed sorting by clicking on column headings.
1594 #
1595 # Revision 1.8  2001/07/29 08:27:40  richard
1596 # Fixed handling of passed-in values in form elements (ie. during a
1597 # drill-down)
1598 #
1599 # Revision 1.7  2001/07/29 07:01:39  richard
1600 # Added vim command to all source so that we don't get no steenkin' tabs :)
1601 #
1602 # Revision 1.6  2001/07/29 05:36:14  richard
1603 # Cleanup of the link label generation.
1604 #
1605 # Revision 1.5  2001/07/29 04:05:37  richard
1606 # Added the fabricated property "id".
1607 #
1608 # Revision 1.4  2001/07/27 06:25:35  richard
1609 # Fixed some of the exceptions so they're the right type.
1610 # Removed the str()-ification of node ids so we don't mask oopsy errors any
1611 # more.
1612 #
1613 # Revision 1.3  2001/07/27 05:17:14  richard
1614 # just some comments
1615 #
1616 # Revision 1.2  2001/07/22 12:09:32  richard
1617 # Final commit of Grande Splite
1618 #
1619 # Revision 1.1  2001/07/22 11:58:35  richard
1620 # More Grande Splite
1621 #
1622 #
1623 # vim: set filetype=python ts=4 sw=4 et si