← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/branch.py

  • Committer: Samuel Bronson
  • Date: 2012-08-30 20:36:18 UTC
  • mto: (6015.57.3 2.4)
  • mto: This revision was merged to the branch mainline in revision 6558.
  • Revision ID: naesten@gmail.com-20120830203618-y2dzw91nqpvpgxvx
Update INSTALL for switch to Python 2.6 and up.

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
20
19
 
21
20
from bzrlib import (
22
21
    bencode,
23
22
    errors,
24
 
    revision as _mod_revision,
25
23
    )
26
 
from bzrlib.controldir import ControlDir
 
24
from bzrlib.bzrdir import BzrDir
27
25
from bzrlib.smart.request import (
28
26
    FailedSmartServerResponse,
29
27
    SmartServerRequest,
47
45
        :return: A SmartServerResponse from self.do_with_branch().
48
46
        """
49
47
        transport = self.transport_from_client_path(path)
50
 
        controldir = ControlDir.open_from_transport(transport)
51
 
        if controldir.get_branch_reference() is not None:
 
48
        bzrdir = BzrDir.open_from_transport(transport)
 
49
        if bzrdir.get_branch_reference() is not None:
52
50
            raise errors.NotBranchError(transport.base)
53
 
        branch = controldir.open_branch(ignore_fallbacks=True)
 
51
        branch = bzrdir.open_branch(ignore_fallbacks=True)
54
52
        return self.do_with_branch(branch, *args)
55
53
 
56
54
 
78
76
            branch.repository.unlock()
79
77
 
80
78
 
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
 
 
90
79
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
91
80
 
92
81
    def do_with_branch(self, branch):
95
84
        The body is not utf8 decoded - its the literal bytestream from disk.
96
85
        """
97
86
        try:
98
 
            content = branch.control_transport.get_bytes('branch.conf')
 
87
            content = branch._transport.get_bytes('branch.conf')
99
88
        except errors.NoSuchFile:
100
89
            content = ''
101
90
        return SuccessfulSmartServerResponse( ('ok', ), content)
102
91
 
103
92
 
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
 
 
135
93
class SmartServerBranchGetParent(SmartServerBranchRequest):
136
94
 
137
95
    def do_with_branch(self, branch):
213
171
        The revision list is returned as the body content,
214
172
        with each revision utf8 encoded and \x00 joined.
215
173
        """
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()
224
174
        return SuccessfulSmartServerResponse(
225
 
            ('ok', ), ('\x00'.join(reversed(history))))
 
175
            ('ok', ), ('\x00'.join(branch.revision_history())))
226
176
 
227
177
 
228
178
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
236
186
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
237
187
 
238
188
 
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
 
 
256
189
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
257
190
    """Base class for handling common branch request logic for requests that
258
191
    update the branch tip.
435
368
        branch.unlock()
436
369
        return SuccessfulSmartServerResponse(('ok',))
437
370
 
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',))