1
# Copyright (C) 2006-2011 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""The 'medium' layer for the smart servers and clients.
19
"Medium" here is the noun meaning "a means of transmission", not the adjective
20
for "the quality between big and small."
22
Media carry the bytes of the requests somehow (e.g. via TCP, wrapped in HTTP, or
23
over SSH), and pass them to and from the protocol logic. See the overview in
24
bzrlib/transport/smart/__init__.py.
27
from __future__ import absolute_import
35
from bzrlib.lazy_import import lazy_import
36
lazy_import(globals(), """
50
from bzrlib.i18n import gettext
51
from bzrlib.smart import client, protocol, request, signals, vfs
52
from bzrlib.transport import ssh
54
from bzrlib import osutils
56
# Throughout this module buffer size parameters are either limited to be at
57
# most _MAX_READ_SIZE, or are ignored and _MAX_READ_SIZE is used instead.
58
# For this module's purposes, MAX_SOCKET_CHUNK is a reasonable size for reads
59
# from non-sockets as well.
60
_MAX_READ_SIZE = osutils.MAX_SOCKET_CHUNK
62
def _get_protocol_factory_for_bytes(bytes):
63
"""Determine the right protocol factory for 'bytes'.
65
This will return an appropriate protocol factory depending on the version
66
of the protocol being used, as determined by inspecting the given bytes.
67
The bytes should have at least one newline byte (i.e. be a whole line),
68
otherwise it's possible that a request will be incorrectly identified as
71
Typical use would be::
73
factory, unused_bytes = _get_protocol_factory_for_bytes(bytes)
74
server_protocol = factory(transport, write_func, root_client_path)
75
server_protocol.accept_bytes(unused_bytes)
77
:param bytes: a str of bytes of the start of the request.
78
:returns: 2-tuple of (protocol_factory, unused_bytes). protocol_factory is
79
a callable that takes three args: transport, write_func,
80
root_client_path. unused_bytes are any bytes that were not part of a
81
protocol version marker.
83
if bytes.startswith(protocol.MESSAGE_VERSION_THREE):
84
protocol_factory = protocol.build_server_protocol_three
85
bytes = bytes[len(protocol.MESSAGE_VERSION_THREE):]
86
elif bytes.startswith(protocol.REQUEST_VERSION_TWO):
87
protocol_factory = protocol.SmartServerRequestProtocolTwo
88
bytes = bytes[len(protocol.REQUEST_VERSION_TWO):]
90
protocol_factory = protocol.SmartServerRequestProtocolOne
91
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):
193
"""Handles smart commands coming over a stream.
195
The stream may be a pipe connected to sshd, or a tcp socket, or an
196
in-process fifo for testing.
198
One instance is created for each connected client; it can serve multiple
199
requests in the lifetime of the connection.
201
The server passes requests through to an underlying backing transport,
202
which will typically be a LocalTransport looking at the server's filesystem.
204
:ivar _push_back_buffer: a str of bytes that have been read from the stream
205
but not used yet, or None if there are no buffered bytes. Subclasses
206
should make sure to exhaust this buffer before reading more bytes from
207
the stream. See also the _push_back method.
212
def __init__(self, backing_transport, root_client_path='/', timeout=None):
213
"""Construct new server.
215
:param backing_transport: Transport for the directory served.
217
# backing_transport could be passed to serve instead of __init__
218
self.backing_transport = backing_transport
219
self.root_client_path = root_client_path
220
self.finished = False
222
raise AssertionError('You must supply a timeout.')
223
self._client_timeout = timeout
224
self._client_poll_timeout = min(timeout / 10.0, 1.0)
225
SmartMedium.__init__(self)
228
"""Serve requests until the client disconnects."""
229
# Keep a reference to stderr because the sys module's globals get set to
230
# None during interpreter shutdown.
231
from sys import stderr
233
while not self.finished:
234
server_protocol = self._build_protocol()
235
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.
243
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
def _build_protocol(self):
271
"""Identifies the version of the incoming request, and returns an
272
a protocol object that can interpret it.
274
If more bytes than the version prefix of the request are read, they will
275
be fed into the protocol before it is returned.
277
:returns: a SmartServerRequestProtocol.
279
self._wait_for_bytes_with_timeout(self._client_timeout)
281
# We're stopping, so don't try to do any more work
283
bytes = self._get_line()
284
protocol_factory, unused_bytes = _get_protocol_factory_for_bytes(bytes)
285
protocol = protocol_factory(
286
self.backing_transport, self._write_out, self.root_client_path)
287
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
def _serve_one_request(self, protocol):
322
"""Read one request from input, process, send back a response.
324
:param protocol: a SmartServerRequestProtocol.
329
self._serve_one_request_unguarded(protocol)
330
except KeyboardInterrupt:
333
self.terminate_due_to_error()
335
def terminate_due_to_error(self):
336
"""Called when an unhandled exception from the protocol occurs."""
337
raise NotImplementedError(self.terminate_due_to_error)
339
def _read_bytes(self, desired_count):
340
"""Get some bytes from the medium.
342
:param desired_count: number of bytes we want to read.
344
raise NotImplementedError(self._read_bytes)
347
class SmartServerSocketStreamMedium(SmartServerStreamMedium):
349
def __init__(self, sock, backing_transport, root_client_path='/',
353
:param sock: the socket the server will read from. It will be put
356
SmartServerStreamMedium.__init__(
357
self, backing_transport, root_client_path=root_client_path,
359
sock.setblocking(True)
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
def _serve_one_request_unguarded(self, protocol):
375
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)
383
protocol.accept_bytes(bytes)
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)
403
def _read_bytes(self, desired_count):
404
return osutils.read_bytes_from_socket(
405
self.socket, self._report_activity)
407
def terminate_due_to_error(self):
408
# TODO: This should log to a server log file, but no such thing
409
# exists yet. Andrew Bennetts 2006-09-29.
413
def _write_out(self, bytes):
414
tstart = osutils.timer_func()
415
osutils.send_all(self.socket, bytes, self._report_activity)
416
if 'hpss' in debug.debug_flags:
417
thread_id = thread.get_ident()
418
trace.mutter('%12s: [%s] %d bytes to the socket in %.3fs'
419
% ('wrote', thread_id, len(bytes),
420
osutils.timer_func() - tstart))
423
class SmartServerPipeStreamMedium(SmartServerStreamMedium):
425
def __init__(self, in_file, out_file, backing_transport, timeout=None):
426
"""Construct new server.
428
:param in_file: Python file from which requests can be read.
429
:param out_file: Python file to write responses.
430
:param backing_transport: Transport for the directory served.
432
SmartServerStreamMedium.__init__(self, backing_transport,
434
if sys.platform == 'win32':
435
# force binary mode for files
437
for f in (in_file, out_file):
438
fileno = getattr(f, 'fileno', None)
440
msvcrt.setmode(fileno(), os.O_BINARY)
445
"""See SmartServerStreamMedium.serve"""
446
# This is the regular serve, except it adds signal trapping for soft
448
stop_gracefully = self._stop_gracefully
449
signals.register_on_hangup(id(self), stop_gracefully)
451
return super(SmartServerPipeStreamMedium, self).serve()
453
signals.unregister_on_hangup(id(self))
455
def _serve_one_request_unguarded(self, protocol):
457
# We need to be careful not to read past the end of the current
458
# request, or else the read from the pipe will block, so we use
459
# protocol.next_read_size().
460
bytes_to_read = protocol.next_read_size()
461
if bytes_to_read == 0:
462
# Finished serving this request.
465
bytes = self.read_bytes(bytes_to_read)
467
# Connection has been closed.
471
protocol.accept_bytes(bytes)
473
def _disconnect_client(self):
478
def _wait_for_bytes_with_timeout(self, timeout_seconds):
479
"""Wait for more bytes to be read, but timeout if none available.
481
This allows us to detect idle connections, and stop trying to read from
482
them, without setting the socket itself to non-blocking. This also
483
allows us to specify when we watch for idle timeouts.
485
:return: None, this will raise ConnectionTimeout if we time out before
488
if (getattr(self._in, 'fileno', None) is None
489
or sys.platform == 'win32'):
490
# You can't select() file descriptors on Windows.
492
return self._wait_on_descriptor(self._in, timeout_seconds)
494
def _read_bytes(self, desired_count):
495
return self._in.read(desired_count)
497
def terminate_due_to_error(self):
498
# TODO: This should log to a server log file, but no such thing
499
# exists yet. Andrew Bennetts 2006-09-29.
503
def _write_out(self, bytes):
504
self._out.write(bytes)
507
class SmartClientMediumRequest(object):
508
"""A request on a SmartClientMedium.
510
Each request allows bytes to be provided to it via accept_bytes, and then
511
the response bytes to be read via read_bytes.
514
request.accept_bytes('123')
515
request.finished_writing()
516
result = request.read_bytes(3)
517
request.finished_reading()
519
It is up to the individual SmartClientMedium whether multiple concurrent
520
requests can exist. See SmartClientMedium.get_request to obtain instances
521
of SmartClientMediumRequest, and the concrete Medium you are using for
522
details on concurrency and pipelining.
525
def __init__(self, medium):
526
"""Construct a SmartClientMediumRequest for the medium medium."""
527
self._medium = medium
528
# we track state by constants - we may want to use the same
529
# pattern as BodyReader if it gets more complex.
530
# valid states are: "writing", "reading", "done"
531
self._state = "writing"
533
def accept_bytes(self, bytes):
534
"""Accept bytes for inclusion in this request.
536
This method may not be called after finished_writing() has been
537
called. It depends upon the Medium whether or not the bytes will be
538
immediately transmitted. Message based Mediums will tend to buffer the
539
bytes until finished_writing() is called.
541
:param bytes: A bytestring.
543
if self._state != "writing":
544
raise errors.WritingCompleted(self)
545
self._accept_bytes(bytes)
547
def _accept_bytes(self, bytes):
548
"""Helper for accept_bytes.
550
Accept_bytes checks the state of the request to determing if bytes
551
should be accepted. After that it hands off to _accept_bytes to do the
554
raise NotImplementedError(self._accept_bytes)
556
def finished_reading(self):
557
"""Inform the request that all desired data has been read.
559
This will remove the request from the pipeline for its medium (if the
560
medium supports pipelining) and any further calls to methods on the
561
request will raise ReadingCompleted.
563
if self._state == "writing":
564
raise errors.WritingNotComplete(self)
565
if self._state != "reading":
566
raise errors.ReadingCompleted(self)
568
self._finished_reading()
570
def _finished_reading(self):
571
"""Helper for finished_reading.
573
finished_reading checks the state of the request to determine if
574
finished_reading is allowed, and if it is hands off to _finished_reading
575
to perform the action.
577
raise NotImplementedError(self._finished_reading)
579
def finished_writing(self):
580
"""Finish the writing phase of this request.
582
This will flush all pending data for this request along the medium.
583
After calling finished_writing, you may not call accept_bytes anymore.
585
if self._state != "writing":
586
raise errors.WritingCompleted(self)
587
self._state = "reading"
588
self._finished_writing()
590
def _finished_writing(self):
591
"""Helper for finished_writing.
593
finished_writing checks the state of the request to determine if
594
finished_writing is allowed, and if it is hands off to _finished_writing
595
to perform the action.
597
raise NotImplementedError(self._finished_writing)
599
def read_bytes(self, count):
600
"""Read bytes from this requests response.
602
This method will block and wait for count bytes to be read. It may not
603
be invoked until finished_writing() has been called - this is to ensure
604
a message-based approach to requests, for compatibility with message
605
based mediums like HTTP.
607
if self._state == "writing":
608
raise errors.WritingNotComplete(self)
609
if self._state != "reading":
610
raise errors.ReadingCompleted(self)
611
return self._read_bytes(count)
613
def _read_bytes(self, count):
614
"""Helper for SmartClientMediumRequest.read_bytes.
616
read_bytes checks the state of the request to determing if bytes
617
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)
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.")
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):
726
"""Smart client is a medium for sending smart protocol requests over."""
728
def __init__(self, base):
729
super(SmartClientMedium, self).__init__()
731
self._protocol_version_error = None
732
self._protocol_version = None
733
self._done_hello = False
734
# Be optimistic: we assume the remote end can accept new remote
735
# requests until we get an error saying otherwise.
736
# _remote_version_is_before tracks the bzr version the remote side
737
# can be based on what we've seen so far.
738
self._remote_version_is_before = None
739
# Install debug hook function if debug flag is set.
740
if 'hpss' in debug.debug_flags:
741
global _debug_counter
742
if _debug_counter is None:
743
_debug_counter = _DebugCounter()
744
_debug_counter.track(self)
745
if 'hpss_client_no_vfs' in debug.debug_flags:
747
if _vfs_refuser is None:
748
_vfs_refuser = _VfsRefuser()
750
def _is_remote_before(self, version_tuple):
751
"""Is it possible the remote side supports RPCs for a given version?
755
needed_version = (1, 2)
756
if medium._is_remote_before(needed_version):
757
fallback_to_pre_1_2_rpc()
761
except UnknownSmartMethod:
762
medium._remember_remote_is_before(needed_version)
763
fallback_to_pre_1_2_rpc()
765
:seealso: _remember_remote_is_before
767
if self._remote_version_is_before is None:
768
# So far, the remote side seems to support everything
770
return version_tuple >= self._remote_version_is_before
772
def _remember_remote_is_before(self, version_tuple):
773
"""Tell this medium that the remote side is older the given version.
775
:seealso: _is_remote_before
777
if (self._remote_version_is_before is not None and
778
version_tuple > self._remote_version_is_before):
779
# We have been told that the remote side is older than some version
780
# which is newer than a previously supplied older-than version.
781
# This indicates that some smart verb call is not guarded
782
# appropriately (it should simply not have been tried).
784
"_remember_remote_is_before(%r) called, but "
785
"_remember_remote_is_before(%r) was called previously."
786
, version_tuple, self._remote_version_is_before)
787
if 'hpss' in debug.debug_flags:
788
ui.ui_factory.show_warning(
789
"_remember_remote_is_before(%r) called, but "
790
"_remember_remote_is_before(%r) was called previously."
791
% (version_tuple, self._remote_version_is_before))
793
self._remote_version_is_before = version_tuple
795
def protocol_version(self):
796
"""Find out if 'hello' smart request works."""
797
if self._protocol_version_error is not None:
798
raise self._protocol_version_error
799
if not self._done_hello:
801
medium_request = self.get_request()
802
# Send a 'hello' request in protocol version one, for maximum
803
# backwards compatibility.
804
client_protocol = protocol.SmartClientRequestProtocolOne(medium_request)
805
client_protocol.query_version()
806
self._done_hello = True
807
except errors.SmartProtocolError, e:
808
# Cache the error, just like we would cache a successful
810
self._protocol_version_error = e
814
def should_probe(self):
815
"""Should RemoteBzrDirFormat.probe_transport send a smart request on
818
Some transports are unambiguously smart-only; there's no need to check
819
if the transport is able to carry smart requests, because that's all
820
it is for. In those cases, this method should return False.
822
But some HTTP transports can sometimes fail to carry smart requests,
823
but still be usuable for accessing remote bzrdirs via plain file
824
accesses. So for those transports, their media should return True here
825
so that RemoteBzrDirFormat can determine if it is appropriate for that
830
def disconnect(self):
831
"""If this medium maintains a persistent connection, close it.
833
The default implementation does nothing.
836
def remote_path_from_transport(self, transport):
837
"""Convert transport into a path suitable for using in a request.
839
Note that the resulting remote path doesn't encode the host name or
840
anything but path, so it is only safe to use it in requests sent over
841
the medium from the matching transport.
843
medium_base = urlutils.join(self.base, '/')
844
rel_url = urlutils.relative_url(medium_base, transport.base)
845
return urlutils.unquote(rel_url)
848
class SmartClientStreamMedium(SmartClientMedium):
849
"""Stream based medium common class.
851
SmartClientStreamMediums operate on a stream. All subclasses use a common
852
SmartClientStreamMediumRequest for their requests, and should implement
853
_accept_bytes and _read_bytes to allow the request objects to send and
857
def __init__(self, base):
858
SmartClientMedium.__init__(self, base)
859
self._current_request = None
861
def accept_bytes(self, bytes):
862
self._accept_bytes(bytes)
865
"""The SmartClientStreamMedium knows how to close the stream when it is
871
"""Flush the output stream.
873
This method is used by the SmartClientStreamMediumRequest to ensure that
874
all data for a request is sent, to avoid long timeouts or deadlocks.
876
raise NotImplementedError(self._flush)
878
def get_request(self):
879
"""See SmartClientMedium.get_request().
881
SmartClientStreamMedium always returns a SmartClientStreamMediumRequest
884
return SmartClientStreamMediumRequest(self)
887
"""We have been disconnected, reset current state.
889
This resets things like _current_request and connected state.
892
self._current_request = None
895
class SmartSimplePipesClientMedium(SmartClientStreamMedium):
896
"""A client medium using simple pipes.
898
This client does not manage the pipes: it assumes they will always be open.
901
def __init__(self, readable_pipe, writeable_pipe, base):
902
SmartClientStreamMedium.__init__(self, base)
903
self._readable_pipe = readable_pipe
904
self._writeable_pipe = writeable_pipe
906
def _accept_bytes(self, bytes):
907
"""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:\n%s" % (e,))
915
self._report_activity(len(bytes), 'write')
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.
922
self._writeable_pipe.flush()
924
def _read_bytes(self, count):
925
"""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."""
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
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):
952
"""Creates a client that will connect on the first use.
954
:param ssh_params: A SSHParams instance.
955
:param vendor: An optional override for the ssh vendor to use. See
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.
966
SmartClientStreamMedium.__init__(self, base)
967
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,
986
def _accept_bytes(self, bytes):
987
"""See SmartClientStreamMedium.accept_bytes."""
988
self._ensure_connection()
989
self._real_medium.accept_bytes(bytes)
991
def disconnect(self):
992
"""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
1000
def _ensure_connection(self):
1001
"""Connect this medium if not already connected."""
1002
if self._real_medium is not None:
1004
if self._vendor is None:
1005
vendor = ssh._get_ssh_vendor()
1007
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',
1012
'--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"]:
1029
"""See SmartClientStreamMedium._flush()."""
1030
self._real_medium._flush()
1032
def _read_bytes(self, count):
1033
"""See SmartClientStreamMedium.read_bytes."""
1034
if self._real_medium is None:
1035
raise errors.MediumNotConnected(self)
1036
return self._real_medium.read_bytes(count)
1039
# Port 4155 is the default port for bzr://, registered with IANA.
1040
BZR_DEFAULT_INTERFACE = None
1041
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):
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."""
1091
def __init__(self, host, port, base):
1092
"""Creates a client that will connect on the first use."""
1093
SmartClientSocketMedium.__init__(self, base)
1097
def _ensure_connection(self):
1098
"""Connect this medium if not already connected."""
1101
if self._port is None:
1102
port = BZR_DEFAULT_PORT
1104
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:
1126
# socket errors either have a (string) or (errno, string) as their
1128
if type(err.args) is str:
1131
err_msg = err.args[1]
1132
raise errors.ConnectionError("failed to connect to %s:%d: %s" %
1133
(self._host, port, err_msg))
1134
self._connected = True
1135
for hook in transport.Transport.hooks["post_connect"]:
1139
class SmartClientAlreadyConnectedSocketMedium(SmartClientSocketMedium):
1140
"""A client medium for an already connected socket.
1142
Note that this class will assume it "owns" the socket, so it will close it
1143
when its disconnect method is called.
1146
def __init__(self, base, sock):
1147
SmartClientSocketMedium.__init__(self, base)
1149
self._connected = True
1151
def _ensure_connection(self):
1152
# Already connected, by definition! So nothing to do.
1156
class SmartClientStreamMediumRequest(SmartClientMediumRequest):
1157
"""A SmartClientMediumRequest that works with an SmartClientStreamMedium."""
1159
def __init__(self, medium):
1160
SmartClientMediumRequest.__init__(self, medium)
1161
# check that we are safe concurrency wise. If some streams start
1162
# allowing concurrent requests - i.e. via multiplexing - then this
1163
# assert should be moved to SmartClientStreamMedium.get_request,
1164
# and the setting/unsetting of _current_request likewise moved into
1165
# that class : but its unneeded overhead for now. RBC 20060922
1166
if self._medium._current_request is not None:
1167
raise errors.TooManyConcurrentRequests(self._medium)
1168
self._medium._current_request = self
1170
def _accept_bytes(self, bytes):
1171
"""See SmartClientMediumRequest._accept_bytes.
1173
This forwards to self._medium._accept_bytes because we are operating
1174
on the mediums stream.
1176
self._medium._accept_bytes(bytes)
1178
def _finished_reading(self):
1179
"""See SmartClientMediumRequest._finished_reading.
1181
This clears the _current_request on self._medium to allow a new
1182
request to be created.
1184
if self._medium._current_request is not self:
1185
raise AssertionError()
1186
self._medium._current_request = None
1188
def _finished_writing(self):
1189
"""See SmartClientMediumRequest._finished_writing.
1191
This invokes self._medium._flush to ensure all bytes are transmitted.
1193
self._medium._flush()
added
removed
bzrlib/smart/medium.py
