← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/request.py

  • Committer: John Arbash Meinel
  • Date: 2009-07-31 19:56:19 UTC
  • mto: This revision was merged to the branch mainline in revision 4592.
  • Revision ID: john@arbash-meinel.com-20090731195619-xabumey07q2w1fge
Change the Makefile to stage things into a build directory
rather than building inside the tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/request.py
32
32
 
33
33
 
34
34
import tempfile
35
 
import thread
36
35
import threading
37
36
 
38
37
from bzrlib import (
39
38
    bzrdir,
40
 
    debug,
41
39
    errors,
42
 
    osutils,
43
40
    registry,
44
41
    revision,
45
42
    trace,
89
86
    # XXX: rename this class to BaseSmartServerRequestHandler ?  A request
90
87
    # *handler* is a different concept to the request.
91
88
 
92
 
    def __init__(self, backing_transport, root_client_path='/', jail_root=None):
 
89
    def __init__(self, backing_transport, root_client_path='/'):
93
90
        """Constructor.
94
91
 
95
92
        :param backing_transport: the base transport to be used when performing
99
96
            from the client.  Clients will not be able to refer to paths above
100
97
            this root.  If root_client_path is None, then no translation will
101
98
            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
99
        """
105
100
        self._backing_transport = backing_transport
106
 
        if jail_root is None:
107
 
            jail_root = backing_transport
108
 
        self._jail_root = jail_root
109
101
        if root_client_path is not None:
110
102
            if not root_client_path.startswith('/'):
111
103
                root_client_path = '/' + root_client_path
163
155
        return self.do_body(body_bytes)
164
156
 
165
157
    def setup_jail(self):
166
 
        jail_info.transports = [self._jail_root]
 
158
        jail_info.transports = [self._backing_transport]
167
159
 
168
160
    def teardown_jail(self):
169
161
        jail_info.transports = None
191
183
            relpath = urlutils.joinpath('/', path)
192
184
            if not relpath.startswith('/'):
193
185
                raise ValueError(relpath)
194
 
            return urlutils.escape('.' + relpath)
 
186
            return '.' + relpath
195
187
        else:
196
188
            raise errors.PathNotChild(client_path, self._root_client_path)
197
189
 
273
265
    # TODO: Better way of representing the body for commands that take it,
274
266
    # and allow it to be streamed into the server.
275
267
 
276
 
    def __init__(self, backing_transport, commands, root_client_path,
277
 
        jail_root=None):
 
268
    def __init__(self, backing_transport, commands, root_client_path):
278
269
        """Constructor.
279
270
 
280
271
        :param backing_transport: a Transport to handle requests for.
284
275
        self._backing_transport = backing_transport
285
276
        self._root_client_path = root_client_path
286
277
        self._commands = commands
287
 
        if jail_root is None:
288
 
            jail_root = backing_transport
289
 
        self._jail_root = jail_root
290
278
        self.response = None
291
279
        self.finished_reading = False
292
280
        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
281
 
315
282
    def accept_body(self, bytes):
316
283
        """Accept body data."""
318
285
            # no active command object, so ignore the event.
319
286
            return
320
287
        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
288
 
325
289
    def end_of_body(self):
326
290
        """No more body data will be received."""
327
291
        self._run_handler_code(self._command.do_end, (), {})
328
292
        # cannot read after this.
329
293
        self.finished_reading = True
330
 
        if 'hpss' in debug.debug_flags:
331
 
            self._trace('end of body', '', include_time=True)
 
294
 
 
295
    def dispatch_command(self, cmd, args):
 
296
        """Deprecated compatibility method.""" # XXX XXX
 
297
        try:
 
298
            command = self._commands.get(cmd)
 
299
        except LookupError:
 
300
            raise errors.UnknownSmartMethod(cmd)
 
301
        self._command = command(self._backing_transport, self._root_client_path)
 
302
        self._run_handler_code(self._command.execute, args, {})
332
303
 
333
304
    def _run_handler_code(self, callable, args, kwargs):
334
305
        """Run some handler specific code 'callable'.
363
334
 
364
335
    def headers_received(self, headers):
365
336
        # Just a no-op at the moment.
366
 
        if 'hpss' in debug.debug_flags:
367
 
            self._trace('headers', repr(headers))
 
337
        pass
368
338
 
369
339
    def args_received(self, args):
370
340
        cmd = args[0]
372
342
        try:
373
343
            command = self._commands.get(cmd)
374
344
        except LookupError:
375
 
            if 'hpss' in debug.debug_flags:
376
 
                self._trace('hpss unknown request', 
377
 
                            cmd, repr(args)[1:-1])
378
345
            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)
 
346
        self._command = command(self._backing_transport)
389
347
        self._run_handler_code(self._command.execute, args, {})
390
348
 
391
349
    def end_received(self):
393
351
            # no active command object, so ignore the event.
394
352
            return
395
353
        self._run_handler_code(self._command.do_end, (), {})
396
 
        if 'hpss' in debug.debug_flags:
397
 
            self._trace('end', '', include_time=True)
398
354
 
399
355
    def post_body_error_received(self, error_args):
400
356
        # Just a no-op at the moment.
408
364
        return ('FileExists', err.path)
409
365
    elif isinstance(err, errors.DirectoryNotEmpty):
410
366
        return ('DirectoryNotEmpty', err.path)
411
 
    elif isinstance(err, errors.IncompatibleRepositories):
412
 
        return ('IncompatibleRepositories', str(err.source), str(err.target),
413
 
            str(err.details))
414
367
    elif isinstance(err, errors.ShortReadvError):
415
368
        return ('ShortReadvError', err.path, str(err.offset), str(err.length),
416
369
                str(err.actual))
553
506
request_handlers.register_lazy(
554
507
    'BzrDir.open', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBzrDir')
555
508
request_handlers.register_lazy(
556
 
    'BzrDir.open_2.1', 'bzrlib.smart.bzrdir', 'SmartServerRequestOpenBzrDir_2_1')
557
 
request_handlers.register_lazy(
558
509
    'BzrDir.open_branch', 'bzrlib.smart.bzrdir',
559
510
    'SmartServerRequestOpenBranch')
560
511
request_handlers.register_lazy(
602
553
request_handlers.register_lazy(
603
554
    'Repository.insert_stream', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStream')
604
555
request_handlers.register_lazy(
605
 
    'Repository.insert_stream_1.19', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStream_1_19')
606
 
request_handlers.register_lazy(
607
556
    'Repository.insert_stream_locked', 'bzrlib.smart.repository', 'SmartServerRepositoryInsertStreamLocked')
608
557
request_handlers.register_lazy(
609
558
    'Repository.is_shared', 'bzrlib.smart.repository', 'SmartServerRepositoryIsShared')
621
570
    'Repository.get_stream', 'bzrlib.smart.repository',
622
571
    'SmartServerRepositoryGetStream')
623
572
request_handlers.register_lazy(
624
 
    'Repository.get_stream_1.19', 'bzrlib.smart.repository',
625
 
    'SmartServerRepositoryGetStream_1_19')
626
 
request_handlers.register_lazy(
627
573
    'Repository.tarball', 'bzrlib.smart.repository',
628
574
    'SmartServerRepositoryTarball')
629
575
request_handlers.register_lazy(