/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 bzrlib/smart/branch.py

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

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 ... import (
 
19
from __future__ import absolute_import
 
20
 
 
21
from bzrlib import (
20
22
    bencode,
21
23
    errors,
22
24
    revision as _mod_revision,
23
25
    )
24
 
from ...controldir import ControlDir
25
 
from .request import (
 
26
from bzrlib.controldir import ControlDir
 
27
from bzrlib.smart.request import (
26
28
    FailedSmartServerResponse,
27
29
    SmartServerRequest,
28
30
    SuccessfulSmartServerResponse,
65
67
        processed.  The physical lock state won't be changed.
66
68
        """
67
69
        # XXX: write a test for LockContention
68
 
        with branch.repository.lock_write(token=repo_token), \
69
 
                branch.lock_write(token=branch_token):
70
 
            return self.do_with_locked_branch(branch, *args)
 
70
        branch.repository.lock_write(token=repo_token)
 
71
        try:
 
72
            branch.lock_write(token=branch_token)
 
73
            try:
 
74
                return self.do_with_locked_branch(branch, *args)
 
75
            finally:
 
76
                branch.unlock()
 
77
        finally:
 
78
            branch.repository.unlock()
71
79
 
72
80
 
73
81
class SmartServerBranchBreakLock(SmartServerBranchRequest):
76
84
        """Break a branch lock.
77
85
        """
78
86
        branch.break_lock()
79
 
        return SuccessfulSmartServerResponse((b'ok', ), )
 
87
        return SuccessfulSmartServerResponse(('ok', ), )
80
88
 
81
89
 
82
90
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
89
97
        try:
90
98
            content = branch.control_transport.get_bytes('branch.conf')
91
99
        except errors.NoSuchFile:
92
 
            content = b''
93
 
        return SuccessfulSmartServerResponse((b'ok', ), content)
 
100
            content = ''
 
101
        return SuccessfulSmartServerResponse( ('ok', ), content)
94
102
 
95
103
 
96
104
class SmartServerBranchPutConfigFile(SmartServerBranchRequest):
111
119
        return None
112
120
 
113
121
    def do_body(self, body_bytes):
114
 
        with self._branch.repository.lock_write(token=self._repo_token), \
115
 
                self._branch.lock_write(token=self._branch_token):
116
 
            self._branch.control_transport.put_bytes(
117
 
                'branch.conf', body_bytes)
118
 
        return SuccessfulSmartServerResponse((b'ok', ))
 
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', ))
119
133
 
120
134
 
121
135
class SmartServerBranchGetParent(SmartServerBranchRequest):
123
137
    def do_with_branch(self, branch):
124
138
        """Return the parent of branch."""
125
139
        parent = branch._get_parent_location() or ''
126
 
        return SuccessfulSmartServerResponse((parent.encode('utf-8'),))
 
140
        return SuccessfulSmartServerResponse((parent,))
127
141
 
128
142
 
129
143
class SmartServerBranchGetTagsBytes(SmartServerBranchRequest):
140
154
        SmartServerLockedBranchRequest.__init__(
141
155
            self, backing_transport, root_client_path, jail_root)
142
156
        self.locked = False
143
 
 
 
157
        
144
158
    def do_with_locked_branch(self, branch):
145
159
        """Call _set_tags_bytes for a branch.
146
160
 
174
188
 
175
189
    def do_with_branch(self, branch):
176
190
        """Return the heads-to-fetch for a Branch as two bencoded lists.
177
 
 
 
191
        
178
192
        See Branch.heads_to_fetch.
179
193
 
180
194
        New in 2.4.
188
202
 
189
203
    def do_with_branch(self, branch):
190
204
        stacked_on_url = branch.get_stacked_on_url()
191
 
        return SuccessfulSmartServerResponse((b'ok', stacked_on_url.encode('ascii')))
 
205
        return SuccessfulSmartServerResponse(('ok', stacked_on_url))
192
206
 
193
207
 
194
208
class SmartServerRequestRevisionHistory(SmartServerBranchRequest):
199
213
        The revision list is returned as the body content,
200
214
        with each revision utf8 encoded and \x00 joined.
201
215
        """
202
 
        with branch.lock_read():
 
216
        branch.lock_read()
 
217
        try:
203
218
            graph = branch.repository.get_graph()
204
219
            stop_revisions = (None, _mod_revision.NULL_REVISION)
205
220
            history = list(graph.iter_lefthand_ancestry(
206
221
                branch.last_revision(), stop_revisions))
 
222
        finally:
 
223
            branch.unlock()
207
224
        return SuccessfulSmartServerResponse(
208
 
            (b'ok', ), (b'\x00'.join(reversed(history))))
 
225
            ('ok', ), ('\x00'.join(reversed(history))))
209
226
 
210
227
 
211
228
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
216
233
        The revno is encoded in decimal, the revision_id is encoded as utf8.
217
234
        """
218
235
        revno, last_revision = branch.last_revision_info()
219
 
        return SuccessfulSmartServerResponse(
220
 
            (b'ok', str(revno).encode('ascii'), last_revision))
 
236
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
221
237
 
222
238
 
223
239
class SmartServerBranchRequestRevisionIdToRevno(SmartServerBranchRequest):
232
248
        try:
233
249
            dotted_revno = branch.revision_id_to_dotted_revno(revid)
234
250
        except errors.NoSuchRevision:
235
 
            return FailedSmartServerResponse((b'NoSuchRevision', revid))
236
 
        except errors.GhostRevisionsHaveNoRevno as e:
237
 
            return FailedSmartServerResponse(
238
 
                (b'GhostRevisionsHaveNoRevno', e.revision_id,
239
 
                    e.ghost_revision_id))
 
251
            return FailedSmartServerResponse(('NoSuchRevision', revid))
240
252
        return SuccessfulSmartServerResponse(
241
 
            (b'ok', ) + tuple([b'%d' % x for x in dotted_revno]))
 
253
            ('ok', ) + tuple(map(str, dotted_revno)))
242
254
 
243
255
 
244
256
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
249
261
    def do_with_locked_branch(self, branch, *args):
250
262
        try:
251
263
            return self.do_tip_change_with_locked_branch(branch, *args)
252
 
        except errors.TipChangeRejected as e:
 
264
        except errors.TipChangeRejected, e:
253
265
            msg = e.msg
254
 
            if isinstance(msg, str):
 
266
            if isinstance(msg, unicode):
255
267
                msg = msg.encode('utf-8')
256
 
            return FailedSmartServerResponse((b'TipChangeRejected', msg))
 
268
            return FailedSmartServerResponse(('TipChangeRejected', msg))
257
269
 
258
270
 
259
271
class SmartServerBranchRequestSetConfigOption(SmartServerLockedBranchRequest):
262
274
    def do_with_locked_branch(self, branch, value, name, section):
263
275
        if not section:
264
276
            section = None
265
 
        branch._get_config().set_option(
266
 
            value.decode('utf-8'), name.decode('utf-8'),
267
 
            section.decode('utf-8') if section is not None else None)
 
277
        branch._get_config().set_option(value.decode('utf8'), name, section)
268
278
        return SuccessfulSmartServerResponse(())
269
279
 
270
280
 
271
281
class SmartServerBranchRequestSetConfigOptionDict(SmartServerLockedBranchRequest):
272
282
    """Set an option in the branch configuration.
273
 
 
 
283
    
274
284
    New in 2.2.
275
285
    """
276
286
 
281
291
            value_dict[key.decode('utf8')] = value.decode('utf8')
282
292
        if not section:
283
293
            section = None
284
 
        else:
285
 
            section = section.decode('utf-8')
286
 
        branch._get_config().set_option(value_dict, name.decode('utf-8'), section)
 
294
        branch._get_config().set_option(value_dict, name, section)
287
295
        return SuccessfulSmartServerResponse(())
288
296
 
289
297
 
290
298
class SmartServerBranchRequestSetLastRevision(SmartServerSetTipRequest):
291
299
 
292
300
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
293
 
        if new_last_revision_id == b'null:':
 
301
        if new_last_revision_id == 'null:':
294
302
            branch.set_last_revision_info(0, new_last_revision_id)
295
303
        else:
296
304
            if not branch.repository.has_revision(new_last_revision_id):
297
305
                return FailedSmartServerResponse(
298
 
                    (b'NoSuchRevision', new_last_revision_id))
 
306
                    ('NoSuchRevision', new_last_revision_id))
299
307
            branch.generate_revision_history(new_last_revision_id, None, None)
300
 
        return SuccessfulSmartServerResponse((b'ok',))
 
308
        return SuccessfulSmartServerResponse(('ok',))
301
309
 
302
310
 
303
311
class SmartServerBranchRequestSetLastRevisionEx(SmartServerSetTipRequest):
304
312
 
305
313
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id,
306
 
                                         allow_divergence, allow_overwrite_descendant):
 
314
            allow_divergence, allow_overwrite_descendant):
307
315
        """Set the last revision of the branch.
308
316
 
309
317
        New in 1.6.
334
342
                relation = branch._revision_relations(
335
343
                    last_rev, new_last_revision_id, graph)
336
344
                if relation == 'diverged' and not allow_divergence:
337
 
                    return FailedSmartServerResponse((b'Diverged',))
 
345
                    return FailedSmartServerResponse(('Diverged',))
338
346
                if relation == 'a_descends_from_b' and do_not_overwrite_descendant:
339
347
                    return SuccessfulSmartServerResponse(
340
 
                        (b'ok', last_revno, last_rev))
 
348
                        ('ok', last_revno, last_rev))
341
349
            new_revno = graph.find_distance_to_null(
342
350
                new_last_revision_id, [(last_rev, last_revno)])
343
351
            branch.set_last_revision_info(new_revno, new_last_revision_id)
344
352
        except errors.GhostRevisionsHaveNoRevno:
345
353
            return FailedSmartServerResponse(
346
 
                (b'NoSuchRevision', new_last_revision_id))
 
354
                ('NoSuchRevision', new_last_revision_id))
