← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/request.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-10 15:46:03 UTC
  • mfrom: (4985.3.21 update)
  • mto: This revision was merged to the branch mainline in revision 5021.
  • Revision ID: v.ladeuil+lp@free.fr-20100210154603-k4no1gvfuqpzrw7p
https://launchpad.net/bugs/113809
Update performs two merges in a more logical order but stop on conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/request.py
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., 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).
 
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
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
 
29
34
import tempfile
 
35
import thread
 
36
import threading
30
37
 
31
38
from bzrlib import (
32
39
    bzrdir,
 
40
    debug,
33
41
    errors,
 
42
    osutils,
34
43
    registry,
35
44
    revision,
 
45
    trace,
36
46
    urlutils,
37
47
    )
38
48
from bzrlib.lazy_import import lazy_import
41
51
""")
42
52
 
43
53
 
 
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
 
44
81
class SmartServerRequest(object):
45
82
    """Base class for request handlers.
46
 
    
 
83
 
47
84
    To define a new request, subclass this class and override the `do` method
48
85
    (and if appropriate, `do_body` as well).  Request implementors should take
49
86
    care to call `translate_client_path` and `transport_from_client_path` as
52
89
    # XXX: rename this class to BaseSmartServerRequestHandler ?  A request
53
90
    # *handler* is a different concept to the request.
54
91
 
55
 
    def __init__(self, backing_transport, root_client_path='/'):
 
92
    def __init__(self, backing_transport, root_client_path='/', jail_root=None):
56
93
        """Constructor.
57
94
 
58
95
        :param backing_transport: the base transport to be used when performing
62
99
            from the client.  Clients will not be able to refer to paths above
63
100
            this root.  If root_client_path is None, then no translation will
64
101
            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.
65
104
        """
66
105
        self._backing_transport = backing_transport
 
106
        if jail_root is None:
 
107
            jail_root = backing_transport
 
108
        self._jail_root = jail_root
67
109
        if root_client_path is not None:
68
110
            if not root_client_path.startswith('/'):
69
111
                root_client_path = '/' + root_client_path
78
120
 
79
121
    def do(self, *args):
80
122
        """Mandatory extension point for SmartServerRequest subclasses.
81
 
        
 
123
 
82
124
        Subclasses must implement this.
83
 
        
 
125
 
84
126
        This should return a SmartServerResponse if this command expects to
85
127
        receive no body.
86
128
        """
101
143
        """Called if the client sends a body with the request.
102
144
 
103
145
        The do() method is still called, and must have returned None.
104
 
        
 
146
 
105
147
        Must return a SmartServerResponse.
106
148
        """
107
 
        raise NotImplementedError(self.do_body)
 
149
        if body_bytes != '':
 
150
            raise errors.SmartProtocolError('Request does not expect a body')
108
151
 
109
152
    def do_chunk(self, chunk_bytes):
110
153
        """Called with each body chunk if the request has a streamed body.
118
161
        body_bytes = ''.join(self._body_chunks)
119
162
        self._body_chunks = None
120
163
        return self.do_body(body_bytes)
121
 
    
 
164
 
 
165
    def setup_jail(self):
 
166
        jail_info.transports = [self._jail_root]
 
167
 
 
168
    def teardown_jail(self):
 
169
        jail_info.transports = None
 
170
 
122
171
    def translate_client_path(self, client_path):
123
172
        """Translate a path received from a network client into a local
124
173
        relpath.
135
184
            return client_path
136
185
        if not client_path.startswith('/'):
137
186
            client_path = '/' + client_path
 
187
        if client_path + '/' == self._root_client_path:
 
188
            return '.'
138
189
        if client_path.startswith(self._root_client_path):
139
190
            path = client_path[len(self._root_client_path):]
140
191
            relpath = urlutils.joinpath('/', path)
141
192
            if not relpath.startswith('/'):
142
193
                raise ValueError(relpath)
143
 
            return '.' + relpath
 
194
            return urlutils.escape('.' + relpath)
144
195
        else:
145
196
            raise errors.PathNotChild(client_path, self._root_client_path)
146
197
 
157
208
 
158
209
class SmartServerResponse(object):
159
210
    """A response to a client request.
160
 
    
 
211
 
161
212
    This base class should not be used. Instead use
162
213
    SuccessfulSmartServerResponse and FailedSmartServerResponse as appropriate.
163
214
    """
207
258
 
208
259
class SmartServerRequestHandler(object):
209
260
    """Protocol logic for smart server.
210
 
    
 
261
 
211
262
    This doesn't handle serialization at all, it just processes requests and
212
263
    creates responses.
213
264
    """
222
273
    # TODO: Better way of representing the body for commands that take it,
223
274
    # and allow it to be streamed into the server.
224
275
 
225
 
    def __init__(self, backing_transport, commands, root_client_path):
 
276
    def __init__(self, backing_transport, commands, root_client_path,
 
277
        jail_root=None):
226
278
        """Constructor.
227
279
 
228
280
        :param backing_transport: a Transport to handle requests for.
232
284
        self._backing_transport = backing_transport
233
285
        self._root_client_path = root_client_path
234
286
        self._commands = commands
 
287
        if jail_root is None:
 
288
            jail_root = backing_transport
 
289
        self._jail_root = jail_root
235
290
        self.response = None
236
291
        self.finished_reading = False
237
292
        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))
238
314
 
239
315
    def accept_body(self, bytes):
240
316
        """Accept body data."""
 
317
        if self._command is None:
 
318
            # no active command object, so ignore the event.
 
319
            return
241
320
        self._run_handler_code(self._command.do_chunk, (bytes,), {})
242
 
        
 
321
        if 'hpss' in debug.debug_flags:
 
322
            self._trace('accept body',
 
323
                        '%d bytes' % (len(bytes),), bytes)
 
324
 
243
325
    def end_of_body(self):
244
326
        """No more body data will be received."""
245
327
        self._run_handler_code(self._command.do_end, (), {})
246
328
        # cannot read after this.
247
329
        self.finished_reading = True
248
 
 
249
 
    def dispatch_command(self, cmd, args):
250
 
        """Deprecated compatibility method.""" # XXX XXX
251
 
        try:
252
 
            command = self._commands.get(cmd)
253
 
        except LookupError:
254
 
            raise errors.UnknownSmartMethod(cmd)
255
 
        self._command = command(self._backing_transport, self._root_client_path)
256
 
        self._run_handler_code(self._command.execute, args, {})
 
330
        if 'hpss' in debug.debug_flags:
 
331
            self._trace('end of body', '', include_time=True)
257
332
 
258
333
    def _run_handler_code(self, callable, args, kwargs):
259
334
        """Run some handler specific code 'callable'.
275
350
        # XXX: most of this error conversion is VFS-related, and thus ought to
276
351
        # be in SmartServerVFSRequestHandler somewhere.
277
352
        try:
278
 
            return callable(*args, **kwargs)
279
 
        except errors.NoSuchFile, e:
280
 
            return FailedSmartServerResponse(('NoSuchFile', e.path))
281
 
        except errors.FileExists, e:
282
 
            return FailedSmartServerResponse(('FileExists', e.path))
283
 
        except errors.DirectoryNotEmpty, e:
284
 
            return FailedSmartServerResponse(('DirectoryNotEmpty', e.path))
285
 
        except errors.ShortReadvError, e:
286
 
            return FailedSmartServerResponse(('ShortReadvError',
287
 
                e.path, str(e.offset), str(e.length), str(e.actual)))
288
 
        except errors.UnstackableRepositoryFormat, e:
289
 
            return FailedSmartServerResponse(('UnstackableRepositoryFormat',
290
 
                str(e.format), e.url))
291
 
        except errors.UnstackableBranchFormat, e:
292
 
            return FailedSmartServerResponse(('UnstackableBranchFormat',
293
 
                str(e.format), e.url))
294
 
        except errors.NotStacked, e:
295
 
            return FailedSmartServerResponse(('NotStacked',))
296
 
        except UnicodeError, e:
297
 
            # If it is a DecodeError, than most likely we are starting
298
 
            # with a plain string
299
 
            str_or_unicode = e.object
300
 
            if isinstance(str_or_unicode, unicode):
301
 
                # XXX: UTF-8 might have \x01 (our protocol v1 and v2 seperator
302
 
                # byte) in it, so this encoding could cause broken responses.
303
 
                # Newer clients use protocol v3, so will be fine.
304
 
                val = 'u:' + str_or_unicode.encode('utf-8')
305
 
            else:
306
 
                val = 's:' + str_or_unicode.encode('base64')
307
 
            # This handles UnicodeEncodeError or UnicodeDecodeError
308
 
            return FailedSmartServerResponse((e.__class__.__name__,
309
 
                    e.encoding, val, str(e.start), str(e.end), e.reason))
310
 
        except errors.TransportNotPossible, e:
311
 
            if e.msg == "readonly transport":
312
 
                return FailedSmartServerResponse(('ReadOnlyError', ))
313
 
            else:
314
 
                raise
315
 
        except errors.ReadError, e:
316
 
            # cannot read the file
317
 
            return FailedSmartServerResponse(('ReadError', e.path))
318
 
        except errors.PermissionDenied, e:
319
 
            return FailedSmartServerResponse(
320
 
                ('PermissionDenied', e.path, e.extra))
 
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)
321
363
 
322
364
    def headers_received(self, headers):
323
365
        # Just a no-op at the moment.
324
 
        pass
 
366
        if 'hpss' in debug.debug_flags:
 
367
            self._trace('headers', repr(headers))
325
368
 
326
369
    def args_received(self, args):
327
370
        cmd = args[0]
329
372
        try:
330
373
            command = self._commands.get(cmd)
331
374
        except LookupError:
 
375
            if 'hpss' in debug.debug_flags:
 
376
                self._trace('hpss unknown request', 
 
377
                            cmd, repr(args)[1:-1])
332
378
            raise errors.UnknownSmartMethod(cmd)
333
 
        self._command = command(self._backing_transport)
 
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
389
        self._run_handler_code(self._command.execute, args, {})
335
390
 
336
391
    def end_received(self):
 
392
        if self._command is None:
 
393
            # no active command object, so ignore the event.
 
394
            return
337
395
        self._run_handler_code(self._command.do_end, (), {})
 
396
        if 'hpss' in debug.debug_flags:
 
397
            self._trace('end', '', include_time=True)
338
398
 
339
399
    def post_body_error_received(self, error_args):
340
400
        # Just a no-op at the moment.
341
401
        pass
342
402
 
343
403
 
 
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
 
344
454
class HelloRequest(SmartServerRequest):
345
455
    """Answer a version request with the highest protocol version this server
346
456
    supports.
380
490
request_handlers.register_lazy(
381
491
    'append', 'bzrlib.smart.vfs', 'AppendRequest')
382
492
request_handlers.register_lazy(
383
 
    'Branch.get_config_file', 'bzrlib.smart.branch', 'SmartServerBranchGetConfigFile')
 
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
503
request_handlers.register_lazy(
385
504
    'Branch.get_stacked_on_url', 'bzrlib.smart.branch', 'SmartServerBranchRequestGetStackedOnURL')
386
505
request_handlers.register_lazy(
387
506
    'Branch.last_revision_info', 'bzrlib.smart.branch', 'SmartServerBranchRequestLastRevisionInfo')
388
507
request_handlers.register_lazy(
389
508
    'Branch.lock_write', 'bzrlib.smart.branch', 'SmartServerBranchRequestLockWrite')
390
 
request_handlers.register_lazy(
391
 
    'Branch.revision_history', 'bzrlib.smart.branch', 'SmartServerRequestRevisionHistory')
392
 
request_handlers.register_lazy(
393
 
    'Branch.set_last_revision', 'bzrlib.smart.branch', 'SmartServerBranchRequestSetLastRevision')
 
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')
394
515
request_handlers.register_lazy(
395
516
    'Branch.set_last_revision_info', 'bzrlib.smart.branch',
396
517
    'SmartServerBranchRequestSetLastRevisionInfo')
398
519
    'Branch.set_last_revision_ex', 'bzrlib.smart.branch',
399
520
    'SmartServerBranchRequestSetLastRevisionEx')
400
521
request_handlers.register_lazy(
 
522
    'Branch.set_parent_location', 'bzrlib.smart.branch',
 
523
    'SmartServerBranchRequestSetParentLocation')
 
524
request_handlers.register_lazy(
401
525
    'Branch.unlock', 'bzrlib.smart.branch', 'SmartServerBranchRequestUnlock')
402
526
request_handlers.register_lazy(
403
 
    'BzrDir.find_repository', 'bzrlib.smart.bzrdir', 'SmartServerRequestFindRepositoryV1')
404
 
request_handlers.register_lazy(
405
 
    'BzrDir.find_repositoryV2', 'bzrlib.smart.bzrdir', 'SmartServerRequestFindRepositoryV2')
406
 
request_handlers.register_lazy(
407
 
    'BzrDirFormat.initialize', 'bzrlib.smart.bzrdir', 'SmartServerRequestInitializeBzrDir')
408
 
request_handlers.register_lazy(
409
 
    'BzrDir.open_branch', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBranch')
 
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')
410
566
request_handlers.register_lazy(
411
567
    'delete', 'bzrlib.smart.vfs', 'DeleteRequest')
412
568
request_handlers.register_lazy(
447
603
request_handlers.register_lazy(
448
604
    'Repository.has_revision', 'bzrlib.smart.repository', 'SmartServerRequestHasRevision')
449
605
request_handlers.register_lazy(
 
606
    'Repository.insert_stream', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStream')
 
607
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(
450
612
    'Repository.is_shared', 'bzrlib.smart.repository', 'SmartServerRepositoryIsShared')
451
613
request_handlers.register_lazy(
452
614
    'Repository.lock_write', 'bzrlib.smart.repository', 'SmartServerRepositoryLockWrite')
453
615
request_handlers.register_lazy(
 
616
    'Repository.set_make_working_trees', 'bzrlib.smart.repository',
 
617
    'SmartServerRepositorySetMakeWorkingTrees')
 
618
request_handlers.register_lazy(
454
619
    'Repository.unlock', 'bzrlib.smart.repository', 'SmartServerRepositoryUnlock')
455
620
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(
456
630
    'Repository.tarball', 'bzrlib.smart.repository',
457
631
    'SmartServerRepositoryTarball')
458
632
request_handlers.register_lazy(
461
635
    'stat', 'bzrlib.smart.vfs', 'StatRequest')
462
636
request_handlers.register_lazy(
463
637
    'Transport.is_readonly', 'bzrlib.smart.request', 'SmartServerIsReadonly')
464
 
request_handlers.register_lazy(
465
 
    'BzrDir.open', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBzrDir')