# Copyright (C) 1998-2008 by the Free Software Foundation, Inc. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """Track pending actions which require confirmation.""" import os import time import errno import random import cPickle from Mailman import mm_cfg from Mailman.Utils import sha_new # Types of pending records SUBSCRIPTION = 'S' UNSUBSCRIPTION = 'U' CHANGE_OF_ADDRESS = 'C' HELD_MESSAGE = 'H' RE_ENABLE = 'E' PROBE_BOUNCE = 'P' _ALLKEYS = (SUBSCRIPTION, UNSUBSCRIPTION, CHANGE_OF_ADDRESS, HELD_MESSAGE, RE_ENABLE, PROBE_BOUNCE, ) try: True, False except NameError: True = 1 False = 0 _missing = [] class Pending: def InitTempVars(self): self.__pendfile = os.path.join(self.fullpath(), 'pending.pck') def pend_new(self, op, *content, **kws): """Create a new entry in the pending database, returning cookie for it. """ assert op in _ALLKEYS, 'op: %s' % op lifetime = kws.get('lifetime', mm_cfg.PENDING_REQUEST_LIFE) # We try the main loop several times. If we get a lock error somewhere # (for instance because someone broke the lock) we simply try again. assert self.Locked() # Load the database db = self.__load() # Calculate a unique cookie. Algorithm vetted by the Timbot. time() # has high resolution on Linux, clock() on Windows. random gives us # about 45 bits in Python 2.2, 53 bits on Python 2.3. The time and # clock values basically help obscure the random number generator, as # does the hash calculation. The integral parts of the time values # are discarded because they're the most predictable bits. while True: now = time.time() x = random.random() + now % 1.0 + time.clock() % 1.0 cookie = sha_new(repr(x)).hexdigest() # We'll never get a duplicate, but we'll be anal about checking # anyway. if not db.has_key(cookie): break # Store the content, plus the time in the future when this entry will # be evicted from the database, due to staleness. db[cookie] = (op,) + content evictions = db.setdefault('evictions', {}) evictions[cookie] = now + lifetime self.__save(db) return cookie def __load(self): try: fp = open(self.__pendfile) except IOError, e: if e.errno <> errno.ENOENT: raise return {'evictions': {}} try: return cPickle.load(fp) finally: fp.close() def __save(self, db): evictions = db['evictions'] now = time.time() for cookie, data in db.items(): if cookie in ('evictions', 'version'): continue timestamp = evictions[cookie] if now > timestamp: # The entry is stale, so remove it. del db[cookie] del evictions[cookie] # Clean out any bogus eviction entries. for cookie in evictions.keys(): if not db.has_key(cookie): del evictions[cookie] db['version'] = mm_cfg.PENDING_FILE_SCHEMA_VERSION tmpfile = '%s.tmp.%d.%d' % (self.__pendfile, os.getpid(), now) omask = os.umask(007) try: fp = open(tmpfile, 'w') try: cPickle.dump(db, fp) fp.flush() os.fsync(fp.fileno()) finally: fp.close() os.rename(tmpfile, self.__pendfile) finally: os.umask(omask) def pend_confirm(self, cookie, expunge=True): """Return data for cookie, or None if not found. If optional expunge is True (the default), the record is also removed from the database. """ db = self.__load() # If we're not expunging, the database is read-only. if not expunge: return db.get(cookie) # Since we're going to modify the database, we must make sure the list # is locked, since it's the list lock that protects pending.pck. assert self.Locked() content = db.get(cookie, _missing) if content is _missing: return None # Do the expunge del db[cookie] del db['evictions'][cookie] self.__save(db) return content def pend_repend(self, cookie, data, lifetime=mm_cfg.PENDING_REQUEST_LIFE): assert self.Locked() db = self.__load() db[cookie] = data db['evictions'][cookie] = time.time() + lifetime self.__save(db) def _update(olddb): db = {} # We don't need this entry anymore if olddb.has_key('lastculltime'): del olddb['lastculltime'] evictions = db.setdefault('evictions', {}) for cookie, data in olddb.items(): # The cookies used to be kept as a 6 digit integer. We now keep the # cookies as a string (sha in our case, but it doesn't matter for # cookie matching). cookie = str(cookie) # The old format kept the content as a tuple and tacked the timestamp # on as the last element of the tuple. We keep the timestamps # separate, but require the prepending of a record type indicator. We # know that the only things that were kept in the old format were # subscription requests. Also, the old request format didn't have the # subscription language. Best we can do here is use the server # default. db[cookie] = (SUBSCRIPTION,) + data[:-1] + \ (mm_cfg.DEFAULT_SERVER_LANGUAGE,) # The old database format kept the timestamp as the time the request # was made. The new format keeps it as the time the request should be # evicted. evictions[cookie] = data[-1] + mm_cfg.PENDING_REQUEST_LIFE return db