Pyro5 5.15__tar.gz → 5.17__tar.gz

{Pyro5-5.15 → pyro5-5.17}/PKG-INFO

@@ -1,16 +1,14 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: Pyro5
-Version: 5.15
+Version: 5.17
 Summary: Remote object communication library, fifth major version
 Home-page: https://github.com/irmen/Pyro5
 Author: Irmen de Jong
 Author-email: irmen@razorvine.net
 License: MIT
 Keywords: distributed objects,RPC,remote method call,IPC
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Natural Language :: Dutch
 Classifier: Operating System :: OS Independent
@@ -22,6 +20,8 @@ Classifier: Topic :: System :: Networking
 Requires-Python: >=3.7
 Description-Content-Type: text/x-rst
 License-File: LICENSE
+Requires-Dist: serpent>=1.41
+Dynamic: license-file
 
 Pyro5
 =====
@@ -34,6 +34,8 @@ Pyro5
 .. image:: https://anaconda.org/conda-forge/pyro5/badges/version.svg
     :target: https://anaconda.org/conda-forge/pyro5
 
+**Project status: super low maintenance mode. Not really worked on anymore, only reported bugs will be looked at.**
+
 
 Info
 ----
@@ -60,7 +62,7 @@ New code should use Pyro5 if at all possible.
 Features
 --------
 
-- written in 100% Python so extremely portable, supported on Python 3.8 and newer, and Pypy3
+- written in 100% Python so extremely portable, supported on CPython 3 and Pypy 3
 - works between different system architectures and operating systems.
 - able to communicate between different Python versions transparently.
 - defaults to a safe serializer (`serpent <https://pypi.python.org/pypi/serpent>`_) that supports many Python data types.
@@ -79,6 +81,10 @@ Features
 - you can define timeouts on network communications to prevent a call blocking forever if there's something wrong.
 - remote exceptions will be raised in the caller, as if they were local. You can extract detailed remote traceback information.
 - http gateway available for clients wanting to use http+json (such as browser scripts).
+- custom handshake data can be exchanged during connection setup.
+- message annotations support attaching custom metadata to every call.
+- correlation ids on every call for end-to-end request tracing.
+- SerializedBlob for efficient transfer of large serialized data blobs.
 - stable network communication code that has worked reliably on many platforms for over a decade.
 - can hook onto existing sockets created for instance with socketpair() to communicate efficiently between threads or sub-processes.
 - possibility to integrate Pyro's event loop into your own (or third party) event loop.
@@ -87,5 +93,3 @@ Features
 - large amount of unit tests and high test coverage.
 - reliable and established: built upon more than 20 years of existing Pyro history, with ongoing support and development.
 
-
-

{Pyro5-5.15 → pyro5-5.17}/Pyro5/__init__.py

@@ -4,7 +4,7 @@ Pyro package. Some generic init stuff to set up logging etc.
 Pyro - Python Remote Objects.  Copyright by Irmen de Jong (irmen@razorvine.net).
 """
 
-__version__ = "5.15"
+__version__ = "5.17"
 __author__ = "Irmen de Jong"
 
 

{Pyro5-5.15 → pyro5-5.17}/Pyro5/client.py

@@ -88,7 +88,7 @@ class Proxy(object):
     def __del__(self):
         if hasattr(self, "_pyroConnection"):
             try:
-                self._pyroRelease()
+                self._pyroConnection.close()
             except Exception:
                 pass
 
@@ -272,7 +272,10 @@ class Proxy(object):
                         raise errors.ProtocolError("result of call is an iterator, but the server is not configured to allow streaming")
                     return _StreamResultIterator(streamId, self)
                 if msg.flags & protocol.FLAGS_EXCEPTION:
-                    raise data  # if you see this in your traceback, you should probably inspect the remote traceback as well
+                    try:
+                        raise data  # if you see this in your traceback, you should probably inspect the remote traceback as well
+                    finally:
+                        del data
                 else:
                     return data
         except (errors.CommunicationError, KeyboardInterrupt):
@@ -296,7 +299,8 @@ class Proxy(object):
         Connects this proxy to the remote Pyro daemon. Does connection handshake.
         Returns true if a new connection was made, false if an existing one was already present.
         """
