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

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2019-01-28 23:51:14 UTC
  • mfrom: (7251.1.1 skip-crypto-deprecation)
  • Revision ID: breezy.the.bot@gmail.com-20190128235114-wurthh67hpldlyip
Ignore UserWarning on travis.

Merged from https://code.launchpad.net/~jelmer/brz/skip-crypto-deprecation/+merge/362227

Show diffs side-by-side

added added

removed removed

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