← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/request.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-10-13 06:08:53 UTC
  • mfrom: (4737.1.1 merge-2.0-into-devel)
  • Revision ID: pqm@pqm.ubuntu.com-20091013060853-erk2aaj80fnkrv25
(andrew) Merge lp:bzr/2.0 into lp:bzr, including fixes for #322807,
        #389413, #402623 and documentation improvements.

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
36
 
38
37
from bzrlib import (
39
 
    debug,
 
38
    bzrdir,
40
39
    errors,
41
 
    osutils,
42
40
    registry,
43
41
    revision,
44
42
    trace,
46
44
    )
47
45
from bzrlib.lazy_import import lazy_import
48
46
lazy_import(globals(), """
49
 
from bzrlib import bzrdir
50
47
from bzrlib.bundle import serializer
51
 
 
52
 
import tempfile
53
 
import thread
54
48
""")
55
49
 
56
50
 
92
86
    # XXX: rename this class to BaseSmartServerRequestHandler ?  A request
93
87
    # *handler* is a different concept to the request.
94
88
 
95
 
    def __init__(self, backing_transport, root_client_path='/', jail_root=None):
 
89
    def __init__(self, backing_transport, root_client_path='/'):
96
90
        """Constructor.
97
91
 
98
92
        :param backing_transport: the base transport to be used when performing
102
96
            from the client.  Clients will not be able to refer to paths above
103
97
            this root.  If root_client_path is None, then no translation will
104
98
            be performed on client paths.  Default is '/'.
105
 
        :param jail_root: if specified, the root of the BzrDir.open jail to use
106
 
            instead of backing_transport.
107
99
        """
108
100
        self._backing_transport = backing_transport
109
 
        if jail_root is None:
110
 
            jail_root = backing_transport
111
 
        self._jail_root = jail_root
112
101
        if root_client_path is not None:
113
102
            if not root_client_path.startswith('/'):
114
103
                root_client_path = '/' + root_client_path
137
126
        It will return a SmartServerResponse if the command does not expect a
138
127
        body.
139
128
 
140
 
        :param args: the arguments of the request.
 
129
        :param *args: the arguments of the request.
141
130
        """
142
131
        self._check_enabled()
143
132
        return self.do(*args)
166
155
        return self.do_body(body_bytes)
167
156
 
168
157
    def setup_jail(self):
169
 
        jail_info.transports = [self._jail_root]
 
158
        jail_info.transports = [self._backing_transport]
170
159
 
171
160
    def teardown_jail(self):
172
161
        jail_info.transports = None
194
183
            relpath = urlutils.joinpath('/', path)
195
184
            if not relpath.startswith('/'):
196
185
                raise ValueError(relpath)
197
 
            return urlutils.escape('.' + relpath)
 
186
            return '.' + relpath
198
187
        else:
199
188
            raise errors.PathNotChild(client_path, self._root_client_path)
200
189
 
276
265
    # TODO: Better way of representing the body for commands that take it,
277
266
    # and allow it to be streamed into the server.
278
267
 
279
 
    def __init__(self, backing_transport, commands, root_client_path,
280
 
        jail_root=None):
 
268
    def __init__(self, backing_transport, commands, root_client_path):
281
269
        """Constructor.
282
270
 
283
271
        :param backing_transport: a Transport to handle requests for.
287
275
        self._backing_transport = backing_transport
288
276
        self._root_client_path = root_client_path
289
277
        self._commands = commands
290
 
        if jail_root is None:
291
 
            jail_root = backing_transport
292
 
        self._jail_root = jail_root
293
278
        self.response = None
294
279
        self.finished_reading = False
295
280
        self._command = None
296
 
        if 'hpss' in debug.debug_flags:
297
 
            self._request_start_time = osutils.timer_func()
298
 
            self._thread_id = thread.get_ident()
299
 
 
300
 
    def _trace(self, action, message, extra_bytes=None, include_time=False):
301
 
        # It is a bit of a shame that this functionality overlaps with that of 
302
 
        # ProtocolThreeRequester._trace. However, there is enough difference
303
 
        # that just putting it in a helper doesn't help a lot. And some state
304
 
        # is taken from the instance.
305
 
        if include_time:
306
 
            t = '%5.3fs ' % (osutils.timer_func() - self._request_start_time)
307
 
        else:
308
 
            t = ''
309
 
        if extra_bytes is None:
310
 
            extra = ''
311
 
        else:
312
 
            extra = ' ' + repr(extra_bytes[:40])
313
 
            if len(extra) > 33:
314
 
                extra = extra[:29] + extra[-1] + '...'
315
 
        trace.mutter('%12s: [%s] %s%s%s'
316
 
                     % (action, self._thread_id, t, message, extra))
317
281
 
318
282
    def accept_body(self, bytes):
319
283
        """Accept body data."""
321
285
            # no active command object, so ignore the event.
322
286
            return
323
287
        self._run_handler_code(self._command.do_chunk, (bytes,), {})
324
 
        if 'hpss' in debug.debug_flags:
325
 
            self._trace('accept body',
326
 
                        '%d bytes' % (len(bytes),), bytes)
327
288
 
328
289
    def end_of_body(self):
329
290
        """No more body data will be received."""
330
291
        self._run_handler_code(self._command.do_end, (), {})
331
292
        # cannot read after this.
332
293
        self.finished_reading = True
333
 
        if 'hpss' in debug.debug_flags:
334
 
            self._trace('end of body', '', include_time=True)
335
294
 
336
295
    def _run_handler_code(self, callable, args, kwargs):
337
296
        """Run some handler specific code 'callable'.
366
325
 
367
326
    def headers_received(self, headers):
368
327
        # Just a no-op at the moment.
369
 
        if 'hpss' in debug.debug_flags:
370
 
            self._trace('headers', repr(headers))
 
328
        pass
371
329
 
372
330
    def args_received(self, args):
373
331
        cmd = args[0]
375
333
        try:
376
334
            command = self._commands.get(cmd)
377
335
        except LookupError:
378
 
            if 'hpss' in debug.debug_flags:
379
 
                self._trace('hpss unknown request', 
380
 
                            cmd, repr(args)[1:-1])
381
336
            raise errors.UnknownSmartMethod(cmd)
382
 
        if 'hpss' in debug.debug_flags:
383
 
            from bzrlib.smart import vfs
384
 
            if issubclass(command, vfs.VfsRequest):
385
 
                action = 'hpss vfs req'
386
 
            else:
387
 
                action = 'hpss request'
388
 
            self._trace(action, 
389
 
                        '%s %s' % (cmd, repr(args)[1:-1]))
390
337
        self._command = command(
391
 
            self._backing_transport, self._root_client_path, self._jail_root)
 
338
            self._backing_transport, self._root_client_path)
392
339
        self._run_handler_code(self._command.execute, args, {})
393
340
 
394
341
    def end_received(self):
396
343
            # no active command object, so ignore the event.
397
344
            return
398
345
        self._run_handler_code(self._command.do_end, (), {})
399
 
        if 'hpss' in debug.debug_flags:
400
 
            self._trace('end', '', include_time=True)
401
346
 
402
347
    def post_body_error_received(self, error_args):
403
348
        # Just a no-op at the moment.
417
362
    elif isinstance(err, errors.ShortReadvError):
418
363
        return ('ShortReadvError', err.path, str(err.offset), str(err.length),
419
364
                str(err.actual))
420
 
    elif isinstance(err, errors.RevisionNotPresent):
421
 
        return ('RevisionNotPresent', err.revision_id, err.file_id)
422
365
    elif isinstance(err, errors.UnstackableRepositoryFormat):
423
366
        return (('UnstackableRepositoryFormat', str(err.format), err.url))
424
367
    elif isinstance(err, errors.UnstackableBranchFormat):
425
368
        return ('UnstackableBranchFormat', str(err.format), err.url)
426
369
    elif isinstance(err, errors.NotStacked):
427
370
        return ('NotStacked',)
428
 
    elif isinstance(err, errors.BzrCheckError):
429
 
        return ('BzrCheckError', err.msg)
430
371
    elif isinstance(err, UnicodeError):
431
372
        # If it is a DecodeError, than most likely we are starting
432
373
        # with a plain string
453
394
        return ('TokenMismatch', err.given_token, err.lock_token)
454
395
    elif isinstance(err, errors.LockContention):
455
396
        return ('LockContention',)
456
 
    elif isinstance(err, MemoryError):
457
 
        # GZ 2011-02-24: Copy bzrlib.trace -Dmem_dump functionality here?
458
 
        return ('MemoryError',)
459
397
    # Unserialisable error.  Log it, and return a generic error
460
398
    trace.log_exception_quietly()
461
 
    return ('error', trace._qualified_exception_name(err.__class__, True),
462
 
        str(err))
 
399
    return ('error', str(err))
463
400
 
464
401
 
465
402
class HelloRequest(SmartServerRequest):
497
434
        return SuccessfulSmartServerResponse((answer,))
498
435
 
499
436
 
500
 
# In the 'info' attribute, we store whether this request is 'safe' to retry if
501
 
# we get a disconnect while reading the response. It can have the values:
502
 
#   read    This is purely a read request, so retrying it is perfectly ok.
503
 
#   idem    An idempotent write request. Something like 'put' where if you put
504
 
#           the same bytes twice you end up with the same final bytes.
505
 
#   semi    This is a request that isn't strictly idempotent, but doesn't
506
 
#           result in corruption if it is retried. This is for things like
507
 
#           'lock' and 'unlock'. If you call lock, it updates the disk
508
 
#           structure. If you fail to read the response, you won't be able to
509
 
#           use the lock, because you don't have the lock token. Calling lock
510
 
#           again will fail, because the lock is already taken. However, we
511
 
#           can't tell if the server received our request or not. If it didn't,
512
 
#           then retrying the request is fine, as it will actually do what we
513
 
#           want. If it did, we will interrupt the current operation, but we
514
 
#           are no worse off than interrupting the current operation because of
515
 
#           a ConnectionReset.
516
 
#   semivfs Similar to semi, but specific to a Virtual FileSystem request.
517
 
#   stream  This is a request that takes a stream that cannot be restarted if
518
 
#           consumed. This request is 'safe' in that if we determine the
519
 
#           connection is closed before we consume the stream, we can try
520
 
#           again.
521
 
#   mutate  State is updated in a way that replaying that request results in a
522
 
#           different state. For example 'append' writes more bytes to a given
523
 
#           file. If append succeeds, it moves the file pointer.
524
437
request_handlers = registry.Registry()
525
438
request_handlers.register_lazy(
526
 
    'append', 'bzrlib.smart.vfs', 'AppendRequest', info='mutate')
527
 
request_handlers.register_lazy(
528
 
    'Branch.break_lock', 'bzrlib.smart.branch',
529
 
    'SmartServerBranchBreakLock', info='idem')
 
439
    'append', 'bzrlib.smart.vfs', 'AppendRequest')
530
440
request_handlers.register_lazy(
531
441
    'Branch.get_config_file', 'bzrlib.smart.branch',
532
 
    'SmartServerBranchGetConfigFile', info='read')
533
 
request_handlers.register_lazy(
534
 
    'Branch.get_parent', 'bzrlib.smart.branch', 'SmartServerBranchGetParent',
535
 
    info='read')
536
 
request_handlers.register_lazy(
537
 
    'Branch.put_config_file', 'bzrlib.smart.branch',
538
 
    'SmartServerBranchPutConfigFile', info='idem')
 
442
    'SmartServerBranchGetConfigFile')
 
443
request_handlers.register_lazy(
 
444
    'Branch.get_parent', 'bzrlib.smart.branch', 'SmartServerBranchGetParent')
539
445
request_handlers.register_lazy(
540
446
    'Branch.get_tags_bytes', 'bzrlib.smart.branch',
541
 
    'SmartServerBranchGetTagsBytes', info='read')
 
447
    'SmartServerBranchGetTagsBytes')
542
448
request_handlers.register_lazy(
543
449
    'Branch.set_tags_bytes', 'bzrlib.smart.branch',
544
 
    'SmartServerBranchSetTagsBytes', info='idem')
545
 
request_handlers.register_lazy(
546
 
    'Branch.heads_to_fetch', 'bzrlib.smart.branch',
547
 
    'SmartServerBranchHeadsToFetch', info='read')
548
 
request_handlers.register_lazy(
549
 
    'Branch.get_stacked_on_url', 'bzrlib.smart.branch',
550
 
    'SmartServerBranchRequestGetStackedOnURL', info='read')
551
 
request_handlers.register_lazy(
552
 
    'Branch.get_physical_lock_status', 'bzrlib.smart.branch',
553
 
    'SmartServerBranchRequestGetPhysicalLockStatus', info='read')
554
 
request_handlers.register_lazy(
555
 
    'Branch.last_revision_info', 'bzrlib.smart.branch',
556
 
    'SmartServerBranchRequestLastRevisionInfo', info='read')
557
 
request_handlers.register_lazy(
558
 
    'Branch.lock_write', 'bzrlib.smart.branch',
559
 
    'SmartServerBranchRequestLockWrite', info='semi')
560
 
request_handlers.register_lazy(
561
 
    'Branch.revision_history', 'bzrlib.smart.branch',
562
 
    'SmartServerRequestRevisionHistory', info='read')
563
 
request_handlers.register_lazy(
564
 
    'Branch.set_config_option', 'bzrlib.smart.branch',
565
 
    'SmartServerBranchRequestSetConfigOption', info='idem')
566
 
request_handlers.register_lazy(
567
 
    'Branch.set_config_option_dict', 'bzrlib.smart.branch',
568
 
    'SmartServerBranchRequestSetConfigOptionDict', info='idem')
569
 
request_handlers.register_lazy(
570
 
    'Branch.set_last_revision', 'bzrlib.smart.branch',
571
 
    'SmartServerBranchRequestSetLastRevision', info='idem')
 
450
    'SmartServerBranchSetTagsBytes')
 
451
request_handlers.register_lazy(
 
452
    'Branch.get_stacked_on_url', 'bzrlib.smart.branch', 'SmartServerBranchRequestGetStackedOnURL')
 
453
request_handlers.register_lazy(
 
454
    'Branch.last_revision_info', 'bzrlib.smart.branch', 'SmartServerBranchRequestLastRevisionInfo')
 
455
request_handlers.register_lazy(
 
456
    'Branch.lock_write', 'bzrlib.smart.branch', 'SmartServerBranchRequestLockWrite')
 
457
request_handlers.register_lazy( 'Branch.revision_history',
 
458
    'bzrlib.smart.branch', 'SmartServerRequestRevisionHistory')
 
459
request_handlers.register_lazy( 'Branch.set_config_option',
 
460
    'bzrlib.smart.branch', 'SmartServerBranchRequestSetConfigOption')
 
461
request_handlers.register_lazy( 'Branch.set_last_revision',
 
462
    'bzrlib.smart.branch', 'SmartServerBranchRequestSetLastRevision')
572
463
request_handlers.register_lazy(
573
464
    'Branch.set_last_revision_info', 'bzrlib.smart.branch',
574
 
    'SmartServerBranchRequestSetLastRevisionInfo', info='idem')
 
465
    'SmartServerBranchRequestSetLastRevisionInfo')
575
466
request_handlers.register_lazy(
576
467
    'Branch.set_last_revision_ex', 'bzrlib.smart.branch',
577
 
    'SmartServerBranchRequestSetLastRevisionEx', info='idem')
 
468
    'SmartServerBranchRequestSetLastRevisionEx')
578
469
request_handlers.register_lazy(
579
470
    'Branch.set_parent_location', 'bzrlib.smart.branch',
580
 
    'SmartServerBranchRequestSetParentLocation', info='idem')
581
 
request_handlers.register_lazy(
582
 
    'Branch.unlock', 'bzrlib.smart.branch',
583
 
    'SmartServerBranchRequestUnlock', info='semi')
584
 
request_handlers.register_lazy(
585
 
    'Branch.revision_id_to_revno', 'bzrlib.smart.branch',
586
 
    'SmartServerBranchRequestRevisionIdToRevno', info='read')
587
 
request_handlers.register_lazy(
588
 
    'BzrDir.checkout_metadir', 'bzrlib.smart.bzrdir',
589
 
    'SmartServerBzrDirRequestCheckoutMetaDir', info='read')
 
471
    'SmartServerBranchRequestSetParentLocation')
 
472
request_handlers.register_lazy(
 
473
    'Branch.unlock', 'bzrlib.smart.branch', 'SmartServerBranchRequestUnlock')
590
474
request_handlers.register_lazy(
591
475
    'BzrDir.cloning_metadir', 'bzrlib.smart.bzrdir',
592
 
    'SmartServerBzrDirRequestCloningMetaDir', info='read')
 
476
    'SmartServerBzrDirRequestCloningMetaDir')
593
477
request_handlers.register_lazy(
594
478
    'BzrDir.create_branch', 'bzrlib.smart.bzrdir',
595
 
    'SmartServerRequestCreateBranch', info='semi')
 
479
    'SmartServerRequestCreateBranch')
596
480
request_handlers.register_lazy(
597
481
    'BzrDir.create_repository', 'bzrlib.smart.bzrdir',
598
 
    'SmartServerRequestCreateRepository', info='semi')
 
482
    'SmartServerRequestCreateRepository')
599
483
request_handlers.register_lazy(
600
484
    'BzrDir.find_repository', 'bzrlib.smart.bzrdir',
601
 
    'SmartServerRequestFindRepositoryV1', info='read')
 
485
    'SmartServerRequestFindRepositoryV1')
602
486
request_handlers.register_lazy(
603
487
    'BzrDir.find_repositoryV2', 'bzrlib.smart.bzrdir',
604
 
    'SmartServerRequestFindRepositoryV2', info='read')
 
488
    'SmartServerRequestFindRepositoryV2')
605
489
request_handlers.register_lazy(
606
490
    'BzrDir.find_repositoryV3', 'bzrlib.smart.bzrdir',
607
 
    'SmartServerRequestFindRepositoryV3', info='read')
608
 
request_handlers.register_lazy(
609
 
    'BzrDir.get_branches', 'bzrlib.smart.bzrdir',
610
 
    'SmartServerBzrDirRequestGetBranches', info='read')
 
491
    'SmartServerRequestFindRepositoryV3')
611
492
request_handlers.register_lazy(
612
493
    'BzrDir.get_config_file', 'bzrlib.smart.bzrdir',
613
 
    'SmartServerBzrDirRequestConfigFile', info='read')
614
 
request_handlers.register_lazy(
615
 
    'BzrDir.destroy_branch', 'bzrlib.smart.bzrdir',
616
 
    'SmartServerBzrDirRequestDestroyBranch', info='semi')
617
 
request_handlers.register_lazy(
618
 
    'BzrDir.destroy_repository', 'bzrlib.smart.bzrdir',
619
 
    'SmartServerBzrDirRequestDestroyRepository', info='semi')
620
 
request_handlers.register_lazy(
621
 
    'BzrDir.has_workingtree', 'bzrlib.smart.bzrdir',
622
 
    'SmartServerBzrDirRequestHasWorkingTree', info='read')
 
494
    'SmartServerBzrDirRequestConfigFile')
623
495
request_handlers.register_lazy(
624
496
    'BzrDirFormat.initialize', 'bzrlib.smart.bzrdir',
625
 
    'SmartServerRequestInitializeBzrDir', info='semi')
 
497
    'SmartServerRequestInitializeBzrDir')
626
498
request_handlers.register_lazy(
627
499
    'BzrDirFormat.initialize_ex_1.16', 'bzrlib.smart.bzrdir',
628
 
    'SmartServerRequestBzrDirInitializeEx', info='semi')
629
 
request_handlers.register_lazy(
630
 
    'BzrDir.open', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBzrDir',
631
 
    info='read')
632
 
request_handlers.register_lazy(
633
 
    'BzrDir.open_2.1', 'bzrlib.smart.bzrdir',
634
 
    'SmartServerRequestOpenBzrDir_2_1', info='read')
 
500
    'SmartServerRequestBzrDirInitializeEx')
 
501
request_handlers.register_lazy(
 
502
    'BzrDir.open', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBzrDir')
 
503
request_handlers.register_lazy(
 
504
    'BzrDir.open_2.1', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBzrDir_2_1')
635
505
request_handlers.register_lazy(
636
506
    'BzrDir.open_branch', 'bzrlib.smart.bzrdir',
637
 
    'SmartServerRequestOpenBranch', info='read')
 
507
    'SmartServerRequestOpenBranch')
638
508
request_handlers.register_lazy(
639
509
    'BzrDir.open_branchV2', 'bzrlib.smart.bzrdir',
640
 
    'SmartServerRequestOpenBranchV2', info='read')
641
 
request_handlers.register_lazy(
642
 
    'BzrDir.open_branchV3', 'bzrlib.smart.bzrdir',
643
 
    'SmartServerRequestOpenBranchV3', info='read')
644
 
request_handlers.register_lazy(
645
 
    'delete', 'bzrlib.smart.vfs', 'DeleteRequest', info='semivfs')
646
 
request_handlers.register_lazy(
647
 
    'get', 'bzrlib.smart.vfs', 'GetRequest', info='read')
648
 
request_handlers.register_lazy(
649
 
    'get_bundle', 'bzrlib.smart.request', 'GetBundleRequest', info='read')
650
 
request_handlers.register_lazy(
651
 
    'has', 'bzrlib.smart.vfs', 'HasRequest', info='read')
652
 
request_handlers.register_lazy(
653
 
    'hello', 'bzrlib.smart.request', 'HelloRequest', info='read')
654
 
request_handlers.register_lazy(
655
 
    'iter_files_recursive', 'bzrlib.smart.vfs', 'IterFilesRecursiveRequest',
656
 
    info='read')
657
 
request_handlers.register_lazy(
658
 
    'list_dir', 'bzrlib.smart.vfs', 'ListDirRequest', info='read')
659
 
request_handlers.register_lazy(
660
 
    'mkdir', 'bzrlib.smart.vfs', 'MkdirRequest', info='semivfs')
661
 
request_handlers.register_lazy(
662
 
    'move', 'bzrlib.smart.vfs', 'MoveRequest', info='semivfs')
663
 
request_handlers.register_lazy(
664
 
    'put', 'bzrlib.smart.vfs', 'PutRequest', info='idem')
665
 
request_handlers.register_lazy(
666
 
    'put_non_atomic', 'bzrlib.smart.vfs', 'PutNonAtomicRequest', info='idem')
667
 
request_handlers.register_lazy(
668
 
    'readv', 'bzrlib.smart.vfs', 'ReadvRequest', info='read')
669
 
request_handlers.register_lazy(
670
 
    'rename', 'bzrlib.smart.vfs', 'RenameRequest', info='semivfs')
671
 
request_handlers.register_lazy(
672
 
    'Repository.add_signature_text', 'bzrlib.smart.repository',
673
 
    'SmartServerRepositoryAddSignatureText', info='idem')
674
 
request_handlers.register_lazy(
675
 
    'Repository.all_revision_ids', 'bzrlib.smart.repository',
676
 
    'SmartServerRepositoryAllRevisionIds', info='read')
 
510
    'SmartServerRequestOpenBranchV2')
 
511
request_handlers.register_lazy(
 
512
    'delete', 'bzrlib.smart.vfs', 'DeleteRequest')
 
513
request_handlers.register_lazy(
 
514
    'get', 'bzrlib.smart.vfs', 'GetRequest')
 
515
request_handlers.register_lazy(
 
516
    'get_bundle', 'bzrlib.smart.request', 'GetBundleRequest')
 
517
request_handlers.register_lazy(
 
518
    'has', 'bzrlib.smart.vfs', 'HasRequest')
 
519
request_handlers.register_lazy(
 
520
    'hello', 'bzrlib.smart.request', 'HelloRequest')
 
521
request_handlers.register_lazy(
 
522
    'iter_files_recursive', 'bzrlib.smart.vfs', 'IterFilesRecursiveRequest')
 
523
request_handlers.register_lazy(
 
524
    'list_dir', 'bzrlib.smart.vfs', 'ListDirRequest')
 
525
request_handlers.register_lazy(
 
526
    'mkdir', 'bzrlib.smart.vfs', 'MkdirRequest')
 
527
request_handlers.register_lazy(
 
528
    'move', 'bzrlib.smart.vfs', 'MoveRequest')
 
529
request_handlers.register_lazy(
 
530
    'put', 'bzrlib.smart.vfs', 'PutRequest')
 
531
request_handlers.register_lazy(
 
532
    'put_non_atomic', 'bzrlib.smart.vfs', 'PutNonAtomicRequest')
 
533
request_handlers.register_lazy(
 
534
    'readv', 'bzrlib.smart.vfs', 'ReadvRequest')
 
535
request_handlers.register_lazy(
 
536
    'rename', 'bzrlib.smart.vfs', 'RenameRequest')
677
537
request_handlers.register_lazy(
678
538
    'PackRepository.autopack', 'bzrlib.smart.packrepository',
679
 
    'SmartServerPackRepositoryAutopack', info='idem')
680
 
request_handlers.register_lazy(
681
 
    'Repository.break_lock', 'bzrlib.smart.repository',
682
 
    'SmartServerRepositoryBreakLock', info='idem')
683
 
request_handlers.register_lazy(
684
 
    'Repository.gather_stats', 'bzrlib.smart.repository',
685
 
    'SmartServerRepositoryGatherStats', info='read')
686
 
request_handlers.register_lazy(
687
 
    'Repository.get_parent_map', 'bzrlib.smart.repository',
688
 
    'SmartServerRepositoryGetParentMap', info='read')
689
 
request_handlers.register_lazy(
690
 
    'Repository.get_revision_graph', 'bzrlib.smart.repository',
691
 
    'SmartServerRepositoryGetRevisionGraph', info='read')
692
 
request_handlers.register_lazy(
693
 
    'Repository.get_revision_signature_text', 'bzrlib.smart.repository',
694
 
    'SmartServerRepositoryGetRevisionSignatureText', info='read')
695
 
request_handlers.register_lazy(
696
 
    'Repository.has_revision', 'bzrlib.smart.repository',
697
 
    'SmartServerRequestHasRevision', info='read')
698
 
request_handlers.register_lazy(
699
 
    'Repository.has_signature_for_revision_id', 'bzrlib.smart.repository',
700
 
    'SmartServerRequestHasSignatureForRevisionId', info='read')
701
 
request_handlers.register_lazy(
702
 
    'Repository.insert_stream', 'bzrlib.smart.repository',
703
 
    'SmartServerRepositoryInsertStream', info='stream')
704
 
request_handlers.register_lazy(
705
 
    'Repository.insert_stream_1.19', 'bzrlib.smart.repository',
706
 
    'SmartServerRepositoryInsertStream_1_19', info='stream')
707
 
request_handlers.register_lazy(
708
 
    'Repository.insert_stream_locked', 'bzrlib.smart.repository',
709
 
    'SmartServerRepositoryInsertStreamLocked', info='stream')
710
 
request_handlers.register_lazy(
711
 
    'Repository.is_shared', 'bzrlib.smart.repository',
712
 
    'SmartServerRepositoryIsShared', info='read')
713
 
request_handlers.register_lazy(
714
 
    'Repository.iter_files_bytes', 'bzrlib.smart.repository',
715
 
    'SmartServerRepositoryIterFilesBytes', info='read')
716
 
request_handlers.register_lazy(
717
 
    'Repository.lock_write', 'bzrlib.smart.repository',
718
 
    'SmartServerRepositoryLockWrite', info='semi')
719
 
request_handlers.register_lazy(
720
 
    'Repository.make_working_trees', 'bzrlib.smart.repository',
721
 
    'SmartServerRepositoryMakeWorkingTrees', info='read')
 
539
    'SmartServerPackRepositoryAutopack')
 
540
request_handlers.register_lazy('Repository.gather_stats',
 
541
                               'bzrlib.smart.repository',
 
542
                               'SmartServerRepositoryGatherStats')
 
543
request_handlers.register_lazy('Repository.get_parent_map',
 
544
                               'bzrlib.smart.repository',
 
545
                               'SmartServerRepositoryGetParentMap')
 
546
request_handlers.register_lazy(
 
547
    'Repository.get_revision_graph', 'bzrlib.smart.repository', 'SmartServerRepositoryGetRevisionGraph')
 
548
request_handlers.register_lazy(
 
549
    'Repository.has_revision', 'bzrlib.smart.repository', 'SmartServerRequestHasRevision')
 
550
request_handlers.register_lazy(
 
551
    'Repository.insert_stream', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStream')
 
552
request_handlers.register_lazy(
 
553
    'Repository.insert_stream_1.19', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStream_1_19')
 
554
request_handlers.register_lazy(
 
555
    'Repository.insert_stream_locked', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStreamLocked')
 
556
request_handlers.register_lazy(
 
557
    'Repository.is_shared', 'bzrlib.smart.repository', 'SmartServerRepositoryIsShared')
 
558
request_handlers.register_lazy(
 
559
    'Repository.lock_write', 'bzrlib.smart.repository', 'SmartServerRepositoryLockWrite')
722
560
request_handlers.register_lazy(
723
561
    'Repository.set_make_working_trees', 'bzrlib.smart.repository',
724
 
    'SmartServerRepositorySetMakeWorkingTrees', info='idem')
725
 
request_handlers.register_lazy(
726
 
    'Repository.unlock', 'bzrlib.smart.repository',
727
 
    'SmartServerRepositoryUnlock', info='semi')
728
 
request_handlers.register_lazy(
729
 
    'Repository.get_physical_lock_status', 'bzrlib.smart.repository',
730
 
    'SmartServerRepositoryGetPhysicalLockStatus', info='read')
 
562
    'SmartServerRepositorySetMakeWorkingTrees')
 
563
request_handlers.register_lazy(
 
564
    'Repository.unlock', 'bzrlib.smart.repository', 'SmartServerRepositoryUnlock')
731
565
request_handlers.register_lazy(
732
566
    'Repository.get_rev_id_for_revno', 'bzrlib.smart.repository',
733
 
    'SmartServerRepositoryGetRevIdForRevno', info='read')
 
567
    'SmartServerRepositoryGetRevIdForRevno')
734
568
request_handlers.register_lazy(
735
569
    'Repository.get_stream', 'bzrlib.smart.repository',
736
 
    'SmartServerRepositoryGetStream', info='read')
 
570
    'SmartServerRepositoryGetStream')
737
571
request_handlers.register_lazy(
738
572
    'Repository.get_stream_1.19', 'bzrlib.smart.repository',
739
 
    'SmartServerRepositoryGetStream_1_19', info='read')
740
 
request_handlers.register_lazy(
741
 
    'Repository.iter_revisions', 'bzrlib.smart.repository',
742
 
    'SmartServerRepositoryIterRevisions', info='read')
743
 
request_handlers.register_lazy(
744
 
    'Repository.pack', 'bzrlib.smart.repository',
745
 
    'SmartServerRepositoryPack', info='idem')
746
 
request_handlers.register_lazy(
747
 
    'Repository.start_write_group', 'bzrlib.smart.repository',
748
 
    'SmartServerRepositoryStartWriteGroup', info='semi')
749
 
request_handlers.register_lazy(
750
 
    'Repository.commit_write_group', 'bzrlib.smart.repository',
751
 
    'SmartServerRepositoryCommitWriteGroup', info='semi')
752
 
request_handlers.register_lazy(
753
 
    'Repository.abort_write_group', 'bzrlib.smart.repository',
754
 
    'SmartServerRepositoryAbortWriteGroup', info='semi')
755
 
request_handlers.register_lazy(
756
 
    'Repository.check_write_group', 'bzrlib.smart.repository',
757
 
    'SmartServerRepositoryCheckWriteGroup', info='read')
758
 
request_handlers.register_lazy(
759
 
    'Repository.reconcile', 'bzrlib.smart.repository',
760
 
    'SmartServerRepositoryReconcile', info='idem')
 
573
    'SmartServerRepositoryGetStream_1_19')
761
574
request_handlers.register_lazy(
762
575
    'Repository.tarball', 'bzrlib.smart.repository',
763
 
    'SmartServerRepositoryTarball', info='read')
764
 
request_handlers.register_lazy(
765
 
    'VersionedFileRepository.get_serializer_format', 'bzrlib.smart.repository',
766
 
    'SmartServerRepositoryGetSerializerFormat', info='read')
767
 
request_handlers.register_lazy(
768
 
    'VersionedFileRepository.get_inventories', 'bzrlib.smart.repository',
769
 
    'SmartServerRepositoryGetInventories', info='read')
770
 
request_handlers.register_lazy(
771
 
    'rmdir', 'bzrlib.smart.vfs', 'RmdirRequest', info='semivfs')
772
 
request_handlers.register_lazy(
773
 
    'stat', 'bzrlib.smart.vfs', 'StatRequest', info='read')
774
 
request_handlers.register_lazy(
775
 
    'Transport.is_readonly', 'bzrlib.smart.request',
776
 
    'SmartServerIsReadonly', info='read')
 
576
    'SmartServerRepositoryTarball')
 
577
request_handlers.register_lazy(
 
578
    'rmdir', 'bzrlib.smart.vfs', 'RmdirRequest')
 
579
request_handlers.register_lazy(
 
580
    'stat', 'bzrlib.smart.vfs', 'StatRequest')
 
581
request_handlers.register_lazy(
 
582
    'Transport.is_readonly', 'bzrlib.smart.request', 'SmartServerIsReadonly')