python:嵌套线程化 SimpleXMLRPCServers 时的 httplib.CannotSendRequest

Question

在使用使用 SocketServer.ThreadingMixin 的 SimpleXMLRPCServer 链时，我间歇性地收到 httplib.CannotSendRequest 异常。

我所说的“链”是指以下内容:

我有一个客户端脚本，它使用 xmlrpclib 调用 SimpleXMLRPCServer 上的函数。该服务器依次调用另一个 SimpleXMLRPCServer。我知道这听起来有多么令人费解，但选择这种架构是有充分理由的，而且我看不出有什么理由不应该这样做。

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

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

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

最终服务器:

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

============================================= ============================================回答:

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

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

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

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

将其链接回我的问题:

1. 三个程序中唯一建立此类连接的地方是服务器代理调用。
2. 该问题仅在线程处理期间出现，因此很可能是竞争条件。
3. 唯一共享 serverproxy 调用的地方是 middleserver.py

那么解决方案显然是让每个线程创建它自己的服务器代理。 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 的风险。这些程序按预期工作。

对不起，打扰了。

Answer 1

好吧，我有点笨。我想我盯着代码看了一段时间，以至于错过了直面我的明显解决方案(从字面上看，因为答案实际上在实际问题中。)

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

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

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

将其链接回我的问题:

1. 三个程序中唯一建立此类连接的地方是服务器代理调用。
2. 该问题仅在线程处理期间出现，因此很可能是竞争条件。
3. 唯一共享 serverproxy 调用的地方是 middleserver.py

那么解决方案显然是让每个线程创建它自己的服务器代理。 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 的风险。这些程序按预期工作。

对不起，打扰了。