347
355
        return SuccessfulSmartServerResponse(
348
 
            (b'ok', new_revno, new_last_revision_id))
 
356
            ('ok', new_revno, new_last_revision_id))
349
357
 
350
358
 
351
359
class SmartServerBranchRequestSetLastRevisionInfo(SmartServerSetTipRequest):
352
360
    """Branch.set_last_revision_info.  Sets the revno and the revision ID of
353
361
    the specified branch.
354
362
 
355
 
    New in breezy 1.4.
 
363
    New in bzrlib 1.4.
356
364
    """
357
365
 
358
366
    def do_tip_change_with_locked_branch(self, branch, new_revno,
359
 
                                         new_last_revision_id):
 
367
            new_last_revision_id):
360
368
        try:
361
369
            branch.set_last_revision_info(int(new_revno), new_last_revision_id)
362
370
        except errors.NoSuchRevision:
363
371
            return FailedSmartServerResponse(
364
 
                (b'NoSuchRevision', new_last_revision_id))
365
 
        return SuccessfulSmartServerResponse((b'ok',))
 
372
                ('NoSuchRevision', new_last_revision_id))
 
373
        return SuccessfulSmartServerResponse(('ok',))
366
374
 
367
375
 
368
376
class SmartServerBranchRequestSetParentLocation(SmartServerLockedBranchRequest):
369
377
    """Set the parent location for a branch.
370
 
 
 
378
    
371
379
    Takes a location to set, which must be utf8 encoded.
372
380
    """
373
381
 
374
382
    def do_with_locked_branch(self, branch, location):
375
 
        branch._set_parent_location(location.decode('utf-8'))
 
383
        branch._set_parent_location(location)
376
384
        return SuccessfulSmartServerResponse(())
377
385
 
378
386
 
379
387
class SmartServerBranchRequestLockWrite(SmartServerBranchRequest):
380
388
 
381
 
    def do_with_branch(self, branch, branch_token=b'', repo_token=b''):
382
 
        if branch_token == b'':
 
389
    def do_with_branch(self, branch, branch_token='', repo_token=''):
 
390
        if branch_token == '':
383
391
            branch_token = None
384
 
        if repo_token == b'':
 
392
        if repo_token == '':
385
393
            repo_token = None
386
394
        try:
387
395
            repo_token = branch.repository.lock_write(
388
396
                token=repo_token).repository_token
389
397
            try:
390
398
                branch_token = branch.lock_write(
391
 
                    token=branch_token).token
 
399
                    token=branch_token).branch_token
392
400
            finally:
393
401
                # this leaves the repository with 1 lock
394
402
                branch.repository.unlock()
395
403
        except errors.LockContention:
396
 
            return FailedSmartServerResponse((b'LockContention',))
 
404
            return FailedSmartServerResponse(('LockContention',))
