python:httplib.嵌套带线程的SimpleXMLRPCServers时无法发送请求

Question

我间歇性地收到httplib。使用使用SocketServer.ThreadingMixin.的SimpleXMLRPCServers链时发生CannotSendRequest异常

我所说的"链"是指以下内容：

我有一个客户端脚本，它使用xmlrpclib来调用SimpleXMLRPCServer上的函数。该服务器反过来调用另一个SimpleXMLRPCServer。我意识到这听起来有多复杂，但有充分的理由选择这种架构，我看不出有什么理由不可能。

(testclient)client_script ---calls--> 
(middleserver)SimpleXMLRPCServer ---calls---> 
(finalserver)SimpleXMLRPCServer --- does something

• 如果我不使用SocketServer.ThreadingMixin，那么这个问题就不会发生(但我需要请求是多线程的，所以这没有帮助。)
• 如果我只有单一级别的服务(即客户端脚本直接调用最终服务器)，则不会发生这种情况

我已经能够在下面的简单测试代码中重现这个问题。有三个片段：

finalserver:

import SocketServer
import time
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
class AsyncXMLRPCServer(SocketServer.ThreadingMixIn,SimpleXMLRPCServer): pass
# Create server
server = AsyncXMLRPCServer(('', 9999), SimpleXMLRPCRequestHandler)
server.register_introspection_functions()
def waste_time():
time.sleep(10)
return True
server.register_function(waste_time, 'waste_time')
server.serve_forever()

中间服务器：

import SocketServer
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
import xmlrpclib
class AsyncXMLRPCServer(SocketServer.ThreadingMixIn,SimpleXMLRPCServer): pass
# Create server
server = AsyncXMLRPCServer(('', 8888), SimpleXMLRPCRequestHandler)
server.register_introspection_functions()
s = xmlrpclib.ServerProxy('http://localhost:9999')
def call_waste():
s.waste_time()
return True
server.register_function(call_waste, 'call_waste')
server.serve_forever()

测试客户端：

import xmlrpclib
s = xmlrpclib.ServerProxy('http://localhost:8888')
print s.call_waste()

要复制，应使用以下步骤：

1. 运行python finalserver.py
2. 运行python middleserver.py
3. 运行python testclient.py
4. 当(3)仍在运行时，运行另一个python testclient.py实例

通常(几乎每次)，当您第一次尝试运行步骤4时，都会收到下面的错误。有趣的是，如果您立即尝试再次运行步骤(4)，则不会发生错误。

Traceback (most recent call last):
File "testclient.py", line 6, in <module>
print s.call_waste()
File "/usr/lib64/python2.7/xmlrpclib.py", line 1224, in __call__
return self.__send(self.__name, args)
File "/usr/lib64/python2.7/xmlrpclib.py", line 1578, in __request
verbose=self.__verbose
File "/usr/lib64/python2.7/xmlrpclib.py", line 1264, in request
return self.single_request(host, handler, request_body, verbose)
File "/usr/lib64/python2.7/xmlrpclib.py", line 1297, in single_request
return self.parse_response(response)
File "/usr/lib64/python2.7/xmlrpclib.py", line 1473, in parse_response
return u.close()
File "/usr/lib64/python2.7/xmlrpclib.py", line 793, in close
raise Fault(**self._stack[0])
xmlrpclib.Fault: <Fault 1: "<class 'httplib.CannotSendRequest'>:">

互联网似乎表明，这种异常可能是由多次调用httplib引起的。HTTPConnection.request，而不介入getresponse调用。然而，互联网并没有在SimpleXMLRPCServer的上下文中讨论这一点。任何指向解析httplib的指针。CannotSendRequest问题将不胜感激。

===========================================================================================答案：

好吧，我有点笨。我想我盯着代码看的时间太长了，以至于我错过了摆在我面前的明显解决方案(确切地说，因为答案实际上在实际问题中。)

基本上，CannotSendRequest发生在httplib。HTTPConnection被介入的"请求"操作中断。每个httplib。HTTPConnection.request必须与.getresponse()调用配对。如果该配对被另一个请求操作中断，则第二个请求将产生CannotSendRequest错误。所以：

connection = httplib.HTTPConnection(...)
connection.request(...)
connection.request(...)

将失败，因为在调用任何getresponse之前，同一连接上有两个请求。

将其与我的问题联系起来：

1. 在这三个程序中，进行此类连接的唯一位置是在serverproxy调用中
2. 这个问题只发生在线程过程中，所以很可能是一个争用情况
3. serverproxy调用共享的唯一位置是middleserver.py

那么，解决方案显然是让每个线程创建自己的服务器代理。中间服务器的固定版本如下，它可以工作：

import SocketServer
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
import xmlrpclib
class AsyncXMLRPCServer(SocketServer.ThreadingMixIn,SimpleXMLRPCServer): pass
# Create server
server = AsyncXMLRPCServer(('', 8888), SimpleXMLRPCRequestHandler)
server.register_introspection_functions()
def call_waste():
# Each call to this function creates its own serverproxy.
# If this function is called by concurrent threads, each thread
# will safely have its own serverproxy.
s = xmlrpclib.ServerProxy('http://localhost:9999')
s.waste_time()
return True
server.register_function(call_waste, 'call_waste')
server.serve_forever()

由于此版本导致每个线程都有自己的xmlrpclib.serverproxy，因此serverproxy的同一实例不存在连续多次调用HTTPConnection.request的风险。程序按预期工作。

抱歉打扰了。

Answer 1

好吧，我有点傻。我想我盯着代码看了很长一段时间，错过了摆在我面前的明显解决方案(确切地说，因为答案实际上在实际问题中。)

基本上，CannotSendRequest发生在httplib。HTTPConnection被介入的"请求"操作中断。基本上，每个httplib。HTTPConnection.request必须与.getresponse()调用配对。如果该配对被另一个请求操作中断，则第二个请求将产生CannotSendRequest错误。所以：

connection = httplib.HTTPConnection(...)
connection.request(...)
connection.request(...)

将失败，因为在调用任何getresponse之前，同一连接上有两个请求。

将其与我的问题联系起来：

1. 在这三个程序中，进行此类连接的唯一位置是在serverproxy调用中
2. 这个问题只发生在线程过程中，所以很可能是一个争用情况
3. serverproxy调用共享的唯一位置是middleserver.py

那么，解决方案显然是让每个线程创建自己的服务器代理。中间服务器的固定版本如下，它可以工作：

import SocketServer
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
import xmlrpclib
class AsyncXMLRPCServer(SocketServer.ThreadingMixIn,SimpleXMLRPCServer): pass
# Create server
server = AsyncXMLRPCServer(('', 8888), SimpleXMLRPCRequestHandler)
server.register_introspection_functions()
def call_waste():
# Each call to this function creates its own serverproxy.
# If this function is called by concurrent threads, each thread
# will safely have its own serverproxy.
s = xmlrpclib.ServerProxy('http://localhost:9999')
s.waste_time()
return True
server.register_function(call_waste, 'call_waste')
server.serve_forever()

由于这个版本导致每个线程都有自己的xmlrpclib.serverproxy，所以serverproxy不存在连续多次调用HTTPConnection.request的风险。程序按预期工作。

抱歉打扰了。