← 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-02-25 23:12:24 UTC
  • mfrom: (4048.1.2 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090225231224-r2fv2iqcgezje0zt
Make ls aware of views (Eduardo O. Padoan)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/request.py
1
 
# Copyright (C) 2006-2010 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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).
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Basic server-side logic for dealing with requests.
 
18
 
 
19
**XXX**:
 
20
 
 
21
The class names are a little confusing: the protocol will instantiate a
 
22
SmartServerRequestHandler, whose dispatch_command method creates an instance of
 
23
a SmartServerRequest subclass.
 
24
 
 
25
The request_handlers registry tracks SmartServerRequest classes (rather than
 
26
SmartServerRequestHandler).
27
27
"""
28
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
29
import tempfile
35
 
import thread
36
 
import threading
37
30
 
38
31
from bzrlib import (
39
32
    bzrdir,
40
 
    debug,
41
33
    errors,
42
 
    osutils,
43
34
    registry,
44
35
    revision,
45
 
    trace,
46
36
    urlutils,
47
37
    )
48
38
from bzrlib.lazy_import import lazy_import
51
41
""")
52
42
 
53
43
 
54
 
jail_info = threading.local()
55
 
jail_info.transports = None
56
 
 
57
 
 
58
 
def _install_hook():
59
 
    bzrdir.BzrDir.hooks.install_named_hook(
60
 
        'pre_open', _pre_open_hook, 'checking server jail')
61
 
 
62
 
 
63
 
def _pre_open_hook(transport):
64
 
    allowed_transports = getattr(jail_info, 'transports', None)
65
 
    if allowed_transports is None:
66
 
        return
67
 
    abspath = transport.base
68
 
    for allowed_transport in allowed_transports:
69
 
        try:
70
 
            allowed_transport.relpath(abspath)
71
 
        except errors.PathNotChild:
72
 
            continue
73
 
        else:
74
 
            return
75
 
    raise errors.JailBreak(abspath)
76
 
 
77
 
 
78
 
_install_hook()
79
 
 
80
 
 
81
44
class SmartServerRequest(object):
82
45
    """Base class for request handlers.
83
46
 
89
52
    # XXX: rename this class to BaseSmartServerRequestHandler ?  A request
90
53
    # *handler* is a different concept to the request.
91
54
 
92
 
    def __init__(self, backing_transport, root_client_path='/', jail_root=None):
 
55
    def __init__(self, backing_transport, root_client_path='/'):
93
56
        """Constructor.
94
57
 
95
58
        :param backing_transport: the base transport to be used when performing
99
62
            from the client.  Clients will not be able to refer to paths above
100
63
            this root.  If root_client_path is None, then no translation will
101
64
            be performed on client paths.  Default is '/'.
102
 
        :param jail_root: if specified, the root of the BzrDir.open jail to use
103
 
            instead of backing_transport.
104
65
        """
105
66
        self._backing_transport = backing_transport
106
 
        if jail_root is None:
107
 
            jail_root = backing_transport
108
 
        self._jail_root = jail_root
109
67
        if root_client_path is not None:
110
68
            if not root_client_path.startswith('/'):
111
69
                root_client_path = '/' + root_client_path
162
120
        self._body_chunks = None
163
121
        return self.do_body(body_bytes)
164
122
 
165
 
    def setup_jail(self):
166
 
        jail_info.transports = [self._jail_root]
167
 
 
168
 
    def teardown_jail(self):
169
 
        jail_info.transports = None
170
 
 
171
123
    def translate_client_path(self, client_path):
172
124
        """Translate a path received from a network client into a local
173
125
        relpath.
184
136
            return client_path
185
137
        if not client_path.startswith('/'):
186
138
            client_path = '/' + client_path
187
 
        if client_path + '/' == self._root_client_path:
188
 
            return '.'
189
139
        if client_path.startswith(self._root_client_path):
190
140
            path = client_path[len(self._root_client_path):]
191
141
            relpath = urlutils.joinpath('/', path)
192
142
            if not relpath.startswith('/'):
193
143
                raise ValueError(relpath)
194
 
            return urlutils.escape('.' + relpath)
 
144
            return '.' + relpath
195
145
        else:
196
146
            raise errors.PathNotChild(client_path, self._root_client_path)
197
147
 
273
223
    # TODO: Better way of representing the body for commands that take it,
274
224
    # and allow it to be streamed into the server.
275
225
 
276
 
    def __init__(self, backing_transport, commands, root_client_path,
277
 
        jail_root=None):
 
226
    def __init__(self, backing_transport, commands, root_client_path):
278
227
        """Constructor.
279
228
 
280
229
        :param backing_transport: a Transport to handle requests for.
284
233
        self._backing_transport = backing_transport
285
234
        self._root_client_path = root_client_path
286
235
        self._commands = commands
287
 
        if jail_root is None:
288
 
            jail_root = backing_transport
289
 
        self._jail_root = jail_root
290
236
        self.response = None
291
237
        self.finished_reading = False
292
238
        self._command = None
293
 
        if 'hpss' in debug.debug_flags:
294
 
            self._request_start_time = osutils.timer_func()
295
 
            self._thread_id = thread.get_ident()
296
 
 
297
 
    def _trace(self, action, message, extra_bytes=None, include_time=False):
298
 
        # It is a bit of a shame that this functionality overlaps with that of 
299
 
        # ProtocolThreeRequester._trace. However, there is enough difference
300
 
        # that just putting it in a helper doesn't help a lot. And some state
301
 
        # is taken from the instance.
302
 
        if include_time:
303
 
            t = '%5.3fs ' % (osutils.timer_func() - self._request_start_time)
304
 
        else:
305
 
            t = ''
306
 
        if extra_bytes is None:
307
 
            extra = ''
308
 
        else:
309
 
            extra = ' ' + repr(extra_bytes[:40])
310
 
            if len(extra) > 33:
311
 
                extra = extra[:29] + extra[-1] + '...'
312
 
        trace.mutter('%12s: [%s] %s%s%s'
313
 
                     % (action, self._thread_id, t, message, extra))
314
239
 
315
240
    def accept_body(self, bytes):
316
241
        """Accept body data."""
317
 
        if self._command is None:
318
 
            # no active command object, so ignore the event.
319
 
            return
320
242
        self._run_handler_code(self._command.do_chunk, (bytes,), {})
321
 
        if 'hpss' in debug.debug_flags:
322
 
            self._trace('accept body',
323
 
                        '%d bytes' % (len(bytes),), bytes)
324
243
 
325
244
    def end_of_body(self):
326
245
        """No more body data will be received."""
327
246
        self._run_handler_code(self._command.do_end, (), {})
328
247
        # cannot read after this.
329
248
        self.finished_reading = True
330
 
        if 'hpss' in debug.debug_flags:
331
 
            self._trace('end of body', '', include_time=True)
 
249
 
 
250
    def dispatch_command(self, cmd, args):
 
251
        """Deprecated compatibility method.""" # XXX XXX
 
252
        try:
 
253
            command = self._commands.get(cmd)
 
254
        except LookupError:
 
255
            raise errors.UnknownSmartMethod(cmd)
 
256
        self._command = command(self._backing_transport, self._root_client_path)
 
257
        self._run_handler_code(self._command.execute, args, {})
332
258
 
333
259
    def _run_handler_code(self, callable, args, kwargs):
334
260
        """Run some handler specific code 'callable'.
350
276
        # XXX: most of this error conversion is VFS-related, and thus ought to
351
277
        # be in SmartServerVFSRequestHandler somewhere.
352
278
        try:
353
 
            self._command.setup_jail()
354
 
            try:
355
 
                return callable(*args, **kwargs)
356
 
            finally:
357
 
                self._command.teardown_jail()
358
 
        except (KeyboardInterrupt, SystemExit):
359
 
            raise
360
 
        except Exception, err:
361
 
            err_struct = _translate_error(err)
362
 
            return FailedSmartServerResponse(err_struct)
 
