[Python-Dev] shm + Win32 + docs (was: Adding library modules to the core) (original) (raw)

Thu, 17 Aug 2000 04:12:18 +0200 (CEST)

    *Specification:
     -------------
     The lock must act as a global mutex, ie block between different
     candidate processus, but ALSO between different candidate
     threads of the same process.
     It must NOT block in case of recursive lock request issued by
     the SAME thread.
     Extraneous unlocks should be ideally harmless.

    *Implementation:
     --------------
     In Python there is no portable global lock AFAIK.
     There is only a LOCAL/ in-process Lock mechanism
     (threading.RLock), so we have to implement our own solution.

    Unix: use fcntl.flock(). Recursive calls OK. Different process OK.
          But <> threads, same process don't block so we have to
          use an extra threading.RLock to fix that point.
    Win: We use WIN32 mutex from Python Win32 extensions. Can't use
         std module msvcrt.locking(), because global lock is OK, but
         blocks also for 2 calls from the same thread!
'''
def __init__(self, fpath, lockInitially=false):
    '''	Creates (or opens) a global lock.

        @param fpath Path of the file used as lock target. This is also
                     the global id of the lock. The file will be created
                     if non existent.
        @param lockInitially if true locks initially.
    '''
    if _windows:
        self.name = string.replace(fpath, '\\', '_')
        self.mutex = win32event.CreateMutex(None, lockInitially, self.name)
    else: # Unix
        self.name = fpath
        self.flock = open(fpath, 'w')
        self.fdlock = self.flock.fileno()
        self.threadLock = threading.RLock()
    if lockInitially:
        self.acquire()

def __del__(self):
    #print '__del__ called' ##
    try: self.release()
    except: pass
    if _windows:
        win32api.CloseHandle(self.mutex)
    else:
        try: self.flock.close()
        except: pass

def __repr__(self):
    return '<Global lock @ %s>' % self.name

def acquire(self):
    ''' Locks. Suspends caller until done.

        On windows an IOError is raised after ~10 sec if the lock
        can't be acquired.
        @exception GlobalLockError if lock can't be acquired (timeout)
    '''
    if _windows:
        r = win32event.WaitForSingleObject(self.mutex, win32event.INFINITE)
        if r == win32event.WAIT_FAILED:
            raise GlobalLockError("Can't acquire mutex.")
    else:
        # Acquire 1st the global (inter-process) lock:
        try:
            fcntl.flock(self.fdlock, fcntl.LOCK_EX)	# blocking
        except IOError:	#(errno 13: perm. denied,
                        #		36: Resource deadlock avoided)
            raise GlobalLockError('Cannot acquire lock on "file" %s\n' %
                                    self.name)
        #print 'got file lock.' ##
        # Then acquire the local (inter-thread) lock:
        self.threadLock.acquire()
        #print 'got thread lock.' ##

def release(self):
    ''' Unlocks. (caller must own the lock!)

        @return The lock count.
        @exception IOError if file lock can't be released
        @exception NotOwner Attempt to release somebody else's lock.
    '''
    if _windows:
        try:
            win32event.ReleaseMutex(self.mutex)
        except pywintypes.error, e:
            errCode, fctName, errMsg =  e.args
            if errCode == 288:
                raise NotOwner("Attempt to release somebody else's lock")
            else:
                raise GlobalLockError('%s: err#%d: %s' % (fctName, errCode,
                                                          errMsg))
    else:
        # Acquire 1st the local (inter-thread) lock:
        try:
            self.threadLock.release()
        except AssertionError:
            raise NotOwner("Attempt to release somebody else's lock")

        # Then release the global (inter-process) lock:
        try:
            fcntl.flock(self.fdlock, fcntl.LOCK_UN)
        except IOError:	# (errno 13: permission denied)
            raise GlobalLockError('Unlock of file "%s" failed\n' %
                                                        self.name)

[Python-Dev] shm + Win32 + docs (was: Adding library modules to the core) (original) (raw)

glock.py: Global mutex

Prerequisites:

- Python 1.5.2 or newer (www.python.org)

- On windows: win32 extensions installed

(http://www.python.org/windows/win32all/win32all.exe)

- OS: Unix, Windows.

History:

-22 Jan 2000 (R.Gruet): creation

Limitations:

TODO:

Imports:

System-dependent imports for locking implementation:

Exceptions :

----------

Constants

---------: