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()
class APIService(threading.Thread):
@trace
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")
@trace
def run(self):
cbdebug("API Service waiting for requests...")
self.server.serve_forever()
cbdebug("API Service shutting down...")
@trace
def stop(self):
cbdebug("Calling API Service shutdown....")
self._stop.set()
self.server.shutdown()
def __init__(self, *args, **kwds):
kwds['allow_none'] = True
kwds['logRequests'] = False
DocXMLRPCServer.__init__(self, *args, **kwds)
self.set_server_title('Brain XML RPC server')
self.set_server_name('Brain XML RPC server methods')
self.set_server_documentation("Keyword arguments should be passed in the last " +
"parameter to function as a dictionary. If there are no keyword parameters, " +
"empty dictionary should be passed.")
# registering multicall function manually, because we should
# remove keyword argument before calling it
multicall = _KeywordFunction(self.system_multicall)
multicall.__doc__ = "XML RPC multicall support"
self.register_function(multicall, 'system.multicall')
class XMLRPC_Server(threading.Thread):
def __init__(self, relays, stream, sensors, leds):
self.relays = relays
self.stream = stream
self.sensors = sensors
self.leds = leds
threading.Thread.__init__(self)
self.start()
def stop(self):
self.server.shutdown()
self.server.server_close()
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()
# XMLRPC methods
def get_status(self):
status = {
"sensors": self.sensors.getSensorsJSON(),
"leds": [{
"mode": "static",
"r": 1.0,
"g": 1.0,
"b": 1.0
}],
"relays": {},
"streaming": self.stream.isOn()
}
# Insert relay status
for r in self.relays.devices:
status["relays"][r] = self.relays.getDeviceState(r)
return status
def set_device(self, id, value):
if value:
self.relays.turnOnDevice(id)
else:
self.relays.turnOffDevice(id)
return self.get_status()
def turn_on_device(self, id):
self.relays.turnOnDevice(id)
return self.get_status()
def turn_off_device(self, id):
self.relays.turnOffDevice(id)
return self.get_status()
def toggle_device(self, id):
self.relays.toggleDevice(id)
return self.get_status()
def turn_on_stream(self):
self.stream.start()
def turn_off_stream(self):
self.stream.stop()
def toggle_stream(self):
if self.stream.isOn():
self.stream.stop()
else:
self.stream.start()
def set_leds_color(self, id, color):
print("Setting LEDS color ", color)
self.leds.setColor(color)
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
serv.register_function(add)
serv.register_function(lambda x, y: x - y)
while numrequests > 0:
serv.handle_request()
numrequests -= 1
except socket.timeout:
pass
finally:
serv.server_close()
PORT = None
evt.set()
def make_server():
serv = DocXMLRPCServer(("localhost", 0), logRequests=False)
try:
# 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())
return serv
except:
serv.server_close()
raise
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 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 register_instance(self, inst): DocXMLRPCServer.register_instance(self, _KeywordInstance(inst))
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')
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 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'
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()