Merge ~sylvain-pineau/checkbox-ng:remote-gee-up into checkbox-ng:master

[Sylvain Pineau]

Two patches for two checkbox RPyC issues:

1. slowness when dealing with ultra verbose I/O logs

It could takes 5 to 20 minutes on a slow devices to process jobs like the sysfs-attachment. The mechanism relying on python Queues was the bottleneck. Instead the patch is still buffering the I/O logs but this time in a io.stringio memory buffer, much more efficient. The benchmarking provider on my i7 reports pretty much the same timings as the local run for the remote-templatey launcher.

2. slowness when generating reports

The solution is to generate reports on the slave. Master is using the exported stream filehandle to read from it instead of offering a filehandle to the slave for writing (much much slower). A new dependency (tqdm) will help monitoring the submission reports transfer from slave tom master (see below).

New dependency: python3-tqdm

Xenial backport:
https://launchpad.net/~checkbox-dev/+archive/ubuntu/ppa/+packages?field.name_filter=tqdm&field.status_filter=published&field.series_filter=xenial

Packaging:
https://git.launchpad.net/~checkbox-dev/checkbox-ng/+git/packaging/commit/?id=11424ad85ca3bc0e1d16f61f348a3c4decd78c0e

Checkbox core snap: master & s16 rebased:
https://code.launchpad.net/~sylvain-pineau/checkbox-core-snap/+git/checkbox-core-snap/+merge/380481

[Maciej Kisielewski (kissiel)]

Wonderful patchset. Landable as is, but see my comments for some potential improvements in fit and finish.

review: Approve

[Sylvain Pineau (sylvain-pineau)]

Landing after testing various type of encodings for the slave (including ASCII). Seems to work well. Fixed a few pep8 errors and bumped to remote API to 10.

review: Approve

diff --git a/checkbox_ng/launcher/master.py b/checkbox_ng/launcher/master.py
index fd14a54..8c29e91 100644
--- a/checkbox_ng/launcher/master.py
+++ b/checkbox_ng/launcher/master.py
@@ -49,6 +49,7 @@ from checkbox_ng.urwid_ui import resume_dialog
 from checkbox_ng.launcher.run import NormalUI, ReRunJob
 from checkbox_ng.launcher.stages import MainLoopStage
 from checkbox_ng.launcher.stages import ReportsStage
+from tqdm import tqdm
 _ = gettext.gettext
 _logger = logging.getLogger("master")
 
@@ -77,10 +78,10 @@ class SimpleUI(NormalUI, MainLoopStage):
         print(SimpleUI.C.header(header, fill='-'))
 
     def green_text(text, end='\n'):
-        print(SimpleUI.C.GREEN(text), end=end)
+        print(SimpleUI.C.GREEN(text), end=end, file=sys.stdout)
 
     def red_text(text, end='\n'):
-        print(SimpleUI.C.RED(text), end=end)
+        print(SimpleUI.C.RED(text), end=end, file=sys.stderr)
 
     def horiz_line():
         print(SimpleUI.C.WHITE('-' * 80))
@@ -160,7 +161,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
     def connect_and_run(self, host, port=18871):
         config = rpyc.core.protocol.DEFAULT_CONFIG.copy()
         config['allow_all_attrs'] = True
-        config['sync_request_timeout'] = 60
+        config['sync_request_timeout'] = 120
         keep_running = False
         self._prepare_transports()
         interrupted = False
@@ -416,11 +417,11 @@ class RemoteMaster(ReportsStage, MainLoopStage):
         while True:
             state, payload = self.sa.monitor_job()
             if payload and not self._is_bootstrapping:
-                for stream, line in payload:
-                    if stream == 'stderr':
-                        SimpleUI.red_text(line, end='')
+                for line in payload.splitlines():
+                    if line.startswith('stderr'):
+                        SimpleUI.red_text(line[6:])
                     else:
-                        SimpleUI.green_text(line, end='')
+                        SimpleUI.green_text(line[6:])
             if state == 'running':
                 time.sleep(0.5)
                 while True:
@@ -452,13 +453,36 @@ class RemoteMaster(ReportsStage, MainLoopStage):
         self.abandon()
         self.new_session()
 
+    def _download_file(conn, remotepath, localpath, chunk_size=16384):
+        try:
+            rf = conn.root.open(remotepath, "rb")
+            with tqdm(total=conn.root.getsize(remotepath), unit='B', unit_scale=True, unit_divisor=1024) as pbar:
+                with open(localpath, "wb") as lf:
+                    while True:
+                        buf = rf.read(chunk_size)
+                        pbar.set_postfix(file=remotepath, refresh=False)
+                        pbar.update(chunk_size)
+                        if not buf:
+                            break
+                        #time.sleep(0.01)
+                        lf.write(buf)
+        finally:
+            rf.close()
+
     def local_export(self, exporter_id, transport, options=()):
         _logger.info("master: Exporting locally'")
-        exporter = self._sa.manager.create_exporter(exporter_id, options)
+        rf = self.sa.cache_report(exporter_id, options)
         exported_stream = SpooledTemporaryFile(max_size=102400, mode='w+b')
-        async_dump = rpyc.async_(exporter.dump_from_session_manager)
-        res = async_dump(self._sa.manager, exported_stream)
-        res.wait()
+        chunk_size=16384
+        with tqdm(total=rf.tell(), unit='B', unit_scale=True, unit_divisor=1024) as pbar:
+            rf.seek(0)
+            while True:
+                buf = rf.read(chunk_size)
+                pbar.set_postfix(file=transport.url, refresh=False)
+                pbar.update(chunk_size)
+                if not buf:
+                    break
+                exported_stream.write(buf)
         exported_stream.seek(0)
         result = transport.send(exported_stream)
         return result
diff --git a/plainbox/impl/session/remote_assistant.py b/plainbox/impl/session/remote_assistant.py
index e1652f0..7185bb9 100644
--- a/plainbox/impl/session/remote_assistant.py
+++ b/plainbox/impl/session/remote_assistant.py
@@ -16,14 +16,14 @@
 # You should have received a copy of the GNU General Public License
 # along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
 import fnmatch
+import io
 import json
 import gettext
 import logging
 import os
-import queue
 import time
-import sys
 from collections import namedtuple
+from tempfile import SpooledTemporaryFile
 from threading import Thread, Lock
 from subprocess import CalledProcessError, check_output
 
@@ -69,22 +69,25 @@ Finalizing = 'finalizing'
 class BufferedUI(SilentUI):
     """UI type that queues the output for later reading."""
 
-    # XXX: using as string as a buffer and one lock over it
-    #      might be a cleaner approach than those queues
     def __init__(self):
         super().__init__()
-        self._queue = queue.Queue()
+        self.lock = Lock()
+        self._output = io.StringIO()
 
     def got_program_output(self, stream_name, line):
-        self._queue.put(
-            (stream_name, line.decode(sys.stdout.encoding, 'replace')))
+        with self.lock:
+            try:
+                self._output.write(stream_name + line.decode("UTF-8"))
+            except UnicodeDecodeError:
+                # Don't start a slave->master transfer for binary attachments
+                pass
 
     def get_output(self):
         """Returns all the output queued up since previous call."""
-        output = []
-        while not self._queue.empty():
-            output.append(self._queue.get())
-        return output
+        with self.lock:
+            output = self._output.getvalue()
+            self._output = io.StringIO()
+            return output
 
 
 class BackgroundExecutor(Thread):
@@ -119,7 +122,7 @@ class BackgroundExecutor(Thread):
 class RemoteSessionAssistant():
     """Remote execution enabling wrapper for the SessionAssistant"""
 
-    REMOTE_API_VERSION = 9
+    REMOTE_API_VERSION = 10
 
     def __init__(self, cmd_callback):
         _logger.debug("__init__()")
@@ -212,8 +215,8 @@ class RemoteSessionAssistant():
                 # psutil < 4.0.0 doesn't provide Process.environ()
                 return self._prepare_display_without_psutil()
             except psutil.NoSuchProcess:
-                # quietly ignore the process that died before we had a chance to
-                # read the environment from them
+                # quietly ignore the process that died before we had a chance
+                # to read the environment from them
                 continue
             if ("DISPLAY" in p_environ and p_user != 'gdm'):  # gdm uses :1024
                 return {'DISPLAY': p_environ['DISPLAY']}
@@ -635,3 +638,10 @@ class RemoteSessionAssistant():
     @property
     def sideloaded_providers(self):
         return self._sa.sideloaded_providers
+
+    def exposed_cache_report(self, exporter_id, options):
+        exporter = self._sa._manager.create_exporter(exporter_id, options)
+        exported_stream = SpooledTemporaryFile(max_size=102400, mode='w+b')
+        exporter.dump_from_session_manager(self._sa._manager, exported_stream)
+        exported_stream.flush()
+        return exported_stream
diff --git a/plainbox/vendor/rpyc/__init__.py b/plainbox/vendor/rpyc/__init__.py
index 7daf69c..9cd71d5 100644
--- a/plainbox/vendor/rpyc/__init__.py
+++ b/plainbox/vendor/rpyc/__init__.py
@@ -41,12 +41,13 @@ Classic-style usage::
     ...
 
 """
+# flake8: noqa: F401
 from plainbox.vendor.rpyc.core import (SocketStream, TunneledSocketStream, PipeStream, Channel,
-    Connection, Service, BaseNetref, AsyncResult, GenericException,
-    AsyncResultTimeout, VoidService, SlaveService, MasterService, ClassicService)
+                       Connection, Service, BaseNetref, AsyncResult, GenericException,
+                       AsyncResultTimeout, VoidService, SlaveService, MasterService, ClassicService)
 from plainbox.vendor.rpyc.utils.factory import (connect_stream, connect_channel, connect_pipes,
-    connect_stdpipes, connect, ssl_connect, discover, connect_by_service, connect_subproc,
-    connect_thread, ssh_connect)
+                                connect_stdpipes, connect, ssl_connect, discover, connect_by_service, connect_subproc,
+                                connect_thread, ssh_connect)
 from plainbox.vendor.rpyc.utils.helpers import async_, timed, buffiter, BgServingThread, restricted
 from plainbox.vendor.rpyc.utils import classic
 from plainbox.vendor.rpyc.version import version as __version__
diff --git a/plainbox/vendor/rpyc/core/__init__.py b/plainbox/vendor/rpyc/core/__init__.py
index fb52c51..4155f1c 100644
--- a/plainbox/vendor/rpyc/core/__init__.py
+++ b/plainbox/vendor/rpyc/core/__init__.py
@@ -1,8 +1,8 @@
+# flake8: noqa: F401
 from plainbox.vendor.rpyc.core.stream import SocketStream, TunneledSocketStream, PipeStream
 from plainbox.vendor.rpyc.core.channel import Channel
 from plainbox.vendor.rpyc.core.protocol import Connection
 from plainbox.vendor.rpyc.core.netref import BaseNetref
 from plainbox.vendor.rpyc.core.async_ import AsyncResult, AsyncResultTimeout
-from plainbox.vendor.rpyc.core.service import (Service, VoidService, SlaveService, MasterService,
-                               ClassicService)
+from plainbox.vendor.rpyc.core.service import Service, VoidService, SlaveService, MasterService, ClassicService
 from plainbox.vendor.rpyc.core.vinegar import GenericException
diff --git a/plainbox/vendor/rpyc/core/async.py b/plainbox/vendor/rpyc/core/async.py
index 96706b3..36dd63a 100644
--- a/plainbox/vendor/rpyc/core/async.py
+++ b/plainbox/vendor/rpyc/core/async.py
@@ -1,2 +1,2 @@
 """Backward compatibility alias on py<=3.6."""
-from plainbox.vendor.rpyc.core.async_ import *
+from plainbox.vendor.rpyc.core.async_ import *  # noqa
diff --git a/plainbox/vendor/rpyc/core/async_.py b/plainbox/vendor/rpyc/core/async_.py
index 7812a37..fd69027 100644
--- a/plainbox/vendor/rpyc/core/async_.py
+++ b/plainbox/vendor/rpyc/core/async_.py
@@ -1,4 +1,4 @@
-import time
+import time  # noqa: F401
 from plainbox.vendor.rpyc.lib import Timeout
 from plainbox.vendor.rpyc.lib.compat import TimeoutError as AsyncResultTimeout
 
@@ -9,6 +9,7 @@ class AsyncResult(object):
     result (which will block if the result has not yet arrived).
     """
     __slots__ = ["_conn", "_is_ready", "_is_exc", "_callbacks", "_obj", "_ttl"]
+
     def __init__(self, conn):
         self._conn = conn
         self._is_ready = False
@@ -16,6 +17,7 @@ class AsyncResult(object):
         self._obj = None
         self._callbacks = []
         self._ttl = Timeout(None)
+
     def __repr__(self):
         if self._is_ready:
             state = "ready"
@@ -58,6 +60,7 @@ class AsyncResult(object):
             func(self)
         else:
             self._callbacks.append(func)
+
     def set_expiry(self, timeout):
         """Sets the expiry time (in seconds, relative to now) or ``None`` for
         unlimited time
@@ -75,10 +78,12 @@ class AsyncResult(object):
             return False
         self._conn.poll_all()
         return self._is_ready
+
     @property
     def error(self):
         """Indicates whether the returned result is an exception"""
         return self.ready and self._is_exc
+
     @property
     def expired(self):
         """Indicates whether the AsyncResult has expired"""
diff --git a/plainbox/vendor/rpyc/core/brine.py b/plainbox/vendor/rpyc/core/brine.py
index 30f4135..0545cb3 100644
--- a/plainbox/vendor/rpyc/core/brine.py
+++ b/plainbox/vendor/rpyc/core/brine.py
@@ -1,56 +1,55 @@
-"""
-**Brine** is a simple, fast and secure object serializer for **immutable** objects.
+"""*Brine* is a simple, fast and secure object serializer for **immutable** objects.
+
 The following types are supported: ``int``, ``long``, ``bool``, ``str``, ``float``,
 ``unicode``, ``bytes``, ``slice``, ``complex``, ``tuple`` (of simple types),
 ``frozenset`` (of simple types) as well as the following singletons: ``None``,
 ``NotImplemented``, and ``Ellipsis``.
 
 Example::
-
-    >>> x = ("he", 7, u"llo", 8, (), 900, None, True, Ellipsis, 18.2, 18.2j + 13,
-    ... slice(1,2,3), frozenset([5,6,7]), NotImplemented)
-    >>> dumpable(x)
-    True
-    >>> y = dump(x)
-    >>> y.encode("hex")
-    '140e0b686557080c6c6c6f580216033930300003061840323333333333331b402a000000000000403233333333333319125152531a1255565705'
-    >>> z = load(y)
-    >>> x == z
-    True
+ >>> x = ("he", 7, u"llo", 8, (), 900, None, True, Ellipsis, 18.2, 18.2j + 13,
+ ... slice(1,2,3), frozenset([5,6,7]), NotImplemented)
+ >>> dumpable(x)
+ True
+ >>> y = dump(x)
+ >>> y.encode("hex")
+ '140e0b686557080c6c6c6f580216033930300003061840323333333333331b402a000000000000403233333333333319125152531a1255565705'
+ >>> z = load(y)
+ >>> x == z
+ True
 """
-from plainbox.vendor.rpyc.lib.compat import Struct, BytesIO, is_py3k, BYTES_LITERAL
+from plainbox.vendor.rpyc.lib.compat import Struct, BytesIO, is_py_3k, BYTES_LITERAL
 
 
 # singletons
-TAG_NONE            = b"\x00"
-TAG_EMPTY_STR       = b"\x01"
-TAG_EMPTY_TUPLE     = b"\x02"
-TAG_TRUE            = b"\x03"
-TAG_FALSE           = b"\x04"
+TAG_NONE = b"\x00"
+TAG_EMPTY_STR = b"\x01"
+TAG_EMPTY_TUPLE = b"\x02"
+TAG_TRUE = b"\x03"
+TAG_FALSE = b"\x04"
 TAG_NOT_IMPLEMENTED = b"\x05"
-TAG_ELLIPSIS        = b"\x06"
+TAG_ELLIPSIS = b"\x06"
 # types
-TAG_UNICODE         = b"\x08"
-TAG_LONG            = b"\x09"
-TAG_STR1            = b"\x0a"
-TAG_STR2            = b"\x0b"
-TAG_STR3            = b"\x0c"
-TAG_STR4            = b"\x0d"
-TAG_STR_L1          = b"\x0e"
-TAG_STR_L4          = b"\x0f"
-TAG_TUP1            = b"\x10"
-TAG_TUP2            = b"\x11"
-TAG_TUP3            = b"\x12"
-TAG_TUP4            = b"\x13"
-TAG_TUP_L1          = b"\x14"
-TAG_TUP_L4          = b"\x15"
-TAG_INT_L1          = b"\x16"
-TAG_INT_L4          = b"\x17"
-TAG_FLOAT           = b"\x18"
-TAG_SLICE           = b"\x19"
-TAG_FSET            = b"\x1a"
-TAG_COMPLEX         = b"\x1b"
-if is_py3k:
+TAG_UNICODE = b"\x08"
+TAG_LONG = b"\x09"
+TAG_STR1 = b"\x0a"
+TAG_STR2 = b"\x0b"
+TAG_STR3 = b"\x0c"
+TAG_STR4 = b"\x0d"
+TAG_STR_L1 = b"\x0e"
+TAG_STR_L4 = b"\x0f"
+TAG_TUP1 = b"\x10"
+TAG_TUP2 = b"\x11"
+TAG_TUP3 = b"\x12"
+TAG_TUP4 = b"\x13"
+TAG_TUP_L1 = b"\x14"
+TAG_TUP_L4 = b"\x15"
+TAG_INT_L1 = b"\x16"
+TAG_INT_L4 = b"\x17"
+TAG_FLOAT = b"\x18"
+TAG_SLICE = b"\x19"
+TAG_FSET = b"\x1a"
+TAG_COMPLEX = b"\x1b"
+if is_py_3k:
     IMM_INTS = dict((i, bytes([i + 0x50])) for i in range(-0x30, 0xa0))
 else:
     IMM_INTS = dict((i, chr(i + 0x50)) for i in range(-0x30, 0xa0))
@@ -64,27 +63,31 @@ _dump_registry = {}
 _load_registry = {}
 IMM_INTS_LOADER = dict((v, k) for k, v in IMM_INTS.items())
 
+
 def register(coll, key):
     def deco(func):
         coll[key] = func
         return func
     return deco
 
-#===============================================================================
+# ===============================================================================
 # dumping
-#===============================================================================
+# ===============================================================================
 @register(_dump_registry, type(None))
 def _dump_none(obj, stream):
     stream.append(TAG_NONE)
 
+
 @register(_dump_registry, type(NotImplemented))
 def _dump_notimplemeted(obj, stream):
     stream.append(TAG_NOT_IMPLEMENTED)
 
+
 @register(_dump_registry, type(Ellipsis))
 def _dump_ellipsis(obj, stream):
     stream.append(TAG_ELLIPSIS)
 
+
 @register(_dump_registry, bool)
 def _dump_bool(obj, stream):
     if obj:
@@ -92,53 +95,60 @@ def _dump_bool(obj, stream):
     else:
         stream.append(TAG_FALSE)
 
+
 @register(_dump_registry, slice)
 def _dump_slice(obj, stream):
     stream.append(TAG_SLICE)
     _dump((obj.start, obj.stop, obj.step), stream)
 
+
 @register(_dump_registry, frozenset)
 def _dump_frozenset(obj, stream):
     stream.append(TAG_FSET)
     _dump(tuple(obj), stream)
 
+
 @register(_dump_registry, int)
 def _dump_int(obj, stream):
     if obj in IMM_INTS:
         stream.append(IMM_INTS[obj])
     else:
         obj = BYTES_LITERAL(str(obj))
-        l = len(obj)
-        if l < 256:
-            stream.append(TAG_INT_L1 + I1.pack(l) + obj)
+        lenobj = len(obj)
+        if lenobj < 256:
+            stream.append(TAG_INT_L1 + I1.pack(lenobj) + obj)
         else:
-            stream.append(TAG_INT_L4 + I4.pack(l) + obj)
+            stream.append(TAG_INT_L4 + I4.pack(lenobj) + obj)
+
 
 @register(_dump_registry, float)
 def _dump_float(obj, stream):
     stream.append(TAG_FLOAT + F8.pack(obj))
 
+
 @register(_dump_registry, complex)
 def _dump_complex(obj, stream):
     stream.append(TAG_COMPLEX + C16.pack(obj.real, obj.imag))
 
+
 @register(_dump_registry, bytes)
 def _dump_bytes(obj, stream):
-    l = len(obj)
-    if l == 0:
+    lenobj = len(obj)
+    if lenobj == 0:
         stream.append(TAG_EMPTY_STR)
-    elif l == 1:
+    elif lenobj == 1:
         stream.append(TAG_STR1 + obj)
-    elif l == 2:
+    elif lenobj == 2:
         stream.append(TAG_STR2 + obj)
-    elif l == 3:
+    elif lenobj == 3:
         stream.append(TAG_STR3 + obj)
-    elif l == 4:
+    elif lenobj == 4:
         stream.append(TAG_STR4 + obj)
-    elif l < 256:
-        stream.append(TAG_STR_L1 + I1.pack(l) + obj)
+    elif lenobj < 256:
+        stream.append(TAG_STR_L1 + I1.pack(lenobj) + obj)
     else:
-        stream.append(TAG_STR_L4 + I4.pack(l) + obj)
+        stream.append(TAG_STR_L4 + I4.pack(lenobj) + obj)
+
 
 @register(_dump_registry, type(u""))
 def _dump_str(obj, stream):
@@ -146,8 +156,8 @@ def _dump_str(obj, stream):
     _dump_bytes(obj.encode("utf8"), stream)
 
 
-if not is_py3k:
-    @register(_dump_registry, long)
+if not is_py_3k:
+    @register(_dump_registry, long)  # noqa: F821
     def _dump_long(obj, stream):
         stream.append(TAG_LONG)
         _dump_int(obj, stream)
@@ -155,57 +165,71 @@ if not is_py3k:
 
 @register(_dump_registry, tuple)
 def _dump_tuple(obj, stream):
-    l = len(obj)
-    if l == 0:
+    lenobj = len(obj)
+    if lenobj == 0:
         stream.append(TAG_EMPTY_TUPLE)
-    elif l == 1:
+    elif lenobj == 1:
         stream.append(TAG_TUP1)
-    elif l == 2:
+    elif lenobj == 2:
         stream.append(TAG_TUP2)
-    elif l == 3:
+    elif lenobj == 3:
         stream.append(TAG_TUP3)
-    elif l == 4:
+    elif lenobj == 4:
         stream.append(TAG_TUP4)
-    elif l < 256:
-        stream.append(TAG_TUP_L1 + I1.pack(l))
+    elif lenobj < 256:
+        stream.append(TAG_TUP_L1 + I1.pack(lenobj))
     else:
-        stream.append(TAG_TUP_L4 + I4.pack(l))
+        stream.append(TAG_TUP_L4 + I4.pack(lenobj))
     for item in obj:
         _dump(item, stream)
 
+
 def _undumpable(obj, stream):
     raise TypeError("cannot dump %r" % (obj,))
 
+
 def _dump(obj, stream):
     _dump_registry.get(type(obj), _undumpable)(obj, stream)
 
-#===============================================================================
+# ===============================================================================
 # loading
-#===============================================================================
+# ===============================================================================
 @register(_load_registry, TAG_NONE)
 def _load_none(stream):
     return None
+
+
 @register(_load_registry, TAG_NOT_IMPLEMENTED)
 def _load_nonimp(stream):
     return NotImplemented
+
+
 @register(_load_registry, TAG_ELLIPSIS)
 def _load_elipsis(stream):
     return Ellipsis
+
+
 @register(_load_registry, TAG_TRUE)
 def _load_true(stream):
     return True
+
+
 @register(_load_registry, TAG_FALSE)
 def _load_false(stream):
     return False
+
+
 @register(_load_registry, TAG_EMPTY_TUPLE)
 def _load_empty_tuple(stream):
     return ()
 
+
 @register(_load_registry, TAG_EMPTY_STR)
 def _load_empty_str(stream):
     return b""
 
-if is_py3k:
+
+if is_py_3k:
     @register(_load_registry, TAG_LONG)
     def _load_long(stream):
         obj = _load(stream)
@@ -214,60 +238,85 @@ else:
     @register(_load_registry, TAG_LONG)
     def _load_long(stream):
         obj = _load(stream)
-        return long(obj)
+        return long(obj)  # noqa: F821
+
 
 @register(_load_registry, TAG_FLOAT)
 def _load_float(stream):
     return F8.unpack(stream.read(8))[0]
+
+
 @register(_load_registry, TAG_COMPLEX)
 def _load_complex(stream):
     real, imag = C16.unpack(stream.read(16))
     return complex(real, imag)
 
+
 @register(_load_registry, TAG_STR1)
 def _load_str1(stream):
     return stream.read(1)
+
+
 @register(_load_registry, TAG_STR2)
 def _load_str2(stream):
     return stream.read(2)
+
+
 @register(_load_registry, TAG_STR3)
 def _load_str3(stream):
     return stream.read(3)
+
+
 @register(_load_registry, TAG_STR4)
 def _load_str4(stream):
     return stream.read(4)
+
+
 @register(_load_registry, TAG_STR_L1)
 def _load_str_l1(stream):
     l, = I1.unpack(stream.read(1))
     return stream.read(l)
+
+
 @register(_load_registry, TAG_STR_L4)
 def _load_str_l4(stream):
     l, = I4.unpack(stream.read(4))
     return stream.read(l)
 
+
 @register(_load_registry, TAG_UNICODE)
 def _load_unicode(stream):
     obj = _load(stream)
     return obj.decode("utf-8")
 
+
 @register(_load_registry, TAG_TUP1)
 def _load_tup1(stream):
     return (_load(stream),)
+
+
 @register(_load_registry, TAG_TUP2)
 def _load_tup2(stream):
     return (_load(stream), _load(stream))
+
+
 @register(_load_registry, TAG_TUP3)
 def _load_tup3(stream):
     return (_load(stream), _load(stream), _load(stream))
+
+
 @register(_load_registry, TAG_TUP4)
 def _load_tup4(stream):
     return (_load(stream), _load(stream), _load(stream), _load(stream))
+
+
 @register(_load_registry, TAG_TUP_L1)
 def _load_tup_l1(stream):
     l, = I1.unpack(stream.read(1))
     return tuple(_load(stream) for i in range(l))
 
-if is_py3k:
+
+if is_py_3k:
     @register(_load_registry, TAG_TUP_L4)
     def _load_tup_l4(stream):
         l, = I4.unpack(stream.read(4))
@@ -276,34 +325,43 @@ else:
     @register(_load_registry, TAG_TUP_L4)
     def _load_tup_l4(stream):
         l, = I4.unpack(stream.read(4))
-        return tuple(_load(stream) for i in xrange(l))
+        return tuple(_load(stream) for i in xrange(l))  # noqa
+
 
 @register(_load_registry, TAG_SLICE)
 def _load_slice(stream):
     start, stop, step = _load(stream)
     return slice(start, stop, step)
+
+
 @register(_load_registry, TAG_FSET)
 def _load_frozenset(stream):
     return frozenset(_load(stream))
 
+
 @register(_load_registry, TAG_INT_L1)
 def _load_int_l1(stream):
     l, = I1.unpack(stream.read(1))
     return int(stream.read(l))
+
+
 @register(_load_registry, TAG_INT_L4)
 def _load_int_l4(stream):
     l, = I4.unpack(stream.read(4))
     return int(stream.read(l))
 
+
 def _load(stream):
     tag = stream.read(1)
     if tag in IMM_INTS_LOADER:
         return IMM_INTS_LOADER[tag]
     return _load_registry.get(tag)(stream)
 
-#===============================================================================
+# ===============================================================================
 # API
-#===============================================================================
+# ===============================================================================
+
+
 def dump(obj):
     """Converts (dumps) the given object to a byte-string representation
 
@@ -315,6 +373,7 @@ def dump(obj):
     _dump(obj, stream)
     return b"".join(stream)
 
+
 def load(data):
     """Recreates (loads) an object from its byte-string representation
 
@@ -325,12 +384,14 @@ def load(data):
     stream = BytesIO(data)
     return _load(stream)
 
-if is_py3k:
+
+if is_py_3k:
     simple_types = frozenset([type(None), int, bool, float, bytes, str, complex,
-        type(NotImplemented), type(Ellipsis)])
+                              type(NotImplemented), type(Ellipsis)])
 else:
-    simple_types = frozenset([type(None), int, long, bool, float, bytes, unicode, complex,
-        type(NotImplemented), type(Ellipsis)])
+    simple_types = frozenset([type(None), int, long, bool, float, bytes, unicode, complex,  # noqa: F821
+                              type(NotImplemented), type(Ellipsis)])
+
 
 def dumpable(obj):
     """Indicates whether the given object is *dumpable* by brine
diff --git a/plainbox/vendor/rpyc/core/channel.py b/plainbox/vendor/rpyc/core/channel.py
index 4d23e24..e0c9bfd 100644
--- a/plainbox/vendor/rpyc/core/channel.py
+++ b/plainbox/vendor/rpyc/core/channel.py
@@ -1,5 +1,4 @@
-"""
-*Channel* is an abstraction layer over streams that works with *packets of data*,
+"""*Channel* is an abstraction layer over streams that works with *packets of data*,
 rather than an endless stream of bytes, and adds support for compression.
 """
 from plainbox.vendor.rpyc.lib import safe_import
@@ -10,6 +9,7 @@ zlib = safe_import("zlib")
 # * separate \n into a FlushingChannel subclass?
 # * add thread safety as a subclass?
 
+
 class Channel(object):
     """Channel implementation.
 
@@ -20,27 +20,32 @@ class Channel(object):
     COMPRESSION_THRESHOLD = 3000
     COMPRESSION_LEVEL = 1
     FRAME_HEADER = Struct("!LB")
-    FLUSHER = BYTES_LITERAL("\n") # cause any line-buffered layers below us to flush
+    FLUSHER = BYTES_LITERAL("\n")  # cause any line-buffered layers below us to flush
     __slots__ = ["stream", "compress"]
 
-    def __init__(self, stream, compress = True):
+    def __init__(self, stream, compress=True):
         self.stream = stream
         if not zlib:
             compress = False
         self.compress = compress
+
     def close(self):
         """closes the channel and underlying stream"""
         self.stream.close()
+
     @property
     def closed(self):
         """indicates whether the underlying stream has been closed"""
         return self.stream.closed
+
     def fileno(self):
         """returns the file descriptor of the underlying stream"""
         return self.stream.fileno()
+
     def poll(self, timeout):
         """polls the underlying steam for data, waiting up to *timeout* seconds"""
         return self.stream.poll(timeout)
+
     def recv(self):
         """Receives the next packet (or *frame*) from the underlying stream.
         This method will block until the packet has been read completely
@@ -53,6 +58,7 @@ class Channel(object):
         if compressed:
             data = zlib.decompress(data)
         return data
+
     def send(self, data):
         """Sends the given string of data as a packet over the underlying
         stream. Blocks until the packet has been sent.
@@ -64,7 +70,15 @@ class Channel(object):
             data = zlib.compress(data, self.COMPRESSION_LEVEL)
         else:
             compressed = 0
-        header = self.FRAME_HEADER.pack(len(data), compressed)
-        buf = header + data + self.FLUSHER
-        self.stream.write(buf)
-
+        data_size = len(data)
+        header = self.FRAME_HEADER.pack(data_size, compressed)
+        flush_size = len(self.FLUSHER)
+        if self.FRAME_HEADER.size + data_size + flush_size <= self.stream.MAX_IO_CHUNK:
+            # avoid overhead from socket writes requiring GIL to be held
+            self.stream.write(header + data + self.FLUSHER)
+        else:
+            # Data larger than 64KB, the extra writes are negligible
+            part1 = self.stream.MAX_IO_CHUNK - self.FRAME_HEADER.size
+            self.stream.write(header + data[:part1])
+            self.stream.write(data[part1:])
+            self.stream.write(self.FLUSHER)
diff --git a/plainbox/vendor/rpyc/core/consts.py b/plainbox/vendor/rpyc/core/consts.py
index 877999b..31a532d 100644
--- a/plainbox/vendor/rpyc/core/consts.py
+++ b/plainbox/vendor/rpyc/core/consts.py
@@ -1,43 +1,42 @@
-"""
-Constants used by the protocol
+"""Constants used by the protocol
 """
 
 # messages
-MSG_REQUEST      = 1
-MSG_REPLY        = 2
-MSG_EXCEPTION    = 3
+MSG_REQUEST = 1
+MSG_REPLY = 2
+MSG_EXCEPTION = 3
 
 # boxing
-LABEL_VALUE      = 1
-LABEL_TUPLE      = 2
-LABEL_LOCAL_REF  = 3
+LABEL_VALUE = 1
+LABEL_TUPLE = 2
+LABEL_LOCAL_REF = 3
 LABEL_REMOTE_REF = 4
 
 # action handlers
-HANDLE_PING        = 1
-HANDLE_CLOSE       = 2
-HANDLE_GETROOT     = 3
-HANDLE_GETATTR     = 4
-HANDLE_DELATTR     = 5
-HANDLE_SETATTR     = 6
-HANDLE_CALL        = 7
-HANDLE_CALLATTR    = 8
-HANDLE_REPR        = 9
-HANDLE_STR         = 10
-HANDLE_CMP         = 11
-HANDLE_HASH        = 12
-HANDLE_DIR         = 13
-HANDLE_PICKLE      = 14
-HANDLE_DEL         = 15
-HANDLE_INSPECT     = 16
-HANDLE_BUFFITER    = 17
-HANDLE_OLDSLICING  = 18
-HANDLE_CTXEXIT     = 19
+HANDLE_PING = 1
+HANDLE_CLOSE = 2
+HANDLE_GETROOT = 3
+HANDLE_GETATTR = 4
+HANDLE_DELATTR = 5
+HANDLE_SETATTR = 6
+HANDLE_CALL = 7
+HANDLE_CALLATTR = 8
+HANDLE_REPR = 9
+HANDLE_STR = 10
+HANDLE_CMP = 11
+HANDLE_HASH = 12
+HANDLE_DIR = 13
+HANDLE_PICKLE = 14
+HANDLE_DEL = 15
+HANDLE_INSPECT = 16
+HANDLE_BUFFITER = 17
+HANDLE_OLDSLICING = 18
+HANDLE_CTXEXIT = 19
+HANDLE_INSTANCECHECK = 20
 
 # optimized exceptions
 EXC_STOP_ITERATION = 1
 
 # DEBUG
-#for k in globals().keys():
+# for k in globals().keys():
 #    globals()[k] = k
-
diff --git a/plainbox/vendor/rpyc/core/netref.py b/plainbox/vendor/rpyc/core/netref.py
index 0c43535..fd15ef1 100644
--- a/plainbox/vendor/rpyc/core/netref.py
+++ b/plainbox/vendor/rpyc/core/netref.py
@@ -1,27 +1,29 @@
-"""
-**NetRef**: a transparent *network reference*. This module contains quite a lot
+"""*NetRef*: a transparent *network reference*. This module contains quite a lot
 of *magic*, so beware.
 """
 import sys
-import inspect
 import types
-from plainbox.vendor.rpyc.lib.compat import pickle, is_py3k, maxint, with_metaclass
+from plainbox.vendor.rpyc.lib import get_methods, get_id_pack
+from plainbox.vendor.rpyc.lib.compat import pickle, is_py_3k, maxint, with_metaclass
 from plainbox.vendor.rpyc.core import consts
 
 
+builtin_id_pack_cache = {}  # name_pack -> id_pack
+builtin_classes_cache = {}  # id_pack -> class
 # If these can be accessed, numpy will try to load the array from local memory,
 # resulting in exceptions and/or segfaults, see #236:
-_deleted_netref_attrs = frozenset([
+DELETED_ATTRS = frozenset([
     '__array_struct__', '__array_interface__',
 ])
 
-_local_netref_attrs = frozenset([
-    '____conn__', '____oid__', '____refcount__', '__class__', '__cmp__', '__del__', '__delattr__',
-    '__dir__', '__doc__', '__getattr__', '__getattribute__', '__methods__',
+LOCAL_ATTRS = frozenset([
+    '____conn__', '____id_pack__', '____refcount__', '__class__', '__cmp__', '__del__', '__delattr__',
+    '__dir__', '__doc__', '__getattr__', '__getattribute__', '__hash__', '__instancecheck__',
     '__init__', '__metaclass__', '__module__', '__new__', '__reduce__',
     '__reduce_ex__', '__repr__', '__setattr__', '__slots__', '__str__',
-    '__weakref__', '__dict__', '__members__',  '__exit__',
-]) | _deleted_netref_attrs
+    '__weakref__', '__dict__', '__methods__', '__exit__',
+    '__eq__', '__ne__', '__lt__', '__gt__', '__le__', '__ge__',
+]) | DELETED_ATTRS
 """the set of attributes that are local to the netref object"""
 
 _builtin_types = [
@@ -45,19 +47,18 @@ except NameError:
 else:
     _builtin_types.append(BaseException)
 
-if is_py3k:
+if is_py_3k:
     _builtin_types.extend([
         bytes, bytearray, type(iter(range(10))), memoryview,
     ])
     xrange = range
 else:
     _builtin_types.extend([
-        basestring, unicode, long, xrange, type(iter(xrange(10))), file,
+        basestring, unicode, long, xrange, type(iter(xrange(10))), file,  # noqa
         types.InstanceType, types.ClassType, types.DictProxyType,
     ])
+_normalized_builtin_types = {}
 
-_normalized_builtin_types = dict(((t.__name__, t.__module__), t)
-    for t in _builtin_types)
 
 def syncreq(proxy, handler, *args):
     """Performs a synchronous request on the given proxy object.
@@ -74,6 +75,7 @@ def syncreq(proxy, handler, *args):
     conn = object.__getattribute__(proxy, "____conn__")
     return conn.sync_request(handler, proxy, *args)
 
