/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/request.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/request.py
1
 
# Copyright (C) 2006-2011 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
26
26
      of times during a request).
27
27
"""
28
28
 
29
 
from __future__ import absolute_import
30
 
 
31
29
# XXX: The class names are a little confusing: the protocol will instantiate a
32
30
# SmartServerRequestHandler, whose dispatch_command method creates an instance
33
31
# of a SmartServerRequest subclass.
34
32
 
35
33
 
 
34
import tempfile
 
35
import thread
36
36
import threading
37
37
 
38
 
from ... import (
39
 
    branch as _mod_branch,
 
38
from bzrlib import (
 
39
    bzrdir,
40
40
    debug,
41
41
    errors,
42
42
    osutils,
45
45
    trace,
46
46
    urlutils,
47
47
    )
48
 
from ...lazy_import import lazy_import
 
48
from bzrlib.lazy_import import lazy_import
49
49
lazy_import(globals(), """
50
 
from breezy.bzr import bzrdir
51
 
from breezy.bundle import serializer
52
 
 
53
 
import tempfile
54
 
import thread
 
50
from bzrlib.bundle import serializer
55
51
""")
56
52
 
57
53
 
59
55
jail_info.transports = None
60
56
 
61
57
 
62
 
class DisabledMethod(errors.InternalBzrError):
63
 
 
64
 
    _fmt = "The smart server method '%(class_name)s' is disabled."
65
 
 
66
 
    def __init__(self, class_name):
67
 
        errors.BzrError.__init__(self)
68
 
        self.class_name = class_name
69
 
 
70
 
 
71
58
def _install_hook():
72
59
    bzrdir.BzrDir.hooks.install_named_hook(
73
60
        'pre_open', _pre_open_hook, 'checking server jail')
147
134
        It will return a SmartServerResponse if the command does not expect a
148
135
        body.
149
136
 
150
 
        :param args: the arguments of the request.
 
137
        :param *args: the arguments of the request.
151
138
        """
152
139
        self._check_enabled()
153
140
        return self.do(*args)
159
146
 
160
147
        Must return a SmartServerResponse.
161
148
        """
162
 
        if body_bytes != b'':
 
149
        if body_bytes != '':
163
150
            raise errors.SmartProtocolError('Request does not expect a body')
164
151
 
165
152
    def do_chunk(self, chunk_bytes):
171
158
 
172
159
    def do_end(self):
173
160
        """Called when the end of the request has been received."""
174
 
        body_bytes = b''.join(self._body_chunks)
 
161
        body_bytes = ''.join(self._body_chunks)
175
162
        self._body_chunks = None
176
163
        return self.do_body(body_bytes)
177
164
 
192
179
            (unlike the untranslated client_path, which must not be used with
193
180
            the backing transport).
194
181
        """
195
 
        client_path = client_path.decode('utf-8')
196
182
        if self._root_client_path is None:
197
183
            # no translation necessary!
198
184
            return client_path
217
203
        :returns: a transport cloned from self._backing_transport
218
204
        """
219
205
        relpath = self.translate_client_path(client_path)
220
 
        if not isinstance(relpath, str):
221
 
            raise TypeError(relpath)
222
206
        return self._backing_transport.clone(relpath)
223
207
 
224
208
 
295
279
 
296
280
        :param backing_transport: a Transport to handle requests for.
297
281
        :param commands: a registry mapping command names to SmartServerRequest
298
 
            subclasses. e.g. breezy.transport.smart.vfs.vfs_commands.
 
282
            subclasses. e.g. bzrlib.transport.smart.vfs.vfs_commands.
299
283
        """
300
284
        self._backing_transport = backing_transport
301
285
        self._root_client_path = root_client_path
311
295
            self._thread_id = thread.get_ident()
312
296
 
313
297
    def _trace(self, action, message, extra_bytes=None, include_time=False):
314
 
        # It is a bit of a shame that this functionality overlaps with that of
 
298
        # It is a bit of a shame that this functionality overlaps with that of 
315
299
        # ProtocolThreeRequester._trace. However, there is enough difference
316
300
        # that just putting it in a helper doesn't help a lot. And some state
317
301
        # is taken from the instance.
373
357
                self._command.teardown_jail()
374
358
        except (KeyboardInterrupt, SystemExit):
375
359
            raise
376
 
        except Exception as err:
 
360
        except Exception, err:
377
361
            err_struct = _translate_error(err)
378
362
            return FailedSmartServerResponse(err_struct)
379
363
 
389
373
            command = self._commands.get(cmd)
390
374
        except LookupError:
391
375
            if 'hpss' in debug.debug_flags:
