/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: John Ferlito
  • Date: 2009-09-02 04:31:45 UTC
  • mto: (4665.7.1 serve-init)
  • mto: This revision was merged to the branch mainline in revision 4913.
  • Revision ID: johnf@inodes.org-20090902043145-gxdsfw03ilcwbyn5
Add a debian init script for bzr --serve

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