+
 def asyncreq(proxy, handler, *args):
     """Performs an asynchronous request on the given proxy object.
     Not intended to be invoked directly.
@@ -89,18 +91,21 @@ def asyncreq(proxy, handler, *args):
     conn = object.__getattribute__(proxy, "____conn__")
     return conn.async_request(handler, proxy, *args)
 
+
 class NetrefMetaclass(type):
     """A *metaclass* used to customize the ``__repr__`` of ``netref`` classes.
     It is quite useless, but it makes debugging and interactive programming
     easier"""
 
     __slots__ = ()
+
     def __repr__(self):
         if self.__module__:
             return "<netref class '%s.%s'>" % (self.__module__, self.__name__)
         else:
             return "<netref class '%s'>" % (self.__name__,)
 
+
 class BaseNetref(with_metaclass(NetrefMetaclass, object)):
     """The base netref class, from which all netref classes derive. Some netref
     classes are "pre-generated" and cached upon importing this module (those
@@ -113,12 +118,17 @@ class BaseNetref(with_metaclass(NetrefMetaclass, object)):
     Do not use this class directly; use :func:`class_factory` instead.
 
     :param conn: the :class:`rpyc.core.protocol.Connection` instance
-    :param oid: the unique object ID of the remote object
+    :param id_pack: id tuple for an object ~ (name_pack, remote-class-id, remote-instance-id)
+        (cont.) name_pack := __module__.__name__ (hits or misses on builtin cache and sys.module)
+                remote-class-id := id of object class (hits or misses on netref classes cache and instance checks)
+                remote-instance-id := id object instance (hits or misses on proxy cache)
+        id_pack is usually created by rpyc.lib.get_id_pack
     """
-    __slots__ = ["____conn__", "____oid__", "__weakref__", "____refcount__"]
-    def __init__(self, conn, oid):
+    __slots__ = ["____conn__", "____id_pack__", "__weakref__", "____refcount__"]
+
+    def __init__(self, conn, id_pack):
         self.____conn__ = conn
-        self.____oid__ = oid
+        self.____id_pack__ = id_pack
         self.____refcount__ = 1
 
     def __del__(self):
@@ -131,7 +141,7 @@ class BaseNetref(with_metaclass(NetrefMetaclass, object)):
             pass
 
     def __getattribute__(self, name):
-        if name in _local_netref_attrs:
+        if name in LOCAL_ATTRS:
             if name == "__class__":
                 cls = object.__getattribute__(self, "__class__")
                 if cls is None:
@@ -139,58 +149,102 @@ class BaseNetref(with_metaclass(NetrefMetaclass, object)):
                 return cls
             elif name == "__doc__":
                 return self.__getattr__("__doc__")
-            elif name == "__members__":                       # for Python < 2.6
-                return self.__dir__()
-            elif name in _deleted_netref_attrs:
+            elif name in DELETED_ATTRS:
                 raise AttributeError()
             else:
                 return object.__getattribute__(self, name)
-        elif name == "__hash__":
-            return object.__getattribute__(self, "__hash__")
         elif name == "__call__":                          # IronPython issue #10
             return object.__getattribute__(self, "__call__")
         elif name == "__array__":
             return object.__getattribute__(self, "__array__")
         else:
             return syncreq(self, consts.HANDLE_GETATTR, name)
+
     def __getattr__(self, name):
-        if name in _deleted_netref_attrs:
+        if name in DELETED_ATTRS:
             raise AttributeError()
         return syncreq(self, consts.HANDLE_GETATTR, name)
+
     def __delattr__(self, name):
-        if name in _local_netref_attrs:
+        if name in LOCAL_ATTRS:
             object.__delattr__(self, name)
         else:
             syncreq(self, consts.HANDLE_DELATTR, name)
+
     def __setattr__(self, name, value):
-        if name in _local_netref_attrs:
+        if name in LOCAL_ATTRS:
             object.__setattr__(self, name, value)
         else:
             syncreq(self, consts.HANDLE_SETATTR, name, value)
+
     def __dir__(self):
         return list(syncreq(self, consts.HANDLE_DIR))
 
     # support for metaclasses
     def __hash__(self):
         return syncreq(self, consts.HANDLE_HASH)
+
     def __cmp__(self, other):
-        return syncreq(self, consts.HANDLE_CMP, other)
+        return syncreq(self, consts.HANDLE_CMP, other, '__cmp__')
+
+    def __eq__(self, other):
+        return syncreq(self, consts.HANDLE_CMP, other, '__eq__')
+
+    def __ne__(self, other):
+        return syncreq(self, consts.HANDLE_CMP, other, '__ne__')
+
+    def __lt__(self, other):
+        return syncreq(self, consts.HANDLE_CMP, other, '__lt__')
+
+    def __gt__(self, other):
+        return syncreq(self, consts.HANDLE_CMP, other, '__gt__')
+
+    def __le__(self, other):
+        return syncreq(self, consts.HANDLE_CMP, other, '__le__')
+
+    def __ge__(self, other):
+        return syncreq(self, consts.HANDLE_CMP, other, '__ge__')
+
     def __repr__(self):
         return syncreq(self, consts.HANDLE_REPR)
+
     def __str__(self):
         return syncreq(self, consts.HANDLE_STR)
+
     def __exit__(self, exc, typ, tb):
         return syncreq(self, consts.HANDLE_CTXEXIT, exc)  # can't pass type nor traceback
-    # support for pickling netrefs
+
     def __reduce_ex__(self, proto):
+        # support for pickling netrefs
         return pickle.loads, (syncreq(self, consts.HANDLE_PICKLE, proto),)
 
+    def __instancecheck__(self, other):
+        # support for checking cached instances across connections
+        if isinstance(other, BaseNetref):
+            if self.____id_pack__[2] != 0:
+                raise TypeError("isinstance() arg 2 must be a class, type, or tuple of classes and types")
+            elif self.____id_pack__[1] == other.____id_pack__[1]:
+                if other.____id_pack__[2] == 0:
+                    return False
+                elif other.____id_pack__[2] != 0:
+                    return True
+            else:
+                # seems dubious if each netref proxies to a different address spaces
+                return syncreq(self, consts.HANDLE_INSTANCECHECK, other.____id_pack__)
+        else:
+            if self.____id_pack__[2] == 0:
+                # outside the context of `__instancecheck__`, `__class__` is expected to be type(self)
+                # within the context of `__instancecheck__`, `other` should be compared to the proxied class
+                return isinstance(other, type(self).__dict__['__class__'].instance)
+            else:
+                raise TypeError("isinstance() arg 2 must be a class, type, or tuple of classes and types")
+
 
 def _make_method(name, doc):
     """creates a method with the given name and docstring that invokes
     :func:`syncreq` on its `self` argument"""
 
-    slicers = {"__getslice__" : "__getitem__", "__delslice__" : "__delitem__", "__setslice__" : "__setitem__"}
+    slicers = {"__getslice__": "__getitem__", "__delslice__": "__delitem__", "__setslice__": "__setitem__"}
 
     name = str(name)                                      # IronPython issue #10
     if name == "__call__":
@@ -222,62 +276,74 @@ def _make_method(name, doc):
         method.__doc__ = doc
         return method
 
-def inspect_methods(obj):
-    """introspects the given (local) object, returning a list of all of its
-    methods (going up the MRO).
 
-    :param obj: any local (not proxy) python object
+class NetrefClass(object):
+    """a descriptor of the class being proxied
 
-    :returns: a list of ``(method name, docstring)`` tuples of all the methods
-              of the given object
+    Future considerations:
+     + there may be a cleaner alternative but lib.compat.with_metaclass prevented using __new__
+     + consider using __slot__ for this class
+     + revisit the design choice to use properties here
     """
-    methods = {}
-    attrs = {}
-    if isinstance(obj, type):
-        # don't forget the darn metaclass
-        mros = list(reversed(type(obj).__mro__)) + list(reversed(obj.__mro__))
-    else:
-        mros = reversed(type(obj).__mro__)
-    for basecls in mros:
-        attrs.update(basecls.__dict__)
-    for name, attr in attrs.items():
-        if name not in _local_netref_attrs and hasattr(attr, "__call__"):
-            methods[name] = inspect.getdoc(attr)
-    return methods.items()
-
-def class_factory(clsname, modname, methods):
+
+    def __init__(self, class_obj):
+        self._class_obj = class_obj
+
+    @property
+    def instance(self):
+        """accessor to class object for the instance being proxied"""
+        return self._class_obj
+
+    @property
+    def owner(self):
+        """accessor to the class object for the instance owner being proxied"""
+        return self._class_obj.__class__
+
+    def __get__(self, netref_instance, netref_owner):
+        """the value returned when accessing the netref class is dictated by whether or not an instance is proxied"""
+        return self.owner if netref_instance.____id_pack__[2] == 0 else self.instance
+
+
+def class_factory(id_pack, methods):
     """Creates a netref class proxying the given class
 
-    :param clsname: the class's name
-    :param modname: the class's module name
-    :param methods: a list of ``(method name, docstring)`` tuples, of the methods
-                    that the class defines
+    :param id_pack: the id pack used for proxy communication
+    :param methods: a list of ``(method name, docstring)`` tuples, of the methods that the class defines
 
     :returns: a netref class
     """
-    clsname = str(clsname)                                # IronPython issue #10
-    modname = str(modname)                                # IronPython issue #10
-    ns = {"__slots__" : ()}
+    ns = {"__slots__": (), "__class__": None}
+    name_pack = id_pack[0]
+    class_descriptor = None
+    if name_pack is not None:
+        # attempt to resolve __class__ using sys.modules (i.e. builtins and imported modules)
+        _module = None
+        cursor = len(name_pack)
+        while cursor != -1:
+            _module = sys.modules.get(name_pack[:cursor])
+            if _module is None:
+                cursor = name_pack[:cursor].rfind('.')
+                continue
+            _class_name = name_pack[cursor + 1:]
+            _class = getattr(_module, _class_name, None)
+            if _class is not None and hasattr(_class, '__class__'):
+                class_descriptor = NetrefClass(_class)
+            break
+    ns['__class__'] = class_descriptor
+    netref_name = class_descriptor.owner.__name__ if class_descriptor is not None else name_pack
+    # create methods that must perform a syncreq
     for name, doc in methods:
-        name = str(name)                                  # IronPython issue #10
-        if name not in _local_netref_attrs:
+        name = str(name)  # IronPython issue #10
+        # only create methods that wont shadow BaseNetref during merge for mro
+        if name not in LOCAL_ATTRS:  # i.e. `name != __class__`
             ns[name] = _make_method(name, doc)
-    ns["__module__"] = modname
-    if modname in sys.modules and hasattr(sys.modules[modname], clsname):
-        ns["__class__"] = getattr(sys.modules[modname], clsname)
-    elif (clsname, modname) in _normalized_builtin_types:
-        ns["__class__"] = _normalized_builtin_types[clsname, modname]
-    else:
-        # to be resolved by the instance
-        ns["__class__"] = None
-    return type(clsname, (BaseNetref,), ns)
-
-builtin_classes_cache = {}
-"""The cache of built-in netref classes (each of the types listed in
-:data:`_builtin_types`). These are shared between all RPyC connections"""
+    return type(netref_name, (BaseNetref,), ns)
 
-# init the builtin_classes_cache
-for cls in _builtin_types:
-    builtin_classes_cache[cls.__name__, cls.__module__] = class_factory(
-        cls.__name__, cls.__module__, inspect_methods(cls))
 
+for _builtin in _builtin_types:
+    _id_pack = get_id_pack(_builtin)
+    _name_pack = _id_pack[0]
+    _normalized_builtin_types[_name_pack] = _builtin
+    _builtin_methods = get_methods(LOCAL_ATTRS, _builtin)
+    # assume all normalized builtins are classes
+    builtin_classes_cache[_name_pack] = class_factory(_id_pack, _builtin_methods)
diff --git a/plainbox/vendor/rpyc/core/protocol.py b/plainbox/vendor/rpyc/core/protocol.py
index a3be171..56cd9a9 100644
--- a/plainbox/vendor/rpyc/core/protocol.py
+++ b/plainbox/vendor/rpyc/core/protocol.py
@@ -1,64 +1,65 @@
-"""
-The RPyC protocol
+"""The RPyC protocol
 """
 import sys
 import itertools
 import socket
-import time
-import gc
+import time  # noqa: F401
+import gc  # noqa: F401
 
 from threading import Lock, Condition
-from plainbox.vendor.rpyc.lib import spawn, Timeout
-from plainbox.vendor.rpyc.lib.compat import (pickle, next, is_py3k, maxint, select_error,
-                             acquire_lock)
+from plainbox.vendor.rpyc.lib import spawn, Timeout, get_methods, get_id_pack
+from plainbox.vendor.rpyc.lib.compat import pickle, next, is_py_3k, maxint, select_error, acquire_lock  # noqa: F401
 from plainbox.vendor.rpyc.lib.colls import WeakValueDict, RefCountingColl
 from plainbox.vendor.rpyc.core import consts, brine, vinegar, netref
 from plainbox.vendor.rpyc.core.async_ import AsyncResult
 
+
 class PingError(Exception):
     """The exception raised should :func:`Connection.ping` fail"""
     pass
 
+
 DEFAULT_CONFIG = dict(
     # ATTRIBUTES
-    allow_safe_attrs = True,
-    allow_exposed_attrs = True,
-    allow_public_attrs = False,
-    allow_all_attrs = False,
-    safe_attrs = set(['__abs__', '__add__', '__and__', '__bool__', '__cmp__', '__contains__',
-        '__delitem__', '__delslice__', '__div__', '__divmod__', '__doc__',
-        '__eq__', '__float__', '__floordiv__', '__ge__', '__getitem__',
-        '__getslice__', '__gt__', '__hash__', '__hex__', '__iadd__', '__iand__',
-        '__idiv__', '__ifloordiv__', '__ilshift__', '__imod__', '__imul__',
-        '__index__', '__int__', '__invert__', '__ior__', '__ipow__', '__irshift__',
-        '__isub__', '__iter__', '__itruediv__', '__ixor__', '__le__', '__len__',
-        '__long__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__',
-        '__neg__', '__new__', '__nonzero__', '__oct__', '__or__', '__pos__',
-        '__pow__', '__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__repr__',
-        '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__',
-        '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__',
-        '__rxor__', '__setitem__', '__setslice__', '__str__', '__sub__',
-        '__truediv__', '__xor__', 'next', '__length_hint__', '__enter__',
-        '__exit__', '__next__',]),
-    exposed_prefix = "exposed_",
-    allow_getattr = True,
-    allow_setattr = False,
-    allow_delattr = False,
+    allow_safe_attrs=True,
+    allow_exposed_attrs=True,
+    allow_public_attrs=False,
+    allow_all_attrs=False,
+    safe_attrs=set(['__abs__', '__add__', '__and__', '__bool__', '__cmp__', '__contains__',
+                    '__delitem__', '__delslice__', '__div__', '__divmod__', '__doc__',
+                    '__eq__', '__float__', '__floordiv__', '__ge__', '__getitem__',
+                    '__getslice__', '__gt__', '__hash__', '__hex__', '__iadd__', '__iand__',
+                    '__idiv__', '__ifloordiv__', '__ilshift__', '__imod__', '__imul__',
+                    '__index__', '__int__', '__invert__', '__ior__', '__ipow__', '__irshift__',
+                    '__isub__', '__iter__', '__itruediv__', '__ixor__', '__le__', '__len__',
+                    '__long__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__',
+                    '__neg__', '__new__', '__nonzero__', '__oct__', '__or__', '__pos__',
+                    '__pow__', '__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__repr__',
+                    '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__',
+                    '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__',
+                    '__rxor__', '__setitem__', '__setslice__', '__str__', '__sub__',
+                    '__truediv__', '__xor__', 'next', '__length_hint__', '__enter__',
+                    '__exit__', '__next__', ]),
+    exposed_prefix="exposed_",
+    allow_getattr=True,
+    allow_setattr=False,
+    allow_delattr=False,
     # EXCEPTIONS
-    include_local_traceback = True,
-    instantiate_custom_exceptions = False,
-    import_custom_exceptions = False,
-    instantiate_oldstyle_exceptions = False, # which don't derive from Exception
-    propagate_SystemExit_locally = False, # whether to propagate SystemExit locally or to the other party
-    propagate_KeyboardInterrupt_locally = True,  # whether to propagate KeyboardInterrupt locally or to the other party
-    log_exceptions = True,
+    include_local_traceback=True,
+    include_local_version=True,
+    instantiate_custom_exceptions=False,
+    import_custom_exceptions=False,
+    instantiate_oldstyle_exceptions=False,  # which don't derive from Exception
+    propagate_SystemExit_locally=False,  # whether to propagate SystemExit locally or to the other party
+    propagate_KeyboardInterrupt_locally=True,  # whether to propagate KeyboardInterrupt locally or to the other party
+    log_exceptions=True,
     # MISC
-    allow_pickle = False,
-    connid = None,
-    credentials = None,
-    endpoints = None,
-    logger = None,
-    sync_request_timeout = 30,
+    allow_pickle=False,
+    connid=None,
+    credentials=None,
+    endpoints=None,
+    logger=None,
+    sync_request_timeout=30,
 )
 """
 The default configuration dictionary of the protocol. You can override these parameters
@@ -157,18 +158,18 @@ class Connection(object):
 
     def __del__(self):
         self.close()
+
     def __enter__(self):
         return self
+
     def __exit__(self, t, v, tb):
         self.close()
+
     def __repr__(self):
         a, b = object.__repr__(self).split(" object ")
         return "%s %r object %s" % (a, self._config["connid"], b)
 
-    #
-    # IO
-    #
-    def _cleanup(self, _anyway = True):
+    def _cleanup(self, _anyway=True):  # IO
         if self._closed and not _anyway:
             return
         self._closed = True
@@ -181,11 +182,11 @@ class Connection(object):
         self._last_traceback = None
         self._remote_root = None
         self._local_root = None
-        #self._seqcounter = None
-        #self._config.clear()
+        # self._seqcounter = None
+        # self._config.clear()
         del self._HANDLERS
 
-    def close(self, _catchall = True):
+    def close(self, _catchall=True):  # IO
         """closes the connection, releasing all held resources"""
         if self._closed:
             return
@@ -198,20 +199,19 @@ class Connection(object):
             if not _catchall:
                 raise
         finally:
-            self._cleanup(_anyway = True)
+            self._cleanup(_anyway=True)
 
     @property
-    def closed(self):
+    def closed(self):  # IO
         """Indicates whether the connection has been closed or not"""
         return self._closed
 
-    def fileno(self):
+    def fileno(self):  # IO
         """Returns the connectin's underlying file descriptor"""
         return self._channel.fileno()
 
-    def ping(self, data = None, timeout = 3):
-        """
-        Asserts that the other party is functioning properly, by making sure
+    def ping(self, data=None, timeout=3):  # IO
+        """Asserts that the other party is functioning properly, by making sure
         the *data* is echoed back before the *timeout* expires
 
         :param data: the data to send (leave ``None`` for the default buffer)
@@ -222,14 +222,14 @@ class Connection(object):
         """
         if data is None:
             data = "abcdefghijklmnopqrstuvwxyz" * 20
-        res = self.async_request(consts.HANDLE_PING, data, timeout = timeout)
+        res = self.async_request(consts.HANDLE_PING, data, timeout=timeout)
         if res.value != data:
             raise PingError("echo mismatches sent data")
 
-    def _get_seq_id(self):
+    def _get_seq_id(self):  # IO
         return next(self._seqcounter)
 
-    def _send(self, msg, seq, args):
+    def _send(self, msg, seq, args):  # IO
         data = brine.dump((msg, seq, args))
         # GC might run while sending data
         # if so, a BaseNetref.__del__ might be called
@@ -260,10 +260,7 @@ class Connection(object):
             finally:
                 self._sendlock.release()
 
-    #
-    # boxing
-    #
-    def _box(self, obj):
+    def _box(self, obj):  # boxing
         """store a local object in such a way that it could be recreated on
         the remote party either by-value or by-reference"""
         if brine.dumpable(obj):
@@ -271,19 +268,13 @@ class Connection(object):
         if type(obj) is tuple:
             return consts.LABEL_TUPLE, tuple(self._box(item) for item in obj)
         elif isinstance(obj, netref.BaseNetref) and obj.____conn__ is self:
-            return consts.LABEL_LOCAL_REF, obj.____oid__
+            return consts.LABEL_LOCAL_REF, obj.____id_pack__
         else:
-            self._local_objects.add(obj)
-            try:
-                cls = obj.__class__
-            except Exception:
-                # see issue #16
-                cls = type(obj)
-            if not isinstance(cls, type):
-                cls = type(obj)
-            return consts.LABEL_REMOTE_REF, (id(obj), cls.__name__, cls.__module__)
+            id_pack = get_id_pack(obj)
+            self._local_objects.add(id_pack, obj)
+            return consts.LABEL_REMOTE_REF, id_pack
 
-    def _unbox(self, package):
+    def _unbox(self, package):  # boxing
         """recreate a local object representation of the remote object: if the
         object is passed by value, just return it; if the object is passed by
         reference, create a netref to it"""
@@ -295,39 +286,39 @@ class Connection(object):
         if label == consts.LABEL_LOCAL_REF:
             return self._local_objects[value]
         if label == consts.LABEL_REMOTE_REF:
-            oid, clsname, modname = value
-            if oid in self._proxy_cache:
-                proxy = self._proxy_cache[oid]
-                proxy.____refcount__ += 1  # other side increased refcount on boxing,
-                                           # if I'm returning from cache instead of new object,
-                                           # must increase refcount to match
-                return proxy
-            proxy = self._netref_factory(oid, clsname, modname)
-            self._proxy_cache[oid] = proxy
+            id_pack = (str(value[0]), value[1], value[2])  # so value is a id_pack
+            if id_pack in self._proxy_cache:
+                proxy = self._proxy_cache[id_pack]
+                proxy.____refcount__ += 1  # if cached then remote incremented refcount, so sync refcount
+            else:
+                proxy = self._netref_factory(id_pack)
+                self._proxy_cache[id_pack] = proxy
             return proxy
         raise ValueError("invalid label %r" % (label,))
 
-    def _netref_factory(self, oid, clsname, modname):
-        typeinfo = (clsname, modname)
-        if typeinfo in self._netref_classes_cache:
-            cls = self._netref_classes_cache[typeinfo]
-        elif typeinfo in netref.builtin_classes_cache:
-            cls = netref.builtin_classes_cache[typeinfo]
-        else:
-            info = self.sync_request(consts.HANDLE_INSPECT, oid)
-            cls = netref.class_factory(clsname, modname, info)
-            self._netref_classes_cache[typeinfo] = cls
-        return cls(self, oid)
-
-    #
-    # dispatching
-    #
-    def _dispatch_request(self, seq, raw_args):
+    def _netref_factory(self, id_pack):  # boxing
+        """id_pack is for remote, so when class id fails to directly match """
+        cls = None
+        if id_pack[2] == 0 and id_pack in self._netref_classes_cache:
+            cls = self._netref_classes_cache[id_pack]
+        elif id_pack[0] in netref.builtin_classes_cache:
+            cls = netref.builtin_classes_cache[id_pack[0]]
+        if cls is None:
+            # in the future, it could see if a sys.module cache/lookup hits first
+            cls_methods = self.sync_request(consts.HANDLE_INSPECT, id_pack)
+            cls = netref.class_factory(id_pack, cls_methods)
+            if id_pack[2] == 0:
+                # only use cached netrefs for classes
+                # ... instance caching after gc of a proxy will take some mental gymnastics
+                self._netref_classes_cache[id_pack] = cls
+        return cls(self, id_pack)
+
+    def _dispatch_request(self, seq, raw_args):  # dispatch
         try:
             handler, args = raw_args
             args = self._unbox(args)
             res = self._HANDLERS[handler](self, *args)
-        except:
+        except:  # TODO: revist how to catch handle locally, this should simplify when py2 is dropped
             # need to catch old style exceptions too
             t, v, tb = sys.exc_info()
             self._last_traceback = tb
@@ -342,34 +333,39 @@ class Connection(object):
         else:
             self._send(consts.MSG_REPLY, seq, self._box(res))
 
-    def _box_exc(self, typ, val, tb):
-        return vinegar.dump(typ, val, tb, include_local_traceback=
-                            self._config["include_local_traceback"])
+    def _box_exc(self, typ, val, tb):  # dispatch?
+        return vinegar.dump(typ, val, tb,
+                            include_local_traceback=self._config["include_local_traceback"],
+                            include_local_version=self._config["include_local_version"])
 
-    def _unbox_exc(self, raw):
+    def _unbox_exc(self, raw):  # dispatch?
         return vinegar.load(raw,
-            import_custom_exceptions = self._config["import_custom_exceptions"],
-            instantiate_custom_exceptions = self._config["instantiate_custom_exceptions"],
-            instantiate_oldstyle_exceptions = self._config["instantiate_oldstyle_exceptions"])
-
-    #
-    # serving
-    #
-
-    def _dispatch(self, data):
+                            import_custom_exceptions=self._config["import_custom_exceptions"],
+                            instantiate_custom_exceptions=self._config["instantiate_custom_exceptions"],
+                            instantiate_oldstyle_exceptions=self._config["instantiate_oldstyle_exceptions"])
+
+    def _seq_request_callback(self, msg, seq, is_exc, obj):
+        _callback = self._request_callbacks.pop(seq, None)
+        if _callback is not None:
+            _callback(is_exc, obj)
+        elif self._config["logger"] is not None:
+            debug_msg = 'Recieved {} seq {} and a related request callback did not exist'
+            self._config["logger"].debug(debug_msg.format(msg, seq))
+
+    def _dispatch(self, data):  # serving---dispatch?
         msg, seq, args = brine.load(data)
         if msg == consts.MSG_REQUEST:
             self._dispatch_request(seq, args)
         elif msg == consts.MSG_REPLY:
             obj = self._unbox(args)
-            self._request_callbacks.pop(seq)(False, obj)
+            self._seq_request_callback(msg, seq, False, obj)
         elif msg == consts.MSG_EXCEPTION:
             obj = self._unbox_exc(args)
-            self._request_callbacks.pop(seq)(True, obj)
+            self._seq_request_callback(msg, seq, True, obj)
         else:
             raise ValueError("invalid message type: %r" % (msg,))
 
-    def serve(self, timeout=1, wait_for_lock=True):
+    def serve(self, timeout=1, wait_for_lock=True):  # serving
         """Serves a single request or reply that arrives within the given
         time frame (default is 1 sec). Note that the dispatching of a request
         might trigger multiple (nested) requests, thus this function may be
@@ -381,8 +377,7 @@ class Connection(object):
         timeout = Timeout(timeout)
         with self._recv_event:
             if not self._recvlock.acquire(False):
-                return (wait_for_lock and
-                        self._recv_event.wait(timeout.timeleft()))
+                return wait_for_lock and self._recv_event.wait(timeout.timeleft())
         try:
             data = self._channel.poll(timeout) and self._channel.recv()
             if not data:
@@ -397,7 +392,7 @@ class Connection(object):
         self._dispatch(data)
         return True
 
-    def poll(self, timeout = 0):
+    def poll(self, timeout=0):  # serving
         """Serves a single transaction, should one arrives in the given
         interval. Note that handling a request/reply may trigger nested
         requests, which are all part of a single transaction.
@@ -405,11 +400,11 @@ class Connection(object):
         :returns: ``True`` if a transaction was served, ``False`` otherwise"""
         return self.serve(timeout, False)
 
-    def serve_all(self):
+    def serve_all(self):  # serving
         """Serves all requests and replies for as long as the connection is
         alive."""
         try:
-            while True:
+            while not self.closed:
                 self.serve(None)
         except (socket.error, select_error, IOError):
             if not self.closed:
@@ -419,9 +414,15 @@ class Connection(object):
         finally:
             self.close()
 
-    def serve_threaded(self, thread_count=10):
-        """Serves all requests and replies for as long as the connection is
-        alive."""
+    def serve_threaded(self, thread_count=10):  # serving
+        """Serves all requests and replies for as long as the connection is alive.
+
+        CAVEAT: using non-immutable types that require a netref to be constructed to serve a request,
+        or invoking anything else that performs a sync_request, may timeout due to the sync_request reply being
+        received by another thread serving the connection. A more conventional approach where each client thread
+        opens a new connection would allow `ThreadedServer` to naturally avoid such multiplexing issues and
+        is the preferred approach for threading procedures that invoke sync_request. See issue #345
+        """
         def _thread_target():
             try:
                 while True:
@@ -441,7 +442,7 @@ class Connection(object):
         finally:
             self.close()
 
-    def poll_all(self, timeout=0):
+    def poll_all(self, timeout=0):  # serving
         """Serves all requests and replies that arrive within the given interval.
 
         :returns: ``True`` if at least a single transaction was served, ``False`` otherwise
@@ -458,11 +459,8 @@ class Connection(object):
             pass
         return at_least_once
 
-    #
-    # requests
-    #
-    def sync_request(self, handler, *args):
-        """Sends a synchronous request (waits for the reply to arrive)
+    def sync_request(self, handler, *args):  # serving
+        """requests, sends a synchronous request (waits for the reply to arrive)
 
         :raises: any exception that the requets may be generated
         :returns: the result of the request
@@ -470,16 +468,19 @@ class Connection(object):
         timeout = self._config["sync_request_timeout"]
         return self.async_request(handler, *args, timeout=timeout).value
 
-    def _async_request(self, handler, args = (), callback = (lambda a, b: None)):
+    def _async_request(self, handler, args=(), callback=(lambda a, b: None)):  # serving
         seq = self._get_seq_id()
         self._request_callbacks[seq] = callback
         try:
             self._send(consts.MSG_REQUEST, seq, (handler, self._box(args)))
-        except:
+        except Exception:
+            # TODO: review test_remote_exception, logging exceptions show attempt to write on closed stream
+            # depending on the case, the MSG_REQUEST may or may not have been sent completely
+            # so, pop the callback and raise to keep response integrity is consistent
             self._request_callbacks.pop(seq, None)
             raise
 
-    def async_request(self, handler, *args, **kwargs):
+    def async_request(self, handler, *args, **kwargs):  # serving
         """Send an asynchronous request (does not wait for it to finish)
 
         :returns: an :class:`rpyc.core.async_.AsyncResult` object, which will
@@ -495,128 +496,170 @@ class Connection(object):
         return res
 
     @property
-    def root(self):
+    def root(self):  # serving
         """Fetches the root object (service) of the other party"""
         if self._remote_root is None:
             self._remote_root = self.sync_request(consts.HANDLE_GETROOT)
         return self._remote_root
 
-    #
-    # attribute access
-    #
-    def _check_attr(self, obj, name, perm):
+    def _check_attr(self, obj, name, perm):  # attribute access
         config = self._config
         if not config[perm]:
             raise AttributeError("cannot access %r" % (name,))
         prefix = config["allow_exposed_attrs"] and config["exposed_prefix"]
-        plain = (config["allow_all_attrs"] or
-                 config["allow_exposed_attrs"] and name.startswith(prefix) or
-                 config["allow_safe_attrs"] and name in config["safe_attrs"] or
-                 config["allow_public_attrs"] and not name.startswith("_"))
-        has_exposed = prefix and hasattr(obj, prefix+name)
+        plain = config["allow_all_attrs"]
+        plain |= config["allow_exposed_attrs"] and name.startswith(prefix)
+        plain |= config["allow_safe_attrs"] and name in config["safe_attrs"]
+        plain |= config["allow_public_attrs"] and not name.startswith("_")
+        has_exposed = prefix and hasattr(obj, prefix + name)
         if plain and (not has_exposed or hasattr(obj, name)):
             return name
         if has_exposed:
-            return prefix+name
+            return prefix + name
         if plain:
-            return name         # chance for better traceback
+            return name  # chance for better traceback
         raise AttributeError("cannot access %r" % (name,))
 
-    def _access_attr(self, obj, name, args, overrider, param, default):
-        if is_py3k:
+    def _access_attr(self, obj, name, args, overrider, param, default):  # attribute access
+        if is_py_3k:
             if type(name) is bytes:
                 name = str(name, "utf8")
             elif type(name) is not str:
                 raise TypeError("name must be a string")
         else:
-            if type(name) not in (str, unicode):
+            if type(name) not in (str, unicode):  # noqa
                 raise TypeError("name must be a string")
-            name = str(name) # IronPython issue #10 + py3k issue
+            name = str(name)  # IronPython issue #10 + py3k issue
         accessor = getattr(type(obj), overrider, None)
         if accessor is None:
             accessor = default
             name = self._check_attr(obj, name, param)
         return accessor(obj, name, *args)
 
-    #
-    # request handlers
-    #
     @classmethod
-    def _request_handlers(cls):
+    def _request_handlers(cls):  # request handlers
         return {
-            consts.HANDLE_PING:        cls._handle_ping,
-            consts.HANDLE_CLOSE:       cls._handle_close,
-            consts.HANDLE_GETROOT:     cls._handle_getroot,
-            consts.HANDLE_GETATTR:     cls._handle_getattr,
-            consts.HANDLE_DELATTR:     cls._handle_delattr,
-            consts.HANDLE_SETATTR:     cls._handle_setattr,
-            consts.HANDLE_CALL:        cls._handle_call,
-            consts.HANDLE_CALLATTR:    cls._handle_callattr,
-            consts.HANDLE_REPR:        cls._handle_repr,
-            consts.HANDLE_STR:         cls._handle_str,
-            consts.HANDLE_CMP:         cls._handle_cmp,
-            consts.HANDLE_HASH:        cls._handle_hash,
-            consts.HANDLE_DIR:         cls._handle_dir,
-            consts.HANDLE_PICKLE:      cls._handle_pickle,
-            consts.HANDLE_DEL:         cls._handle_del,
-            consts.HANDLE_INSPECT:     cls._handle_inspect,
-            consts.HANDLE_BUFFITER:    cls._handle_buffiter,
-            consts.HANDLE_OLDSLICING:  cls._handle_oldslicing,
-            consts.HANDLE_CTXEXIT:     cls._handle_ctxexit,
+            consts.HANDLE_PING: cls._handle_ping,
+            consts.HANDLE_CLOSE: cls._handle_close,
+            consts.HANDLE_GETROOT: cls._handle_getroot,
+            consts.HANDLE_GETATTR: cls._handle_getattr,
+            consts.HANDLE_DELATTR: cls._handle_delattr,
+            consts.HANDLE_SETATTR: cls._handle_setattr,
+            consts.HANDLE_CALL: cls._handle_call,
+            consts.HANDLE_CALLATTR: cls._handle_callattr,
+            consts.HANDLE_REPR: cls._handle_repr,
+            consts.HANDLE_STR: cls._handle_str,
+            consts.HANDLE_CMP: cls._handle_cmp,
+            consts.HANDLE_HASH: cls._handle_hash,
+            consts.HANDLE_INSTANCECHECK: cls._handle_instancecheck,
+            consts.HANDLE_DIR: cls._handle_dir,
+            consts.HANDLE_PICKLE: cls._handle_pickle,
+            consts.HANDLE_DEL: cls._handle_del,
+            consts.HANDLE_INSPECT: cls._handle_inspect,
+            consts.HANDLE_BUFFITER: cls._handle_buffiter,
+            consts.HANDLE_OLDSLICING: cls._handle_oldslicing,
+            consts.HANDLE_CTXEXIT: cls._handle_ctxexit,
         }
 
-    def _handle_ping(self, data):
+    def _handle_ping(self, data):  # request handler
         return data
-    def _handle_close(self):
+
+    def _handle_close(self):  # request handler
         self._cleanup()
-    def _handle_getroot(self):
+
+    def _handle_getroot(self):  # request handler
         return self._local_root
-    def _handle_del(self, obj, count=1):
-        self._local_objects.decref(id(obj), count)
-    def _handle_repr(self, obj):
+
+    def _handle_del(self, obj, count=1):  # request handler
+        self._local_objects.decref(get_id_pack(obj), count)
+
+    def _handle_repr(self, obj):  # request handler
         return repr(obj)
-    def _handle_str(self, obj):
+
+    def _handle_str(self, obj):  # request handler
         return str(obj)
-    def _handle_cmp(self, obj, other):
-        # cmp() might enter recursive resonance... yet another workaround
-        #return cmp(obj, other)
+
+    def _handle_cmp(self, obj, other, op='__cmp__'):  # request handler
+        # cmp() might enter recursive resonance... so use the underlying type and return cmp(obj, other)
         try:
-            return type(obj).__cmp__(obj, other)
-        except (AttributeError, TypeError):
-            return NotImplemented
-    def _handle_hash(self, obj):
+            return self._access_attr(type(obj), op, (), "_rpyc_getattr", "allow_getattr", getattr)(obj, other)
+        except Exception:
+            raise
+
+    def _handle_hash(self, obj):  # request handler
         return hash(obj)
-    def _handle_call(self, obj, args, kwargs=()):
+
+    def _handle_call(self, obj, args, kwargs=()):  # request handler
         return obj(*args, **dict(kwargs))
-    def _handle_dir(self, obj):
+
+    def _handle_dir(self, obj):  # request handler
         return tuple(dir(obj))
-    def _handle_inspect(self, oid):
-        return tuple(netref.inspect_methods(self._local_objects[oid]))
-    def _handle_getattr(self, obj, name):
+
+    def _handle_inspect(self, id_pack):  # request handler
+        if hasattr(self._local_objects[id_pack], '____conn__'):
+            # When RPyC is chained (RPyC over RPyC), id_pack is cached in local objects as a netref
+            # since __mro__ is not a safe attribute the request is forwarded using the proxy connection
+            # see issue #346 or tests.test_rpyc_over_rpyc.Test_rpyc_over_rpyc
+            conn = self._local_objects[id_pack].____conn__
+            return conn.sync_request(consts.HANDLE_INSPECT, id_pack)
+        else:
+            return tuple(get_methods(netref.LOCAL_ATTRS, self._local_objects[id_pack]))
+
+    def _handle_getattr(self, obj, name):  # request handler
         return self._access_attr(obj, name, (), "_rpyc_getattr", "allow_getattr", getattr)
-    def _handle_delattr(self, obj, name):
+
+    def _handle_delattr(self, obj, name):  # request handler
         return self._access_attr(obj, name, (), "_rpyc_delattr", "allow_delattr", delattr)
-    def _handle_setattr(self, obj, name, value):
+
+    def _handle_setattr(self, obj, name, value):  # request handler
         return self._access_attr(obj, name, (value,), "_rpyc_setattr", "allow_setattr", setattr)
-    def _handle_callattr(self, obj, name, args, kwargs=()):
+
+    def _handle_callattr(self, obj, name, args, kwargs=()):  # request handler
         obj = self._handle_getattr(obj, name)
         return self._handle_call(obj, args, kwargs)
-    def _handle_ctxexit(self, obj, exc):
+
+    def _handle_ctxexit(self, obj, exc):  # request handler
         if exc:
             try:
                 raise exc
-            except:
+            except Exception:
                 exc, typ, tb = sys.exc_info()
         else:
             typ = tb = None
         return self._handle_getattr(obj, "__exit__")(exc, typ, tb)
-    def _handle_pickle(self, obj, proto):
+
+    def _handle_instancecheck(self, obj, other_id_pack):
+        # TODOs:
+        #  + refactor cache instancecheck/inspect/class_factory
+        #  + improve cache docs
+
+        if hasattr(obj, '____conn__'):  # keep unwrapping!
+            # When RPyC is chained (RPyC over RPyC), id_pack is cached in local objects as a netref
+            # since __mro__ is not a safe attribute the request is forwarded using the proxy connection
+            # relates to issue #346 or tests.test_netref_hierachy.Test_Netref_Hierarchy.test_StandardError
+            conn = obj.____conn__
+            return conn.sync_request(consts.HANDLE_INSPECT, id_pack)
+        # Create a name pack which would be familiar here and see if there is a hit
+        other_id_pack2 = (other_id_pack[0], other_id_pack[1], 0)
+        if other_id_pack[0] in netref.builtin_classes_cache:
+            cls = netref.builtin_classes_cache[other_id_pack[0]]
+            other = cls(self, other_id_pack)
+        elif other_id_pack2 in self._netref_classes_cache:
+            cls = self._netref_classes_cache[other_id_pack2]
+            other = cls(self, other_id_pack2)
+        else:  # might just have missed cache, FIX ME
+            return False
+        return isinstance(other, obj)
+
+    def _handle_pickle(self, obj, proto):  # request handler
         if not self._config["allow_pickle"]:
             raise ValueError("pickling is disabled")
         return bytes(pickle.dumps(obj, proto))
-    def _handle_buffiter(self, obj, count):
+
+    def _handle_buffiter(self, obj, count):  # request handler
         return tuple(itertools.islice(obj, count))
-    def _handle_oldslicing(self, obj, attempt, fallback, start, stop, args):
+
+    def _handle_oldslicing(self, obj, attempt, fallback, start, stop, args):  # request handler
         try:
             # first try __xxxitem__
             getitem = self._handle_getattr(obj, attempt)
diff --git a/plainbox/vendor/rpyc/core/reactor.py b/plainbox/vendor/rpyc/core/reactor.py
index 08edc60..9821c50 100644
--- a/plainbox/vendor/rpyc/core/reactor.py
+++ b/plainbox/vendor/rpyc/core/reactor.py
@@ -5,11 +5,14 @@ import threading
 
 class SelectReactor(object):
     TIMEOUT = 0.5 if os.name == "nt" else None
+
     def __init__(self):
         self._active = False
         self._readfds = set()
+
     def register_read(self, fileobj):
         self._readfds.append(fileobj)
+
     def run(self):
         self._active = True
         while self._active:
@@ -23,17 +26,18 @@ class SelectReactor(object):
 
 _reactor = SelectReactor()
 
+
 def _reactor_thread():
     pass
 
 
 _thd = None
+
+
 def start_reactor():
     global _thd
     if _thd is None:
         raise ValueError("already started")
-    _thd = threading.Thread("rpyc reactor thread", target = _reactor_thread)
+    _thd = threading.Thread("rpyc reactor thread", target=_reactor_thread)
     _thd.setDaemon(True)
     _thd.start()
-
-
diff --git a/plainbox/vendor/rpyc/core/service.py b/plainbox/vendor/rpyc/core/service.py
index 36b94b4..55526be 100644
--- a/plainbox/vendor/rpyc/core/service.py
+++ b/plainbox/vendor/rpyc/core/service.py
@@ -6,8 +6,10 @@ Note that the services by both parties need not be symmetric, e.g., one side may
 exposed *service A*, while the other may expose *service B*. As long as the two
 can interoperate, you're good to go.
 """
+from functools import partial
+
 from plainbox.vendor.rpyc.lib import hybridmethod
-from plainbox.vendor.rpyc.lib.compat import execute, is_py3k
+from plainbox.vendor.rpyc.lib.compat import execute, is_py_3k
 from plainbox.vendor.rpyc.core.protocol import Connection
 
 
@@ -57,6 +59,7 @@ class Service(object):
     def on_connect(self, conn):
         """called when the connection is established"""
         pass
+
     def on_disconnect(self, conn):
         """called when the connection had already terminated for cleanup
         (must not perform any IO on the connection)"""
@@ -67,6 +70,7 @@ class Service(object):
 
     def _rpyc_delattr(self, name):
         raise AttributeError("access denied")
+
     def _rpyc_setattr(self, name, value):
         raise AttributeError("access denied")
 
@@ -79,6 +83,7 @@ class Service(object):
         if name.endswith("SERVICE"):
             name = name[:-7]
         return (name,)
+
     @classmethod
     def get_service_name(cls):
         """returns the canonical name of the service (which is its first
@@ -111,9 +116,11 @@ class ModuleNamespace(object):
     'module namespace'"""
 
     __slots__ = ["__getmodule", "__cache", "__weakref__"]
+
     def __init__(self, getmodule):
         self.__getmodule = getmodule
         self.__cache = {}
+
     def __contains__(self, name):
         try:
             self[name]
@@ -121,33 +128,42 @@ class ModuleNamespace(object):
             return False
         else:
             return True
+
     def __getitem__(self, name):
         if type(name) is tuple:
             name = ".".join(name)
         if name not in self.__cache:
             self.__cache[name] = self.__getmodule(name)
         return self.__cache[name]
+
     def __getattr__(self, name):
         return self[name]
 
+
 class Slave(object):
     __slots__ = ["_conn", "namespace"]
+
     def __init__(self):
         self._conn = None
         self.namespace = {}
+
     def execute(self, text):
         """execute arbitrary code (using ``exec``)"""
         execute(text, self.namespace)
+
     def eval(self, text):
         """evaluate arbitrary code (using ``eval``)"""
         return eval(text, self.namespace)
+
     def getmodule(self, name):
         """imports an arbitrary module"""
         return __import__(name, None, None, "*")
+
     def getconn(self):
         """returns the local connection instance to the other side"""
         return self._conn
 
+
 class SlaveService(Slave, Service):
     """The SlaveService allows the other side to perform arbitrary imports and
     execution arbitrary code on the server. This is provided for compatibility
@@ -160,28 +176,30 @@ class SlaveService(Slave, Service):
     def on_connect(self, conn):
         self._conn = conn
         self._conn._config.update(dict(
-            allow_all_attrs = True,
-            allow_pickle = True,
-            allow_getattr = True,
-            allow_setattr = True,
-            allow_delattr = True,
-            allow_exposed_attrs = False,
-            import_custom_exceptions = True,
-            instantiate_custom_exceptions = True,
-            instantiate_oldstyle_exceptions = True,
+            allow_all_attrs=True,
+            allow_pickle=True,
+            allow_getattr=True,
+            allow_setattr=True,
+            allow_delattr=True,
+            allow_exposed_attrs=False,
+            import_custom_exceptions=True,
+            instantiate_custom_exceptions=True,
+            instantiate_oldstyle_exceptions=True,
         ))
         super(SlaveService, self).on_connect(conn)
 
+
 class FakeSlaveService(VoidService):
     """VoidService that can be used for connecting to peers that operate a
     :class:`MasterService`, :class:`ClassicService`, or the old
     ``SlaveService`` (pre v3.5) without exposing any functionality to them."""
     __slots__ = ()
     exposed_namespace = None
-    exposed_execute   = None
-    exposed_eval      = None
+    exposed_execute = None
+    exposed_eval = None
     exposed_getmodule = None
-    exposed_getconn   = None
+    exposed_getconn = None
+
 
 class MasterService(Service):
 
@@ -197,21 +215,25 @@ class MasterService(Service):
     @staticmethod
     def _install(conn, slave):
         modules = ModuleNamespace(slave.getmodule)
-        builtin = modules.builtins if is_py3k else modules.__builtin__
+        builtin = modules.builtins if is_py_3k else modules.__builtin__
         conn.modules = modules
         conn.eval = slave.eval
         conn.execute = slave.execute
         conn.namespace = slave.namespace
         conn.builtin = builtin
         conn.builtins = builtin
+        from plainbox.vendor.rpyc.utils.classic import teleport_function
+        conn.teleport = partial(teleport_function, conn)
+
 
 class ClassicService(MasterService, SlaveService):
     """Full duplex master/slave service, i.e. both parties have full control
     over the other. Must be used by both parties."""
     __slots__ = ()
 
+
 class ClassicClient(MasterService, FakeSlaveService):
     """MasterService that can be used for connecting to peers that operate a
-    :class:`MasterService`, :class:`ClassicService`, or the old
-    ``SlaveService`` (pre v3.5) without exposing any functionality to them."""
+    :class:`MasterService`, :class:`ClassicService` without exposing any
+    functionality to them."""
     __slots__ = ()
diff --git a/plainbox/vendor/rpyc/core/stream.py b/plainbox/vendor/rpyc/core/stream.py
index 57825a4..6c8d790 100644
--- a/plainbox/vendor/rpyc/core/stream.py
+++ b/plainbox/vendor/rpyc/core/stream.py
@@ -6,12 +6,11 @@ import sys
 import os
 import socket
 import errno
-from plainbox.vendor.rpyc.lib import safe_import, Timeout
-from plainbox.vendor.rpyc.lib.compat import poll, select_error, BYTES_LITERAL, get_exc_errno, maxint
+from plainbox.vendor.rpyc.lib import safe_import, Timeout, socket_backoff_connect
+from plainbox.vendor.rpyc.lib.compat import poll, select_error, BYTES_LITERAL, get_exc_errno, maxint  # noqa: F401
 win32file = safe_import("win32file")
 win32pipe = safe_import("win32pipe")
-msvcrt = safe_import("msvcrt")
-ssl = safe_import("ssl")
+win32event = safe_import("win32event")
 
 
 retry_errnos = (errno.EAGAIN, errno.EWOULDBLOCK)
@@ -21,16 +20,20 @@ class Stream(object):
     """Base Stream"""
 
     __slots__ = ()
+
     def close(self):
         """closes the stream, releasing any system resources associated with it"""
         raise NotImplementedError()
+
     @property
     def closed(self):
         """tests whether the stream is closed or not"""
         raise NotImplementedError()
+
     def fileno(self):
         """returns the stream's file descriptor"""
         raise NotImplementedError()
+
     def poll(self, timeout):
         """indicates whether the stream has data to read (within *timeout*
         seconds)"""
@@ -57,6 +60,7 @@ class Stream(object):
             ex = sys.exc_info()[1]
             raise select_error(str(ex))
         return bool(rl)
+
     def read(self, count):
         """reads **exactly** *count* bytes, or raise EOFError
 
@@ -65,14 +69,17 @@ class Stream(object):
         :returns: read data
         """
         raise NotImplementedError()
+
     def write(self, data):
         """writes the entire *data*, or raise EOFError
 
         :param data: a string of binary data
         """
         raise NotImplementedError()
+
     def __enter__(self):
         return self
+
     def __exit__(self, *exc_info):
         self.close()
 
@@ -80,17 +87,23 @@ class Stream(object):
 class ClosedFile(object):
     """Represents a closed file object (singleton)"""
     __slots__ = ()
+
     def __getattr__(self, name):
-        if name.startswith("__"): # issue 71
+        if name.startswith("__"):  # issue 71
             raise AttributeError("stream has been closed")
         raise EOFError("stream has been closed")
+
     def close(self):
         pass
+
     @property
     def closed(self):
         return True
+
     def fileno(self):
         raise EOFError("stream has been closed")
+
+
 ClosedFile = ClosedFile()
 
 
@@ -98,36 +111,41 @@ class SocketStream(Stream):
     """A stream over a socket"""
 
     __slots__ = ("sock",)
-    MAX_IO_CHUNK = 8000
+    MAX_IO_CHUNK = 64000  # read/write chunk is 64KB, too large of a value will degrade response for other clients
+
     def __init__(self, sock):
         self.sock = sock
 
     @classmethod
-    def _connect(cls, host, port, family = socket.AF_INET, socktype = socket.SOCK_STREAM,
-            proto = 0, timeout = 3, nodelay = False, keepalive = False):
+    def _connect(cls, host, port, family=socket.AF_INET, socktype=socket.SOCK_STREAM,
+                 proto=0, timeout=3, nodelay=False, keepalive=False, attempts=6):
         family, socktype, proto, _, sockaddr = socket.getaddrinfo(host, port, family,
-            socktype, proto)[0]
-        s = socket.socket(family, socktype, proto)
-        s.settimeout(timeout)
-        s.connect(sockaddr)
-        if nodelay:
-            s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-        if keepalive:
-            s.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-
-            if hasattr(socket, "TCP_KEEPIDLE") and hasattr(socket, "TCP_KEEPINTVL") and hasattr(socket, "TCP_KEEPCNT"):
+                                                                  socktype, proto)[0]
+        s = socket_backoff_connect(family, socktype, proto, sockaddr, timeout, attempts)
+        try:
+            if nodelay:
+                s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            if keepalive:
+                s.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
                 # Linux specific: after <keepalive> idle seconds, start sending keepalives every <keepalive> seconds.
-                # Drop connection after 5 failed keepalives
-                # `keepalive` may be a bool or an integer
-                if keepalive is True:
-                    keepalive = 60
-                if keepalive < 1:
-                    raise ValueError("Keepalive minimal value is 1 second")
-
-                s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 5)
-                s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, keepalive)
-                s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, keepalive)
-        return s
+                is_linux_socket = hasattr(socket, "TCP_KEEPIDLE")
+                is_linux_socket &= hasattr(socket, "TCP_KEEPINTVL")
+                is_linux_socket &= hasattr(socket, "TCP_KEEPCNT")
+                if is_linux_socket:
+                    # Drop connection after 5 failed keepalives
+                    # `keepalive` may be a bool or an integer
+                    if keepalive is True:
+                        keepalive = 60
+                    if keepalive < 1:
+                        raise ValueError("Keepalive minimal value is 1 second")
+
+                    s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 5)
+                    s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, keepalive)
+                    s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, keepalive)
+            return s
+        except BaseException:
+            s.close()
+            raise
 
     @classmethod
     def connect(cls, host, port, **kwargs):
