def __init__(self, no_introspection=False):
if sys.version_info[:2] < (2, 5):
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self, False, 'utf-8')
if not no_introspection:
self.register_introspection_functions()
def post(self, request):
dispatcher = SimpleXMLRPCDispatcher(allow_none=False, encoding=None)
dispatcher.register_function(partial(self.ping, request), 'pingback:ping')
response = HttpResponse(mimetype="application/xml")
response.write(dispatcher._marshaled_dispatch(request.raw_post_data))
return response
def __init__(self):
#: Python 2.5 requires some arguments like `allow_none`
#: and the encoding. Python 2.4 and 2.3 doesn't.
if sys.version_info[:2] < (2, 5):
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
def __init__(self, path):
path = to_unicode(path)
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
self.register_introspection_functions()
self.register_multicall_functions()
self.instance = self.instance_class(path)
self.path = path
def __init__(self, requestHandler, logRequests=True, allow_none=False,
encoding=None):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none=allow_none,
encoding=encoding)
ConnectedTCPServer.__init__(self, requestHandler)
def __init__(self, allow_none=False, encoding=None):
try:
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
except TypeError:
# see http://bugs.debian.org/470645
# python2.4 and before only took one argument
SimpleXMLRPCDispatcher.__init__(self)
def __init__(self, registerInstance, server_address, keyFile=DEFAULTKEYFILE,
certFile=DEFAULTCERTFILE, caFile = DEFAULTCAFILE, logRequests=True):
"""Secure Documenting XML-RPC server.
It it very similar to DocXMLRPCServer but it uses HTTPS for transporting XML data.
"""
SimpleXMLRPCServer.__init__(self, server_address, SecureXMLRPCRequestHandler, logRequests)
self.logRequests = logRequests
self.register_introspection_functions()
# init stuff, handle different versions:
try:
SimpleXMLRPCDispatcher.__init__(self)
except TypeError:
# An exception is raised in Python 2.5 as the prototype of the __init__
# method has changed and now has 3 arguments (self, allow_none, encoding)
SimpleXMLRPCDispatcher.__init__(self, False, None)
SocketServer.BaseServer.__init__(self, server_address, SecureXMLRPCRequestHandler)
self.register_instance(registerInstance) # for some reason, have to register instance down here!
# SSL socket stuff
ctx = SSL.Context(SSL.SSLv23_METHOD)
ctx.use_privatekey_file(keyFile)
ctx.use_certificate_file(certFile)
# verify
ctx.load_verify_locations(caFile)
ctx.set_verify(SSL.VERIFY_PEER|SSL.VERIFY_FAIL_IF_NO_PEER_CERT, self._verify)
self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type))
self.server_bind()
self.server_activate()
# requests count and condition, to allow for keyboard quit via CTL-C
self.requests = 0
self.rCondition = Condition()
def CreateApp(self, name):
"""
Creates new app.
@param name: Name of an app.
@type name: C{str}
@return: Instance id of an app.
@rtype: C{int}
"""
if not self.Apps:
return 0
if name not in self.Apps:
return 0
id= int(random.getrandbits(16))
print self.Apps[name]
if not self.instances:
self.instances= {}
self.instances[id]= (self.Apps[name](), name,)
dispatcher= SimpleXMLRPCDispatcher()
dispatcher.register_introspection_functions()
dispatcher.register_instance(self.instances[id][0])
self.server.add_dispatcher( "/"+str(id), dispatcher)
return id
def __init__(self,application, request, transforms=None): tornado.web.RequestHandler.__init__(self,application, request, transforms) SimpleXMLRPCDispatcher.__init__(self,True,None) self.register_multicall_functions() self.register_methods()
def __init__(self, prefix):
self.prefix = prefix
try:
# Python 2.4
self.dispatcher = SimpleXMLRPCDispatcher()
except TypeError:
# Python 2.5
self.dispatcher = SimpleXMLRPCDispatcher(allow_none=False, encoding=None)
def __init__(self, clientHost, clientPort):
SimpleXMLRPCDispatcher.__init__(self)
ThreadingTCPServer.__init__(self,
(clientHost, clientPort),
SimpleXMLRPCRequestHandler)
self.logRequests = 1
self.client = AdminControlInterface()
self.register_introspection_functions()
self.register_instance(self.client)
def __init__(self, addr, requestHandler=RequestHandler):
self.logRequests = 0
if os.path.exists(addr):
os.unlink(addr)
dir = os.path.dirname(addr)
if not(os.path.exists(dir)):
os.makedirs(dir)
SimpleXMLRPCDispatcher.__init__(self)
UnixStreamServer.__init__(self, addr, requestHandler)
class Server(Thread):
"""
XML-RPC server.
"""
@LogCall()
def __init__(self, requestHandler, host="localhost", port=8400):
"""
Initializes server.
@param requestHandler: Request handler for base class calls.
@type requestHandler: C{AppsHandler}
@param host: Host where to bind.
@type host: C{str}
@param port: Port where to bind.
@type port: C{int}
@return: Instance of self.
@rtype: C{Server}
"""
Thread.__init__(self)
self.server = MultiPathXMLRPCServer((host, port), requestHandler=RHandler)
self.requestHandler= requestHandler(self.server, False)
self.dispatcher= SimpleXMLRPCDispatcher()
self.dispatcher.register_introspection_functions()
self.dispatcher.register_instance(self.requestHandler)
self.server.add_dispatcher("/", self.dispatcher)
@LogCall({"level": INFO})
def run(self):
"""
Runs server.
@return: Nothing
@rtype: C{None}
"""
self.server.serve_forever()
@LogCall({"level": INFO})
def __del__(self):
"""
Stops server.
@return: Nothing
@rtype: C{None}
"""
self.server.shutdown()
def GetRequestHandler(self):
"""
Gets base request handler used with this server.
@return: Request handler used with this server.
@rtype: C{AppsHandler}
"""
return self.requestHandler
def __init__(self, requestHandler=IPXMLRPCRequestHandler,
logRequests=False, allow_none=False, encoding=None):
SimpleXMLRPCDispatcher.__init__(self, allow_none=allow_none,
encoding=encoding)
self.requestHandler = requestHandler
self.logRequests = logRequests
# TODO provide proper limit for this queue
self.queue = TaskQueue(sys.maxint)
def __init__(self,
address,
requestHandler=SimpleXMLRPCRequestHandler,
allow_none=False,
encoding=None):
self.logRequests = False
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
UnixStreamServer.__init__(self, address, requestHandler)
def __init__(self, allow_none=True, encoding=None):
if sys.version_info[:2] == (2, 4):
# doesn't support extra args in python 2.4
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
self.allow_none = allow_none
self.encoding = encoding
self.register_multicall_functions()
def __init__(self):
try:
# older Pythons like 2.4.3 demand a single parameter
# newest Python versions handle 1, 2 or 3 parameters
# supplying defaults for the 2nd and 3rd
SimpleXMLRPCDispatcher.__init__(self)
except:
# some mid-age Python versions demand 3 parameters without
# offering default values for the 2nd and 3rd
SimpleXMLRPCDispatcher.__init__(self, False, None)
def __init__(self, addr, requestHandler=DroidPresRequestHandler, logRequests=False, allow_none=False, encoding=None, bind_and_activate=True):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
ThreadingTCPServer.__init__(self, addr, requestHandler, bind_and_activate)
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def __init__(self, allow_none=True, encoding=None):
if sys.version_info[:2] == (2, 4):
# doesn't support extra args in python 2.4
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
self.allow_none = allow_none
self.encoding = encoding
self.register_multicall_functions()
def __init__(self, apis):
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
funcs = {}
for api in apis:
prefix = api.prefix
for attr_name in dir(api):
attr = getattr(api, attr_name)
if callable(attr):
funcs[prefix + attr_name] = attr
self.funcs = funcs
self.register_introspection_functions()
def __init__(self, addr, requestHandler,
logRequests, allow_none, encoding, bind_and_activate):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
ForkingTCPServer.__init__(self, addr, requestHandler, bind_and_activate)
if fcntl is not None and hasattr(fcntl, 'FD_COLEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_COLEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def __init__(self,
requestHandler,
logRequests=True,
allow_none=False,
encoding=None):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self,
allow_none=allow_none,
encoding=encoding)
ConnectedTCPServer.__init__(self, requestHandler)
def __init__(self, host, port):
'''create a XML-RPC server
Takes two initial inputs:
host -- hostname of XML-RPC server host
port -- port number for server requests
'''
Server.__init__(self)
SimpleXMLRPCDispatcher.__init__(self, allow_none=False, encoding=None)
self._installSocket(host, port)
self._activeProcesses = {} #{ fd : pid }
def main_loop():
setproctitle("webshelld")
dispatcher = SimpleXMLRPCDispatcher()
SOCKFILE = "/var/run/webshell.sock"
if os.path.exists(SOCKFILE):
os.unlink(SOCKFILE)
server = SocketServer.UnixStreamServer(SOCKFILE, XMLRPCHandler)
os.chmod(SOCKFILE, 0o700)
dispatcher.register_instance(Multiplex("/usr/local/bin/bash", "xterm-color"))
server.dispatcher = dispatcher
server.serve_forever()
def __init__(self, host, port):
"""create a XML-RPC server
Takes two initial inputs:
host -- hostname of XML-RPC server host
port -- port number for server requests
"""
Server.__init__(self)
SimpleXMLRPCDispatcher.__init__(self, allow_none=False, encoding=None)
self._installSocket(host, port)
self._activeProcesses = {} # { fd : pid }
def __init__(self, instance=None, methods=[]):
"""Create windmill xmlrpc dispatcher"""
try:
self.dispatcher = SimpleXMLRPCDispatcher(allow_none=True, encoding=None)
except TypeError:
# python 2.4
self.dispatcher = SimpleXMLRPCDispatcher()
if instance is not None:
self.dispatcher.register_instance(instance)
for method in methods:
self.dispatcher.register_function(method)
self.dispatcher.register_introspection_functions()
def __init__(self, instance=None, methods=[]):
"""Create windmill xmlrpc dispatcher"""
try:
self.dispatcher = SimpleXMLRPCDispatcher(allow_none=True,
encoding=None)
except TypeError:
# python 2.4
self.dispatcher = SimpleXMLRPCDispatcher()
if instance is not None:
self.dispatcher.register_instance(instance)
for method in methods:
self.dispatcher.register_function(method)
self.dispatcher.register_introspection_functions()
def main_loop():
setproctitle('webshelld')
dispatcher = SimpleXMLRPCDispatcher()
SOCKFILE = '/var/run/webshell.sock'
if os.path.exists(SOCKFILE):
os.unlink(SOCKFILE)
server = SocketServer.UnixStreamServer(SOCKFILE, XMLRPCHandler)
os.chmod(SOCKFILE, 0o700)
dispatcher.register_instance(
Multiplex("/usr/local/bin/bash", "xterm-color"))
server.dispatcher = dispatcher
server.serve_forever()
def __init__(self,
requestHandler=IPXMLRPCRequestHandler,
logRequests=False,
allow_none=False,
encoding=None):
SimpleXMLRPCDispatcher.__init__(self,
allow_none=allow_none,
encoding=encoding)
self.requestHandler = requestHandler
self.logRequests = logRequests
# TODO provide proper limit for this queue
self.queue = TaskQueue(sys.maxint)
def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler,
logRequests=True, allow_none=False, encoding=None, bind_and_activate=True):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
ThreadingTCPServer.__init__(self, addr, requestHandler, bind_and_activate)
# [Bug #1222790] If possible, set close-on-exec flag; if a
# method spawns a subprocess, the subprocess shouldn't have
# the listening socket open.
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def __init__(self):
SimpleXMLRPCDispatcher.__init__(self, allow_none=False,
encoding=None)
XMLRPCDocGenerator.__init__(self)
def _dumps(obj, *args, **kwargs):
kwargs['allow_none'] = self.allow_none
kwargs['encoding'] = self.encoding
return xmlrpclib.dumps(obj, *args, **kwargs)
self.dumps = _dumps
# map of name => (auth, func)
self.func_map = {}
def __init__(self,
addr,
logger,
allow_none=False,
logRequests=1,
encoding='iso-8859-1'):
class AuthenticatedRequestHandler(SimpleXMLRPCRequestHandler):
def parse_request(myself):
if SimpleXMLRPCRequestHandler.parse_request(myself):
header = myself.headers.get('Authorization')
if header == None:
username = None
password = None
else:
(basic, encoded) = \
header.split(' ', 2)
assert basic == 'Basic', 'Only basic authentication supported'
(username,
password) = base64.b64decode(encoded).split(':', 2)
if self.authenticate(username, password):
return True
else:
myself.send_response(401, 'Authentication failed')
myself.send_header('WWW-Authenticate',
'Basic realm="XML-RPC"')
myself.end_headers()
myself.wfile.write('Authentication failed.')
return False
self.logRequests = logRequests
if sys.version_info[:2] < (2, 5):
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self,
allow_none=allow_none,
encoding=encoding)
ThreadingTCPServer.__init__(self, addr, AuthenticatedRequestHandler)
self.required_username = None
self.required_password = None
self.logger = logger
def __init__(self):
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
self.register_function(list_packages)
self.register_function(package_releases)
self.register_function(release_urls)
self.register_function(release_urls, name='package_urls') # Deprecated
self.register_function(release_data)
self.register_function(release_data, name='package_data') # Deprecated
self.register_function(search)
self.register_function(updated_releases)
self.register_function(changelog)
self.register_function(post_cheesecake_for_release)
self.register_introspection_functions()
self.register_multicall_functions()
def __init__(self):
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
self.register_function(list_packages)
self.register_function(package_releases)
self.register_function(release_urls)
self.register_function(release_urls, name='package_urls') # Deprecated
self.register_function(release_data)
self.register_function(release_data, name='package_data') # Deprecated
self.register_function(search)
self.register_function(updated_releases)
self.register_function(changelog)
self.register_function(post_cheesecake_for_release)
self.register_introspection_functions()
self.register_multicall_functions()
def get_handler(methodlist):
dispatcher = SimpleXMLRPCDispatcher(False, None)
for method in web.group(methodlist, 2):
dispatcher.register_function(method[1], method[0])
class rpc:
def GET(self):
web.header('Content-Type', 'text/html')
print get_doc(dispatcher)
def POST(self):
response = dispatcher._marshaled_dispatch(web.webapi.data())
web.header('Content-Type', 'text/xml')
web.header('Content-length', str(len(response)))
print response
return rpc
def __init__(self, server_address, requestHandler, keyfile, certfile, logRequests=True, allow_none=False):
"""Secure XML-RPC server.
It it very similar to SimpleXMLRPCServer but it uses HTTPS for transporting XML data.
"""
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none=allow_none)
SocketServer.BaseServer.__init__(self, server_address, requestHandler)
ctx = SSL.Context(SSL.SSLv23_METHOD)
ctx.use_privatekey_file(keyfile)
ctx.use_certificate_file(certfile)
self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type))
self.server_bind()
self.server_activate()
def __init__(self, addr, KEYFILE, CERTFILE):
SimpleXMLRPCDispatcher.__init__(self)
VerifyingServer.__init__(self, addr)
self.socket = ssl.wrap_socket(
socket.socket(self.address_family, self.socket_type),
server_side=True,
keyfile=KEYFILE,
certfile=CERTFILE,
cert_reqs=ssl.CERT_NONE,
ssl_version=ssl.PROTOCOL_SSLv23,
)
self.server_bind()
self.server_activate()
def register_function(self, function, name=None):
"""
This will register the given function. There are two ways to use it.
As a plain old method, with or without a name::
handler.register_function(spam)
handler.register_function(spam, 'spam')
As a decorator, also with or without a name::
@handler.register_function
def spam():
pass
@handler.register_function('spam')
def spam():
pass
It's shorter and easier to use :meth:`register`, however, as it does
the exact same thing.
:param function: The function to register. (In the named decorator
form, this is the function's name.)
:param name: The name to use, except in the named decorator form.
If not given, the function's :obj:`__name__` attribute
will be used.
"""
if isinstance(function, basestring):
return lambda fn: self.register_function(fn, function)
return Dispatcher.register_function(self, function, name)
def __init__(self,
endpoint_name=None,
instance=None,
introspection=True,
multicall=False):
if sys.version_info[:2] < (2, 5):
Dispatcher.__init__(self)
else:
Dispatcher.__init__(self, True, 'utf-8')
self.endpoint_name = endpoint_name
if introspection:
self.register_introspection_functions()
if multicall:
self.register_multicall_functions()
if instance:
self.register_instance(instance)
def __init__(self, server_address, HandlerClass, logRequests=True):
"""Secure XML-RPC server.
It it very similar to SimpleXMLRPCServer but it uses HTTPS for
transporting XML data.
"""
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self)
SocketServer.BaseServer.__init__(self, server_address, HandlerClass)
ctx = SSL.Context(SSL.SSLv23_METHOD)
ctx.use_privatekey_file (KEYFILE)
ctx.use_certificate_file(CERTFILE)
self.socket = SSL.Connection(ctx, socket.socket(self.address_family,
self.socket_type))
self.server_bind()
self.server_activate()
def __init__(self,instance=None,methods=[]):
self.dispatcher = SimpleXMLRPCDispatcher(allow_none=True,encoding=None)
if instance is not None:
self.dispatcher.register_instance(instance)
for method in methods:
self.dispatcher.register_function(method)
self.dispatcher.register_introspection_functions()
def _dispatch(self, *args, **kw):
try:
result = SimpleXMLRPCDispatcher._dispatch(self, *args, **kw)
# self.logger.debug("Result: %s" % (result, ))
return result
except:
self.logger.exception("Error while processing request")
raise
def handle_request(app, request):
'''Wrap an invocation of the XML-RPC dispatcher.
'''
dispatcher = SimpleXMLRPCDispatcher()
dispatcher.register_instance(Interface(app, request))
# read in the XML-RPC request data, limiting to a sensible size
if int(request.headers['Content-Length']) > 10 * 1024 * 1024:
raise BadRequest('request data too large')
xml_request = request.get_data(cache=False, as_text=True)
# errors here are handled by _marshaled_dispatch
response = dispatcher._marshaled_dispatch(xml_request)
# legacy; remove non-printable ASCII control codes from the response
response = re.sub('([\x00-\x08]|[\x0b-\x0c]|[\x0e-\x1f])+', '', response)
return Response(response, mimetype="text/xml")
def __init__(self):
if sys.version_info[:3] >= (2,5,):
SimpleXMLRPCDispatcher.__init__(self, allow_none=False,
encoding=None)
def _dumps(obj, *args, **kwargs):
kwargs['allow_none'] = self.allow_none
kwargs['encoding'] = self.encoding
return xmlrpclib.dumps(obj, *args, **kwargs)
else:
def _dumps(obj, *args, **kwargs):
return xmlrpclib.dumps(obj, *args, **kwargs)
SimpleXMLRPCDispatcher.__init__(self)
self.dumps = _dumps
# map of name => (auth, func)
self.func_map = {}
def register_instance(self, instance, allow_dotted_names=False):
"""
This registers any kind of object. If the requested method hasn't been
registered by :meth:`register_function`, it will be checked against
the instance. You can only have one instance at a time, however.
If :obj:`allow_dotted_names` is True, the name will be split on the
dots and the object will be traveled down recursively. However, this
is a **HUGE SECURITY LOOPHOLE**, as while private methods (starting
with ``_``) will not be exposed, it's still possible that someone
could get access to your globals and do very bad things. So don't
do it unless you have a very good reason.
:param instance: The instance to register.
:param allow_dotted_names: Whether to resolve dots in method names.
You probably shouldn't.
"""
# Yes, it's just a wrapper. I know. This way the docs are consistent.
Dispatcher.register_instance(self, instance, allow_dotted_names)
def __init__(self,
addr,
requestHandler=UnixStreamXMLRPCRequestHandler,
logRequests=True,
allow_none=False,
encoding=None,
bind_and_activate=True,
use_builtin_types=False):
self.logRequests = logRequests
try:
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding,
use_builtin_types)
except TypeError:
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
socketserver.UnixStreamServer.__init__(self, addr, requestHandler,
bind_and_activate)
def _dispatch(self, method, params):
try:
return SimpleXMLRPCDispatcher._dispatch(self, method, params)
except Exception, e:
message = "XML-RPC request caused exception:\n"
message += "Method: %s\n" % (method)
message += "Parameters: %s" % (str(params))
self.logger.exception(message)
raise
class WSGIXMLRPCApplication(object):
"""Application to handle requests to the XMLRPC service"""
def __init__(self, instance=None, methods=[]):
"""Create windmill xmlrpc dispatcher"""
self.dispatcher = SimpleXMLRPCDispatcher(allow_none=True,
encoding=None)
if instance is not None:
self.dispatcher.register_instance(instance)
for method in methods:
self.dispatcher.register_function(method)
self.dispatcher.register_introspection_functions()
def handler(self, environ, start_response):
"""XMLRPC service for windmill browser core to communicate with"""
if environ['REQUEST_METHOD'] == 'POST':
return self.handle_POST(environ, start_response)
else:
start_response("400 Bad request", [('Content-Type', 'text/plain')])
return ['']
def handle_POST(self, environ, start_response):
"""Handles the HTTP POST request.
Attempts to interpret all HTTP POST requests as XML-RPC calls,
which are forwarded to the server's _dispatch method for handling.
Most code taken from SimpleXMLRPCServer with modifications for wsgi and
my custom dispatcher.
"""
try:
# Get arguments by reading body of request.
# We read this in chunks to avoid straining
length = int(environ['CONTENT_LENGTH'])
data = environ['wsgi.input'].read(length)
# In previous versions of SimpleXMLRPCServer, _dispatch
# could be overridden in this class, instead of in
# SimpleXMLRPCDispatcher. To maintain backwards compatibility,
# check to see if a subclass implements _dispatch and
# using that method if present.
response = self.dispatcher._marshaled_dispatch(
data, getattr(self.dispatcher, '_dispatch', None)
)
response += '\n'
except: # This should only happen if the module is buggy
# internal error, report as HTTP server error
start_response("500 Server error", [('Content-Type',
'text/plain')])
return []
else:
# got a valid XML RPC response
start_response("200 OK", [('Content-Type', 'text/xml'),
('Content-Length', str(len(response)),)])
return [response]
def __call__(self, environ, start_response):
return self.handler(environ, start_response)
def system_listMethods(self):
"""
Gets a list of the methods supported by the server.
:returns: ['method name', ...]
:rtype: list
"""
return SimpleXMLRPCDispatcher.system_listMethods(self)
def __init__(self,
addr,
requestHandler,
logRequests=True,
allow_none=False,
encoding=None,
bind_and_activate=True):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
HTTPServer.__init__(self, addr, requestHandler)
# [Bug #1222790] If possible, set close-on-exec flag; if a
# method spawns a subprocess, the subprocess shouldn't have
# the listening socket open.
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def handler(request, response, methods):
response.session_id = None # no sessions for xmlrpc
dispatcher = SimpleXMLRPCDispatcher(allow_none=True, encoding=None)
for method in methods:
dispatcher.register_function(method)
dispatcher.register_introspection_functions()
response.headers['Content-Type'] = 'text/xml'
dispatch = getattr(dispatcher, '_dispatch', None)
return dispatcher._marshaled_dispatch(request.body.read(), dispatch)
class WSGIXMLRPCApplication(object):
"""Application to handle requests to the XMLRPC service"""
def __init__(self, instance=None, methods=()):
"""Create windmill xmlrpc dispatcher"""
try:
self.dispatcher = SimpleXMLRPCDispatcher(allow_none=True,
encoding=None)
except TypeError:
# python 2.4
self.dispatcher = SimpleXMLRPCDispatcher()
if instance is not None:
self.dispatcher.register_instance(instance)
for method in methods:
self.dispatcher.register_function(method)
self.dispatcher.register_introspection_functions()
@Request.application
def handler(self, request):
if request.method == 'POST':
return self.handle_POST(request)
else:
return BadRequest()
def handle_POST(self, request):
"""Handles the HTTP POST request.
Attempts to interpret all HTTP POST requests as XML-RPC calls,
which are forwarded to the server's _dispatch method for handling.
Most code taken from SimpleXMLRPCServer with modifications for wsgi and
my custom dispatcher.
"""
try:
# Read the data from the request
data = request.get_data()
# In previous versions of SimpleXMLRPCServer, _dispatch
# could be overridden in this class, instead of in
# SimpleXMLRPCDispatcher. To maintain backwards compatibility,
# check to see if a subclass implements _dispatch and
# using that method if present.
response = self.dispatcher._marshaled_dispatch(
data, getattr(self.dispatcher, '_dispatch', None))
response += '\n'
except: # This should only happen if the module is buggy
# internal error, report as HTTP server error
return InternalServerError()
else:
# got a valid XML RPC response
return Response(response, mimetype='text/xml')
def __call__(self, environ, start_response):
return self.handler(environ, start_response)
def __init__(self, hostname='', port=5370, threadcount=1):
# Satisfy base classes.
# =====================
addr = (hostname, port)
SimpleXMLRPCDispatcher.__init__(self)
SocketServer.TCPServer.__init__(self, addr, SimpleXMLRPCRequestHandler)
# Set up signal handling.
# =======================
self.DIE = threading.Event()
signal.signal(signal.SIGINT, self.signal_handler)
signal.signal(signal.SIGTERM, self.signal_handler)
# Set up threading.
# =================
self.SHUTDOWN = object()
self.threads = {}
self.queue = Queue.Queue()
self.fill_thread_pool(threadcount)
def system_methodHelp(self, method_name):
"""
Gets documentation for the specified method.
:type method_name: string
:returns: 'help text'
:rtype: string
"""
return SimpleXMLRPCDispatcher.system_methodHelp(self, method_name)
def _dispatch(self, method, params):
"""
Custom _dispatch so we can log exceptions and the time taken to
execute each method.
"""
start = datetime.utcnow()
try:
result = SimpleXMLRPCDispatcher._dispatch(self, method, params)
except:
logger.exception('Error handling XML-RPC call %s', str(method))
logger.debug('Time: %s %s %s', datetime.utcnow() - start, str(method), str(params)[0:50])
raise
logger.debug('Time: %s %s %s', datetime.utcnow() - start, str(method), str(params)[0:50])
return result
def __init__(self):
SimpleXMLRPCDispatcher.__init__(self, True, 'utf-8')
self.register_function(list_packages)
self.register_function(package_releases)
self.register_function(release_urls)
self.register_function(release_urls, name='package_urls') # Deprecated
self.register_function(release_data)
self.register_function(release_data, name='package_data') # Deprecated
self.register_function(search)
self.register_function(browse)
self.register_function(updated_releases)
self.register_function(changelog)
self.register_function(changelog_last_serial)
self.register_function(changelog_since_serial)
self.register_function(changed_packages)
self.register_function(post_cheesecake_for_release)
self.register_function(release_downloads)
self.register_function(package_roles)
self.register_function(user_packages)
self.register_function(package_hosting_mode)
self.register_function(top_packages)
self.register_function(list_packages_with_serial)
self.register_introspection_functions()
self.register_multicall_functions()
def __init__(self,
server_address,
keyfile,
certfile,
ssl_version=ssl.PROTOCOL_TLSv1,
requestHandler=SimpleXMLRPCRequestHandler,
logRequests=True,
allow_none=False,
encoding=None,
bind_and_activate=True):
self.logRequests = logRequests
self.keyfile = keyfile
self.certfile = certfile
self.ssl_version = ssl_version
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
TCPServer.__init__(self, server_address, requestHandler,
bind_and_activate)
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def _dispatch(self, method, auth, response_method, params):
params = (self.auth, response_method, params)
SimpleXMLRPCDispatcher._dispatch(self, method, params)
def __init__(self):
if sys.version[0:3] == '2.4':
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self, False, None)
self.authMethod = None