279
            return callable(*args, **kwargs)
 
280
        except errors.NoSuchFile, e:
 
281
            return FailedSmartServerResponse(('NoSuchFile', e.path))
 
282
        except errors.FileExists, e:
 
283
            return FailedSmartServerResponse(('FileExists', e.path))
 
284
        except errors.DirectoryNotEmpty, e:
 
285
            return FailedSmartServerResponse(('DirectoryNotEmpty', e.path))
 
286
        except errors.ShortReadvError, e:
 
287
            return FailedSmartServerResponse(('ShortReadvError',
 
288
                e.path, str(e.offset), str(e.length), str(e.actual)))
 
289
        except errors.UnstackableRepositoryFormat, e:
 
290
            return FailedSmartServerResponse(('UnstackableRepositoryFormat',
 
291
                str(e.format), e.url))
 
292
        except errors.UnstackableBranchFormat, e:
 
293
            return FailedSmartServerResponse(('UnstackableBranchFormat',
 
294
                str(e.format), e.url))
 
295
        except errors.NotStacked, e:
 
296
            return FailedSmartServerResponse(('NotStacked',))
 
297
        except UnicodeError, e:
 
298
            # If it is a DecodeError, than most likely we are starting
 
299
            # with a plain string
 
300
            str_or_unicode = e.object
 
301
            if isinstance(str_or_unicode, unicode):
 
302
                # XXX: UTF-8 might have \x01 (our protocol v1 and v2 seperator
 
303
                # byte) in it, so this encoding could cause broken responses.
 
304
                # Newer clients use protocol v3, so will be fine.
 
305
                val = 'u:' + str_or_unicode.encode('utf-8')
 
306
            else:
 
307
                val = 's:' + str_or_unicode.encode('base64')
 
308
            # This handles UnicodeEncodeError or UnicodeDecodeError
 
309
            return FailedSmartServerResponse((e.__class__.__name__,
 
310
                    e.encoding, val, str(e.start), str(e.end), e.reason))
 
311
        except errors.TransportNotPossible, e:
 
312
            if e.msg == "readonly transport":
 
313
                return FailedSmartServerResponse(('ReadOnlyError', ))
 
314
            else:
 
315
                raise
 
316
        except errors.ReadError, e:
 
317
            # cannot read the file
 
318
            return FailedSmartServerResponse(('ReadError', e.path))
 
319
        except errors.PermissionDenied, e:
 
320
            return FailedSmartServerResponse(
 
321
                ('PermissionDenied', e.path, e.extra))
363
322
 
364
323
    def headers_received(self, headers):
365
324
        # Just a no-op at the moment.
366
 
        if 'hpss' in debug.debug_flags:
367
 
            self._trace('headers', repr(headers))
 
325
        pass
368
326
 
369
327
    def args_received(self, args):
370
328
        cmd = args[0]
372
330
        try:
373
331
            command = self._commands.get(cmd)
374
332
        except LookupError:
375
 
            if 'hpss' in debug.debug_flags:
376
 
                self._trace('hpss unknown request', 
377
 
                            cmd, repr(args)[1:-1])
378
333
            raise errors.UnknownSmartMethod(cmd)
379
 
        if 'hpss' in debug.debug_flags:
380
 
            from bzrlib.smart import vfs
381
 
            if issubclass(command, vfs.VfsRequest):
382
 
                action = 'hpss vfs req'
383
 
            else:
384
 
                action = 'hpss request'
385
 
            self._trace(action, 
386
 
                        '%s %s' % (cmd, repr(args)[1:-1]))
387
 
        self._command = command(
388
 
            self._backing_transport, self._root_client_path, self._jail_root)
 
334
        self._command = command(self._backing_transport)
389
335
        self._run_handler_code(self._command.execute, args, {})
390
336
 
391
337
    def end_received(self):
392
 
        if self._command is None:
393
 
            # no active command object, so ignore the event.
394
 
            return
395
338
        self._run_handler_code(self._command.do_end, (), {})
396
 
        if 'hpss' in debug.debug_flags:
397
 
            self._trace('end', '', include_time=True)
398
339
 
399
340
    def post_body_error_received(self, error_args):
400
341
        # Just a no-op at the moment.
401
342
        pass
402
343
 
403
344
 
404
 
def _translate_error(err):
405
 
    if isinstance(err, errors.NoSuchFile):
406
 
        return ('NoSuchFile', err.path)
407
 
    elif isinstance(err, errors.FileExists):
408
 
        return ('FileExists', err.path)
409
 
    elif isinstance(err, errors.DirectoryNotEmpty):
410
 
        return ('DirectoryNotEmpty', err.path)
411
 
    elif isinstance(err, errors.IncompatibleRepositories):
412
 
        return ('IncompatibleRepositories', str(err.source), str(err.target),
413
 
            str(err.details))
414
 
    elif isinstance(err, errors.ShortReadvError):
415
 
        return ('ShortReadvError', err.path, str(err.offset), str(err.length),
416
 
                str(err.actual))
417
 
    elif isinstance(err, errors.UnstackableRepositoryFormat):
418
 
        return (('UnstackableRepositoryFormat', str(err.format), err.url))
419
 
    elif isinstance(err, errors.UnstackableBranchFormat):
420
 
        return ('UnstackableBranchFormat', str(err.format), err.url)
421
 
    elif isinstance(err, errors.NotStacked):
422
 
        return ('NotStacked',)
423
 
    elif isinstance(err, UnicodeError):
424
 
        # If it is a DecodeError, than most likely we are starting
425
 
        # with a plain string
426
 
        str_or_unicode = err.object
427
 
        if isinstance(str_or_unicode, unicode):
428
 
            # XXX: UTF-8 might have \x01 (our protocol v1 and v2 seperator
429
 
            # byte) in it, so this encoding could cause broken responses.
430
 
            # Newer clients use protocol v3, so will be fine.
431
 
            val = 'u:' + str_or_unicode.encode('utf-8')
432
 
        else:
433
 
            val = 's:' + str_or_unicode.encode('base64')
434
 
        # This handles UnicodeEncodeError or UnicodeDecodeError
435
 
        return (err.__class__.__name__, err.encoding, val, str(err.start),
436
 
                str(err.end), err.reason)
437
 
    elif isinstance(err, errors.TransportNotPossible):
438
 
        if err.msg == "readonly transport":
439
 
            return ('ReadOnlyError', )
440
 
    elif isinstance(err, errors.ReadError):
441
 
        # cannot read the file
442
 
        return ('ReadError', err.path)
443
 
    elif isinstance(err, errors.PermissionDenied):
444
 
        return ('PermissionDenied', err.path, err.extra)
445
 
    elif isinstance(err, errors.TokenMismatch):
446
 
        return ('TokenMismatch', err.given_token, err.lock_token)
447
 
    elif isinstance(err, errors.LockContention):
448
 
        return ('LockContention',)
449
 
    # Unserialisable error.  Log it, and return a generic error
450
 
    trace.log_exception_quietly()
451
 
    return ('error', str(err))
