~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

- rules for using destructors

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
 
18
 
"""Locking using OS file locks or file existence.
19
 
 
20
 
Note: This method of locking is generally deprecated in favour of LockDir, but
21
 
is used to lock local WorkingTrees, and by some old formats.  It's accessed
22
 
through Transport.lock_read(), etc.
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
"""Locking wrappers.
 
19
 
 
20
This only does local locking using OS locks for now.
23
21
 
24
22
This module causes two methods, lock() and unlock() to be defined in
25
23
any way that works on the current platform.
26
24
 
27
25
It is not specified whether these locks are reentrant (i.e. can be
28
26
taken repeatedly by a single process) or whether they exclude
29
 
different threads in a single process.  That reentrancy is provided by
30
 
LockableFiles.
 
27
different threads in a single process.  
 
28
 
 
29
Eventually we may need to use some kind of lock representation that
 
30
will work on a dumb filesystem without actual locking primitives.
31
31
 
32
32
This defines two classes: ReadLock and WriteLock, which can be
33
33
implemented in different ways on different platforms.  Both have an
34
34
unlock() method.
35
35
"""
36
36
 
37
 
import errno
 
37
 
 
38
import sys
38
39
import os
39
 
import sys
40
 
import warnings
41
 
 
42
 
from bzrlib import (
43
 
    debug,
44
 
    errors,
45
 
    osutils,
46
 
    trace,
47
 
    )
48
 
from bzrlib.hooks import HookPoint, Hooks
49
 
 
50
 
 
51
 
class LockHooks(Hooks):
52
 
 
53
 
    def __init__(self):
54
 
        Hooks.__init__(self)
55
 
        self.create_hook(HookPoint('lock_acquired',
56
 
            "Called with a bzrlib.lock.LockResult when a physical lock is "
57
 
            "acquired.", (1, 8), None))
58
 
        self.create_hook(HookPoint('lock_released',
59
 
            "Called with a bzrlib.lock.LockResult when a physical lock is "
60
 
            "released.", (1, 8), None))
61
 
        self.create_hook(HookPoint('lock_broken',
62
 
            "Called with a bzrlib.lock.LockResult when a physical lock is "
63
 
            "broken.", (1, 15), None))
64
 
 
65
 
 
66
 
class Lock(object):
67
 
    """Base class for locks.
68
 
 
69
 
    :cvar hooks: Hook dictionary for operations on locks.
70
 
    """
71
 
 
72
 
    hooks = LockHooks()
73
 
 
74
 
 
75
 
class LockResult(object):
76
 
    """Result of an operation on a lock; passed to a hook"""
77
 
 
78
 
    def __init__(self, lock_url, details=None):
79
 
        """Create a lock result for lock with optional details about the lock."""
80
 
        self.lock_url = lock_url
81
 
        self.details = details
82
 
 
83
 
    def __eq__(self, other):
84
 
        return self.lock_url == other.lock_url and self.details == other.details
85
 
 
86
 
    def __repr__(self):
87
 
        return '%s(%s%s)' % (self.__class__.__name__,
88
 
                             self.lock_url, self.details)
89
 
 
90
 
 
91
 
def cant_unlock_not_held(locked_object):
92
 
    """An attempt to unlock failed because the object was not locked.
93
 
 
94
 
    This provides a policy point from which we can generate either a warning 
95
 
    or an exception.
96
 
    """
97
 
    # This is typically masking some other error and called from a finally
98
 
    # block, so it's useful to have the option not to generate a new error
99
 
    # here.  You can use -Werror to make it fatal.  It should possibly also
100
 
    # raise LockNotHeld.
101
 
    if 'unlock' in debug.debug_flags:
102
 
        warnings.warn("%r is already unlocked" % (locked_object,),
103
 
            stacklevel=3)
104
 
    else:
105
 
        raise errors.LockNotHeld(locked_object)
106
 
 
107
 
 
108
 
try:
109
 
    import fcntl
110
 
    have_fcntl = True
111
 
except ImportError:
112
 
    have_fcntl = False
113
 
 
114
 
have_pywin32 = False
115
 
have_ctypes_win32 = False
116
 
if sys.platform == 'win32':
117
 
    import msvcrt
118
 
    try:
119
 
        import win32file, pywintypes, winerror
120
 
        have_pywin32 = True
121
 
    except ImportError:
122
 
        pass
123
 
 
124
 
    try:
125
 
        import ctypes
126
 
        have_ctypes_win32 = True
127
 
    except ImportError:
128
 
        pass
129
 
 
130
 
 
131
 
class _OSLock(object):
132
 
 
133
 
    def __init__(self):
134
 
        self.f = None
135
 
        self.filename = None
136
 
 
 
40
 
 
41
from bzrlib.trace import mutter, note, warning
 
42
from bzrlib.errors import LockError
 
43
 
 
44
class _base_Lock(object):
137
45
    def _open(self, filename, filemode):
138
 
        self.filename = osutils.realpath(filename)
 
46
        import errno
139
47
        try:
140
 
            self.f = open(self.filename, filemode)
 
48
            self.f = open(filename, filemode)
141
49
            return self.f
142
50
        except IOError, e:
143
 
            if e.errno in (errno.EACCES, errno.EPERM):
144
 
                raise errors.LockFailed(self.filename, str(e))
145
51
            if e.errno != errno.ENOENT:
146
52
                raise
147
53
 
148
54
            # maybe this is an old branch (before may 2005)
149
 
            trace.mutter("trying to create missing lock %r", self.filename)
150
 
 
151
 
            self.f = open(self.filename, 'wb+')
 
55
            mutter("trying to create missing branch lock %r" % filename)
 
56
            
 
57
            self.f = open(filename, 'wb')
152
58
            return self.f
153
59
 
154
 
    def _clear_f(self):
155
 
        """Clear the self.f attribute cleanly."""
156
 
        if self.f:
157
 
            self.f.close()
158
 
            self.f = None
159
60
 
160
61
    def __del__(self):
161
62
        if self.f:
162
63
            from warnings import warn
163
64
            warn("lock on %r not released" % self.f)
164
65
            self.unlock()
 
66
            
165
67
 
166
68
    def unlock(self):
167
69
        raise NotImplementedError()
168
70
 
169
 
 
170
 
_lock_classes = []
171
 
 
172
 
 
173
 
if have_fcntl:
174
 
 
175
 
    class _fcntl_FileLock(_OSLock):
176
 
 
177
 
        def _unlock(self):
 
71
        
 
72
 
 
73
 
 
74
 
 
75
 
 
76
############################################################
 
77
# msvcrt locks
 
78
 
 
79
 
 
80
try:
 
81
    import fcntl
 
82
 
 
83
    class _fcntl_FileLock(_base_Lock):
 
84
        f = None
 
85
 
 
86
        def unlock(self):
178
87
            fcntl.lockf(self.f, fcntl.LOCK_UN)
179
 
            self._clear_f()
 
88
            self.f.close()
 
89
            del self.f 
180
90
 
181
91
 
182
92
    class _fcntl_WriteLock(_fcntl_FileLock):
183
 
 
184
 
        _open_locks = set()
185
 
 
186
93
        def __init__(self, filename):
187
 
            super(_fcntl_WriteLock, self).__init__()
188
 
            # Check we can grab a lock before we actually open the file.
189
 
            self.filename = osutils.realpath(filename)
190
 
            if self.filename in _fcntl_WriteLock._open_locks:
191
 
                self._clear_f()
192
 
                raise errors.LockContention(self.filename)
193
 
            if self.filename in _fcntl_ReadLock._open_locks:
194
 
                if 'strict_locks' in debug.debug_flags:
195
 
                    self._clear_f()
196
 
                    raise errors.LockContention(self.filename)
197
 
                else:
198
 
                    trace.mutter('Write lock taken w/ an open read lock on: %s'
199
 
                                 % (self.filename,))
200
 
 
201
 
            self._open(self.filename, 'rb+')
202
 
            # reserve a slot for this lock - even if the lockf call fails,
203
 
            # at this point unlock() will be called, because self.f is set.
204
 
            # TODO: make this fully threadsafe, if we decide we care.
205
 
            _fcntl_WriteLock._open_locks.add(self.filename)
206
94
            try:
207
 
                # LOCK_NB will cause IOError to be raised if we can't grab a
208
 
                # lock right away.
209
 
                fcntl.lockf(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
210
 
            except IOError, e:
211
 
                if e.errno in (errno.EAGAIN, errno.EACCES):
212
 
                    # We couldn't grab the lock
213
 
                    self.unlock()
214
 
                # we should be more precise about whats a locking
215
 
                # error and whats a random-other error
216
 
                raise errors.LockContention(self.filename, e)
217
 
 
218
 
        def unlock(self):
219
 
            _fcntl_WriteLock._open_locks.remove(self.filename)
220
 
            self._unlock()
 
95
                fcntl.lockf(self._open(filename, 'wb'), fcntl.LOCK_EX)
 
96
            except Exception, e:
 
97
                raise LockError(e)
221
98
 
222
99
 
223
100
    class _fcntl_ReadLock(_fcntl_FileLock):
224
 
 
225
 
        _open_locks = {}
226
 
 
227
 
        def __init__(self, filename):
228
 
            super(_fcntl_ReadLock, self).__init__()
229
 
            self.filename = osutils.realpath(filename)
230
 
            if self.filename in _fcntl_WriteLock._open_locks:
231
 
                if 'strict_locks' in debug.debug_flags:
232
 
                    # We raise before calling _open so we don't need to
233
 
                    # _clear_f
234
 
                    raise errors.LockContention(self.filename)
235
 
                else:
236
 
                    trace.mutter('Read lock taken w/ an open write lock on: %s'
237
 
                                 % (self.filename,))
238
 
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
239
 
            _fcntl_ReadLock._open_locks[self.filename] += 1
240
 
            self._open(filename, 'rb')
241
 
            try:
242
 
                # LOCK_NB will cause IOError to be raised if we can't grab a
243
 
                # lock right away.
244
 
                fcntl.lockf(self.f, fcntl.LOCK_SH | fcntl.LOCK_NB)
245
 
            except IOError, e:
246
 
                # we should be more precise about whats a locking
247
 
                # error and whats a random-other error
248
 
                raise errors.LockContention(self.filename, e)
249
 
 
250
 
        def unlock(self):
251
 
            count = _fcntl_ReadLock._open_locks[self.filename]
252
 
            if count == 1:
253
 
                del _fcntl_ReadLock._open_locks[self.filename]
254
 
            else:
255
 
                _fcntl_ReadLock._open_locks[self.filename] = count - 1
256
 
            self._unlock()
257
 
 
258
 
        def temporary_write_lock(self):
259
 
            """Try to grab a write lock on the file.
260
 
 
261
 
            On platforms that support it, this will upgrade to a write lock
262
 
            without unlocking the file.
263
 
            Otherwise, this will release the read lock, and try to acquire a
264
 
            write lock.
265
 
 
266
 
            :return: A token which can be used to switch back to a read lock.
267
 
            """
268
 
            if self.filename in _fcntl_WriteLock._open_locks:
269
 
                raise AssertionError('file already locked: %r'
270
 
                    % (self.filename,))
271
 
            try:
272
 
                wlock = _fcntl_TemporaryWriteLock(self)
273
 
            except errors.LockError:
274
 
                # We didn't unlock, so we can just return 'self'
275
 
                return False, self
276
 
            return True, wlock
277
 
 
278
 
 
279
 
    class _fcntl_TemporaryWriteLock(_OSLock):
280
 
        """A token used when grabbing a temporary_write_lock.
281
 
 
282
 
        Call restore_read_lock() when you are done with the write lock.
283
 
        """
284
 
 
285
 
        def __init__(self, read_lock):
286
 
            super(_fcntl_TemporaryWriteLock, self).__init__()
287
 
            self._read_lock = read_lock
288
 
            self.filename = read_lock.filename
289
 
 
290
 
            count = _fcntl_ReadLock._open_locks[self.filename]
291
 
            if count > 1:
292
 
                # Something else also has a read-lock, so we cannot grab a
293
 
                # write lock.
294
 
                raise errors.LockContention(self.filename)
295
 
 
296
 
            if self.filename in _fcntl_WriteLock._open_locks:
297
 
                raise AssertionError('file already locked: %r'
298
 
                    % (self.filename,))
299
 
 
300
 
            # See if we can open the file for writing. Another process might
301
 
            # have a read lock. We don't use self._open() because we don't want
302
 
            # to create the file if it exists. That would have already been
303
 
            # done by _fcntl_ReadLock
304
 
            try:
305
 
                new_f = open(self.filename, 'rb+')
306
 
            except IOError, e:
307
 
                if e.errno in (errno.EACCES, errno.EPERM):
308
 
                    raise errors.LockFailed(self.filename, str(e))
309
 
                raise
310
 
            try:
311
 
                # LOCK_NB will cause IOError to be raised if we can't grab a
312
 
                # lock right away.
313
 
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
314
 
            except IOError, e:
315
 
                # TODO: Raise a more specific error based on the type of error
316
 
                raise errors.LockContention(self.filename, e)
317
 
            _fcntl_WriteLock._open_locks.add(self.filename)
318
 
 
319
 
            self.f = new_f
320
 
 
321
 
        def restore_read_lock(self):
322
 
            """Restore the original ReadLock."""
323
 
            # For fcntl, since we never released the read lock, just release the
324
 
            # write lock, and return the original lock.
325
 
            fcntl.lockf(self.f, fcntl.LOCK_UN)
326
 
            self._clear_f()
327
 
            _fcntl_WriteLock._open_locks.remove(self.filename)
328
 
            # Avoid reference cycles
329
 
            read_lock = self._read_lock
330
 
            self._read_lock = None
331
 
            return read_lock
332
 
 
333
 
 
334
 
    _lock_classes.append(('fcntl', _fcntl_WriteLock, _fcntl_ReadLock))
335
 
 
336
 
 
337
 
if have_pywin32 and sys.platform == 'win32':
338
 
    if os.path.supports_unicode_filenames:
339
 
        # for Windows NT/2K/XP/etc
340
 
        win32file_CreateFile = win32file.CreateFileW
341
 
    else:
342
 
        # for Windows 98
343
 
        win32file_CreateFile = win32file.CreateFile
344
 
 
345
 
    class _w32c_FileLock(_OSLock):
346
 
 
347
 
        def _open(self, filename, access, share, cflags, pymode):
348
 
            self.filename = osutils.realpath(filename)
349
 
            try:
350
 
                self._handle = win32file_CreateFile(filename, access, share,
351
 
                    None, win32file.OPEN_ALWAYS,
352
 
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
353
 
            except pywintypes.error, e:
354
 
                if e.args[0] == winerror.ERROR_ACCESS_DENIED:
355
 
                    raise errors.LockFailed(filename, e)
356
 
                if e.args[0] == winerror.ERROR_SHARING_VIOLATION:
357
 
                    raise errors.LockContention(filename, e)
358
 
                raise
359
 
            fd = win32file._open_osfhandle(self._handle, cflags)
360
 
            self.f = os.fdopen(fd, pymode)
361
 
            return self.f
362
 
 
363
 
        def unlock(self):
364
 
            self._clear_f()
365
 
            self._handle = None
366
 
 
367
 
 
368
 
    class _w32c_ReadLock(_w32c_FileLock):
369
 
        def __init__(self, filename):
370
 
            super(_w32c_ReadLock, self).__init__()
371
 
            self._open(filename, win32file.GENERIC_READ,
372
 
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
373
 
 
374
 
        def temporary_write_lock(self):
375
 
            """Try to grab a write lock on the file.
