← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

Merge from jam-storage.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lock.py
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
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.
 
21
 
 
22
This module causes two methods, lock() and unlock() to be defined in
 
23
any way that works on the current platform.
 
24
 
 
25
It is not specified whether these locks are reentrant (i.e. can be
 
26
taken repeatedly by a single process) or whether they exclude
 
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
 
 
32
This defines two classes: ReadLock and WriteLock, which can be
 
33
implemented in different ways on different platforms.  Both have an
 
34
unlock() method.
 
35
"""
 
36
 
 
37
 
 
38
import sys
 
39
import os
 
40
 
 
41
from bzrlib.trace import mutter, note, warning
 
42
from bzrlib.errors import LockError
 
43
 
 
44
class _base_Lock(object):
 
45
    def _open(self, filename, filemode):
 
46
        import errno
 
47
        try:
 
48
            self.f = open(filename, filemode)
 
49
            return self.f
 
50
        except IOError, e:
 
51
            if e.errno != errno.ENOENT:
 
52
                raise
 
53
 
 
54
            # maybe this is an old branch (before may 2005)
 
55
            mutter("trying to create missing branch lock %r", filename)
 
56
            
 
57
            self.f = open(filename, 'wb')
 
58
            return self.f
 
59
 
 
60
 
 
61
    def __del__(self):
 
62
        if self.f:
 
63
            from warnings import warn
 
64
            warn("lock on %r not released" % self.f)
 
65
            self.unlock()
 
66
            
 
67
 
 
68
    def unlock(self):
 
69
        raise NotImplementedError()
 
70
 
 
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):
 
87
            fcntl.lockf(self.f, fcntl.LOCK_UN)
 
88
            self.f.close()
 
89
            del self.f 
 
90
 
 
91
 
 
92
    class _fcntl_WriteLock(_fcntl_FileLock):
 
93
        def __init__(self, filename):
 
94
            try:
 
95
                fcntl.lockf(self._open(filename, 'wb'), fcntl.LOCK_EX)
 
96
            except Exception, e:
 
97
                raise LockError(e)
 
98
 
 
99
 
 
100
    class _fcntl_ReadLock(_fcntl_FileLock):
 
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',
 
143
                                     LOCK_NB)
 
144
 
 
145
        class _w32c_WriteLock(_w32c_FileLock):
 
146
            def __init__(self, filename):
 
147
                _w32c_FileLock._lock(self, filename, 'wb',
 
148
                                     LOCK_EX + LOCK_NB)
 
149
 
 
150
 
 
151
 
 
152
        WriteLock = _w32c_WriteLock
 
153
        ReadLock = _w32c_ReadLock
 
154
 
 
155
    except ImportError:
 
156
        try:
 
157
            import msvcrt
 
158
 
 
159
 
 
160
            # Unfortunately, msvcrt.locking() doesn't distinguish between
 
161
            # read locks and write locks. Also, the way the combinations
 
162
            # work to get non-blocking is not the same, so we
 
163
            # have to write extra special functions here.
 
164
 
 
165
 
 
166
            class _msvc_FileLock(_base_Lock):
 
167
                LOCK_SH = 1
 
168
                LOCK_EX = 2
 
169
                LOCK_NB = 4
 
170
                def unlock(self):
 
171
                    _msvc_unlock(self.f)
 
172
                    self.f.close()
 
173
                    self.f = None
 
174
 
 
175
 
 
176
            class _msvc_ReadLock(_msvc_FileLock):
 
177
                def __init__(self, filename):
 
178
                    _msvc_lock(self._open(filename, 'rb'), self.LOCK_SH)
 
179
 
 
180
 
 
181
            class _msvc_WriteLock(_msvc_FileLock):
 
182
                def __init__(self, filename):
 
183
                    _msvc_lock(self._open(filename, 'wb'), self.LOCK_EX)
 
184
 
 
185
 
 
186
 
 
187
            def _msvc_lock(f, flags):
 
188
                try:
 
189
                    # Unfortunately, msvcrt.LK_RLCK is equivalent to msvcrt.LK_LOCK
 
190
                    # according to the comments, LK_RLCK is open the lock for writing.
 
191
 
 
192
                    # Unfortunately, msvcrt.locking() also has the side effect that it
 
193
                    # will only block for 10 seconds at most, and then it will throw an
 
194
                    # exception, this isn't terrible, though.
 
195
                    if type(f) == file:
 
196
                        fpos = f.tell()
 
197
                        fn = f.fileno()
 
198
                        f.seek(0)
 
199
                    else:
 
200
                        fn = f
 
201
                        fpos = os.lseek(fn, 0,0)
 
202
                        os.lseek(fn, 0,0)
 
203
 
 
204
                    if flags & _msvc_FileLock.LOCK_SH:
 
205
                        if flags & _msvc_FileLock.LOCK_NB:
 
206
                            lock_mode = msvcrt.LK_NBLCK
 
207
                        else:
 
208
                            lock_mode = msvcrt.LK_LOCK
 
209
                    elif flags & _msvc_FileLock.LOCK_EX:
 
210
                        if flags & _msvc_FileLock.LOCK_NB:
 
211
                            lock_mode = msvcrt.LK_NBRLCK
 
212
                        else:
 
213
                            lock_mode = msvcrt.LK_RLCK
 
214
                    else:
 
215
                        raise ValueError('Invalid lock mode: %r' % flags)
 
216
                    try:
 
217
                        msvcrt.locking(fn, lock_mode, -1)
 
218
                    finally:
 
219
                        os.lseek(fn, fpos, 0)
 
220
                except Exception, e:
 
221
                    raise LockError(e)
 
222
 
 
223
            def _msvc_unlock(f):
 
224
                try:
 
225
                    if type(f) == file:
 
226
                        fpos = f.tell()
 
227
                        fn = f.fileno()
 
228
                        f.seek(0)
 
229
                    else:
 
230
                        fn = f
 
231
                        fpos = os.lseek(fn, 0,0)
 
232
                        os.lseek(fn, 0,0)
 
233
 
 
234
                    try:
 
235
                        msvcrt.locking(fn, msvcrt.LK_UNLCK, -1)
 
236
                    finally:
 
237
                        os.lseek(fn, fpos, 0)
 
238
                except Exception, e:
 
239
                    raise LockError(e)
 
240
 
 
241
 
 
242
 
 
243
            WriteLock = _msvc_WriteLock
 
244
            ReadLock = _msvc_ReadLock
 
245
        except ImportError:
 
246
            raise NotImplementedError("please write a locking method "
 
247
                                      "for platform %r" % sys.platform)
 
248
 
 
249
 
 
250
 
 
251
 
 
252
 
 
253
 
 
254