214
231
while not self.finished:
215
232
server_protocol = self._build_protocol()
216
233
self._serve_one_request(server_protocol)
234
except errors.ConnectionTimeout, e:
235
trace.note('%s' % (e,))
236
trace.log_exception_quietly()
237
self._disconnect_client()
238
# We reported it, no reason to make a big fuss.
217
240
except Exception, e:
218
241
stderr.write("%s terminating on exception %s\n" % (self, e))
243
self._disconnect_client()
245
def _stop_gracefully(self):
246
"""When we finish this message, stop looking for more."""
247
trace.mutter('Stopping %s' % (self,))
250
def _disconnect_client(self):
251
"""Close the current connection. We stopped due to a timeout/etc."""
252
# The default implementation is a no-op, because that is all we used to
253
# do when disconnecting from a client. I suppose we never had the
254
# *server* initiate a disconnect, before
256
def _wait_for_bytes_with_timeout(self, timeout_seconds):
257
"""Wait for more bytes to be read, but timeout if none available.
259
This allows us to detect idle connections, and stop trying to read from
260
them, without setting the socket itself to non-blocking. This also
261
allows us to specify when we watch for idle timeouts.
263
:return: Did we timeout? (True if we timed out, False if there is data
266
raise NotImplementedError(self._wait_for_bytes_with_timeout)
221
268
def _build_protocol(self):
222
269
"""Identifies the version of the incoming request, and returns an
234
285
protocol.accept_bytes(unused_bytes)
288
def _wait_on_descriptor(self, fd, timeout_seconds):
289
"""select() on a file descriptor, waiting for nonblocking read()
291
This will raise a ConnectionTimeout exception if we do not get a
292
readable handle before timeout_seconds.
295
t_end = self._timer() + timeout_seconds
296
poll_timeout = min(timeout_seconds, self._client_poll_timeout)
298
while not rs and not xs and self._timer() < t_end:
302
rs, _, xs = select.select([fd], [], [fd], poll_timeout)
303
except (select.error, socket.error) as e:
304
err = getattr(e, 'errno', None)
305
if err is None and getattr(e, 'args', None) is not None:
306
# select.error doesn't have 'errno', it just has args[0]
308
if err in _bad_file_descriptor:
309
return # Not a socket indicates read() will fail
310
elif err == errno.EINTR:
311
# Interrupted, keep looping.
316
raise errors.ConnectionTimeout('disconnecting client after %.1f seconds'
317
% (timeout_seconds,))
237
319
def _serve_one_request(self, protocol):
238
320
"""Read one request from input, process, send back a response.
240
322
:param protocol: a SmartServerRequestProtocol.
243
327
self._serve_one_request_unguarded(protocol)
244
328
except KeyboardInterrupt:
261
345
class SmartServerSocketStreamMedium(SmartServerStreamMedium):
263
def __init__(self, sock, backing_transport, root_client_path='/'):
347
def __init__(self, sock, backing_transport, root_client_path='/',
266
351
:param sock: the socket the server will read from. It will be put
267
352
into blocking mode.
269
354
SmartServerStreamMedium.__init__(
270
self, backing_transport, root_client_path=root_client_path)
355
self, backing_transport, root_client_path=root_client_path,
271
357
sock.setblocking(True)
272
358
self.socket = sock
359
# Get the getpeername now, as we might be closed later when we care.
361
self._client_info = sock.getpeername()
363
self._client_info = '<unknown>'
366
return '%s(client=%s)' % (self.__class__.__name__, self._client_info)
369
return '%s.%s(client=%s)' % (self.__module__, self.__class__.__name__,
274
372
def _serve_one_request_unguarded(self, protocol):
275
373
while protocol.next_read_size():
285
383
self._push_back(protocol.unused_data)
385
def _disconnect_client(self):
386
"""Close the current connection. We stopped due to a timeout/etc."""
389
def _wait_for_bytes_with_timeout(self, timeout_seconds):
390
"""Wait for more bytes to be read, but timeout if none available.
392
This allows us to detect idle connections, and stop trying to read from
393
them, without setting the socket itself to non-blocking. This also
394
allows us to specify when we watch for idle timeouts.
396
:return: None, this will raise ConnectionTimeout if we time out before
399
return self._wait_on_descriptor(self.socket, timeout_seconds)
287
401
def _read_bytes(self, desired_count):
288
402
return osutils.read_bytes_from_socket(
289
403
self.socket, self._report_activity)
307
421
class SmartServerPipeStreamMedium(SmartServerStreamMedium):
309
def __init__(self, in_file, out_file, backing_transport):
423
def __init__(self, in_file, out_file, backing_transport, timeout=None):
310
424
"""Construct new server.
312
426
:param in_file: Python file from which requests can be read.
313
427
:param out_file: Python file to write responses.
314
428
:param backing_transport: Transport for the directory served.
316
SmartServerStreamMedium.__init__(self, backing_transport)
430
SmartServerStreamMedium.__init__(self, backing_transport,
317
432
if sys.platform == 'win32':
318
433
# force binary mode for files
343
469
protocol.accept_bytes(bytes)
471
def _disconnect_client(self):
476
def _wait_for_bytes_with_timeout(self, timeout_seconds):
477
"""Wait for more bytes to be read, but timeout if none available.
479
This allows us to detect idle connections, and stop trying to read from
480
them, without setting the socket itself to non-blocking. This also
481
allows us to specify when we watch for idle timeouts.
483
:return: None, this will raise ConnectionTimeout if we time out before
486
if (getattr(self._in, 'fileno', None) is None
487
or sys.platform == 'win32'):
488
# You can't select() file descriptors on Windows.
490
return self._wait_on_descriptor(self._in, timeout_seconds)
345
492
def _read_bytes(self, desired_count):
346
493
return self._in.read(desired_count)
491
638
return self._medium._get_line()
641
class _VfsRefuser(object):
642
"""An object that refuses all VFS requests.
647
client._SmartClient.hooks.install_named_hook(
648
'call', self.check_vfs, 'vfs refuser')
650
def check_vfs(self, params):
652
request_method = request.request_handlers.get(params.method)
654
# A method we don't know about doesn't count as a VFS method.
656
if issubclass(request_method, vfs.VfsRequest):
657
raise errors.HpssVfsRequestNotAllowed(params.method, params.args)
494
660
class _DebugCounter(object):
495
661
"""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
663
When a medium is garbage-collected, or failing that when
664
bzrlib.global_state exits, the total number of calls made on that medium
665
are reported via trace.note.
502
668
def __init__(self):
503
669
self.counts = weakref.WeakKeyDictionary()
504
670
client._SmartClient.hooks.install_named_hook(
505
671
'call', self.increment_call_count, 'hpss call counter')
506
atexit.register(self.flush_all)
672
bzrlib.global_state.cleanups.add_cleanup(self.flush_all)
508
674
def track(self, medium):
509
675
"""Start tracking calls made to a medium.
738
905
def _read_bytes(self, count):
739
906
"""See SmartClientStreamMedium._read_bytes."""
740
bytes = osutils.until_no_eintr(self._readable_pipe.read, count)
907
bytes_to_read = min(count, _MAX_READ_SIZE)
908
bytes = self._readable_pipe.read(bytes_to_read)
741
909
self._report_activity(len(bytes), 'read')
913
class SSHParams(object):
914
"""A set of parameters for starting a remote bzr via SSH."""
916
def __init__(self, host, port=None, username=None, password=None,
917
bzr_remote_path='bzr'):
920
self.username = username
921
self.password = password
922
self.bzr_remote_path = bzr_remote_path
745
925
class SmartSSHClientMedium(SmartClientStreamMedium):
746
"""A client medium using SSH."""
926
"""A client medium using SSH.
928
It delegates IO to a SmartClientSocketMedium or
929
SmartClientAlreadyConnectedSocketMedium (depending on platform).
748
def __init__(self, host, port=None, username=None, password=None,
749
base=None, vendor=None, bzr_remote_path=None):
932
def __init__(self, base, ssh_params, vendor=None):
750
933
"""Creates a client that will connect on the first use.
935
:param ssh_params: A SSHParams instance.
752
936
:param vendor: An optional override for the ssh vendor to use. See
753
937
bzrlib.transport.ssh for details on ssh vendors.
755
self._connected = False
757
self._password = password
759
self._username = username
939
self._real_medium = None
940
self._ssh_params = ssh_params
760
941
# for the benefit of progress making a short description of this
762
943
self._scheme = 'bzr+ssh'
764
945
# _DebugCounter so we have to store all the values used in our repr
765
946
# method before calling the super init.
766
947
SmartClientStreamMedium.__init__(self, base)
767
self._read_from = None
948
self._vendor = vendor
768
949
self._ssh_connection = None
769
self._vendor = vendor
770
self._write_to = None
771
self._bzr_remote_path = bzr_remote_path
773
951
def __repr__(self):
774
if self._port is None:
952
if self._ssh_params.port is None:
777
maybe_port = ':%s' % self._port
778
return "%s(%s://%s@%s%s/)" % (
955
maybe_port = ':%s' % self._ssh_params.port
956
if self._ssh_params.username is None:
959
maybe_user = '%s@' % self._ssh_params.username
960
return "%s(%s://%s%s%s/)" % (
779
961
self.__class__.__name__,
964
self._ssh_params.host,
785
967
def _accept_bytes(self, bytes):
786
968
"""See SmartClientStreamMedium.accept_bytes."""
787
969
self._ensure_connection()
788
self._write_to.write(bytes)
789
self._report_activity(len(bytes), 'write')
970
self._real_medium.accept_bytes(bytes)
791
972
def disconnect(self):
792
973
"""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
974
if self._real_medium is not None:
975
self._real_medium.disconnect()
976
self._real_medium = None
977
if self._ssh_connection is not None:
978
self._ssh_connection.close()
979
self._ssh_connection = None
800
981
def _ensure_connection(self):
801
982
"""Connect this medium if not already connected."""
983
if self._real_medium is not None:
804
985
if self._vendor is None:
805
986
vendor = ssh._get_ssh_vendor()
807
988
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',
989
self._ssh_connection = vendor.connect_ssh(self._ssh_params.username,
990
self._ssh_params.password, self._ssh_params.host,
991
self._ssh_params.port,
992
command=[self._ssh_params.bzr_remote_path, 'serve', '--inet',
811
993
'--directory=/', '--allow-writes'])
812
self._read_from, self._write_to = \
813
self._ssh_connection.get_filelike_channels()
814
self._connected = True
994
io_kind, io_object = self._ssh_connection.get_sock_or_pipes()
995
if io_kind == 'socket':
996
self._real_medium = SmartClientAlreadyConnectedSocketMedium(
997
self.base, io_object)
998
elif io_kind == 'pipes':
999
read_from, write_to = io_object
1000
self._real_medium = SmartSimplePipesClientMedium(
1001
read_from, write_to, self.base)
1003
raise AssertionError(
1004
"Unexpected io_kind %r from %r"
1005
% (io_kind, self._ssh_connection))
816
1007
def _flush(self):
817
1008
"""See SmartClientStreamMedium._flush()."""
818
self._write_to.flush()
1009
self._real_medium._flush()
820
1011
def _read_bytes(self, count):
821
1012
"""See SmartClientStreamMedium.read_bytes."""
822
if not self._connected:
1013
if self._real_medium is None:
823
1014
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')
1015
return self._real_medium.read_bytes(count)
830
1018
# Port 4155 is the default port for bzr://, registered with IANA.
832
1020
BZR_DEFAULT_PORT = 4155
835
class SmartTCPClientMedium(SmartClientStreamMedium):
836
"""A client medium using TCP."""
1023
class SmartClientSocketMedium(SmartClientStreamMedium):
1024
"""A client medium using a socket.
1026
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."""
1029
def __init__(self, base):
840
1030
SmartClientStreamMedium.__init__(self, base)
841
1032
self._connected = False
846
1034
def _accept_bytes(self, bytes):
847
1035
"""See SmartClientMedium.accept_bytes."""
848
1036
self._ensure_connection()
849
1037
osutils.send_all(self._socket, bytes, self._report_activity)
1039
def _ensure_connection(self):
1040
"""Connect this medium if not already connected."""
1041
raise NotImplementedError(self._ensure_connection)
1044
"""See SmartClientStreamMedium._flush().
1046
For sockets we do no flushing. For TCP sockets we may want to turn off
1047
TCP_NODELAY and add a means to do a flush, but that can be done in the
1051
def _read_bytes(self, count):
1052
"""See SmartClientMedium.read_bytes."""
1053
if not self._connected:
1054
raise errors.MediumNotConnected(self)
1055
return osutils.read_bytes_from_socket(
1056
self._socket, self._report_activity)
851
1058
def disconnect(self):
852
1059
"""See SmartClientMedium.disconnect()."""
853
1060
if not self._connected:
895
1112
(self._host, port, err_msg))
896
1113
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)
1116
class SmartClientAlreadyConnectedSocketMedium(SmartClientSocketMedium):
1117
"""A client medium for an already connected socket.
1119
Note that this class will assume it "owns" the socket, so it will close it
1120
when its disconnect method is called.
1123
def __init__(self, base, sock):
1124
SmartClientSocketMedium.__init__(self, base)
1126
self._connected = True
1128
def _ensure_connection(self):
1129
# Already connected, by definition! So nothing to do.
913
1133
class SmartClientStreamMediumRequest(SmartClientMediumRequest):
added
removed
bzrlib/smart/medium.py