376
 
 
377
 
            On platforms that support it, this will upgrade to a write lock
378
 
            without unlocking the file.
379
 
            Otherwise, this will release the read lock, and try to acquire a
380
 
            write lock.
381
 
 
382
 
            :return: A token which can be used to switch back to a read lock.
383
 
            """
384
 
            # I can't find a way to upgrade a read lock to a write lock without
385
 
            # unlocking first. So here, we do just that.
386
 
            self.unlock()
387
 
            try:
388
 
                wlock = _w32c_WriteLock(self.filename)
389
 
            except errors.LockError:
390
 
                return False, _w32c_ReadLock(self.filename)
391
 
            return True, wlock
392
 
 
393
 
 
394
 
    class _w32c_WriteLock(_w32c_FileLock):
395
 
        def __init__(self, filename):
396
 
            super(_w32c_WriteLock, self).__init__()
397
 
            self._open(filename,
398
 
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
399
 
                os.O_RDWR, "rb+")
400
 
 
401
 
        def restore_read_lock(self):
402
 
            """Restore the original ReadLock."""
403
 
            # For win32 we had to completely let go of the original lock, so we
404
 
            # just unlock and create a new read lock.
405
 
            self.unlock()
406
 
            return _w32c_ReadLock(self.filename)
407
 
 
408
 
 
409
 
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
410
 
 
411
 
 
412
 
if have_ctypes_win32:
413
 
    from ctypes.wintypes import DWORD, LPCSTR, LPCWSTR
414
 
    LPSECURITY_ATTRIBUTES = ctypes.c_void_p # used as NULL no need to declare
415
 
    HANDLE = ctypes.c_int # rather than unsigned as in ctypes.wintypes
416
 
    if os.path.supports_unicode_filenames:
417
 
        _function_name = "CreateFileW"
418
 
        LPTSTR = LPCWSTR
419
 
    else:
420
 
        _function_name = "CreateFileA"
421
 
        class LPTSTR(LPCSTR):
422
 
            def __new__(cls, obj):
423
 
                return LPCSTR.__new__(cls, obj.encode("mbcs"))
424
 
 
425
 
    # CreateFile <http://msdn.microsoft.com/en-us/library/aa363858.aspx>
426
 
    _CreateFile = ctypes.WINFUNCTYPE(
427
 
            HANDLE,                # return value
428
 
            LPTSTR,                # lpFileName
429
 
            DWORD,                 # dwDesiredAccess
430
 
            DWORD,                 # dwShareMode
431
 
            LPSECURITY_ATTRIBUTES, # lpSecurityAttributes
432
 
            DWORD,                 # dwCreationDisposition
433
 
            DWORD,                 # dwFlagsAndAttributes
434
 
            HANDLE                 # hTemplateFile
435
 
        )((_function_name, ctypes.windll.kernel32))
436
 
 
437
 
    INVALID_HANDLE_VALUE = -1
438
 
 
439
 
    GENERIC_READ = 0x80000000
440
 
    GENERIC_WRITE = 0x40000000
441
 
    FILE_SHARE_READ = 1
442
 
    OPEN_ALWAYS = 4
443
 
    FILE_ATTRIBUTE_NORMAL = 128
444
 
 
445
 
    ERROR_ACCESS_DENIED = 5
446
 
    ERROR_SHARING_VIOLATION = 32
447
 
 
448
 
    class _ctypes_FileLock(_OSLock):
449
 
 
450
 
        def _open(self, filename, access, share, cflags, pymode):
451
 
            self.filename = osutils.realpath(filename)
452
 
            handle = _CreateFile(filename, access, share, None, OPEN_ALWAYS,
453
 
                FILE_ATTRIBUTE_NORMAL, 0)
454
 
            if handle in (INVALID_HANDLE_VALUE, 0):
455
 
                e = ctypes.WinError()
456
 
                if e.args[0] == ERROR_ACCESS_DENIED:
457
 
                    raise errors.LockFailed(filename, e)
458
 
                if e.args[0] == ERROR_SHARING_VIOLATION:
459
 
                    raise errors.LockContention(filename, e)
460
 
                raise e
461
 
            fd = msvcrt.open_osfhandle(handle, cflags)
462
 
            self.f = os.fdopen(fd, pymode)
463
 
            return self.f
464
 
 
465
 
        def unlock(self):
466
 
            self._clear_f()
467
 
 
468
 
 
469
 
    class _ctypes_ReadLock(_ctypes_FileLock):
470
 
        def __init__(self, filename):
471
 
            super(_ctypes_ReadLock, self).__init__()
472
 
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
473
 
                "rb")
474
 
 
475
 
        def temporary_write_lock(self):
476
 
            """Try to grab a write lock on the file.
