231
214
while not self.finished:
232
215
server_protocol = self._build_protocol()
233
# TODO: This seems inelegant:
234
if server_protocol is None:
235
# We could 'continue' only to notice that self.finished is
238
216
self._serve_one_request(server_protocol)
239
except errors.ConnectionTimeout, e:
240
trace.note('%s' % (e,))
241
trace.log_exception_quietly()
242
self._disconnect_client()
243
# We reported it, no reason to make a big fuss.
245
217
except Exception, e:
246
218
stderr.write("%s terminating on exception %s\n" % (self, e))
248
self._disconnect_client()
250
def _stop_gracefully(self):
251
"""When we finish this message, stop looking for more."""
252
trace.mutter('Stopping %s' % (self,))
255
def _disconnect_client(self):
256
"""Close the current connection. We stopped due to a timeout/etc."""
257
# The default implementation is a no-op, because that is all we used to
258
# do when disconnecting from a client. I suppose we never had the
259
# *server* initiate a disconnect, before
261
def _wait_for_bytes_with_timeout(self, timeout_seconds):
262
"""Wait for more bytes to be read, but timeout if none available.
264
This allows us to detect idle connections, and stop trying to read from
265
them, without setting the socket itself to non-blocking. This also
266
allows us to specify when we watch for idle timeouts.
268
:return: Did we timeout? (True if we timed out, False if there is data
271
raise NotImplementedError(self._wait_for_bytes_with_timeout)
273
221
def _build_protocol(self):
274
222
"""Identifies the version of the incoming request, and returns an
290
234
protocol.accept_bytes(unused_bytes)
293
def _wait_on_descriptor(self, fd, timeout_seconds):
294
"""select() on a file descriptor, waiting for nonblocking read()
296
This will raise a ConnectionTimeout exception if we do not get a
297
readable handle before timeout_seconds.
300
t_end = self._timer() + timeout_seconds
301
poll_timeout = min(timeout_seconds, self._client_poll_timeout)
303
while not rs and not xs and self._timer() < t_end:
307
rs, _, xs = select.select([fd], [], [fd], poll_timeout)
308
except (select.error, socket.error) as e:
309
err = getattr(e, 'errno', None)
310
if err is None and getattr(e, 'args', None) is not None:
311
# select.error doesn't have 'errno', it just has args[0]
313
if err in _bad_file_descriptor:
314
return # Not a socket indicates read() will fail
315
elif err == errno.EINTR:
316
# Interrupted, keep looping.
321
raise errors.ConnectionTimeout('disconnecting client after %.1f seconds'
322
% (timeout_seconds,))
324
237
def _serve_one_request(self, protocol):
325
238
"""Read one request from input, process, send back a response.
348
261
class SmartServerSocketStreamMedium(SmartServerStreamMedium):
350
def __init__(self, sock, backing_transport, root_client_path='/',
263
def __init__(self, sock, backing_transport, root_client_path='/'):
354
266
:param sock: the socket the server will read from. It will be put
355
267
into blocking mode.
357
269
SmartServerStreamMedium.__init__(
358
self, backing_transport, root_client_path=root_client_path,
270
self, backing_transport, root_client_path=root_client_path)
360
271
sock.setblocking(True)
361
272
self.socket = sock
362
# Get the getpeername now, as we might be closed later when we care.
364
self._client_info = sock.getpeername()
366
self._client_info = '<unknown>'
369
return '%s(client=%s)' % (self.__class__.__name__, self._client_info)
372
return '%s.%s(client=%s)' % (self.__module__, self.__class__.__name__,
375
274
def _serve_one_request_unguarded(self, protocol):
376
275
while protocol.next_read_size():
386
285
self._push_back(protocol.unused_data)
388
def _disconnect_client(self):
389
"""Close the current connection. We stopped due to a timeout/etc."""
392
def _wait_for_bytes_with_timeout(self, timeout_seconds):
393
"""Wait for more bytes to be read, but timeout if none available.
395
This allows us to detect idle connections, and stop trying to read from
396
them, without setting the socket itself to non-blocking. This also
397
allows us to specify when we watch for idle timeouts.
399
:return: None, this will raise ConnectionTimeout if we time out before
402
return self._wait_on_descriptor(self.socket, timeout_seconds)
404
287
def _read_bytes(self, desired_count):
405
288
return osutils.read_bytes_from_socket(
406
289
self.socket, self._report_activity)
424
307
class SmartServerPipeStreamMedium(SmartServerStreamMedium):
426
def __init__(self, in_file, out_file, backing_transport, timeout=None):
309
def __init__(self, in_file, out_file, backing_transport):
427
310
"""Construct new server.
429
312
:param in_file: Python file from which requests can be read.
430
313
:param out_file: Python file to write responses.
431
314
:param backing_transport: Transport for the directory served.
433
SmartServerStreamMedium.__init__(self, backing_transport,
316
SmartServerStreamMedium.__init__(self, backing_transport)
435
317
if sys.platform == 'win32':
436
318
# force binary mode for files
442
324
self._in = in_file
443
325
self._out = out_file
446
"""See SmartServerStreamMedium.serve"""
447
# This is the regular serve, except it adds signal trapping for soft
449
stop_gracefully = self._stop_gracefully
450
signals.register_on_hangup(id(self), stop_gracefully)
452
return super(SmartServerPipeStreamMedium, self).serve()
454
signals.unregister_on_hangup(id(self))
456
327
def _serve_one_request_unguarded(self, protocol):
458
329
# We need to be careful not to read past the end of the current
472
343
protocol.accept_bytes(bytes)
474
def _disconnect_client(self):
479
def _wait_for_bytes_with_timeout(self, timeout_seconds):
480
"""Wait for more bytes to be read, but timeout if none available.
482
This allows us to detect idle connections, and stop trying to read from
483
them, without setting the socket itself to non-blocking. This also
484
allows us to specify when we watch for idle timeouts.
486
:return: None, this will raise ConnectionTimeout if we time out before
489
if (getattr(self._in, 'fileno', None) is None
490
or sys.platform == 'win32'):
491
# You can't select() file descriptors on Windows.
493
return self._wait_on_descriptor(self._in, timeout_seconds)
495
345
def _read_bytes(self, desired_count):
496
346
return self._in.read(desired_count)
641
491
return self._medium._get_line()
644
class _VfsRefuser(object):
645
"""An object that refuses all VFS requests.
650
client._SmartClient.hooks.install_named_hook(
651
'call', self.check_vfs, 'vfs refuser')
653
def check_vfs(self, params):
655
request_method = request.request_handlers.get(params.method)
657
# A method we don't know about doesn't count as a VFS method.
659
if issubclass(request_method, vfs.VfsRequest):
660
raise errors.HpssVfsRequestNotAllowed(params.method, params.args)
663
494
class _DebugCounter(object):
664
495
"""An object that counts the HPSS calls made to each client medium.
666
When a medium is garbage-collected, or failing that when
667
bzrlib.global_state exits, the total number of calls made on that medium
668
are reported via trace.note.
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
671
502
def __init__(self):
672
503
self.counts = weakref.WeakKeyDictionary()
673
504
client._SmartClient.hooks.install_named_hook(
674
505
'call', self.increment_call_count, 'hpss call counter')
675
bzrlib.global_state.cleanups.add_cleanup(self.flush_all)
506
atexit.register(self.flush_all)
677
508
def track(self, medium):
678
509
"""Start tracking calls made to a medium.
781
607
# which is newer than a previously supplied older-than version.
782
608
# This indicates that some smart verb call is not guarded
783
609
# appropriately (it should simply not have been tried).
610
raise AssertionError(
785
611
"_remember_remote_is_before(%r) called, but "
786
612
"_remember_remote_is_before(%r) was called previously."
787
, version_tuple, self._remote_version_is_before)
788
if 'hpss' in debug.debug_flags:
789
ui.ui_factory.show_warning(
790
"_remember_remote_is_before(%r) called, but "
791
"_remember_remote_is_before(%r) was called previously."
792
% (version_tuple, self._remote_version_is_before))
613
% (version_tuple, self._remote_version_is_before))
794
614
self._remote_version_is_before = version_tuple
796
616
def protocol_version(self):
908
732
def _read_bytes(self, count):
909
733
"""See SmartClientStreamMedium._read_bytes."""
910
bytes_to_read = min(count, _MAX_READ_SIZE)
911
bytes = self._readable_pipe.read(bytes_to_read)
734
bytes = osutils.until_no_eintr(self._readable_pipe.read, count)
912
735
self._report_activity(len(bytes), 'read')
916
class SSHParams(object):
917
"""A set of parameters for starting a remote bzr via SSH."""
739
class SmartSSHClientMedium(SmartClientStreamMedium):
740
"""A client medium using SSH."""
919
742
def __init__(self, host, port=None, username=None, password=None,
920
bzr_remote_path='bzr'):
923
self.username = username
924
self.password = password
925
self.bzr_remote_path = bzr_remote_path
928
class SmartSSHClientMedium(SmartClientStreamMedium):
929
"""A client medium using SSH.
931
It delegates IO to a SmartClientSocketMedium or
932
SmartClientAlreadyConnectedSocketMedium (depending on platform).
935
def __init__(self, base, ssh_params, vendor=None):
743
base=None, vendor=None, bzr_remote_path=None):
936
744
"""Creates a client that will connect on the first use.
938
:param ssh_params: A SSHParams instance.
939
746
:param vendor: An optional override for the ssh vendor to use. See
940
747
bzrlib.transport.ssh for details on ssh vendors.
942
self._real_medium = None
943
self._ssh_params = ssh_params
749
self._connected = False
751
self._password = password
753
self._username = username
944
754
# for the benefit of progress making a short description of this
946
756
self._scheme = 'bzr+ssh'
948
758
# _DebugCounter so we have to store all the values used in our repr
949
759
# method before calling the super init.
950
760
SmartClientStreamMedium.__init__(self, base)
761
self._read_from = None
762
self._ssh_connection = None
951
763
self._vendor = vendor
952
self._ssh_connection = None
764
self._write_to = None
765
self._bzr_remote_path = bzr_remote_path
954
767
def __repr__(self):
955
if self._ssh_params.port is None:
768
if self._port is None:
958
maybe_port = ':%s' % self._ssh_params.port
771
maybe_port = ':%s' % self._port
959
772
return "%s(%s://%s@%s%s/)" % (
960
773
self.__class__.__name__,
962
self._ssh_params.username,
963
self._ssh_params.host,
966
779
def _accept_bytes(self, bytes):
967
780
"""See SmartClientStreamMedium.accept_bytes."""
968
781
self._ensure_connection()
969
self._real_medium.accept_bytes(bytes)
782
self._write_to.write(bytes)
783
self._report_activity(len(bytes), 'write')
971
785
def disconnect(self):
972
786
"""See SmartClientMedium.disconnect()."""
973
if self._real_medium is not None:
974
self._real_medium.disconnect()
975
self._real_medium = None
976
if self._ssh_connection is not None:
977
self._ssh_connection.close()
978
self._ssh_connection = None
787
if not self._connected:
789
self._read_from.close()
790
self._write_to.close()
791
self._ssh_connection.close()
792
self._connected = False
980
794
def _ensure_connection(self):
981
795
"""Connect this medium if not already connected."""
982
if self._real_medium is not None:
984
798
if self._vendor is None:
985
799
vendor = ssh._get_ssh_vendor()
987
801
vendor = self._vendor
988
self._ssh_connection = vendor.connect_ssh(self._ssh_params.username,
989
self._ssh_params.password, self._ssh_params.host,
990
self._ssh_params.port,
991
command=[self._ssh_params.bzr_remote_path, 'serve', '--inet',
802
self._ssh_connection = vendor.connect_ssh(self._username,
803
self._password, self._host, self._port,
804
command=[self._bzr_remote_path, 'serve', '--inet',
992
805
'--directory=/', '--allow-writes'])
993
io_kind, io_object = self._ssh_connection.get_sock_or_pipes()
994
if io_kind == 'socket':
995
self._real_medium = SmartClientAlreadyConnectedSocketMedium(
996
self.base, io_object)
997
elif io_kind == 'pipes':
998
read_from, write_to = io_object
999
self._real_medium = SmartSimplePipesClientMedium(
1000
read_from, write_to, self.base)
1002
raise AssertionError(
1003
"Unexpected io_kind %r from %r"
1004
% (io_kind, self._ssh_connection))
806
self._read_from, self._write_to = \
807
self._ssh_connection.get_filelike_channels()
808
self._connected = True
1006
810
def _flush(self):
1007
811
"""See SmartClientStreamMedium._flush()."""
1008
self._real_medium._flush()
812
self._write_to.flush()
1010
814
def _read_bytes(self, count):
1011
815
"""See SmartClientStreamMedium.read_bytes."""
1012
if self._real_medium is None:
816
if not self._connected:
1013
817
raise errors.MediumNotConnected(self)
1014
return self._real_medium.read_bytes(count)
818
bytes_to_read = min(count, _MAX_READ_SIZE)
819
bytes = self._read_from.read(bytes_to_read)
820
self._report_activity(len(bytes), 'read')
1017
824
# Port 4155 is the default port for bzr://, registered with IANA.
1019
826
BZR_DEFAULT_PORT = 4155
1022
class SmartClientSocketMedium(SmartClientStreamMedium):
1023
"""A client medium using a socket.
1025
This class isn't usable directly. Use one of its subclasses instead.
829
class SmartTCPClientMedium(SmartClientStreamMedium):
830
"""A client medium using TCP."""
1028
def __init__(self, base):
832
def __init__(self, host, port, base):
833
"""Creates a client that will connect on the first use."""
1029
834
SmartClientStreamMedium.__init__(self, base)
835
self._connected = False
1030
838
self._socket = None
1031
self._connected = False
1033
840
def _accept_bytes(self, bytes):
1034
841
"""See SmartClientMedium.accept_bytes."""
1035
842
self._ensure_connection()
1036
843
osutils.send_all(self._socket, bytes, self._report_activity)
1038
def _ensure_connection(self):
1039
"""Connect this medium if not already connected."""
1040
raise NotImplementedError(self._ensure_connection)
1043
"""See SmartClientStreamMedium._flush().
1045
For sockets we do no flushing. For TCP sockets we may want to turn off
1046
TCP_NODELAY and add a means to do a flush, but that can be done in the
1050
def _read_bytes(self, count):
1051
"""See SmartClientMedium.read_bytes."""
1052
if not self._connected:
1053
raise errors.MediumNotConnected(self)
1054
return osutils.read_bytes_from_socket(
1055
self._socket, self._report_activity)
1057
845
def disconnect(self):
1058
846
"""See SmartClientMedium.disconnect()."""
1059
847
if not self._connected:
1111
889
(self._host, port, err_msg))
1112
890
self._connected = True
1115
class SmartClientAlreadyConnectedSocketMedium(SmartClientSocketMedium):
1116
"""A client medium for an already connected socket.
1118
Note that this class will assume it "owns" the socket, so it will close it
1119
when its disconnect method is called.
1122
def __init__(self, base, sock):
1123
SmartClientSocketMedium.__init__(self, base)
1125
self._connected = True
1127
def _ensure_connection(self):
1128
# Already connected, by definition! So nothing to do.
893
"""See SmartClientStreamMedium._flush().
895
For TCP we do no flushing. We may want to turn off TCP_NODELAY and
896
add a means to do a flush, but that can be done in the future.
899
def _read_bytes(self, count):
900
"""See SmartClientMedium.read_bytes."""
901
if not self._connected:
902
raise errors.MediumNotConnected(self)
903
return osutils.read_bytes_from_socket(
904
self._socket, self._report_activity)
1132
907
class SmartClientStreamMediumRequest(SmartClientMediumRequest):
added
removed
bzrlib/smart/medium.py