452
 
 
453
 
 
454
345
class HelloRequest(SmartServerRequest):
455
346
    """Answer a version request with the highest protocol version this server
456
347
    supports.
490
381
request_handlers.register_lazy(
491
382
    'append', 'bzrlib.smart.vfs', 'AppendRequest')
492
383
request_handlers.register_lazy(
493
 
    'Branch.get_config_file', 'bzrlib.smart.branch',
494
 
    'SmartServerBranchGetConfigFile')
495
 
request_handlers.register_lazy(
496
 
    'Branch.get_parent', 'bzrlib.smart.branch', 'SmartServerBranchGetParent')
497
 
request_handlers.register_lazy(
498
 
    'Branch.get_tags_bytes', 'bzrlib.smart.branch',
499
 
    'SmartServerBranchGetTagsBytes')
500
 
request_handlers.register_lazy(
501
 
    'Branch.set_tags_bytes', 'bzrlib.smart.branch',
502
 
    'SmartServerBranchSetTagsBytes')
 
384
    'Branch.get_config_file', 'bzrlib.smart.branch', 'SmartServerBranchGetConfigFile')
503
385
request_handlers.register_lazy(
504
386
    'Branch.get_stacked_on_url', 'bzrlib.smart.branch', 'SmartServerBranchRequestGetStackedOnURL')
505
387
request_handlers.register_lazy(
506
388
    'Branch.last_revision_info', 'bzrlib.smart.branch', 'SmartServerBranchRequestLastRevisionInfo')
507
389
request_handlers.register_lazy(
508
390
    'Branch.lock_write', 'bzrlib.smart.branch', 'SmartServerBranchRequestLockWrite')
509
 
request_handlers.register_lazy( 'Branch.revision_history',
510
 
    'bzrlib.smart.branch', 'SmartServerRequestRevisionHistory')
511
 
request_handlers.register_lazy( 'Branch.set_config_option',
512
 
    'bzrlib.smart.branch', 'SmartServerBranchRequestSetConfigOption')
513
 
request_handlers.register_lazy( 'Branch.set_last_revision',
514
 
    'bzrlib.smart.branch', 'SmartServerBranchRequestSetLastRevision')
 
391
request_handlers.register_lazy(
 
392
    'Branch.revision_history', 'bzrlib.smart.branch', 'SmartServerRequestRevisionHistory')
 
393
request_handlers.register_lazy(
 
394
    'Branch.set_last_revision', 'bzrlib.smart.branch', 'SmartServerBranchRequestSetLastRevision')
515
395
request_handlers.register_lazy(
516
396
    'Branch.set_last_revision_info', 'bzrlib.smart.branch',
517
397
    'SmartServerBranchRequestSetLastRevisionInfo')
519
399
    'Branch.set_last_revision_ex', 'bzrlib.smart.branch',
520
400
    'SmartServerBranchRequestSetLastRevisionEx')
521
401
request_handlers.register_lazy(
522
 
    'Branch.set_parent_location', 'bzrlib.smart.branch',
523
 
    'SmartServerBranchRequestSetParentLocation')
524
 
request_handlers.register_lazy(
525
402
    'Branch.unlock', 'bzrlib.smart.branch', 'SmartServerBranchRequestUnlock')
526
403
request_handlers.register_lazy(
527
 
    'BzrDir.cloning_metadir', 'bzrlib.smart.bzrdir',
528
 
    'SmartServerBzrDirRequestCloningMetaDir')
529
 
request_handlers.register_lazy(
530
 
    'BzrDir.create_branch', 'bzrlib.smart.bzrdir',
531
 
    'SmartServerRequestCreateBranch')
532
 
request_handlers.register_lazy(
533
 
    'BzrDir.create_repository', 'bzrlib.smart.bzrdir',
534
 
    'SmartServerRequestCreateRepository')
535
 
request_handlers.register_lazy(
536
 
    'BzrDir.find_repository', 'bzrlib.smart.bzrdir',
537
 
    'SmartServerRequestFindRepositoryV1')
538
 
request_handlers.register_lazy(
539
 
    'BzrDir.find_repositoryV2', 'bzrlib.smart.bzrdir',
540
 
    'SmartServerRequestFindRepositoryV2')
541
 
request_handlers.register_lazy(
542
 
    'BzrDir.find_repositoryV3', 'bzrlib.smart.bzrdir',
543
 
    'SmartServerRequestFindRepositoryV3')
544
 
request_handlers.register_lazy(
545
 
    'BzrDir.get_config_file', 'bzrlib.smart.bzrdir',
546
 
    'SmartServerBzrDirRequestConfigFile')
547
 
request_handlers.register_lazy(
548
 
    'BzrDirFormat.initialize', 'bzrlib.smart.bzrdir',
549
 
    'SmartServerRequestInitializeBzrDir')
550
 
request_handlers.register_lazy(
551
 
    'BzrDirFormat.initialize_ex_1.16', 'bzrlib.smart.bzrdir',
552
 
    'SmartServerRequestBzrDirInitializeEx')
553
 
request_handlers.register_lazy(
554
 
    'BzrDir.open', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBzrDir')
555
 
request_handlers.register_lazy(
556
 
    'BzrDir.open_2.1', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBzrDir_2_1')
557
 
request_handlers.register_lazy(
558
 
    'BzrDir.open_branch', 'bzrlib.smart.bzrdir',
559
 
    'SmartServerRequestOpenBranch')
560
 
request_handlers.register_lazy(
561
 
    'BzrDir.open_branchV2', 'bzrlib.smart.bzrdir',
562
 
    'SmartServerRequestOpenBranchV2')
563
 
request_handlers.register_lazy(
564
 
    'BzrDir.open_branchV3', 'bzrlib.smart.bzrdir',
565
 
    'SmartServerRequestOpenBranchV3')
 
404
    'BzrDir.create_branch', 'bzrlib.smart.bzrdir', 'SmartServerRequestCreateBranch')
 
405
request_handlers.register_lazy(
 
406
    'BzrDir.create_repository', 'bzrlib.smart.bzrdir', 'SmartServerRequestCreateRepository')
 
407
request_handlers.register_lazy(
 
408
    'BzrDir.find_repository', 'bzrlib.smart.bzrdir', 'SmartServerRequestFindRepositoryV1')
 
409
request_handlers.register_lazy(
 
410
    'BzrDir.find_repositoryV2', 'bzrlib.smart.bzrdir', 'SmartServerRequestFindRepositoryV2')
 
411
request_handlers.register_lazy(
 
412
    'BzrDirFormat.initialize', 'bzrlib.smart.bzrdir', 'SmartServerRequestInitializeBzrDir')
 
413
request_handlers.register_lazy(
 
414
    'BzrDir.open_branch', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBranch')
566
415
request_handlers.register_lazy(
567
416
    'delete', 'bzrlib.smart.vfs', 'DeleteRequest')
568
417
request_handlers.register_lazy(
605
454
request_handlers.register_lazy(
606
455
    'Repository.insert_stream', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStream')
607
456
request_handlers.register_lazy(
608
 
    'Repository.insert_stream_1.19', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStream_1_19')
609
 
request_handlers.register_lazy(
610
 
    'Repository.insert_stream_locked', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStreamLocked')
611
 
request_handlers.register_lazy(
612
457
    'Repository.is_shared', 'bzrlib.smart.repository', 'SmartServerRepositoryIsShared')
613
458
request_handlers.register_lazy(
614
459
    'Repository.lock_write', 'bzrlib.smart.repository', 'SmartServerRepositoryLockWrite')
618
463
request_handlers.register_lazy(
619
464
    'Repository.unlock', 'bzrlib.smart.repository', 'SmartServerRepositoryUnlock')
620
465
request_handlers.register_lazy(
621
 
    'Repository.get_rev_id_for_revno', 'bzrlib.smart.repository',
622
 
    'SmartServerRepositoryGetRevIdForRevno')
623
 
request_handlers.register_lazy(
624
 
    'Repository.get_stream', 'bzrlib.smart.repository',
625
 
    'SmartServerRepositoryGetStream')
626
 
request_handlers.register_lazy(
627
 
    'Repository.get_stream_1.19', 'bzrlib.smart.repository',
628
 
    'SmartServerRepositoryGetStream_1_19')
629
 
request_handlers.register_lazy(
630
466
    'Repository.tarball', 'bzrlib.smart.repository',
631
467
    'SmartServerRepositoryTarball')
632
468
request_handlers.register_lazy(
635
471
    'stat', 'bzrlib.smart.vfs', 'StatRequest')
636
472
request_handlers.register_lazy(
637
473
    'Transport.is_readonly', 'bzrlib.smart.request', 'SmartServerIsReadonly')
 
474
request_handlers.register_lazy(
 
475
    'BzrDir.open', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBzrDir')