/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, 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Infrastructure for server-side request handlers.
 
18
 
 
19
Interesting module attributes:
 
20
    * The request_handlers registry maps verb names to SmartServerRequest
 
21
      classes.
 
22
    * The jail_info threading.local() object is used to prevent accidental
 
23
      opening of BzrDirs outside of the backing transport, or any other
 
24
      transports placed in jail_info.transports.  The jail_info is reset on
 
25
      every call into a request handler (which can happen an arbitrary number
 
26
      of times during a request).
 
27
"""
 
28
 
 
29
# XXX: The class names are a little confusing: the protocol will instantiate a
 
30
# SmartServerRequestHandler, whose dispatch_command method creates an instance
 
31
# of a SmartServerRequest subclass.
 
32
 
 
33
 
 
34
import tempfile
 
35
import threading
 
36
 
 
37
from bzrlib import (
 
38
    bzrdir,
 
39
    errors,
 
40
    registry,
 
41
    revision,
 
42
    trace,
 
43
    urlutils,
 
44
    )
 
45
from bzrlib.lazy_import import lazy_import
 
46
lazy_import(globals(), """
 
47
from bzrlib.bundle import serializer
 
48
""")
 
49
 
 
50
 
 
51
jail_info = threading.local()
 
52
jail_info.transports = None
 
53
 
 
54
 
 
55
def _install_hook():
 
56
    bzrdir.BzrDir.hooks.install_named_hook(
 
57
        'pre_open', _pre_open_hook, 'checking server jail')
 
58
 
 
59
 
 
60
def _pre_open_hook(transport):
 
61
    allowed_transports = getattr(jail_info, 'transports', None)
 
62
    if allowed_transports is None:
 
63
        return
 
64
    abspath = transport.base
 
65
    for allowed_transport in allowed_transports:
 
66
        try:
 
67
            allowed_transport.relpath(abspath)
 
68
        except errors.PathNotChild:
 
69
            continue
 
70
        else:
 
71
            return
 
72
    raise errors.JailBreak(abspath)
 
73
 
 
74
 
 
75
_install_hook()
 
76
 
 
77
 
 
78
class SmartServerRequest(object):
 
79
    """Base class for request handlers.
 
80
 
 
81
    To define a new request, subclass this class and override the `do` method
 
82
    (and if appropriate, `do_body` as well).  Request implementors should take
 
83
    care to call `translate_client_path` and `transport_from_client_path` as
 
84
    appropriate when dealing with paths received from the client.
 
85
    """
 
86
    # XXX: rename this class to BaseSmartServerRequestHandler ?  A request
 
87
    # *handler* is a different concept to the request.
 
88
 
 
89
    def __init__(self, backing_transport, root_client_path='/', jail_root=None):
 
90
        """Constructor.
 
91
 
 
92
        :param backing_transport: the base transport to be used when performing
 
93
            this request.
 
94
        :param root_client_path: the client path that maps to the root of
 
95
            backing_transport.  This is used to interpret relpaths received
 
96
            from the client.  Clients will not be able to refer to paths above
 
97
            this root.  If root_client_path is None, then no translation will
 
98
            be performed on client paths.  Default is '/'.
 
99
        :param jail_root: if specified, the root of the BzrDir.open jail to use
 
100
            instead of backing_transport.
 
101
        """
 
102
        self._backing_transport = backing_transport
 
103
        if jail_root is None:
 
104
            jail_root = backing_transport
 
105
        self._jail_root = jail_root
 
106
        if root_client_path is not None:
 
107
            if not root_client_path.startswith('/'):
 
108
                root_client_path = '/' + root_client_path
 
109
            if not root_client_path.endswith('/'):
 
110
                root_client_path += '/'
 
111
        self._root_client_path = root_client_path
 
112
        self._body_chunks = []
 
113
 
 
114
    def _check_enabled(self):
 
115
        """Raises DisabledMethod if this method is disabled."""
 
116
        pass
 
117
 
 
118
    def do(self, *args):
 
119
        """Mandatory extension point for SmartServerRequest subclasses.
 
120
 
 
121
        Subclasses must implement this.
 
122
 
 
123
        This should return a SmartServerResponse if this command expects to
 
124
        receive no body.
 
125
        """
 
126
        raise NotImplementedError(self.do)
 
127
 
 
128
    def execute(self, *args):
 
129
        """Public entry point to execute this request.
 
130
 
 
131
        It will return a SmartServerResponse if the command does not expect a
 
