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