~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005 Canonical Ltd

# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""Locking wrappers.

This only does local locking using OS locks for now.

This module causes two methods, lock() and unlock() to be defined in

any way that works on the current platform.

It is not specified whether these locks are reentrant (i.e. can be

taken repeatedly by a single process) or whether they exclude

different threads in a single process.  

Eventually we may need to use some kind of lock representation that

will work on a dumb filesystem without actual locking primitives."""

import sys, os

import bzrlib

from trace import mutter, note, warning

class LockError(Exception):

    """All exceptions from the lock/unlock functions should be from this exception class.

    They will be translated as necessary. The original exception is available as e.original_error

    """

    def __init__(self, e=None):

        self.original_error = e

        if e:

            Exception.__init__(self, e)

        else:

            Exception.__init__(self)

try:

    import fcntl

    LOCK_SH = fcntl.LOCK_SH

    LOCK_EX = fcntl.LOCK_EX

    LOCK_NB = fcntl.LOCK_NB

    def lock(f, flags):

        try:

            fcntl.flock(f, flags)

        except Exception, e:

            raise LockError(e)

    def unlock(f):

        try:

            fcntl.flock(f, fcntl.LOCK_UN)

        except Exception, e:

            raise LockError(e)

except ImportError:

    try:

        import win32con, win32file, pywintypes

        LOCK_SH = 0 # the default

        LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK

        LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY

        def lock(f, flags):

            try:

                if type(f) == file:

                    hfile = win32file._get_osfhandle(f.fileno())

                else:

                    hfile = win32file._get_osfhandle(f)

                overlapped = pywintypes.OVERLAPPED()

                win32file.LockFileEx(hfile, flags, 0, 0x7fff0000, overlapped)

            except Exception, e:

                raise LockError(e)

        def unlock(f):

            try:

                if type(f) == file:

                    hfile = win32file._get_osfhandle(f.fileno())

                else:

                    hfile = win32file._get_osfhandle(f)

                overlapped = pywintypes.OVERLAPPED()

                win32file.UnlockFileEx(hfile, 0, 0x7fff0000, overlapped)

            except Exception, e:

                raise LockError(e)

    except ImportError:

        try:

            import msvcrt

            # Unfortunately, msvcrt.locking() doesn't distinguish between

            # read locks and write locks. Also, the way the combinations

            # work to get non-blocking is not the same, so we

            # have to write extra special functions here.

            LOCK_SH = 1

            LOCK_EX = 2

            LOCK_NB = 4

            def lock(f, flags):

                try:

                    # Unfortunately, msvcrt.LK_RLCK is equivalent to msvcrt.LK_LOCK

                    # according to the comments, LK_RLCK is open the lock for writing.

                    # Unfortunately, msvcrt.locking() also has the side effect that it

                    # will only block for 10 seconds at most, and then it will throw an

                    # exception, this isn't terrible, though.

                    if type(f) == file:

                        fpos = f.tell()

                        fn = f.fileno()

                        f.seek(0)

                    else:

                        fn = f

                        fpos = os.lseek(fn, 0,0)

                        os.lseek(fn, 0,0)

                    if flags & LOCK_SH:

                        if flags & LOCK_NB:

                            lock_mode = msvcrt.LK_NBLCK

                        else:

                            lock_mode = msvcrt.LK_LOCK

                    elif flags & LOCK_EX:

                        if flags & LOCK_NB:

                            lock_mode = msvcrt.LK_NBRLCK

                        else:

                            lock_mode = msvcrt.LK_RLCK

                    else:

                        raise ValueError('Invalid lock mode: %r' % flags)

                    try:

                        msvcrt.locking(fn, lock_mode, -1)

                    finally:

                        os.lseek(fn, fpos, 0)

                except Exception, e:

                    raise LockError(e)

            def unlock(f):

                try:

                    if type(f) == file:

                        fpos = f.tell()

                        fn = f.fileno()

                        f.seek(0)

                    else:

                        fn = f

                        fpos = os.lseek(fn, 0,0)

                        os.lseek(fn, 0,0)

                    try:

                        msvcrt.locking(fn, msvcrt.LK_UNLCK, -1)

                    finally:

                        os.lseek(fn, fpos, 0)

                except Exception, e:

                    raise LockError(e)

        except ImportError:

            from warnings import Warning

            warning("please write a locking method for platform %r" % sys.platform)

            # Creating no-op lock/unlock for now

            def lock(f, flags):

                pass

            def unlock(f):

                pass