~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/request.py

  • Committer: Vincent Ladeuil
  • Date: 2007-06-20 14:25:06 UTC
  • mfrom: (2540 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070620142506-txsb1v8538kpsafw
merge bzr.dev @ 2540

Show diffs side-by-side

added added

removed removed

Lines of Context:
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).
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.
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Basic server-side logic for dealing with requests."""
32
18
 
33
19
 
34
20
import tempfile
35
 
import thread
36
 
import threading
37
21
 
38
22
from bzrlib import (
39
23
    bzrdir,
40
 
    debug,
41
24
    errors,
42
 
    osutils,
43
25
    registry,
44
26
    revision,
45
 
    trace,
46
 
    urlutils,
47
27
    )
48
 
from bzrlib.lazy_import import lazy_import
49
 
lazy_import(globals(), """
50
 
from bzrlib.bundle import serializer
51
 
""")
52
 
 
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()
 
28
from bzrlib.bundle.serializer import write_bundle
79
29
 
80
30
 
81
31
class SmartServerRequest(object):
82
 
    """Base class for request handlers.
83
 
 
84
 
    To define a new request, subclass this class and override the `do` method
85
 
    (and if appropriate, `do_body` as well).  Request implementors should take
86
 
    care to call `translate_client_path` and `transport_from_client_path` as
87
 
    appropriate when dealing with paths received from the client.
88
 
    """
89
 
    # XXX: rename this class to BaseSmartServerRequestHandler ?  A request
90
 
    # *handler* is a different concept to the request.
91
 
 
92
 
    def __init__(self, backing_transport, root_client_path='/', jail_root=None):
 
32
    """Base class for request handlers."""
 
33
 
 
34
    def __init__(self, backing_transport):
93
35
        """Constructor.
94
36
 
95
37
        :param backing_transport: the base transport to be used when performing
96
38
            this request.
97
 
        :param root_client_path: the client path that maps to the root of
98
 
            backing_transport.  This is used to interpret relpaths received
99
 
            from the client.  Clients will not be able to refer to paths above
100
 
            this root.  If root_client_path is None, then no translation will
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.
104
39
        """
105
40
        self._backing_transport = backing_transport
106
 
        if jail_root is None:
107
 
            jail_root = backing_transport
108
 
        self._jail_root = jail_root
109
 
        if root_client_path is not None:
110
 
            if not root_client_path.startswith('/'):
111
 
                root_client_path = '/' + root_client_path
112
 
            if not root_client_path.endswith('/'):
113
 
                root_client_path += '/'
114
 
        self._root_client_path = root_client_path
115
 
        self._body_chunks = []
116
41
 
117
42
    def _check_enabled(self):
118
43
        """Raises DisabledMethod if this method is disabled."""
120
45
 
121
46
    def do(self, *args):
122
47
        """Mandatory extension point for SmartServerRequest subclasses.
123
 
 
 
48
        
124
49
        Subclasses must implement this.
125
 
 
 
50
        
126
51
        This should return a SmartServerResponse if this command expects to
127
52
        receive no body.
128
53
        """
141
66
 
142
67
    def do_body(self, body_bytes):
143
68
        """Called if the client sends a body with the request.
144
 
 
145
 
        The do() method is still called, and must have returned None.
146
 
 
 
69
        
147
70
        Must return a SmartServerResponse.
148
71
        """
149
 
        if body_bytes != '':
150
 
            raise errors.SmartProtocolError('Request does not expect a body')
151
 
 
152
 
    def do_chunk(self, chunk_bytes):
153
 
        """Called with each body chunk if the request has a streamed body.
154
 
 
155
 
        The do() method is still called, and must have returned None.
156
 
        """
157
 
        self._body_chunks.append(chunk_bytes)
158
 
 
159
 
    def do_end(self):
160
 
        """Called when the end of the request has been received."""
161
 
        body_bytes = ''.join(self._body_chunks)
162
 
        self._body_chunks = None
163
 
        return self.do_body(body_bytes)
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
 
 
171
 
    def translate_client_path(self, client_path):
172
 
        """Translate a path received from a network client into a local
173
 
        relpath.
174
 
 
175
 
        All paths received from the client *must* be translated.
176
 
 
177
 
        :param client_path: the path from the client.
178
 
        :returns: a relpath that may be used with self._backing_transport
179
 
            (unlike the untranslated client_path, which must not be used with
180
 
            the backing transport).
181
 
        """
182
 
        if self._root_client_path is None:
183
 
            # no translation necessary!
184
 
            return client_path
185
 
        if not client_path.startswith('/'):
186
 
            client_path = '/' + client_path
187
 
        if client_path + '/' == self._root_client_path:
188
 
            return '.'
189
 
        if client_path.startswith(self._root_client_path):
190
 
            path = client_path[len(self._root_client_path):]
191
 
            relpath = urlutils.joinpath('/', path)
192
 
            if not relpath.startswith('/'):
193
 
                raise ValueError(relpath)
194
 
            return urlutils.escape('.' + relpath)
195
 
        else:
196
 
            raise errors.PathNotChild(client_path, self._root_client_path)
197
 
 
198
 
    def transport_from_client_path(self, client_path):
199
 
        """Get a backing transport corresponding to the location referred to by
200
 
        a network client.
201
 
 
202
 
        :seealso: translate_client_path
203
 
        :returns: a transport cloned from self._backing_transport
204
 
        """
205
 
        relpath = self.translate_client_path(client_path)
206
 
        return self._backing_transport.clone(relpath)
 
72
        # TODO: if a client erroneously sends a request that shouldn't have a
 
73
        # body, what to do?  Probably SmartServerRequestHandler should catch
 
74
        # this NotImplementedError and translate it into a 'bad request' error
 
75
        # to send to the client.
 
76
        raise NotImplementedError(self.do_body)
207
77
 
208
78
 
209
79
class SmartServerResponse(object):
210
80
    """A response to a client request.
211
 
 
 
81
    
212
82
    This base class should not be used. Instead use
213
83
    SuccessfulSmartServerResponse and FailedSmartServerResponse as appropriate.
214
84
    """
215
85
 
216
 
    def __init__(self, args, body=None, body_stream=None):
217
 
        """Constructor.
218
 
 
219
 
        :param args: tuple of response arguments.
220
 
        :param body: string of a response body.
221
 
        :param body_stream: iterable of bytestrings to be streamed to the
222
 
            client.
223
 
        """
 
86
    def __init__(self, args, body=None):
224
87
        self.args = args
225
 
        if body is not None and body_stream is not None:
226
 
            raise errors.BzrError(
227
 
                "'body' and 'body_stream' are mutually exclusive.")
228
88
        self.body = body
229
 
        self.body_stream = body_stream
230
89
 
231
90
    def __eq__(self, other):
232
91
        if other is None:
233
92
            return False
234
 
        return (other.args == self.args and
235
 
                other.body == self.body and
236
 
                other.body_stream is self.body_stream)
 
93
        return other.args == self.args and other.body == self.body
237
94
 
238
95
    def __repr__(self):
239
 
        return "<%s args=%r body=%r>" % (self.__class__.__name__,
 
96
        return "<SmartServerResponse args=%r body=%r>" % (self.is_successful(), 
240
97
            self.args, self.body)
241
98
 
242
99
 
258
115
 
259
116
class SmartServerRequestHandler(object):
260
117
    """Protocol logic for smart server.
261
 
 
 
118
    
262
119
    This doesn't handle serialization at all, it just processes requests and
263
120
    creates responses.
264
121
    """
273
130
    # TODO: Better way of representing the body for commands that take it,
274
131
    # and allow it to be streamed into the server.
275
132
 
276
 
    def __init__(self, backing_transport, commands, root_client_path,
277
 
        jail_root=None):
 
133
    def __init__(self, backing_transport, commands):
278
134
        """Constructor.
279
135
 
280
136
        :param backing_transport: a Transport to handle requests for.
282
138
            subclasses. e.g. bzrlib.transport.smart.vfs.vfs_commands.
283
139
        """
284
140
        self._backing_transport = backing_transport
285
 
        self._root_client_path = root_client_path
286
141
        self._commands = commands
287
 
        if jail_root is None:
288
 
            jail_root = backing_transport
289
 
        self._jail_root = jail_root
 
142
        self._body_bytes = ''
290
143
        self.response = None
291
144
        self.finished_reading = False
292
145
        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
146
 
315
147
    def accept_body(self, bytes):
316
148
        """Accept body data."""
317
 
        if self._command is None:
318
 
            # no active command object, so ignore the event.
319
 
            return
320
 
        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
 
 
 
149
 
 
150
        # TODO: This should be overriden for each command that desired body data
 
151
        # to handle the right format of that data, i.e. plain bytes, a bundle,
 
152
        # etc.  The deserialisation into that format should be done in the
 
153
        # Protocol object.
 
154
 
 
155
        # default fallback is to accumulate bytes.
 
156
        self._body_bytes += bytes
 
157
        
325
158
    def end_of_body(self):
326
159
        """No more body data will be received."""
327
 
        self._run_handler_code(self._command.do_end, (), {})
 
160
        self._run_handler_code(self._command.do_body, (self._body_bytes,), {})
328
161
        # cannot read after this.
329
162
        self.finished_reading = True
330
 
        if 'hpss' in debug.debug_flags:
331
 
            self._trace('end of body', '', include_time=True)
 
163
 
 
164
    def dispatch_command(self, cmd, args):
 
165
        """Deprecated compatibility method.""" # XXX XXX
 
166
        try:
 
167
            command = self._commands.get(cmd)
 
168
        except LookupError:
 
169
            raise errors.SmartProtocolError("bad request %r" % (cmd,))
 
170
        self._command = command(self._backing_transport)
 
171
        self._run_handler_code(self._command.execute, args, {})
332
172
 
333
173
    def _run_handler_code(self, callable, args, kwargs):
334
174
        """Run some handler specific code 'callable'.
350
190
        # XXX: most of this error conversion is VFS-related, and thus ought to
351
191
        # be in SmartServerVFSRequestHandler somewhere.
352
192
        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)
363
 
 
364
 
    def headers_received(self, headers):
365
 
        # Just a no-op at the moment.
366
 
        if 'hpss' in debug.debug_flags:
367
 
            self._trace('headers', repr(headers))
368
 
 
369
 
    def args_received(self, args):
370
 
        cmd = args[0]
371
 
        args = args[1:]
372
 
        try:
373
 
            command = self._commands.get(cmd)
374
 
        except LookupError:
375
 
            if 'hpss' in debug.debug_flags:
376
 
                self._trace('hpss unknown request', 
377
 
                            cmd, repr(args)[1:-1])
378
 
            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)
389
 
        self._run_handler_code(self._command.execute, args, {})
390
 
 
391
 
    def end_received(self):
392
 
        if self._command is None:
393
 
            # no active command object, so ignore the event.
394
 
            return
395
 
        self._run_handler_code(self._command.do_end, (), {})
396
 
        if 'hpss' in debug.debug_flags:
397
 
            self._trace('end', '', include_time=True)
398
 
 
399
 
    def post_body_error_received(self, error_args):
400
 
        # Just a no-op at the moment.
401
 
        pass
402
 
 
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))
 
193
            return callable(*args, **kwargs)
 
194
        except errors.NoSuchFile, e:
 
195
            return FailedSmartServerResponse(('NoSuchFile', e.path))
 
196
        except errors.FileExists, e:
 
197
            return FailedSmartServerResponse(('FileExists', e.path))
 
198
        except errors.DirectoryNotEmpty, e:
 
199
            return FailedSmartServerResponse(('DirectoryNotEmpty', e.path))
 
200
        except errors.ShortReadvError, e:
 
201
            return FailedSmartServerResponse(('ShortReadvError',
 
202
                e.path, str(e.offset), str(e.length), str(e.actual)))
 
203
        except UnicodeError, e:
 
204
            # If it is a DecodeError, than most likely we are starting
 
205
            # with a plain string
 
206
            str_or_unicode = e.object
 
207
            if isinstance(str_or_unicode, unicode):
 
208
                # XXX: UTF-8 might have \x01 (our seperator byte) in it.  We
 
209
                # should escape it somehow.
 
210
                val = 'u:' + str_or_unicode.encode('utf-8')
 
211
            else:
 
212
                val = 's:' + str_or_unicode.encode('base64')
 
213
            # This handles UnicodeEncodeError or UnicodeDecodeError
 
214
            return FailedSmartServerResponse((e.__class__.__name__,
 
215
                    e.encoding, val, str(e.start), str(e.end), e.reason))
 
216
        except errors.TransportNotPossible, e:
 
217
            if e.msg == "readonly transport":
 
218
                return FailedSmartServerResponse(('ReadOnlyError', ))
 
219
            else:
 
220
                raise
452
221
 
453
222
 
454
223
class HelloRequest(SmartServerRequest):
465
234
 
466
235
    def do(self, path, revision_id):
467
236
        # open transport relative to our base
468
 
        t = self.transport_from_client_path(path)
 
237
        t = self._backing_transport.clone(path)
469
238
        control, extra_path = bzrdir.BzrDir.open_containing_from_transport(t)
470
239
        repo = control.open_repository()
471
240
        tmpf = tempfile.TemporaryFile()
472
241
        base_revision = revision.NULL_REVISION
473
 
        serializer.write_bundle(repo, revision_id, base_revision, tmpf)
 
242
        write_bundle(repo, revision_id, base_revision, tmpf)
474
243
        tmpf.seek(0)
475
244
        return SuccessfulSmartServerResponse((), tmpf.read())
476
245
 
490
259
request_handlers.register_lazy(
491
260
    'append', 'bzrlib.smart.vfs', 'AppendRequest')
492
261
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')
503
 
request_handlers.register_lazy(
504
 
    'Branch.get_stacked_on_url', 'bzrlib.smart.branch', 'SmartServerBranchRequestGetStackedOnURL')
 
262
    'Branch.get_config_file', 'bzrlib.smart.branch', 'SmartServerBranchGetConfigFile')
505
263
request_handlers.register_lazy(
506
264
    'Branch.last_revision_info', 'bzrlib.smart.branch', 'SmartServerBranchRequestLastRevisionInfo')
507
265
request_handlers.register_lazy(
508
266
    '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')
515
 
request_handlers.register_lazy(
516
 
    'Branch.set_last_revision_info', 'bzrlib.smart.branch',
517
 
    'SmartServerBranchRequestSetLastRevisionInfo')
518
 
request_handlers.register_lazy(
519
 
    'Branch.set_last_revision_ex', 'bzrlib.smart.branch',
520
 
    'SmartServerBranchRequestSetLastRevisionEx')
521
 
request_handlers.register_lazy(
522
 
    'Branch.set_parent_location', 'bzrlib.smart.branch',
523
 
    'SmartServerBranchRequestSetParentLocation')
 
267
request_handlers.register_lazy(
 
268
    'Branch.revision_history', 'bzrlib.smart.branch', 'SmartServerRequestRevisionHistory')
 
269
request_handlers.register_lazy(
 
270
    'Branch.set_last_revision', 'bzrlib.smart.branch', 'SmartServerBranchRequestSetLastRevision')
524
271
request_handlers.register_lazy(
525
272
    'Branch.unlock', 'bzrlib.smart.branch', 'SmartServerBranchRequestUnlock')
526
273
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')
 
274
    'BzrDir.find_repository', 'bzrlib.smart.bzrdir', 'SmartServerRequestFindRepository')
 
275
request_handlers.register_lazy(
 
276
    'BzrDirFormat.initialize', 'bzrlib.smart.bzrdir', 'SmartServerRequestInitializeBzrDir')
 
277
request_handlers.register_lazy(
 
278
    'BzrDir.open_branch', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBranch')
566
279
request_handlers.register_lazy(
567
280
    'delete', 'bzrlib.smart.vfs', 'DeleteRequest')
568
281
request_handlers.register_lazy(
589
302
    'readv', 'bzrlib.smart.vfs', 'ReadvRequest')
590
303
request_handlers.register_lazy(
591
304
    'rename', 'bzrlib.smart.vfs', 'RenameRequest')
592
 
request_handlers.register_lazy(
593
 
    'PackRepository.autopack', 'bzrlib.smart.packrepository',
594
 
    'SmartServerPackRepositoryAutopack')
595
305
request_handlers.register_lazy('Repository.gather_stats',
596
306
                               'bzrlib.smart.repository',
597
307
                               'SmartServerRepositoryGatherStats')
598
 
request_handlers.register_lazy('Repository.get_parent_map',
599
 
                               'bzrlib.smart.repository',
600
 
                               'SmartServerRepositoryGetParentMap')
601
308
request_handlers.register_lazy(
602
309
    'Repository.get_revision_graph', 'bzrlib.smart.repository', 'SmartServerRepositoryGetRevisionGraph')
603
310
request_handlers.register_lazy(
604
311
    'Repository.has_revision', 'bzrlib.smart.repository', 'SmartServerRequestHasRevision')
605
312
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(
612
313
    'Repository.is_shared', 'bzrlib.smart.repository', 'SmartServerRepositoryIsShared')
613
314
request_handlers.register_lazy(
614
315
    'Repository.lock_write', 'bzrlib.smart.repository', 'SmartServerRepositoryLockWrite')
615
316
request_handlers.register_lazy(
616
 
    'Repository.set_make_working_trees', 'bzrlib.smart.repository',
617
 
    'SmartServerRepositorySetMakeWorkingTrees')
618
 
request_handlers.register_lazy(
619
317
    'Repository.unlock', 'bzrlib.smart.repository', 'SmartServerRepositoryUnlock')
620
318
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
319
    'Repository.tarball', 'bzrlib.smart.repository',
631
320
    'SmartServerRepositoryTarball')
632
321
request_handlers.register_lazy(
635
324
    'stat', 'bzrlib.smart.vfs', 'StatRequest')
636
325
request_handlers.register_lazy(
637
326
    'Transport.is_readonly', 'bzrlib.smart.request', 'SmartServerIsReadonly')
 
327
request_handlers.register_lazy(
 
328
    'BzrDir.open', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBzrDir')