45
47
from bzrlib.smart import client, protocol, request, vfs
46
48
from bzrlib.transport import ssh
50
#usually already imported, and getting IllegalScoperReplacer on it here.
48
51
from bzrlib import osutils
50
# Throughout this module buffer size parameters are either limited to be at
51
# most _MAX_READ_SIZE, or are ignored and _MAX_READ_SIZE is used instead.
52
# For this module's purposes, MAX_SOCKET_CHUNK is a reasonable size for reads
53
# from non-sockets as well.
54
_MAX_READ_SIZE = osutils.MAX_SOCKET_CHUNK
53
# We must not read any more than 64k at a time so we don't risk "no buffer
54
# space available" errors on some platforms. Windows in particular is likely
55
# to give error 10053 or 10055 if we read more than 64k from a socket.
56
_MAX_READ_SIZE = 64 * 1024
56
59
def _get_protocol_factory_for_bytes(bytes):
57
60
"""Determine the right protocol factory for 'bytes'.
284
287
self._push_back(protocol.unused_data)
286
289
def _read_bytes(self, desired_count):
287
return osutils.read_bytes_from_socket(
288
self.socket, self._report_activity)
290
return _read_bytes_from_socket(
291
self.socket.recv, desired_count, self._report_activity)
290
293
def terminate_due_to_error(self):
291
294
# TODO: This should log to a server log file, but no such thing
292
295
# exists yet. Andrew Bennetts 2006-09-29.
296
osutils.until_no_eintr(self.socket.close)
294
297
self.finished = True
296
299
def _write_out(self, bytes):
331
334
bytes_to_read = protocol.next_read_size()
332
335
if bytes_to_read == 0:
333
336
# Finished serving this request.
337
osutils.until_no_eintr(self._out.flush)
336
339
bytes = self.read_bytes(bytes_to_read)
338
341
# Connection has been closed.
339
342
self.finished = True
343
osutils.until_no_eintr(self._out.flush)
342
345
protocol.accept_bytes(bytes)
344
347
def _read_bytes(self, desired_count):
345
return self._in.read(desired_count)
348
return osutils.until_no_eintr(self._in.read, desired_count)
347
350
def terminate_due_to_error(self):
348
351
# TODO: This should log to a server log file, but no such thing
349
352
# exists yet. Andrew Bennetts 2006-09-29.
353
osutils.until_no_eintr(self._out.close)
351
354
self.finished = True
353
356
def _write_out(self, bytes):
354
self._out.write(bytes)
357
osutils.until_no_eintr(self._out.write, bytes)
357
360
class SmartClientMediumRequest(object):
493
496
class _DebugCounter(object):
494
497
"""An object that counts the HPSS calls made to each client medium.
496
When a medium is garbage-collected, or failing that when
497
bzrlib.global_state exits, the total number of calls made on that medium
498
are reported via trace.note.
499
When a medium is garbage-collected, or failing that when atexit functions
500
are run, the total number of calls made on that medium are reported via
501
504
def __init__(self):
502
505
self.counts = weakref.WeakKeyDictionary()
503
506
client._SmartClient.hooks.install_named_hook(
504
507
'call', self.increment_call_count, 'hpss call counter')
505
bzrlib.global_state.cleanups.add_cleanup(self.flush_all)
508
atexit.register(self.flush_all)
507
510
def track(self, medium):
508
511
"""Start tracking calls made to a medium.
606
609
# which is newer than a previously supplied older-than version.
607
610
# This indicates that some smart verb call is not guarded
608
611
# appropriately (it should simply not have been tried).
612
raise AssertionError(
610
613
"_remember_remote_is_before(%r) called, but "
611
614
"_remember_remote_is_before(%r) was called previously."
612
, version_tuple, self._remote_version_is_before)
613
if 'hpss' in debug.debug_flags:
614
ui.ui_factory.show_warning(
615
"_remember_remote_is_before(%r) called, but "
616
"_remember_remote_is_before(%r) was called previously."
617
% (version_tuple, self._remote_version_is_before))
615
% (version_tuple, self._remote_version_is_before))
619
616
self._remote_version_is_before = version_tuple
621
618
def protocol_version(self):
724
721
def _accept_bytes(self, bytes):
725
722
"""See SmartClientStreamMedium.accept_bytes."""
726
self._writeable_pipe.write(bytes)
723
osutils.until_no_eintr(self._writeable_pipe.write, bytes)
727
724
self._report_activity(len(bytes), 'write')
729
726
def _flush(self):
730
727
"""See SmartClientStreamMedium._flush()."""
731
self._writeable_pipe.flush()
728
osutils.until_no_eintr(self._writeable_pipe.flush)
733
730
def _read_bytes(self, count):
734
731
"""See SmartClientStreamMedium._read_bytes."""
735
bytes_to_read = min(count, _MAX_READ_SIZE)
736
bytes = self._readable_pipe.read(bytes_to_read)
732
bytes = osutils.until_no_eintr(self._readable_pipe.read, count)
737
733
self._report_activity(len(bytes), 'read')
741
class SSHParams(object):
742
"""A set of parameters for starting a remote bzr via SSH."""
737
class SmartSSHClientMedium(SmartClientStreamMedium):
738
"""A client medium using SSH."""
744
740
def __init__(self, host, port=None, username=None, password=None,
745
bzr_remote_path='bzr'):
748
self.username = username
749
self.password = password
750
self.bzr_remote_path = bzr_remote_path
753
class SmartSSHClientMedium(SmartClientStreamMedium):
754
"""A client medium using SSH.
756
It delegates IO to a SmartClientSocketMedium or
757
SmartClientAlreadyConnectedSocketMedium (depending on platform).
760
def __init__(self, base, ssh_params, vendor=None):
741
base=None, vendor=None, bzr_remote_path=None):
761
742
"""Creates a client that will connect on the first use.
763
:param ssh_params: A SSHParams instance.
764
744
:param vendor: An optional override for the ssh vendor to use. See
765
745
bzrlib.transport.ssh for details on ssh vendors.
767
self._real_medium = None
768
self._ssh_params = ssh_params
747
self._connected = False
749
self._password = password
751
self._username = username
769
752
# for the benefit of progress making a short description of this
771
754
self._scheme = 'bzr+ssh'
773
756
# _DebugCounter so we have to store all the values used in our repr
774
757
# method before calling the super init.
775
758
SmartClientStreamMedium.__init__(self, base)
759
self._read_from = None
760
self._ssh_connection = None
776
761
self._vendor = vendor
777
self._ssh_connection = None
762
self._write_to = None
763
self._bzr_remote_path = bzr_remote_path
779
765
def __repr__(self):
780
if self._ssh_params.port is None:
766
if self._port is None:
783
maybe_port = ':%s' % self._ssh_params.port
769
maybe_port = ':%s' % self._port
784
770
return "%s(%s://%s@%s%s/)" % (
785
771
self.__class__.__name__,
787
self._ssh_params.username,
788
self._ssh_params.host,
791
777
def _accept_bytes(self, bytes):
792
778
"""See SmartClientStreamMedium.accept_bytes."""
793
779
self._ensure_connection()
794
self._real_medium.accept_bytes(bytes)
780
osutils.until_no_eintr(self._write_to.write, bytes)
781
self._report_activity(len(bytes), 'write')
796
783
def disconnect(self):
797
784
"""See SmartClientMedium.disconnect()."""
798
if self._real_medium is not None:
799
self._real_medium.disconnect()
800
self._real_medium = None
801
if self._ssh_connection is not None:
802
self._ssh_connection.close()
803
self._ssh_connection = None
785
if not self._connected:
787
osutils.until_no_eintr(self._read_from.close)
788
osutils.until_no_eintr(self._write_to.close)
789
self._ssh_connection.close()
790
self._connected = False
805
792
def _ensure_connection(self):
806
793
"""Connect this medium if not already connected."""
807
if self._real_medium is not None:
809
796
if self._vendor is None:
810
797
vendor = ssh._get_ssh_vendor()
812
799
vendor = self._vendor
813
self._ssh_connection = vendor.connect_ssh(self._ssh_params.username,
814
self._ssh_params.password, self._ssh_params.host,
815
self._ssh_params.port,
816
command=[self._ssh_params.bzr_remote_path, 'serve', '--inet',
800
self._ssh_connection = vendor.connect_ssh(self._username,
801
self._password, self._host, self._port,
802
command=[self._bzr_remote_path, 'serve', '--inet',
817
803
'--directory=/', '--allow-writes'])
818
io_kind, io_object = self._ssh_connection.get_sock_or_pipes()
819
if io_kind == 'socket':
820
self._real_medium = SmartClientAlreadyConnectedSocketMedium(
821
self.base, io_object)
822
elif io_kind == 'pipes':
823
read_from, write_to = io_object
824
self._real_medium = SmartSimplePipesClientMedium(
825
read_from, write_to, self.base)
827
raise AssertionError(
828
"Unexpected io_kind %r from %r"
829
% (io_kind, self._ssh_connection))
804
self._read_from, self._write_to = \
805
self._ssh_connection.get_filelike_channels()
806
self._connected = True
831
808
def _flush(self):
832
809
"""See SmartClientStreamMedium._flush()."""
833
self._real_medium._flush()
810
self._write_to.flush()
835
812
def _read_bytes(self, count):
836
813
"""See SmartClientStreamMedium.read_bytes."""
837
if self._real_medium is None:
814
if not self._connected:
838
815
raise errors.MediumNotConnected(self)
839
return self._real_medium.read_bytes(count)
816
bytes_to_read = min(count, _MAX_READ_SIZE)
817
bytes = osutils.until_no_eintr(self._read_from.read, bytes_to_read)
818
self._report_activity(len(bytes), 'read')
842
822
# Port 4155 is the default port for bzr://, registered with IANA.
844
824
BZR_DEFAULT_PORT = 4155
847
class SmartClientSocketMedium(SmartClientStreamMedium):
848
"""A client medium using a socket.
850
This class isn't usable directly. Use one of its subclasses instead.
827
class SmartTCPClientMedium(SmartClientStreamMedium):
828
"""A client medium using TCP."""
853
def __init__(self, base):
830
def __init__(self, host, port, base):
831
"""Creates a client that will connect on the first use."""
854
832
SmartClientStreamMedium.__init__(self, base)
833
self._connected = False
855
836
self._socket = None
856
self._connected = False
858
838
def _accept_bytes(self, bytes):
859
839
"""See SmartClientMedium.accept_bytes."""
860
840
self._ensure_connection()
861
841
osutils.send_all(self._socket, bytes, self._report_activity)
863
def _ensure_connection(self):
864
"""Connect this medium if not already connected."""
865
raise NotImplementedError(self._ensure_connection)
868
"""See SmartClientStreamMedium._flush().
870
For sockets we do no flushing. For TCP sockets we may want to turn off
871
TCP_NODELAY and add a means to do a flush, but that can be done in the
875
def _read_bytes(self, count):
876
"""See SmartClientMedium.read_bytes."""
877
if not self._connected:
878
raise errors.MediumNotConnected(self)
879
return osutils.read_bytes_from_socket(
880
self._socket, self._report_activity)
882
843
def disconnect(self):
883
844
"""See SmartClientMedium.disconnect()."""
884
845
if not self._connected:
847
osutils.until_no_eintr(self._socket.close)
887
848
self._socket = None
888
849
self._connected = False
891
class SmartTCPClientMedium(SmartClientSocketMedium):
892
"""A client medium that creates a TCP connection."""
894
def __init__(self, host, port, base):
895
"""Creates a client that will connect on the first use."""
896
SmartClientSocketMedium.__init__(self, base)
900
851
def _ensure_connection(self):
901
852
"""Connect this medium if not already connected."""
902
853
if self._connected:
936
887
(self._host, port, err_msg))
937
888
self._connected = True
940
class SmartClientAlreadyConnectedSocketMedium(SmartClientSocketMedium):
941
"""A client medium for an already connected socket.
943
Note that this class will assume it "owns" the socket, so it will close it
944
when its disconnect method is called.
947
def __init__(self, base, sock):
948
SmartClientSocketMedium.__init__(self, base)
950
self._connected = True
952
def _ensure_connection(self):
953
# Already connected, by definition! So nothing to do.
891
"""See SmartClientStreamMedium._flush().
893
For TCP we do no flushing. We may want to turn off TCP_NODELAY and
894
add a means to do a flush, but that can be done in the future.
897
def _read_bytes(self, count):
898
"""See SmartClientMedium.read_bytes."""
899
if not self._connected:
900
raise errors.MediumNotConnected(self)
901
return _read_bytes_from_socket(
902
self._socket.recv, count, self._report_activity)
957
905
class SmartClientStreamMediumRequest(SmartClientMediumRequest):
994
942
self._medium._flush()
945
def _read_bytes_from_socket(sock, desired_count, report_activity):
946
# We ignore the desired_count because on sockets it's more efficient to
947
# read large chunks (of _MAX_READ_SIZE bytes) at a time.
949
bytes = osutils.until_no_eintr(sock, _MAX_READ_SIZE)
950
except socket.error, e:
951
if len(e.args) and e.args[0] in (errno.ECONNRESET, 10054):
952
# The connection was closed by the other side. Callers expect an
953
# empty string to signal end-of-stream.
958
report_activity(len(bytes), 'read')
added
removed
bzrlib/smart/medium.py