477
 
 
478
 
            On platforms that support it, this will upgrade to a write lock
479
 
            without unlocking the file.
480
 
            Otherwise, this will release the read lock, and try to acquire a
481
 
            write lock.
482
 
 
483
 
            :return: A token which can be used to switch back to a read lock.
484
 
            """
485
 
            # I can't find a way to upgrade a read lock to a write lock without
486
 
            # unlocking first. So here, we do just that.
487
 
            self.unlock()
488
 
            try:
489
 
                wlock = _ctypes_WriteLock(self.filename)
490
 
            except errors.LockError:
491
 
                return False, _ctypes_ReadLock(self.filename)
492
 
            return True, wlock
493
 
 
494
 
    class _ctypes_WriteLock(_ctypes_FileLock):
495
 
        def __init__(self, filename):
496
 
            super(_ctypes_WriteLock, self).__init__()
497
 
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
498
 
                "rb+")
499
 
 
500
 
        def restore_read_lock(self):
501
 
            """Restore the original ReadLock."""
502
 
            # For win32 we had to completely let go of the original lock, so we
503
 
            # just unlock and create a new read lock.
504
 
            self.unlock()
505
 
            return _ctypes_ReadLock(self.filename)
506
 
 
507
 
 
508
 
    _lock_classes.append(('ctypes', _ctypes_WriteLock, _ctypes_ReadLock))
509
 
 
510
 
 
511
 
if len(_lock_classes) == 0:
512
 
    raise NotImplementedError(
513
 
        "We must have one of fcntl, pywin32, or ctypes available"
514
 
        " to support OS locking."
515
 
        )
516
 
 
517
 
 
518
 
# We default to using the first available lock class.
519
 
_lock_type, WriteLock, ReadLock = _lock_classes[0]
520
 
 
521
 
 
522
 
class _RelockDebugMixin(object):
523
 
    """Mixin support for -Drelock flag.
