嵌套线程SimpleXMLRPCServers时的python: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()

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()

s = xmlrpclib.ServerProxy('http://localhost:9999')
def call_waste():
    s.waste_time()
    return True

server.register_function(call_waste, 'call_waste')
server.serve_forever()

TestClient的:

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. 三个程序中唯一进行此类连接的地方是serverproxy调用.
2. 问题只发生在线程中,因此很可能是竞争条件.
3. serverproxy调用共享的唯一位置是middleserver.py

那么解决方案显然是让每个线程创建自己的serverproxy.中间服务器的固定版本如下,它的工作原理如下:

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

好的,我有点傻.我想我盯着代码延长了一段时间,我错过了一个明显的解决方案,盯着我的脸(实际上,因为答案实际上是在实际的问题中.)

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

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

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

将其链接回我的问题:

1. 三个程序中唯一进行此类连接的地方是serverproxy调用.
2. 问题只发生在线程中,因此很可能是竞争条件.
3. serverproxy调用共享的唯一位置是middleserver.py

那么解决方案显然是让每个线程创建自己的serverproxy.中间服务器的固定版本如下,它的工作原理如下:

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.这些计划按预期运作.

抱歉打扰了.