← 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 10:37:58 UTC
  • mto: This revision was merged to the branch mainline in revision 6427.
  • Revision ID: martin.packman@canonical.com-20120105103758-wzftnmsip5iv9n2g
Revert addition of get_message_encoding function

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/branch.py
20
20
from bzrlib import (
21
21
    bencode,
22
22
    errors,
 
23
    revision as _mod_revision,
23
24
    )
24
 
from bzrlib.bzrdir import BzrDir
 
25
from bzrlib.controldir import ControlDir
25
26
from bzrlib.smart.request import (
26
27
    FailedSmartServerResponse,
27
28
    SmartServerRequest,
45
46
        :return: A SmartServerResponse from self.do_with_branch().
46
47
        """
47
48
        transport = self.transport_from_client_path(path)
48
 
        bzrdir = BzrDir.open_from_transport(transport)
49
 
        if bzrdir.get_branch_reference() is not None:
 
49
        controldir = ControlDir.open_from_transport(transport)
 
50
        if controldir.get_branch_reference() is not None:
50
51
            raise errors.NotBranchError(transport.base)
51
 
        branch = bzrdir.open_branch(ignore_fallbacks=True)
 
52
        branch = controldir.open_branch(ignore_fallbacks=True)
52
53
        return self.do_with_branch(branch, *args)
53
54
 
54
55
 
76
77
            branch.repository.unlock()
77
78
 
78
79
 
 
80
class SmartServerBranchBreakLock(SmartServerBranchRequest):
 
81
 
 
82
    def do_with_branch(self, branch):
 
83
        """Break a branch lock.
 
84
        """
 
85
        branch.break_lock()
 
86
        return SuccessfulSmartServerResponse(('ok', ), )
 
87
 
 
88
 
79
89
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
80
90
 
81
91
    def do_with_branch(self, branch):
84
94
        The body is not utf8 decoded - its the literal bytestream from disk.
85
95
        """
86
96
        try:
87
 
            content = branch._transport.get_bytes('branch.conf')
 
97
            content = branch.control_transport.get_bytes('branch.conf')
88
98
        except errors.NoSuchFile:
89
99
            content = ''
90
100
        return SuccessfulSmartServerResponse( ('ok', ), content)
91
101
 
92
102
 
 
103
class SmartServerBranchPutConfigFile(SmartServerBranchRequest):
 
104
    """Set the configuration data for a branch.
 
105
 
 
106
    New in 2.5.
 
107
    """
 
108
 
 
109
    def do_with_branch(self, branch, branch_token, repo_token):
 
110
        """Set the content of branch.conf.
 
111
 
 
112
        The body is not utf8 decoded - its the literal bytestream for disk.
 
113
        """
 
114
        self._branch = branch
 
115
        self._branch_token = branch_token
 
116
        self._repo_token = repo_token
 
117
        # Signal we want a body
 
118
        return None
 
119
 
 
120
    def do_body(self, body_bytes):
 
121
        self._branch.repository.lock_write(token=self._repo_token)
 
122
        try:
 
123
            self._branch.lock_write(token=self._branch_token)
 
124
            try:
 
125
                self._branch.control_transport.put_bytes(
 
126
                    'branch.conf', body_bytes)
 
127
            finally:
 
128
                self._branch.unlock()
 
129
        finally:
 
130
            self._branch.repository.unlock()
 
131
        return SuccessfulSmartServerResponse(('ok', ))
 
132
 
 
133
 
93
134
class SmartServerBranchGetParent(SmartServerBranchRequest):
94
135
 
95
136
    def do_with_branch(self, branch):
171
212
        The revision list is returned as the body content,
172
213
        with each revision utf8 encoded and \x00 joined.
173
214
        """
 
215
        branch.lock_read()
 
216
        try:
 
217
            graph = branch.repository.get_graph()
 
218
            stop_revisions = (None, _mod_revision.NULL_REVISION)
 
219
            history = list(graph.iter_lefthand_ancestry(
 
220
                branch.last_revision(), stop_revisions))
 
221
        finally:
 
222
            branch.unlock()
174
223
        return SuccessfulSmartServerResponse(
175
 
            ('ok', ), ('\x00'.join(branch.revision_history())))
 
224
            ('ok', ), ('\x00'.join(reversed(history))))
176
225
 
177
226
 
178
227
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
186
235
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
187
236
 
188
237
 
 
238
class SmartServerBranchRequestRevisionIdToRevno(SmartServerBranchRequest):
 
239
 
 
240
    def do_with_branch(self, branch, revid):
 
241
        """Return branch.revision_id_to_revno().
 
242
 
 
243
        New in 2.5.
 
244
 
 
245
        The revno is encoded in decimal, the revision_id is encoded as utf8.
 
246
        """
 
247
        try:
 
248
            dotted_revno = branch.revision_id_to_dotted_revno(revid)
 
249
        except errors.NoSuchRevision:
 
250
            return FailedSmartServerResponse(('NoSuchRevision', revid))
 
251
        return SuccessfulSmartServerResponse(
 
252
            ('ok', ) + tuple(map(str, dotted_revno)))
 
253
 
 
254
 
189
255
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
190
256
    """Base class for handling common branch request logic for requests that
191
257
    update the branch tip.
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',))