397
405
        except errors.TokenMismatch:
398
 
            return FailedSmartServerResponse((b'TokenMismatch',))
 
406
            return FailedSmartServerResponse(('TokenMismatch',))
399
407
        except errors.UnlockableTransport:
400
 
            return FailedSmartServerResponse((b'UnlockableTransport',))
401
 
        except errors.LockFailed as e:
402
 
            return FailedSmartServerResponse((b'LockFailed',
403
 
                                              str(e.lock).encode('utf-8'), str(e.why).encode('utf-8')))
 
408
            return FailedSmartServerResponse(('UnlockableTransport',))
 
409
        except errors.LockFailed, e:
 
410
            return FailedSmartServerResponse(('LockFailed', str(e.lock), str(e.why)))
404
411
        if repo_token is None:
405
 
            repo_token = b''
 
412
            repo_token = ''
406
413
        else:
407
414
            branch.repository.leave_lock_in_place()
408
415
        branch.leave_lock_in_place()
409
416
        branch.unlock()
410
 
        return SuccessfulSmartServerResponse((b'ok', branch_token, repo_token))
 
417
        return SuccessfulSmartServerResponse(('ok', branch_token, repo_token))
411
418
 
412
419
 
413
420
class SmartServerBranchRequestUnlock(SmartServerBranchRequest):
414
421
 
415
422
    def do_with_branch(self, branch, branch_token, repo_token):
416
423
        try:
417
 
            with branch.repository.lock_write(token=repo_token):
 
424
            branch.repository.lock_write(token=repo_token)
 
425
            try:
418
426
                branch.lock_write(token=branch_token)
 
427
            finally:
 
428
                branch.repository.unlock()
419
429
        except errors.TokenMismatch:
420
 
            return FailedSmartServerResponse((b'TokenMismatch',))
 
430
            return FailedSmartServerResponse(('TokenMismatch',))
421
431
        if repo_token:
422
432
            branch.repository.dont_leave_lock_in_place()
423
433
        branch.dont_leave_lock_in_place()
424
434
        branch.unlock()
425
 
        return SuccessfulSmartServerResponse((b'ok',))
 
435
        return SuccessfulSmartServerResponse(('ok',))
426
436
 
427
437
 
428
438
class SmartServerBranchRequestGetPhysicalLockStatus(SmartServerBranchRequest):
433
443
 
434
444
    def do_with_branch(self, branch):
435
445
        if branch.get_physical_lock_status():
436
 
            return SuccessfulSmartServerResponse((b'yes',))
 
446
            return SuccessfulSmartServerResponse(('yes',))
437
447
        else:
438
 
            return SuccessfulSmartServerResponse((b'no',))
439
 
 
440
 
 
441
 
class SmartServerBranchRequestGetAllReferenceInfo(SmartServerBranchRequest):
442
 
    """Get the reference information.
443
 
 
444
 
    New in 3.1.
445
 
    """
446
 
 
447
 
    def do_with_branch(self, branch):
448
 
        all_reference_info = branch._get_all_reference_info()
449
 
        content = bencode.bencode([
450
 
            (key, value[0].encode('utf-8'), value[1].encode('utf-8') if value[1] else b'')
451
 
            for (key, value) in all_reference_info.items()])
452
 
        return SuccessfulSmartServerResponse((b'ok', ), content)
 
448
            return SuccessfulSmartServerResponse(('no',))