Python标准库xmlrpc.clientXMLRPC客户端访问

• Z时代
• 2024-01-10
• 分类：综合

源代码: Lib/xmlrpc/client.py

XML-RPC 是一种远程过程调用方法，它以使用 HTTP(S) 传递的 XML 作为载体。 通过它，客户端可以在远程服务器（服务器以 URI 指明）上调用带参数的方法并获取结构化的数据。 本模块支持编写 XML-RPC 客户端代码；它会处理在通用 Python 对象和 XML 之间进行在线翻译的所有细节。

class xmlrpc.client.ServerProxy(uri, transport=None, encoding=None, verbose=False, allow_none=False, use_datetime=False, use_builtin_types=False, *, context=None)¶

在 3.3 版更改: 增加了 use_builtin_types 旗标。

ServerProxy 实例是管理与远程 XML-RPC 服务器通信的对象。 要求的第一个参数为 URI (统一资源定位符)，通常就是服务器的 URL。 可选的第二个参数为传输工厂实例；在默认情况下对于 https: URL 是一个内部 SafeTransport 实例，在其他情况下则是一个内部 HTTP Transport 实例。 可选的第三个参数为编码格式，默认为 UTF-8。 可选的第四个参数为调试旗标。

The following parameters govern the use of the returned proxy instance.

If allow_none is true, the Python constant None will be translated into

XML; the default behaviour is for None to raise a TypeError. This is

a commonly-used extension to the XML-RPC specification, but isn't supported by

all clients and servers; see http://ontosys.com/xml-rpc/extensions.php

for a description.

The use_builtin_types flag can be used to cause date/time values

to be presented as datetime.datetime objects and binary data to be

presented as bytes objects; this flag is false by default.

datetime.datetime, bytes and bytearray objects

may be passed to calls.

The obsolete use_datetime flag is similar to use_builtin_types but it

applies only to date/time values.

HTTP 和 HTTPS 传输均支持用于 HTTP 基本身份验证的 URL 语法扩展: http://user:pass@host:port/path。 user:pass 部分将以 base64 编码为 HTTP 'Authorization' 标头，并在发起调用 XML-RPC 方法时作为连接过程的一部分发送给远程服务器。 你只需要在远程服务器要求基本身份验证账号和密码时使用此语法。 如果提供了 HTTPS URL，context 可以为 ssl.SSLContext 并配置有下层 HTTPS 连接的 SSL 设置。

返回的实例是一个代理对象，具有可被用来在远程服务器上发起相应 RPC 调用的方法。 如果远程服务器支持内省 API，则也可使用该代理对象在远程服务器上查询它所支持的方法（服务发现）并获取其他服务器相关的元数据

适用的类型（即可通过 XML 生成 marshall 对象），包括如下类型（除了已说明的例外，它们会被反 marshall 为同样的 Python 类型）:

XML-RPC类型	Python 类型
boolean	bool
int, i1, i2, i4, i8 或者 biginteger	int 的范围从 -2147483648 到 2147483647。值将获得 <int> 标志。
double 或 float	float. 值将获得 <double> 标志.
string	str
array	list 或 tuple 包含整合元素。数组以 lists 形式返回。
struct	dict。 键必须为字符串，值可以为任何适用的类型。 可以传入用户自定义类的对象；只有其 __dict__ 属性会被传输。
dateTime.iso8601	DateTime 或 datetime.datetime。返回的类型取决于 use_builtin_types 和 use_datetime 标志的值。
base64	Binary, bytes 或 bytearray。返回的类型取决于 use_builtin_types 标志的值。
nil	None 常量。仅当 allow_none 为true时才允许传递。
bigdecimal	decimal.Decimal. 仅返回类型。

这是This is the full set of data types supported by XML-RPC 所支持数据类型的完整集合。 方法调用也可能引发一个特殊的 Fault 实例，用来提示 XML-RPC 服务器错误，或是用 ProtocolError 来提示 HTTP/HTTPS 传输层中的错误。 Fault 和 ProtocolError 都派生自名为 Error 的基类。 请注意 xmlrpc client 模块目前不可 marshal 内置类型的子类的实例。

当传入字符串时，XML 中的特殊字符如 <, > 和 & 将被自动转义。 但是，调用方有责任确保字符串中没有 XML 中不允许的字符，例如 ASCII 值在 0 和 31 之间的控制字符（当然，制表、换行和回车除外）；不这样做将导致 XML-RPC 请求的 XML 格式不正确。 如果你必须通过 XML-RPC 传入任意字节数据，请使用 bytes 或 bytearray 类或者下文描述的 Binary 包装器类。

Server 被保留作为 ServerProxy 的别名用于向下兼容。 新的代码应当使用 ServerProxy。

在 3.5 版更改: 增加了 context 参数。

在 3.6 版更改: 增加了对带有前缀的类型标签的支持 (例如 ex:nil)。 增加了对反 marshall 被 Apache XML-RPC 实现用于表示数值的附加类型的支持: i1, i2, i8, biginteger, float 和 bigdecimal。 请参阅 http://ws.apache.org/xmlrpc/types.html 了解详情。