@@ -154,7 +172,7 @@ class SocketStream(Stream):
         return cls(cls._connect(host, port, **kwargs))
 
     @classmethod
-    def unix_connect(cls, path, timeout = 3):
+    def unix_connect(cls, path, timeout=3):
         """factory method that creates a ``SocketStream`` over a unix domain socket
         located in *path*
 
@@ -162,9 +180,13 @@ class SocketStream(Stream):
         :param timeout: socket timeout
         """
         s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        s.settimeout(timeout)
-        s.connect(path)
-        return cls(s)
+        try:
+            s.settimeout(timeout)
+            s.connect(path)
+            return cls(s)
+        except BaseException:
+            s.close()
+            raise
 
     @classmethod
     def ssl_connect(cls, host, port, ssl_kwargs, **kwargs):
@@ -183,15 +205,21 @@ class SocketStream(Stream):
 
         :returns: a :class:`SocketStream`
         """
+        import ssl
         if kwargs.pop("ipv6", False):
             kwargs["family"] = socket.AF_INET6
         s = cls._connect(host, port, **kwargs)
-        s2 = ssl.wrap_socket(s, **ssl_kwargs)
-        return cls(s2)
+        try:
+            s2 = ssl.wrap_socket(s, **ssl_kwargs)
+            return cls(s2)
+        except BaseException:
+            s.close()
+            raise
 
     @property
     def closed(self):
         return self.sock is ClosedFile
+
     def close(self):
         if not self.closed:
             try:
@@ -200,6 +228,7 @@ class SocketStream(Stream):
                 pass
         self.sock.close()
         self.sock = ClosedFile
+
     def fileno(self):
         try:
             return self.sock.fileno()
@@ -231,6 +260,7 @@ class SocketStream(Stream):
             data.append(buf)
             count -= len(buf)
         return BYTES_LITERAL("").join(data)
+
     def write(self, data):
         try:
             while data:
@@ -241,27 +271,33 @@ class SocketStream(Stream):
             self.close()
             raise EOFError(ex)
 
+
 class TunneledSocketStream(SocketStream):
     """A socket stream over an SSH tunnel (terminates the tunnel when the connection closes)"""
 
     __slots__ = ("tun",)
+
     def __init__(self, sock):
         self.sock = sock
         self.tun = None
+
     def close(self):
         SocketStream.close(self)
         if self.tun:
             self.tun.close()
 
+
 class PipeStream(Stream):
     """A stream over two simplex pipes (one used to input, another for output)"""
 
     __slots__ = ("incoming", "outgoing")
     MAX_IO_CHUNK = 32000
+
     def __init__(self, incoming, outgoing):
         outgoing.flush()
         self.incoming = incoming
         self.outgoing = outgoing
+
     @classmethod
     def from_std(cls):
         """factory method that creates a PipeStream over the standard pipes
@@ -270,6 +306,7 @@ class PipeStream(Stream):
         :returns: a :class:`PipeStream` instance
         """
         return cls(sys.stdin, sys.stdout)
+
     @classmethod
     def create_pair(cls):
         """factory method that creates two pairs of anonymous pipes, and
@@ -282,16 +319,20 @@ class PipeStream(Stream):
         side1 = cls(os.fdopen(r1, "rb"), os.fdopen(w2, "wb"))
         side2 = cls(os.fdopen(r2, "rb"), os.fdopen(w1, "wb"))
         return side1, side2
+
     @property
     def closed(self):
         return self.incoming is ClosedFile
+
     def close(self):
         self.incoming.close()
         self.outgoing.close()
         self.incoming = ClosedFile
         self.outgoing = ClosedFile
+
     def fileno(self):
         return self.incoming.fileno()
+
     def read(self, count):
         data = []
         try:
@@ -309,6 +350,7 @@ class PipeStream(Stream):
             self.close()
             raise EOFError(ex)
         return BYTES_LITERAL("").join(data)
+
     def write(self, data):
         try:
             while data:
@@ -330,6 +372,7 @@ class Win32PipeStream(Stream):
     MAX_IO_CHUNK = 32000
 
     def __init__(self, incoming, outgoing):
+        import msvcrt
         self._keepalive = (incoming, outgoing)
         if hasattr(incoming, "fileno"):
             self._fileno = incoming.fileno()
@@ -338,9 +381,11 @@ class Win32PipeStream(Stream):
             outgoing = msvcrt.get_osfhandle(outgoing.fileno())
         self.incoming = incoming
         self.outgoing = outgoing
+
     @classmethod
     def from_std(cls):
         return cls(sys.stdin, sys.stdout)
+
     @classmethod
     def create_pair(cls):
         r1, w1 = win32pipe.CreatePipe(None, cls.PIPE_BUFFER_SIZE)
