def run(self): class RequestHandler(DocXMLRPCRequestHandler): rpc_paths = ('/AtlantisRPC', ) def do_OPTIONS(self): self.send_response(200) self.end_headers() # Add these headers to all responses def end_headers(self): self.send_header( "Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept") self.send_header("Access-Control-Allow-Origin", "*") DocXMLRPCRequestHandler.end_headers(self) self.server = DocXMLRPCServer( (GlobalConfig.xmlrpc_host, GlobalConfig.xmlrpc_port), requestHandler=RequestHandler) self.server.set_server_title("Atlantis RPCXML server") self.server.set_server_name("Atlantis RPCXML server") self.server.set_server_documentation( "Atlantis RPCXML server documentation") self.server.register_introspection_functions() self.server.register_function(self.get_status) self.server.register_function(self.set_device) self.server.register_function(self.turn_on_device) self.server.register_function(self.turn_off_device) self.server.register_function(self.toggle_device) self.server.register_function(self.turn_on_stream) self.server.register_function(self.turn_off_stream) self.server.register_function(self.toggle_stream) self.server.register_function(self.set_leds_color) self.server.serve_forever()
def serve(): logger.info("Started serving.") from xmlrpc.server import DocXMLRPCServer from xmlrpc.server import DocXMLRPCRequestHandler from . import config # A request handler that responds appropriately for CORS and preflight class CORSRequestHandler(DocXMLRPCRequestHandler): def do_OPTIONS(self): self.send_response(200) self.end_headers() # Add these headers to all responses def end_headers(self): self.send_header( "Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept", ) self.send_header("Access-Control-Allow-Origin", "*") super().end_headers() net_address = config.get_config_for_key("Scheduler Address") server = DocXMLRPCServer( ("0.0.0.0", net_address.get("Port")), requestHandler=CORSRequestHandler ) server.set_server_title("Scheduler Docs") server.set_server_name("CTMO Scheduler Service") server.set_server_documentation( "The scheduler module exports only the front_desk method through the XML-RPC protocol." ) server.register_function(front_desk) server.serve_forever()
def docxmlrpcserver(title, name, documentation): p = int(os.environ['INITIAL_PORT'] ) # avoid starting the server on the same port by PyExZ3 serv = DocXMLRPCServer(("localhost", p), logRequests=False) serv.set_server_title(title) #"DocXMLRPCServer Test Documentation") serv.set_server_name(name) #"DocXMLRPCServer Test Docs") serv.set_server_documentation( documentation) #"This is an XML-RPC server's documentation") serv.register_introspection_functions() serv.register_multicall_functions() serv.register_function(lambda x, y: x + y) serv.register_instance(DocXMLRPCServer(("localhost", p + 1))) generated = serv.generate_html_documentation() os.environ["INITIAL_PORT"] = str(p + 2) if '<script>' in generated: return 'dangerous' else: return 'safe'
def server(evt, numrequests): serv = DocXMLRPCServer(("localhost", 0), logRequests=False) try: global PORT PORT = serv.socket.getsockname()[1] # Add some documentation serv.set_server_title("DocXMLRPCServer Test Documentation") serv.set_server_name("DocXMLRPCServer Test Docs") serv.set_server_documentation( "This is an XML-RPC server's documentation, but the server " "can be used by POSTing to /RPC2. Try self.add, too.") # Create and register classes and functions class TestClass(object): def test_method(self, arg): """Test method's docs. This method truly does very little.""" self.arg = arg serv.register_introspection_functions() serv.register_instance(TestClass()) def add(x, y): """Add two instances together. This follows PEP008, but has nothing to do with RFC1952. Case should matter: pEp008 and rFC1952. Things that start with http and ftp should be auto-linked, too: http://google.com. """ return x + y def annotation(x: int): """ Use function annotations. """ return x class ClassWithAnnotation: def method_annotation(self, x: bytes): return x.decode() serv.register_function(add) serv.register_function(lambda x, y: x-y) serv.register_function(annotation) serv.register_instance(ClassWithAnnotation()) while numrequests > 0: serv.handle_request() numrequests -= 1 except socket.timeout: pass finally: serv.server_close() PORT = None evt.set()
def simple_server(): def is_even(n): """ 偶数判断 """ return n % 2 == 0 server = DocXMLRPCServer(("localhost", 8000)) server.register_function(pow) server.register_function(lambda x, y: x + y, 'add') server.register_function(is_even, "is_even") server.register_introspection_functions() server.serve_forever()
def __init__(self, pid, passive, active, debug, port, hostname): super(APIService, self).__init__() self._stop = threading.Event() self.pid = pid self.abort = False self.aborted = False self.port = port self.hostname = hostname self.api = API(pid, passive, active, port, debug) cbdebug("Initializing API Service on " + hostname + ":" + str(port)) if debug is None: self.server = AsyncDocXMLRPCServer((self.hostname, int(self.port)), allow_none=True) else: self.server = DocXMLRPCServer((self.hostname, int(self.port)), allow_none=True) self.server.abort = False self.server.aborted = False self.server.set_server_title("API Service (xmlrpc)") self.server.set_server_name("API Service (xmlrpc)") #self.server.register_introspection_functions() self.api.signatures = {} for methodtuple in inspect.getmembers(self.api, predicate=inspect.ismethod): name = methodtuple[0] if name in ["__init__", "success", "error", "migrate"]: continue func = getattr(self.api, name) argspec = inspect.getargspec(func) spec = argspec[0] defaults = [] if argspec[3] is None else argspec[3] num_spec = len(spec) num_defaults = len(defaults) diff = num_spec - num_defaults named = diff - 1 doc = "Usage: " for x in range(1, diff): doc += spec[x] + ", " for x in range(diff, num_spec): doc += spec[x] + " = " + str(defaults[x - diff]) + ", " doc = doc[:-2] self.api.signatures[name] = {"args": spec[1:], "named": named} self.server.register_function(unwrap_kwargs(func, doc), name) # self.server.register_instance(self.api) cbdebug("API Service started")
def make_server(): serv = DocXMLRPCServer(('localhost', 0), logRequests=False) try: serv.set_server_title('DocXMLRPCServer Test Documentation') serv.set_server_name('DocXMLRPCServer Test Docs') serv.set_server_documentation( "This is an XML-RPC server's documentation, but the server can be used by POSTing to /RPC2. Try self.add, too." ) class TestClass(object): def test_method(self, arg): """Test method's docs. This method truly does very little.""" self.arg = arg serv.register_introspection_functions() serv.register_instance(TestClass()) def add(x, y): """Add two instances together. This follows PEP008, but has nothing to do with RFC1952. Case should matter: pEp008 and rFC1952. Things that start with http and ftp should be auto-linked, too: http://google.com. """ return x + y def annotation(x: int): """ Use function annotations. """ return x class ClassWithAnnotation: def method_annotation(self, x: bytes): return x.decode() serv.register_function(add) serv.register_function(lambda x, y: x - y) serv.register_function(annotation) serv.register_instance(ClassWithAnnotation()) return serv except: serv.server_close() raise
if name in cmds: lqs = 'last_{:s}_query'.format(name) lqd = 'last_{:s}_retval'.format(name) lastq = store.get(lqs, 0) if time() - lastq > config.rpyc_cmd_retry_interval: retval = cmds.get(name).exec(**kwargs) store[lqs] = time() store[lqd] = retval else: retval = store[lqd] return retval if __name__ == "__main__": rm = ResourceMonitor() rm.start() with DocXMLRPCServer(('', 8001)) as server_: from disco import DiscoClient from apparatus import get_my_ip dc = DiscoClient() dc.announce('SmartieSlave', 'http://{:s}:{:d}'.format(get_my_ip(), 8001)) server_.register_instance(SmartieSlave()) os.system('systemd-notify --ready') server_.serve_forever()
#!/usr/bin/python3 # Implements a simple XMLRPC server for test purposes # 26.03.2010 Bram from xmlrpc.server import DocXMLRPCServer from xmlrpc.server import DocXMLRPCRequestHandler class RequestHandler(DocXMLRPCRequestHandler): rpc_paths = ('/RPC2', ) server = DocXMLRPCServer(("0.0.0.0", 2720), requestHandler=RequestHandler) # gives access to system.listMethods, system.methodHelp and system.methodSignature server.register_introspection_functions() def reverse(x): return "".join(list(reversed(x))) def get(): return ["Power", "Energy", "Force", "Distance", "Current", "Apple pies"] print("Registering functions") server.register_function(reverse, 'reverse') server.register_function(get, 'get')
if __name__ == '__main__': from xmlrpc.server import DocXMLRPCServer import os from disco import DiscoServer redis_url = os.environ.get('REDIS_URL', 'redis://localhost') instance = DiscoServer(redis_url) with DocXMLRPCServer(('', 8888), allow_none=True) as server: server.register_instance(instance) os.system('systemd-notify --ready') server.serve_forever()