~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

  • Committer: Martin Pool
  • Date: 2005-06-10 06:34:26 UTC
  • Revision ID: mbp@sourcefrog.net-20050610063426-cfcf5c0f96c271ec
- split out updated progress indicator

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005 Canonical Ltd
2
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
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
"""Locking using OS file locks or file existence.
 
18
"""Locking wrappers.
19
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.
 
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
38
 
import os
39
 
import sys
40
 
 
41
 
from bzrlib.trace import mutter, note, warning
42
 
from bzrlib.errors import LockError
 
37
 
 
38
import sys, os
 
39
 
 
40
from trace import mutter, note, warning
 
41
from errors import LockError
43
42
 
44
43
class _base_Lock(object):
45
44
    def _open(self, filename, filemode):
46
 
        try:
47
 
            self.f = open(filename, filemode)
48
 
            return self.f
49
 
        except IOError, e:
50
 
            if e.errno != errno.ENOENT:
51
 
                raise
52
 
 
53
 
            # maybe this is an old branch (before may 2005)
54
 
            mutter("trying to create missing branch lock %r", filename)
55
 
            
56
 
            self.f = open(filename, 'wb+')
57
 
            return self.f
 
45
        self.f = open(filename, filemode)
 
46
        return self.f
 
47
    
58
48
 
59
49
    def __del__(self):
60
50
        if self.f:
61
51
            from warnings import warn
62
52
            warn("lock on %r not released" % self.f)
63
53
            self.unlock()
64
 
            
 
54
 
65
55
    def unlock(self):
66
56
        raise NotImplementedError()
67
57
 
81
71
        f = None
82
72
 
83
73
        def unlock(self):
84
 
            fcntl.lockf(self.f, fcntl.LOCK_UN)
 
74
            fcntl.flock(self.f, fcntl.LOCK_UN)
85
75
            self.f.close()
86
76
            del self.f 
87
77
 
 
78
 
88
79
    class _fcntl_WriteLock(_fcntl_FileLock):
89
80
        def __init__(self, filename):
90
 
            # standard IO errors get exposed directly.
91
 
            self._open(filename, 'wb')
92
81
            try:
93
 
                fcntl.lockf(self.f, fcntl.LOCK_EX)
94
 
            except IOError, e:
95
 
                # we should be more precise about whats a locking
96
 
                # error and whats a random-other error
 
82
                fcntl.flock(self._open(filename, 'wb'), fcntl.LOCK_EX)
 
83
            except Exception, e:
97
84
                raise LockError(e)
98
85
 
 
86
 
99
87
    class _fcntl_ReadLock(_fcntl_FileLock):
100
 
 
101
88
        def __init__(self, filename):
102
 
            # standard IO errors get exposed directly.
103
 
            self._open(filename, 'rb')
104
89
            try:
105
 
                fcntl.lockf(self.f, fcntl.LOCK_SH)
106
 
            except IOError, e:
107
 
                # we should be more precise about whats a locking
108
 
                # error and whats a random-other error
 
90
                fcntl.flock(self._open(filename, 'rb'), fcntl.LOCK_SH)
 
91
            except Exception, e:
109
92
                raise LockError(e)
110
93
 
111
94
    WriteLock = _fcntl_WriteLock
112
95
    ReadLock = _fcntl_ReadLock
113
96
 
114
 
 
115
97
except ImportError:
116
98
    try:
117
99
        import win32con, win32file, pywintypes
118
100
 
119
101
 
120
 
        LOCK_SH = 0 # the default
121
 
        LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
122
 
        LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
 
102
        #LOCK_SH = 0 # the default
 
103
        #LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
 
104
        #LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
123
105
 
124
106
        class _w32c_FileLock(_base_Lock):
125
107
            def _lock(self, filename, openmode, lockmode):
144
126
 
145
127
        class _w32c_ReadLock(_w32c_FileLock):
146
128
            def __init__(self, filename):
147
 
                _w32c_FileLock._lock(self, filename, 'rb',
148
 
                                     LOCK_NB)
 
129
                _w32c_FileLock._lock(self, filename, 'rb', 0)
149
130
 
150
131
        class _w32c_WriteLock(_w32c_FileLock):
151
132
            def __init__(self, filename):
152
133
                _w32c_FileLock._lock(self, filename, 'wb',
153
 
                                     LOCK_EX + LOCK_NB)
 
134
                                     win32con.LOCKFILE_EXCLUSIVE_LOCK)
154
135
 
155
136
 
156
137
 
174
155
                LOCK_NB = 4
175
156
                def unlock(self):
176
157
                    _msvc_unlock(self.f)
177
 
                    self.f.close()
178
 
                    self.f = None
179
158
 
180
159
 
181
160
            class _msvc_ReadLock(_msvc_FileLock):
206
185
                        fpos = os.lseek(fn, 0,0)
207
186
                        os.lseek(fn, 0,0)
208
187
 
209
 
                    if flags & _msvc_FileLock.LOCK_SH:
210
 
                        if flags & _msvc_FileLock.LOCK_NB:
 
188
                    if flags & self.LOCK_SH:
 
189
                        if flags & self.LOCK_NB:
211
190
                            lock_mode = msvcrt.LK_NBLCK
212
191
                        else:
213
192
                            lock_mode = msvcrt.LK_LOCK
214
 
                    elif flags & _msvc_FileLock.LOCK_EX:
215
 
                        if flags & _msvc_FileLock.LOCK_NB:
 
193
                    elif flags & self.LOCK_EX:
 
194
                        if flags & self.LOCK_NB:
216
195
                            lock_mode = msvcrt.LK_NBRLCK
217
196
                        else:
218
197
                            lock_mode = msvcrt.LK_RLCK
250
229
        except ImportError:
251
230
            raise NotImplementedError("please write a locking method "
252
231
                                      "for platform %r" % sys.platform)
 
232
 
 
233
 
 
234
 
 
235
 
 
236
 
 
237
 
 
238