/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

https://launchpad.net/bugs/508288
Provide VersionedFiles.get_annotator.

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.flock(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.flock(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.flock(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
 
 
172
 
 
173
 
            class _msvc_ReadLock(_msvc_FileLock):
174
 
                def __init__(self, filename):
175
 
                    _msvc_lock(self._open(filename, 'rb'), self.LOCK_SH)
176
 
 
177
 
 
178
 
            class _msvc_WriteLock(_msvc_FileLock):
179
 
                def __init__(self, filename):
180
 
                    _msvc_lock(self._open(filename, 'wb'), self.LOCK_EX)
181
 
 
182
 
 
183
 
 
184
 
            def _msvc_lock(f, flags):
185
 
                try:
186
 
                    # Unfortunately, msvcrt.LK_RLCK is equivalent to msvcrt.LK_LOCK
187
 
                    # according to the comments, LK_RLCK is open the lock for writing.
188
 
 
189
 
                    # Unfortunately, msvcrt.locking() also has the side effect that it
190
 
                    # will only block for 10 seconds at most, and then it will throw an
191
 
                    # exception, this isn't terrible, though.
192
 
                    if type(f) == file:
193
 
                        fpos = f.tell()
194
 
                        fn = f.fileno()
195
 
                        f.seek(0)
196
 
                    else:
197
 
                        fn = f
198
 
                        fpos = os.lseek(fn, 0,0)
199
 
                        os.lseek(fn, 0,0)
200
 
 
201
 
                    if flags & self.LOCK_SH:
202
 
                        if flags & self.LOCK_NB:
203
 
                            lock_mode = msvcrt.LK_NBLCK
204
 
                        else:
205
 
                            lock_mode = msvcrt.LK_LOCK
206
 
                    elif flags & self.LOCK_EX:
207
 
                        if flags & self.LOCK_NB:
208
 
                            lock_mode = msvcrt.LK_NBRLCK
209
 
                        else:
210
 
                            lock_mode = msvcrt.LK_RLCK
211
 
                    else:
212
 
                        raise ValueError('Invalid lock mode: %r' % flags)
213
 
                    try:
214
 
                        msvcrt.locking(fn, lock_mode, -1)
215
 
                    finally:
216
 
                        os.lseek(fn, fpos, 0)
217
 
                except Exception, e:
218
 
                    raise LockError(e)
219
 
 
220
 
            def _msvc_unlock(f):
221
 
                try:
222
 
                    if type(f) == file:
223
 
                        fpos = f.tell()
224
 
                        fn = f.fileno()
225
 
                        f.seek(0)
226
 
                    else:
227
 
                        fn = f
228
 
                        fpos = os.lseek(fn, 0,0)
229
 
                        os.lseek(fn, 0,0)
230
 
 
231
 
                    try:
232
 
                        msvcrt.locking(fn, msvcrt.LK_UNLCK, -1)
233
 
                    finally:
234
 
                        os.lseek(fn, fpos, 0)
235
 
                except Exception, e:
236
 
                    raise LockError(e)
237
 
 
238
 
 
239
 
 
240
 
            WriteLock = _msvc_WriteLock
241
 
            ReadLock = _msvc_ReadLock
242
 
        except ImportError:
243
 
            raise NotImplementedError("please write a locking method "
244
 
                                      "for platform %r" % sys.platform)
245
 
 
246
 
 
247
 
 
248
 
 
249
 
 
250
 
 
251