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 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 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)
def __init__(self, cache_dir=None): # set up a dispatcher self.dispatcher = SimpleXMLRPCDispatcher(allow_none=True, encoding=None) self.dispatcher.register_function(self.convert_locally, 'convert_locally') self.dispatcher.register_function(self.get_cached, 'get_cached') self.dispatcher.register_introspection_functions() self.cache_dir = cache_dir
def xmlrpc_handle_mp(server_handler, request_text): """ Same as xmlrpc_handle_cgi() but within a mod_python environment. Return a pair of the response and a list of affected unids. """ # create an XMLRPC server handler and bind interface handler = SimpleXMLRPCDispatcher(allow_none=False, encoding=None) handler.register_instance(server_handler) response, error = _exc_marshaled_dispatch(handler, request_text) return response, error, list(server_handler.affected_unids())
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 rpc_handler(request): """ the actual handler: if you setup your urls.py properly, all calls to the xml-rpc service should be routed through here. If post data is defined, it assumes it's XML-RPC and tries to process as such Empty post assumes you're viewing from a browser and tells you about the service. """ #moving this here to see if it will fix the thread leaks dispatcher = SimpleXMLRPCDispatcher(allow_none=False, encoding=None) # Python 2.5 if len(request.POST): dispatcher.register_function(_updateStatus, 'updateStatus') dispatcher.register_function(_setSceneError, 'setSceneError') dispatcher.register_function(_set_scene_unavailable, 'setSceneUnavailable') dispatcher.register_function(_markSceneComplete, 'markSceneComplete') dispatcher.register_function(_getConfiguration, 'getConfiguration') dispatcher.register_function(_getScenesToProcess, 'getScenesToProcess') dispatcher.register_function(_getScenesToPurge, 'getScenesToPurge') dispatcher.register_function(_getSceneInputPath, 'getSceneInputPath') dispatcher.register_function(_getDataSourceCredentials, 'getDataSourceCredentials') #if our leak isn't fixed, try checking to see if we need to close the response here. response = HttpResponse(mimetype="application/xml") response.write(dispatcher._marshaled_dispatch(request.raw_post_data)) else: response = HttpResponse() response.write("<b>This is an XML-RPC Service.</b><br>") response.write("You need to invoke it using an XML-RPC Client!<br>") response.write("The following methods are available:<ul>") methods = dispatcher.system_listMethods() for method in methods: # right now, my version of SimpleXMLRPCDispatcher always # returns "signatures not supported"... :( # but, in an ideal world it will tell users what args are expected sig = dispatcher.system_methodSignature(method) # this just reads your docblock, so fill it in! help = dispatcher.system_methodHelp(method) response.write("<li><b>%s</b>: [%s] %s" % (method, sig, help)) response.write("</ul>") response.write('<a href="http://www.djangoproject.com/"> <img src="http://media.djangoproject.com/img/badges/djangomade124x25_grey.gif" border="0" alt="Made with Django." title="Made with Django."></a>') response['Content-length'] = str(len(response.content)) return response
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 run_in_thread(fn): def run(*k, **kw): try: t = threading.Thread(target=fn, args=k, kwargs=kw) t.start() except: pass return run srv = SimpleXMLRPCDispatcher() ropeProject = None lint = None autoimp = None lock = threading.Lock() class CheckReporter(BaseReporter): __implements____ = IReporter def __init__(self): BaseReporter.__init__(self, sys.stdout) self.messages = [] def add_message(self, msg_id, location, msg): module, object, line, col = location[1:]
from django.db.models import Q from django.http import HttpResponse from django.utils import six from django.views.decorators.csrf import csrf_exempt from localshop.apps.packages import models from localshop.apps.permissions.utils import credentials_required if six.PY2: from SimpleXMLRPCServer import SimpleXMLRPCDispatcher else: from xmlrpc.server import SimpleXMLRPCDispatcher dispatcher = SimpleXMLRPCDispatcher(allow_none=False, encoding=None) @csrf_exempt @credentials_required def handle_request(request): response = HttpResponse(content_type='application/xml') response.write(dispatcher._marshaled_dispatch(request.body)) return response def search(spec, operator='and'): """Implement xmlrpc search command. This only searches through the mirrored and private packages """
class rhui_rpc_server(object): """ Instantiates an XMLRPC Server for the incoming connection. Provides methods for interacting with the platform. """ dispatcher = SimpleXMLRPCDispatcher(allow_none=False, encoding=None) def rpc_handler(self, request): if len(request.POST): response = HttpResponse(mimetype="application/xml") response.write( rhui_rpc_server.dispatcher._marshaled_dispatch( request.raw_post_data)) ## DEBUG #methods = rhui_rpc_server.dispatcher.system_listMethods() #print "Incoming XMLRPC connection." #print "Available methods: " + str(methods) else: response = HttpResponse() response.write( "<b>This is an XMLRPC Service to Cockfosters.</b><br>") response.write("You need to invoke it using an XMLRPC client.<br>") response.write("The following methods are available:<ul>") methods = rhui_rpc_server.dispatcher.system_listMethods() for method in methods: sig = rhui_rpc_server.dispatcher.system_methodSignature(method) help = rhui_rpc_server.dispatcher.system_methodHelp(method) response.write("<li><b>%s</b>: [%s] %s" % (method, sig, help)) response.write("</ul>") response['Content-length'] = str(len(response.content)) return response def commit_data(partner_name_val, partner_contact_val, end_user_name_val, end_user_country_val, end_user_postal_code_val, end_user_contact_val, uuid_val, hostname_val, cpus_val, sys_info_val, ent_virtual_val, ent_cluster_val, ent_lvs_val, ent_resilient_val, ent_scalable_val, ent_hpn_val, virtual_guests_val): """ Commits data from the client into the RHUI usage database """ entry = usage_data(partner_name=str(partner_name_val), partner_contact=str(partner_contact_val), end_user_name=str(end_user_name_val), end_user_country=str(end_user_country_val), end_user_postal_code=str(end_user_postal_code_val), end_user_contact=str(end_user_contact_val), uuid=str(uuid_val), hostname=str(hostname_val), cpus=int(cpus_val), sys_info=sys_info_val, ent_virtual=ent_virtual_val, ent_cluster=ent_cluster_val, ent_lvs=ent_lvs_val, ent_resilient=ent_resilient_val, ent_scalable=ent_scalable_val, ent_hpn=ent_hpn_val, virtual_guests=virtual_guests_val) try: entry.save() return True except: return False def db_read(): """ Pulls all of the individual records out of the database """ db_out = usage_data.objects.all() return db_out dispatcher.register_function(commit_data, 'commit_data') dispatcher.register_function(db_read, 'db_read')
from django.http import HttpResponse, HttpResponseBadRequest, HttpResponseRedirect, StreamingHttpResponse from django.shortcuts import get_object_or_404, render from django.template import loader from django.urls import reverse from django.views.decorators.csrf import csrf_exempt from sapphire import CoincidenceQuery, datetime_to_gps from ..histograms import esd from ..histograms.models import NetworkSummary, Summary from ..inforecords.models import Cluster, Station from . import knmi_lightning from .date_generator import single_day_ranges from .forms import CoincidenceDownloadForm, DataDownloadForm dispatcher = SimpleXMLRPCDispatcher() MIME_PLAIN = 'text/plain' MIME_TSV = 'text/tab-separated-values' MIME_XML = 'text/xml' class SingleLineStringIO: """Very limited file-like object buffering a single line.""" def write(self, line): self.line = line @csrf_exempt
"/secret_illuminati_world_domination_plans" ) def decode_request_content(self, data): encoding = self.headers.get("content-encoding", "identity").lower() if encoding != "gzip": self.send_response(501, "encoding %r not supported" % encoding) return SimpleXMLRPCRequestHandler.decode_request_content(self, data) if __name__ == "__main__": server = MultiPathXMLRPCServer(("0.0.0.0", 12345), requestHandler=RequestHandler, allow_none=True, encoding="utf8") random_server = SimpleXMLRPCDispatcher(allow_none=True, encoding="utf8") random_server.register_introspection_functions() random_server.register_instance(RandomServer()) server.add_dispatcher("/random", random_server) file_server = SimpleXMLRPCDispatcher(allow_none=True, encoding="utf8") file_server.register_introspection_functions() file_server.register_instance(FileServer()) server.add_dispatcher("/fileserver", file_server) secret_server = SimpleXMLRPCDispatcher(allow_none=True, encoding="utf8") secret_server.register_introspection_functions() secret_server.register_instance(SecretServer()) server.add_dispatcher("/secret_illuminati_world_domination_plans", secret_server) info_server = SimpleXMLRPCDispatcher(allow_none=True, encoding="utf8")
def __init__(self, instance): """Creates XML RPC dispatcher.""" self.dispatcher = SimpleXMLRPCDispatcher(allow_none=True, encoding=None) self.dispatcher.register_introspection_functions() if instance is not None: self.RegisterInstance(instance)
else: submit.State = unicode(JudgeRes[3][0]) submit.Src = JudgeRes[3][0] submit.Detail = JudgeRes submit.isWait = False submit.save() return True def RPC_GetDataURL(jk, name): if jk != JudgeKey: return False try: Prob = Problem.objects.get(Name=name) except Problem.DoesNotExist: return False if not Prob.Data: return False return [ MD5File(Prob.Data), DataServer + reverse("DataDownland", kwargs={"name": name}) + "?JudgeKey=" + JudgeKey ] XmlRPC = SimpleXMLRPCDispatcher(allow_none=True) XmlRPC.register_function(RPC_GetSubmit, "GetSubmit") XmlRPC.register_function(RPC_PostRes, "PostRes") XmlRPC.register_function(RPC_AddSubmit, "AddSubmit") XmlRPC.register_function(RPC_GetDataURL, "GetDataURL")
## xmlrpc_svc.py # # Author(s): Michael Hrivnak <*****@*****.**> # Sean Myers <*****@*****.**> # Copyright 2008 American Research Institute, Inc. from SimpleXMLRPCServer import SimpleXMLRPCDispatcher from django.http import HttpResponse from pr_services.rpc.service import ServiceManagers import facade import settings import sys if sys.version_info[:2] == (2, 4): dispatcher = SimpleXMLRPCDispatcher() elif sys.version_info[:2] >= (2, 5): dispatcher = SimpleXMLRPCDispatcher(allow_none=True, encoding='utf-8') dispatcher.register_introspection_functions() dispatcher.register_multicall_functions() def gateway(request): response = HttpResponse() if len(request.POST): response = HttpResponse( mimetype="application/xml" ) # Cleaner to reinstantiate than to add seemingly useless else clause response.write(dispatcher._marshaled_dispatch(request.raw_post_data)) elif settings.DEBUG: response.write("<b>This is an XML-RPC Service.</b><br>") response.write("The following methods are available:<ul>")
class BMultiPathXMLRPCServer(PoolMixIn, MultiPathXMLRPCServer): pool = ThreadPoolExecutor(max_workers=100) class calculate: def add(self, x, y): import time time.sleep(10) return x + y def multiply(self, x, y): return x * y def subtract(self, x, y): return abs(x - y) def divide(self, x, y): return x / y server = BMultiPathXMLRPCServer(("localhost", 8088), requestHandler=MultiPathRequestHandler) obj = calculate() d = server.add_dispatcher("/test", SimpleXMLRPCDispatcher()) d.register_instance(obj) print "Listening on port 8088" server.serve_forever()