← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/branch.py

Merge bzr.dev, update to use new hooks.

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):
142
183
            self.branch.unlock()
143
184
 
144
185
 
 
186
class SmartServerBranchHeadsToFetch(SmartServerBranchRequest):
 
187
 
 
188
    def do_with_branch(self, branch):
 
189
        """Return the heads-to-fetch for a Branch as two bencoded lists.
 
190
        
 
191
        See Branch.heads_to_fetch.
 
192
 
 
193
        New in 2.4.
 
194
        """
 
195
        must_fetch, if_present_fetch = branch.heads_to_fetch()
 
196
        return SuccessfulSmartServerResponse(
 
197
            (list(must_fetch), list(if_present_fetch)))
 
198
 
 
199
 
145
200
class SmartServerBranchRequestGetStackedOnURL(SmartServerBranchRequest):
146
201
 
147
202
    def do_with_branch(self, branch):
157
212
        The revision list is returned as the body content,
158
213
        with each revision utf8 encoded and \x00 joined.
159
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()
160
223
        return SuccessfulSmartServerResponse(
161
 
            ('ok', ), ('\x00'.join(branch.revision_history())))
 
224
            ('ok', ), ('\x00'.join(reversed(history))))
162
225
 
163
226
 
164
227
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
172
235
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
173
236
 
174
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
 
175
255
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
176
256
    """Base class for handling common branch request logic for requests that
177
257
    update the branch tip.
218
298
 
219
299
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
220
300
        if new_last_revision_id == 'null:':
221
 
            branch.set_revision_history([])
 
301
            branch._set_revision_history([])
222
302
        else:
223
303
            if not branch.repository.has_revision(new_last_revision_id):
224
304
                return FailedSmartServerResponse(
225
305
                    ('NoSuchRevision', new_last_revision_id))
226
 
            branch.set_revision_history(branch._lefthand_history(
 
306
            branch._set_revision_history(branch._lefthand_history(
227
307
                new_last_revision_id, None, None))
228
308
        return SuccessfulSmartServerResponse(('ok',))
229
309
 
354
434
        branch.unlock()
355
435
        return SuccessfulSmartServerResponse(('ok',))
356
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',))