176
178
ui.ui_factory.report_transport_activity(self, bytes, direction)
181
_bad_file_descriptor = (errno.EBADF,)
182
if sys.platform == 'win32':
183
# Given on Windows if you pass a closed socket to select.select. Probably
184
# also given if you pass a file handle to select.
186
_bad_file_descriptor += (WSAENOTSOCK,)
179
189
class SmartServerStreamMedium(SmartMedium):
180
190
"""Handles smart commands coming over a stream.
214
230
while not self.finished:
215
231
server_protocol = self._build_protocol()
232
# TODO: This seems inelegant:
233
if server_protocol is None:
234
# We could 'continue' only to notice that self.finished is
236
trace.mutter('Stopped while waiting for request: %s\n'
216
239
self._serve_one_request(server_protocol)
240
except errors.ConnectionTimeout, e:
241
trace.note('%s' % (e,))
242
trace.log_exception_quietly()
243
self._disconnect_client()
244
# We reported it, no reason to make a big fuss.
217
246
except Exception, e:
218
247
stderr.write("%s terminating on exception %s\n" % (self, e))
249
self._disconnect_client()
251
def _stop_gracefully(self):
252
"""When we finish this message, stop looking for more."""
253
trace.mutter('Stopping %s' % (self,))
256
def _disconnect_client(self):
257
"""Close the current connection. We stopped due to a timeout/etc."""
258
# The default implementation is a no-op, because that is all we used to
259
# do when disconnecting from a client. I suppose we never had the
260
# *server* initiate a disconnect, before
262
def _wait_for_bytes_with_timeout(self, timeout_seconds):
263
"""Wait for more bytes to be read, but timeout if none available.
265
This allows us to detect idle connections, and stop trying to read from
266
them, without setting the socket itself to non-blocking. This also
267
allows us to specify when we watch for idle timeouts.
269
:return: Did we timeout? (True if we timed out, False if there is data
272
raise NotImplementedError(self._wait_for_bytes_with_timeout)
221
274
def _build_protocol(self):
222
275
"""Identifies the version of the incoming request, and returns an
234
291
protocol.accept_bytes(unused_bytes)
294
def _wait_on_descriptor(self, fd, timeout_seconds):
295
"""select() on a file descriptor, waiting for nonblocking read()
297
This will raise a ConnectionTimeout exception if we do not get a
298
readable handle before timeout_seconds.
301
t_end = self._timer() + timeout_seconds
302
poll_timeout = min(timeout_seconds, self._client_poll_timeout)
304
while not rs and not xs and self._timer() < t_end:
308
rs, _, xs = select.select([fd], [], [fd], poll_timeout)
309
except (select.error, socket.error) as e:
310
err = getattr(e, 'errno', None)
311
if err is None and getattr(e, 'args', None) is not None:
312
# select.error doesn't have 'errno', it just has args[0]
314
if err in _bad_file_descriptor:
315
return # Not a socket indicates read() will fail
316
elif err == errno.EINTR:
317
# Interrupted, keep looping.
322
raise errors.ConnectionTimeout('disconnecting client after %.1f seconds'
323
% (timeout_seconds,))
237
325
def _serve_one_request(self, protocol):
238
326
"""Read one request from input, process, send back a response.
261
349
class SmartServerSocketStreamMedium(SmartServerStreamMedium):
263
def __init__(self, sock, backing_transport, root_client_path='/'):
351
def __init__(self, sock, backing_transport, root_client_path='/',
266
355
:param sock: the socket the server will read from. It will be put
267
356
into blocking mode.
269
358
SmartServerStreamMedium.__init__(
270
self, backing_transport, root_client_path=root_client_path)
359
self, backing_transport, root_client_path=root_client_path,
271
361
sock.setblocking(True)
272
362
self.socket = sock
363
# Get the getpeername now, as we might be closed later when we care.
365
self._client_info = sock.getpeername()
367
self._client_info = '<unknown>'
370
return '%s(client=%s)' % (self.__class__.__name__, self._client_info)
373
return '%s.%s(client=%s)' % (self.__module__, self.__class__.__name__,
274
376
def _serve_one_request_unguarded(self, protocol):
275
377
while protocol.next_read_size():
285
387
self._push_back(protocol.unused_data)
389
def _disconnect_client(self):
390
"""Close the current connection. We stopped due to a timeout/etc."""
393
def _wait_for_bytes_with_timeout(self, timeout_seconds):
394
"""Wait for more bytes to be read, but timeout if none available.
396
This allows us to detect idle connections, and stop trying to read from
397
them, without setting the socket itself to non-blocking. This also
398
allows us to specify when we watch for idle timeouts.
400
:return: None, this will raise ConnectionTimeout if we time out before
403
return self._wait_on_descriptor(self.socket, timeout_seconds)
287
405
def _read_bytes(self, desired_count):
288
406
return osutils.read_bytes_from_socket(
289
407
self.socket, self._report_activity)
307
425
class SmartServerPipeStreamMedium(SmartServerStreamMedium):
309
def __init__(self, in_file, out_file, backing_transport):
427
def __init__(self, in_file, out_file, backing_transport, timeout=None):
310
428
"""Construct new server.
312
430
:param in_file: Python file from which requests can be read.
313
431
:param out_file: Python file to write responses.
314
432
:param backing_transport: Transport for the directory served.
316
SmartServerStreamMedium.__init__(self, backing_transport)
434
SmartServerStreamMedium.__init__(self, backing_transport,
317
436
if sys.platform == 'win32':
318
437
# force binary mode for files
324
443
self._in = in_file
325
444
self._out = out_file
447
"""See SmartServerStreamMedium.serve"""
448
# This is the regular serve, except it adds signal trapping for soft
450
stop_gracefully = self._stop_gracefully
451
signals.register_on_hangup(id(self), stop_gracefully)
453
return super(SmartServerPipeStreamMedium, self).serve()
455
signals.unregister_on_hangup(id(self))
327
457
def _serve_one_request_unguarded(self, protocol):
329
459
# We need to be careful not to read past the end of the current
343
473
protocol.accept_bytes(bytes)
475
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)
345
495
def _read_bytes(self, desired_count):
346
496
return self._in.read(desired_count)
491
641
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)
494
663
class _DebugCounter(object):
495
664
"""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
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.
502
671
def __init__(self):
503
672
self.counts = weakref.WeakKeyDictionary()
504
673
client._SmartClient.hooks.install_named_hook(
505
674
'call', self.increment_call_count, 'hpss call counter')
506
atexit.register(self.flush_all)
675
bzrlib.global_state.cleanups.add_cleanup(self.flush_all)
508
677
def track(self, medium):
509
678
"""Start tracking calls made to a medium.
738
908
def _read_bytes(self, count):
739
909
"""See SmartClientStreamMedium._read_bytes."""
740
bytes = osutils.until_no_eintr(self._readable_pipe.read, count)
910
bytes_to_read = min(count, _MAX_READ_SIZE)
911
bytes = self._readable_pipe.read(bytes_to_read)
741
912
self._report_activity(len(bytes), 'read')
916
class SSHParams(object):
917
"""A set of parameters for starting a remote bzr via SSH."""
919
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
745
928
class SmartSSHClientMedium(SmartClientStreamMedium):
746
"""A client medium using SSH."""
929
"""A client medium using SSH.
931
It delegates IO to a SmartClientSocketMedium or
932
SmartClientAlreadyConnectedSocketMedium (depending on platform).
748
def __init__(self, host, port=None, username=None, password=None,
749
base=None, vendor=None, bzr_remote_path=None):
935
def __init__(self, base, ssh_params, vendor=None):
750
936
"""Creates a client that will connect on the first use.
938
:param ssh_params: A SSHParams instance.
752
939
:param vendor: An optional override for the ssh vendor to use. See
753
940
bzrlib.transport.ssh for details on ssh vendors.
755
self._connected = False
757
self._password = password
759
self._username = username
942
self._real_medium = None
943
self._ssh_params = ssh_params
760
944
# for the benefit of progress making a short description of this
762
946
self._scheme = 'bzr+ssh'
764
948
# _DebugCounter so we have to store all the values used in our repr
765
949
# method before calling the super init.
766
950
SmartClientStreamMedium.__init__(self, base)
767
self._read_from = None
951
self._vendor = vendor
768
952
self._ssh_connection = None
769
self._vendor = vendor
770
self._write_to = None
771
self._bzr_remote_path = bzr_remote_path
773
954
def __repr__(self):
774
if self._port is None:
955
if self._ssh_params.port is None:
777
maybe_port = ':%s' % self._port
958
maybe_port = ':%s' % self._ssh_params.port
778
959
return "%s(%s://%s@%s%s/)" % (
779
960
self.__class__.__name__,
962
self._ssh_params.username,
963
self._ssh_params.host,
785
966
def _accept_bytes(self, bytes):
786
967
"""See SmartClientStreamMedium.accept_bytes."""
787
968
self._ensure_connection()
788
self._write_to.write(bytes)
789
self._report_activity(len(bytes), 'write')
969
self._real_medium.accept_bytes(bytes)
791
971
def disconnect(self):
792
972
"""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
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
800
980
def _ensure_connection(self):
801
981
"""Connect this medium if not already connected."""
982
if self._real_medium is not None:
804
984
if self._vendor is None:
805
985
vendor = ssh._get_ssh_vendor()
807
987
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',
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',
811
992
'--directory=/', '--allow-writes'])
812
self._read_from, self._write_to = \
813
self._ssh_connection.get_filelike_channels()
814
self._connected = True
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))
816
1006
def _flush(self):
817
1007
"""See SmartClientStreamMedium._flush()."""
818
self._write_to.flush()
1008
self._real_medium._flush()
820
1010
def _read_bytes(self, count):
821
1011
"""See SmartClientStreamMedium.read_bytes."""
822
if not self._connected:
1012
if self._real_medium is None:
823
1013
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')
1014
return self._real_medium.read_bytes(count)
830
1017
# Port 4155 is the default port for bzr://, registered with IANA.
832
1019
BZR_DEFAULT_PORT = 4155
835
class SmartTCPClientMedium(SmartClientStreamMedium):
836
"""A client medium using TCP."""
1022
class SmartClientSocketMedium(SmartClientStreamMedium):
1023
"""A client medium using a socket.
1025
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."""
1028
def __init__(self, base):
840
1029
SmartClientStreamMedium.__init__(self, base)
841
1031
self._connected = False
846
1033
def _accept_bytes(self, bytes):
847
1034
"""See SmartClientMedium.accept_bytes."""
848
1035
self._ensure_connection()
849
1036
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)
851
1057
def disconnect(self):
852
1058
"""See SmartClientMedium.disconnect()."""
853
1059
if not self._connected:
895
1111
(self._host, port, err_msg))
896
1112
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)
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.
913
1132
class SmartClientStreamMediumRequest(SmartClientMediumRequest):
added
removed
bzrlib/smart/medium.py