132
        body.
 
133
 
 
134
        :param *args: the arguments of the request.
 
135
        """
 
136
        self._check_enabled()
 
137
        return self.do(*args)
 
138
 
 
139
    def do_body(self, body_bytes):
 
140
        """Called if the client sends a body with the request.
 
141
 
 
142
        The do() method is still called, and must have returned None.
 
143
 
 
144
        Must return a SmartServerResponse.
 
145
        """
 
146
        if body_bytes != '':
 
147
            raise errors.SmartProtocolError('Request does not expect a body')
 
148
 
 
149
    def do_chunk(self, chunk_bytes):
 
150
        """Called with each body chunk if the request has a streamed body.
 
151
 
 
152
        The do() method is still called, and must have returned None.
 
153
        """
 
154
        self._body_chunks.append(chunk_bytes)
 
155
 
 
156
    def do_end(self):
 
157
        """Called when the end of the request has been received."""
 
158
        body_bytes = ''.join(self._body_chunks)
 
159
        self._body_chunks = None
 
160
        return self.do_body(body_bytes)
 
161
 
 
162
    def setup_jail(self):
 
163
        jail_info.transports = [self._jail_root]
 
164
 
 
165
    def teardown_jail(self):
 
166
        jail_info.transports = None
 
167
 
 
168
    def translate_client_path(self, client_path):
 
169
        """Translate a path received from a network client into a local
 
170
        relpath.
 
171
 
 
172
        All paths received from the client *must* be translated.
 
173
 
 
174
        :param client_path: the path from the client.
 
175
        :returns: a relpath that may be used with self._backing_transport
 
176
            (unlike the untranslated client_path, which must not be used with
 
177
            the backing transport).
 
178
        """
 
179
        if self._root_client_path is None:
 
180
            # no translation necessary!
 
181
            return client_path
 
182
        if not client_path.startswith('/'):
 
183
            client_path = '/' + client_path
 
184
        if client_path + '/' == self._root_client_path:
 
185
            return '.'
 
186
        if client_path.startswith(self._root_client_path):
 
187
            path = client_path[len(self._root_client_path):]
 
188
            relpath = urlutils.joinpath('/', path)
 
189
            if not relpath.startswith('/'):
 
190
                raise ValueError(relpath)
 
191
            return '.' + relpath
 
192
        else:
 
193
            raise errors.PathNotChild(client_path, self._root_client_path)
 
194
 
 
195
    def transport_from_client_path(self, client_path):
 
196
        """Get a backing transport corresponding to the location referred to by
 
197
        a network client.
 
198
 
 
199
        :seealso: translate_client_path
 
200
        :returns: a transport cloned from self._backing_transport
 
201
        """
 
202
        relpath = self.translate_client_path(client_path)
 
203
        return self._backing_transport.clone(relpath)
 
204
 
 
205
 
 
206
class SmartServerResponse(object):
 
207
    """A response to a client request.
 
208
 
 
209
    This base class should not be used. Instead use
 
210
    SuccessfulSmartServerResponse and FailedSmartServerResponse as appropriate.
 
211
    """
 
212
 
 
213
    def __init__(self, args, body=None, body_stream=None):
 
214
        """Constructor.
 
215
 
 
216
        :param args: tuple of response arguments.
 
217
        :param body: string of a response body.
 
218
        :param body_stream: iterable of bytestrings to be streamed to the
 
219
            client.
 
220
        """
 
221
        self.args = args
 
222
        if body is not None and body_stream is not None:
 
223
            raise errors.BzrError(
 
224
                "'body' and 'body_stream' are mutually exclusive.")
 
225
        self.body = body
 
226
        self.body_stream = body_stream
 
227
 
 
228
    def __eq__(self, other):
 
229
        if other is None:
 
230
            return False
 
231
        return (other.args == self.args and
 
232
                other.body == self.body and
 
233
                other.body_stream is self.body_stream)
 
234
 
 
235
    def __repr__(self):
 
236
        return "<%s args=%r body=%r>" % (self.__class__.__name__,
 
237
            self.args, self.body)
 
238
 
 
239
 
 
240
class FailedSmartServerResponse(SmartServerResponse):
 
241
    """A SmartServerResponse for a request which failed."""
 
242
 
 
243
    def is_successful(self):
 
244
        """FailedSmartServerResponse are not successful."""
 
245
        return False
 
246
 
 
247
 
 
248
class SuccessfulSmartServerResponse(SmartServerResponse):
 
249
    """A SmartServerResponse for a successfully completed request."""
 
250
 
 
251
    def is_successful(self):
 
252
        """SuccessfulSmartServerResponse are successful."""
 
253
        return True
 
254
 
 
255
 
 
256
class SmartServerRequestHandler(object):
 
257
    """Protocol logic for smart server.
 
258
 
 
259
    This doesn't handle serialization at all, it just processes requests and
 
260
    creates responses.
 
261
    """
 
262
 
 
263
    # IMPORTANT FOR IMPLEMENTORS: It is important that SmartServerRequestHandler
 
264
    # not contain encoding or decoding logic to allow the wire protocol to vary
 
265
    # from the object protocol: we will want to tweak the wire protocol separate
 
266
    # from the object model, and ideally we will be able to do that without
 
267
    # having a SmartServerRequestHandler subclass for each wire protocol, rather
 
268
    # just a Protocol subclass.
 
269
 
 
270
    # TODO: Better way of representing the body for commands that take it,
 
271
    # and allow it to be streamed into the server.
 
272
 
 
273
    def __init__(self, backing_transport, commands, root_client_path,
 
274
        jail_root):
 
275
        """Constructor.
 
276
 
 
277
        :param backing_transport: a Transport to handle requests for.
 
278
        :param commands: a registry mapping command names to SmartServerRequest
 
279
            subclasses. e.g. bzrlib.transport.smart.vfs.vfs_commands.
 
280
        """
 
281
        self._backing_transport = backing_transport
 
282
        self._root_client_path = root_client_path
 
283
        self._commands = commands
 
284
        self._jail_root = jail_root
 
285
        self.response = None
 
286
        self.finished_reading = False
 
287
        self._command = None
 
288
 
 
289
    def accept_body(self, bytes):
 
290
        """Accept body data."""
 
291
        if self._command is None:
 
292
            # no active command object, so ignore the event.
 
293
            return
 
294
        self._run_handler_code(self._command.do_chunk, (bytes,), {})
 
295
 
 
296
    def end_of_body(self):
 
297
        """No more body data will be received."""
 
298
        self._run_handler_code(self._command.do_end, (), {})
 
299
        # cannot read after this.
 
300
        self.finished_reading = True
 
301
 
 
302
    def _run_handler_code(self, callable, args, kwargs):
 
303
        """Run some handler specific code 'callable'.
 
304
 
 
305
        If a result is returned, it is considered to be the commands response,
 
306
        and finished_reading is set true, and its assigned to self.response.
 
307
 
 
308
        Any exceptions caught are translated and a response object created
 
309
        from them.
 
310
        """
 
311
        result = self._call_converting_errors(callable, args, kwargs)
 
312
 
 
313
        if result is not None:
 
314
            self.response = result
 
315
            self.finished_reading = True
 
316
 
 
317
    def _call_converting_errors(self, callable, args, kwargs):
 
318
        """Call callable converting errors to Response objects."""
 
319
        # XXX: most of this error conversion is VFS-related, and thus ought to
 
320
        # be in SmartServerVFSRequestHandler somewhere.
 
321
        try:
 
322
            self._command.setup_jail()
 
323
            try:
 
324
                return callable(*args, **kwargs)
 
325
            finally:
 
326
                self._command.teardown_jail()
 
327
        except (KeyboardInterrupt, SystemExit):
 
328
            raise
 
329
        except Exception, err:
 
330
            err_struct = _translate_error(err)
 
331
            return FailedSmartServerResponse(err_struct)
 
332
 
 
333
    def headers_received(self, headers):
 
334
        # Just a no-op at the moment.
 
335
        pass
 
336
 
 
337
    def args_received(self, args):
 
338
        cmd = args[0]
 
339
        args = args[1:]
 
340
        try:
 
341
            command = self._commands.get(cmd)
 
342
        except LookupError:
 
343
            raise errors.UnknownSmartMethod(cmd)
 
344
        self._command = command(
 
345
            self._backing_transport, self._root_client_path, self._jail_root)
 
346
        self._run_handler_code(self._command.execute, args, {})
 
347
 
 
348
    def end_received(self):
 
349
        if self._command is None:
 
350
            # no active command object, so ignore the event.
 
351
            return
 
352
        self._run_handler_code(self._command.do_end, (), {})
 
353
 
 
354
    def post_body_error_received(self, error_args):
 
355
        # Just a no-op at the moment.
 
356
        pass
 
357
 
 
358
 
 
359
def _translate_error(err):
 
360
    if isinstance(err, errors.NoSuchFile):
 
361
        return ('NoSuchFile', err.path)
 
362
    elif isinstance(err, errors.FileExists):
 
363
        return ('FileExists', err.path)
 
364
    elif isinstance(err, errors.DirectoryNotEmpty):
 
365
        return ('DirectoryNotEmpty', err.path)
 
366
    elif isinstance(err, errors.IncompatibleRepositories):
 
367
        return ('IncompatibleRepositories', str(err.source), str(err.target),
 
368
            str(err.details))
 
369
    elif isinstance(err, errors.ShortReadvError):
 
370
        return ('ShortReadvError', err.path, str(err.offset), str(err.length),
 
371
                str(err.actual))
 
372
    elif isinstance(err, errors.UnstackableRepositoryFormat):
 
373
        return (('UnstackableRepositoryFormat', str(err.format), err.url))
 
374
    elif isinstance(err, errors.UnstackableBranchFormat):
 
375
        return ('UnstackableBranchFormat', str(err.format), err.url)
 
376
    elif isinstance(err, errors.NotStacked):
 
377
        return ('NotStacked',)
 
378
    elif isinstance(err, UnicodeError):
 
379
        # If it is a DecodeError, than most likely we are starting
 
380
        # with a plain string
 
381
        str_or_unicode = err.object
 
382
        if isinstance(str_or_unicode, unicode):
 
383
            # XXX: UTF-8 might have \x01 (our protocol v1 and v2 seperator
 
384
            # byte) in it, so this encoding could cause broken responses.
 
385
            # Newer clients use protocol v3, so will be fine.
 
386
            val = 'u:' + str_or_unicode.encode('utf-8')
 
387
        else:
 
388
            val = 's:' + str_or_unicode.encode('base64')
 
389
        # This handles UnicodeEncodeError or UnicodeDecodeError
 
390
        return (err.__class__.__name__, err.encoding, val, str(err.start),
 
391
                str(err.end), err.reason)
 
392
    elif isinstance(err, errors.TransportNotPossible):
 
393
        if err.msg == "readonly transport":
 
394
            return ('ReadOnlyError', )
 
395
    elif isinstance(err, errors.ReadError):
 
396
        # cannot read the file
 
397
        return ('ReadError', err.path)
 
398
    elif isinstance(err, errors.PermissionDenied):
 
399
        return ('PermissionDenied', err.path, err.extra)
 
400
    elif isinstance(err, errors.TokenMismatch):
 
401
        return ('TokenMismatch', err.given_token, err.lock_token)
 
402
    elif isinstance(err, errors.LockContention):
 
403
        return ('LockContention',)
 
404
    # Unserialisable error.  Log it, and return a generic error
 
405
    trace.log_exception_quietly()
 
406
    return ('error', str(err))
 
407
 
 
408
 
 
409
class HelloRequest(SmartServerRequest):
 
410
    """Answer a version request with the highest protocol version this server
 
411
    supports.
 
412
    """
 
413
 
 
414
    def do(self):
 
415
        return SuccessfulSmartServerResponse(('ok', '2'))
 
416
 
 
417
 
 
418
class GetBundleRequest(SmartServerRequest):
 
419
    """Get a bundle of from the null revision to the specified revision."""
 
420
 
 
421
    def do(self, path, revision_id):
 
422
        # open transport relative to our base
 
423
        t = self.transport_from_client_path(path)
 
424
        control, extra_path = bzrdir.BzrDir.open_containing_from_transport(t)
 
425
        repo = control.open_repository()
 
426
        tmpf = tempfile.TemporaryFile()
 
427
        base_revision = revision.NULL_REVISION
 
428
        serializer.write_bundle(repo, revision_id, base_revision, tmpf)
 
429
        tmpf.seek(0)
 
430
        return SuccessfulSmartServerResponse((), tmpf.read())
 
431
 
 
432
 
 
433
class SmartServerIsReadonly(SmartServerRequest):
 
434
    # XXX: this request method belongs somewhere else.
 
435
 
 
436
    def do(self):
 
437
        if self._backing_transport.is_readonly():
 
438
            answer = 'yes'
 
439
        else:
 
440
            answer = 'no'
 
441
        return SuccessfulSmartServerResponse((answer,))
 
442
 
 
443
 
 
444
request_handlers = registry.Registry()
 
445
request_handlers.register_lazy(
 
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')