524
 
 
525
 
    Add this as a base class then call self._note_lock with 'r' or 'w' when
526
 
    acquiring a read- or write-lock.  If this object was previously locked (and
527
 
    locked the same way), and -Drelock is set, then this will trace.note a
528
 
    message about it.
529
 
    """
530
 
    
531
 
    _prev_lock = None
532
 
 
533
 
    def _note_lock(self, lock_type):
534
 
        if 'relock' in debug.debug_flags and self._prev_lock == lock_type:
535
 
            if lock_type == 'r':
536
 
                type_name = 'read'
537
 
            else:
538
 
                type_name = 'write'
539
 
            trace.note('%r was %s locked again', self, type_name)
540
 
        self._prev_lock = lock_type
 
101
        def __init__(self, filename):
 
102
            try:
 
103
                fcntl.lockf(self._open(filename, 'rb'), fcntl.LOCK_SH)
 
104
            except Exception, e:
 
105
                raise LockError(e)
 
106
 
 
107
    WriteLock = _fcntl_WriteLock
 
108
    ReadLock = _fcntl_ReadLock
 
109
 
 
110
except ImportError:
 
111
    try:
 
112
        import win32con, win32file, pywintypes
 
113
 
 
114
 
 
115
        #LOCK_SH = 0 # the default
 
116
        #LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
 
117
        #LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
 
118
 
 
119
        class _w32c_FileLock(_base_Lock):
 
120
            def _lock(self, filename, openmode, lockmode):
 
121
                try:
 
122
                    self._open(filename, openmode)
 
123
                    self.hfile = win32file._get_osfhandle(self.f.fileno())
 
124
                    overlapped = pywintypes.OVERLAPPED()
 
125
                    win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000, overlapped)
 
126
                except Exception, e:
 
127
                    raise LockError(e)
 
128
 
 
129
            def unlock(self):
 
130
                try:
 
131
                    overlapped = pywintypes.OVERLAPPED()
 
132
                    win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
 
133
                    self.f.close()
 
134
                    self.f = None
 
135
                except Exception, e:
 
136
                    raise LockError(e)
 
137
 
 
138
 
 
139
 
 
140
        class _w32c_ReadLock(_w32c_FileLock):
 
141
            def __init__(self, filename):
 
142
                _w32c_FileLock._lock(self, filename, 'rb', 0)
 
143
 
 
144
        class _w32c_WriteLock(_w32c_FileLock):
 
145
            def __init__(self, filename):
 
146
                _w32c_FileLock._lock(self, filename, 'wb',
 
147
                                     win32con.LOCKFILE_EXCLUSIVE_LOCK)
 
148
 
 
149
 
 
150
 
 
151
        WriteLock = _w32c_WriteLock
 
152
        ReadLock = _w32c_ReadLock
 
153
 
 
154
    except ImportError:
 
155
        try:
 
156
            import msvcrt
 
157
 
 
158
 
 
159
            # Unfortunately, msvcrt.locking() doesn't distinguish between
 
160
            # read locks and write locks. Also, the way the combinations
 
161
            # work to get non-blocking is not the same, so we
 
162
            # have to write extra special functions here.
 
163
 
 
164
 
 
165
            class _msvc_FileLock(_base_Lock):
 
166
                LOCK_SH = 1
 
167
                LOCK_EX = 2
 
168
                LOCK_NB = 4
 
169
                def unlock(self):
 
170
                    _msvc_unlock(self.f)
 
171
                    self.f.close()
 
172
                    self.f = None
 
173
 
 
174
 
 
175
            class _msvc_ReadLock(_msvc_FileLock):
 
176
                def __init__(self, filename):
 
177
                    _msvc_lock(self._open(filename, 'rb'), self.LOCK_SH)
 
178
 
 
179
 
 
180
            class _msvc_WriteLock(_msvc_FileLock):
 
181
                def __init__(self, filename):
 
182
                    _msvc_lock(self._open(filename, 'wb'), self.LOCK_EX)
 
183
 
 
184
 
 
185
 
 
186
            def _msvc_lock(f, flags):
 
187
                try:
 
188
                    # Unfortunately, msvcrt.LK_RLCK is equivalent to msvcrt.LK_LOCK
 
189
                    # according to the comments, LK_RLCK is open the lock for writing.
 
190
 
 
191
                    # Unfortunately, msvcrt.locking() also has the side effect that it
 
192
                    # will only block for 10 seconds at most, and then it will throw an
 
193
                    # exception, this isn't terrible, though.
 
194
                    if type(f) == file:
 
195
                        fpos = f.tell()
 
196
                        fn = f.fileno()
 
197
                        f.seek(0)
 
198
                    else:
 
199
                        fn = f
 
200
                        fpos = os.lseek(fn, 0,0)
 
201
                        os.lseek(fn, 0,0)
 
202
 
 
203
                    if flags & _msvc_FileLock.LOCK_SH:
 
204
                        if flags & _msvc_FileLock.LOCK_NB:
 
205
                            lock_mode = msvcrt.LK_NBLCK
 
206
                        else:
 
207
                            lock_mode = msvcrt.LK_LOCK
 
208
                    elif flags & _msvc_FileLock.LOCK_EX:
 
209
                        if flags & _msvc_FileLock.LOCK_NB:
 
210
                            lock_mode = msvcrt.LK_NBRLCK
 
211
                        else:
 
212
                            lock_mode = msvcrt.LK_RLCK
 
213
                    else:
 
214
                        raise ValueError('Invalid lock mode: %r' % flags)
 
215
                    try:
 
216
                        msvcrt.locking(fn, lock_mode, -1)
 
217
                    finally:
 
218
                        os.lseek(fn, fpos, 0)
 
219
                except Exception, e:
 
220
                    raise LockError(e)
 
221
 
 
222
            def _msvc_unlock(f):
 
223
                try:
 
224
                    if type(f) == file:
 
225
                        fpos = f.tell()
 
226
                        fn = f.fileno()
 
227
                        f.seek(0)
 
228
                    else:
 
229
                        fn = f
 
230
                        fpos = os.lseek(fn, 0,0)
 
231
                        os.lseek(fn, 0,0)
 
232
 
 
233
                    try:
 
234
                        msvcrt.locking(fn, msvcrt.LK_UNLCK, -1)
 
235
                    finally:
 
236
                        os.lseek(fn, fpos, 0)
 
237
                except Exception, e:
 
238
                    raise LockError(e)
 
239
 
 
240
 
 
241
 
 
242
            WriteLock = _msvc_WriteLock
 
243
            ReadLock = _msvc_ReadLock
 
244
        except ImportError:
 
245
            raise NotImplementedError("please write a locking method "
 
246
                                      "for platform %r" % sys.platform)
 
247
 
 
248
 
 
249
 
 
250
 
 
251
 
 
252
 
541
253