← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/branch.py

  • Committer: Vincent Ladeuil
  • Date: 2012-01-18 14:09:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120118140919-rlvdrhpc0nq1lbwi
Change set/remove to require a lock for the branch config files.

This means that tests (or any plugin for that matter) do not requires an
explicit lock on the branch anymore to change a single option. This also
means the optimisation becomes "opt-in" and as such won't be as
spectacular as it may be and/or harder to get right (nothing fails
anymore).

This reduces the diff by ~300 lines.

Code/tests that were updating more than one config option is still taking
a lock to at least avoid some IOs and demonstrate the benefits through
the decreased number of hpss calls.

The duplication between BranchStack and BranchOnlyStack will be removed
once the same sharing is in place for local config files, at which point
the Stack class itself may be able to host the changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/branch.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
16
16
 
17
17
"""Server-side branch related request implmentations."""
18
18
 
 
19
from __future__ import absolute_import
19
20
 
20
 
from bzrlib import errors
21
 
from bzrlib.bzrdir import BzrDir
 
21
from bzrlib import (
 
22
    bencode,
 
23
    errors,
 
24
    revision as _mod_revision,
 
25
    )
 
26
from bzrlib.controldir import ControlDir
22
27
from bzrlib.smart.request import (
23
28
    FailedSmartServerResponse,
24
29
    SmartServerRequest,
42
47
        :return: A SmartServerResponse from self.do_with_branch().
43
48
        """
44
49
        transport = self.transport_from_client_path(path)
45
 
        bzrdir = BzrDir.open_from_transport(transport)
46
 
        if bzrdir.get_branch_reference() is not None:
 
50
        controldir = ControlDir.open_from_transport(transport)
 
51
        if controldir.get_branch_reference() is not None:
47
52
            raise errors.NotBranchError(transport.base)
48
 
        branch = bzrdir.open_branch(ignore_fallbacks=True)
 
53
        branch = controldir.open_branch(ignore_fallbacks=True)
49
54
        return self.do_with_branch(branch, *args)
50
55
 
51
56
 
73
78
            branch.repository.unlock()
74
79
 
75
80
 
 
81
class SmartServerBranchBreakLock(SmartServerBranchRequest):
 
82
 
 
83
    def do_with_branch(self, branch):
 
84
        """Break a branch lock.
 
85
        """
 
86
        branch.break_lock()
 
87
        return SuccessfulSmartServerResponse(('ok', ), )
 
88
 
 
89
 
76
90
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
77
91
 
78
92
    def do_with_branch(self, branch):
81
95
        The body is not utf8 decoded - its the literal bytestream from disk.
82
96
        """
83
97
        try:
84
 
            content = branch._transport.get_bytes('branch.conf')
 
98
            content = branch.control_transport.get_bytes('branch.conf')
85
99
        except errors.NoSuchFile:
86
100
            content = ''
87
101
        return SuccessfulSmartServerResponse( ('ok', ), content)
88
102
 
89
103
 
 
104
class SmartServerBranchPutConfigFile(SmartServerBranchRequest):
 
105
    """Set the configuration data for a branch.
 
106
 
 
107
    New in 2.5.
 
108
    """
 
109
 
 
110
    def do_with_branch(self, branch, branch_token, repo_token):
 
111
        """Set the content of branch.conf.
 
112
 
 
113
        The body is not utf8 decoded - its the literal bytestream for disk.
 
114
        """
 
115
        self._branch = branch
 
116
        self._branch_token = branch_token
 
117
        self._repo_token = repo_token
 
118
        # Signal we want a body
 
119
        return None
 
120
 
 
121
    def do_body(self, body_bytes):
 
122
        self._branch.repository.lock_write(token=self._repo_token)
 
123
        try:
 
124
            self._branch.lock_write(token=self._branch_token)
 
125
            try:
 
126
                self._branch.control_transport.put_bytes(
 
127
                    'branch.conf', body_bytes)
 
128
            finally:
 
129
                self._branch.unlock()
 
130
        finally:
 
131
            self._branch.repository.unlock()
 
132
        return SuccessfulSmartServerResponse(('ok', ))
 
133
 
 
134
 
90
135
class SmartServerBranchGetParent(SmartServerBranchRequest):
91
136
 
92
137
    def do_with_branch(self, branch):
139
184
            self.branch.unlock()
140
185
 
141
186
 
 
187
class SmartServerBranchHeadsToFetch(SmartServerBranchRequest):
 
188
 
 
189
    def do_with_branch(self, branch):
 
190
        """Return the heads-to-fetch for a Branch as two bencoded lists.
 
191
        
 
192
        See Branch.heads_to_fetch.
 
193
 
 
194
        New in 2.4.
 
195
        """
 
196
        must_fetch, if_present_fetch = branch.heads_to_fetch()
 
197
        return SuccessfulSmartServerResponse(
 
198
            (list(must_fetch), list(if_present_fetch)))
 
199
 
 
200
 
142
201
class SmartServerBranchRequestGetStackedOnURL(SmartServerBranchRequest):
143
202
 
144
203
    def do_with_branch(self, branch):
154
213
        The revision list is returned as the body content,
155
214
        with each revision utf8 encoded and \x00 joined.
156
215
        """
 
216
        branch.lock_read()
 
217
        try:
 
218
            graph = branch.repository.get_graph()
 
219
            stop_revisions = (None, _mod_revision.NULL_REVISION)
 
220
            history = list(graph.iter_lefthand_ancestry(
 
221
                branch.last_revision(), stop_revisions))
 
222
        finally:
 
223
            branch.unlock()
157
224
        return SuccessfulSmartServerResponse(
158
 
            ('ok', ), ('\x00'.join(branch.revision_history())))
 
225
            ('ok', ), ('\x00'.join(reversed(history))))
159
226
 
160
227
 
161
228
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
169
236
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
170
237
 
171
238
 
 
239
class SmartServerBranchRequestRevisionIdToRevno(SmartServerBranchRequest):
 
240
 
 
241
    def do_with_branch(self, branch, revid):
 
242
        """Return branch.revision_id_to_revno().
 
243
 
 
244
        New in 2.5.
 
245
 
 
246
        The revno is encoded in decimal, the revision_id is encoded as utf8.
 
247
        """
 
248
        try:
 
249
            dotted_revno = branch.revision_id_to_dotted_revno(revid)
 
250
        except errors.NoSuchRevision:
 
251
            return FailedSmartServerResponse(('NoSuchRevision', revid))
 
252
        return SuccessfulSmartServerResponse(
 
253
            ('ok', ) + tuple(map(str, dotted_revno)))
 
254
 
 
255
 
172
256
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
173
257
    """Base class for handling common branch request logic for requests that
174
258
    update the branch tip.
194
278
        return SuccessfulSmartServerResponse(())
195
279
 
196
280
 
 
281
class SmartServerBranchRequestSetConfigOptionDict(SmartServerLockedBranchRequest):
 
282
    """Set an option in the branch configuration.
 
283
    
 
284
    New in 2.2.
 
285
    """
 
286
 
 
287
    def do_with_locked_branch(self, branch, value_dict, name, section):
 
288
        utf8_dict = bencode.bdecode(value_dict)
 
289
        value_dict = {}
 
290
        for key, value in utf8_dict.items():
 
291
            value_dict[key.decode('utf8')] = value.decode('utf8')
 
292
        if not section:
 
293
            section = None
 
294
        branch._get_config().set_option(value_dict, name, section)
 
295
        return SuccessfulSmartServerResponse(())
 
296
 
 
297
 
197
298
class SmartServerBranchRequestSetLastRevision(SmartServerSetTipRequest):
198
299
 
199
300
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
200
301
        if new_last_revision_id == 'null:':
201
 
            branch.set_revision_history([])
 
302
            branch._set_revision_history([])
202
303
        else:
203
304
            if not branch.repository.has_revision(new_last_revision_id):
204
305
                return FailedSmartServerResponse(
205
306
                    ('NoSuchRevision', new_last_revision_id))
206
 
            branch.set_revision_history(branch._lefthand_history(
 
307
            branch._set_revision_history(branch._lefthand_history(
207
308
                new_last_revision_id, None, None))
208
309
        return SuccessfulSmartServerResponse(('ok',))
209
310
 
292
393
        if repo_token == '':
293
394
            repo_token = None
294
395
        try:
295
 
            repo_token = branch.repository.lock_write(token=repo_token)
 
396
            repo_token = branch.repository.lock_write(
 
397
                token=repo_token).repository_token
296
398
            try:
297
 
                branch_token = branch.lock_write(token=branch_token)
 
399
                branch_token = branch.lock_write(
 
400
                    token=branch_token).branch_token
298
401
            finally:
299
402
                # this leaves the repository with 1 lock
300
403
                branch.repository.unlock()
332
435
        branch.unlock()
333
436
        return SuccessfulSmartServerResponse(('ok',))
334
437
 
 
438
 
 
439
class SmartServerBranchRequestGetPhysicalLockStatus(SmartServerBranchRequest):
 
440
    """Get the physical lock status for a branch.
 
441
 
 
442
    New in 2.5.
 
443
    """
 
444
 
 
445
    def do_with_branch(self, branch):
 
446
        if branch.get_physical_lock_status():
 
447
            return SuccessfulSmartServerResponse(('yes',))
 
448
        else:
 
449
            return SuccessfulSmartServerResponse(('no',))