← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/branch.py

  • Committer: Patch Queue Manager
  • Date: 2016-02-01 19:13:13 UTC
  • mfrom: (6614.2.2 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20160201191313-wdfvmfff1djde6oq
(vila) Release 2.7.0 (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/branch.py
16
16
 
17
17
"""Server-side branch related request implmentations."""
18
18
 
 
19
from __future__ import absolute_import
19
20
 
20
21
from bzrlib import (
21
22
    bencode,
22
23
    errors,
 
24
    revision as _mod_revision,
23
25
    )
24
 
from bzrlib.bzrdir import BzrDir
 
26
from bzrlib.controldir import ControlDir
25
27
from bzrlib.smart.request import (
26
28
    FailedSmartServerResponse,
27
29
    SmartServerRequest,
45
47
        :return: A SmartServerResponse from self.do_with_branch().
46
48
        """
47
49
        transport = self.transport_from_client_path(path)
48
 
        bzrdir = BzrDir.open_from_transport(transport)
49
 
        if bzrdir.get_branch_reference() is not None:
 
50
        controldir = ControlDir.open_from_transport(transport)
 
51
        if controldir.get_branch_reference() is not None:
50
52
            raise errors.NotBranchError(transport.base)
51
 
        branch = bzrdir.open_branch(ignore_fallbacks=True)
 
53
        branch = controldir.open_branch(ignore_fallbacks=True)
52
54
        return self.do_with_branch(branch, *args)
53
55
 
54
56
 
76
78
            branch.repository.unlock()
77
79
 
78
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
 
79
90
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
80
91
 
81
92
    def do_with_branch(self, branch):
84
95
        The body is not utf8 decoded - its the literal bytestream from disk.
85
96
        """
86
97
        try:
87
 
            content = branch._transport.get_bytes('branch.conf')
 
98
            content = branch.control_transport.get_bytes('branch.conf')
88
99
        except errors.NoSuchFile:
89
100
            content = ''
90
101
        return SuccessfulSmartServerResponse( ('ok', ), content)
91
102
 
92
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
 
93
135
class SmartServerBranchGetParent(SmartServerBranchRequest):
94
136
 
95
137
    def do_with_branch(self, branch):
171
213
        The revision list is returned as the body content,
172
214
        with each revision utf8 encoded and \x00 joined.
173
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()
174
224
        return SuccessfulSmartServerResponse(
175
 
            ('ok', ), ('\x00'.join(branch.revision_history())))
 
225
            ('ok', ), ('\x00'.join(reversed(history))))
176
226
 
177
227
 
178
228
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
186
236
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
187
237
 
188
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
 
189
256
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
190
257
    """Base class for handling common branch request logic for requests that
191
258
    update the branch tip.
232
299
 
233
300
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
234
301
        if new_last_revision_id == 'null:':
235
 
            branch._set_revision_history([])
 
302
            branch.set_last_revision_info(0, new_last_revision_id)
236
303
        else:
237
304
            if not branch.repository.has_revision(new_last_revision_id):
238
305
                return FailedSmartServerResponse(
239
306
                    ('NoSuchRevision', new_last_revision_id))
240
 
            branch._set_revision_history(branch._lefthand_history(
241
 
                new_last_revision_id, None, None))
 
307
            branch.generate_revision_history(new_last_revision_id, None, None)
242
308
        return SuccessfulSmartServerResponse(('ok',))
243
309
 
244
310
 
368
434
        branch.unlock()
369
435
        return SuccessfulSmartServerResponse(('ok',))
370
436
 
 
437
 
 
438
class SmartServerBranchRequestGetPhysicalLockStatus(SmartServerBranchRequest):
 
439
    """Get the physical lock status for a branch.
 
440
 
 
441
    New in 2.5.
 
442
    """
 
443
 
 
444
    def do_with_branch(self, branch):
 
445
        if branch.get_physical_lock_status():
 
446
            return SuccessfulSmartServerResponse(('yes',))
 
447
        else:
 
448
            return SuccessfulSmartServerResponse(('no',))