/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/smart/branch.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-10 00:21:41 UTC
  • mto: This revision was merged to the branch mainline in revision 6675.
  • Revision ID: jelmer@jelmer.uk-20170610002141-m1z5k7fs8laesa65
Fix import.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/smart/branch.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Server-side branch related request implmentations."""
18
18
 
 
19
from __future__ import absolute_import
19
20
 
20
 
from bzrlib import errors
21
 
from bzrlib.bzrdir import BzrDir
22
 
from bzrlib.smart.request import (
 
21
from .. import (
 
22
    bencode,
 
23
    errors,
 
24
    revision as _mod_revision,
 
25
    )
 
26
from ..controldir import ControlDir
 
27
from .request import (
23
28
    FailedSmartServerResponse,
24
29
    SmartServerRequest,
25
30
    SuccessfulSmartServerResponse,
42
47
        :return: A SmartServerResponse from self.do_with_branch().
43
48
        """
44
49
        transport = self.transport_from_client_path(path)
45
 
        bzrdir = BzrDir.open_from_transport(transport)
46
 
        if bzrdir.get_branch_reference() is not None:
 
50
        controldir = ControlDir.open_from_transport(transport)
 
51
        if controldir.get_branch_reference() is not None:
47
52
            raise errors.NotBranchError(transport.base)
48
 
        branch = bzrdir.open_branch(ignore_fallbacks=True)
 
53
        branch = controldir.open_branch(ignore_fallbacks=True)
49
54
        return self.do_with_branch(branch, *args)
50
55
 
51
56
 
73
78
            branch.repository.unlock()
74
79
 
75
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
 
76
90
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
77
91
 
78
92
    def do_with_branch(self, branch):
81
95
        The body is not utf8 decoded - its the literal bytestream from disk.
82
96
        """
83
97
        try:
84
 
            content = branch._transport.get_bytes('branch.conf')
 
98
            content = branch.control_transport.get_bytes('branch.conf')
85
99
        except errors.NoSuchFile:
86
100
            content = ''
87
101
        return SuccessfulSmartServerResponse( ('ok', ), content)
88
102
 
89
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
 
90
135
class SmartServerBranchGetParent(SmartServerBranchRequest):
91
136
 
92
137
    def do_with_branch(self, branch):
139
184
            self.branch.unlock()
140
185
 
141
186
 
 
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
 
142
201
class SmartServerBranchRequestGetStackedOnURL(SmartServerBranchRequest):
143
202
 
144
203
    def do_with_branch(self, branch):
154
213
        The revision list is returned as the body content,
155
214
        with each revision utf8 encoded and \x00 joined.
156
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()
157
224
        return SuccessfulSmartServerResponse(
158
 
            ('ok', ), ('\x00'.join(branch.revision_history())))
 
225
            ('ok', ), ('\x00'.join(reversed(history))))
159
226
 
160
227
 
161
228
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
169
236
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
170
237
 
171
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
 
172
256
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
173
257
    """Base class for handling common branch request logic for requests that
174
258
    update the branch tip.
177
261
    def do_with_locked_branch(self, branch, *args):
178
262
        try:
179
263
            return self.do_tip_change_with_locked_branch(branch, *args)
180
 
        except errors.TipChangeRejected, e:
 
264
        except errors.TipChangeRejected as e:
181
265
            msg = e.msg
182
266
            if isinstance(msg, unicode):
183
267
                msg = msg.encode('utf-8')
194
278
        return SuccessfulSmartServerResponse(())
195
279
 
196
280
 
 
281
class SmartServerBranchRequestSetConfigOptionDict(SmartServerLockedBranchRequest):
 
282
    """Set an option in the branch configuration.
 
283
    
 
284
    New in 2.2.
 
285
    """
 
286
 
 
287
    def do_with_locked_branch(self, branch, value_dict, name, section):
 
288
        utf8_dict = bencode.bdecode(value_dict)
 
289
        value_dict = {}
 
290
        for key, value in utf8_dict.items():
 
291
            value_dict[key.decode('utf8')] = value.decode('utf8')
 
292
        if not section:
 
293
            section = None
 
294
        branch._get_config().set_option(value_dict, name, section)
 
295
        return SuccessfulSmartServerResponse(())
 
296
 
 
297
 
197
298
class SmartServerBranchRequestSetLastRevision(SmartServerSetTipRequest):
198
299
 
199
300
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
200
301
        if new_last_revision_id == 'null:':
201
 
            branch.set_revision_history([])
 
302
            branch.set_last_revision_info(0, new_last_revision_id)
202
303
        else:
203
304
            if not branch.repository.has_revision(new_last_revision_id):
204
305
                return FailedSmartServerResponse(
205
306
                    ('NoSuchRevision', new_last_revision_id))
206
 
            branch.set_revision_history(branch._lefthand_history(
207
 
                new_last_revision_id, None, None))
 
307
            branch.generate_revision_history(new_last_revision_id, None, None)
208
308
        return SuccessfulSmartServerResponse(('ok',))
209
309
 
210
310
 
260
360
    """Branch.set_last_revision_info.  Sets the revno and the revision ID of
261
361
    the specified branch.
262
362
 
263
 
    New in bzrlib 1.4.
 
363
    New in breezy 1.4.
264
364
    """
265
365
 
266
366
    def do_tip_change_with_locked_branch(self, branch, new_revno,
292
392
        if repo_token == '':
293
393
            repo_token = None
294
394
        try:
295
 
            repo_token = branch.repository.lock_write(token=repo_token)
 
395
            repo_token = branch.repository.lock_write(
 
396
                token=repo_token).repository_token
296
397
            try:
297
 
                branch_token = branch.lock_write(token=branch_token)
 
398
                branch_token = branch.lock_write(
 
399
                    token=branch_token).branch_token
298
400
            finally:
299
401
                # this leaves the repository with 1 lock
300
402
                branch.repository.unlock()
304
406
            return FailedSmartServerResponse(('TokenMismatch',))
305
407
        except errors.UnlockableTransport:
306
408
            return FailedSmartServerResponse(('UnlockableTransport',))
307
 
        except errors.LockFailed, e:
 
409
        except errors.LockFailed as e:
308
410
            return FailedSmartServerResponse(('LockFailed', str(e.lock), str(e.why)))
309
411
        if repo_token is None:
310
412
            repo_token = ''
332
434
        branch.unlock()
333
435
        return SuccessfulSmartServerResponse(('ok',))
334
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',))