214
233
while not self.finished:
215
234
server_protocol = self._build_protocol()
216
235
self._serve_one_request(server_protocol)
236
except errors.ConnectionTimeout, e:
237
trace.note('%s' % (e,))
238
trace.log_exception_quietly()
239
self._disconnect_client()
240
# We reported it, no reason to make a big fuss.
217
242
except Exception, e:
218
243
stderr.write("%s terminating on exception %s\n" % (self, e))
245
self._disconnect_client()
247
def _stop_gracefully(self):
248
"""When we finish this message, stop looking for more."""
249
trace.mutter('Stopping %s' % (self,))
252
def _disconnect_client(self):
253
"""Close the current connection. We stopped due to a timeout/etc."""
254
# The default implementation is a no-op, because that is all we used to
255
# do when disconnecting from a client. I suppose we never had the
256
# *server* initiate a disconnect, before
258
def _wait_for_bytes_with_timeout(self, timeout_seconds):
259
"""Wait for more bytes to be read, but timeout if none available.
261
This allows us to detect idle connections, and stop trying to read from
262
them, without setting the socket itself to non-blocking. This also
263
allows us to specify when we watch for idle timeouts.
265
:return: Did we timeout? (True if we timed out, False if there is data
268
raise NotImplementedError(self._wait_for_bytes_with_timeout)
221
270
def _build_protocol(self):
222
271
"""Identifies the version of the incoming request, and returns an
234
287
protocol.accept_bytes(unused_bytes)
290
def _wait_on_descriptor(self, fd, timeout_seconds):
291
"""select() on a file descriptor, waiting for nonblocking read()
293
This will raise a ConnectionTimeout exception if we do not get a
294
readable handle before timeout_seconds.
297
t_end = self._timer() + timeout_seconds
298
poll_timeout = min(timeout_seconds, self._client_poll_timeout)
300
while not rs and not xs and self._timer() < t_end:
304
rs, _, xs = select.select([fd], [], [fd], poll_timeout)
305
except (select.error, socket.error) as e:
306
err = getattr(e, 'errno', None)
307
if err is None and getattr(e, 'args', None) is not None:
308
# select.error doesn't have 'errno', it just has args[0]
310
if err in _bad_file_descriptor:
311
return # Not a socket indicates read() will fail
312
elif err == errno.EINTR:
313
# Interrupted, keep looping.
318
raise errors.ConnectionTimeout('disconnecting client after %.1f seconds'
319
% (timeout_seconds,))
237
321
def _serve_one_request(self, protocol):
238
322
"""Read one request from input, process, send back a response.
240
324
:param protocol: a SmartServerRequestProtocol.
243
329
self._serve_one_request_unguarded(protocol)
244
330
except KeyboardInterrupt:
261
347
class SmartServerSocketStreamMedium(SmartServerStreamMedium):
263
def __init__(self, sock, backing_transport, root_client_path='/'):
349
def __init__(self, sock, backing_transport, root_client_path='/',
266
353
:param sock: the socket the server will read from. It will be put
267
354
into blocking mode.
269
356
SmartServerStreamMedium.__init__(
270
self, backing_transport, root_client_path=root_client_path)
357
self, backing_transport, root_client_path=root_client_path,
271
359
sock.setblocking(True)
272
360
self.socket = sock
361
# Get the getpeername now, as we might be closed later when we care.
363
self._client_info = sock.getpeername()
365
self._client_info = '<unknown>'
368
return '%s(client=%s)' % (self.__class__.__name__, self._client_info)
371
return '%s.%s(client=%s)' % (self.__module__, self.__class__.__name__,
274
374
def _serve_one_request_unguarded(self, protocol):
275
375
while protocol.next_read_size():
285
385
self._push_back(protocol.unused_data)
387
def _disconnect_client(self):
388
"""Close the current connection. We stopped due to a timeout/etc."""
391
def _wait_for_bytes_with_timeout(self, timeout_seconds):
392
"""Wait for more bytes to be read, but timeout if none available.
394
This allows us to detect idle connections, and stop trying to read from
395
them, without setting the socket itself to non-blocking. This also
396
allows us to specify when we watch for idle timeouts.
398
:return: None, this will raise ConnectionTimeout if we time out before
401
return self._wait_on_descriptor(self.socket, timeout_seconds)
287
403
def _read_bytes(self, desired_count):
288
404
return osutils.read_bytes_from_socket(
289
405
self.socket, self._report_activity)
307
423
class SmartServerPipeStreamMedium(SmartServerStreamMedium):
309
def __init__(self, in_file, out_file, backing_transport):
425
def __init__(self, in_file, out_file, backing_transport, timeout=None):
310
426
"""Construct new server.
312
428
:param in_file: Python file from which requests can be read.
313
429
:param out_file: Python file to write responses.
314
430
:param backing_transport: Transport for the directory served.
316
SmartServerStreamMedium.__init__(self, backing_transport)
432
SmartServerStreamMedium.__init__(self, backing_transport,
317
434
if sys.platform == 'win32':
318
435
# force binary mode for files
343
471
protocol.accept_bytes(bytes)
473
def _disconnect_client(self):
478
def _wait_for_bytes_with_timeout(self, timeout_seconds):
479
"""Wait for more bytes to be read, but timeout if none available.
481
This allows us to detect idle connections, and stop trying to read from
482
them, without setting the socket itself to non-blocking. This also
483
allows us to specify when we watch for idle timeouts.
485
:return: None, this will raise ConnectionTimeout if we time out before
488
if (getattr(self._in, 'fileno', None) is None
489
or sys.platform == 'win32'):
490
# You can't select() file descriptors on Windows.
492
return self._wait_on_descriptor(self._in, timeout_seconds)
345
494
def _read_bytes(self, desired_count):
346
495
return self._in.read(desired_count)
491
640
return self._medium._get_line()
643
class _VfsRefuser(object):
644
"""An object that refuses all VFS requests.
649
client._SmartClient.hooks.install_named_hook(
650
'call', self.check_vfs, 'vfs refuser')
652
def check_vfs(self, params):
654
request_method = request.request_handlers.get(params.method)
656
# A method we don't know about doesn't count as a VFS method.
658
if issubclass(request_method, vfs.VfsRequest):
659
raise errors.HpssVfsRequestNotAllowed(params.method, params.args)
494
662
class _DebugCounter(object):
495
663
"""An object that counts the HPSS calls made to each client medium.
497
When a medium is garbage-collected, or failing that when atexit functions
498
are run, the total number of calls made on that medium are reported via
665
When a medium is garbage-collected, or failing that when
666
bzrlib.global_state exits, the total number of calls made on that medium
667
are reported via trace.note.
502
670
def __init__(self):
503
671
self.counts = weakref.WeakKeyDictionary()
504
672
client._SmartClient.hooks.install_named_hook(
505
673
'call', self.increment_call_count, 'hpss call counter')
506
atexit.register(self.flush_all)
674
bzrlib.global_state.cleanups.add_cleanup(self.flush_all)
508
676
def track(self, medium):
509
677
"""Start tracking calls made to a medium.
711
884
return SmartClientStreamMediumRequest(self)
887
"""We have been disconnected, reset current state.
889
This resets things like _current_request and connected state.
892
self._current_request = None
714
895
class SmartSimplePipesClientMedium(SmartClientStreamMedium):
715
896
"""A client medium using simple pipes.
717
898
This client does not manage the pipes: it assumes they will always be open.
719
Note that if readable_pipe.read might raise IOError or OSError with errno
720
of EINTR, it must be safe to retry the read. Plain CPython fileobjects
721
(such as used for sys.stdin) are safe.
724
901
def __init__(self, readable_pipe, writeable_pipe, base):
729
906
def _accept_bytes(self, bytes):
730
907
"""See SmartClientStreamMedium.accept_bytes."""
731
self._writeable_pipe.write(bytes)
909
self._writeable_pipe.write(bytes)
911
if e.errno in (errno.EINVAL, errno.EPIPE):
912
raise errors.ConnectionReset(
913
"Error trying to write to subprocess:\n%s" % (e,))
732
915
self._report_activity(len(bytes), 'write')
734
917
def _flush(self):
735
918
"""See SmartClientStreamMedium._flush()."""
919
# Note: If flush were to fail, we'd like to raise ConnectionReset, etc.
920
# However, testing shows that even when the child process is
921
# gone, this doesn't error.
736
922
self._writeable_pipe.flush()
738
924
def _read_bytes(self, count):
739
925
"""See SmartClientStreamMedium._read_bytes."""
740
bytes = osutils.until_no_eintr(self._readable_pipe.read, count)
926
bytes_to_read = min(count, _MAX_READ_SIZE)
927
bytes = self._readable_pipe.read(bytes_to_read)
741
928
self._report_activity(len(bytes), 'read')
932
class SSHParams(object):
933
"""A set of parameters for starting a remote bzr via SSH."""
935
def __init__(self, host, port=None, username=None, password=None,
936
bzr_remote_path='bzr'):
939
self.username = username
940
self.password = password
941
self.bzr_remote_path = bzr_remote_path
745
944
class SmartSSHClientMedium(SmartClientStreamMedium):
746
"""A client medium using SSH."""
748
def __init__(self, host, port=None, username=None, password=None,
749
base=None, vendor=None, bzr_remote_path=None):
945
"""A client medium using SSH.
947
It delegates IO to a SmartSimplePipesClientMedium or
948
SmartClientAlreadyConnectedSocketMedium (depending on platform).
951
def __init__(self, base, ssh_params, vendor=None):
750
952
"""Creates a client that will connect on the first use.
954
:param ssh_params: A SSHParams instance.
752
955
:param vendor: An optional override for the ssh vendor to use. See
753
956
bzrlib.transport.ssh for details on ssh vendors.
755
self._connected = False
757
self._password = password
759
self._username = username
958
self._real_medium = None
959
self._ssh_params = ssh_params
760
960
# for the benefit of progress making a short description of this
762
962
self._scheme = 'bzr+ssh'
764
964
# _DebugCounter so we have to store all the values used in our repr
765
965
# method before calling the super init.
766
966
SmartClientStreamMedium.__init__(self, base)
767
self._read_from = None
967
self._vendor = vendor
768
968
self._ssh_connection = None
769
self._vendor = vendor
770
self._write_to = None
771
self._bzr_remote_path = bzr_remote_path
773
970
def __repr__(self):
774
if self._port is None:
971
if self._ssh_params.port is None:
777
maybe_port = ':%s' % self._port
778
return "%s(%s://%s@%s%s/)" % (
974
maybe_port = ':%s' % self._ssh_params.port
975
if self._ssh_params.username is None:
978
maybe_user = '%s@' % self._ssh_params.username
979
return "%s(%s://%s%s%s/)" % (
779
980
self.__class__.__name__,
983
self._ssh_params.host,
785
986
def _accept_bytes(self, bytes):
786
987
"""See SmartClientStreamMedium.accept_bytes."""
787
988
self._ensure_connection()
788
self._write_to.write(bytes)
789
self._report_activity(len(bytes), 'write')
989
self._real_medium.accept_bytes(bytes)
791
991
def disconnect(self):
792
992
"""See SmartClientMedium.disconnect()."""
793
if not self._connected:
795
self._read_from.close()
796
self._write_to.close()
797
self._ssh_connection.close()
798
self._connected = False
993
if self._real_medium is not None:
994
self._real_medium.disconnect()
995
self._real_medium = None
996
if self._ssh_connection is not None:
997
self._ssh_connection.close()
998
self._ssh_connection = None
800
1000
def _ensure_connection(self):
801
1001
"""Connect this medium if not already connected."""
1002
if self._real_medium is not None:
804
1004
if self._vendor is None:
805
1005
vendor = ssh._get_ssh_vendor()
807
1007
vendor = self._vendor
808
self._ssh_connection = vendor.connect_ssh(self._username,
809
self._password, self._host, self._port,
810
command=[self._bzr_remote_path, 'serve', '--inet',
1008
self._ssh_connection = vendor.connect_ssh(self._ssh_params.username,
1009
self._ssh_params.password, self._ssh_params.host,
1010
self._ssh_params.port,
1011
command=[self._ssh_params.bzr_remote_path, 'serve', '--inet',
811
1012
'--directory=/', '--allow-writes'])
812
self._read_from, self._write_to = \
813
self._ssh_connection.get_filelike_channels()
814
self._connected = True
1013
io_kind, io_object = self._ssh_connection.get_sock_or_pipes()
1014
if io_kind == 'socket':
1015
self._real_medium = SmartClientAlreadyConnectedSocketMedium(
1016
self.base, io_object)
1017
elif io_kind == 'pipes':
1018
read_from, write_to = io_object
1019
self._real_medium = SmartSimplePipesClientMedium(
1020
read_from, write_to, self.base)
1022
raise AssertionError(
1023
"Unexpected io_kind %r from %r"
1024
% (io_kind, self._ssh_connection))
1025
for hook in transport.Transport.hooks["post_connect"]:
816
1028
def _flush(self):
817
1029
"""See SmartClientStreamMedium._flush()."""
818
self._write_to.flush()
1030
self._real_medium._flush()
820
1032
def _read_bytes(self, count):
821
1033
"""See SmartClientStreamMedium.read_bytes."""
822
if not self._connected:
1034
if self._real_medium is None:
823
1035
raise errors.MediumNotConnected(self)
824
bytes_to_read = min(count, _MAX_READ_SIZE)
825
bytes = self._read_from.read(bytes_to_read)
826
self._report_activity(len(bytes), 'read')
1036
return self._real_medium.read_bytes(count)
830
1039
# Port 4155 is the default port for bzr://, registered with IANA.
832
1041
BZR_DEFAULT_PORT = 4155
835
class SmartTCPClientMedium(SmartClientStreamMedium):
836
"""A client medium using TCP."""
1044
class SmartClientSocketMedium(SmartClientStreamMedium):
1045
"""A client medium using a socket.
1047
This class isn't usable directly. Use one of its subclasses instead.
838
def __init__(self, host, port, base):
839
"""Creates a client that will connect on the first use."""
1050
def __init__(self, base):
840
1051
SmartClientStreamMedium.__init__(self, base)
841
1053
self._connected = False
846
1055
def _accept_bytes(self, bytes):
847
1056
"""See SmartClientMedium.accept_bytes."""
848
1057
self._ensure_connection()
849
1058
osutils.send_all(self._socket, bytes, self._report_activity)
1060
def _ensure_connection(self):
1061
"""Connect this medium if not already connected."""
1062
raise NotImplementedError(self._ensure_connection)
1065
"""See SmartClientStreamMedium._flush().
1067
For sockets we do no flushing. For TCP sockets we may want to turn off
1068
TCP_NODELAY and add a means to do a flush, but that can be done in the
1072
def _read_bytes(self, count):
1073
"""See SmartClientMedium.read_bytes."""
1074
if not self._connected:
1075
raise errors.MediumNotConnected(self)
1076
return osutils.read_bytes_from_socket(
1077
self._socket, self._report_activity)
851
1079
def disconnect(self):
852
1080
"""See SmartClientMedium.disconnect()."""
853
1081
if not self._connected:
894
1132
raise errors.ConnectionError("failed to connect to %s:%d: %s" %
895
1133
(self._host, port, err_msg))
896
1134
self._connected = True
899
"""See SmartClientStreamMedium._flush().
901
For TCP we do no flushing. We may want to turn off TCP_NODELAY and
902
add a means to do a flush, but that can be done in the future.
905
def _read_bytes(self, count):
906
"""See SmartClientMedium.read_bytes."""
907
if not self._connected:
908
raise errors.MediumNotConnected(self)
909
return osutils.read_bytes_from_socket(
910
self._socket, self._report_activity)
1135
for hook in transport.Transport.hooks["post_connect"]:
1139
class SmartClientAlreadyConnectedSocketMedium(SmartClientSocketMedium):
1140
"""A client medium for an already connected socket.
1142
Note that this class will assume it "owns" the socket, so it will close it
1143
when its disconnect method is called.
1146
def __init__(self, base, sock):
1147
SmartClientSocketMedium.__init__(self, base)
1149
self._connected = True
1151
def _ensure_connection(self):
1152
# Already connected, by definition! So nothing to do.
913
1156
class SmartClientStreamMediumRequest(SmartClientMediumRequest):
added
removed
bzrlib/smart/medium.py