392
 
                self._trace('hpss unknown request',
 
376
                self._trace('hpss unknown request', 
393
377
                            cmd, repr(args)[1:-1])
394
378
            raise errors.UnknownSmartMethod(cmd)
395
379
        if 'hpss' in debug.debug_flags:
396
 
            from . import vfs
 
380
            from bzrlib.smart import vfs
397
381
            if issubclass(command, vfs.VfsRequest):
398
382
                action = 'hpss vfs req'
399
383
            else:
400
384
                action = 'hpss request'
401
 
            self._trace(action, '%s %s' % (cmd, repr(args)[1:-1]))
 
385
            self._trace(action, 
 
386
                        '%s %s' % (cmd, repr(args)[1:-1]))
402
387
        self._command = command(
403
388
            self._backing_transport, self._root_client_path, self._jail_root)
404
389
        self._run_handler_code(self._command.execute, args, {})
418
403
 
419
404
def _translate_error(err):
420
405
    if isinstance(err, errors.NoSuchFile):
421
 
        return (b'NoSuchFile', err.path.encode('utf-8'))
 
406
        return ('NoSuchFile', err.path)
422
407
    elif isinstance(err, errors.FileExists):
423
 
        return (b'FileExists', err.path.encode('utf-8'))
 
408
        return ('FileExists', err.path)
424
409
    elif isinstance(err, errors.DirectoryNotEmpty):
425
 
        return (b'DirectoryNotEmpty', err.path.encode('utf-8'))
 
410
        return ('DirectoryNotEmpty', err.path)
426
411
    elif isinstance(err, errors.IncompatibleRepositories):
427
 
        return (b'IncompatibleRepositories', str(err.source), str(err.target),
 
412
        return ('IncompatibleRepositories', str(err.source), str(err.target),
428
413
            str(err.details))
429
414
    elif isinstance(err, errors.ShortReadvError):
430
 
        return (b'ShortReadvError', err.path.encode('utf-8'),
431
 
                str(err.offset).encode('ascii'),
432
 
                str(err.length).encode('ascii'),
433
 
                str(err.actual).encode('ascii'))
434
 
    elif isinstance(err, errors.RevisionNotPresent):
435
 
        return (b'RevisionNotPresent', err.revision_id, err.file_id)
 
415
        return ('ShortReadvError', err.path, str(err.offset), str(err.length),
 
416
                str(err.actual))
436
417
    elif isinstance(err, errors.UnstackableRepositoryFormat):
437
 
        return ((b'UnstackableRepositoryFormat',
438
 
            str(err.format).encode('utf-8'), err.url.encode('utf-8')))
439
 
    elif isinstance(err, _mod_branch.UnstackableBranchFormat):
440
 
        return (b'UnstackableBranchFormat', str(err.format).encode('utf-8'),
441
 
                err.url.encode('utf-8'))
 
418
        return (('UnstackableRepositoryFormat', str(err.format), err.url))
 
419
    elif isinstance(err, errors.UnstackableBranchFormat):
 
420
        return ('UnstackableBranchFormat', str(err.format), err.url)
442
421
    elif isinstance(err, errors.NotStacked):
443
 
        return (b'NotStacked',)
444
 
    elif isinstance(err, errors.BzrCheckError):
445
 
        return (b'BzrCheckError', err.msg.encode('utf-8'))
 
422
        return ('NotStacked',)
446
423
    elif isinstance(err, UnicodeError):
447
424
        # If it is a DecodeError, than most likely we are starting
448
425
        # with a plain string
459
436
                str(err.end), err.reason)
460
437
    elif isinstance(err, errors.TransportNotPossible):
461
438
        if err.msg == "readonly transport":
462
 
            return (b'ReadOnlyError', )
 
439
            return ('ReadOnlyError', )
463
440
    elif isinstance(err, errors.ReadError):
464
441
        # cannot read the file
465
 
        return (b'ReadError', err.path)
 
442
        return ('ReadError', err.path)
466
443
    elif isinstance(err, errors.PermissionDenied):
467
 
        return (b'PermissionDenied', err.path.encode('utf-8'), err.extra.encode('utf-8'))
 
444
        return ('PermissionDenied', err.path, err.extra)
468
445
    elif isinstance(err, errors.TokenMismatch):
469
 
        return (b'TokenMismatch', err.given_token, err.lock_token)
 
446
        return ('TokenMismatch', err.given_token, err.lock_token)
470
447
    elif isinstance(err, errors.LockContention):
471
 
        return (b'LockContention',)
472
 
    elif isinstance(err, MemoryError):
473
 
        # GZ 2011-02-24: Copy breezy.trace -Dmem_dump functionality here?
474
 
        return (b'MemoryError',)
 
448
        return ('LockContention',)
475
449
    # Unserialisable error.  Log it, and return a generic error
476
450
    trace.log_exception_quietly()
477
 
    return (b'error',
478
 
            trace._qualified_exception_name(err.__class__, True).encode('utf-8'),
479
 
            str(err).encode('utf-8'))
 
451
    return ('error', str(err))
480
452
 
481
453
 
482
454
class HelloRequest(SmartServerRequest):
485
457
    """
486
458
 
487
459
    def do(self):
488
 
        return SuccessfulSmartServerResponse((b'ok', b'2'))
 
460
        return SuccessfulSmartServerResponse(('ok', '2'))
489
461
 
490
462
 
491
463
class GetBundleRequest(SmartServerRequest):
508
480
 
509
481
    def do(self):
510
482
        if self._backing_transport.is_readonly():
511
 
            answer = b'yes'
 
483
            answer = 'yes'
512
484
        else:
513
 
            answer = b'no'
 
485
            answer = 'no'
514
486
        return SuccessfulSmartServerResponse((answer,))
515
487
 
516
488
 
517
 
# In the 'info' attribute, we store whether this request is 'safe' to retry if
518
 
# we get a disconnect while reading the response. It can have the values:
519
 
#   read    This is purely a read request, so retrying it is perfectly ok.
520
 
#   idem    An idempotent write request. Something like 'put' where if you put
521
 
#           the same bytes twice you end up with the same final bytes.
522
 
#   semi    This is a request that isn't strictly idempotent, but doesn't
523
 
#           result in corruption if it is retried. This is for things like
524
 
#           'lock' and 'unlock'. If you call lock, it updates the disk
525
 
#           structure. If you fail to read the response, you won't be able to
526
 
#           use the lock, because you don't have the lock token. Calling lock
527
 
#           again will fail, because the lock is already taken. However, we
528
 
#           can't tell if the server received our request or not. If it didn't,
529
 
#           then retrying the request is fine, as it will actually do what we
530
 
#           want. If it did, we will interrupt the current operation, but we
531
 
#           are no worse off than interrupting the current operation because of
532
 
#           a ConnectionReset.
533
 
#   semivfs Similar to semi, but specific to a Virtual FileSystem request.
534
 
#   stream  This is a request that takes a stream that cannot be restarted if
535
 
#           consumed. This request is 'safe' in that if we determine the
536
 
#           connection is closed before we consume the stream, we can try
537
 
#           again.
538
 
#   mutate  State is updated in a way that replaying that request results in a
539
 
#           different state. For example 'append' writes more bytes to a given
540
 
#           file. If append succeeds, it moves the file pointer.
541
489
request_handlers = registry.Registry()
542
490
request_handlers.register_lazy(
543
 
    b'append', 'breezy.bzr.smart.vfs', 'AppendRequest', info='mutate')
544
 
request_handlers.register_lazy(
545
 
    b'Branch.break_lock', 'breezy.bzr.smart.branch',
546
 
    'SmartServerBranchBreakLock', info='idem')
547
 
request_handlers.register_lazy(
548
 
    b'Branch.get_config_file', 'breezy.bzr.smart.branch',
549
 
    'SmartServerBranchGetConfigFile', info='read')
550
 
request_handlers.register_lazy(
551
 
    b'Branch.get_parent', 'breezy.bzr.smart.branch', 'SmartServerBranchGetParent',
552
 
    info='read')
553
 
request_handlers.register_lazy(
554
 
    b'Branch.put_config_file', 'breezy.bzr.smart.branch',
555
 
    'SmartServerBranchPutConfigFile', info='idem')
556
 
request_handlers.register_lazy(
557
 
    b'Branch.get_tags_bytes', 'breezy.bzr.smart.branch',
558
 
    'SmartServerBranchGetTagsBytes', info='read')
559
 
request_handlers.register_lazy(
560
 
    b'Branch.set_tags_bytes', 'breezy.bzr.smart.branch',
561
 
    'SmartServerBranchSetTagsBytes', info='idem')
562
 
request_handlers.register_lazy(
563
 
    b'Branch.heads_to_fetch', 'breezy.bzr.smart.branch',
564
 
    'SmartServerBranchHeadsToFetch', info='read')
565
 
request_handlers.register_lazy(
566
 
    b'Branch.get_stacked_on_url', 'breezy.bzr.smart.branch',
567
 
    'SmartServerBranchRequestGetStackedOnURL', info='read')
568
 
request_handlers.register_lazy(
569
 
    b'Branch.get_physical_lock_status', 'breezy.bzr.smart.branch',
570
 
    'SmartServerBranchRequestGetPhysicalLockStatus', info='read')
571
 
request_handlers.register_lazy(
572
 
    b'Branch.last_revision_info', 'breezy.bzr.smart.branch',
573
 
    'SmartServerBranchRequestLastRevisionInfo', info='read')
574
 
request_handlers.register_lazy(
575
 
    b'Branch.lock_write', 'breezy.bzr.smart.branch',
576
 
    'SmartServerBranchRequestLockWrite', info='semi')
577
 
request_handlers.register_lazy(
578
 
    b'Branch.revision_history', 'breezy.bzr.smart.branch',
579
 
    'SmartServerRequestRevisionHistory', info='read')
580
 
request_handlers.register_lazy(
581
 
    b'Branch.set_config_option', 'breezy.bzr.smart.branch',
582
 
    'SmartServerBranchRequestSetConfigOption', info='idem')
583
 
request_handlers.register_lazy(
584
 
    b'Branch.set_config_option_dict', 'breezy.bzr.smart.branch',
585
 
    'SmartServerBranchRequestSetConfigOptionDict', info='idem')
586
 
request_handlers.register_lazy(
587
 
    b'Branch.set_last_revision', 'breezy.bzr.smart.branch',
588
 
    'SmartServerBranchRequestSetLastRevision', info='idem')
589
 
request_handlers.register_lazy(
590
 
    b'Branch.set_last_revision_info', 'breezy.bzr.smart.branch',
591
 
    'SmartServerBranchRequestSetLastRevisionInfo', info='idem')
592
 
request_handlers.register_lazy(
593
 
    b'Branch.set_last_revision_ex', 'breezy.bzr.smart.branch',
594
 
    'SmartServerBranchRequestSetLastRevisionEx', info='idem')
595
 
request_handlers.register_lazy(
596
 
    b'Branch.set_parent_location', 'breezy.bzr.smart.branch',
597
 
    'SmartServerBranchRequestSetParentLocation', info='idem')
598
 
request_handlers.register_lazy(
599
 
    b'Branch.unlock', 'breezy.bzr.smart.branch',
600
 
    'SmartServerBranchRequestUnlock', info='semi')
601
 
request_handlers.register_lazy(
602
 
    b'Branch.revision_id_to_revno', 'breezy.bzr.smart.branch',
603
 
    'SmartServerBranchRequestRevisionIdToRevno', info='read')
604
 
request_handlers.register_lazy(
605
 
    b'BzrDir.checkout_metadir', 'breezy.bzr.smart.bzrdir',
606
 
    'SmartServerBzrDirRequestCheckoutMetaDir', info='read')
607
 
request_handlers.register_lazy(
608
 
    b'BzrDir.cloning_metadir', 'breezy.bzr.smart.bzrdir',
609
 
    'SmartServerBzrDirRequestCloningMetaDir', info='read')
610
 
request_handlers.register_lazy(
611
 
    b'BzrDir.create_branch', 'breezy.bzr.smart.bzrdir',
612
 
    'SmartServerRequestCreateBranch', info='semi')
613
 
request_handlers.register_lazy(
614
 
    b'BzrDir.create_repository', 'breezy.bzr.smart.bzrdir',
615
 
    'SmartServerRequestCreateRepository', info='semi')
616
 
request_handlers.register_lazy(
617
 
    b'BzrDir.find_repository', 'breezy.bzr.smart.bzrdir',
618
 
    'SmartServerRequestFindRepositoryV1', info='read')
619
 
request_handlers.register_lazy(
620
 
    b'BzrDir.find_repositoryV2', 'breezy.bzr.smart.bzrdir',
621
 
    'SmartServerRequestFindRepositoryV2', info='read')
622
 
request_handlers.register_lazy(
623
 
    b'BzrDir.find_repositoryV3', 'breezy.bzr.smart.bzrdir',
624
 
    'SmartServerRequestFindRepositoryV3', info='read')
625
 
request_handlers.register_lazy(
626
 
    b'BzrDir.get_branches', 'breezy.bzr.smart.bzrdir',
627
 
    'SmartServerBzrDirRequestGetBranches', info='read')
628
 
request_handlers.register_lazy(
629
 
    b'BzrDir.get_config_file', 'breezy.bzr.smart.bzrdir',
630
 
    'SmartServerBzrDirRequestConfigFile', info='read')
631
 
request_handlers.register_lazy(
632
 
    b'BzrDir.destroy_branch', 'breezy.bzr.smart.bzrdir',
633
 
    'SmartServerBzrDirRequestDestroyBranch', info='semi')
634
 
request_handlers.register_lazy(
635
 
    b'BzrDir.destroy_repository', 'breezy.bzr.smart.bzrdir',
636
 
    'SmartServerBzrDirRequestDestroyRepository', info='semi')
637
 
request_handlers.register_lazy(
638
 
    b'BzrDir.has_workingtree', 'breezy.bzr.smart.bzrdir',
639
 
    'SmartServerBzrDirRequestHasWorkingTree', info='read')
640
 
request_handlers.register_lazy(
641
 
    b'BzrDirFormat.initialize', 'breezy.bzr.smart.bzrdir',
642
 
    'SmartServerRequestInitializeBzrDir', info='semi')
643
 
request_handlers.register_lazy(
644
 
    b'BzrDirFormat.initialize_ex_1.16', 'breezy.bzr.smart.bzrdir',
645
 
    'SmartServerRequestBzrDirInitializeEx', info='semi')
646
 
request_handlers.register_lazy(
647
 
    b'BzrDir.open', 'breezy.bzr.smart.bzrdir', 'SmartServerRequestOpenBzrDir',
648
 
    info='read')
649
 
request_handlers.register_lazy(
650
 
    b'BzrDir.open_2.1', 'breezy.bzr.smart.bzrdir',
651
 
    'SmartServerRequestOpenBzrDir_2_1', info='read')
652
 
request_handlers.register_lazy(
653
 
    b'BzrDir.open_branch', 'breezy.bzr.smart.bzrdir',
654
 
    'SmartServerRequestOpenBranch', info='read')
655
 
request_handlers.register_lazy(
656
 
    b'BzrDir.open_branchV2', 'breezy.bzr.smart.bzrdir',
657
 
    'SmartServerRequestOpenBranchV2', info='read')
658
 
request_handlers.register_lazy(
659
 
    b'BzrDir.open_branchV3', 'breezy.bzr.smart.bzrdir',
660
 
    'SmartServerRequestOpenBranchV3', info='read')
661
 
request_handlers.register_lazy(
662
 
    b'delete', 'breezy.bzr.smart.vfs', 'DeleteRequest', info='semivfs')
663
 
request_handlers.register_lazy(
664
 
    b'get', 'breezy.bzr.smart.vfs', 'GetRequest', info='read')
665
 
request_handlers.register_lazy(
666
 
    b'get_bundle', 'breezy.bzr.smart.request', 'GetBundleRequest', info='read')
667
 
request_handlers.register_lazy(
668
 
    b'has', 'breezy.bzr.smart.vfs', 'HasRequest', info='read')
669
 
request_handlers.register_lazy(
670
 
    b'hello', 'breezy.bzr.smart.request', 'HelloRequest', info='read')
671
 
request_handlers.register_lazy(
672
 
    b'iter_files_recursive', 'breezy.bzr.smart.vfs', 'IterFilesRecursiveRequest',
673
 
    info='read')
674
 
request_handlers.register_lazy(
675
 
    b'list_dir', 'breezy.bzr.smart.vfs', 'ListDirRequest', info='read')
676
 
request_handlers.register_lazy(
677
 
    b'mkdir', 'breezy.bzr.smart.vfs', 'MkdirRequest', info='semivfs')
678
 
request_handlers.register_lazy(
679
 
    b'move', 'breezy.bzr.smart.vfs', 'MoveRequest', info='semivfs')
680
 
request_handlers.register_lazy(
681
 
    b'put', 'breezy.bzr.smart.vfs', 'PutRequest', info='idem')
682
 
request_handlers.register_lazy(
683
 
    b'put_non_atomic', 'breezy.bzr.smart.vfs', 'PutNonAtomicRequest', info='idem')
684
 
request_handlers.register_lazy(
685
 
    b'readv', 'breezy.bzr.smart.vfs', 'ReadvRequest', info='read')
686
 
request_handlers.register_lazy(
687
 
    b'rename', 'breezy.bzr.smart.vfs', 'RenameRequest', info='semivfs')
688
 
request_handlers.register_lazy(
689
 
    b'Repository.add_signature_text', 'breezy.bzr.smart.repository',
690
 
    'SmartServerRepositoryAddSignatureText', info='idem')
691
 
request_handlers.register_lazy(
692
 
    b'Repository.all_revision_ids', 'breezy.bzr.smart.repository',
693
 
    'SmartServerRepositoryAllRevisionIds', info='read')
694
 
request_handlers.register_lazy(
695
 
    b'PackRepository.autopack', 'breezy.bzr.smart.packrepository',
696
 
    'SmartServerPackRepositoryAutopack', info='idem')
697
 
request_handlers.register_lazy(
698
 
    b'Repository.break_lock', 'breezy.bzr.smart.repository',
699
 
    'SmartServerRepositoryBreakLock', info='idem')
700
 
request_handlers.register_lazy(
701
 
    b'Repository.gather_stats', 'breezy.bzr.smart.repository',
702
 
    'SmartServerRepositoryGatherStats', info='read')
703
 
request_handlers.register_lazy(
704
 
    b'Repository.get_parent_map', 'breezy.bzr.smart.repository',
705
 
    'SmartServerRepositoryGetParentMap', info='read')
706
 
request_handlers.register_lazy(
707
 
    b'Repository.get_revision_graph', 'breezy.bzr.smart.repository',
708
 
    'SmartServerRepositoryGetRevisionGraph', info='read')
709
 
request_handlers.register_lazy(
710
 
    b'Repository.get_revision_signature_text', 'breezy.bzr.smart.repository',
711
 
    'SmartServerRepositoryGetRevisionSignatureText', info='read')
712
 
request_handlers.register_lazy(
713
 
    b'Repository.has_revision', 'breezy.bzr.smart.repository',
714
 
    'SmartServerRequestHasRevision', info='read')
715
 
request_handlers.register_lazy(
716
 
    b'Repository.has_signature_for_revision_id', 'breezy.bzr.smart.repository',
717
 
    'SmartServerRequestHasSignatureForRevisionId', info='read')
718
 
request_handlers.register_lazy(
719
 
    b'Repository.insert_stream', 'breezy.bzr.smart.repository',
720
 
    'SmartServerRepositoryInsertStream', info='stream')
721
 
request_handlers.register_lazy(
722
 
    b'Repository.insert_stream_1.19', 'breezy.bzr.smart.repository',
723
 
    'SmartServerRepositoryInsertStream_1_19', info='stream')
724
 
request_handlers.register_lazy(
725
 
    b'Repository.insert_stream_locked', 'breezy.bzr.smart.repository',
726
 
    'SmartServerRepositoryInsertStreamLocked', info='stream')
727
 
request_handlers.register_lazy(
728
 
    b'Repository.is_shared', 'breezy.bzr.smart.repository',
729
 
    'SmartServerRepositoryIsShared', info='read')
730
 
request_handlers.register_lazy(
731
 
    b'Repository.iter_files_bytes', 'breezy.bzr.smart.repository',
732
 
    'SmartServerRepositoryIterFilesBytes', info='read')
733
 
request_handlers.register_lazy(
734
 
    b'Repository.lock_write', 'breezy.bzr.smart.repository',
735
 
    'SmartServerRepositoryLockWrite', info='semi')
736
 
request_handlers.register_lazy(
737
 
    b'Repository.make_working_trees', 'breezy.bzr.smart.repository',
738
 
    'SmartServerRepositoryMakeWorkingTrees', info='read')
739
 
request_handlers.register_lazy(
740
 
    b'Repository.set_make_working_trees', 'breezy.bzr.smart.repository',
741
 
    'SmartServerRepositorySetMakeWorkingTrees', info='idem')
742
 
request_handlers.register_lazy(
743
 
    b'Repository.unlock', 'breezy.bzr.smart.repository',
744
 
    'SmartServerRepositoryUnlock', info='semi')
745
 
request_handlers.register_lazy(
746
 
    b'Repository.get_physical_lock_status', 'breezy.bzr.smart.repository',
747
 
    'SmartServerRepositoryGetPhysicalLockStatus', info='read')
748
 
request_handlers.register_lazy(
749
 
    b'Repository.get_rev_id_for_revno', 'breezy.bzr.smart.repository',
750
 
    'SmartServerRepositoryGetRevIdForRevno', info='read')
751
 
request_handlers.register_lazy(
752
 
    b'Repository.get_stream', 'breezy.bzr.smart.repository',
753
 
    'SmartServerRepositoryGetStream', info='read')
754
 
request_handlers.register_lazy(
755
 
    b'Repository.get_stream_1.19', 'breezy.bzr.smart.repository',
756
 
    'SmartServerRepositoryGetStream_1_19', info='read')
757
 
request_handlers.register_lazy(
758
 
    b'Repository.iter_revisions', 'breezy.bzr.smart.repository',
759
 
    'SmartServerRepositoryIterRevisions', info='read')
760
 
request_handlers.register_lazy(
761
 
    b'Repository.pack', 'breezy.bzr.smart.repository',
762
 
    'SmartServerRepositoryPack', info='idem')
763
 
request_handlers.register_lazy(
764
 
    b'Repository.start_write_group', 'breezy.bzr.smart.repository',
765
 
    'SmartServerRepositoryStartWriteGroup', info='semi')
766
 
request_handlers.register_lazy(
767
 
    b'Repository.commit_write_group', 'breezy.bzr.smart.repository',
768
 
    'SmartServerRepositoryCommitWriteGroup', info='semi')
769
 
request_handlers.register_lazy(
770
 
    b'Repository.abort_write_group', 'breezy.bzr.smart.repository',
771
 
    'SmartServerRepositoryAbortWriteGroup', info='semi')
772
 
request_handlers.register_lazy(
773
 
    b'Repository.check_write_group', 'breezy.bzr.smart.repository',
774
 
    'SmartServerRepositoryCheckWriteGroup', info='read')
775
 
request_handlers.register_lazy(
776
 
    b'Repository.reconcile', 'breezy.bzr.smart.repository',
777
 
    'SmartServerRepositoryReconcile', info='idem')
778
 
request_handlers.register_lazy(
779
 
    b'Repository.tarball', 'breezy.bzr.smart.repository',
780
 
    'SmartServerRepositoryTarball', info='read')
781
 
request_handlers.register_lazy(
782
 
    b'VersionedFileRepository.get_serializer_format', 'breezy.bzr.smart.repository',
783
 
    'SmartServerRepositoryGetSerializerFormat', info='read')
784
 
request_handlers.register_lazy(
785
 
    b'VersionedFileRepository.get_inventories', 'breezy.bzr.smart.repository',
786
 
    'SmartServerRepositoryGetInventories', info='read')
787
 
request_handlers.register_lazy(
788
 
    b'rmdir', 'breezy.bzr.smart.vfs', 'RmdirRequest', info='semivfs')
789
 
request_handlers.register_lazy(
790
 
    b'stat', 'breezy.bzr.smart.vfs', 'StatRequest', info='read')
791
 
request_handlers.register_lazy(
792
 
    b'Transport.is_readonly', 'breezy.bzr.smart.request',
793
 
    'SmartServerIsReadonly', info='read')
 
491
    'append', 'bzrlib.smart.vfs', 'AppendRequest')
 
492
request_handlers.register_lazy(
 
493
    'Branch.get_config_file', 'bzrlib.smart.branch',
 
494
    'SmartServerBranchGetConfigFile')
 
495
request_handlers.register_lazy(
 
496
    'Branch.get_parent', 'bzrlib.smart.branch', 'SmartServerBranchGetParent')
 
497
request_handlers.register_lazy(
 
498
    'Branch.get_tags_bytes', 'bzrlib.smart.branch',
 
499
    'SmartServerBranchGetTagsBytes')
 
500
request_handlers.register_lazy(
 
501
    'Branch.set_tags_bytes', 'bzrlib.smart.branch',
 
502
    'SmartServerBranchSetTagsBytes')
 
503
request_handlers.register_lazy(
 
504
    'Branch.get_stacked_on_url', 'bzrlib.smart.branch', 'SmartServerBranchRequestGetStackedOnURL')
 
505
request_handlers.register_lazy(
 
506
    'Branch.last_revision_info', 'bzrlib.smart.branch', 'SmartServerBranchRequestLastRevisionInfo')
 
507
request_handlers.register_lazy(
 
508
    'Branch.lock_write', 'bzrlib.smart.branch', 'SmartServerBranchRequestLockWrite')
 
509
request_handlers.register_lazy( 'Branch.revision_history',
 
510
    'bzrlib.smart.branch', 'SmartServerRequestRevisionHistory')
 
511
request_handlers.register_lazy( 'Branch.set_config_option',
 
512
    'bzrlib.smart.branch', 'SmartServerBranchRequestSetConfigOption')
 
513
request_handlers.register_lazy( 'Branch.set_last_revision',
 
514
    'bzrlib.smart.branch', 'SmartServerBranchRequestSetLastRevision')
 
515
request_handlers.register_lazy(
 
516
    'Branch.set_last_revision_info', 'bzrlib.smart.branch',
 
517
    'SmartServerBranchRequestSetLastRevisionInfo')
 
518
request_handlers.register_lazy(
 
519
    'Branch.set_last_revision_ex', 'bzrlib.smart.branch',
 
520
    'SmartServerBranchRequestSetLastRevisionEx')
 
521
request_handlers.register_lazy(
 
522
    'Branch.set_parent_location', 'bzrlib.smart.branch',
 
523
    'SmartServerBranchRequestSetParentLocation')
 
524
request_handlers.register_lazy(
 
525
    'Branch.unlock', 'bzrlib.smart.branch', 'SmartServerBranchRequestUnlock')
 
526
request_handlers.register_lazy(
 
527
    'BzrDir.cloning_metadir', 'bzrlib.smart.bzrdir',
 
528
    'SmartServerBzrDirRequestCloningMetaDir')
 
529
request_handlers.register_lazy(
 
530
    'BzrDir.create_branch', 'bzrlib.smart.bzrdir',
 
531
    'SmartServerRequestCreateBranch')
 
532
request_handlers.register_lazy(
 
533
    'BzrDir.create_repository', 'bzrlib.smart.bzrdir',
 
534
    'SmartServerRequestCreateRepository')
 
535
request_handlers.register_lazy(
 
536
    'BzrDir.find_repository', 'bzrlib.smart.bzrdir',
 
537
    'SmartServerRequestFindRepositoryV1')
 
538
request_handlers.register_lazy(
 
539
    'BzrDir.find_repositoryV2', 'bzrlib.smart.bzrdir',
 
540
    'SmartServerRequestFindRepositoryV2')
 
541
request_handlers.register_lazy(
 
542
    'BzrDir.find_repositoryV3', 'bzrlib.smart.bzrdir',
 
543
    'SmartServerRequestFindRepositoryV3')
 
544
request_handlers.register_lazy(
 
545
    'BzrDir.get_config_file', 'bzrlib.smart.bzrdir',
 
546
    'SmartServerBzrDirRequestConfigFile')
 
547
request_handlers.register_lazy(
 
548
    'BzrDirFormat.initialize', 'bzrlib.smart.bzrdir',
 
549
    'SmartServerRequestInitializeBzrDir')
 
550
request_handlers.register_lazy(
 
551
    'BzrDirFormat.initialize_ex_1.16', 'bzrlib.smart.bzrdir',
 
552
    'SmartServerRequestBzrDirInitializeEx')
 
553
request_handlers.register_lazy(
 
554
    'BzrDir.open', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBzrDir')
 
555
request_handlers.register_lazy(
 
556
    'BzrDir.open_2.1', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBzrDir_2_1')
 
557
request_handlers.register_lazy(
 
558
    'BzrDir.open_branch', 'bzrlib.smart.bzrdir',
 
559
    'SmartServerRequestOpenBranch')
 
560
request_handlers.register_lazy(
 
561
    'BzrDir.open_branchV2', 'bzrlib.smart.bzrdir',
 
562
    'SmartServerRequestOpenBranchV2')
 
563
request_handlers.register_lazy(
 
564
    'BzrDir.open_branchV3', 'bzrlib.smart.bzrdir',
 
565
    'SmartServerRequestOpenBranchV3')
 
566
request_handlers.register_lazy(
 
567
    'delete', 'bzrlib.smart.vfs', 'DeleteRequest')
 
568
request_handlers.register_lazy(
 
569
    'get', 'bzrlib.smart.vfs', 'GetRequest')
 
570
request_handlers.register_lazy(
 
571
    'get_bundle', 'bzrlib.smart.request', 'GetBundleRequest')
 
572
request_handlers.register_lazy(
 
573
    'has', 'bzrlib.smart.vfs', 'HasRequest')
 
574
request_handlers.register_lazy(
 
575
    'hello', 'bzrlib.smart.request', 'HelloRequest')
 
576
request_handlers.register_lazy(
 
577
    'iter_files_recursive', 'bzrlib.smart.vfs', 'IterFilesRecursiveRequest')
 
578
request_handlers.register_lazy(
 
579
    'list_dir', 'bzrlib.smart.vfs', 'ListDirRequest')
 
580
request_handlers.register_lazy(
 
581
    'mkdir', 'bzrlib.smart.vfs', 'MkdirRequest')
 
582
request_handlers.register_lazy(
 
583
    'move', 'bzrlib.smart.vfs', 'MoveRequest')
 
584
request_handlers.register_lazy(
 
585
    'put', 'bzrlib.smart.vfs', 'PutRequest')
 
586
request_handlers.register_lazy(
 
587
    'put_non_atomic', 'bzrlib.smart.vfs', 'PutNonAtomicRequest')
 
588
request_handlers.register_lazy(
 
589
    'readv', 'bzrlib.smart.vfs', 'ReadvRequest')
 
590
request_handlers.register_lazy(
 
591
    'rename', 'bzrlib.smart.vfs', 'RenameRequest')
 
592
request_handlers.register_lazy(
 
593
    'PackRepository.autopack', 'bzrlib.smart.packrepository',
 
594
    'SmartServerPackRepositoryAutopack')
 
595
request_handlers.register_lazy('Repository.gather_stats',
 
596
                               'bzrlib.smart.repository',
 
597
                               'SmartServerRepositoryGatherStats')
 
598
request_handlers.register_lazy('Repository.get_parent_map',
 
599
                               'bzrlib.smart.repository',
 
600
                               'SmartServerRepositoryGetParentMap')
 
601
request_handlers.register_lazy(
 
602
    'Repository.get_revision_graph', 'bzrlib.smart.repository', 'SmartServerRepositoryGetRevisionGraph')
 
603
request_handlers.register_lazy(
 
604
    'Repository.has_revision', 'bzrlib.smart.repository', 'SmartServerRequestHasRevision')
 
605
request_handlers.register_lazy(
 
606
    'Repository.insert_stream', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStream')
 
607
request_handlers.register_lazy(
 
608
    'Repository.insert_stream_1.19', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStream_1_19')
 
609
request_handlers.register_lazy(
 
610
    'Repository.insert_stream_locked', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStreamLocked')
 
611
request_handlers.register_lazy(
 
612
    'Repository.is_shared', 'bzrlib.smart.repository', 'SmartServerRepositoryIsShared')
 
613
request_handlers.register_lazy(
 
614
    'Repository.lock_write', 'bzrlib.smart.repository', 'SmartServerRepositoryLockWrite')
 
615
request_handlers.register_lazy(
 
616
    'Repository.set_make_working_trees', 'bzrlib.smart.repository',
 
617
    'SmartServerRepositorySetMakeWorkingTrees')
 
618
request_handlers.register_lazy(
 
619
    'Repository.unlock', 'bzrlib.smart.repository', 'SmartServerRepositoryUnlock')
 
620
request_handlers.register_lazy(
 
621
    'Repository.get_rev_id_for_revno', 'bzrlib.smart.repository',
 
622
    'SmartServerRepositoryGetRevIdForRevno')
 
623
request_handlers.register_lazy(
 
624
    'Repository.get_stream', 'bzrlib.smart.repository',
 
625
    'SmartServerRepositoryGetStream')
 
626
request_handlers.register_lazy(
 
627
    'Repository.get_stream_1.19', 'bzrlib.smart.repository',
 
628
    'SmartServerRepositoryGetStream_1_19')
 
629
request_handlers.register_lazy(
 
630
    'Repository.tarball', 'bzrlib.smart.repository',
 
631
    'SmartServerRepositoryTarball')
 
632
request_handlers.register_lazy(
 
633
    'rmdir', 'bzrlib.smart.vfs', 'RmdirRequest')
 
634
request_handlers.register_lazy(
 
635
    'stat', 'bzrlib.smart.vfs', 'StatRequest')
 
636
request_handlers.register_lazy(
 
637
    'Transport.is_readonly', 'bzrlib.smart.request', 'SmartServerIsReadonly')