@@ -349,9 +394,11 @@ class Win32PipeStream(Stream):
 
     def fileno(self):
         return self._fileno
+
     @property
     def closed(self):
         return self.incoming is ClosedFile
+
     def close(self):
         if self.closed:
             return
@@ -365,6 +412,7 @@ class Win32PipeStream(Stream):
         except Exception:
             pass
         self.outgoing = ClosedFile
+
     def read(self, count):
         try:
             data = []
@@ -382,6 +430,7 @@ class Win32PipeStream(Stream):
             self.close()
             raise EOFError(ex)
         return BYTES_LITERAL("").join(data)
+
     def write(self, data):
         try:
             while data:
@@ -397,8 +446,8 @@ class Win32PipeStream(Stream):
             self.close()
             raise EOFError(ex)
 
-    def poll(self, timeout, interval = 0.1):
-        """a poor man's version of select()"""
+    def poll(self, timeout, interval=0.001):
+        """a Windows version of select()"""
         timeout = Timeout(timeout)
         try:
             while True:
@@ -421,20 +470,28 @@ class NamedPipeStream(Win32PipeStream):
     NAMED_PIPE_PREFIX = r'\\.\pipe\rpyc_'
     PIPE_IO_TIMEOUT = 3
     CONNECT_TIMEOUT = 3
-    __slots__ = ("is_server_side",)
 
     def __init__(self, handle, is_server_side):
+        import pywintypes
         Win32PipeStream.__init__(self, handle, handle)
         self.is_server_side = is_server_side
+        self.read_overlapped = pywintypes.OVERLAPPED()
+        self.read_overlapped.hEvent = win32event.CreateEvent(None, 1, 1, None)
+        self.write_overlapped = pywintypes.OVERLAPPED()
+        self.write_overlapped.hEvent = win32event.CreateEvent(None, 1, 1, None)
+        self.poll_buffer = win32file.AllocateReadBuffer(1)
+        self.poll_read = False
+
     @classmethod
     def from_std(cls):
         raise NotImplementedError()
+
     @classmethod
     def create_pair(cls):
         raise NotImplementedError()
 
     @classmethod
-    def create_server(cls, pipename, connect = True):
+    def create_server(cls, pipename, connect=True):
         """factory method that creates a server-side ``NamedPipeStream``, over
         a newly-created *named pipe* of the given name.
 
@@ -449,8 +506,8 @@ class NamedPipeStream(Win32PipeStream):
             pipename = cls.NAMED_PIPE_PREFIX + pipename
         handle = win32pipe.CreateNamedPipe(
             pipename,
-            win32pipe.PIPE_ACCESS_DUPLEX,
-            win32pipe.PIPE_TYPE_BYTE | win32pipe.PIPE_READMODE_BYTE | win32pipe.PIPE_WAIT,
+            win32pipe.PIPE_ACCESS_DUPLEX | win32file.FILE_FLAG_OVERLAPPED,
+            win32pipe.PIPE_TYPE_BYTE | win32pipe.PIPE_READMODE_BYTE,
             1,
             cls.PIPE_BUFFER_SIZE,
             cls.PIPE_BUFFER_SIZE,
@@ -467,7 +524,8 @@ class NamedPipeStream(Win32PipeStream):
         until a connection arrives)"""
         if not self.is_server_side:
             raise ValueError("this must be the server side")
-        win32pipe.ConnectNamedPipe(self.incoming, None)
+        win32pipe.ConnectNamedPipe(self.incoming, self.write_overlapped)
+        win32event.WaitForSingleObject(self.write_overlapped.hEvent, win32event.INFINITE)
 
     @classmethod
     def create_client(cls, pipename):
@@ -488,7 +546,7 @@ class NamedPipeStream(Win32PipeStream):
             0,
             None,
             win32file.OPEN_EXISTING,
-            0,
+            win32file.FILE_FLAG_OVERLAPPED,
             None
         )
         return cls(handle, False)
@@ -499,9 +557,77 @@ class NamedPipeStream(Win32PipeStream):
         if self.is_server_side:
             win32file.FlushFileBuffers(self.outgoing)
             win32pipe.DisconnectNamedPipe(self.outgoing)
+
+        win32file.CloseHandle(self.read_overlapped.hEvent)
+        win32file.CloseHandle(self.write_overlapped.hEvent)
         Win32PipeStream.close(self)
 
+    def read(self, count):
+        try:
+            if self.poll_read:
+                win32file.GetOverlappedResult(self.incoming, self.read_overlapped, 1)
+                data = [self.poll_buffer[:]]
+                self.poll_read = False
+                count -= 1
+            else:
+                data = []
+            while count > 0:
+                hr, buf = win32file.ReadFile(self.incoming,
+                                             win32file.AllocateReadBuffer(int(min(self.MAX_IO_CHUNK, count))),
+                                             self.read_overlapped)
+                n = win32file.GetOverlappedResult(self.incoming, self.read_overlapped, 1)
+                count -= n
+                data.append(buf[:n])
+        except TypeError:
+            ex = sys.exc_info()[1]
+            if not self.closed:
+                raise
+            raise EOFError(ex)
+        except win32file.error:
+            ex = sys.exc_info()[1]
+            self.close()
+            raise EOFError(ex)
+        return BYTES_LITERAL("").join(data)
 
-if sys.platform == "win32":
-    PipeStream = Win32PipeStream
+    def write(self, data):
+        try:
+            while data:
+                dummy, count = win32file.WriteFile(self.outgoing, data[:self.MAX_IO_CHUNK], self.write_overlapped)
+                data = data[count:]
+        except TypeError:
+            ex = sys.exc_info()[1]
+            if not self.closed:
+                raise
+            raise EOFError(ex)
+        except win32file.error:
+            ex = sys.exc_info()[1]
+            self.close()
+            raise EOFError(ex)
 
+    def poll(self, timeout, interval=0.001):
+        """Windows version of select()"""
+        timeout = Timeout(timeout)
+        try:
+            if timeout.finite:
+                wait_time = int(max(1, timeout.timeleft() * 1000))
+            else:
+                wait_time = win32event.INFINITE
+
+            if not self.poll_read:
+                hr, self.poll_buffer = win32file.ReadFile(self.incoming,
+                                                          self.poll_buffer,
+                                                          self.read_overlapped)
+                self.poll_read = True
+                if hr == 0:
+                    return True
+            res = win32event.WaitForSingleObject(self.read_overlapped.hEvent, wait_time)
+            return res == win32event.WAIT_OBJECT_0
+        except TypeError:
+            ex = sys.exc_info()[1]
+            if not self.closed:
+                raise
+            raise EOFError(ex)
+
+
+if sys.platform == "win32":
+    PipeStream = Win32PipeStream  # noqa: F811
diff --git a/plainbox/vendor/rpyc/core/vinegar.py b/plainbox/vendor/rpyc/core/vinegar.py
index d9b92a7..b766b58 100644
--- a/plainbox/vendor/rpyc/core/vinegar.py
+++ b/plainbox/vendor/rpyc/core/vinegar.py
@@ -21,7 +21,13 @@ except ImportError:
 
 from plainbox.vendor.rpyc.core import brine
 from plainbox.vendor.rpyc.core import consts
-from plainbox.vendor.rpyc.lib.compat import is_py3k
+from plainbox.vendor.rpyc import version
+from plainbox.vendor.rpyc.lib.compat import is_py_3k
+
+
+REMOTE_LINE_START = "\n\n========= Remote Traceback "
+REMOTE_LINE_END = " =========\n"
+REMOTE_LINE = "{0}({{}}){1}".format(REMOTE_LINE_START, REMOTE_LINE_END)
 
 
 try:
@@ -30,7 +36,8 @@ except NameError:
     # python 2.4 compatible
     BaseException = Exception
 
-def dump(typ, val, tb, include_local_traceback):
+
+def dump(typ, val, tb, include_local_traceback, include_local_version):
     """Dumps the given exceptions info, as returned by ``sys.exc_info()``
 
     :param typ: the exception's type (class)
@@ -47,7 +54,7 @@ def dump(typ, val, tb, include_local_traceback):
               :func:`brine.dump <rpyc.core.brine.dump>`
     """
     if typ is StopIteration:
-        return consts.EXC_STOP_ITERATION # optimization
+        return consts.EXC_STOP_ITERATION  # optimization
     if type(typ) is str:
         return typ
 
@@ -76,8 +83,13 @@ def dump(typ, val, tb, include_local_traceback):
             if not brine.dumpable(attrval):
                 attrval = repr(attrval)
             attrs.append((name, attrval))
+    if include_local_version:
+        attrs.append(("_remote_version", version.version_string))
+    else:
+        attrs.append(("_remote_version", "<version denied>"))
     return (typ.__module__, typ.__name__), tuple(args), tuple(attrs), tbtext
 
+
 def load(val, import_custom_exceptions, instantiate_custom_exceptions, instantiate_oldstyle_exceptions):
     """
     Loads a dumped exception (the tuple returned by :func:`dump`) info a
@@ -101,11 +113,12 @@ def load(val, import_custom_exceptions, instantiate_custom_exceptions, instantia
     :returns: A throwable exception object
     """
     if val == consts.EXC_STOP_ITERATION:
-        return StopIteration # optimization
+        return StopIteration  # optimization
     if type(val) is str:
-        return val # deprecated string exceptions
+        return val  # deprecated string exceptions
 
     (modname, clsname), args, attrs, tbtext = val
+
     if import_custom_exceptions and modname not in sys.modules:
         try:
             __import__(modname, None, None, "*")
