/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: Andrew Bennetts
  • Date: 2009-10-21 11:13:40 UTC
  • mto: This revision was merged to the branch mainline in revision 4762.
  • Revision ID: andrew.bennetts@canonical.com-20091021111340-w7x4d5yf83qwjncc
Add test that WSGI glue allows request handlers to access paths above that request's. backing transport, so long as it is within the WSGI app's backing transport.

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