Python: 在嵌套线程SimpleXMLRPCServers时，出现httplib.CannotSendRequest错误

Question

我在使用SocketServer.ThreadingMixin的一系列SimpleXMLRPCServers时，偶尔会收到httplib.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），则不会出现此错误。

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问题的指针，将不胜感激。

===========================================================================================

好的，我有点儿傻。我想我盯着代码看了太长时间，错过了一眼就能看到的明显解决方案（实际上，答案就在问题本身）。基本上，当一个httplib.HTTPConnection被介入“request”操作时，CannotSendRequest就会发生。每个httplib.HTTPConnection.request必须与一个.getresponse()调用配对。如果这个配对被另一个请求操作打断，第二个请求将产生CannotSendRequest错误。因此：

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

由于在调用任何getresponse之前，您的两个请求使用了同一连接，因此会失败。

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

1. 三个程序中唯一进行此类连接的地方是在serverproxy调用中。
2. 问题仅在线程期间发生，因此可能是竞争条件。
3. serverproxy调用被共享的唯一地方是在middleserver.py中。

因此，解决方案显然是让每个线程创建自己的serverproxy。下面是middelservser的修复版本，并且它有效：

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的风险。程序按预期工作。

对此造成的麻烦表示抱歉。

- user1848244

Answer 1

好的，我有点傻。我认为我盯着代码看了太长时间，以至于错过了正面注视我的明显解决方案（实际上，答案实际上在问题中。）

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

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

由于在任何getresponse被调用之前，您在同一连接上发起了两个请求，因此将失败。

将其归结回我的问题：

1. 三个程序中唯一进行此类连接的地方是在serverproxy调用中。
2. 问题仅在线程期间发生，因此很可能是竞态条件。
3. 唯一共享serverproxy调用的地方是在middleserver.py中。

因此，解决方案显然是让每个线程创建自己的serverproxy。修复后的middleserver版本如下，并且它可以工作：

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，因此不存在服务器代理连续调用HTTPConnection.request的风险。程序按预期工作。

抱歉打扰了。

- user1848244