@@ -122,7 +135,7 @@ def load(val, import_custom_exceptions, instantiate_custom_exceptions, instantia
     else:
         cls = None
 
-    if is_py3k:
+    if is_py_3k:
         if not isinstance(cls, type) or not issubclass(cls, BaseException):
             cls = None
     else:
@@ -138,7 +151,7 @@ def load(val, import_custom_exceptions, instantiate_custom_exceptions, instantia
         # py2: `type()` expects `str` not `unicode`!
         fullname = str(fullname)
         if fullname not in _generic_exceptions_cache:
-            fakemodule = {"__module__" : "%s/%s" % (__name__, modname)}
+            fakemodule = {"__module__": "%s/%s" % (__name__, modname)}
             if isinstance(GenericException, ClassType):
                 _generic_exceptions_cache[fullname] = ClassType(fullname, (GenericException,), fakemodule)
             else:
@@ -155,7 +168,17 @@ def load(val, import_custom_exceptions, instantiate_custom_exceptions, instantia
 
     exc.args = args
     for name, attrval in attrs:
-        setattr(exc, name, attrval)
+        try:
+            setattr(exc, name, attrval)
+        except AttributeError:      # handle immutable attrs (@property)
+            pass
+
+    # When possible and relevant, warn the user about mismatch in major versions between remote and local
+    remote_ver = getattr(exc, "_remote_version", "<version denied>")
+    if remote_ver != "<version denied>" and remote_ver.split('.')[0] != str(version.version[0]):
+        _warn = '\nWARNING: Remote is on RPyC {} and local is on RPyC {}.\n\n'
+        tbtext += _warn.format(remote_ver, version.version_string)
+
     exc._remote_tb = tbtext
     return exc
 
@@ -165,9 +188,11 @@ class GenericException(Exception):
     the other party cannot be instantiated locally"""
     pass
 
+
 _generic_exceptions_cache = {}
 _exception_classes_cache = {}
 
+
 def _get_exception_class(cls):
     if cls in _exception_classes_cache:
         return _exception_classes_cache[cls]
@@ -180,9 +205,10 @@ def _get_exception_class(cls):
             except Exception:
                 text = "<Unprintable exception>"
             if hasattr(self, "_remote_tb"):
-                text += "\n\n========= Remote Traceback (%d) =========\n%s" % (
-                    self._remote_tb.count("\n\n========= Remote Traceback") + 1, self._remote_tb)
+                text += REMOTE_LINE.format(self._remote_tb.count(REMOTE_LINE_START) + 1)
+                text += self._remote_tb
             return text
+
         def __repr__(self):
             return str(self)
 
@@ -190,4 +216,3 @@ def _get_exception_class(cls):
     Derived.__module__ = cls.__module__
     _exception_classes_cache[cls] = Derived
     return Derived
-
diff --git a/plainbox/vendor/rpyc/experimental/__init__.py b/plainbox/vendor/rpyc/experimental/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/plainbox/vendor/rpyc/experimental/__init__.py
+++ /dev/null
diff --git a/plainbox/vendor/rpyc/experimental/retunnel.py b/plainbox/vendor/rpyc/experimental/retunnel.py
deleted file mode 100644
index 5becac2..0000000
--- a/plainbox/vendor/rpyc/experimental/retunnel.py
+++ /dev/null
@@ -1,185 +0,0 @@
-import socket
-import random
-import time
-from Queue import Queue, Empty as QueueEmpty
-from plainbox.vendor.rpyc.core.stream import Stream, TunneledSocketStream, ClosedFile
-
-
-COOKIE_LENGTH = 8
-
-class ReconnectingTunnelStream(Stream):
-    RETRIES = 5
-
-    def __init__(self, remote_machine, destination_port, retries = RETRIES):
-        self.remote_machine = remote_machine
-        self.destination_port = destination_port
-        self.retries = retries
-        self.cookie = "".join(chr(random.randint(0, 255)) for _ in range(COOKIE_LENGTH))
-        self.stream = None
-
-    def close(self):
-        if self.stream is not None and not self.closed:
-            self.stream.close()
-        self.stream = ClosedFile
-
-    @property
-    def closed(self):
-        return self.stream is ClosedFile
-
-    def fileno(self):
-        return self._safeio(lambda stream: stream.fileno())
-
-    def _reconnect(self):
-        # choose random local_port
-        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        s.bind(("localhost", 0))
-        local_port = s.getsockname()[1]
-        s.close()
-        # create a tunnel from local_port:destination_port and connect it
-        tun = self.remote_machine.tunnel(local_port, self.destination_port)
-        stream = TunneledSocketStream.connect("localhost", local_port)
-        stream.write(self.cookie)
-        stream.tun = tun
-        # print "ReconnectingTunnelStream._reconnect: established a tunnel from localhost:%r to %s:%r" % (
-        #    local_port, self.remote_machine, self.destination_port)
-        return stream
-
-    def _safeio(self, callback):
-        if self.closed:
-            raise ValueError("I/O operation on closed file")
-        for i in range(self.retries):
-            try:
-                if not self.stream:
-                    self.stream = self._reconnect()
-                return callback(self.stream)
-            except (EOFError, IOError, OSError, socket.error):
-                if i >= self.retries - 1:
-                    raise
-                if self.stream:
-                    self.stream.close()
-                self.stream = None
-                time.sleep(0.5)
-
-    def write(self, data):
-        # print "ReconnectingTunnelStream.write(%r)" % (len(data),)
-        return self._safeio(lambda stream: stream.write(data))
-
-    def read(self, count):
-        # print "ReconnectingTunnelStream.read(%r)" % (count,)
-        return self._safeio(lambda stream: stream.read(count))
-
-
-class MultiplexingListener(object):
-    REACCEPT_TIMEOUT = 10
-    RETRIES = 5
-
-    def __init__(self, reaccept_timeout = REACCEPT_TIMEOUT, retries = RETRIES):
-        self.listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.reaccept_timeout = reaccept_timeout
-        self.retries = retries
-        self.client_map = {}
-
-    def close(self):
-        self.listener.close()
-        self.listener = ClosedFile
-    def fileno(self):
-        return self.listener.getfileno()
-    def getsockname(self):
-        return self.listener.getsockname()
-    def listen(self, backlog):
-        self.listener.listen(backlog)
-    def bind(self, addrinfo):
-        self.listener.bind(addrinfo)
-    def settimeout(self, timeout):
-        self.listener.settimeout(timeout)
-    def setsockopt(self, level, option, value):
-        return self.listener.setsockopt(level, option, value)
-    def shutdown(self, mode):
-        self.listener.shutdown(mode)
-
-    def accept(self):
-        while True:
-            # print "MultiplexingListener.accept"
-            sock, addrinfo = self.listener.accept()
-            cookie = sock.recv(COOKIE_LENGTH)
-            # print "MultiplexingListener.accept: got cookie %r" % (cookie,)
-
-            if cookie not in self.client_map:
-                self.client_map[cookie] = Queue(1)
-                self.client_map[cookie].put(sock)
-                # print "MultiplexingListener.accept: new, map=%r" % (self.client_map,)
-
-                resock = ReconnectingSocket(self, cookie, self.retries)
-                return resock, addrinfo
-            else:
-                self.client_map[cookie].put(sock)
-                # print "MultiplexingListener.accept: old, map=%r" % (self.client_map,)
-
-    def reaccept(self, cookie):
-        # print "MultiplexingListener.reaccept: %r" % (cookie,)
-        try:
-            return self.client_map[cookie].get(self.reaccept_timeout)
-        except QueueEmpty:
-            raise EOFError("Client did not reconnect within the timeout")
-
-
-class ReconnectingSocket(object):
-    def __init__(self, listener, cookie, retries):
-        self.listener = listener
-        self.cookie = cookie
-        self.sock = None
-        self.retries = retries
-        self.blocking_mode = None
-
-    def close(self):
-        if self.sock:
-            self.sock.close()
-        self.sock = ClosedFile
-
-    def fileno(self):
-        return self._safeio(lambda sock: sock.fileno())
-    def getsockname(self):
-        return self._safeio(lambda sock: sock.getsockname())
-    def getpeername(self):
-        return self._safeio(lambda sock: sock.getpeername())
-    def shutdown(self, mode):
-        if self.sock:
-            self.sock.shutdown(mode)
-
-    def setblocking(self, mode):
-        self.blocking_mode = mode
-        if self.sock:
-            self.sock.setblocking(mode)
-
-    def _safeio(self, callback):
-        for i in range(self.retries):
-            if self.sock is None:
-                self.sock = self.listener.reaccept(self.cookie)
-                if self.blocking_mode is not None:
-                    self.sock.setblocking(self.blocking_mode)
-
-            try:
-                return callback(self.sock)
-            except (EOFError, IOError, OSError, socket.error):
-                if i >= self.retries - 1:
-                    raise
-                if self.sock:
-                    self.sock.close()
-                self.sock = None
-
-    def recv(self, count):
-        # print "ReconnectingSocket.recv(%r)" % (count,)
-        return self._safeio(lambda sock: sock.recv(count))
-
-    def send(self, data):
-        # print "ReconnectingSocket.send(%r)" % (len(data),)
-        return self._safeio(lambda sock: sock.send(data))
-
-
-
-
-
-
-
-
-
diff --git a/plainbox/vendor/rpyc/experimental/splitbrain.py b/plainbox/vendor/rpyc/experimental/splitbrain.py
deleted file mode 100644
index 3c89cf3..0000000
--- a/plainbox/vendor/rpyc/experimental/splitbrain.py
+++ /dev/null
@@ -1,247 +0,0 @@
-"""
-The Magnificent Splitbrain
-.. versionadded:: 3.3
-
-"""
-import sys
-import atexit
-import threading
-from contextlib import contextmanager
-import functools
-import gc
-try:
-    import __builtin__ as builtins
-except ImportError:
-    import builtins # python 3+
-from types import ModuleType
-
-router = threading.local()
-
-routed_modules = set(["os", "os.path", "platform", "ntpath", "posixpath", "zipimport", "genericpath",
-    "posix", "nt", "signal", "time", "sysconfig", "_locale", "locale", "socket", "_socket", "ssl", "_ssl",
-    "struct", "_struct", "_symtable", "errno", "fcntl", "grp", "pwd", "select", "spwd", "syslog", "thread",
-    "_io", "io", "subprocess", "_subprocess", "datetime", "mmap", "msvcrt", "pdb", "bdb", "glob", "fnmatch",
-    #"_frozen_importlib", "imp", "exceptions"
-    ])
-
-class RoutedModule(ModuleType):
-    def __init__(self, realmod):
-        ModuleType.__init__(self, realmod.__name__, getattr(realmod, "__doc__", None))
-        object.__setattr__(self, "__realmod__", realmod)
-        object.__setattr__(self, "__file__", getattr(realmod, "__file__", None))
-    def __repr__(self):
-        if self.__file__:
-            return "<module %r from %r>" % (self.__name__, self.__file__)
-        else:
-            return "<module %r (built-in)>" % (self.__name__,)
-    def __dir__(self):
-        return dir(self.__currmod__)
-    def __getattribute__(self, name):
-        if name == "__realmod__":
-            return object.__getattribute__(self, "__realmod__")
-        elif name == "__name__":
-            return object.__getattribute__(self, "__name__")
-        elif name == "__currmod__":
-            modname = object.__getattribute__(self, "__name__")
-            if hasattr(router, "conn"):
-                return router.conn.modules[modname]
-            else:
-                return object.__getattribute__(self, "__realmod__")
-        else:
-            return getattr(self.__currmod__, name)
-    def __delattr__(self, name, val):
-        return setattr(self.__currmod__, name, val)
-    def __setattr__(self, name, val):
-        return setattr(self.__currmod__, name, val)
-
-routed_sys_attrs = set(["byteorder", "platform", "getfilesystemencoding", "getdefaultencoding", "settrace",
-    "setprofile", "setrecursionlimit", "getprofile", "getrecursionlimit", "getsizeof", "gettrace",
-    "exc_clear", "exc_info", "exc_type", "last_type", "last_value", "last_traceback",
-    ])
-
-class RoutedSysModule(ModuleType):
-    def __init__(self):
-        ModuleType.__init__(self, "sys", sys.__doc__)
-    def __dir__(self):
-        return dir(sys)
-    def __getattribute__(self, name):
-        if name in routed_sys_attrs and hasattr(router, "conn"):
-            return getattr(router.conn.modules["sys"], name)
-        else:
-            return getattr(sys, name)
-    def __setattr__(self, name, value):
-        if name in routed_sys_attrs and hasattr(router, "conn"):
-            setattr(router.conn.modules["sys"], name, value)
-        else:
-            setattr(sys, name, value)
-
-rsys = RoutedSysModule()
-
-class RemoteModule(ModuleType):
-    def __init__(self, realmod):
-        ModuleType.__init__(self, realmod.__name__, getattr(realmod, "__doc__", None))
-        object.__setattr__(self, "__file__", getattr(realmod, "__file__", None))
-    def __repr__(self):
-        try:
-            self.__currmod__
-        except (AttributeError, ImportError):
-            return "<module %r (stale)>" % (self.__name__,)
-        if self.__file__:
-            return "<module %r from %r>" % (self.__name__, self.__file__)
-        else:
-            return "<module %r (built-in)>" % (self.__name__,)
-    def __dir__(self):
-        return dir(self.__currmod__)
-
-    def __getattribute__(self, name):
-        if name == "__name__":
-            return object.__getattribute__(self, "__name__")
-        elif name == "__currmod__":
-            modname = object.__getattribute__(self, "__name__")
-            if not hasattr(router, "conn"):
-                raise AttributeError("Module %r is not available in this context" % (modname,))
-            mod = router.conn.modules._ModuleNamespace__cache.get(modname)
-            if not mod:
-                raise AttributeError("Module %r is not available in this context" % (modname,))
-            return mod
-        else:
-            return getattr(self.__currmod__, name)
-    def __delattr__(self, name, val):
-        return setattr(self.__currmod__, name, val)
-    def __setattr__(self, name, val):
-        return setattr(self.__currmod__, name, val)
-
-
-_orig_import = builtins.__import__
-
-def _importer(modname, *args, **kwargs):
-    if not hasattr(router, "conn"):
-        return _orig_import(modname, *args, **kwargs)
-    existing = sys.modules.get(modname, None)
-    if type(existing) is RoutedModule:
-        return existing
-
-    mod = router.conn.modules[modname]
-    if existing and type(existing) is RemoteModule:
-        return existing
-    rmod = RemoteModule(mod)
-    sys.modules[modname] = rmod
-    return rmod
-
-_enabled = False
-_prev_builtins = {}
-
-def enable_splitbrain():
-    """Enables (activates) the Splitbrain machinery; must be called before entering
-    ``splitbrain`` or ``localbrain`` contexts"""
-    global _enabled
-    if _enabled:
-        return
-    sys.modules["sys"] = rsys
-    for modname in routed_modules:
-        try:
-            realmod = _orig_import(modname, [], [], "*")
-        except ImportError:
-            continue
-        rmod = RoutedModule(realmod)
-        sys.modules[modname] = rmod
-        for ref in gc.get_referrers(realmod):
-            if not isinstance(ref, dict) or "__name__" not in ref or ref.get("__file__") is None:
-                continue
-            n = ref["__name__"]
-            if n in routed_modules or n.startswith("rpyc") or n.startswith("importlib") or n.startswith("imp"):
-                continue
-            for k, v in ref.items():
-                if v is realmod:
-                    #print ("## %s.%s = %s" % (ref["__name__"], ref[k], modname))
-                    ref[k] = rmod
-
-    builtins.__import__ = _importer
-    for funcname in ["open", "execfile", "file"]:
-        if not hasattr(builtins, funcname):
-            continue
-        def mkfunc(funcname, origfunc):
-            @functools.wraps(getattr(builtins, funcname))
-            def tlbuiltin(*args, **kwargs):
-                if hasattr(router, "conn"):
-                    func = getattr(router.conn.builtins, funcname)
-                else:
-                    func = origfunc
-                return func(*args, **kwargs)
-            return tlbuiltin
-        origfunc = getattr(builtins, funcname)
-        _prev_builtins[funcname] = origfunc
-        setattr(builtins, funcname, mkfunc(funcname, origfunc))
-
-    _enabled = True
-
-def disable_splitbrain():
-    """Disables (deactivates) the Splitbrain machinery"""
-    global _enabled
-    if not _enabled:
-        return
-    _enabled = False
-    for funcname, origfunc in _prev_builtins.items():
-        setattr(builtins, funcname, origfunc)
-    for modname, mod in sys.modules.items():
-        if isinstance(mod, RoutedModule):
-            sys.modules[modname] = mod.__realmod__
-            for ref in gc.get_referrers(mod):
-                if isinstance(ref, dict) and "__name__" in ref and ref.get("__file__") is not None:
-                    for k, v in ref.items():
-                        if v is mod:
-                            ref[k] = mod.__realmod__
-    sys.modules["sys"] = sys
-    builtins.__import__ = _orig_import
-
-atexit.register(disable_splitbrain)
-
-@contextmanager
-def splitbrain(conn):
-    """Enter a splitbrain context in which imports take place over the given RPyC connection (expected to
-    be a SlaveService). You can enter this context only after calling ``enable()``"""
-    if not _enabled:
-        enable_splitbrain()
-        #raise ValueError("Splitbrain not enabled")
-    prev_conn = getattr(router, "conn", None)
-    prev_modules = sys.modules.copy()
-    router.conn = conn
-    prev_stdin = conn.modules.sys.stdin
-    prev_stdout = conn.modules.sys.stdout
-    prev_stderr = conn.modules.sys.stderr
-    conn.modules["sys"].stdin = sys.stdin
-    conn.modules["sys"].stdout = sys.stdout
-    conn.modules["sys"].stderr = sys.stderr
-    try:
-        yield
-    finally:
-        conn.modules["sys"].stdin = prev_stdin
-        conn.modules["sys"].stdout = prev_stdout
-        conn.modules["sys"].stderr = prev_stderr
-        sys.modules.clear()
-        sys.modules.update(prev_modules)
-        router.conn = prev_conn
-        if not router.conn:
-            del router.conn
-
-@contextmanager
-def localbrain():
-    """Return to operate on the local machine. You can enter this context only after calling ``enable()``"""
-    if not _enabled:
-        raise ValueError("Splitbrain not enabled")
-    prev_conn = getattr(router, "conn", None)
-    prev_modules = sys.modules.copy()
-    if hasattr(router, "conn"):
-        del router.conn
-    try:
-        yield
-    finally:
-        sys.modules.clear()
-        sys.modules.update(prev_modules)
-        router.conn = prev_conn
-        if not router.conn:
-            del router.conn
-
-
-
-
diff --git a/plainbox/vendor/rpyc/lib/__init__.py b/plainbox/vendor/rpyc/lib/__init__.py
index 9895f1e..d96656b 100644
--- a/plainbox/vendor/rpyc/lib/__init__.py
+++ b/plainbox/vendor/rpyc/lib/__init__.py
@@ -1,25 +1,32 @@
 """
 A library of various helpers functions and classes
 """
+import inspect
 import sys
+import socket
 import logging
 import threading
 import time
-from plainbox.vendor.rpyc.lib.compat import maxint
+import random
+from plainbox.vendor.rpyc.lib.compat import maxint  # noqa: F401
 
 
 class MissingModule(object):
     __slots__ = ["__name"]
+
     def __init__(self, name):
         self.__name = name
+
     def __getattr__(self, name):
-        if name.startswith("__"): # issue 71
+        if name.startswith("__"):  # issue 71
             raise AttributeError("module %r not found" % (self.__name,))
         raise ImportError("module %r not found" % (self.__name,))
+
     def __bool__(self):
         return False
     __nonzero__ = __bool__
 
+
 def safe_import(name):
     try:
         mod = __import__(name, None, None, "*")
@@ -27,13 +34,14 @@ def safe_import(name):
         mod = MissingModule(name)
     except Exception:
         # issue 72: IronPython on Mono
-        if sys.platform == "cli" and name == "signal": #os.name == "posix":
+        if sys.platform == "cli" and name == "signal":  # os.name == "posix":
             mod = MissingModule(name)
         else:
             raise
     return mod
 
-def setup_logger(quiet = False, logfile = None):
+
+def setup_logger(quiet=False, logfile=None):
     opts = {}
     if quiet:
         opts['level'] = logging.ERROR
@@ -48,10 +56,13 @@ class hybridmethod(object):
     """Decorator for hybrid instance/class methods that will act like a normal
     method if accessed via an instance, but act like classmethod if accessed
     via the class."""
+
     def __init__(self, func):
         self.func = func
+
     def __get__(self, obj, cls):
         return self.func.__get__(cls if obj is None else obj, obj)
+
     def __set__(self, obj, val):
         raise AttributeError("Cannot overwrite method")
 
@@ -74,7 +85,8 @@ def spawn_waitready(init, main):
     """
     event = threading.Event()
     stack = [event]     # used to exchange arguments with thread, so `event`
-                        # can be deleted when it has fulfilled its purpose.
+    # can be deleted when it has fulfilled its purpose.
+
     def start():
         stack.append(init())
         stack.pop(0).set()
@@ -92,7 +104,7 @@ class Timeout:
             self.tmax = timeout.tmax
         else:
             self.finite = timeout is not None and timeout >= 0
-            self.tmax = time.time()+timeout if self.finite else None
+            self.tmax = time.time() + timeout if self.finite else None
 
     def expired(self):
         return self.finite and time.time() >= self.tmax
@@ -102,3 +114,102 @@ class Timeout:
 
     def sleep(self, interval):
         time.sleep(min(interval, self.timeleft()) if self.finite else interval)
+
+
+def socket_backoff_connect(family, socktype, proto, addr, timeout, attempts):
+    """connect will backoff if the response is not ready for a pseudo random number greater than zero and less than
+        51e-6, 153e-6, 358e-6, 768e-6, 1587e-6, 3225e-6, 6502e-6, 13056e-6, 26163e-6, 52377e-6
+    this should help avoid congestion.
+    """
+    sock = socket.socket(family, socktype, proto)
+    collision = 0
+    connecting = True
+    while connecting:
+        collision += 1
+        try:
+            sock.settimeout(timeout)
+            sock.connect(addr)
+            connecting = False
+        except socket.timeout:
+            if collision == attempts or attempts < 1:
+                raise
+            else:
+                sock.close()
+                sock = socket.socket(family, socktype, proto)
+                time.sleep(exp_backoff(collision))
+    return sock
+
+
+def exp_backoff(collision):
+    """ Exponential backoff algorithm from
+    Peterson, L.L., and Davie, B.S. Computer Networks: a systems approach. 5th ed. pp. 127
+    """
+    n = min(collision, 10)
+    supremum_adjustment = 1 if n > 3 else 0
+    k = random.uniform(0, 2**n - supremum_adjustment)
+    return k * 0.0000512
+
+
+def get_id_pack(obj):
+    """introspects the given "local" object, returns id_pack as expected by BaseNetref
+
+    The given object is "local" in the sense that it is from the local cache. Any object in the local cache exists
+    in the current address space or is a netref. A netref in the local cache could be from a chained-connection.
+    To handle type related behavior properly, the attribute `__class__` is a descriptor for netrefs.
+
+    So, check thy assumptions regarding the given object when creating `id_pack`.
+    """
+    if hasattr(obj, '____id_pack__'):
+        # netrefs are handled first since __class__ is a descriptor
+        return obj.____id_pack__
+    elif inspect.ismodule(obj) or getattr(obj, '__name__', None) == 'module':
+        # TODO: not sure about this, need to enumerate cases in units
+        if isinstance(obj, type):  # module
+            obj_cls = type(obj)
+            name_pack = '{0}.{1}'.format(obj_cls.__module__, obj_cls.__name__)
+            return (name_pack, id(type(obj)), id(obj))
+        else:
+            if inspect.ismodule(obj) and obj.__name__ != 'module':
+                if obj.__name__ in sys.modules:
+                    name_pack = obj.__name__
+                else:
+                    name_pack = '{0}.{1}'.format(obj.__class__.__module__, obj.__name__)
+            elif inspect.ismodule(obj):
+                name_pack = '{0}.{1}'.format(obj__module__, obj.__name__)
+                print(name_pack)
+            elif hasattr(obj, '__module__'):
+                name_pack = '{0}.{1}'.format(obj.__module__, obj.__name__)
+            else:
+                obj_cls = type(obj)
+                name_pack = '{0}'.format(obj.__name__)
+            return (name_pack, id(type(obj)), id(obj))
+    elif not inspect.isclass(obj):
+        name_pack = '{0}.{1}'.format(obj.__class__.__module__, obj.__class__.__name__)
+        return (name_pack, id(type(obj)), id(obj))
+    else:
+        name_pack = '{0}.{1}'.format(obj.__module__, obj.__name__)
+        return (name_pack, id(obj), 0)
+
+
+def get_methods(obj_attrs, obj):
+    """introspects the given (local) object, returning a list of all of its
+    methods (going up the MRO).
+
+    :param obj: any local (not proxy) python object
+
+    :returns: a list of ``(method name, docstring)`` tuples of all the methods
+              of the given object
+    """
+    methods = {}
+    attrs = {}
+    if isinstance(obj, type):
+        # don't forget the darn metaclass
+        mros = list(reversed(type(obj).__mro__)) + list(reversed(obj.__mro__))
+    else:
+        mros = reversed(type(obj).__mro__)
+    for basecls in mros:
+        attrs.update(basecls.__dict__)
+    for name, attr in attrs.items():
+        if name not in obj_attrs and hasattr(attr, "__call__"):
+            methods[name] = inspect.getdoc(attr)
+    return methods.items()
diff --git a/plainbox/vendor/rpyc/lib/colls.py b/plainbox/vendor/rpyc/lib/colls.py
index 1301862..e3b2be9 100644
--- a/plainbox/vendor/rpyc/lib/colls.py
+++ b/plainbox/vendor/rpyc/lib/colls.py
@@ -2,17 +2,23 @@ from __future__ import with_statement
 import weakref
 from threading import Lock
 
+
 class WeakValueDict(object):
     """a light-weight version of weakref.WeakValueDictionary"""
     __slots__ = ("_dict",)
+
     def __init__(self):
         self._dict = {}
+
     def __repr__(self):
         return repr(self._dict)
+
     def __iter__(self):
         return self.iterkeys()
+
     def __len__(self):
         return len(self._dict)
+
     def __contains__(self, key):
         try:
             self[key]
@@ -20,59 +26,76 @@ class WeakValueDict(object):
             return False
         else:
             return True
-    def get(self, key, default = None):
+
+    def get(self, key, default=None):
         try:
             return self[key]
         except KeyError:
             return default
+
     def __getitem__(self, key):
         obj = self._dict[key]()
         if obj is None:
             raise KeyError(key)
         return obj
+
     def __setitem__(self, key, value):
-        def remover(wr, _dict = self._dict, key = key):
+        def remover(wr, _dict=self._dict, key=key):
             _dict.pop(key, None)
         self._dict[key] = weakref.ref(value, remover)
+
     def __delitem__(self, key):
         del self._dict[key]
+
     def iterkeys(self):
         return self._dict.keys()
+
     def keys(self):
         return self._dict.keys()
+
     def itervalues(self):
         for k in self:
             yield self[k]
+
     def values(self):
         return list(self.itervalues())
+
     def iteritems(self):
         for k in self:
             yield k, self[k]
+
     def items(self):
         return list(self.iteritems())
+
     def clear(self):
         self._dict.clear()
 
+
 class RefCountingColl(object):
     """a set-like object that implements refcounting on its contained objects"""
     __slots__ = ("_lock", "_dict")
+
     def __init__(self):
         self._lock = Lock()
         self._dict = {}
+
     def __repr__(self):
         return repr(self._dict)
-    def add(self, obj):
+
+    def add(self, key, obj):
+        """Add object to refcounting coll."""
         with self._lock:
-            key = id(obj)
             slot = self._dict.get(key, None)
             if slot is None:
                 slot = [obj, 0]
             else:
                 slot[1] += 1
             self._dict[key] = slot
+
     def clear(self):
         with self._lock:
             self._dict.clear()
+
     def decref(self, key, count=1):
         with self._lock:
             slot = self._dict[key]
@@ -81,7 +104,7 @@ class RefCountingColl(object):
             else:
                 slot[1] -= count
                 self._dict[key] = slot
+
     def __getitem__(self, key):
         with self._lock:
             return self._dict[key][0]
-
diff --git a/plainbox/vendor/rpyc/lib/compat.py b/plainbox/vendor/rpyc/lib/compat.py
index e941ec5..35be8fd 100644
--- a/plainbox/vendor/rpyc/lib/compat.py
+++ b/plainbox/vendor/rpyc/lib/compat.py
@@ -5,38 +5,46 @@ and various platforms (posix/windows)
 import sys
 import time
 
-is_py3k = (sys.version_info[0] >= 3)
+is_py_3k = (sys.version_info[0] >= 3)
+is_py_gte38 = is_py_3k and (sys.version_info[1] >= 8)
 
-if is_py3k:
+
+if is_py_3k:
     exec("execute = exec")
+
     def BYTES_LITERAL(text):
         return bytes(text, "utf8")
     maxint = sys.maxsize
 else:
     exec("""def execute(code, globals = None, locals = None):
                 exec code in globals, locals""")
+
     def BYTES_LITERAL(text):
         return text
     maxint = sys.maxint
 
 try:
-    from struct import Struct #@UnusedImport
+    from struct import Struct  # noqa: F401
 except ImportError:
     import struct
+
     class Struct(object):
         __slots__ = ["format", "size"]
+
         def __init__(self, format):
             self.format = format
             self.size = struct.calcsize(format)
+
         def pack(self, *args):
             return struct.pack(self.format, *args)
+
         def unpack(self, data):
             return struct.unpack(self.format, data)
 
 try:
     from cStringIO import StringIO as BytesIO
 except ImportError:
-    from io import BytesIO #@UnusedImport
+    from io import BytesIO  # noqa: F401
 
 try:
     next = next
@@ -47,7 +55,7 @@ except NameError:
 try:
     import cPickle as pickle
 except ImportError:
-    import pickle #@UnusedImport
+    import pickle  # noqa: F401
 
 try:
     callable = callable
@@ -59,6 +67,7 @@ try:
     import select as select_module
 except ImportError:
     select_module = None
+
     def select(*args):
         raise ImportError("select not supported on this platform")
 else:
@@ -68,12 +77,14 @@ else:
     else:
         from select import select
 
+
 def get_exc_errno(exc):
     if hasattr(exc, "errno"):
         return exc.errno
     else:
         return exc[0]
 
+
 if select_module:
     select_error = select_module.error
 else:
@@ -83,6 +94,7 @@ if hasattr(select_module, "poll"):
     class PollingPoll(object):
         def __init__(self):
             self._poll = select_module.poll()
+
         def register(self, fd, mode):
             flags = 0
             if "r" in mode:
@@ -98,12 +110,14 @@ if hasattr(select_module, "poll"):
                 flags |= select_module.POLLHUP | select_module.POLLNVAL | POLLRDHUP
             self._poll.register(fd, flags)
         modify = register
+
         def unregister(self, fd):
             self._poll.unregister(fd)
-        def poll(self, timeout = None):
+
+        def poll(self, timeout=None):
             if timeout:
                 # the real poll takes milliseconds while we have seconds here
-                timeout = 1000*timeout
+                timeout = 1000 * timeout
             events = self._poll.poll(timeout)
             processed = []
             for fd, evt in events:
@@ -127,16 +141,19 @@ else:
         def __init__(self):
             self.rlist = set()
             self.wlist = set()
+
         def register(self, fd, mode):
             if "r" in mode:
                 self.rlist.add(fd)
             if "w" in mode:
                 self.wlist.add(fd)
         modify = register
+
         def unregister(self, fd):
             self.rlist.discard(fd)
             self.wlist.discard(fd)
-        def poll(self, timeout = None):
+
+        def poll(self, timeout=None):
             if not self.rlist and not self.wlist:
                 time.sleep(timeout)
                 return []  # need to return an empty array in this case
@@ -157,10 +174,11 @@ def with_metaclass(meta, *bases):
             return meta(name, bases, d)
     return type.__new__(metaclass, 'temporary_class', (), {})
 
+
 if sys.version_info >= (3, 3):
-    TimeoutError = TimeoutError
+    TimeoutError = TimeoutError  # noqa: F821
 else:
-    class TimeoutError(Exception):
+    class TimeoutError(Exception):  # noqa: F821
         pass
 
 if sys.version_info >= (3, 2):
diff --git a/plainbox/vendor/rpyc/utils/__init__.py b/plainbox/vendor/rpyc/utils/__init__.py
index bdc7f07..6a9f9ef 100644
--- a/plainbox/vendor/rpyc/utils/__init__.py
+++ b/plainbox/vendor/rpyc/utils/__init__.py
@@ -1,4 +1,3 @@
 """
 Utilities (not part of the core protocol)
 """
-
diff --git a/plainbox/vendor/rpyc/utils/authenticators.py b/plainbox/vendor/rpyc/utils/authenticators.py
index 226cd02..0d97882 100644
--- a/plainbox/vendor/rpyc/utils/authenticators.py
+++ b/plainbox/vendor/rpyc/utils/authenticators.py
@@ -27,6 +27,7 @@ import sys
 from plainbox.vendor.rpyc.lib import safe_import
 ssl = safe_import("ssl")
 
+
 class AuthenticationError(Exception):
     """raised to signal a failed authentication attempt"""
     pass
@@ -56,8 +57,8 @@ class SSLAuthenticator(object):
     service parameters.
     """
 
-    def __init__(self, keyfile, certfile, ca_certs = None, cert_reqs = None,
-            ssl_version = None, ciphers = None):
+    def __init__(self, keyfile, certfile, ca_certs=None, cert_reqs=None,
+                 ssl_version=None, ciphers=None):
         self.keyfile = str(keyfile)
         self.certfile = str(certfile)
         self.ca_certs = str(ca_certs) if ca_certs else None
@@ -75,9 +76,9 @@ class SSLAuthenticator(object):
             self.ssl_version = ssl_version
 
     def __call__(self, sock):
-        kwargs = dict(keyfile = self.keyfile, certfile = self.certfile,
-            server_side = True, ca_certs = self.ca_certs, cert_reqs = self.cert_reqs,
-            ssl_version = self.ssl_version)
+        kwargs = dict(keyfile=self.keyfile, certfile=self.certfile,
+                      server_side=True, ca_certs=self.ca_certs, cert_reqs=self.cert_reqs,
+                      ssl_version=self.ssl_version)
         if self.ciphers is not None:
             kwargs["ciphers"] = self.ciphers
         try:
@@ -86,6 +87,3 @@ class SSLAuthenticator(object):
             ex = sys.exc_info()[1]
             raise AuthenticationError(str(ex))
         return sock2, sock2.getpeercert()
-
-
-
diff --git a/plainbox/vendor/rpyc/utils/classic.py b/plainbox/vendor/rpyc/utils/classic.py
index 7699c06..2f97dcf 100644
--- a/plainbox/vendor/rpyc/utils/classic.py
+++ b/plainbox/vendor/rpyc/utils/classic.py
@@ -2,22 +2,23 @@ from __future__ import with_statement
 import sys
 import os
 import inspect
-from plainbox.vendor.rpyc.lib.compat import pickle, execute, is_py3k
+from plainbox.vendor.rpyc.lib.compat import pickle, execute, is_py_3k  # noqa: F401
 from plainbox.vendor.rpyc.core.service import ClassicService, Slave
 from plainbox.vendor.rpyc.utils import factory
-from plainbox.vendor.rpyc.core.service import ModuleNamespace
+from plainbox.vendor.rpyc.core.service import ModuleNamespace  # noqa: F401
 from contextlib import contextmanager
 
 
 DEFAULT_SERVER_PORT = 18812
 DEFAULT_SERVER_SSL_PORT = 18821
 
-SlaveService = ClassicService   # avoid renaming SlaveService in this module
-                                # for now
+SlaveService = ClassicService   # avoid renaming SlaveService in this module for now
 
-#===============================================================================
+# ===============================================================================
 # connecting
-#===============================================================================
+# ===============================================================================
+
+
 def connect_channel(channel):
     """
     Creates an RPyC connection over the given ``channel``
@@ -28,6 +29,7 @@ def connect_channel(channel):
     """
     return factory.connect_channel(channel, SlaveService)
 
+
 def connect_stream(stream):
     """
     Creates an RPyC connection over the given stream
@@ -38,6 +40,7 @@ def connect_stream(stream):
     """
     return factory.connect_stream(stream, SlaveService)
 
+
 def connect_stdpipes():
     """
     Creates an RPyC connection over the standard pipes (``stdin`` and ``stdout``)
@@ -46,6 +49,7 @@ def connect_stdpipes():
     """
     return factory.connect_stdpipes(SlaveService)
 
+
 def connect_pipes(input, output):
     """
     Creates an RPyC connection over two pipes
@@ -57,7 +61,8 @@ def connect_pipes(input, output):
     """
     return factory.connect_pipes(input, output, SlaveService)
 
-def connect(host, port = DEFAULT_SERVER_PORT, ipv6 = False, keepalive = False):
+
+def connect(host, port=DEFAULT_SERVER_PORT, ipv6=False, keepalive=False):
     """
     Creates a socket connection to the given host and port.
 
@@ -67,7 +72,8 @@ def connect(host, port = DEFAULT_SERVER_PORT, ipv6 = False, keepalive = False):
 
     :returns: an RPyC connection exposing ``SlaveService``
     """
-    return factory.connect(host, port, SlaveService, ipv6 = ipv6, keepalive = keepalive)
+    return factory.connect(host, port, SlaveService, ipv6=ipv6, keepalive=keepalive)
+
 
 def unix_connect(path):
     """
@@ -79,9 +85,10 @@ def unix_connect(path):
     """
     return factory.unix_connect(path, SlaveService)
 
-def ssl_connect(host, port = DEFAULT_SERVER_SSL_PORT, keyfile = None,
-        certfile = None, ca_certs = None, cert_reqs = None, ssl_version = None,
-        ciphers = None, ipv6 = False):
+
+def ssl_connect(host, port=DEFAULT_SERVER_SSL_PORT, keyfile=None,
+                certfile=None, ca_certs=None, cert_reqs=None, ssl_version=None,
+                ciphers=None, ipv6=False):
     """Creates a secure (``SSL``) socket connection to the given host and port,
     authenticating with the given certfile and CA file.
 
@@ -105,9 +112,10 @@ def ssl_connect(host, port = DEFAULT_SERVER_SSL_PORT, keyfile = None,
 
     .. _wrap_socket:
     """
-    return factory.ssl_connect(host, port, keyfile = keyfile, certfile = certfile,
-        ssl_version = ssl_version, ca_certs = ca_certs, service = SlaveService,
-        ipv6 = ipv6)
+    return factory.ssl_connect(host, port, keyfile=keyfile, certfile=certfile,
+                               ssl_version=ssl_version, ca_certs=ca_certs, service=SlaveService,
+                               ipv6=ipv6)
+
 
 def ssh_connect(remote_machine, remote_port):
     """Connects to the remote server over an SSH tunnel. See
@@ -120,7 +128,8 @@ def ssh_connect(remote_machine, remote_port):
     """
     return factory.ssh_connect(remote_machine, remote_port, SlaveService)
 
-def connect_subproc(server_file = None):
+
+def connect_subproc(server_file=None):
     """Runs an RPyC classic server as a subprocess and returns an RPyC
     connection to it over stdio
 
@@ -134,7 +143,8 @@ def connect_subproc(server_file = None):
         if not server_file:
             raise ValueError("server_file not given and could not be inferred")
     return factory.connect_subproc([sys.executable, "-u", server_file, "-q", "-m", "stdio"],
-        SlaveService)
+                                   SlaveService)
+
 
 def connect_thread():
     """
@@ -143,9 +153,10 @@ def connect_thread():
 
     :returns: an RPyC connection exposing ``SlaveService``
     """
-    return factory.connect_thread(SlaveService, remote_service = SlaveService)
+    return factory.connect_thread(SlaveService, remote_service=SlaveService)
 
-def connect_multiprocess(args = {}):
+
+def connect_multiprocess(args={}):
     """
     Starts a SlaveService on a multiprocess process and connects to it.
     Useful for testing purposes and running multicore code thats uses shared
@@ -153,14 +164,14 @@ def connect_multiprocess(args = {}):
 
     :returns: an RPyC connection exposing ``SlaveService``
     """
-    return factory.connect_multiprocess(SlaveService, remote_service = SlaveService, args=args)
+    return factory.connect_multiprocess(SlaveService, remote_service=SlaveService, args=args)
 
 
-#===============================================================================
+# ===============================================================================
 # remoting utilities
-#===============================================================================
+# ===============================================================================
 
-def upload(conn, localpath, remotepath, filter = None, ignore_invalid = False, chunk_size = 16000):
+def upload(conn, localpath, remotepath, filter=None, ignore_invalid=False, chunk_size=16000):
     """uploads a file or a directory to the given remote path
 
     :param localpath: the local file or directory
@@ -177,7 +188,8 @@ def upload(conn, localpath, remotepath, filter = None, ignore_invalid = False, c
         if not ignore_invalid:
             raise ValueError("cannot upload %r" % (localpath,))
 
-def upload_file(conn, localpath, remotepath, chunk_size = 16000):
+
+def upload_file(conn, localpath, remotepath, chunk_size=16000):
     with open(localpath, "rb") as lf:
         with conn.builtin.open(remotepath, "wb") as rf:
             while True:
@@ -186,16 +198,18 @@ def upload_file(conn, localpath, remotepath, chunk_size = 16000):
                     break
                 rf.write(buf)
 
-def upload_dir(conn, localpath, remotepath, filter = None, chunk_size = 16000):
+
+def upload_dir(conn, localpath, remotepath, filter=None, chunk_size=16000):
     if not conn.modules.os.path.isdir(remotepath):
         conn.modules.os.makedirs(remotepath)
     for fn in os.listdir(localpath):
         if not filter or filter(fn):
             lfn = os.path.join(localpath, fn)
             rfn = conn.modules.os.path.join(remotepath, fn)
-            upload(conn, lfn, rfn, filter = filter, ignore_invalid = True, chunk_size = chunk_size)
+            upload(conn, lfn, rfn, filter=filter, ignore_invalid=True, chunk_size=chunk_size)
 
-def download(conn, remotepath, localpath, filter = None, ignore_invalid = False, chunk_size = 16000):
+
+def download(conn, remotepath, localpath, filter=None, ignore_invalid=False, chunk_size=16000):
     """
     download a file or a directory to the given remote path
 
@@ -213,7 +227,8 @@ def download(conn, remotepath, localpath, filter = None, ignore_invalid = False,
         if not ignore_invalid:
             raise ValueError("cannot download %r" % (remotepath,))
 
-def download_file(conn, remotepath, localpath, chunk_size = 16000):
+
+def download_file(conn, remotepath, localpath, chunk_size=16000):
     with conn.builtin.open(remotepath, "rb") as rf:
         with open(localpath, "wb") as lf:
             while True:
@@ -222,16 +237,18 @@ def download_file(conn, remotepath, localpath, chunk_size = 16000):
                     break
                 lf.write(buf)
 
-def download_dir(conn, remotepath, localpath, filter = None, chunk_size = 16000):
+
+def download_dir(conn, remotepath, localpath, filter=None, chunk_size=16000):
     if not os.path.isdir(localpath):
         os.makedirs(localpath)
     for fn in conn.modules.os.listdir(remotepath):
         if not filter or filter(fn):
             rfn = conn.modules.os.path.join(remotepath, fn)
             lfn = os.path.join(localpath, fn)
-            download(conn, rfn, lfn, filter = filter, ignore_invalid = True)
+            download(conn, rfn, lfn, filter=filter, ignore_invalid=True)
+
 
-def upload_package(conn, module, remotepath = None, chunk_size = 16000):
+def upload_package(conn, module, remotepath=None, chunk_size=16000):
     """
     uploads a module or a package to the remote party
 
@@ -255,10 +272,12 @@ def upload_package(conn, module, remotepath = None, chunk_size = 16000):
         site = conn.modules["distutils.sysconfig"].get_python_lib()
         remotepath = conn.modules.os.path.join(site, module.__name__)
     localpath = os.path.dirname(os.path.abspath(inspect.getsourcefile(module)))
-    upload(conn, localpath, remotepath, chunk_size = chunk_size)
+    upload(conn, localpath, remotepath, chunk_size=chunk_size)
+
 
 upload_module = upload_package
 
+
 def obtain(proxy):
     """obtains (copies) a remote object from a proxy object. the object is
     ``pickled`` on the remote side and ``unpickled`` locally, thus moved
@@ -272,6 +291,7 @@ def obtain(proxy):
     """
     return pickle.loads(pickle.dumps(proxy))
 
+
 def deliver(conn, localobj):
     """delivers (recreates) a local object on the other party. the object is
     ``pickled`` locally and ``unpickled`` on the remote side, thus moved
@@ -288,6 +308,7 @@ def deliver(conn, localobj):
     return conn.modules["rpyc.lib.compat"].pickle.loads(
         bytes(pickle.dumps(localobj)))
 
+
 @contextmanager
 def redirected_stdio(conn):
     r"""
@@ -313,16 +334,18 @@ def redirected_stdio(conn):
         conn.modules.sys.stdout = orig_stdout
         conn.modules.sys.stderr = orig_stderr
 
+
 def pm(conn):
     """same as ``pdb.pm()`` but on a remote exception
 
     :param conn: the RPyC connection
     """
-    #pdb.post_mortem(conn.root.getconn()._last_traceback)
+    # pdb.post_mortem(conn.root.getconn()._last_traceback)
     with redirected_stdio(conn):
         conn.modules.pdb.post_mortem(conn.root.getconn()._last_traceback)
 
-def interact(conn, namespace = None):
+
+def interact(conn, namespace=None):
     """remote interactive interpreter
 
     :param conn: the RPyC connection
@@ -337,13 +360,16 @@ def interact(conn, namespace = None):
             code.interact(local = dict(ns))""")
         conn.namespace["_rinteract"](namespace)
 
+
 class MockClassicConnection(object):
     """Mock classic RPyC connection object. Useful when you want the same code to run remotely or locally.
     """
+
     def __init__(self):
         self.root = Slave()
         ClassicService._install(self, self.root)
 
+
 def teleport_function(conn, func, globals=None, def_=True):
     """
     "Teleports" a function (including nested functions/closures) over the RPyC connection.
@@ -363,7 +389,7 @@ def teleport_function(conn, func, globals=None, def_=True):
     """
     if globals is None:
         globals = conn.namespace
-    from rpyc.utils.teleportation import export_function
+    from plainbox.vendor.rpyc.utils.teleportation import export_function
     exported = export_function(func)
     return conn.modules["rpyc.utils.teleportation"].import_function(
         exported, globals, def_)
diff --git a/plainbox/vendor/rpyc/utils/factory.py b/plainbox/vendor/rpyc/utils/factory.py
index 38cfdf0..23acc1f 100644
--- a/plainbox/vendor/rpyc/utils/factory.py
+++ b/plainbox/vendor/rpyc/utils/factory.py
@@ -29,9 +29,9 @@ class DiscoveryError(Exception):
     pass
 
 
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 # API
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 def connect_channel(channel, service=VoidService, config={}):
     """creates a connection over a given channel
 
@@ -43,6 +43,7 @@ def connect_channel(channel, service=VoidService, config={}):
     """
     return service._connect(channel, config)
 
+
 def connect_stream(stream, service=VoidService, config={}):
     """creates a connection over a given stream
 
@@ -54,6 +55,7 @@ def connect_stream(stream, service=VoidService, config={}):
     """
     return connect_channel(Channel(stream), service=service, config=config)
 
+
 def connect_pipes(input, output, service=VoidService, config={}):
     """
     creates a connection over the given input/output pipes
@@ -67,6 +69,7 @@ def connect_pipes(input, output, service=VoidService, config={}):
     """
     return connect_stream(PipeStream(input, output), service=service, config=config)
 
+
 def connect_stdpipes(service=VoidService, config={}):
     """
     creates a connection over the standard input/output pipes
@@ -78,6 +81,7 @@ def connect_stdpipes(service=VoidService, config={}):
     """
     return connect_stream(PipeStream.from_std(), service=service, config=config)
 
+
 def connect(host, port, service=VoidService, config={}, ipv6=False, keepalive=False):
     """
     creates a socket-connection to the given host and port
@@ -86,16 +90,18 @@ def connect(host, port, service=VoidService, config={}, ipv6=False, keepalive=Fa
     :param port: the TCP port to use
     :param service: the local service to expose (defaults to Void)
     :param config: configuration dict
-    :param ipv6: whether to use IPv6 or not
+    :param ipv6: whether to create an IPv6 socket (defaults to ``False``)
+    :param keepalive: whether to set TCP keepalive on the socket (defaults to ``False``)
 
     :returns: an RPyC connection
     """
     s = SocketStream.connect(host, port, ipv6=ipv6, keepalive=keepalive)
     return connect_stream(s, service, config)
 
+
 def unix_connect(path, service=VoidService, config={}):
     """
-    creates a socket-connection to the given host and port
+    creates a socket-connection to the given unix domain socket
 
     :param path: the path to the unix domain socket
     :param service: the local service to expose (defaults to Void)
@@ -106,6 +112,7 @@ def unix_connect(path, service=VoidService, config={}):
     s = SocketStream.unix_connect(path)
     return connect_stream(s, service, config)
 
+
 def ssl_connect(host, port, keyfile=None, certfile=None, ca_certs=None,
                 cert_reqs=None, ssl_version=None, ciphers=None,
                 service=VoidService, config={}, ipv6=False, keepalive=False):
@@ -117,7 +124,8 @@ def ssl_connect(host, port, keyfile=None, certfile=None, ca_certs=None,
     :param port: the TCP port to use
     :param service: the local service to expose (defaults to Void)
     :param config: configuration dict
-    :param ipv6: whether to create an IPv6 socket or an IPv4 one
+    :param ipv6: whether to create an IPv6 socket or an IPv4 one(defaults to ``False``)
+    :param keepalive: whether to set TCP keepalive on the socket (defaults to ``False``)
 
     The following arguments are passed directly to
     `ssl.wrap_socket <http://docs.python.org/dev/library/ssl.html#ssl.wrap_socket>`_:
@@ -133,7 +141,7 @@ def ssl_connect(host, port, keyfile=None, certfile=None, ca_certs=None,
 
     :returns: an RPyC connection
     """
-    ssl_kwargs = {"server_side" : False}
+    ssl_kwargs = {"server_side": False}
     if keyfile is not None:
         ssl_kwargs["keyfile"] = keyfile
     if certfile is not None:
@@ -152,6 +160,7 @@ def ssl_connect(host, port, keyfile=None, certfile=None, ca_certs=None,
     s = SocketStream.ssl_connect(host, port, ssl_kwargs, ipv6=ipv6, keepalive=keepalive)
     return connect_stream(s, service, config)
 
+
 def _get_free_port():
     """attempts to find a free port"""
     s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -159,8 +168,10 @@ def _get_free_port():
         s.bind(("localhost", 0))
         return s.getsockname()[1]
 
+
 _ssh_connect_lock = threading.Lock()
 
+
 def ssh_connect(remote_machine, remote_port, service=VoidService, config={}):
     """
     Connects to an RPyC server over an SSH tunnel (created by plumbum).
@@ -186,6 +197,7 @@ def ssh_connect(remote_machine, remote_port, service=VoidService, config={}):
         stream.tun = tun
     return service._connect(Channel(stream), config=config)
 
+
 def discover(service_name, host=None, registrar=None, timeout=2):
     """
     discovers hosts running the given service
@@ -212,6 +224,7 @@ def discover(service_name, host=None, registrar=None, timeout=2):
         raise DiscoveryError("no servers exposing %r were found on %r" % (service_name, host))
     return addrs
 
+
 def connect_by_service(service_name, host=None, service=VoidService, config={}):
     """create a connection to an arbitrary server that exposes the requested service
 
@@ -235,6 +248,7 @@ def connect_by_service(service_name, host=None, service=VoidService, config={}):
             pass
     raise DiscoveryError("All services are down: %s" % (addrs,))
 
+
 def connect_subproc(args, service=VoidService, config={}):
     """runs an rpyc server on a child process that and connects to it over
     the stdio pipes. uses the subprocess module.
@@ -246,17 +260,18 @@ def connect_subproc(args, service=VoidService, config={}):
     from subprocess import Popen, PIPE
     proc = Popen(args, stdin=PIPE, stdout=PIPE)
     conn = connect_pipes(proc.stdout, proc.stdin, service=service, config=config)
-    conn.proc = proc # just so you can have control over the processs
+    conn.proc = proc  # just so you can have control over the processs
     return conn
 
+
 def connect_thread(service=VoidService, config={}, remote_service=VoidService, remote_config={}):
     """starts an rpyc server on a new thread, bound to an arbitrary port,
     and connects to it over a socket.
 
     :param service: the local service to expose (defaults to Void)
     :param config: configuration dict
-    :param server_service: the remote service to expose (of the server; defaults to Void)
-    :param server_config: remote configuration dict (of the server)
+    :param remote_service: the remote service to expose (of the server; defaults to Void)
+    :param remote_config: remote configuration dict (of the server)
     """
     listener = socket.socket()
     listener.bind(("localhost", 0))
@@ -276,6 +291,7 @@ def connect_thread(service=VoidService, config={}, remote_service=VoidService, r
     host, port = listener.getsockname()
     return connect(host, port, service=service, config=config)
 
+
 def connect_multiprocess(service=VoidService, config={}, remote_service=VoidService, remote_config={}, args={}):
     """starts an rpyc server on a new process, bound to an arbitrary port,
     and connects to it over a socket. Basically a copy of connect_thread().
@@ -284,8 +300,8 @@ def connect_multiprocess(service=VoidService, config={}, remote_service=VoidServ
 
     :param service: the local service to expose (defaults to Void)
     :param config: configuration dict
-    :param server_service: the remote service to expose (of the server; defaults to Void)
-    :param server_config: remote configuration dict (of the server)
+    :param remote_service: the remote service to expose (of the server; defaults to Void)
+    :param remote_config: remote configuration dict (of the server)
     :param args: dict of local vars to pass to new connection, form {'name':var}
 
     Contributed by *@tvanzyl*
diff --git a/plainbox/vendor/rpyc/utils/helpers.py b/plainbox/vendor/rpyc/utils/helpers.py
index 221f171..521e226 100644
--- a/plainbox/vendor/rpyc/utils/helpers.py
+++ b/plainbox/vendor/rpyc/utils/helpers.py
@@ -9,7 +9,7 @@ from plainbox.vendor.rpyc.core.consts import HANDLE_BUFFITER, HANDLE_CALL
 from plainbox.vendor.rpyc.core.netref import syncreq, asyncreq
 
 
-def buffiter(obj, chunk = 10, max_chunk = 1000, factor = 2):
+def buffiter(obj, chunk=10, max_chunk=1000, factor=2):
     """Buffered iterator - reads the remote iterator in chunks starting with
     *chunk*, multiplying the chunk size by *factor* every time, as an
     exponential-backoff, up to a chunk of *max_chunk* size.
@@ -45,7 +45,8 @@ def buffiter(obj, chunk = 10, max_chunk = 1000, factor = 2):
         for elem in items:
             yield elem
 
-def restricted(obj, attrs, wattrs = None):
+
+def restricted(obj, attrs, wattrs=None):
     """Returns a 'restricted' version of an object, i.e., allowing access only to a subset of its
     attributes. This is useful when returning a "broad" or "dangerous" object, where you don't
     want the other party to have access to all of its attributes.
@@ -71,12 +72,14 @@ def restricted(obj, attrs, wattrs = None):
     """
     if wattrs is None:
         wattrs = attrs
+
     class Restricted(object):
         def _rpyc_getattr(self, name):
             if name not in attrs:
                 raise AttributeError(name)
             return getattr(obj, name)
         __getattr__ = _rpyc_getattr
+
         def _rpyc_setattr(self, name, value):
             if name not in wattrs:
                 raise AttributeError(name)
@@ -84,20 +87,27 @@ def restricted(obj, attrs, wattrs = None):
         __setattr__ = _rpyc_setattr
     return Restricted()
 
+
 class _Async(object):
     """Creates an async proxy wrapper over an existing proxy. Async proxies
     are cached. Invoking an async proxy will return an AsyncResult instead of
     blocking"""
 
     __slots__ = ("proxy", "__weakref__")
+
     def __init__(self, proxy):
         self.proxy = proxy
+
     def __call__(self, *args, **kwargs):
         return asyncreq(self.proxy, HANDLE_CALL, args, tuple(kwargs.items()))
+
     def __repr__(self):
         return "async_(%r)" % (self.proxy,)
 
+
 _async_proxies_cache = WeakValueDict()
+
+
 def async_(proxy):
     """
     Returns an asynchronous "version" of the given proxy. Invoking the returned
@@ -134,7 +144,7 @@ def async_(proxy):
     pid = id(proxy)
     if pid in _async_proxies_cache:
         return _async_proxies_cache[pid]
-    if not hasattr(proxy, "____conn__") or not hasattr(proxy, "____oid__"):
+    if not hasattr(proxy, "____conn__") or not hasattr(proxy, "____id_pack__"):
         raise TypeError("'proxy' must be a Netref: %r", (proxy,))
     if not callable(proxy):
         raise TypeError("'proxy' must be callable: %r" % (proxy,))
@@ -142,6 +152,7 @@ def async_(proxy):
     _async_proxies_cache[id(caller)] = _async_proxies_cache[pid] = caller
     return caller
 
+
 async_.__doc__ = _Async.__doc__
 globals()['async'] = async_         # backward compatibility alias
 
@@ -164,16 +175,20 @@ class timed(object):
     """
 
     __slots__ = ("__weakref__", "proxy", "timeout")
+
     def __init__(self, proxy, timeout):
         self.proxy = async_(proxy)
         self.timeout = timeout
+
     def __call__(self, *args, **kwargs):
         res = self.proxy(*args, **kwargs)
         res.set_expiry(self.timeout)
         return res
+
     def __repr__(self):
         return "timed(%r, %r)" % (self.proxy.proxy, self.timeout)
 
+
 class BgServingThread(object):
     """Runs an RPyC server in the background to serve all requests and replies
     that arrive on the given RPyC connection. The thread is started upon the
@@ -201,20 +216,23 @@ class BgServingThread(object):
         self._active = True
         self._callback = callback
         self._thread = spawn(self._bg_server)
+
     def __del__(self):
         if self._active:
             self.stop()
+
     def _bg_server(self):
         try:
             while self._active:
                 self._conn.serve(self.SERVE_INTERVAL)
-                time.sleep(self.SLEEP_INTERVAL) # to reduce contention
+                time.sleep(self.SLEEP_INTERVAL)  # to reduce contention
         except Exception:
             if self._active:
                 self._active = False
                 if self._callback is None:
                     raise
                 self._callback()
+
     def stop(self):
         """stop the server thread. once stopped, it cannot be resumed. you will
         have to create a new BgServingThread object later."""
@@ -227,8 +245,10 @@ class BgServingThread(object):
 def classpartial(*args, **kwargs):
     """Bind arguments to a class's __init__."""
     cls, args = args[0], args[1:]
+
     class Partial(cls):
         __doc__ = cls.__doc__
+
         def __new__(self):
             return cls(*args, **kwargs)
     Partial.__name__ = cls.__name__
diff --git a/plainbox/vendor/rpyc/utils/registry.py b/plainbox/vendor/rpyc/utils/registry.py
index 91b4eff..315d9f3 100644
--- a/plainbox/vendor/rpyc/utils/registry.py
+++ b/plainbox/vendor/rpyc/utils/registry.py
@@ -20,18 +20,18 @@ from plainbox.vendor.rpyc.core import brine
 
 
 DEFAULT_PRUNING_TIMEOUT = 4 * 60
-MAX_DGRAM_SIZE          = 1500
-REGISTRY_PORT           = 18811
+MAX_DGRAM_SIZE = 1500
+REGISTRY_PORT = 18811
 
 
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 # servers
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 
 class RegistryServer(object):
     """Base registry server"""
 
-    def __init__(self, listenersock, pruning_timeout = None, logger = None):
+    def __init__(self, listenersock, pruning_timeout=None, logger=None):
         self.sock = listenersock
         self.port = self.sock.getsockname()[1]
         self.active = False
@@ -85,7 +85,7 @@ class RegistryServer(object):
             return ()
 
         oldest = time.time() - self.pruning_timeout
-        all_servers = sorted(self.services[name].items(), key = lambda x: x[1])
+        all_servers = sorted(self.services[name].items(), key=lambda x: x[1])
         servers = []
         for addrinfo, t in all_servers:
             if t < oldest:
@@ -167,20 +167,21 @@ class RegistryServer(object):
         self.logger.debug("stopping server...")
         self.active = False
 
+
 class UDPRegistryServer(RegistryServer):
     """UDP-based registry server. The server listens to UDP broadcasts and
     answers them. Useful in local networks, were broadcasts are allowed"""
 
     TIMEOUT = 1.0
 
-    def __init__(self, host = "0.0.0.0", port = REGISTRY_PORT, pruning_timeout = None, logger = None):
+    def __init__(self, host="0.0.0.0", port=REGISTRY_PORT, pruning_timeout=None, logger=None):
         family, socktype, proto, _, sockaddr = socket.getaddrinfo(host, port, 0,
-            socket.SOCK_DGRAM)[0]
+                                                                  socket.SOCK_DGRAM)[0]
         sock = socket.socket(family, socktype, proto)
         sock.bind(sockaddr)
         sock.settimeout(self.TIMEOUT)
-        RegistryServer.__init__(self, sock, pruning_timeout = pruning_timeout,
-            logger = logger)
+        RegistryServer.__init__(self, sock, pruning_timeout=pruning_timeout,
+                                logger=logger)
 
     def _get_logger(self):
         return logging.getLogger("REGSRV/UDP/%d" % (self.port,))
@@ -194,6 +195,7 @@ class UDPRegistryServer(RegistryServer):
         except (socket.error, socket.timeout):
             pass
 
+
 class TCPRegistryServer(RegistryServer):
     """TCP-based registry server. The server listens to a certain TCP port and
     answers requests. Useful when you need to cross routers in the network, since
@@ -201,11 +203,11 @@ class TCPRegistryServer(RegistryServer):
 
     TIMEOUT = 3.0
 
-    def __init__(self, host = "0.0.0.0", port = REGISTRY_PORT, pruning_timeout = None,
-            logger = None, reuse_addr = True):
+    def __init__(self, host="0.0.0.0", port=REGISTRY_PORT, pruning_timeout=None,
+                 logger=None, reuse_addr=True):
 
         family, socktype, proto, _, sockaddr = socket.getaddrinfo(host, port, 0,
-            socket.SOCK_STREAM)[0]
+                                                                  socket.SOCK_STREAM)[0]
         sock = socket.socket(family, socktype, proto)
         if reuse_addr and sys.platform != "win32":
             # warning: reuseaddr is not what you expect on windows!
@@ -213,8 +215,8 @@ class TCPRegistryServer(RegistryServer):
         sock.bind(sockaddr)
         sock.listen(10)
         sock.settimeout(self.TIMEOUT)
-        RegistryServer.__init__(self, sock, pruning_timeout = pruning_timeout,
-            logger = logger)
+        RegistryServer.__init__(self, sock, pruning_timeout=pruning_timeout,
+                                logger=logger)
         self._connected_sockets = {}
 
     def _get_logger(self):
@@ -235,15 +237,17 @@ class TCPRegistryServer(RegistryServer):
             except (socket.error, socket.timeout):
                 pass
 
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 # clients (registrars)
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+
 class RegistryClient(object):
     """Base registry client. Also known as **registrar**"""
 
     REREGISTER_INTERVAL = 60
 
-    def __init__(self, ip, port, timeout, logger = None):
+    def __init__(self, ip, port, timeout, logger=None):
         self.ip = ip
         self.port = port
         self.timeout = timeout
@@ -280,6 +284,7 @@ class RegistryClient(object):
         """
         raise NotImplementedError()
 
+
 class UDPRegistryClient(RegistryClient):
     """UDP-based registry clients. By default, it sends UDP broadcasts (requires
     special user privileges on certain OS's) and collects the replies. You can
@@ -294,10 +299,10 @@ class UDPRegistryClient(RegistryClient):
        Consider using :func:`rpyc.utils.factory.discover` instead
     """
 
-    def __init__(self, ip = "255.255.255.255", port = REGISTRY_PORT, timeout = 2,
-            bcast = None, logger = None, ipv6 = False):
-        RegistryClient.__init__(self, ip = ip, port = port, timeout = timeout,
-            logger = logger)
+    def __init__(self, ip="255.255.255.255", port=REGISTRY_PORT, timeout=2,
+                 bcast=None, logger=None, ipv6=False):
+        RegistryClient.__init__(self, ip=ip, port=port, timeout=timeout,
+                                logger=logger)
 
         if ipv6:
             self.sock_family = socket.AF_INET6
@@ -329,7 +334,7 @@ class UDPRegistryClient(RegistryClient):
                 servers = brine.load(data)
         return servers
 
-    def register(self, aliases, port, interface = ""):
+    def register(self, aliases, port, interface=""):
         self.logger.info("registering on %s:%s", self.ip, self.port)
         sock = socket.socket(self.sock_family, socket.SOCK_DGRAM)
         with closing(sock):
@@ -384,9 +389,9 @@ class TCPRegistryClient(RegistryClient):
        Consider using :func:`rpyc.utils.factory.discover` instead
     """
 
-    def __init__(self, ip, port = REGISTRY_PORT, timeout = 2, logger = None):
-        RegistryClient.__init__(self, ip = ip, port = port, timeout = timeout,
-            logger = logger)
+    def __init__(self, ip, port=REGISTRY_PORT, timeout=2, logger=None):
+        RegistryClient.__init__(self, ip=ip, port=port, timeout=timeout,
+                                logger=logger)
 
     def _get_logger(self):
         return logging.getLogger('REGCLNT/TCP')
@@ -407,7 +412,7 @@ class TCPRegistryClient(RegistryClient):
                 servers = brine.load(data)
         return servers
 
-    def register(self, aliases, port, interface = ""):
+    def register(self, aliases, port, interface=""):
         self.logger.info("registering on %s:%s", self.ip, self.port)
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         with closing(sock):
diff --git a/plainbox/vendor/rpyc/utils/server.py b/plainbox/vendor/rpyc/utils/server.py
index f8e9c37..d50e118 100644
--- a/plainbox/vendor/rpyc/utils/server.py
+++ b/plainbox/vendor/rpyc/utils/server.py
@@ -5,7 +5,7 @@ import sys
 import os
 import socket
 import time
-import threading
+import threading  # noqa: F401
 import errno
 import logging
 from contextlib import closing
@@ -22,7 +22,6 @@ signal = safe_import("signal")
 gevent = safe_import("gevent")
 
 
-
 class Server(object):
     """Base server implementation
 
@@ -48,10 +47,10 @@ class Server(object):
                              on embedded platforms with limited battery)
     """
 
-    def __init__(self, service, hostname = "", ipv6 = False, port = 0,
-            backlog = 10, reuse_addr = True, authenticator = None, registrar = None,
-            auto_register = None, protocol_config = {}, logger = None, listener_timeout = 0.5,
-            socket_path = None):
+    def __init__(self, service, hostname="", ipv6=False, port=0,
+                 backlog=socket.SOMAXCONN, reuse_addr=True, authenticator=None, registrar=None,
+                 auto_register=None, protocol_config={}, logger=None, listener_timeout=0.5,
+                 socket_path=None):
         self.active = False
         self._closed = False
         self.service = service
@@ -65,7 +64,7 @@ class Server(object):
         self.clients = set()
 
         if socket_path is not None:
-            if hostname != "" or port != 0 or ipv6 != False:
+            if hostname != "" or port != 0 or ipv6 is not False:
                 raise ValueError("socket_path is mutually exclusive with: hostname, port, ipv6")
             self.listener = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
             self.listener.bind(socket_path)
@@ -99,7 +98,7 @@ class Server(object):
         if "logger" not in self.protocol_config:
             self.protocol_config["logger"] = self.logger
         if registrar is None:
-            registrar = UDPRegistryClient(logger = self.logger)
+            registrar = UDPRegistryClient(logger=self.logger)
         self.registrar = registrar
 
     def close(self):
@@ -187,7 +186,7 @@ class Server(object):
                 sock.shutdown(socket.SHUT_RDWR)
             except Exception:
                 pass
-            sock.close()
+            closing(sock)
             self.clients.discard(sock)
 
     def _serve_client(self, sock, credentials):
@@ -197,8 +196,8 @@ class Server(object):
         else:
             self.logger.info("welcome %s", addrinfo)
         try:
-            config = dict(self.protocol_config, credentials = credentials,
-                endpoints = (sock.getsockname(), addrinfo), logger = self.logger)
+            config = dict(self.protocol_config, credentials=credentials,
+                          endpoints=(sock.getsockname(), addrinfo), logger=self.logger)
             conn = self.service._connect(Channel(SocketStream(sock)), config)
             self._handle_connection(conn)
         finally:
@@ -211,7 +210,7 @@ class Server(object):
     def _bg_register(self):
         interval = self.registrar.REREGISTER_INTERVAL
         self.logger.info("started background auto-register thread "
-            "(interval = %s)", interval)
+                         "(interval = %s)", interval)
         tnext = 0
         try:
             while self.active:
@@ -220,7 +219,7 @@ class Server(object):
                     did_register = False
                     aliases = self.service.get_service_aliases()
                     try:
-                        did_register = self.registrar.register(aliases, self.port, interface = self.host)
+                        did_register = self.registrar.register(aliases, self.port, interface=self.host)
                     except Exception:
                         self.logger.exception("error registering services")
 
@@ -262,7 +261,7 @@ class Server(object):
             while self.active:
                 self.accept()
         except EOFError:
-            pass # server closed by another thread
+            pass  # server closed by another thread
         except KeyboardInterrupt:
             print("")
             self.logger.warn("keyboard interrupt!")
@@ -285,9 +284,13 @@ class OneShotServer(Server):
 
     Parameters: see :class:`Server`
     """
+
     def _accept_method(self, sock):
-        with closing(sock):
+        try:
             self._authenticate_and_serve_client(sock)
+        finally:
+            self.close()
+
 
 class ThreadedServer(Server):
     """
@@ -296,6 +299,7 @@ class ThreadedServer(Server):
 
     Parameters: see :class:`Server`
     """
+
     def _accept_method(self, sock):
         spawn(self._authenticate_and_serve_client, sock)
 
@@ -317,31 +321,27 @@ class ThreadPoolServer(Server):
     def __init__(self, *args, **kwargs):
         '''Initializes a ThreadPoolServer. In particular, instantiate the thread pool.'''
         # get the number of threads in the pool
-        nbthreads = 20
-        if 'nbThreads' in kwargs:
-            nbthreads = kwargs['nbThreads']
-            del kwargs['nbThreads']
-        # get the request batch size
-        self.request_batch_size = 10
-        if 'requestBatchSize' in kwargs:
-            self.request_batch_size = kwargs['requestBatchSize']
-            del kwargs['requestBatchSize']
+        self.nbthreads = kwargs.pop('nbThreads', 20)
+        self.request_batch_size = kwargs.pop('requestBatchSize', 10)
         # init the parent
         Server.__init__(self, *args, **kwargs)
         # a queue of connections having something to process
         self._active_connection_queue = Queue.Queue()
-        # declare the pool as already active
-        self.active = True
+        # a dictionary fd -> connection
+        self.fd_to_conn = {}
+        # a polling object to be used be the polling thread
+        self.poll_object = poll()
+
+    def _listen(self):
+        if self.active:
+            return
+        super(ThreadPoolServer, self)._listen()
         # setup the thread pool for handling requests
         self.workers = []
-        for i in range(nbthreads):
+        for i in range(self.nbthreads):
             t = spawn(self._serve_clients)
             t.setName('Worker%i' % i)
             self.workers.append(t)
-        # a polling object to be used be the polling thread
-        self.poll_object = poll()
-        # a dictionary fd -> connection
-        self.fd_to_conn = {}
         # setup a thread for polling inactive connections
         self.polling_thread = spawn(self._poll_inactive_clients)
         self.polling_thread.setName('PollingThread')
@@ -428,7 +428,7 @@ class ThreadPoolServer(Server):
         # serve a maximum of RequestBatchSize requests for this connection
         for _ in range(self.request_batch_size):
             try:
-                if not self.fd_to_conn[fd].poll(): # note that poll serves the request
+                if not self.fd_to_conn[fd].poll():  # note that poll serves the request
                     # we could not find a request, so we put this connection back to the inactive set
                     self._add_inactive_connection(fd)
                     return
@@ -472,40 +472,32 @@ class ThreadPoolServer(Server):
         changed if rpyc evolves'''
         # authenticate
         if self.authenticator:
-            h, p = sock.getpeername()
-            try:
-                sock, credentials = self.authenticator(sock)
-            except AuthenticationError:
-                self.logger.warning("%s:%s failed to authenticate, rejecting connection", h, p)
-                return None
+            sock, credentials = self.authenticator(sock)
         else:
             credentials = None
         # build a connection
         h, p = sock.getpeername()
-        config = dict(self.protocol_config, credentials=credentials, connid="%s:%d"%(h, p),
+        config = dict(self.protocol_config, credentials=credentials, connid="%s:%d" % (h, p),
                       endpoints=(sock.getsockname(), (h, p)))
-        return self.service._connect(Channel(SocketStream(sock)), config)
+        return sock, self.service._connect(Channel(SocketStream(sock)), config)
 
     def _accept_method(self, sock):
         '''Implementation of the accept method : only pushes the work to the internal queue.
         In case the queue is full, raises an AsynResultTimeout error'''
         try:
+            h, p = None, None
             # authenticate and build connection object
-            conn = self._authenticate_and_build_connection(sock)
+            sock, conn = self._authenticate_and_build_connection(sock)
             # put the connection in the active queue
-            if conn:
-                h, p = sock.getpeername()
-                fd = conn.fileno()
-                self.logger.debug("Created connection to %s:%d with fd %d", h, p, fd)
-                self.fd_to_conn[fd] = conn
-                self._add_inactive_connection(fd)
-                self.clients.clear()
-            else:
-                self.logger.warning("Failed to authenticate and build connection, closing %s:%d", h, p)
-                sock.close()
-        except Exception:
             h, p = sock.getpeername()
-            self.logger.exception("Failed to serve client for %s:%d, caught exception", h, p)
+            fd = conn.fileno()
+            self.logger.debug("Created connection to %s:%d with fd %d", h, p, fd)
+            self.fd_to_conn[fd] = conn
+            self._add_inactive_connection(fd)
+            self.clients.clear()
+        except Exception:
+            err_msg = "Failed to serve client for {}:{}, caught exception".format(h, p)
+            self.logger.exception(err_msg)
             sock.close()
 
 
@@ -547,12 +539,12 @@ class ForkingServer(Server):
             try:
                 self.logger.debug("child process created")
                 signal.signal(signal.SIGCHLD, self._prevhandler)
-                #76: call signal.siginterrupt(False) in forked child
+                # 76: call signal.siginterrupt(False) in forked child
                 signal.siginterrupt(signal.SIGCHLD, False)
                 self.listener.close()
                 self.clients.clear()
                 self._authenticate_and_serve_client(sock)
-            except:
+            except Exception:
                 self.logger.exception("child process terminated abnormally")
             else:
                 self.logger.debug("child process terminated")
@@ -562,6 +554,7 @@ class ForkingServer(Server):
         else:
             # parent
             sock.close()
+            self.clients.discard(sock)
 
 
 class GeventServer(Server):
diff --git a/plainbox/vendor/rpyc/utils/teleportation.py b/plainbox/vendor/rpyc/utils/teleportation.py
index 36aafe4..451c93d 100644
--- a/plainbox/vendor/rpyc/utils/teleportation.py
+++ b/plainbox/vendor/rpyc/utils/teleportation.py
@@ -3,8 +3,8 @@ import sys
 try:
     import __builtin__
 except ImportError:
-    import builtins as __builtin__
-from plainbox.vendor.rpyc.lib.compat import is_py3k
+    import builtins as __builtin__  # noqa: F401
+from plainbox.vendor.rpyc.lib.compat import is_py_3k, is_py_gte38
 from types import CodeType, FunctionType
 from plainbox.vendor.rpyc.core import brine
 from plainbox.vendor.rpyc.core import netref
@@ -14,7 +14,7 @@ CODEOBJ_MAGIC = "MAg1c J0hNNzo0hn ZqhuBP17LQk8"
 
 # NOTE: dislike this kind of hacking on the level of implementation details,
 # should search for a more reliable/future-proof way:
-CODE_HAVEARG_SIZE = 2 if sys.version_info >= (3,6) else 3
+CODE_HAVEARG_SIZE = 2 if sys.version_info >= (3, 6) else 3
 try:
     from dis import _unpack_opargs
 except ImportError:
@@ -26,20 +26,20 @@ except ImportError:
         while i < n:
             op = code[i]
             offset = i
-            i = i+1
+            i = i + 1
             arg = None
             if op >= opcode.HAVE_ARGUMENT:
-                arg = code[i] + code[i+1]*256 + extended_arg
+                arg = code[i] + code[i + 1] * 256 + extended_arg
                 extended_arg = 0
-                i = i+2
+                i = i + 2
                 if op == opcode.EXTENDED_ARG:
-                    extended_arg = arg*65536
+                    extended_arg = arg * 65536
             yield (offset, op, arg)
 
 
 def decode_codeobj(codeobj):
     # adapted from dis.dis
-    if is_py3k:
+    if is_py_3k:
         codestr = codeobj.co_code
     else:
         codestr = [ord(ch) for ch in codeobj.co_code]
@@ -64,6 +64,7 @@ def decode_codeobj(codeobj):
 
         yield (opname, argval)
 
+
 def _export_codeobj(cobj):
     consts2 = []
     for const in cobj.co_consts:
@@ -74,20 +75,27 @@ def _export_codeobj(cobj):
         else:
             raise TypeError("Cannot export a function with non-brinable constants: %r" % (const,))
 
-    if is_py3k:
+    if is_py_gte38:
+        # Constructor was changed in 3.8 to support "advanced" programming styles
+        exported = (cobj.co_argcount, cobj.co_posonlyargcount, cobj.co_kwonlyargcount, cobj.co_nlocals,
+                    cobj.co_stacksize, cobj.co_flags, cobj.co_code, tuple(consts2), cobj.co_names, cobj.co_varnames,
+                    cobj.co_filename, cobj.co_name, cobj.co_firstlineno, cobj.co_lnotab, cobj.co_freevars,
+                    cobj.co_cellvars)
+    elif is_py_3k:
         exported = (cobj.co_argcount, cobj.co_kwonlyargcount, cobj.co_nlocals, cobj.co_stacksize, cobj.co_flags,
-            cobj.co_code, tuple(consts2), cobj.co_names, cobj.co_varnames, cobj.co_filename,
-            cobj.co_name, cobj.co_firstlineno, cobj.co_lnotab, cobj.co_freevars, cobj.co_cellvars)
+                    cobj.co_code, tuple(consts2), cobj.co_names, cobj.co_varnames, cobj.co_filename,
+                    cobj.co_name, cobj.co_firstlineno, cobj.co_lnotab, cobj.co_freevars, cobj.co_cellvars)
     else:
         exported = (cobj.co_argcount, cobj.co_nlocals, cobj.co_stacksize, cobj.co_flags,
-            cobj.co_code, tuple(consts2), cobj.co_names, cobj.co_varnames, cobj.co_filename,
-            cobj.co_name, cobj.co_firstlineno, cobj.co_lnotab, cobj.co_freevars, cobj.co_cellvars)
+                    cobj.co_code, tuple(consts2), cobj.co_names, cobj.co_varnames, cobj.co_filename,
+                    cobj.co_name, cobj.co_firstlineno, cobj.co_lnotab, cobj.co_freevars, cobj.co_cellvars)
 
     assert brine.dumpable(exported)
     return (CODEOBJ_MAGIC, exported)
 
+
 def export_function(func):
-    if is_py3k:
+    if is_py_3k:
         func_closure = func.__closure__
         func_code = func.__code__
         func_defaults = func.__defaults__
@@ -103,13 +111,20 @@ def export_function(func):
 
     return func.__name__, func.__module__, func_defaults, _export_codeobj(func_code)[1]
 
+
 def _import_codetup(codetup):
-    if is_py3k:
-        (argcnt, kwargcnt, nloc, stk, flg, codestr, consts, names, varnames, filename, name,
-            firstlineno, lnotab, freevars, cellvars) = codetup
+    if is_py_3k:
+        # Handle tuples sent from 3.8 as well as 3 < version < 3.8.
+        if len(codetup) == 16:
+            (argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize, flags, code, consts, names, varnames,
+             filename, name, firstlineno, lnotab, freevars, cellvars) = codetup
+        else:
+            (argcount, kwonlyargcount, nlocals, stacksize, flags, code, consts, names, varnames,
+             filename, name, firstlineno, lnotab, freevars, cellvars) = codetup
+            posonlyargcount = 0
     else:
-        (argcnt, nloc, stk, flg, codestr, consts, names, varnames, filename, name,
-            firstlineno, lnotab, freevars, cellvars) = codetup
+        (argcount, nlocals, stacksize, flags, code, consts, names, varnames,
+         filename, name, firstlineno, lnotab, freevars, cellvars) = codetup
 
     consts2 = []
     for const in consts:
@@ -117,13 +132,18 @@ def _import_codetup(codetup):
             consts2.append(_import_codetup(const[1]))
         else:
             consts2.append(const)
-
-    if is_py3k:
-        return CodeType(argcnt, kwargcnt, nloc, stk, flg, codestr, tuple(consts2), names, varnames, filename, name,
-            firstlineno, lnotab, freevars, cellvars)
+    consts = tuple(consts2)
+    if is_py_gte38:
+        codetup = (argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize, flags, code, consts, names, varnames,
+                   filename, name, firstlineno, lnotab, freevars, cellvars)
+    elif is_py_3k:
+        codetup = (argcount, kwonlyargcount, nlocals, stacksize, flags, code, consts, names, varnames, filename, name,
+                   firstlineno, lnotab, freevars, cellvars)
     else:
-        return CodeType(argcnt, nloc, stk, flg, codestr, tuple(consts2), names, varnames, filename, name,
-            firstlineno, lnotab, freevars, cellvars)
+        codetup = (argcount, nlocals, stacksize, flags, code, consts, names, varnames, filename, name, firstlineno,
+                   lnotab, freevars, cellvars)
+    return CodeType(*codetup)
+
 
 def import_function(functup, globals=None, def_=True):
     name, modname, defaults, codetup = functup
@@ -135,7 +155,7 @@ def import_function(functup, globals=None, def_=True):
         globals = mod.__dict__
     # function globals must be real dicts, sadly:
     if isinstance(globals, netref.BaseNetref):
-        from rpyc.utils.classic import obtain
+        from plainbox.vendor.rpyc.utils.classic import obtain
         globals = obtain(globals)
     globals.setdefault('__builtins__', __builtins__)
     codeobj = _import_codetup(codetup)
diff --git a/plainbox/vendor/rpyc/utils/zerodeploy.py b/plainbox/vendor/rpyc/utils/zerodeploy.py
index bbe48bc..bbc4922 100644
--- a/plainbox/vendor/rpyc/utils/zerodeploy.py
+++ b/plainbox/vendor/rpyc/utils/zerodeploy.py
@@ -5,7 +5,7 @@ Requires [plumbum](http://plumbum.readthedocs.org/)
 """
 from __future__ import with_statement
 import sys
-import socket
+import socket  # noqa: F401
 from plainbox.vendor.rpyc.lib.compat import BYTES_LITERAL
 from plainbox.vendor.rpyc.core.service import VoidService
 from plainbox.vendor.rpyc.core.stream import SocketStream
@@ -13,6 +13,7 @@ import rpyc.utils.factory
 import rpyc.utils.classic
 try:
     from plumbum import local, ProcessExecutionError, CommandNotFound
+    from plumbum.commands.base import BoundCommand
     from plumbum.path import copy
 except ImportError:
     import inspect
@@ -64,6 +65,7 @@ finally:
     thd.join(2)
 """
 
+
 class DeployedServer(object):
     """
     Sets up a temporary, short-lived RPyC deployment on the given remote machine. It will:
@@ -85,7 +87,8 @@ class DeployedServer(object):
     :param extra_setup: any extra code to add to the script
     """
 
-    def __init__(self, remote_machine, server_class = "rpyc.utils.server.ThreadedServer", extra_setup = "", python_executable=None):
+    def __init__(self, remote_machine, server_class="rpyc.utils.server.ThreadedServer",
+                 extra_setup="", python_executable=None):
         self.proc = None
         self.tun = None
         self.remote_machine = remote_machine
@@ -98,8 +101,11 @@ class DeployedServer(object):
 
         script = (tmp / "deployed-rpyc.py")
         modname, clsname = server_class.rsplit(".", 1)
-        script.write(SERVER_SCRIPT.replace("$MODULE$", modname).replace("$SERVER$", clsname).replace("$EXTRA_SETUP$", extra_setup))
-        if python_executable:
+        script.write(SERVER_SCRIPT.replace("$MODULE$", modname).replace(
+            "$SERVER$", clsname).replace("$EXTRA_SETUP$", extra_setup))
+        if isinstance(python_executable, BoundCommand):
+            cmd = python_executable
+        elif python_executable:
             cmd = remote_machine[python_executable]
         else:
             major = sys.version_info[0]
@@ -115,7 +121,7 @@ class DeployedServer(object):
             if not cmd:
                 cmd = remote_machine.python
 
-        self.proc = cmd.popen(script, new_session = True)
+        self.proc = cmd.popen(script, new_session=True)
 
         line = ""