def handleRequest(self):
"""Handles a single connection request event and returns if the connection is still active"""
try:
self.daemon.handleRequest(self.conn)
return True
except (socket.error, errors.ConnectionClosedError,
errors.SecurityError) as x:
# client went away or caused a security error.
# close the connection silently.
ex_t, ex_v, ex_tb = sys.exc_info()
tb = util.formatTraceback(ex_t, ex_v, ex_tb)
try:
peername = self.conn.sock.getpeername()
log.debug("disconnected %s", peername)
except socket.error:
log.debug("disconnected a client")
self.shutdown()
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)
return False
except:
# other error occurred, close the connection, but also log a warning
ex_t, ex_v, ex_tb = sys.exc_info()
tb = util.formatTraceback(ex_t, ex_v, ex_tb)
msg = "error during handleRequest: %s; %s" % (ex_v, "".join(tb))
log.warning(msg)
return False
def _handleConnection(self, sock):
try:
if sock is None:
return
csock, caddr = sock.accept()
if Pyro4.config.COMMTIMEOUT:
csock.settimeout(Pyro4.config.COMMTIMEOUT)
except socket.error:
x=sys.exc_info()[1]
err=getattr(x, "errno", x.args[0])
if err in socketutil.ERRNO_RETRIES:
# just ignore this error for now and continue
log.warning("accept() failed errno=%d, shouldn't happen", err)
return None
if err in socketutil.ERRNO_BADF or err in socketutil.ERRNO_ENOTSOCK:
# our server socket got destroyed
raise errors.ConnectionClosedError("server socket closed")
raise
try:
conn=socketutil.SocketConnection(csock)
if self.daemon._handshake(conn):
return conn
except: # catch all errors, otherwise the event loop could terminate
ex_t, ex_v, ex_tb = sys.exc_info()
tb = util.formatTraceback(ex_t, ex_v, ex_tb)
log.warning("error during connect/handshake: %s; %s", ex_v, "\n".join(tb))
try:
csock.shutdown(socket.SHUT_RDWR)
except (OSError, socket.error):
pass
csock.close()
return None
def _handleConnection(self, sock):
try:
if sock is None:
return
csock, caddr = sock.accept()
if Pyro4.config.COMMTIMEOUT:
csock.settimeout(Pyro4.config.COMMTIMEOUT)
except socket.error:
x = sys.exc_info()[1]
err = getattr(x, "errno", x.args[0])
if err in socketutil.ERRNO_RETRIES:
# just ignore this error for now and continue
log.warning("accept() failed errno=%d, shouldn't happen", err)
return None
if err in socketutil.ERRNO_BADF or err in socketutil.ERRNO_ENOTSOCK:
# our server socket got destroyed
raise errors.ConnectionClosedError("server socket closed")
raise
try:
conn = socketutil.SocketConnection(csock)
if self.daemon._handshake(conn):
return conn
except: # catch all errors, otherwise the event loop could terminate
ex_t, ex_v, ex_tb = sys.exc_info()
tb = util.formatTraceback(ex_t, ex_v, ex_tb)
log.warning("error during connect/handshake: %s; %s", ex_v,
"\n".join(tb))
try:
csock.shutdown(socket.SHUT_RDWR)
except (OSError, socket.error):
pass
csock.close()
return None
def __call__(self):
if self.handleConnection():
try:
while True:
try:
self.daemon.handleRequest(self.csock)
except (socket.error, errors.ConnectionClosedError):
# client went away.
log.debug("disconnected %s", self.caddr)
break
except errors.SecurityError:
log.debug("security error on client %s", self.caddr)
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)
break
except:
# other errors log a warning, break this loop and close the client connection
ex_t, ex_v, ex_tb = sys.exc_info()
tb = util.formatTraceback(ex_t, ex_v, ex_tb)
msg = "error during handleRequest: %s; %s" % (
ex_v, "".join(tb))
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))
self.csock.close()
def handleRequest(self):
"""Handles a single connection request event and returns if the connection is still active"""
try:
self.daemon.handleRequest(self.conn)
return True
except (socket.error, errors.ConnectionClosedError, errors.SecurityError) as x:
# client went away or caused a security error.
# close the connection silently.
try:
peername = self.conn.sock.getpeername()
log.debug("disconnected %s", peername)
except socket.error:
log.debug("disconnected a client")
self.shutdown()
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)
return False
except:
# other error occurred, close the connection, but also log a warning
ex_t, ex_v, ex_tb = sys.exc_info()
tb = util.formatTraceback(ex_t, ex_v, ex_tb)
msg = "error during handleRequest: %s; %s" % (ex_v, "".join(tb))
log.warning(msg)
return False
def _handleConnection(self, sock):
try:
if sock is None:
return
csock, caddr = sock.accept()
if hasattr(csock, "getpeercert"):
log.debug("connected %s - SSL", caddr)
else:
log.debug("connected %s - unencrypted", caddr)
if config.COMMTIMEOUT:
csock.settimeout(config.COMMTIMEOUT)
except (socket.error, OSError) as x:
err = getattr(x, "errno", x.args[0])
if err in socketutil.ERRNO_BADF or err in socketutil.ERRNO_ENOTSOCK:
# our server socket got destroyed
raise errors.ConnectionClosedError("server socket closed")
# socket errors may not lead to a server abort, so we log it and continue
err = getattr(x, "errno", x.args[0])
log.warning("accept() failed '%s' with errno=%d, shouldn't happen", x, err)
return None
try:
conn = socketutil.SocketConnection(csock)
if self.daemon._handshake(conn):
return conn
conn.close()
except: # catch all errors, otherwise the event loop could terminate
ex_t, ex_v, ex_tb = sys.exc_info()
tb = util.formatTraceback(ex_t, ex_v, ex_tb)
log.warning("error during connect/handshake: %s; %s", ex_v, "\n".join(tb))
try:
csock.shutdown(socket.SHUT_RDWR)
except (OSError, socket.error):
pass
csock.close()
return None
def __call__(self):
if self.handleConnection():
try:
while True:
try:
self.daemon.handleRequest(self.csock)
except (socket.error, errors.ConnectionClosedError):
# client went away.
log.debug("disconnected %s", self.caddr)
break
except errors.SecurityError:
log.debug("security error on client %s", self.caddr)
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)
break
except:
# other errors log a warning, break this loop and close the client connection
ex_t, ex_v, ex_tb = sys.exc_info()
tb = util.formatTraceback(ex_t, ex_v, ex_tb)
msg = "error during handleRequest: %s; %s" % (ex_v, "".join(tb))
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))
self.csock.close()
def _pyro_run_call(obj, method, vargs, kwargs):
log = logger.debug
try:
method = util.getAttribute(obj, method)
return method(*vargs, **kwargs) # this is the actual method call to the Pyro object
except Exception:
xt, xv = sys.exc_info()[0:2]
log("Exception occurred while handling request: %s", xv)
xv._pyroTraceback = util.formatTraceback(detailed=Pyro4.config.DETAILED_TRACEBACK)
if sys.platform == "cli":
util.fixIronPythonExceptionForPickle(xv, True) # piggyback attributes
return xv
def handleConnection(self):
# connection handshake
try:
if self.daemon._handshake(self.csock):
return True
self.csock.close()
except:
ex_t, ex_v, ex_tb = sys.exc_info()
tb = util.formatTraceback(ex_t, ex_v, ex_tb)
log.warning("error during connect/handshake: %s; %s", ex_v, "\n".join(tb))
self.csock.close()
return False
def handleRequest(self, conn):
"""Handles a single connection request event and returns if the connection is still active"""
try:
self.daemon.handleRequest(conn)
return True
except (socket.error, errors.ConnectionClosedError, errors.SecurityError):
# client went away or caused a security error.
# close the connection silently.
return False
except:
# other error occurred, close the connection, but also log a warning
ex_t, ex_v, ex_tb = sys.exc_info()
tb = util.formatTraceback(ex_t, ex_v, ex_tb)
log.warning("error during handleRequest: %s; %s", ex_v, "\n".join(tb))
return False
def handleRequest(self, conn):
"""Handles a single connection request event and returns if the connection is still active"""
try:
self.daemon.handleRequest(conn)
return True
except (socket.error, errors.ConnectionClosedError, errors.SecurityError):
# client went away or caused a security error.
# close the connection silently.
return False
except:
# other error occurred, close the connection, but also log a warning
ex_t, ex_v, ex_tb = sys.exc_info()
tb = util.formatTraceback(ex_t, ex_v, ex_tb)
msg = "error during handleRequest: %s; %s" % (ex_v, "".join(tb))
log.warning(msg)
return False
def handleRequest(self, conn):
"""
Handle incoming Pyro request. Catches any exception that may occur and
wraps it in a reply to the calling side, as to not make this server side loop
terminate due to exceptions caused by remote invocations.
"""
flags=0
seq=0
wasBatched=False
isCallback=False
try:
msgType, flags, seq, data = MessageFactory.getMessage(conn, MessageFactory.MSG_INVOKE)
objId, method, vargs, kwargs=self.serializer.deserialize(
data, compressed=flags & MessageFactory.FLAGS_COMPRESSED)
del data # invite GC to collect the object, don't wait for out-of-scope
obj=self.objectsById.get(objId)
if obj is not None:
self._set_log(
"info",
"[Object] Client %s contacting object %s" %
(conn.sock.getpeername()[0], objId)
)
if kwargs and sys.version_info<(2, 6, 5) and os.name!="java":
# Python before 2.6.5 doesn't accept unicode keyword arguments
kwargs = dict((str(k), kwargs[k]) for k in kwargs)
if flags & MessageFactory.FLAGS_BATCH:
# batched method calls, loop over them all and collect all results
data=[]
for method,vargs,kwargs in vargs:
method=util.resolveDottedAttribute(obj, method, Pyro4.config.DOTTEDNAMES)
try:
result=method(*vargs, **kwargs) # this is the actual method call to the Pyro object
except Exception:
xt,xv=sys.exc_info()[0:2]
xv._pyroTraceback=util.formatTraceback(detailed=Pyro4.config.DETAILED_TRACEBACK)
if sys.platform=="cli":
fixIronPythonExceptionForPickle(xv, True) # piggyback attributes
data.append(_ExceptionWrapper(xv))
break # stop processing the rest of the batch
else:
data.append(result)
wasBatched=True
else:
# normal single method call
method=util.resolveDottedAttribute(obj, method, Pyro4.config.DOTTEDNAMES)
if flags & MessageFactory.FLAGS_ONEWAY and Pyro4.config.ONEWAY_THREADED:
# oneway call to be run inside its own thread
thread=threadutil.Thread(target=method, args=vargs, kwargs=kwargs)
thread.setDaemon(True)
thread.start()
else:
isCallback=getattr(method, "_pyroCallback", False)
data=method(*vargs, **kwargs) # this is the actual method call to the Pyro object
else:
self._set_log(
"critical",
"[Object] Client %s contacting unknown object %s" %
(conn.sock.getpeername()[0], objId)
)
raise errors.DaemonError("unknown object")
if flags & MessageFactory.FLAGS_ONEWAY:
return # oneway call, don't send a response
else:
data, compressed=self.serializer.serialize(data, compress=Pyro4.config.COMPRESSION)
flags=0
if compressed:
flags |= MessageFactory.FLAGS_COMPRESSED
if wasBatched:
flags |= MessageFactory.FLAGS_BATCH
msg=MessageFactory.createMessage(MessageFactory.MSG_RESULT, data, flags, seq)
del data
conn.send(msg)
except Exception:
xt,xv=sys.exc_info()[0:2]
if xt is not errors.ConnectionClosedError:
if not flags & MessageFactory.FLAGS_ONEWAY:
tblines=util.formatTraceback(detailed=Pyro4.config.DETAILED_TRACEBACK)
self._sendExceptionResponse(conn, seq, xv, tblines)
if isCallback or isinstance(xv, (errors.CommunicationError, errors.SecurityError)):
raise
def handleRequest(self, conn):
"""
Handle incoming Pyro request. Catches any exception that may occur and
wraps it in a reply to the calling side, as to not make this server side loop
terminate due to exceptions caused by remote invocations.
"""
request_flags = 0
request_seq = 0
request_serializer_id = util.MarshalSerializer.serializer_id
wasBatched = False
isCallback = False
try:
msg = Message.recv(
conn, [Pyro4.message.MSG_INVOKE, Pyro4.message.MSG_PING])
request_flags = msg.flags
request_seq = msg.seq
request_serializer_id = msg.serializer_id
if Pyro4.config.LOGWIRE:
log.debug(
"daemon wiredata received: msgtype=%d flags=0x%x ser=%d seq=%d data=%r"
% (msg.type, msg.flags, msg.serializer_id, msg.seq,
msg.data))
if msg.type == Pyro4.message.MSG_PING:
# return same seq, but ignore any data (it's a ping, not an echo). Nothing is deserialized.
msg = Message(Pyro4.message.MSG_PING, b"pong",
msg.serializer_id, 0, msg.seq)
if Pyro4.config.LOGWIRE:
log.debug(
"daemon wiredata sending: msgtype=%d flags=0x%x ser=%d seq=%d data=%r"
% (msg.type, msg.flags, msg.serializer_id, msg.seq,
msg.data))
conn.send(msg.to_bytes())
return
if msg.serializer_id not in self.__serializer_ids:
raise errors.ProtocolError(
"message used serializer that is not accepted: %d" %
msg.serializer_id)
serializer = util.get_serializer_by_id(msg.serializer_id)
objId, method, vargs, kwargs = serializer.deserializeCall(
msg.data,
compressed=msg.flags & Pyro4.message.FLAGS_COMPRESSED)
del msg # invite GC to collect the object, don't wait for out-of-scope
obj = self.objectsById.get(objId)
if obj is not None:
if kwargs and sys.version_info < (2, 6,
5) and os.name != "java":
# Python before 2.6.5 doesn't accept unicode keyword arguments
kwargs = dict((str(k), kwargs[k]) for k in kwargs)
if request_flags & Pyro4.message.FLAGS_BATCH:
# batched method calls, loop over them all and collect all results
data = []
for method, vargs, kwargs in vargs:
method = util.resolveDottedAttribute(
obj, method, Pyro4.config.DOTTEDNAMES)
try:
result = method(
*vargs, **kwargs
) # this is the actual method call to the Pyro object
except Exception:
xt, xv = sys.exc_info()[0:2]
log.debug(
"Exception occurred while handling batched request: %s",
xv)
xv._pyroTraceback = util.formatTraceback(
detailed=Pyro4.config.DETAILED_TRACEBACK)
if sys.platform == "cli":
util.fixIronPythonExceptionForPickle(
xv, True) # piggyback attributes
data.append(futures._ExceptionWrapper(xv))
break # stop processing the rest of the batch
else:
data.append(result)
wasBatched = True
else:
# normal single method call
method = util.resolveDottedAttribute(
obj, method, Pyro4.config.DOTTEDNAMES)
if request_flags & Pyro4.message.FLAGS_ONEWAY and Pyro4.config.ONEWAY_THREADED:
# oneway call to be run inside its own thread
thread = threadutil.Thread(target=method,
args=vargs,
kwargs=kwargs)
thread.setDaemon(True)
thread.start()
else:
isCallback = getattr(method, "_pyroCallback", False)
data = method(
*vargs, **kwargs
) # this is the actual method call to the Pyro object
else:
log.debug("unknown object requested: %s", objId)
raise errors.DaemonError("unknown object")
if request_flags & Pyro4.message.FLAGS_ONEWAY:
return # oneway call, don't send a response
else:
data, compressed = serializer.serializeData(
data, compress=Pyro4.config.COMPRESSION)
response_flags = 0
if compressed:
response_flags |= Pyro4.message.FLAGS_COMPRESSED
if wasBatched:
response_flags |= Pyro4.message.FLAGS_BATCH
if Pyro4.config.LOGWIRE:
log.debug(
"daemon wiredata sending: msgtype=%d flags=0x%x ser=%d seq=%d data=%r"
% (Pyro4.message.MSG_RESULT, response_flags,
serializer.serializer_id, request_seq, data))
msg = Message(Pyro4.message.MSG_RESULT, data,
serializer.serializer_id, response_flags,
request_seq)
conn.send(msg.to_bytes())
except Exception:
xt, xv = sys.exc_info()[0:2]
if xt is not errors.ConnectionClosedError:
log.debug("Exception occurred while handling request: %r", xv)
if not request_flags & Pyro4.message.FLAGS_ONEWAY:
# only return the error to the client if it wasn't a oneway call
tblines = util.formatTraceback(
detailed=Pyro4.config.DETAILED_TRACEBACK)
self._sendExceptionResponse(conn, request_seq,
request_serializer_id, xv,
tblines)
if isCallback or isinstance(
xv, (errors.CommunicationError, errors.SecurityError)):
raise # re-raise if flagged as callback, communication or security error.
def handleRequest(self, conn):
"""
Handle incoming Pyro request. Catches any exception that may occur and
wraps it in a reply to the calling side, as to not make this server side loop
terminate due to exceptions caused by remote invocations.
"""
flags=0
seq=0
wasBatched=False
isCallback=False
client_future = None
try:
msgType, flags, seq, data = MessageFactory.getMessage(conn, MessageFactory.MSG_INVOKE)
objId, method, vargs, kwargs=self.serializer.deserialize(
data, compressed=flags & MessageFactory.FLAGS_COMPRESSED)
del data # invite GC to collect the object, don't wait for out-of-scope
obj=self.objectsById.get(objId)
if flags & MessageFactory.FLAGS_ASYNC:
client_future = vargs[0]
client_future._pyroOneway.update(["set_cancelled", "set_result", "set_exception", "set_progress"])
vargs = vargs[1:]
elif flags & MessageFactory.FLAGS_ASYNC_CANCEL:
client_future_uri = vargs[0]
if obj is not None:
if kwargs and sys.version_info<(2, 6, 5) and os.name!="java":
# Python before 2.6.5 doesn't accept unicode keyword arguments
kwargs = dict((str(k), kwargs[k]) for k in kwargs)
if flags & MessageFactory.FLAGS_BATCH:
# batched method calls, loop over them all and collect all results
data=[]
for method,vargs,kwargs in vargs:
method=util.resolveDottedAttribute(obj, method, Pyro4.config.DOTTEDNAMES)
try:
result=method(*vargs, **kwargs) # this is the actual method call to the Pyro object
except Exception:
xt,xv=sys.exc_info()[0:2]
log.debug("Exception occurred while handling batched request: %s", xv)
xv._pyroTraceback=util.formatTraceback(detailed=Pyro4.config.DETAILED_TRACEBACK)
if sys.platform=="cli":
util.fixIronPythonExceptionForPickle(xv, True) # piggyback attributes
data.append(futures._ExceptionWrapper(xv))
break # stop processing the rest of the batch
else:
data.append(result)
wasBatched=True
elif flags & MessageFactory.FLAGS_ASYNC_CANCEL:
data=self._cancelFuture(client_future_uri)
else:
# normal single method call
method=util.resolveDottedAttribute(obj, method, Pyro4.config.DOTTEDNAMES)
if flags & MessageFactory.FLAGS_ONEWAY and Pyro4.config.ONEWAY_THREADED:
# oneway call to be run inside its own thread
thread=threadutil.Thread(target=method, args=vargs, kwargs=kwargs)
thread.setDaemon(True)
thread.start()
elif flags & MessageFactory.FLAGS_ASYNC:
future=method(*vargs, **kwargs)
self._followFuture(future, client_future)
else:
isCallback=getattr(method, "_pyroCallback", False)
data=method(*vargs, **kwargs) # this is the actual method call to the Pyro object
else:
log.debug("unknown object requested: %s", objId)
raise errors.DaemonError("unknown object")
if flags & MessageFactory.FLAGS_ONEWAY:
return # oneway call, don't send a response
elif flags & MessageFactory.FLAGS_ASYNC:
return # async call, don't send a response yet
else:
data, compressed=self.serializer.serialize(data, compress=Pyro4.config.COMPRESSION)
flags=0
if compressed:
flags |= MessageFactory.FLAGS_COMPRESSED
if wasBatched:
flags |= MessageFactory.FLAGS_BATCH
msg=MessageFactory.createMessage(MessageFactory.MSG_RESULT, data, flags, seq)
del data
conn.send(msg)
except Exception as ex:
xt,xv=sys.exc_info()[0:2]
if xt is not errors.ConnectionClosedError:
log.debug("Exception occurred while handling request: %r", xv)
if client_future is not None:
# send exception to the client future
client_future.set_exception(ex)
elif not flags & MessageFactory.FLAGS_ONEWAY:
# only return the error to the client if it wasn't a oneway call
tblines=util.formatTraceback(detailed=Pyro4.config.DETAILED_TRACEBACK)
self._sendExceptionResponse(conn, seq, xv, tblines)
if isCallback or isinstance(xv, (errors.CommunicationError, errors.SecurityError)):
raise # re-raise if flagged as callback, communication or security error.
