~openerp/openobject-server/trunk-speedup-need_action-tde
» Revision
1884.1.1
: python25-compat/SimpleXMLRPCServer.py
« back to all changes in this revision
Viewing changes to python25-compat/SimpleXMLRPCServer.py
- browse files at revision 1884.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 1884.1.1
- Committer: Harry (Open ERP)
- Author(s): xrg
- Date: 2009-11-20 14:31:04 UTC
- mfrom: (1119.1.208)
- mto: (1898.1.1 trunk)
- mto: This revision was merged to the branch mainline in revision 1900.
- Revision ID: hmo@tinyerp.com-20091120143104-tb6136unkdw7yfy9
[merge] merge from lp:~xrg/openobject-server/optimize-5.0 and removed some confilts
- files added:
- bin/report/render/rml2pdf/customfonts.py
- bin/report/render/rml2txt
- bin/ssl
- debian
- debian/local
- debian/patches
- debian/po
- python25-compat
- sql
- files modified:
- bin/addons/__init__.py
added
removed
python25-compat/SimpleXMLRPCServer.py
1
"""Simple XML-RPC Server.
2
3
This module can be used to create simple XML-RPC servers
4
by creating a server and either installing functions, a
5
class instance, or by extending the SimpleXMLRPCServer
6
class.
7
8
It can also be used to handle XML-RPC requests in a CGI
9
environment using CGIXMLRPCRequestHandler.
10
11
A list of possible usage patterns follows:
12
13
1. Install functions:
14
15
server = SimpleXMLRPCServer(("localhost", 8000))
16
server.register_function(pow)
17
server.register_function(lambda x,y: x+y, 'add')
18
server.serve_forever()
19
20
2. Install an instance:
21
22
class MyFuncs:
23
def __init__(self):
24
# make all of the string functions available through
25
# string.func_name
26
import string
27
self.string = string
28
def _listMethods(self):
29
# implement this method so that system.listMethods
30
# knows to advertise the strings methods
31
return list_public_methods(self) + \
32
['string.' + method for method in list_public_methods(self.string)]
33
def pow(self, x, y): return pow(x, y)
34
def add(self, x, y) : return x + y
35
36
server = SimpleXMLRPCServer(("localhost", 8000))
37
server.register_introspection_functions()
38
server.register_instance(MyFuncs())
39
server.serve_forever()
40
41
3. Install an instance with custom dispatch method:
42
43
class Math:
44
def _listMethods(self):
45
# this method must be present for system.listMethods
46
# to work
47
return ['add', 'pow']
48
def _methodHelp(self, method):
49
# this method must be present for system.methodHelp
50
# to work
51
if method == 'add':
52
return "add(2,3) => 5"
53
elif method == 'pow':
54
return "pow(x, y[, z]) => number"
55
else:
56
# By convention, return empty
57
# string if no help is available
58
return ""
59
def _dispatch(self, method, params):
60
if method == 'pow':
61
return pow(*params)
62
elif method == 'add':
63
return params[0] + params[1]
64
else:
65
raise 'bad method'
66
67
server = SimpleXMLRPCServer(("localhost", 8000))
68
server.register_introspection_functions()
69
server.register_instance(Math())
70
server.serve_forever()
71
72
4. Subclass SimpleXMLRPCServer:
73
74
class MathServer(SimpleXMLRPCServer):
75
def _dispatch(self, method, params):
76
try:
77
# We are forcing the 'export_' prefix on methods that are
78
# callable through XML-RPC to prevent potential security
79
# problems
80
func = getattr(self, 'export_' + method)
81
except AttributeError:
82
raise Exception('method "%s" is not supported' % method)
83
else:
84
return func(*params)
85
86
def export_add(self, x, y):
87
return x + y
88
89
server = MathServer(("localhost", 8000))
90
server.serve_forever()
91
92
5. CGI script:
93
94
server = CGIXMLRPCRequestHandler()
95
server.register_function(pow)
96
server.handle_request()
97
"""
98
99
# Written by Brian Quinlan (brian@sweetapp.com).
100
# Based on code written by Fredrik Lundh.
101
102
import xmlrpclib
103
from xmlrpclib import Fault
104
import SocketServer
105
import BaseHTTPServer
106
import sys
107
import os
108
import traceback
109
try:
110
import fcntl
111
except ImportError:
112
fcntl = None
113
114
def resolve_dotted_attribute(obj, attr, allow_dotted_names=True):
115
"""resolve_dotted_attribute(a, 'b.c.d') => a.b.c.d
116
117
Resolves a dotted attribute name to an object. Raises
118
an AttributeError if any attribute in the chain starts with a '_'.
119
120
If the optional allow_dotted_names argument is false, dots are not
121
supported and this function operates similar to getattr(obj, attr).
122
"""
123
124
if allow_dotted_names:
125
attrs = attr.split('.')
126
else:
127
attrs = [attr]
128
129
for i in attrs:
130
if i.startswith('_'):
131
raise AttributeError(
132
'attempt to access private attribute "%s"' % i
133
)
134
else:
135
obj = getattr(obj,i)
136
return obj
137
138
def list_public_methods(obj):
139
"""Returns a list of attribute strings, found in the specified
140
object, which represent callable attributes"""
141
142
return [member for member in dir(obj)
143
if not member.startswith('_') and
144
hasattr(getattr(obj, member), '__call__')]
145
146
def remove_duplicates(lst):
147
"""remove_duplicates([2,2,2,1,3,3]) => [3,1,2]
148
149
Returns a copy of a list without duplicates. Every list
150
item must be hashable and the order of the items in the
151
resulting list is not defined.
152
"""
153
u = {}
154
for x in lst:
155
u[x] = 1
156
157
return u.keys()
158
159
class SimpleXMLRPCDispatcher:
160
"""Mix-in class that dispatches XML-RPC requests.
161
162
This class is used to register XML-RPC method handlers
163
and then to dispatch them. There should never be any
164
reason to instantiate this class directly.
165
"""
166
167
def __init__(self, allow_none, encoding):
168
self.funcs = {}
169
self.instance = None
170
self.allow_none = allow_none
171
self.encoding = encoding
172
173
def register_instance(self, instance, allow_dotted_names=False):
174
"""Registers an instance to respond to XML-RPC requests.
175
176
Only one instance can be installed at a time.
177
178
If the registered instance has a _dispatch method then that
179
method will be called with the name of the XML-RPC method and
180
its parameters as a tuple
181
e.g. instance._dispatch('add',(2,3))
182
183
If the registered instance does not have a _dispatch method
184
then the instance will be searched to find a matching method
185
and, if found, will be called. Methods beginning with an '_'
186
are considered private and will not be called by
187
SimpleXMLRPCServer.
188
189
If a registered function matches a XML-RPC request, then it
190
will be called instead of the registered instance.
191
192
If the optional allow_dotted_names argument is true and the
193
instance does not have a _dispatch method, method names
194
containing dots are supported and resolved, as long as none of
195
the name segments start with an '_'.
196
197
*** SECURITY WARNING: ***
198
199
Enabling the allow_dotted_names options allows intruders
200
to access your module's global variables and may allow
201
intruders to execute arbitrary code on your machine. Only
202
use this option on a secure, closed network.
203
204
"""
205
206
self.instance = instance
207
self.allow_dotted_names = allow_dotted_names
208
209
def register_function(self, function, name = None):
210
"""Registers a function to respond to XML-RPC requests.
211
212
The optional name argument can be used to set a Unicode name
213
for the function.
214
"""
215
216
if name is None:
217
name = function.__name__
218
self.funcs[name] = function
219
220
def register_introspection_functions(self):
221
"""Registers the XML-RPC introspection methods in the system
222
namespace.
223
224
see http://xmlrpc.usefulinc.com/doc/reserved.html
225
"""
226
227
self.funcs.update({'system.listMethods' : self.system_listMethods,
228
'system.methodSignature' : self.system_methodSignature,
229
'system.methodHelp' : self.system_methodHelp})
230
231
def register_multicall_functions(self):
232
"""Registers the XML-RPC multicall method in the system
233
namespace.
234
235
see http://www.xmlrpc.com/discuss/msgReader$1208"""
236
237
self.funcs.update({'system.multicall' : self.system_multicall})
238
239
def _marshaled_dispatch(self, data, dispatch_method = None):
240
"""Dispatches an XML-RPC method from marshalled (XML) data.
241
242
XML-RPC methods are dispatched from the marshalled (XML) data
243
using the _dispatch method and the result is returned as
244
marshalled data. For backwards compatibility, a dispatch
245
function can be provided as an argument (see comment in
246
SimpleXMLRPCRequestHandler.do_POST) but overriding the
247
existing method through subclassing is the prefered means
248
of changing method dispatch behavior.
249
"""
250
251
try:
252
params, method = xmlrpclib.loads(data)
253
254
# generate response
255
if dispatch_method is not None:
256
response = dispatch_method(method, params)
257
else:
258
response = self._dispatch(method, params)
259
# wrap response in a singleton tuple
260
response = (response,)
261
response = xmlrpclib.dumps(response, methodresponse=1,
262
allow_none=self.allow_none, encoding=self.encoding)
263
except Fault, fault:
264
response = xmlrpclib.dumps(fault, allow_none=self.allow_none,
265
encoding=self.encoding)
266
except:
267
# report exception back to server
268
exc_type, exc_value, exc_tb = sys.exc_info()
269
response = xmlrpclib.dumps(
270
xmlrpclib.Fault(1, "%s:%s" % (exc_type, exc_value)),
271
encoding=self.encoding, allow_none=self.allow_none,
272
)
273
274
return response
275
276
def system_listMethods(self):
277
"""system.listMethods() => ['add', 'subtract', 'multiple']
278
279
Returns a list of the methods supported by the server."""
280
281
methods = self.funcs.keys()
282
if self.instance is not None:
283
# Instance can implement _listMethod to return a list of
284
# methods
285
if hasattr(self.instance, '_listMethods'):
286
methods = remove_duplicates(
287
methods + self.instance._listMethods()
288
)
289
# if the instance has a _dispatch method then we
290
# don't have enough information to provide a list
291
# of methods
292
elif not hasattr(self.instance, '_dispatch'):
293
methods = remove_duplicates(
294
methods + list_public_methods(self.instance)
295
)
296
methods.sort()
297
return methods
298
299
def system_methodSignature(self, method_name):
300
"""system.methodSignature('add') => [double, int, int]
301
302
Returns a list describing the signature of the method. In the
303
above example, the add method takes two integers as arguments
304
and returns a double result.
305
306
This server does NOT support system.methodSignature."""
307
308
# See http://xmlrpc.usefulinc.com/doc/sysmethodsig.html
309
310
return 'signatures not supported'
311
312
def system_methodHelp(self, method_name):
313
"""system.methodHelp('add') => "Adds two integers together"
314
315
Returns a string containing documentation for the specified method."""
316
317
method = None
318
if method_name in self.funcs:
319
method = self.funcs[method_name]
320
elif self.instance is not None:
321
# Instance can implement _methodHelp to return help for a method
322
if hasattr(self.instance, '_methodHelp'):
323
return self.instance._methodHelp(method_name)
324
# if the instance has a _dispatch method then we
325
# don't have enough information to provide help
326
elif not hasattr(self.instance, '_dispatch'):
327
try:
328
method = resolve_dotted_attribute(
329
self.instance,
330
method_name,
331
self.allow_dotted_names
332
)
333
except AttributeError:
334
pass
335
336
# Note that we aren't checking that the method actually
337
# be a callable object of some kind
338
if method is None:
339
return ""
340
else:
341
import pydoc
342
return pydoc.getdoc(method)
343
344
def system_multicall(self, call_list):
345
"""system.multicall([{'methodName': 'add', 'params': [2, 2]}, ...]) => \
346
[[4], ...]
347
348
Allows the caller to package multiple XML-RPC calls into a single
349
request.
350
351
See http://www.xmlrpc.com/discuss/msgReader$1208
352
"""
353
354
results = []
355
for call in call_list:
356
method_name = call['methodName']
357
params = call['params']
358
359
try:
360
# XXX A marshalling error in any response will fail the entire
361
# multicall. If someone cares they should fix this.
362
results.append([self._dispatch(method_name, params)])
363
except Fault, fault:
364
results.append(
365
{'faultCode' : fault.faultCode,
366
'faultString' : fault.faultString}
367
)
368
except:
369
exc_type, exc_value, exc_tb = sys.exc_info()
370
results.append(
371
{'faultCode' : 1,
372
'faultString' : "%s:%s" % (exc_type, exc_value)}
373
)
374
return results
375
376
def _dispatch(self, method, params):
377
"""Dispatches the XML-RPC method.
378
379
XML-RPC calls are forwarded to a registered function that
380
matches the called XML-RPC method name. If no such function
381
exists then the call is forwarded to the registered instance,
382
if available.
383
384
If the registered instance has a _dispatch method then that
385
method will be called with the name of the XML-RPC method and
386
its parameters as a tuple
387
e.g. instance._dispatch('add',(2,3))
388
389
If the registered instance does not have a _dispatch method
390
then the instance will be searched to find a matching method
391
and, if found, will be called.
392
393
Methods beginning with an '_' are considered private and will
394
not be called.
395
"""
396
397
func = None
398
try:
399
# check to see if a matching function has been registered
400
func = self.funcs[method]
401
except KeyError:
402
if self.instance is not None:
403
# check for a _dispatch method
404
if hasattr(self.instance, '_dispatch'):
405
return self.instance._dispatch(method, params)
406
else:
407
# call instance method directly
408
try:
409
func = resolve_dotted_attribute(
410
self.instance,
411
method,
412
self.allow_dotted_names
413
)
414
except AttributeError:
415
pass
416
417
if func is not None:
418
return func(*params)
419
else:
420
raise Exception('method "%s" is not supported' % method)
421
422
class SimpleXMLRPCRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
423
"""Simple XML-RPC request handler class.
424
425
Handles all HTTP POST requests and attempts to decode them as
426
XML-RPC requests.
427
"""
428
429
# Class attribute listing the accessible path components;
430
# paths not on this list will result in a 404 error.
431
rpc_paths = ('/', '/RPC2')
432
433
def is_rpc_path_valid(self):
434
if self.rpc_paths:
435
return self.path in self.rpc_paths
436
else:
437
# If .rpc_paths is empty, just assume all paths are legal
438
return True
439
440
def do_POST(self):
441
"""Handles the HTTP POST request.
442
443
Attempts to interpret all HTTP POST requests as XML-RPC calls,
444
which are forwarded to the server's _dispatch method for handling.
445
"""
446
447
# Check that the path is legal
448
if not self.is_rpc_path_valid():
449
self.report_404()
450
return
451
452
try:
453
# Get arguments by reading body of request.
454
# We read this in chunks to avoid straining
455
# socket.read(); around the 10 or 15Mb mark, some platforms
456
# begin to have problems (bug #792570).
457
max_chunk_size = 10*1024*1024
458
size_remaining = int(self.headers["content-length"])
459
L = []
460
while size_remaining:
461
chunk_size = min(size_remaining, max_chunk_size)
462
L.append(self.rfile.read(chunk_size))
463
size_remaining -= len(L[-1])
464
data = ''.join(L)
465
466
# In previous versions of SimpleXMLRPCServer, _dispatch
467
# could be overridden in this class, instead of in
468
# SimpleXMLRPCDispatcher. To maintain backwards compatibility,
469
# check to see if a subclass implements _dispatch and dispatch
470
# using that method if present.
471
response = self.server._marshaled_dispatch(
472
data, getattr(self, '_dispatch', None)
473
)
474
except Exception, e: # This should only happen if the module is buggy
475
# internal error, report as HTTP server error
476
self.send_response(500)
477
478
# Send information about the exception if requested
479
if hasattr(self.server, '_send_traceback_header') and \
480
self.server._send_traceback_header:
481
self.send_header("X-exception", str(e))
482
self.send_header("X-traceback", traceback.format_exc())
483
484
self.end_headers()
485
else:
486
# got a valid XML RPC response
487
self.send_response(200)
488
self.send_header("Content-type", "text/xml")
489
self.send_header("Content-length", str(len(response)))
490
self.end_headers()
491
self.wfile.write(response)
492
493
# shut down the connection
494
self.wfile.flush()
495
self.connection.shutdown(1)
496
497
def report_404 (self):
498
# Report a 404 error
499
self.send_response(404)
500
response = 'No such page'
501
self.send_header("Content-type", "text/plain")
502
self.send_header("Content-length", str(len(response)))
503
self.end_headers()
504
self.wfile.write(response)
505
# shut down the connection
506
self.wfile.flush()
507
self.connection.shutdown(1)
508
509
def log_request(self, code='-', size='-'):
510
"""Selectively log an accepted request."""
511
512
if self.server.logRequests:
513
BaseHTTPServer.BaseHTTPRequestHandler.log_request(self, code, size)
514
515
class SimpleXMLRPCServer(SocketServer.TCPServer,
516
SimpleXMLRPCDispatcher):
517
"""Simple XML-RPC server.
518
519
Simple XML-RPC server that allows functions and a single instance
520
to be installed to handle requests. The default implementation
521
attempts to dispatch XML-RPC calls to the functions or instance
522
installed in the server. Override the _dispatch method inhereted
523
from SimpleXMLRPCDispatcher to change this behavior.
524
"""
525
526
allow_reuse_address = True
527
528
# Warning: this is for debugging purposes only! Never set this to True in
529
# production code, as will be sending out sensitive information (exception
530
# and stack trace details) when exceptions are raised inside
531
# SimpleXMLRPCRequestHandler.do_POST
532
_send_traceback_header = False
533
534
def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler,
535
logRequests=True, allow_none=False, encoding=None, bind_and_activate=True):
536
self.logRequests = logRequests
537
538
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
539
SocketServer.TCPServer.__init__(self, addr, requestHandler, bind_and_activate)
540
541
# [Bug #1222790] If possible, set close-on-exec flag; if a
542
# method spawns a subprocess, the subprocess shouldn't have
543
# the listening socket open.
544
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
545
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
546
flags |= fcntl.FD_CLOEXEC
547
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
548
549
class CGIXMLRPCRequestHandler(SimpleXMLRPCDispatcher):
550
"""Simple handler for XML-RPC data passed through CGI."""
551
552
def __init__(self, allow_none=False, encoding=None):
553
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
554
555
def handle_xmlrpc(self, request_text):
556
"""Handle a single XML-RPC request"""
557
558
response = self._marshaled_dispatch(request_text)
559
560
print 'Content-Type: text/xml'
561
print 'Content-Length: %d' % len(response)
562
print
563
sys.stdout.write(response)
564
565
def handle_get(self):
566
"""Handle a single HTTP GET request.
567
568
Default implementation indicates an error because
569
XML-RPC uses the POST method.
570
"""
571
572
code = 400
573
message, explain = \
574
BaseHTTPServer.BaseHTTPRequestHandler.responses[code]
575
576
response = BaseHTTPServer.DEFAULT_ERROR_MESSAGE % \
577
{
578
'code' : code,
579
'message' : message,
580
'explain' : explain
581
}
582
print 'Status: %d %s' % (code, message)
583
print 'Content-Type: text/html'
584
print 'Content-Length: %d' % len(response)
585
print
586
sys.stdout.write(response)
587
588
def handle_request(self, request_text = None):
589
"""Handle a single XML-RPC request passed through a CGI post method.
590
591
If no XML data is given then it is read from stdin. The resulting
592
XML-RPC response is printed to stdout along with the correct HTTP
593
headers.
594
"""
595
596
if request_text is None and \
597
os.environ.get('REQUEST_METHOD', None) == 'GET':
598
self.handle_get()
599
else:
600
# POST data is normally available through stdin
601
if request_text is None:
602
request_text = sys.stdin.read()
603
604
self.handle_xmlrpc(request_text)
605
606
if __name__ == '__main__':
607
print 'Running XML-RPC server on port 8000'
608
server = SimpleXMLRPCServer(("localhost", 8000))
609
server.register_function(pow)
610
server.register_function(lambda x,y: x+y, 'add')
611
server.serve_forever()
Loggerhead is a web-based interface for Breezy
Version: 2.0.1