243
347
class SmartServerSocketStreamMedium(SmartServerStreamMedium):
245
def __init__(self, sock, backing_transport, root_client_path='/'):
349
def __init__(self, sock, backing_transport, root_client_path='/',
248
353
:param sock: the socket the server will read from. It will be put
249
354
into blocking mode.
251
356
SmartServerStreamMedium.__init__(
252
self, backing_transport, root_client_path=root_client_path)
357
self, backing_transport, root_client_path=root_client_path,
253
359
sock.setblocking(True)
254
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__,
256
374
def _serve_one_request_unguarded(self, protocol):
257
375
while protocol.next_read_size():
258
376
# We can safely try to read large chunks. If there is less data
259
# than _MAX_READ_SIZE ready, the socket wil just return a short
260
# read immediately rather than block.
261
bytes = self.read_bytes(_MAX_READ_SIZE)
377
# than MAX_SOCKET_CHUNK ready, the socket will just return a
378
# short read immediately rather than block.
379
bytes = self.read_bytes(osutils.MAX_SOCKET_CHUNK)
263
381
self.finished = True
265
383
protocol.accept_bytes(bytes)
267
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)
269
403
def _read_bytes(self, desired_count):
270
# We ignore the desired_count because on sockets it's more efficient to
271
# read large chunks (of _MAX_READ_SIZE bytes) at a time.
272
return self.socket.recv(_MAX_READ_SIZE)
404
return osutils.read_bytes_from_socket(
405
self.socket, self._report_activity)
274
407
def terminate_due_to_error(self):
275
408
# TODO: This should log to a server log file, but no such thing
455
627
if not line.endswith('\n'):
456
628
# end of file encountered reading from server
457
629
raise errors.ConnectionReset(
458
"please check connectivity and permissions",
459
"(and try -Dhpss if further diagnosis is required)")
630
"Unexpected end of message. Please check connectivity "
631
"and permissions, and report a bug if problems persist.")
462
634
def _read_line(self):
463
635
"""Helper for SmartClientMediumRequest.read_line.
465
637
By default this forwards to self._medium._get_line because we are
466
638
operating on the medium's stream.
468
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)
662
class _DebugCounter(object):
663
"""An object that counts the HPSS calls made to each client medium.
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.
671
self.counts = weakref.WeakKeyDictionary()
672
client._SmartClient.hooks.install_named_hook(
673
'call', self.increment_call_count, 'hpss call counter')
674
bzrlib.global_state.cleanups.add_cleanup(self.flush_all)
676
def track(self, medium):
677
"""Start tracking calls made to a medium.
679
This only keeps a weakref to the medium, so shouldn't affect the
682
medium_repr = repr(medium)
683
# Add this medium to the WeakKeyDictionary
684
self.counts[medium] = dict(count=0, vfs_count=0,
685
medium_repr=medium_repr)
686
# Weakref callbacks are fired in reverse order of their association
687
# with the referenced object. So we add a weakref *after* adding to
688
# the WeakKeyDict so that we can report the value from it before the
689
# entry is removed by the WeakKeyDict's own callback.
690
ref = weakref.ref(medium, self.done)
692
def increment_call_count(self, params):
693
# Increment the count in the WeakKeyDictionary
694
value = self.counts[params.medium]
697
request_method = request.request_handlers.get(params.method)
699
# A method we don't know about doesn't count as a VFS method.
701
if issubclass(request_method, vfs.VfsRequest):
702
value['vfs_count'] += 1
705
value = self.counts[ref]
706
count, vfs_count, medium_repr = (
707
value['count'], value['vfs_count'], value['medium_repr'])
708
# In case this callback is invoked for the same ref twice (by the
709
# weakref callback and by the atexit function), set the call count back
710
# to 0 so this item won't be reported twice.
712
value['vfs_count'] = 0
714
trace.note(gettext('HPSS calls: {0} ({1} vfs) {2}').format(
715
count, vfs_count, medium_repr))
718
for ref in list(self.counts.keys()):
721
_debug_counter = None
471
725
class SmartClientMedium(SmartMedium):
472
726
"""Smart client is a medium for sending smart protocol requests over."""
624
906
def _accept_bytes(self, bytes):
625
907
"""See SmartClientStreamMedium.accept_bytes."""
626
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", e)
915
self._report_activity(len(bytes), 'write')
628
917
def _flush(self):
629
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.
630
922
self._writeable_pipe.flush()
632
924
def _read_bytes(self, count):
633
925
"""See SmartClientStreamMedium._read_bytes."""
634
return self._readable_pipe.read(count)
926
bytes_to_read = min(count, _MAX_READ_SIZE)
927
bytes = self._readable_pipe.read(bytes_to_read)
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
637
944
class SmartSSHClientMedium(SmartClientStreamMedium):
638
"""A client medium using SSH."""
640
def __init__(self, host, port=None, username=None, password=None,
641
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):
642
952
"""Creates a client that will connect on the first use.
954
:param ssh_params: A SSHParams instance.
644
955
:param vendor: An optional override for the ssh vendor to use. See
645
956
bzrlib.transport.ssh for details on ssh vendors.
958
self._real_medium = None
959
self._ssh_params = ssh_params
960
# for the benefit of progress making a short description of this
962
self._scheme = 'bzr+ssh'
963
# SmartClientStreamMedium stores the repr of this object in its
964
# _DebugCounter so we have to store all the values used in our repr
965
# method before calling the super init.
647
966
SmartClientStreamMedium.__init__(self, base)
648
self._connected = False
650
self._password = password
652
self._username = username
653
self._read_from = None
967
self._vendor = vendor
654
968
self._ssh_connection = None
655
self._vendor = vendor
656
self._write_to = None
657
self._bzr_remote_path = bzr_remote_path
658
if self._bzr_remote_path is None:
659
symbol_versioning.warn(
660
'bzr_remote_path is required as of bzr 0.92',
661
DeprecationWarning, stacklevel=2)
662
self._bzr_remote_path = os.environ.get('BZR_REMOTE_PATH', 'bzr')
971
if self._ssh_params.port is None:
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/)" % (
980
self.__class__.__name__,
983
self._ssh_params.host,
664
986
def _accept_bytes(self, bytes):
665
987
"""See SmartClientStreamMedium.accept_bytes."""
666
988
self._ensure_connection()
667
self._write_to.write(bytes)
989
self._real_medium.accept_bytes(bytes)
669
991
def disconnect(self):
670
992
"""See SmartClientMedium.disconnect()."""
671
if not self._connected:
673
self._read_from.close()
674
self._write_to.close()
675
self._ssh_connection.close()
676
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
678
1000
def _ensure_connection(self):
679
1001
"""Connect this medium if not already connected."""
1002
if self._real_medium is not None:
682
1004
if self._vendor is None:
683
1005
vendor = ssh._get_ssh_vendor()
685
1007
vendor = self._vendor
686
self._ssh_connection = vendor.connect_ssh(self._username,
687
self._password, self._host, self._port,
688
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',
689
1012
'--directory=/', '--allow-writes'])
690
self._read_from, self._write_to = \
691
self._ssh_connection.get_filelike_channels()
692
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"]:
694
1028
def _flush(self):
695
1029
"""See SmartClientStreamMedium._flush()."""
696
self._write_to.flush()
1030
self._real_medium._flush()
698
1032
def _read_bytes(self, count):
699
1033
"""See SmartClientStreamMedium.read_bytes."""
700
if not self._connected:
1034
if self._real_medium is None:
701
1035
raise errors.MediumNotConnected(self)
702
bytes_to_read = min(count, _MAX_READ_SIZE)
703
return self._read_from.read(bytes_to_read)
1036
return self._real_medium.read_bytes(count)
706
1039
# Port 4155 is the default port for bzr://, registered with IANA.
707
BZR_DEFAULT_INTERFACE = '0.0.0.0'
1040
BZR_DEFAULT_INTERFACE = None
708
1041
BZR_DEFAULT_PORT = 4155
711
class SmartTCPClientMedium(SmartClientStreamMedium):
712
"""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.
1050
def __init__(self, base):
1051
SmartClientStreamMedium.__init__(self, base)
1053
self._connected = False
1055
def _accept_bytes(self, bytes):
1056
"""See SmartClientMedium.accept_bytes."""
1057
self._ensure_connection()
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)
1079
def disconnect(self):
1080
"""See SmartClientMedium.disconnect()."""
1081
if not self._connected:
1083
self._socket.close()
1085
self._connected = False
1088
class SmartTCPClientMedium(SmartClientSocketMedium):
1089
"""A client medium that creates a TCP connection."""
714
1091
def __init__(self, host, port, base):
715
1092
"""Creates a client that will connect on the first use."""
716
SmartClientStreamMedium.__init__(self, base)
717
self._connected = False
1093
SmartClientSocketMedium.__init__(self, base)
718
1094
self._host = host
719
1095
self._port = port
722
def _accept_bytes(self, bytes):
723
"""See SmartClientMedium.accept_bytes."""
724
self._ensure_connection()
725
osutils.send_all(self._socket, bytes)
727
def disconnect(self):
728
"""See SmartClientMedium.disconnect()."""
729
if not self._connected:
733
self._connected = False
735
1097
def _ensure_connection(self):
736
1098
"""Connect this medium if not already connected."""
737
1099
if self._connected:
739
self._socket = socket.socket()
740
self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
741
1101
if self._port is None:
742
1102
port = BZR_DEFAULT_PORT
744
1104
port = int(self._port)
746
self._socket.connect((self._host, port))
747
except socket.error, err:
1106
sockaddrs = socket.getaddrinfo(self._host, port, socket.AF_UNSPEC,
1107
socket.SOCK_STREAM, 0, 0)
1108
except socket.gaierror, (err_num, err_msg):
1109
raise errors.ConnectionError("failed to lookup %s:%d: %s" %
1110
(self._host, port, err_msg))
1111
# Initialize err in case there are no addresses returned:
1112
err = socket.error("no address found for %s" % self._host)
1113
for (family, socktype, proto, canonname, sockaddr) in sockaddrs:
1115
self._socket = socket.socket(family, socktype, proto)
1116
self._socket.setsockopt(socket.IPPROTO_TCP,
1117
socket.TCP_NODELAY, 1)
1118
self._socket.connect(sockaddr)
1119
except socket.error, err:
1120
if self._socket is not None:
1121
self._socket.close()
1125
if self._socket is None:
748
1126
# socket errors either have a (string) or (errno, string) as their
750
1128
if type(err.args) is str: