← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/branch.py

  • Committer: Martin Packman
  • Date: 2012-01-05 09:50:04 UTC
  • mfrom: (6424 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6426.
  • Revision ID: martin.packman@canonical.com-20120105095004-mia9xb7y0efmto0v
Merge bzr.dev to resolve conflicts in bzrlib.builtins

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.
368
435
        branch.unlock()
369
436
        return SuccessfulSmartServerResponse(('ok',))
370
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',))