← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Martin Pool
  • Date: 2005-05-27 05:23:57 UTC
  • Revision ID: mbp@sourcefrog.net-20050527052357-240127f785aa3d60
- start to move toward Branch.lock and unlock methods, 
  rather than setting it in the constructor

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
32
32
from errors import BzrError
33
33
from textui import show_status
34
34
 
35
 
import lock
36
 
 
37
35
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
38
36
## TODO: Maybe include checks for common corruption of newlines, etc?
39
37
 
87
85
 
88
86
    base
89
87
        Base directory of the branch.
 
88
 
 
89
    _lock_mode
 
90
        None, or a duple with 'r' or 'w' for the first element and a positive
 
91
        count for the second.
 
92
 
 
93
    _lockfile
 
94
        Open file used for locking.
90
95
    """
91
 
    _lockmode = None
92
96
    base = None
 
97
    _lock_mode = None
93
98
    
94
99
    def __init__(self, base, init=False, find_root=True, lock_mode='w'):
95
100
        """Create new branch object at a particular location.
119
124
                                     ['use "bzr init" to initialize a new working tree',
120
125
                                      'current bzr can only operate from top-of-tree'])
121
126
        self._check_format()
122
 
        self._lockfile = None
 
127
        self._lockfile = self.controlfile('branch-lock', 'wb')
123
128
        self.lock(lock_mode)
124
129
 
125
130
        self.text_store = ImmutableStore(self.controlfilename('text-store'))
134
139
    __repr__ = __str__
135
140
 
136
141
 
137
 
 
138
 
    def lock(self, mode='w'):
139
 
        """Lock the on-disk branch, excluding other processes."""
140
 
        try:
141
 
            import fcntl, errno
142
 
 
143
 
            if mode == 'w':
144
 
                lm = fcntl.LOCK_EX
145
 
                om = os.O_WRONLY | os.O_CREAT
146
 
            elif mode == 'r':
147
 
                lm = fcntl.LOCK_SH
148
 
                om = os.O_RDONLY
149
 
            else:
150
 
                raise BzrError("invalid locking mode %r" % mode)
151
 
 
152
 
            try:
153
 
                lockfile = os.open(self.controlfilename('branch-lock'), om)
154
 
            except OSError, e:
155
 
                if e.errno == errno.ENOENT:
156
 
                    # might not exist on branches from <0.0.4
157
 
                    self.controlfile('branch-lock', 'w').close()
158
 
                    lockfile = os.open(self.controlfilename('branch-lock'), om)
159
 
                else:
160
 
                    raise e
161
 
            
162
 
            fcntl.lockf(lockfile, lm)
163
 
            def unlock():
164
 
                fcntl.lockf(lockfile, fcntl.LOCK_UN)
165
 
                os.close(lockfile)
166
 
                self._lockmode = None
167
 
            self.unlock = unlock
168
 
            self._lockmode = mode
169
 
        except ImportError:
170
 
            import warnings
171
 
            warnings.warning("please write a locking method for platform %r" % sys.platform)
172
 
            def unlock():
173
 
                self._lockmode = None
174
 
            self.unlock = unlock
175
 
            self._lockmode = mode
 
142
    def __del__(self):
 
143
        if self._lock_mode:
 
144
            from warnings import warn
 
145
            warn("branch %r was not explicitly unlocked" % self)
 
146
            self.unlock()
 
147
 
 
148
 
 
149
    def lock(self, mode):
 
150
        if self._lock_mode:
 
151
            raise BzrError('branch %r is already locked: %r' % (self, self._lock_mode))
 
152
 
 
153
        from bzrlib.lock import lock, LOCK_SH, LOCK_EX
 
154
        if mode == 'r':
 
155
            m = LOCK_SH
 
156
        elif mode == 'w':
 
157
            m = LOCK_EX
 
158
        else:
 
159
            raise ValueError('invalid lock mode %r' % mode)
 
160
        
 
161
        lock(self._lockfile, m)
 
162
        self._lock_mode = (mode, 1)
 
163
 
 
164
 
 
165
    def unlock(self):
 
166
        if not self._lock_mode:
 
167
            raise BzrError('branch %r is not locked' % (self))
 
168
        from bzrlib.lock import unlock
 
169
        unlock(self._lockfile)
 
170
        self._lock_mode = None
176
171
 
177
172
 
178
173
    def _need_readlock(self):
179
 
        if self._lockmode not in ['r', 'w']:
 
174
        if not self._lock_mode:
180
175
            raise BzrError('need read lock on branch, only have %r' % self._lockmode)
181
176
 
 
177
 
182
178
    def _need_writelock(self):
183
 
        if self._lockmode not in ['w']:
 
179
        if (self._lock_mode == None) or (self._lock_mode[0] != 'w'):
184
180
            raise BzrError('need write lock on branch, only have %r' % self._lockmode)
185
181
 
186
182