-        def connect_and_handshake(conn):
+        def connect_and_handshake():
+            conn = None
             try:
                 if self._pyroConnection is not None:
                     return False  # already connected
@@ -312,7 +316,11 @@ class Proxy(object):
                                                 timeout=self.__pyroTimeout,
                                                 nodelay=config.SOCK_NODELAY,
                                                 sslContext=sslContext)
-                conn = socketutil.SocketConnection(sock, uri.object)
+                try:
+                    conn = socketutil.SocketConnection(sock, uri.object)
+                except Exception:
+                    sock.close()
+                    raise
                 # Do handshake.
                 serializer = serializers.serializers[self._pyroSerializer or config.SERIALIZER]
                 data = {"handshake": self._pyroHandshake, "object": uri.object}
@@ -366,14 +374,13 @@ class Proxy(object):
             return False  # already connected
         uri = core.resolve(self._pyroUri)
         # socket connection (normal or Unix domain socket)
-        conn = None
         log.debug("connecting to %s", uri)
         connect_location = uri.sockname or (uri.host, uri.port)
         if connected_socket:
             self._pyroConnection = socketutil.SocketConnection(connected_socket, uri.object, True)
             self._pyroLocalSocket = connected_socket.getsockname()
         else:
-            connect_and_handshake(conn)
+            connect_and_handshake()
         # obtain metadata if this feature is enabled, and the metadata is not known yet
         if not self._pyroMethods and not self._pyroAttrs:
             self._pyroGetMetadata(uri.object)
@@ -413,7 +420,7 @@ class Proxy(object):
             log.debug("from meta: methods=%s, oneway methods=%s, attributes=%s",
                       sorted(self._pyroMethods), sorted(self._pyroOneway), sorted(self._pyroAttrs))
         if not self._pyroMethods and not self._pyroAttrs:
-            raise errors.PyroError("remote object doesn't expose any methods or attributes. Did you forget setting @expose on them?")
+            raise errors.PyroError("remote object '%s' doesn't expose any methods or attributes. Did you forget setting @expose on them?" % self._pyroUri)
 
     def _pyroReconnect(self, tries=100000000):
         """

{Pyro5-5.15 → pyro5-5.17}/Pyro5/configure.py

@@ -93,6 +93,8 @@ class Configuration:
                         envvalue = True
                     else:
                         raise ValueError("invalid boolean value: %s%s=%s" % (prefix, item, envvalue))
+                elif valuetype is type(None):
+                    envvalue = str(envvalue)
                 else:
                     try:
                         envvalue = valuetype(envvalue)

{Pyro5-5.15 → pyro5-5.17}/Pyro5/core.py

@@ -10,6 +10,7 @@ import contextlib
 import ipaddress
 import socket
 import random
+import platform
 import serpent
 from typing import Union, Optional
 from . import config, errors, socketutil, serializers
@@ -152,7 +153,13 @@ class _ExceptionWrapper(object):
         self.exception = exception
 
     def raiseIt(self):
-        raise self.exception
+        try:
+            err = self.exception.__class__(*self.exception.args)
+            if hasattr(self.exception, '_pyroTraceback'):
+                err._pyroTraceback = self.exception._pyroTraceback
+            raise err
+        finally:
+            del err
 
     def __serialized_dict__(self):
         """serialized form as a dictionary"""
@@ -215,11 +222,15 @@ def locate_ns(host: Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address] = "
             else:
                 # Some systems have 127.0.1.1 in the hosts file assigned to the hostname,
                 # so try this too (only if it's actually used as a valid ip address)
-                try:
-                    socket.gethostbyaddr("127.0.1.1")
-                    hosts = [config.NS_HOST] if config.NS_HOST == "127.0.1.1" else [config.NS_HOST, "127.0.1.1"]
-                except socket.error:
+                # Skip this check on Windows to avoid slow DNS lookup timeout (5+ seconds)
+                if platform.system() == "Windows":
                     hosts = [config.NS_HOST]
+                else:
+                    try:
+                        socket.gethostbyaddr("127.0.1.1")
+                        hosts = [config.NS_HOST] if config.NS_HOST == "127.0.1.1" else [config.NS_HOST, "127.0.1.1"]
+                    except socket.error:
+                        hosts = [config.NS_HOST]
             for host in hosts:
                 uristring = "PYRO:%s@%s:%d" % (NAMESERVER_NAME, host, port or config.NS_PORT)
                 log.debug("locating the NS: %s", uristring)
@@ -236,27 +247,28 @@ def locate_ns(host: Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address] = "
                 port = config.NS_BCPORT
             log.debug("broadcast locate")
             sock = socketutil.create_bc_socket(reuseaddr=config.SOCK_REUSE, timeout=0.7)
-            for _ in range(3):
-                try:
-                    for bcaddr in config.BROADCAST_ADDRS:
-                        try:
-                            sock.sendto(b"GET_NSURI", 0, (bcaddr, port))
-                        except socket.error as x:
-                            err = getattr(x, "errno", x.args[0])
-                            # handle some errno's that some platforms like to throw:
-                            if err not in socketutil.ERRNO_EADDRNOTAVAIL and err not in socketutil.ERRNO_EADDRINUSE:
-                                raise
-                    data, _ = sock.recvfrom(100)
-                    sock.close()
-                    text = data.decode("iso-8859-1")
-                    log.debug("located NS: %s", text)
-                    proxy = client.Proxy(text)
-                    return proxy
-                except socket.timeout:
-                    continue
-            with contextlib.suppress(OSError, socket.error):
-                sock.shutdown(socket.SHUT_RDWR)
-            sock.close()
+            try:
+                for _ in range(3):
+                    try:
+                        for bcaddr in config.BROADCAST_ADDRS:
+                            try:
+                                sock.sendto(b"GET_NSURI", 0, (bcaddr, port))
+                            except socket.error as x:
+                                err = getattr(x, "errno", x.args[0])
+                                # handle some errno's that some platforms like to throw:
+                                if err not in socketutil.ERRNO_EADDRNOTAVAIL and err not in socketutil.ERRNO_EADDRINUSE:
+                                    raise
+                        data, _ = sock.recvfrom(100)
+                        text = data.decode("iso-8859-1")
+                        log.debug("located NS: %s", text)
+                        proxy = client.Proxy(text)
+                        return proxy
+                    except socket.timeout:
+                        continue
+            finally:
+                with contextlib.suppress(OSError, socket.error):
+                    sock.shutdown(socket.SHUT_RDWR)
+                sock.close()
             log.debug("broadcast locate failed, try direct connection on NS_HOST")
         else:
             log.debug("skipping broadcast lookup")

{Pyro5-5.15 → pyro5-5.17}/Pyro5/errors.py

@@ -70,7 +70,7 @@ def get_pyro_traceback(ex_type=None, ex_value=None, ex_tb=None):
     you do not supply the objects yourself."""
 
     def formatRemoteTraceback(remote_tb_lines):
-        result = [" +--- This exception occured remotely (Pyro) - Remote traceback:"]
+        result = [" +--- This exception occurred remotely (Pyro) - Remote traceback:"]
         for line in remote_tb_lines:
             if line.endswith("\n"):
                 line = line[:-1]

{Pyro5-5.15 → pyro5-5.17}/Pyro5/nameserver.py

@@ -37,7 +37,7 @@ class MemoryStorage(dict):
 
     def __setitem__(self, key, value):
         uri, metadata = value
-        super(MemoryStorage, self).__setitem__(key, (uri, metadata or frozenset()))
+        super(MemoryStorage, self).__setitem__(key, (uri, metadata if metadata is not None else frozenset()))
 
     def optimized_prefix_list(self, prefix, return_metadata=False):
         return None
@@ -315,7 +315,7 @@ class NameServer(object):
         with self.lock:
             if safe and name in self.storage:
                 raise NamingError("name already registered: " + name)
-            self.storage[name] = uri, set(metadata) if metadata else None
+            self.storage[name] = uri, set(metadata) if metadata is not None else None
 
     def set_metadata(self, name, metadata):
         """update the metadata for an existing registration"""
@@ -327,28 +327,32 @@ class NameServer(object):
         with self.lock:
             try:
                 uri, old_meta = self.storage[name]
-                self.storage[name] = uri, set(metadata) if metadata else None
+                self.storage[name] = uri, set(metadata) if metadata is not None else None
             except KeyError:
                 raise NamingError("unknown name: " + name)
 
     def remove(self, name=None, prefix=None, regex=None):
         """Remove a registration. returns the number of items removed."""
-        if name and name in self.storage and name != core.NAMESERVER_NAME:
+        if name and name != core.NAMESERVER_NAME:
             with self.lock:
-                del self.storage[name]
-            return 1
+                if name in self.storage:
+                    del self.storage[name]
+                    return 1
+                return 0
         if prefix:
-            items = list(self.list(prefix=prefix).keys())
-            if core.NAMESERVER_NAME in items:
-                items.remove(core.NAMESERVER_NAME)
-            self.storage.remove_items(items)
-            return len(items)
+            with self.lock:
+                items = list(self.list(prefix=prefix).keys())
+                if core.NAMESERVER_NAME in items:
+                    items.remove(core.NAMESERVER_NAME)
+                self.storage.remove_items(items)
+                return len(items)
         if regex:
-            items = list(self.list(regex=regex).keys())
-            if core.NAMESERVER_NAME in items:
-                items.remove(core.NAMESERVER_NAME)
-            self.storage.remove_items(items)
-            return len(items)
+            with self.lock:
+                items = list(self.list(regex=regex).keys())
+                if core.NAMESERVER_NAME in items:
+                    items.remove(core.NAMESERVER_NAME)
+                self.storage.remove_items(items)
+                return len(items)
         return 0
 
     # noinspection PyNoneFunctionAssignment
@@ -645,7 +649,8 @@ class BroadcastServer(object):
 
 
 def start_ns_loop(host=None, port=None, enableBroadcast=True, bchost=None, bcport=None,
-                  unixsocket=None, nathost=None, natport=None, storage=None):
+                  unixsocket=None, nathost=None, natport=None, storage=None, 
+                  loopCondition=lambda: True):
     """utility function that starts a new Name server and enters its requestloop."""
     daemon = NameServerDaemon(host, port, unixsocket, nathost=nathost, natport=natport, storage=storage)
     nsUri = daemon.uriFor(daemon.nameserver)
@@ -681,7 +686,7 @@ def start_ns_loop(host=None, port=None, enableBroadcast=True, bchost=None, bcpor
         print("URI = %s" % nsUri)
     sys.stdout.flush()
     try:
-        daemon.requestLoop()
+        daemon.requestLoop(loopCondition=loopCondition)
     finally:
         daemon.close()
         if bcserver is not None:

{Pyro5-5.15 → pyro5-5.17}/Pyro5/protocol.py

@@ -75,12 +75,11 @@ class SendingMessage:
         self.seq = seq
         self.serializer_id = serializer_id
         annotations = annotations or {}
-        annotations_size = sum([8 + len(v) for v in annotations.values()])
+        annotations_size = sum(8 + len(v) for v in annotations.values())
         flags &= ~FLAGS_COMPRESSED
         if config.COMPRESSION and len(payload) > 100:
             payload = zlib.compress(payload, 4)
             flags |= FLAGS_COMPRESSED
-        self.flags = flags
         total_size = len(payload) + annotations_size
         if total_size > config.MAX_MESSAGE_SIZE:
             raise errors.ProtocolError("message too large ({:d}, max={:d})".format(total_size, config.MAX_MESSAGE_SIZE))
@@ -89,7 +88,8 @@ class SendingMessage:
             self.corr_id = current_context.correlation_id.bytes
         else:
             self.corr_id = _empty_correlation_id
-        header_data = struct.pack(_header_format, b"PYRO", PROTOCOL_VERSION, msgtype, serializer_id, flags, seq,
+        self.flags = flags
+        header_data = struct.pack(_header_format, b"PYRO", PROTOCOL_VERSION, msgtype, serializer_id, self.flags, seq,
                                   len(payload), annotations_size, self.corr_id, 0, _magic_number)
         annotation_data = []
         for k, v in annotations.items():
@@ -158,9 +158,12 @@ class ReceivingMessage:
             while i < self.annotations_size:
                 annotation_id = bytes(payload[i:i+4]).decode("ascii")
                 length = int.from_bytes(payload[i+4:i+8], "big")
+                if length < 0 or i + 8 + length > self.annotations_size:
+                    raise errors.ProtocolError("annotation chunk length exceeds remaining data")
                 self.annotations[annotation_id] = payload[i+8:i+8+length]     # note: it stores a memoryview!
                 i += 8 + length
-            assert i == self.annotations_size
+            if i != self.annotations_size:
+                raise errors.ProtocolError("annotation parsing did not consume all annotation data")
             self.data = payload[self.annotations_size:]
         else:
             self.data = payload
@@ -175,8 +178,8 @@ def log_wiredata(logger, text, msg):
     num_anns = len(msg.annotations) if hasattr(msg, "annotations") else 0
     corr_bytes = bytes(msg.corr_id) if hasattr(msg, "corr_id") else _empty_correlation_id
     corr_id = uuid.UUID(bytes=corr_bytes)
-    logger.debug("%s: msgtype=%d flags=0x%x ser=%d seq=%d num_annotations=%s corr_id=%s\ndata=%r" %
-                 (text, msg.type, msg.flags, msg.serializer_id, msg.seq, num_anns, corr_id, bytes(msg.data)))
+    logger.debug("%s: msgtype=%d flags=0x%x ser=%d seq=%d num_annotations=%s corr_id=%s\ndata=%r",
+                 text, msg.type, msg.flags, msg.serializer_id, msg.seq, num_anns, corr_id, bytes(msg.data))
 
 
 def recv_stub(connection, accepted_msgtypes=None):

{Pyro5-5.15 → pyro5-5.17}/Pyro5/serializers.py

@@ -231,7 +231,7 @@ class SerializerBase(object):
                 exceptiontype = getattr(sqlite3, short_classname)
                 if issubclass(exceptiontype, BaseException):
                     return SerializerBase.make_exception(exceptiontype, data)
-        log.warning("unsupported serialized class: " + classname)
+        log.warning("unsupported serialized class: %s", classname)
         raise errors.SerializeError("unsupported serialized class: " + classname)
 
     @staticmethod
@@ -422,7 +422,7 @@ class MsgpackSerializer(SerializerBase):
         return msgpack.packb(data, use_bin_type=True, default=self.default)
 
     def loadsCall(self, data):
-        return msgpack.unpackb(self._convertToBytes(data), raw=False, object_hook=self.object_hook)
+        return msgpack.unpackb(self._convertToBytes(data), raw=False, object_hook=self.object_hook, ext_hook=self.ext_hook)
 
     def loads(self, data):
         return msgpack.unpackb(self._convertToBytes(data), raw=False, object_hook=self.object_hook, ext_hook=self.ext_hook)

{Pyro5-5.15 → pyro5-5.17}/Pyro5/server.py

@@ -168,7 +168,7 @@ class DaemonObject(object):
             metadata = _get_exposed_members(obj)
             if not metadata["methods"] and not metadata["attrs"]:
                 # Something seems wrong: nothing is remotely exposed.
-                warnings.warn("Class %r doesn't expose any methods or attributes. Did you forget setting @expose on them?" % type(obj))
+                warnings.warn("Class %s doesn't expose any methods or attributes. Did you forget setting @expose on them?" % repr(obj))
             return metadata
         else:
             log.debug("unknown object requested: %s", objectId)
@@ -241,7 +241,7 @@ class Daemon(object):
         natport_for_loc = natport
         if natport == 0:
             # expose internal port number as NAT port as well. (don't use port because it could be 0 and will be chosen by the OS)
-            natport_for_loc = int(self.locationStr.split(":")[1])
+            natport_for_loc = int(self.locationStr.rsplit(":", 1)[1])
         # The NAT-location (str of the form ``nathost:natportnumber``) on which the Daemon is exposed for use with NAT-routing
         self.natLocationStr = "%s:%d" % (nathost, natport_for_loc) if nathost else None
         if self.natLocationStr:
@@ -250,10 +250,11 @@ class Daemon(object):
         pyroObject._pyroId = core.DAEMON_NAME
         # Dictionary from Pyro object id to the actual Pyro object registered by this id
         self.objectsById = {pyroObject._pyroId: pyroObject}
-        log.debug("pyro protocol version: %d" % protocol.PROTOCOL_VERSION)
+        log.debug("pyro protocol version: %d", protocol.PROTOCOL_VERSION)
         self._pyroInstances = {}   # pyro objects for instance_mode=single (singletons, just one per daemon)
         self.streaming_responses = {}   # stream_id -> (client, creation_timestamp, linger_timestamp, stream)
         self.housekeeper_lock = threading.Lock()
+        self._disconnect_lock = threading.Lock()
         self.create_single_instance_lock = threading.Lock()
         self.__mustshutdown.clear()
         self.methodcall_error_handler = _default_methodcall_error_handler
@@ -456,6 +457,16 @@ class Daemon(object):
                     if method == "__getattr__":
                         # special case for direct attribute access (only exposed @properties are accessible)
                         data = _get_exposed_property_value(obj, vargs[0])
+                        if not request_flags & protocol.FLAGS_ONEWAY:
+                            isStream, data = self._streamResponse(data, conn)
+                            if isStream:
+                                # throw an exception as well as setting message flags
+                                # this way, it is backwards compatible with older pyro versions.
+                                exc = errors.ProtocolError("result of call is an iterator")
+                                ann = {"STRM": data.encode()} if data else {}
+                                self._sendExceptionResponse(conn, request_seq, serializer.serializer_id, exc, None,
+                                                            annotations=ann, flags=protocol.FLAGS_ITEMSTREAMRESULT)
+                                return
                     elif method == "__setattr__":
                         # special case for direct attribute access (only exposed @properties are accessible)
                         data = _set_exposed_property_value(obj, vargs[0], vargs[1])
@@ -514,19 +525,20 @@ class Daemon(object):
                 raise  # re-raise if flagged as callback, communication or security error.
 
     def _clientDisconnect(self, conn):
-        if config.ITER_STREAM_LINGER > 0:
-            # client goes away, keep streams around for a bit longer (allow reconnect)
-            for streamId in list(self.streaming_responses):
-                info = self.streaming_responses.get(streamId, None)
-                if info and info[0] is conn:
-                    _, timestamp, _, stream = info
-                    self.streaming_responses[streamId] = (None, timestamp, time.time(), stream)
-        else:
-            # client goes away, close any streams it had open as well
-            for streamId in list(self.streaming_responses):
-                info = self.streaming_responses.get(streamId, None)
-                if info and info[0] is conn:
-                    del self.streaming_responses[streamId]
+        with self._disconnect_lock:
+            if config.ITER_STREAM_LINGER > 0:
+                # client goes away, keep streams around for a bit longer (allow reconnect)
+                for streamId in list(self.streaming_responses):
+                    info = self.streaming_responses.get(streamId, None)
+                    if info and info[0] is conn:
+                        _, timestamp, _, stream = info
+                        self.streaming_responses[streamId] = (None, timestamp, time.time(), stream)
+            else:
+                # client goes away, close any streams it had open as well
+                for streamId in list(self.streaming_responses):
+                    info = self.streaming_responses.get(streamId, None)
+                    if info and info[0] is conn:
+                        del self.streaming_responses[streamId]
         self.clientDisconnect(conn)  # user overridable hook
 
     def _housekeeping(self):
@@ -650,12 +662,14 @@ class Daemon(object):
                 obj_or_class._pyroInstancing = ("session", None)
         if not force:
             if hasattr(obj_or_class, "_pyroId") and obj_or_class._pyroId != "":  # check for empty string is needed for Cython
-                raise errors.DaemonError("object or class already has a Pyro id")
+                pyro_id = obj_or_class._pyroId
+                if pyro_id and self.objectsById.get(pyro_id) is obj_or_class:
+                    raise errors.DaemonError("object or class already has a Pyro id")
             if objectId in self.objectsById:
                 raise errors.DaemonError("an object or class is already registered with that id")
         # set some pyro attributes
         obj_or_class._pyroId = objectId
-        obj_or_class._pyroDaemon = self
+        obj_or_class._pyroDaemon = weakref.proxy(self)
         # register a custom serializer for the type to automatically return proxies
         # we need to do this for all known serializers
         for ser in serializers.serializers.values():
@@ -664,7 +678,7 @@ class Daemon(object):
             else:
                 ser.register_type_replacement(type(obj_or_class), _pyro_obj_to_auto_proxy)
         # register the object/class in the mapping
-        self.objectsById[obj_or_class._pyroId] = (obj_or_class if not weak else weakref.ref(obj_or_class))
+        self.objectsById[obj_or_class._pyroId] = obj_or_class if not weak else weakref.ref(obj_or_class)
         if weak: weakref.finalize(obj_or_class,self.unregister,objectId)
         return self.uriFor(objectId)
 
@@ -847,8 +861,8 @@ def _default_methodcall_error_handler(daemon: Daemon, client_sock: socketutil.So
                                       method: Callable, vargs: Sequence[Any], kwargs: Dict[str, Any],
                                       exception: Exception) -> None:
     """The default routine called to process a exception raised in the user code of a method call"""
-    log.debug("exception occurred in method call user code: client={} method={} exception={}"
-              .format(client_sock, method.__qualname__, repr(exception)))
+    log.debug("exception occurred in method call user code: client=%s method=%s exception=%r",
+              client_sock, method.__qualname__, exception)
 
 
 # register the special serializers for the pyro objects

{Pyro5-5.15 → pyro5-5.17}/Pyro5/socketutil.py

@@ -79,7 +79,10 @@ def get_ip_address(hostname: str, workaround127: bool = False, version: int = No
             raise ValueError("unknown value for argument ipVersion.")
         ip = socket.getaddrinfo(hostname or socket.gethostname(), 80, family, socket.SOCK_STREAM, socket.SOL_TCP)[0][4][0]
         if workaround127 and (ip.startswith("127.") or ip == "0.0.0.0"):
-            return get_interface("4.2.2.2").ip
+            try:
+                return get_interface("4.2.2.2").ip
+            except OSError:
+                pass  # network unreachable, fall through to return loopback address
         return ipaddress.ip_address(ip)
 
     try:
@@ -154,9 +157,12 @@ def receive_data(sock: socket.socket, size: int) -> bytes:
                     data.extend(chunk)
                     msglen += len(chunk)
                 if len(data) != size:
-                    err = ConnectionClosedError("receiving: not enough data")
-                    err.partialData = data  # store the message that was received until now
-                    raise err
+                    try:
+                        err = ConnectionClosedError("receiving: not enough data")
+                        err.partialData = data  # store the message that was received until now
+                        raise err
+                    finally:
+                        del err
                 return data  # yay, complete
             except socket.timeout:
                 raise TimeoutError("receiving: timeout")

{Pyro5-5.15 → pyro5-5.17}/Pyro5/svr_existingconn.py

@@ -24,7 +24,7 @@ class SocketServer_ExistingConnection(object):
             raise socket.error("SSL configured for Pyro but existing socket is not a SSL socket")
         self.daemon = daemon
         self.sock = connected_socket
-        log.info("starting server on user-supplied connected socket " + str(connected_socket))
+        log.info("starting server on user-supplied connected socket %s", connected_socket)
         sn = connected_socket.getsockname()
         if hasattr(socket, "AF_UNIX") and connected_socket.family == socket.AF_UNIX:
             self.locationStr = "./u:" + (sn or "<<not-bound>>")
@@ -86,7 +86,7 @@ class SocketServer_ExistingConnection(object):
             return False
         except errors.TimeoutError as x:
             # for timeout errors we're not really interested in detailed traceback info
-            log.warning("error during handleRequest: %s" % x)
+            log.warning("error during handleRequest: %s", x)
             return False
         except Exception:
             # other error occurred, close the connection, but also log a warning

{Pyro5-5.15 → pyro5-5.17}/Pyro5/svr_multiplex.py

@@ -87,7 +87,7 @@ class SocketServer_Multiplex(object):
                     try:
                         self.daemon._clientDisconnect(s)
                     except Exception as x:
-                        log.warning("Error in clientDisconnect: " + str(x))
+                        log.warning("Error in clientDisconnect: %s", x)
                     self.selector.unregister(s)
                     s.close()
         self.daemon._housekeeping()
@@ -174,7 +174,7 @@ class SocketServer_Multiplex(object):
             return False
         except errors.TimeoutError as x:
             # for timeout errors we're not really interested in detailed traceback info
-            log.warning("error during handleRequest: %s" % x)
+            log.warning("error during handleRequest: %s", x)
             return False
         except Exception:
             # other error occurred, close the connection, but also log a warning

{Pyro5-5.15 → pyro5-5.17}/Pyro5/svr_threads.py

@@ -17,7 +17,6 @@ import contextlib
 from . import config, socketutil, errors
 
 log = logging.getLogger("Pyro5.threadpoolserver")
-_client_disconnect_lock = threading.Lock()
 
 
 class ClientConnectionJob(object):
@@ -46,7 +45,7 @@ class ClientConnectionJob(object):
                         break
                     except errors.TimeoutError as x:
                         # for timeout errors we're not really interested in detailed traceback info
-                        log.warning("error during handleRequest: %s" % x)
+                        log.warning("error during handleRequest: %s", x)
                         break
                     except Exception:
                         # other errors log a warning, break this loop and close the client connection
@@ -56,11 +55,10 @@ class ClientConnectionJob(object):
                         log.warning(msg)
                         break
             finally:
-                with _client_disconnect_lock:
-                    try:
-                        self.daemon._clientDisconnect(self.csock)
-                    except Exception as x:
-                        log.warning("Error in clientDisconnect: " + str(x))
+                try:
+                    self.daemon._clientDisconnect(self.csock)
+                except Exception as x:
+                    log.warning("Error in clientDisconnect: %s", x)
                 self.csock.close()
 
     def handleConnection(self):
@@ -77,7 +75,7 @@ class ClientConnectionJob(object):
         return False
 
     def denyConnection(self, reason):
-        log.warning("client connection was denied: " + reason)
+        log.warning("client connection was denied: %s", reason)
         # return failed handshake
         self.daemon._handshake(self.csock, denied_reason=reason)
         self.csock.close()
@@ -308,11 +306,11 @@ class Pool(object):
     def close(self):
         if not self.closed:
             log.debug("closing down")
+            self.closed = True
             for w in list(self.busy):
                 w.process(None)
             for w in list(self.idle):
                 w.process(None)
-            self.closed = True
             time.sleep(0.1)
             idle, self.idle = self.idle, set()
             busy, self.busy = self.busy, set()