91
74
return protocol_factory, bytes
94
def _get_line(read_bytes_func):
95
"""Read bytes using read_bytes_func until a newline byte.
97
This isn't particularly efficient, so should only be used when the
98
expected size of the line is quite short.
100
:returns: a tuple of two strs: (line, excess)
104
while newline_pos == -1:
105
new_bytes = read_bytes_func(1)
108
# Ran out of bytes before receiving a complete line.
110
newline_pos = bytes.find('\n')
111
line = bytes[:newline_pos+1]
112
excess = bytes[newline_pos+1:]
116
class SmartMedium(object):
117
"""Base class for smart protocol media, both client- and server-side."""
120
self._push_back_buffer = None
122
def _push_back(self, bytes):
123
"""Return unused bytes to the medium, because they belong to the next
126
This sets the _push_back_buffer to the given bytes.
128
if self._push_back_buffer is not None:
129
raise AssertionError(
130
"_push_back called when self._push_back_buffer is %r"
131
% (self._push_back_buffer,))
134
self._push_back_buffer = bytes
136
def _get_push_back_buffer(self):
137
if self._push_back_buffer == '':
138
raise AssertionError(
139
'%s._push_back_buffer should never be the empty string, '
140
'which can be confused with EOF' % (self,))
141
bytes = self._push_back_buffer
142
self._push_back_buffer = None
145
def read_bytes(self, desired_count):
146
"""Read some bytes from this medium.
148
:returns: some bytes, possibly more or less than the number requested
149
in 'desired_count' depending on the medium.
151
if self._push_back_buffer is not None:
152
return self._get_push_back_buffer()
153
bytes_to_read = min(desired_count, _MAX_READ_SIZE)
154
return self._read_bytes(bytes_to_read)
156
def _read_bytes(self, count):
157
raise NotImplementedError(self._read_bytes)
160
"""Read bytes from this request's response until a newline byte.
162
This isn't particularly efficient, so should only be used when the
163
expected size of the line is quite short.
165
:returns: a string of bytes ending in a newline (byte 0x0A).
167
line, excess = _get_line(self.read_bytes)
168
self._push_back(excess)
171
def _report_activity(self, bytes, direction):
172
"""Notify that this medium has activity.
174
Implementations should call this from all methods that actually do IO.
175
Be careful that it's not called twice, if one method is implemented on
178
:param bytes: Number of bytes read or written.
179
:param direction: 'read' or 'write' or None.
181
ui.ui_factory.report_transport_activity(self, bytes, direction)
184
_bad_file_descriptor = (errno.EBADF,)
185
if sys.platform == 'win32':
186
# Given on Windows if you pass a closed socket to select.select. Probably
187
# also given if you pass a file handle to select.
189
_bad_file_descriptor += (WSAENOTSOCK,)
192
class SmartServerStreamMedium(SmartMedium):
77
class SmartServerStreamMedium(object):
193
78
"""Handles smart commands coming over a stream.
195
80
The stream may be a pipe connected to sshd, or a tcp socket, or an
233
135
while not self.finished:
234
136
server_protocol = self._build_protocol()
235
137
self._serve_one_request(server_protocol)
236
except errors.ConnectionTimeout, e:
237
trace.note('%s' % (e,))
238
trace.log_exception_quietly()
239
self._disconnect_client()
240
# We reported it, no reason to make a big fuss.
242
138
except Exception, e:
243
139
stderr.write("%s terminating on exception %s\n" % (self, e))
245
self._disconnect_client()
247
def _stop_gracefully(self):
248
"""When we finish this message, stop looking for more."""
249
trace.mutter('Stopping %s' % (self,))
252
def _disconnect_client(self):
253
"""Close the current connection. We stopped due to a timeout/etc."""
254
# The default implementation is a no-op, because that is all we used to
255
# do when disconnecting from a client. I suppose we never had the
256
# *server* initiate a disconnect, before
258
def _wait_for_bytes_with_timeout(self, timeout_seconds):
259
"""Wait for more bytes to be read, but timeout if none available.
261
This allows us to detect idle connections, and stop trying to read from
262
them, without setting the socket itself to non-blocking. This also
263
allows us to specify when we watch for idle timeouts.
265
:return: Did we timeout? (True if we timed out, False if there is data
268
raise NotImplementedError(self._wait_for_bytes_with_timeout)
270
142
def _build_protocol(self):
271
143
"""Identifies the version of the incoming request, and returns an
287
155
protocol.accept_bytes(unused_bytes)
290
def _wait_on_descriptor(self, fd, timeout_seconds):
291
"""select() on a file descriptor, waiting for nonblocking read()
293
This will raise a ConnectionTimeout exception if we do not get a
294
readable handle before timeout_seconds.
297
t_end = self._timer() + timeout_seconds
298
poll_timeout = min(timeout_seconds, self._client_poll_timeout)
300
while not rs and not xs and self._timer() < t_end:
304
rs, _, xs = select.select([fd], [], [fd], poll_timeout)
305
except (select.error, socket.error) as e:
306
err = getattr(e, 'errno', None)
307
if err is None and getattr(e, 'args', None) is not None:
308
# select.error doesn't have 'errno', it just has args[0]
310
if err in _bad_file_descriptor:
311
return # Not a socket indicates read() will fail
312
elif err == errno.EINTR:
313
# Interrupted, keep looping.
318
raise errors.ConnectionTimeout('disconnecting client after %.1f seconds'
319
% (timeout_seconds,))
321
158
def _serve_one_request(self, protocol):
322
159
"""Read one request from input, process, send back a response.
324
161
:param protocol: a SmartServerRequestProtocol.
329
164
self._serve_one_request_unguarded(protocol)
330
165
except KeyboardInterrupt:
336
171
"""Called when an unhandled exception from the protocol occurs."""
337
172
raise NotImplementedError(self.terminate_due_to_error)
339
def _read_bytes(self, desired_count):
174
def _get_bytes(self, desired_count):
340
175
"""Get some bytes from the medium.
342
177
:param desired_count: number of bytes we want to read.
344
raise NotImplementedError(self._read_bytes)
179
raise NotImplementedError(self._get_bytes)
182
"""Read bytes from this request's response until a newline byte.
184
This isn't particularly efficient, so should only be used when the
185
expected size of the line is quite short.
187
:returns: a string of bytes ending in a newline (byte 0x0A).
191
while newline_pos == -1:
192
new_bytes = self._get_bytes(1)
195
# Ran out of bytes before receiving a complete line.
197
newline_pos = bytes.find('\n')
198
line = bytes[:newline_pos+1]
199
self._push_back(bytes[newline_pos+1:])
347
203
class SmartServerSocketStreamMedium(SmartServerStreamMedium):
349
def __init__(self, sock, backing_transport, root_client_path='/',
205
def __init__(self, sock, backing_transport, root_client_path='/'):
353
208
:param sock: the socket the server will read from. It will be put
354
209
into blocking mode.
356
211
SmartServerStreamMedium.__init__(
357
self, backing_transport, root_client_path=root_client_path,
212
self, backing_transport, root_client_path=root_client_path)
359
213
sock.setblocking(True)
360
214
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__,
374
216
def _serve_one_request_unguarded(self, protocol):
375
217
while protocol.next_read_size():
376
# We can safely try to read large chunks. If there is less data
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)
218
bytes = self._get_bytes(4096)
381
220
self.finished = True
383
222
protocol.accept_bytes(bytes)
385
224
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)
403
def _read_bytes(self, desired_count):
404
return osutils.read_bytes_from_socket(
405
self.socket, self._report_activity)
226
def _get_bytes(self, desired_count):
227
if self._push_back_buffer is not None:
228
return self._get_push_back_buffer()
229
# We ignore the desired_count because on sockets it's more efficient to
231
return self.socket.recv(4096)
407
233
def terminate_due_to_error(self):
408
234
# TODO: This should log to a server log file, but no such thing
409
235
# exists yet. Andrew Bennetts 2006-09-29.
611
397
return self._read_bytes(count)
613
399
def _read_bytes(self, count):
614
"""Helper for SmartClientMediumRequest.read_bytes.
400
"""Helper for read_bytes.
616
402
read_bytes checks the state of the request to determing if bytes
617
403
should be read. After that it hands off to _read_bytes to do the
620
By default this forwards to self._medium.read_bytes because we are
621
operating on the medium's stream.
623
return self._medium.read_bytes(count)
406
raise NotImplementedError(self._read_bytes)
625
408
def read_line(self):
626
line = self._read_line()
627
if not line.endswith('\n'):
628
# end of file encountered reading from server
629
raise errors.ConnectionReset(
630
"Unexpected end of message. Please check connectivity "
631
"and permissions, and report a bug if problems persist.")
409
"""Read bytes from this request's response until a newline byte.
411
This isn't particularly efficient, so should only be used when the
412
expected size of the line is quite short.
414
:returns: a string of bytes ending in a newline (byte 0x0A).
416
# XXX: this duplicates SmartClientRequestProtocolOne._recv_tuple
418
while not line or line[-1] != '\n':
419
new_char = self.read_bytes(1)
422
# end of file encountered reading from server
423
raise errors.ConnectionReset(
424
"please check connectivity and permissions",
425
"(and try -Dhpss if further diagnosis is required)")
634
def _read_line(self):
635
"""Helper for SmartClientMediumRequest.read_line.
637
By default this forwards to self._medium._get_line because we are
638
operating on the medium's stream.
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
725
class SmartClientMedium(SmartMedium):
429
class SmartClientMedium(object):
726
430
"""Smart client is a medium for sending smart protocol requests over."""
728
432
def __init__(self, base):
906
585
def _accept_bytes(self, bytes):
907
586
"""See SmartClientStreamMedium.accept_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')
587
self._writeable_pipe.write(bytes)
917
589
def _flush(self):
918
590
"""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.
922
591
self._writeable_pipe.flush()
924
593
def _read_bytes(self, count):
925
594
"""See SmartClientStreamMedium._read_bytes."""
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."""
595
return self._readable_pipe.read(count)
598
class SmartSSHClientMedium(SmartClientStreamMedium):
599
"""A client medium using SSH."""
935
601
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
944
class SmartSSHClientMedium(SmartClientStreamMedium):
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):
602
base=None, vendor=None, bzr_remote_path=None):
952
603
"""Creates a client that will connect on the first use.
954
:param ssh_params: A SSHParams instance.
955
605
:param vendor: An optional override for the ssh vendor to use. See
956
606
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.
966
608
SmartClientStreamMedium.__init__(self, base)
609
self._connected = False
611
self._password = password
613
self._username = username
614
self._read_from = None
615
self._ssh_connection = None
967
616
self._vendor = vendor
968
self._ssh_connection = None
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,
617
self._write_to = None
618
self._bzr_remote_path = bzr_remote_path
619
if self._bzr_remote_path is None:
620
symbol_versioning.warn(
621
'bzr_remote_path is required as of bzr 0.92',
622
DeprecationWarning, stacklevel=2)
623
self._bzr_remote_path = os.environ.get('BZR_REMOTE_PATH', 'bzr')
986
625
def _accept_bytes(self, bytes):
987
626
"""See SmartClientStreamMedium.accept_bytes."""
988
627
self._ensure_connection()
989
self._real_medium.accept_bytes(bytes)
628
self._write_to.write(bytes)
991
630
def disconnect(self):
992
631
"""See SmartClientMedium.disconnect()."""
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
632
if not self._connected:
634
self._read_from.close()
635
self._write_to.close()
636
self._ssh_connection.close()
637
self._connected = False
1000
639
def _ensure_connection(self):
1001
640
"""Connect this medium if not already connected."""
1002
if self._real_medium is not None:
1004
643
if self._vendor is None:
1005
644
vendor = ssh._get_ssh_vendor()
1007
646
vendor = self._vendor
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',
647
self._ssh_connection = vendor.connect_ssh(self._username,
648
self._password, self._host, self._port,
649
command=[self._bzr_remote_path, 'serve', '--inet',
1012
650
'--directory=/', '--allow-writes'])
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"]:
651
self._read_from, self._write_to = \
652
self._ssh_connection.get_filelike_channels()
653
self._connected = True
1028
655
def _flush(self):
1029
656
"""See SmartClientStreamMedium._flush()."""
1030
self._real_medium._flush()
657
self._write_to.flush()
1032
659
def _read_bytes(self, count):
1033
660
"""See SmartClientStreamMedium.read_bytes."""
1034
if self._real_medium is None:
661
if not self._connected:
1035
662
raise errors.MediumNotConnected(self)
1036
return self._real_medium.read_bytes(count)
663
return self._read_from.read(count)
1039
666
# Port 4155 is the default port for bzr://, registered with IANA.
1040
BZR_DEFAULT_INTERFACE = None
667
BZR_DEFAULT_INTERFACE = '0.0.0.0'
1041
668
BZR_DEFAULT_PORT = 4155
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):
671
class SmartTCPClientMedium(SmartClientStreamMedium):
672
"""A client medium using TCP."""
674
def __init__(self, host, port, base):
675
"""Creates a client that will connect on the first use."""
1051
676
SmartClientStreamMedium.__init__(self, base)
677
self._connected = False
1052
680
self._socket = None
1053
self._connected = False
1055
682
def _accept_bytes(self, bytes):
1056
683
"""See SmartClientMedium.accept_bytes."""
1057
684
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)
685
osutils.send_all(self._socket, bytes)
1079
687
def disconnect(self):
1080
688
"""See SmartClientMedium.disconnect()."""
1084
692
self._socket = None
1085
693
self._connected = False
1088
class SmartTCPClientMedium(SmartClientSocketMedium):
1089
"""A client medium that creates a TCP connection."""
1091
def __init__(self, host, port, base):
1092
"""Creates a client that will connect on the first use."""
1093
SmartClientSocketMedium.__init__(self, base)
1097
695
def _ensure_connection(self):
1098
696
"""Connect this medium if not already connected."""
1099
697
if self._connected:
699
self._socket = socket.socket()
700
self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
1101
701
if self._port is None:
1102
702
port = BZR_DEFAULT_PORT
1104
704
port = int(self._port)
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:
706
self._socket.connect((self._host, port))
707
except socket.error, err:
1126
708
# socket errors either have a (string) or (errno, string) as their
1128
710
if type(err.args) is str:
added
removed
bzrlib/smart/medium.py
