← 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: 2010-12-07 10:16:53 UTC
  • mto: (5575.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 5576.
  • Revision ID: v.ladeuil+lp@free.fr-20101207101653-20iiufih26buvmy3
Use assertLength as it provides a better ouput to debug tests.

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):
184
142
            self.branch.unlock()
185
143
 
186
144
 
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
 
 
201
145
class SmartServerBranchRequestGetStackedOnURL(SmartServerBranchRequest):
202
146
 
203
147
    def do_with_branch(self, branch):
213
157
        The revision list is returned as the body content,
214
158
        with each revision utf8 encoded and \x00 joined.
215
159
        """
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
160
        return SuccessfulSmartServerResponse(
225
 
            ('ok', ), ('\x00'.join(reversed(history))))
 
161
            ('ok', ), ('\x00'.join(branch.revision_history())))
226
162
 
227
163
 
228
164
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
236
172
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
237
173
 
238
174
 
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
175
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
257
176
    """Base class for handling common branch request logic for requests that
258
177
    update the branch tip.
299
218
 
300
219
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
301
220
        if new_last_revision_id == 'null:':
302
 
            branch.set_last_revision_info(0, new_last_revision_id)
 
221
            branch.set_revision_history([])
303
222
        else:
304
223
            if not branch.repository.has_revision(new_last_revision_id):
305
224
                return FailedSmartServerResponse(
306
225
                    ('NoSuchRevision', new_last_revision_id))
307
 
            branch.generate_revision_history(new_last_revision_id, None, None)
 
226
            branch.set_revision_history(branch._lefthand_history(
 
227
                new_last_revision_id, None, None))
308
228
        return SuccessfulSmartServerResponse(('ok',))
309
229
 
310
230
 
434
354
        branch.unlock()
435
355
        return SuccessfulSmartServerResponse(('ok',))
436
356
 
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',))