« back to all changes in this revision
Viewing changes to bzrlib/transport/remote.py
- browse files at revision 2018.5.136
- compare with another revision
- compare with revision 5439.1.1
- download diff
- download tarball
- view history from revision 2018.5.136
- Committer: Andrew Bennetts
- Date: 2007-04-05 04:46:49 UTC
- mto: (2018.18.11 hpss-faster-copy)
- mto: This revision was merged to the branch mainline in revision 2435.
- Revision ID: andrew.bennetts@canonical.com-20070405044649-6w32o4u1im56i7kr
Remote duplicated SmartServerRequestHandler from bzrlib/transport/remote.py; we use the one in bzrlib/smart/request.py now.
- files modified:
- bzrlib/transport/remote.py
added
removed
bzrlib/transport/remote.py
40
40
urlutils,
41
41
)
42
42
from bzrlib.bundle.serializer import write_bundle
43
from bzrlib.smart import client, medium, protocol
43
from bzrlib.smart import client, medium, protocol, SmartServerRequestHandler
44
44
45
45
# must do this otherwise urllib can't parse the urls properly :(
46
46
for scheme in ['ssh', 'bzr', 'bzr+loopback', 'bzr+ssh', 'bzr+http']:
116
116
first_line, self.in_buffer = self.in_buffer.split('\n', 1)
117
117
first_line += '\n'
118
118
req_args = _decode_tuple(first_line)
119
self.request = SmartServerRequestHandler(
119
self.request = request.SmartServerRequestHandler(
120
120
self._backing_transport)
121
121
self.request.dispatch_command(req_args[0], req_args[1:])
122
122
if self.request.finished_reading:
411
411
self.args = args
412
412
self.body = body
413
413
414
# XXX: TODO: Create a SmartServerRequestHandler which will take the responsibility
415
# for delivering the data for a request. This could be done with as the
416
# StreamServer, though that would create conflation between request and response
417
# which may be undesirable.
418
419
420
class SmartServerRequestHandler(object):
421
"""Protocol logic for smart server.
422
423
This doesn't handle serialization at all, it just processes requests and
424
creates responses.
425
"""
426
427
# IMPORTANT FOR IMPLEMENTORS: It is important that SmartServerRequestHandler
428
# not contain encoding or decoding logic to allow the wire protocol to vary
429
# from the object protocol: we will want to tweak the wire protocol separate
430
# from the object model, and ideally we will be able to do that without
431
# having a SmartServerRequestHandler subclass for each wire protocol, rather
432
# just a Protocol subclass.
433
434
# TODO: Better way of representing the body for commands that take it,
435
# and allow it to be streamed into the server.
436
437
def __init__(self, backing_transport):
438
self._backing_transport = backing_transport
439
self._converted_command = False
440
self.finished_reading = False
441
self._body_bytes = ''
442
self.response = None
443
444
def accept_body(self, bytes):
445
"""Accept body data.
446
447
This should be overriden for each command that desired body data to
448
handle the right format of that data. I.e. plain bytes, a bundle etc.
449
450
The deserialisation into that format should be done in the Protocol
451
object. Set self.desired_body_format to the format your method will
452
handle.
453
"""
454
# default fallback is to accumulate bytes.
455
self._body_bytes += bytes
456
457
def _end_of_body_handler(self):
458
"""An unimplemented end of body handler."""
459
raise NotImplementedError(self._end_of_body_handler)
460
461
def do_hello(self):
462
"""Answer a version request with my version."""
463
return SmartServerResponse(('ok', '1'))
464
465
def do_has(self, relpath):
466
r = self._backing_transport.has(relpath) and 'yes' or 'no'
467
return SmartServerResponse((r,))
468
469
def do_get(self, relpath):
470
backing_bytes = self._backing_transport.get_bytes(relpath)
471
return SmartServerResponse(('ok',), backing_bytes)
472
473
def _deserialise_optional_mode(self, mode):
474
# XXX: FIXME this should be on the protocol object.
475
if mode == '':
476
return None
477
else:
478
return int(mode)
479
480
def do_append(self, relpath, mode):
481
self._converted_command = True
482
self._relpath = relpath
483
self._mode = self._deserialise_optional_mode(mode)
484
self._end_of_body_handler = self._handle_do_append_end
485
486
def _handle_do_append_end(self):
487
old_length = self._backing_transport.append_bytes(
488
self._relpath, self._body_bytes, self._mode)
489
self.response = SmartServerResponse(('appended', '%d' % old_length))
490
491
def do_delete(self, relpath):
492
self._backing_transport.delete(relpath)
493
494
def do_iter_files_recursive(self, relpath):
495
transport = self._backing_transport.clone(relpath)
496
filenames = transport.iter_files_recursive()
497
return SmartServerResponse(('names',) + tuple(filenames))
498
499
def do_list_dir(self, relpath):
500
filenames = self._backing_transport.list_dir(relpath)
501
return SmartServerResponse(('names',) + tuple(filenames))
502
503
def do_mkdir(self, relpath, mode):
504
self._backing_transport.mkdir(relpath,
505
self._deserialise_optional_mode(mode))
506
507
def do_move(self, rel_from, rel_to):
508
self._backing_transport.move(rel_from, rel_to)
509
510
def do_put(self, relpath, mode):
511
self._converted_command = True
512
self._relpath = relpath
513
self._mode = self._deserialise_optional_mode(mode)
514
self._end_of_body_handler = self._handle_do_put
515
516
def _handle_do_put(self):
517
self._backing_transport.put_bytes(self._relpath,
518
self._body_bytes, self._mode)
519
self.response = SmartServerResponse(('ok',))
520
521
def _deserialise_offsets(self, text):
522
# XXX: FIXME this should be on the protocol object.
523
offsets = []
524
for line in text.split('\n'):
525
if not line:
526
continue
527
start, length = line.split(',')
528
offsets.append((int(start), int(length)))
529
return offsets
530
531
def do_put_non_atomic(self, relpath, mode, create_parent, dir_mode):
532
self._converted_command = True
533
self._end_of_body_handler = self._handle_put_non_atomic
534
self._relpath = relpath
535
self._dir_mode = self._deserialise_optional_mode(dir_mode)
536
self._mode = self._deserialise_optional_mode(mode)
537
# a boolean would be nicer XXX
538
self._create_parent = (create_parent == 'T')
539
540
def _handle_put_non_atomic(self):
541
self._backing_transport.put_bytes_non_atomic(self._relpath,
542
self._body_bytes,
543
mode=self._mode,
544
create_parent_dir=self._create_parent,
545
dir_mode=self._dir_mode)
546
self.response = SmartServerResponse(('ok',))
547
548
def do_readv(self, relpath):
549
self._converted_command = True
550
self._end_of_body_handler = self._handle_readv_offsets
551
self._relpath = relpath
552
553
def end_of_body(self):
554
"""No more body data will be received."""
555
self._run_handler_code(self._end_of_body_handler, (), {})
556
# cannot read after this.
557
self.finished_reading = True
558
559
def _handle_readv_offsets(self):
560
"""accept offsets for a readv request."""
561
offsets = self._deserialise_offsets(self._body_bytes)
562
backing_bytes = ''.join(bytes for offset, bytes in
563
self._backing_transport.readv(self._relpath, offsets))
564
self.response = SmartServerResponse(('readv',), backing_bytes)
565
566
def do_rename(self, rel_from, rel_to):
567
self._backing_transport.rename(rel_from, rel_to)
568
569
def do_rmdir(self, relpath):
570
self._backing_transport.rmdir(relpath)
571
572
def do_stat(self, relpath):
573
stat = self._backing_transport.stat(relpath)
574
return SmartServerResponse(('stat', str(stat.st_size), oct(stat.st_mode)))
575
576
def do_get_bundle(self, path, revision_id):
577
# open transport relative to our base
578
t = self._backing_transport.clone(path)
579
control, extra_path = bzrdir.BzrDir.open_containing_from_transport(t)
580
repo = control.open_repository()
581
tmpf = tempfile.TemporaryFile()
582
base_revision = revision.NULL_REVISION
583
write_bundle(repo, revision_id, base_revision, tmpf)
584
tmpf.seek(0)
585
return SmartServerResponse((), tmpf.read())
586
587
def dispatch_command(self, cmd, args):
588
"""Deprecated compatibility method.""" # XXX XXX
589
func = getattr(self, 'do_' + cmd, None)
590
if func is None:
591
raise errors.SmartProtocolError("bad request %r" % (cmd,))
592
self._run_handler_code(func, args, {})
593
594
def _run_handler_code(self, callable, args, kwargs):
595
"""Run some handler specific code 'callable'.
596
597
If a result is returned, it is considered to be the commands response,
598
and finished_reading is set true, and its assigned to self.response.
599
600
Any exceptions caught are translated and a response object created
601
from them.
602
"""
603
result = self._call_converting_errors(callable, args, kwargs)
604
if result is not None:
605
self.response = result
606
self.finished_reading = True
607
# handle unconverted commands
608
if not self._converted_command:
609
self.finished_reading = True
610
if result is None:
611
self.response = SmartServerResponse(('ok',))
612
613
def _call_converting_errors(self, callable, args, kwargs):
614
"""Call callable converting errors to Response objects."""
615
try:
616
return callable(*args, **kwargs)
617
except errors.NoSuchFile, e:
618
return SmartServerResponse(('NoSuchFile', e.path))
619
except errors.FileExists, e:
620
return SmartServerResponse(('FileExists', e.path))
621
except errors.DirectoryNotEmpty, e:
622
return SmartServerResponse(('DirectoryNotEmpty', e.path))
623
except errors.ShortReadvError, e:
624
return SmartServerResponse(('ShortReadvError',
625
e.path, str(e.offset), str(e.length), str(e.actual)))
626
except UnicodeError, e:
627
# If it is a DecodeError, than most likely we are starting
628
# with a plain string
629
str_or_unicode = e.object
630
if isinstance(str_or_unicode, unicode):
631
# XXX: UTF-8 might have \x01 (our seperator byte) in it. We
632
# should escape it somehow.
633
val = 'u:' + str_or_unicode.encode('utf-8')
634
else:
635
val = 's:' + str_or_unicode.encode('base64')
636
# This handles UnicodeEncodeError or UnicodeDecodeError
637
return SmartServerResponse((e.__class__.__name__,
638
e.encoding, val, str(e.start), str(e.end), e.reason))
639
except errors.TransportNotPossible, e:
640
if e.msg == "readonly transport":
641
return SmartServerResponse(('ReadOnlyError', ))
642
else:
643
raise
644
645
414
646
415
class SmartTCPServer(object):
647
416
"""Listens on a TCP socket and accepts connections from smart clients"""
Loggerhead is a web-based interface for Breezy
Version: 2.0.1