class Server:
def __init__(self, address):
self._rpc_methods_ = ['get', 'put', 'put_back', 'tick', 'keys']
self._data = {}
self._serv = SimpleXMLRPCServer(address, allow_none=True)
for name in self._rpc_methods_:
self._serv.register_function(getattr(self, name))
def get(self, key):
return self._data[key]
def put(self, key, value):
self._data[key] = value
def put_back(self, key, value):
pass
def tick(self):
pass
def keys(self):
return list(self._data)
def serve_forever(self):
self._serv.serve_forever()
class SchedServer(object):
def __init__(self, ip="localhost", port=8000):
self.sched = scheduler.Scheduler()
self.server = SimpleXMLRPCServer((ip, port), requestHandler=RequestHandler)
self.server.register_introspection_functions()
self.serving = 0
self.server.register_function(self.push)
self.server.register_function(self.shutdown)
self.sched.run()
self.server.serve_forever()
def push(self, username, policy_number, code):
user_id = db_session.query(User.id).filter(User.username == username).one()[0]
db_task = Task(user_id, policy_number)
t = task.Task(program.Program(code), username, 3, 1000)
index = self.sched.add(t)
if index == -1:
print("Shutting down")
return -1
db_session.add(db_task)
db_session.commit()
ret_val = self.sched.get(index)
while ret_val is None:
ret_val = self.sched.get(index)
sleep(0.2)
return ret_val
def shutdown(self):
self.sched.join()
class KeyValueServer:
_rpc_methods = ["get", "set", "exists", "delete", "keys"]
def __init__(self, address):
self._data = {}
self._serv = SimpleXMLRPCServer(address, allow_none=True)
for method in self._rpc_methods:
self._serv.register_function(getattr(self, method), method)
def get(self, name):
return self._data["name"]
def set(self, name, value):
self._data["name"] = value
def exists(self, name):
return name in self._data
def delete(self, name):
del self._data["name"]
def keys(self):
# dict_keys is not supported
return list(self._data.keys())
def serve_forever(self):
self._serv.serve_forever()
def main():
# Parse CLI options
import argparse
cli_parser = argparse.ArgumentParser(
description="XML-RPC server for filtering recommendations."
)
# Add verbosity option
cli_parser.add_argument('-v', '--verbose', action='store_true',
help='Be more verbose')
args = cli_parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.INFO)
filterServer = RecFilter()
server = SimpleXMLRPCServer(
(config.filter_server_hostname, config.filter_server_hostport),
allow_none=True)
server.register_introspection_functions()
server.register_function(filterServer.getRecs, 'getrecs')
print("Filter-server is running...")
# Run the server's main loop
server.serve_forever()
def xmlrpc_run(self, port=13100, bind='127.0.0.1', logRequests=False):
'''Run xmlrpc server'''
import umsgpack
try:
from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.client import Binary
except ImportError:
from SimpleXMLRPCServer import SimpleXMLRPCServer
from xmlrpclib import Binary
logger.info("bloomfilter starting...")
server = SimpleXMLRPCServer((bind, port), allow_none=True, logRequests=logRequests)
server.register_introspection_functions()
server.register_multicall_functions()
server.register_function(self.quit, '_quit')
server.register_function(self.add, 'add')
server.timeout = 0.5
while not self._quit:
server.handle_request()
logger.info("bloomfilter exiting...")
server.server_close()
class RPC:
_metodos_rpc = ['get', 'set', 'delete', 'exists', 'keys']
def __init__(self,direccion):
self._datos = {}
self._servidor = SimpleXMLRPCServer(direccion, allow_none=True)
for metodo in self._metodos_rpc:
self._servidor.register_function(getattr(self,metodo))
def get(self, nombre):
return self._datos[nombre]
def set(self, nombre, valor):
self._datos[nombre] = valor
def delete(self, nombre):
del self._datos[nombre]
def exists(self, nombre):
return nombre in self._datos
def keys(self):
return list(self._datos)
def iniciar_servidor(self):
self._servidor.serve_forever()
class KeyValueServer:
_rpc_methods_ = ['get', 'set', 'delete', 'exists', 'keys']
def __init__(self, address):
self._data = {}
self._serv = SimpleXMLRPCServer(address, allow_none=True)
for name in self._rpc_methods_:
self._serv.register_function(getattr(self, name))
def get(self, name):
return self._data[name]
def set(self, name, value):
self._data[name] = value
def delete(self, name):
del self._data[name]
def exists(self, name):
return name in self._data
def keys(self):
return list(self._data)
def serve_forever(self):
self._serv.serve_forever()
class KeyValueServer:
_rpc_methods_ = ['get', 'set', 'delete', 'exists', 'keys']
def __init__(self, address):
self._data = {}
self._serv = SimpleXMLRPCServer(address, allow_none=True)
for name in self._rpc_methods_:
self._serv.register_function(getattr(self, name))
def get(self, name):
return self._data[name]
def set(self, name, value):
self._data[name] = value
def delete(self, name):
del self._data[name]
def exists(self, name):
return name in self._data
def keys(self):
return list(self._data)
def serve_forever(self):
self._serv.serve_forever()
class RPCServer(object):
"""
export_functions = []
export_functions.append((func1, "add"))
export_functions.append((func2, "sub"))
"""
def __init__(self, port=9999, export_functions=[], export_instance=None, name='RPC Server'):
self._port = port
self._started = False
self._export_functions = export_functions
self._export_instance = export_instance
self._name = name
def __del__(self):
self.stop()
@staticmethod
def _rpc_server_thread(rpc_server):
rpc_server._server.serve_forever()
def stop(self):
if self._started:
self._started = False
self._server.shutdown()
self._server.server_close()
def start(self, blocking=True):
if not self._started:
try:
self._server = SimpleXMLRPCServer(('127.0.0.1', self._port), logRequests=False, allow_none=True)
except socket.error as e:
pass
else:
self._server.register_multicall_functions()
for func in self._export_functions:
self._server.register_function(func[0], func[1])
if self._export_instance is not None:
self._server.register_instance(self._export_instance)
self._started = True
if not blocking:
self._thread = threading.Thread(target=RPCServer._rpc_server_thread, args=(
self,), name='%s thread' % self._name)
self._thread.daemon = True
self._thread.start()
else:
RPCServer._rpc_server_thread(self)
return self._started
def get_listening_port(self):
return self._port
def is_started(self):
return self._started
def wait_stopped(self):
if hasattr(self, '_thread'):
while self._thread.is_alive():
self._thread.join(1)
def main(argv):
if argv is None:
argv = sys.argv
# read from config and serve
s = SimpleXMLRPCServer(("", 8888))
s.register_function(execute)
s.serve_forever()
def serve():
server = SimpleXMLRPCServer(('0.0.0.0', 20000))
server.register_function(start_redis)
try:
print('Use Control-C to exit')
server.serve_forever()
except KeyboardInterrupt:
print('Exiting')
def rpcserver():
server = SimpleXMLRPCServer(('localhost', 8000), requestHandler=TestRequestHandler)
server.register_introspection_functions()
server.register_function(pow)
server.register_function(adder_func, 'add')
server.register_instance(TestRPCClass())
server.serve_forever()
def run():
server = SimpleXMLRPCServer(("localhost", 22234),
requestHandler=RequestHandler,
logRequests=False)
server.register_introspection_functions()
server.register_function(translate, 'translate')
# Run the server's main loop
server.serve_forever()
def xmlrpc_server(): # XMLを交換形式とするRPC関数を提供するサーバー
from xmlrpc.server import SimpleXMLRPCServer
def double(num): # RPC関数として提供される
return num * 2
server = SimpleXMLRPCServer(("localhost", 6789)) # localhost:6789でサーバーを起動
server.register_function(double, "double") # double関数を登録
server.serve_forever() # リクエストのハンドルを開始
def serve():
logger.info("Started serving.")
from xmlrpc.server import SimpleXMLRPCServer
from . import config
net_address = config.get_config_for_key("Telescope Address")
server = SimpleXMLRPCServer(("0.0.0.0", net_address.get("Port")))
server.register_function(front_desk, "front_desk")
server.serve_forever()
def _start_rpc_server(self):
def is_bluenet_connected():
return self._ble_peripheral.is_connected
server = SimpleXMLRPCServer(('127.0.0.1', 6459),
requestHandler=RequestHandler)
server.register_function(is_bluenet_connected)
logger.info("Starting RPC server")
server.serve_forever()
class RPCThread(QThread):
def run(self):
# sleep a little bit to make sure QApplication is running.
self.sleep(1)
print("--- starting server…")
self.rpcserver = SimpleXMLRPCServer((cfg.host, cfg.port))
self.rpcserver.register_function(hello)
self.rpcserver.serve_forever()
def main():
server = SimpleXMLRPCServer(("localhost", PORT))
print("We've got a connection and are listening on port {}...huzzah".format(PORT))
# 注册函数,这样它可以被即将创建的客户端代码使用
server.register_function(square, "square")
# 启动服务器
server.serve_forever()
def test_exposeFunction2(self):
"""Expose a function using a different name via XML-RPC."""
server = SimpleXMLRPCServer((HOST, PORT + 2))
server.register_function(multiply, "mult")
ServerThread(server).start()
# Access the exposed service.
client = xmlrpc.client.ServerProxy("http://%s:%d" % (HOST, PORT + 2))
self.assertEqual(client.mult(7, 11), 77)
def test_exposeFunction2(self):
"""Expose a function using a different name via XML-RPC."""
server = SimpleXMLRPCServer((HOST, PORT + 2))
server.register_function(multiply, "mult")
ServerThread(server).start()
# Access the exposed service.
client = xmlrpc.client.ServerProxy("http://%s:%d" % (HOST, PORT + 2))
self.assertEqual(client.mult(7, 11), 77)
def test_exposeFunction1(self):
"""Expose a function via XML-RPC."""
server = SimpleXMLRPCServer((HOST, PORT + 1))
server.register_function(multiply)
ServerThread(server).start()
# Access the exposed service.
client = xmlrpc.client.ServerProxy("http://%s:%d" % (HOST, PORT + 1))
self.assertEqual(client.multiply(5, 10), 50)
def buildServer():
"""build an XMLRPC Server and serve forever \
waiting for problem to submit.
"""
global config
server = SimpleXMLRPCServer((config.get("XMLRPCServer","host"), \
config.getint("XMLRPCServer","port")))
server.register_function(receive, "send")
server.serve_forever()
def test_exposeFunction1(self):
"""Expose a function via XML-RPC."""
server = SimpleXMLRPCServer((HOST, PORT + 1))
server.register_function(multiply)
ServerThread(server).start()
# Access the exposed service.
client = xmlrpc.client.ServerProxy("http://%s:%d" % (HOST, PORT + 1))
self.assertEqual(client.multiply(5, 10), 50)
class ServerRPCMain:
def __init__(self, ip, puerto, tipo="main"):
self.server = SimpleXMLRPCServer((ip, puerto),
requestHandler=RequestHandler)
self.server.register_introspection_functions()
self.ip = ip
self.puerto = puerto
self.tipo = tipo
self.servers = {}
def menu(self):
return "---Operaciones---\n- suma - aplica valor1+valor2\n- resta - aplica valor1-valor2\n- multi - aplica valor1*valor2\n- div - aplica valor1/valor2\nDebe indicarse servidor, version, valor1, valor2, valor3, valor4\n la versión 1 es operación binarin, la 2 es de 3 valores y la 3 es de 4 valores"
def runServer(self):
print("corriendo server de tipo {}".format(self.tipo))
if self.tipo == "main":
print("conectado a servidores externos")
for i in ["suma", "resta", "multi", "div"]:
ipServer = str(
input("Ingrese la ip del server de {} -> ".format(i)))
puertoServer = str(
input("ingrese el puerto del server de {} -> ".format(i)))
print("server IP:", ipServer, i)
print("server port:", puertoServer, i)
self.servers[i] = xmlrpc.client.ServerProxy("http://" +
ipServer + ":" +
puertoServer)
print(
"Servidores conectados, iniciando servidor de comunicación media"
)
print("Server iniciado")
self.server.register_function(self.soliOP, 'op')
self.server.register_function(self.menu, 'menu')
self.server.serve_forever()
def soliOP(self, server, version, values):
print(
"Solicitando operación de los valores {} al servidor {}, versión {}"
.format(values, server, version))
if (server in [*self.servers]):
if (version + 1 == len(values) and len(values) > 1):
if (len(values) == 2):
value1, value2 = values
print("valores", value1, value2)
return self.servers[server].op1(value1, value2)
elif (len(values) == 3):
value1, value2, value3 = values
return self.servers[server].op2(value1, value2, value3)
elif (len(values) == 4):
value1, value2, value3, value4 = values
return self.servers[server].op3(value1, value2, value3,
value4)
return "Formato incorrecto"
else:
return "el servidor {} No existe".format(server)
def start_srv(de0srv):
try:
from xmlrpc.server import SimpleXMLRPCServer
srv = SimpleXMLRPCServer(('', 0xDE0))
srv.register_function(lambda cmd: call_de0(de0srv, cmd), 'call_de0')
srv.allow_none = True
srv.logRequests = False
srv.serve_forever()
except:
pass
def main():
server = SimpleXMLRPCServer(("127.0.0.1", 8080))
server.register_function(is_prime)
server.register_function(is_pairwise_primes)
server.register_function(is_relative_primes)
server.register_function(get_next)
server.register_function(get_prev)
server.register_function(get_random_prime_array)
server.register_function(get_random_prime_number)
server.serve_forever()
def test_exposeLambda(self):
"""Expose a lambda function via XML-RPC."""
# Create a server instance.
server = SimpleXMLRPCServer((HOST, PORT))
server.register_function(lambda x, y: x + y, 'add')
ServerThread(server).start()
# Access the exposed service.
client = xmlrpc.client.ServerProxy("http://%s:%d" % (HOST, PORT))
self.assertEqual(client.add(10, 20), 30)
def test_exposeLambda(self):
"""Expose a lambda function via XML-RPC."""
# Create a server instance.
server = SimpleXMLRPCServer((HOST, PORT))
server.register_function(lambda x, y: x+y, 'add')
ServerThread(server).start()
# Access the exposed service.
client = xmlrpc.client.ServerProxy("http://%s:%d" % (HOST, PORT))
self.assertEqual(client.add(10, 20), 30)
def main():
server = SimpleXMLRPCServer(("localhost", PORT))
print(
"We've got a connection and are listening on port {}...huzzah".format(
PORT))
# 注册函数,这样它可以被即将创建的客户端代码使用
server.register_function(square, "square")
# 启动服务器
server.serve_forever()
class RemoteAPIServer:
def __init__(self, ip, port):
self.ip = ip
self.port = port
self.server = SimpleXMLRPCServer((self.ip, self.port), allow_none=True)
def register_function(self, func):
self.server.register_function(func)
def start_listen(self):
self.server.serve_forever()
class ServerThread(threading.Thread):
def __init__(self, host="localhost", port=8000):
threading.Thread.__init__(self)
self.host = host
self.port = port
self.localServer = SimpleXMLRPCServer((self.host, self.port), allow_none=True)
def add_function(self, function):
self.localServer.register_function(function, function.__name__)
def run(self):
self.localServer.serve_forever()
class SubAliveSlave:
"""
Class for handling a master's alive pings. If the alive timeouts, we can quit.
"""
def __init__(self):
# print('starting with master alive period', master_alive_period_s)
self.alive_check_period_s = _AlivePeriod_s * 1.5
# last time the master pinged alive
self.prev_alive_ping_time = time.time()
# previously received alive counter
self.prev_alive_cnt = None
# start RPC server for alive ping
self.server = SimpleXMLRPCServer(_RPC_ADDRESS, logRequests=False)
# register alive ping function, to be called by the master process
self.server.register_function(self.alive, 'alive')
# create and start the RPC server in a separate thread
self.rpc_thread = threading.Thread(target=self.server.serve_forever)
self.rpc_thread.start()
# start the periodic timeout checker
self.check_timeout()
def alive(self, alive_cnt: int):
"""
Method to be called via RPC by the master
:param alive_cnt: master increments it modulo _AliveCounterMax
:return: 0, because xmlrpc requires something.
"""
# print('alive received', alive_cnt)
if self.prev_alive_cnt is not None:
if (alive_cnt - self.prev_alive_cnt) not in [1, 1 - _AliveCounterMax]:
print('Invalid alive received.')
self.prev_alive_cnt = alive_cnt
self.prev_alive_ping_time = time.time()
return 0
def check_timeout(self):
"""
Periodic timeout check for the master's alive ping
"""
# print('checking timeout')
if time.time() - self.prev_alive_ping_time >= self.alive_check_period_s:
# timeout, shutdown RPC server and quit.
self.server.shutdown()
print('timeout, closing.')
self.rpc_thread.join(timeout=5)
# time.sleep(2)
exit(0)
else:
pass
# print(' ok')
# reschedule timeout checking
threading.Timer(self.alive_check_period_s, self.check_timeout).start()
class MyXMLRPCServer(Thread):
def __init__(self, nodeAddrHostPort):
Thread.__init__(self)
self.setDaemon(True)
self.server = SimpleXMLRPCServer(nodeAddrHostPort)
print("Listening on port %d ..." % nodeAddrHostPort[1])
self.server.register_function(publisherUpdate, "publisherUpdate")
self.server.register_function(requestTopic, "requestTopic")
self.start()
def run(self):
self.server.serve_forever()
def init_server():
host = sys.argv[1]
port = int(sys.argv[2])
print(host)
print(port)
global localserver
localserver = SimpleXMLRPCServer((host, port))
localserver.register_function(rec_rec)
localserver.register_function(rec_load)
def main():
address = args[1].split(":")
address = (address[0], int(address[1]))
rpc = RPCServer(address, allow_none=True)
for f in (create_file, delete_file, call):
rpc.register_function(f)
print("Listening on %s:%s" % address)
with suppress(KeyboardInterrupt):
rpc.serve_forever()
print("\nBye!")
class ServerThread(threading.Thread):
def __init__(self, node_ip, rpc_port, sys_nodes):
threading.Thread.__init__(self)
#self.localServer = SimpleThreadedXMLRPCServer((node_ip, rpc_port))
self.localServer = SimpleXMLRPCServer((node_ip, rpc_port),
allow_none=True)
self.localServer.register_function(
self.new_node) #just return a string
self.localServer.register_function(self.set_sys_nodes)
self.sys_nodes = sys_nodes
def run(self):
try:
self.localServer.serve_forever()
except KeyboardInterrupt:
print('Closing RPC Server')
def set_sys_nodes(self, sys_nodes):
self.sys_nodes = sys_nodes
def new_node(self, node_data):
node_data = json.loads(node_data)
print('\n\nAdding node to the system\n\n')
sys_nodes_int = [int(n) for n in self.sys_nodes.keys()]
new_node_id = min(sys_nodes_int) - 1
# add data to node_data
node_data['id'] = new_node_id
node_data['rpc_port'] = max(
[v['rpc_port'] for k, v in self.sys_nodes.items()]) + 1
node_data['master_id'] = max(sys_nodes_int)
pub_ports_ka = [
v['publish_ports']['keep_alive']
for k, v in self.sys_nodes.items()
]
pub_ports_m = [
v['publish_ports']['measurement']
for k, v in self.sys_nodes.items()
]
node_data['publish_ports'] = {
'keep_alive': max(pub_ports_ka) + 1,
'measurement': max(pub_ports_m) + 1
}
# add new node_data to syst_nodes
self.sys_nodes[str(new_node_id)] = node_data
# Return the node_id for the newcomer and the sys_nodes dict.
# To stop the server
self.quit = 1
return str(new_node_id) + ';' + json.dumps(self.sys_nodes,
ensure_ascii=False)
def connect(self) -> None:
server = SimpleXMLRPCServer((self.url, self.port))
logger.info(f"Listening on port {self.port}...")
server.register_function(self.get_arduino_pin_status, "arduino_pin_status")
server.register_function(self.get_arduino_dim_pin_status, "arduino_pin_dim_status")
server.register_function(self.get_arduino_status, "arduino_status")
server.register_function(self.get_dimmer_light_value, "dimmer_light_value")
server.register_function(self.test, "GET")
server.register_multicall_functions()
th = threading.Thread(target=server.serve_forever)
th.daemon = True
th.start()
def _start_rpc_server(self):
"""
Starts a XML RPC server that can be used check if this Bluenet instance is connected
to a setup app. (Netwatch won't stop DTNIoTSC in this case)
"""
def is_dtniotsc_connected():
return self._ble_peripheral.is_connected
server = SimpleXMLRPCServer(('127.0.0.1', 6459),
requestHandler=RequestHandler)
server.register_function(is_dtniotsc_connected)
logger.info("Starting RPC server")
server.serve_forever()
def register_function(self,
function: Callable,
name: str = None,
prefix: str = None):
if prefix is not None:
if name is None:
name = function.__name__
prefix = prefix + "_" if not prefix.endswith('_') else prefix
SimpleXMLRPCServer.register_function(self,
function,
name=prefix + name)
else:
SimpleXMLRPCServer.register_function(self, function, name=name)
class ServerThread(threading.Thread):
def __init__(self, host, port):
threading.Thread.__init__(self)
self.localServer = SimpleXMLRPCServer((host, port))
self.localServer.register_function(
addItemtoQueue) #just return a string
self.localServer.register_function(getItemfromDict)
self.localServer.register_function(reloadWorker)
self.localServer.register_function(shutdown)
self.localServer.register_function(Test)
def run(self):
self.localServer.serve_forever()
def start_xmlrpc(bindaddr):
from xmlrpc.server import (SimpleXMLRPCServer,
SimpleXMLRPCRequestHandler)
class handler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/motionwol',)
addr, port = bindaddr.split(':') #long live IPv4
server = SimpleXMLRPCServer((addr, int(port)), allow_none=True, requestHandler=handler)
server.register_introspection_functions()
server.register_function(disable_rules, 'disable')
server.register_function(enable_rules, 'enable')
XmlRpcDispatch(server.fileno()).server = server
def main():
parser = argparse.ArgumentParser()
parser.add_argument('net_dir', help='directory of network weights/params')
parser.add_argument('-p', '--port', help='port to listen on')
parser.add_argument('-i', '--interface', help='inteface to listen on')
parser.add_argument(
'-m',
'--model',
help='model to use, may be "rcnn" or "unet" or "multiclass"',
default="unet")
args = parser.parse_args()
server = SimpleXMLRPCServer(
(get_ip(args.interface if args.interface else 'eth0'),
int(args.port if args.port else 8000)))
if args.model == 'rcnn':
server.register_function(DetectionWorkerMRCNN(args.net_dir),
"detect_bbox")
elif args.model == 'multiclass':
server.register_function(MulticlassDetectionWorkerMRCNN(args.net_dir),
"detect_bbox")
elif args.model == 'detectron':
server.register_function(DetectionWorkerDetectron(args.net_dir),
"detect_bbox")
else:
server.register_function(DetectionWorker(args.net_dir), "detect_bbox")
try:
server.serve_forever()
except KeyboardInterrupt:
pass
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-p",
"--port",
type=int,
default=8000,
help="listen port")
args = parser.parse_args()
port = args.port
server = SimpleXMLRPCServer(("0.0.0.0", port), allow_none=True)
server.register_function(run_python_code)
server.register_function(lambda: 'pong', 'ping')
server.register_function(lambda x, y: x + y, 'add')
server.register_function(lambda: os.kill(os.getpid(), signal.SIGTERM),
'quit')
# server.register_function(_connect, "connect")
server.register_multicall_functions()
print(f'Serving XML-RPC on localhost port {port}')
try:
server.serve_forever()
except KeyboardInterrupt:
print("\nKeyboard interrupt received, exiting.")
class RPCServer:
def __init__(self, addr, port, peer):
self.peer = peer
self._server = SimpleXMLRPCServer((addr, port))
self._server.register_function(self.peer.append_entry, "append_entry")
self._server.register_function(self.peer.request_vote, "request_vote")
def start(self):
server_thread = threading.Thread(target=self._server.serve_forever)
server_thread.daemn = True
server_thread.start()
def close(self):
self._server.shutdown()
self._server.server_close()
def start_server():
print('Intializing NLP engine... (this may take a while)')
nlp.init()
print('Starting HTTP server at <http://localhost:{port}>.'.format(port=PORT))
if not fork_and_daemonize():
exit(0)
server = SimpleXMLRPCServer(('localhost', PORT), allow_none=True)
server.register_function(ping)
server.register_function(query)
try:
server.serve_forever()
except:
server.server_close()
class DebugStubComm(object):
def __init__(self, stub, port):
self.stub = stub
addr = "0.0.0.0"
self.server = SimpleXMLRPCServer((addr, port))
self.server.register_function(self.handshake)
self.server.register_function(self.get_agent_list)
self.server.register_function(self.track_agent)
self.server.register_function(self.get_agent_track)
def start_service(self):
self.server.serve_forever()
###########################################################################
# client side api
###########################################################################
def get_agent_list(self):
self.stub.lock.acquire()
l = [i for i in self.stub.agents]
self.stub.lock.release()
return l
def handshake(self):
return True
def track_agent(self, agent_id, on_off):
self.stub.lock.acquire()
if agent_id not in self.stub.agents:
self.stub.lock.release()
return False
agent = self.stub.agents[agent_id]
agent.tracked = on_off
self.stub.lock.release()
return True
def get_agent_track(self, agent_id):
self.stub.lock.acquire()
if agent_id not in self.stub.agents:
self.stub.lock.release()
return False
agent = self.stub.agents[agent_id]
ret = agent.history
agent.history = []
self.stub.lock.release()
return ret
def set_breakpoint(self, agent_id, location_info):
pass
def remove_breakpoint(self, agent_id, location_info):
pass
def continue_agent(self, agent_id):
pass
def main():
parser = learn.get_argparser()
args = parser.parse_args()
brownclusters.set_paths_file(args.clusterfn)
triple_sentences = learn.load_bitext(args)
tl_sentences = learn.get_target_language_sentences(triple_sentences)
sl_sentences = [s for (s,t,a) in triple_sentences]
tagged_sentences = [list(zip(ss, ts))
for ss,ts in zip(sl_sentences, tl_sentences)]
learn.set_examples(sl_sentences,tagged_sentences)
# Create server
server = SimpleXMLRPCServer(("localhost", 8000),
requestHandler=RequestHandler)
server.register_introspection_functions()
server.register_function(label_sentence)
print("SERVER IS NOW ON IT.")
server.serve_forever()
def start_driverdb_server(correct_protocol=True):
'''Create XML-RPC driver db server.
This will listen on localhost:8080 and serve fake_db. This must be
terminated with stop_driverdb_server().
If correct_protocol is False, this will answer with a bogus protocol
version.
'''
start_driverdb_server.pid = os.fork()
if start_driverdb_server.pid == 0:
try:
s = SimpleXMLRPCServer(('localhost', 8080), logRequests=False)
s.register_introspection_functions()
if correct_protocol:
s.register_function(xmlrpc_driverdb_query, 'query')
else:
s.register_function(xmlrpc_driverdb_query_bogus, 'query')
s.serve_forever()
except:
sys.stderr.write('********** DEMO XML-RPC server failed: ***********\n')
traceback.print_exc()
os._exit(1)
# wait until it is ready
c = ServerProxy('http://localhost:8080')
timeout = 100
while timeout > 0:
time.sleep(0.1)
try:
c.query('0', '0', {})
except socket.error:
timeout -= 1
continue
break
if timeout == 0:
raise SystemError('XML-RPC demo server did not start')
def main():
server = SimpleXMLRPCServer(('127.0.0.1', 7001))
server.register_introspection_functions()
server.register_multicall_functions()
server.register_function(addtogether)
server.register_function(quadratic)
server.register_function(remote_repr)
print("Server ready")
server.serve_forever()
class RPCBot(ChatBot):
def __init__(self, *args, **kwargs):
super(RPCBot, self).__init__(*args, **kwargs)
self.lock = threading.RLock()
with self.lock:
self._pending_messages = []
self.start_rpc_server()
def run_pending(self):
with self.lock:
messages = copy.deepcopy(self._pending_messages)
self._pending_messages.clear()
for message in messages:
channel_id = self.broker.channel_id(message['channel'])
self.broker.post(
message['text'],
channel_id=channel_id,
)
def post(self, message):
with self.lock:
self._pending_messages.append(message)
def start_rpc_server(self):
def post_handler(channel, text):
self.post({
'channel': channel,
'text': text,
})
return True
self.server = SimpleXMLRPCServer(("localhost", 34278))
self.server.register_introspection_functions()
self.server.register_function(post_handler, 'post')
self.rpc_thread = threading.Thread(target=self.server.serve_forever)
self.rpc_thread.daemon = True
self.rpc_thread.start()
class RequestHandler(ThreadingMixIn, SimpleXMLRPCRequestHandler):
'''A (very) simple threaded XMLRPC server that accepts file
uploads from client instances.
'''
def __init__(self, ip, port, lock, logger, data_dir):
self.logger = logger
self.data_dir = data_dir
try:
self.server = SimpleXMLRPCServer((ip, port), logRequests=False)
except Exception as e:
self.logger.critical('The XMLRPC server won\'t start: %s', e)
sys.exit(1)
# A synchronization variable so we're not fighting with clients over files
# in the data directory
self.lock = lock
# This method gives us a way to check connectivity for clients
self.server.register_introspection_functions()
self.server.register_function(self.server_receive_file, 'server_receive_file')
if not os.path.exists(self.data_dir):
try:
os.makedirs(self.data_dir)
except OSError as e:
self.logger.critical('ERROR: XMLRPC server unable to create data directory: %s', e)
sys.exit(1)
try:
self.server.serve_forever()
except KeyboardInterrupt:
self.logger.info('XMLRPC server exiting normally in response to KILL signal')
sys.exit(0)
def server_receive_file(self, filename, contents):
self.logger.info('XMLRPC server received file from upstream client %s', filename.split('_')[0].replace('-', '.'))
self.lock.acquire()
with open(self.data_dir + '/' + filename, "wb") as handle:
handle.write(contents.data)
self.lock.release()
return True
def start_receiver(self, port):
server = SimpleXMLRPCServer(('localhost', port), requestHandler=RequestHandler)
# listen messages to this node
# the messages that this receiver serves
server.register_function(append_entries)
server.register_function(request_vote)
server.register_function(ping)
print('serving on ', self.port)
server.serve_forever()
if not type(message) is str: message = jsdumps(message)
subject, message = map(b64enc, (subject, message))
return bitmessage.sendMessage(toaddress, fromaddress, subject, message)
# Get a list of all new messages
from json import loads as jsloads
def receive():
messages = []
inbox = jsloads(bitmessage.getAllInboxMessages())['inboxMessages']
for msgid in (m['msgid'] for m in inbox):
message = jsloads(bitmessage.getInboxMessageByID(msgid))['inboxMessage'][0]
subject, message = map(b64dec, (message['subject'], message['message']))
messages.append({'subject': subject, 'message': message})
bitmessage.trashMessage(msgid)
return messages
# Serve RPC
from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.server import SimpleXMLRPCRequestHandler
server = SimpleXMLRPCServer(("127.0.0.1", 6712), requestHandler=SimpleXMLRPCRequestHandler)
server.register_introspection_functions()
server.register_function(send, 'send')
server.register_function(receive, 'receive')
try:
server.serve_forever()
except KeyboardInterrupt:
from sys import exit
exit(0)
import os
from xmlrpc.server import SimpleXMLRPCServer
from globals import host, port
from document import DocumentManager
server_document_location = '../../user_documents'
def receive_file(filename, results, is_public=False):
file_location = os.path.join(server_document_location, filename)
with open(file_location, 'wb') as f:
f.write(results.data)
return DocumentManager().add(filename, filesize=os.stat(file_location).st_size, is_public=is_public)
def list_public():
return DocumentManager().list_public()
server = SimpleXMLRPCServer((host, port), allow_none=True)
print('{host} running on {port}...'.format(host=host, port=port))
print('Archive directory: {archive_location}'.format(archive_location=os.path.abspath(server_document_location)))
server.register_function(receive_file, 'upload')
server.register_function(list_public)
server.serve_forever()
RPIO.output(down_pin, 0)
except:
pass
time.sleep(1)
def stop_all():
try:
RPIO.output(up_pin, 1)
RPIO.output(down_pin, 1)
RPIO.cleanup()
except:
pass
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/RPC2',)
# Create server
server = SimpleXMLRPCServer(("192.168.0.100", 44444), requestHandler=RequestHandler, allow_none=True)
server.register_introspection_functions()
#registred functions
server.register_function(move)
server.register_function(stop_all)
# Run the server's main loop
server.serve_forever()
from xmlrpc.server import SimpleXMLRPCServer
def echo(x):
return x
server = SimpleXMLRPCServer(('localhost',10002))
server.register_function(echo)
server.serve_forever()
filename = '../resources/airports.dat'
host = 'localhost'
port = 8052
def get_airport(abbr):
results = 'not found'
try:
with open(filename, encoding='utf8') as f:
try:
headings = f.readline().strip()[1:].split(',') # [1:] is stripping the \ufeff byte order mark out.
tuple_attributes = ' '.join([heading.strip() for heading in headings])
Airport = collections.namedtuple('Airport', tuple_attributes)
for row in csv.reader(f):
airport = Airport(*row)
if abbr.upper() in airport.IATA_FAA:
results = '{name} ({city}, {country}) Abbr: {IATA_FAA}'.format(**airport.__dict__)
except csv.Error as e:
print('Error: {err}'.format(err=e))
except IOError as err:
print('Error with {fn}: {err}'.format(fn=filename, err=err))
return results
server = SimpleXMLRPCServer((host, port))
print('{host} running on {port}...'.format(host=host, port=port))
server.register_function(get_airport, 'search_airport')
server.serve_forever()
def _create_rpc_server(self):
server = SimpleXMLRPCServer((self._host, self._port), allow_none=True)
server.register_function(self.change_tasks)
server.register_function(self.add_task)
return server
if new_hash == old_hash:
return True
else:
with open(DATASTORE_CFG, 'w') as file:
file.write(datastore_cfg)
# reload uWSGI
with open(RELOAD_PATH, 'a'):
os.utime(RELOAD_PATH, None)
with open(HASH, 'w') as file:
file.write(new_hash)
return True
if __name__ == '__main__':
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/RPC2',)
# Create server
server = SimpleXMLRPCServer(DATASTORE_XMLRPC_SERVER,
requestHandler=RequestHandler)
server.register_introspection_functions()
server.register_function(reload_datastore)
# Run the server's main loop
server.serve_forever()
def main():
autoWait()
ea = ScreenEA()
server = SimpleXMLRPCServer(("localhost", 9000))
server.register_function(is_connected, "is_connected")
server.register_function(wrapper_get_raw, "get_raw")
server.register_function(wrapper_get_function, "get_function")
server.register_function(wrapper_Heads, "Heads")
server.register_function(wrapper_Functions, "Functions")
server.register_instance(IDAWrapper())
server.register_function(wrapper_quit, "quit")
server.serve_forever()
qexit(0)
