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)