fromxmlrpc.serverimportSimpleXMLRPCServer
defis_even(n):
returnn%2==0
server=SimpleXMLRPCServer(("localhost",8000))
print("Listening on port 8000...")
server.register_function(is_even,"is_even")
server.serve_forever()

importxmlrpc.client
withxmlrpc.client.ServerProxy("http://localhost:8000/")asproxy:
print("3 is even: %s"%str(proxy.is_even(3)))
print("100 is even: %s"%str(proxy.is_even(100)))

importdatetime
fromxmlrpc.serverimportSimpleXMLRPCServer
importxmlrpc.client
deftoday():
today=datetime.datetime.today()
returnxmlrpc.client.DateTime(today)
server=SimpleXMLRPCServer(("localhost",8000))
print("Listening on port 8000...")
server.register_function(today,"today")
server.serve_forever()

importxmlrpc.client
importdatetime
proxy=xmlrpc.client.ServerProxy("http://localhost:8000/")
today=proxy.today()
# convert the ISO8601 string to a datetime object
converted=datetime.datetime.strptime(today.value,"%Y%m%dT%H:%M:%S")
print("Today: %s"%converted.strftime("%d.%m.%Y, %H:%M"))

fromxmlrpc.serverimportSimpleXMLRPCServer
importxmlrpc.client
defpython_logo():
withopen("python_logo.jpg","rb")ashandle:
returnxmlrpc.client.Binary(handle.read())
server=SimpleXMLRPCServer(("localhost",8000))
print("Listening on port 8000...")
server.register_function(python_logo,'python_logo')
server.serve_forever()

importxmlrpc.client
proxy=xmlrpc.client.ServerProxy("http://localhost:8000/")
withopen("fetched_python_logo.jpg","wb")ashandle:
handle.write(proxy.python_logo().data)

fromxmlrpc.serverimportSimpleXMLRPCServer
# A marshalling error is going to occur because we're returning a
# complex number
defadd(x,y):
returnx+y+0j
server=SimpleXMLRPCServer(("localhost",8000))
print("Listening on port 8000...")
server.register_function(add,'add')
server.serve_forever()

importxmlrpc.client
proxy=xmlrpc.client.ServerProxy("http://localhost:8000/")
try:
proxy.add(2,5)
exceptxmlrpc.client.Faultaserr:
print("A fault occurred")
print("Fault code: %d"%err.faultCode)
print("Fault string: %s"%err.faultString)

importxmlrpc.client
# create a ServerProxy with a URI that doesn't respond to XMLRPC requests
proxy=xmlrpc.client.ServerProxy("http://google.com/")
try:
proxy.some_method()
exceptxmlrpc.client.ProtocolErroraserr:
print("A protocol error occurred")
print("URL: %s"%err.url)
print("HTTP/HTTPS headers: %s"%err.headers)
print("Error code: %d"%err.errcode)
print("Error message: %s"%err.errmsg)

fromxmlrpc.serverimportSimpleXMLRPCServer
defadd(x,y):
returnx+y
defsubtract(x,y):
returnx-y
defmultiply(x,y):
returnx*y
defdivide(x,y):
returnx//y
# A simple server with simple arithmetic functions
server=SimpleXMLRPCServer(("localhost",8000))
print("Listening on port 8000...")
server.register_multicall_functions()
server.register_function(add,'add')
server.register_function(subtract,'subtract')
server.register_function(multiply,'multiply')
server.register_function(divide,'divide')
server.serve_forever()

importxmlrpc.client
proxy=xmlrpc.client.ServerProxy("http://localhost:8000/")
multicall=xmlrpc.client.MultiCall(proxy)
multicall.add(7,3)
multicall.subtract(7,3)
multicall.multiply(7,3)
multicall.divide(7,3)
result=multicall()
print("7+3=%d, 7-3=%d, 7*3=%d, 7//3=%d"%tuple(result))

# simple test program (from the XML-RPC specification)
fromxmlrpc.clientimportServerProxy,Error
# server = ServerProxy("http://localhost:8000") # local server
withServerProxy("http://betty.userland.com")asproxy:
print(proxy)
try:
print(proxy.examples.getStateName(41))
exceptErrorasv:
print("ERROR",v)

importhttp.client
importxmlrpc.client
classProxiedTransport(xmlrpc.client.Transport):
defset_proxy(self,host,port=None,headers=None):
self.proxy=host,port
self.proxy_headers=headers
defmake_connection(self,host):
connection=http.client.HTTPConnection(*self.proxy)
connection.set_tunnel(host,headers=self.proxy_headers)
self._connection=host,connection
returnconnection
transport=ProxiedTransport()
transport.set_proxy('proxy-server',8080)
server=xmlrpc.client.ServerProxy('http://betty.userland.com',transport=transport)
print(server.examples.getStateName(41))