class DummyROSMaster(Thread): def __init__(self, host_port_addr): Thread.__init__(self) self.setDaemon(True) self.server = SimpleXMLRPCServer(host_port_addr) print('Listening on %s:%d ...' % host_port_addr) self.server.register_function(getSystemState, 'getSystemState') self.server.register_function(registerPublisher, 'registerPublisher') self.server.register_function(registerSubscriber, 'registerSubscriber') # fake calls for "real" ROS node self.server.register_function(requestTopic, 'requestTopic') self.server.register_function(self.request_shutdown, 'request_shutdown') self.quit = False self.host_port_addr = host_port_addr self.start() def request_shutdown(self): self.quit = True return True def run(self): while not self.quit: self.server.handle_request() def shutdown(self): url = "http://{}:{}".format(*self.host_port_addr) s = ServerProxy(url) s.request_shutdown() self.join(timeout=1) if self.is_alive(): raise RuntimeError("DummyROSMaster failed to shutdown.") self.server.server_close()
class Server(threading.Thread): """ Thread for incoming messages (server side of the peer) """ def __init__(self, peer): threading.Thread.__init__(self) self.loop = True self.peer = peer try: self.server = SimpleXMLRPCServer((peer.IPaddr, peer.portno), allow_none=True, logRequests = False) # we change this for not show unnecessary messages self.server.register_instance(self.peer) except Exception as e: print(e) sys.exit(0) def log(self, *msg): print("[%s]" % self.peer.name, *msg) def stop(self): self.server.server_close() self.loop = False def run(self): while self.loop: #self.log("xmlrpc server is handling a request...") self.server.handle_request() self.log("Server Done!")
class MasterServerProcess(multiprocessing.Process): quit = False def __init__(self, myIP, myPortNum, token, ready): multiprocessing.Process.__init__(self) #self.setDaemon(True) self.daemon = True self.server = SimpleXMLRPCServer((myIP, int(myPortNum)), requestHandler=RequestHandler, allow_none=True) self.server.register_introspection_functions() myFuncs = MyFuncs(token, ready) self.funcs = myFuncs self.server.register_instance(myFuncs) def run(self): # self.server.serve_forever() while not self.quit: self.server.handle_request() def stop_server(self): self.quit = True self.server.server_close() print("here") return 0
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 MyXMLRPCServer(Thread): def __init__(self, nodeAddrHostPort): Thread.__init__(self) self.setDaemon(True) self.quit = False self.nodeAddrHostPort = nodeAddrHostPort self.server = SimpleXMLRPCServer( nodeAddrHostPort ) print("Listening on port %d ..." % nodeAddrHostPort[1]) self.server.register_function(publisherUpdate, "publisherUpdate") self.server.register_function(requestTopic, "requestTopic") self.server.register_function(self.request_shutdown, 'request_shutdown') self.start() def request_shutdown(self): self.quit = True return True def run(self): while not self.quit: self.server.handle_request() def shutdown(self): url = "http://{}:{}".format(*self.nodeAddrHostPort) s = ServerProxy(url) s.request_shutdown() self.join(timeout=1) if self.is_alive(): raise RuntimeError("MyXMLRPCServer failed to shutdown.") self.server.server_close()
class TeacherProxy(object): def __init__(self, teacher): self._quit = False self._teacher = teacher self.server = SimpleXMLRPCServer(('0.0.0.0', 8080), logRequests=False, allow_none=True) self.server.register_instance(self, allow_dotted_names=True) Thread(target = self.run).start() def run(self): while not self._quit: self.server.handle_request() def add_winner(self, winner_uuid): self._teacher.add_winner(winner_uuid)
def run(host, port): global should_kill _check_lock() logger.info(f"Starting server on {host}:{port}") _write_url(host, port) server = SimpleXMLRPCServer((host, port), logRequests=False) server.register_function(ping, "ping") server.register_function(kill, "kill") server.register_function(kill, "kill") server.register_function(get_work_unit, "get_work_unit") server.register_function(post_result, "post_result") while not should_kill: server.handle_request()
class PlayerControlProxy(object): def __init__(self, player): self._quit = False self._player = player self.server = SimpleXMLRPCServer( (self._player.host, self._player.port), logRequests=False, allow_none=True) self.server.register_instance(self, allow_dotted_names=True) Thread(target=self.run).start() def run(self): while not self._quit: self.server.handle_request() def player_move(self, output_spec): return self._player.player_move(output_spec) def print_table(self, table_state): self._player.print_table(table_state) def join(self): self._player.add_player() def rejoin_new(self, ai_id='unchanged'): self._player.rejoin_new(ai_id) def rejoin(self, ai_type=0): self._player.rejoin() def get_ai_id(self): return self._player.get_ai_id() def get_ai_type(self): return self._player.get_ai_type() def save_ai_state(self): self._player.save_ai_state() def delete_ai(self): self._player.delete_ai() def quit(self): self._player.server.remove_player(self._player.playerID) self._quit = True self.server.server_close()
class TeacherProxy(object): def __init__(self, teacher): self._quit = False self._teacher = teacher self.server = SimpleXMLRPCServer(('0.0.0.0', 8080), logRequests=False, allow_none=True) self.server.register_instance(self, allow_dotted_names=True) Thread(target=self.run).start() def run(self): while not self._quit: self.server.handle_request() def add_winner(self, winner_uuid): self._teacher.add_winner(winner_uuid)
def run_server(): from xmlrpc.server import SimpleXMLRPCServer from xmlrpc.server import SimpleXMLRPCRequestHandler server = SimpleXMLRPCServer((my_host, my_port), allow_none=True, logRequests=False) server.register_function(delete, 'delete') server.register_function(get, 'get') server.register_function(put, 'put') server.register_function(dump, 'dump') server.register_function(lambda: setattr(server, 'running', False), 'stop') server.running = True while server.running: try: server.handle_request() except BaseException as e: traceback.print_exc(file=sys.stdout) print("server stopped")
def run_server(host, port): from xmlrpc.server import SimpleXMLRPCServer server = SimpleXMLRPCServer((host, port), allow_none=True, logRequests=False) server.register_function(delete, 'delete') server.register_function(get, 'get') server.register_function(put, 'put') server.running = True while server.running: try: server.handle_request() except KeyboardInterrupt: print("Shutting down server") sys.exit(0) except BaseException as e: traceback.print_exc(file=sys.stdout) print("server stopped")
def stat(): import json # cfg_json=json.load(open("./conf/easyhttpbenchmark.conf", "r"),encoding='utf-8') stat_rpc_server = options.stat_rpc_server stat_rpc_port = options.stat_rpc_port svr = SimpleXMLRPCServer((stat_rpc_server, int(stat_rpc_port)), allow_none=True) print(svr) #svr=ThreadXMLRPCServer(("", 4321), allow_none=True) print('started...') svr.register_function(stat_total_req_cnt) svr.register_function(ret_total_req_cnt) svr.register_function(stat_total_res_cnt) svr.register_function(ret_total_res_cnt) svr.register_function(stat_total_err_cnt) svr.register_function(ret_total_err_cnt) svr.register_function(stat_total_nul_cnt) svr.register_function(ret_total_nul_cnt) svr.register_function(shutdown) svr.register_function(set_test_time) svr.register_function(get_test_time) svr.register_function(ret_qps) svr.register_function(stat_total_below_10) svr.register_function(ret_total_below_10) svr.register_function(stat_total_between_10_20) svr.register_function(ret_total_between_10_20) svr.register_function(stat_total_between_20_30) svr.register_function(ret_total_between_20_30) svr.register_function(stat_total_over_30) svr.register_function(ret_total_over_30) svr.register_function(stat_total_res_time) svr.register_function(ret_total_res_time) svr.register_function(ret_avg_res_time) svr.register_function(stat_maxclientnum) svr.register_function(ret_maxclientnum) svr.register_function(stat_clientnum) svr.register_function(ret_clientnum) while not finished: #svr.serve_forever() svr.handle_request() print('exited...')
class Server(object): quit = False def __init__(self, networkConfig=('', 80), methods=[]): self.server = SimpleXMLRPCServer(networkConfig, requestHandler=RequestHandler, allow_none=True, logRequests=False) self.server.register_introspection_functions() self.methods = methods for method in self.methods: self.server.register_function(method) self.server.register_function(self.kill) def kill(self): self.quit = True def run(self): while not self.quit: self.server.handle_request()
class PlayerControlProxy(object): def __init__(self, player): self._quit = False self._player = player self.server = SimpleXMLRPCServer((self._player.host, self._player.port), logRequests=False, allow_none=True) self.server.register_instance(self, allow_dotted_names=True) Thread(target=self.run).start() def run(self): while not self._quit: self.server.handle_request() def player_move(self, output_spec): return self._player.player_move(output_spec) def print_table(self, table_state): self._player.print_table(table_state) def join(self): self._player.add_player() def rejoin_new(self, ai_id="unchanged"): self._player.rejoin_new(ai_id) def rejoin(self, ai_type=0): self._player.rejoin() def get_ai_id(self): return self._player.get_ai_id() def save_ai_state(self): self._player.save_ai_state() def delete_ai(self): self._player.delete_ai() def quit(self): self._player.server.remove_player(self._player.playerID) self._quit = True
class XmlRPCServer(threading.Thread): run_flag = True config = None lock = None def __init__(self, q, lock_obj, config_obj): threading.Thread.__init__(self) self.thread_name = 'XMLRPCServer' self.q = q self.config = config_obj self.lock = lock_obj self.server = SimpleXMLRPCServer((self.config.get( 'rpc-server', 'host'), self.config.getint('rpc-server', 'port')), logRequests=False, allow_none=True) self.server.register_introspection_functions() self.server.register_function(self.shutdown) self.server.register_function(self.test) def run(self): module_logger.debug('Starting ' + self.thread_name) while self.run_flag: self.server.handle_request() def test(self): module_logger.debug('running test') self.lock.acquire() self.q.put('test') self.lock.release() def shutdown(self): module_logger.debug('shutdown') # send close message to other thread self.lock.acquire() self.q.put('shutdown') self.lock.release() # close RPC server self.run_flag = False
class Server(Thread): def __init__(self, host=gethostname(), port=3000): Thread.__init__(self) self._host = host self._port = port self._server = SimpleXMLRPCServer((self._host, self._port)) self._running = False self._dict = None self.start() def set(self, dictionary): self._dict = dictionary def run(self): self._server.register_function(lambda: True, 'ping') def get_var(var_str): d = self._dict if var_str == '': cstr = zlib.compress(pickle.dumps(d, PICKLE_PROTOCOL), 9) else: exec('q = d.' + var_str, locals()) var = q if hasattr(var, 'value'): var = var.value cstr = zlib.compress(pickle.dumps(var, PICKLE_PROTOCOL), 9) return xmlrpclib.Binary(cstr) self._server.register_function(get_var, 'get') self._running = True while self._running: self._server.handle_request() self._server.server_close() def stop(self): self._running = False proxy = xmlrpclib.ServerProxy('http://' + self._host + ':' + str(self._port) + '/') proxy.ping()
class ServidorApp(formClass, baseClass): def __init__(self, parent = None): formClass.__init__(self) baseClass.__init__(self) self.setupUi(self) self.juegoActivo = 0 self.viboras = [] self.timer = QtCore.QTimer() self.btn_terminar = QtGui.QPushButton('Terminar Juego') #boton para terminar el juego self.table.horizontalHeader().setResizeMode(1) self.table.verticalHeader().setResizeMode(1) self.table.setFocusPolicy(0x3) #conectamos a los botones y mas a las funciones adecuadas. self.timer.setInterval(self.spinBox_Wait.value()) self.spinBox_Columnas.valueChanged.connect(self.cambiarTam) self.spinBox_Filas.valueChanged.connect(self.cambiarTam) self.spinBox_Wait.valueChanged.connect(self.cambiarEspera) self.btn_Juego.clicked.connect(self.cambiaEstado) self.btn_Serv.clicked.connect(self.creaServidor) self.btn_terminar.clicked.connect(self.acabaJuego) self.timer.timeout.connect(self.mainloop) self.show() #Cambia la velocidad del juego def cambiarEspera(self): self.timer.setInterval(self.spinBox_Wait.value()) #cambia el numero de colas y filas en la TableWidget def cambiarTam(self): self.table.setRowCount(self.spinBox_Filas.value()) self.table.setColumnCount(self.spinBox_Columnas.value()) #crea el servidor def creaServidor(self): self.server = SimpleXMLRPCServer((self.URL.text(), self.spinBox_Puerto.value()), allow_none=True) self.server.register_function(self.ping) self.server.register_function(self.yo_juego) self.server.register_function(self.cambia_direccion) self.server.register_function(self.estado_del_juego) self.server.timeout = self.spinBox_Timeout.value() if (self.spinBox_Puerto.value() == 0): self.spinBox_Puerto.setValue(self.server.server_address[1]); def ping(self): return "¡Pong!" #agrega una serpiente al juego def yo_juego(self): vib = Vibora() self.viboras.append(vib) return {"id": vib.Id, "color": vib.color} #cambia la direccion de la serpiente especificada def cambia_direccion(self, Id, nDir): for v in self.viboras: if(v.Id == Id): if (v.direccion != nDir-2 and v.direccion != nDir+2): v.direccion = nDir #regresea el estado del juego def estado_del_juego(self): infovib = [] for v in self.viboras: infovib.append({"id": v.Id, "camino": v.cuerpo, "color": v.color}) return {"espera": self.spinBox_Wait.value(),"tamX": self.spinBox_Columnas.value(), "tamY": self.spinBox_Filas.value(), "viboras": infovib} #Cambia el estado del juego def cambiaEstado(self): if self.juegoActivo == 0: #juego no ha comenzado self.btn_Juego.setText("Pausar el juego") self.juegoActivo = 1 self.timer.start() self.btn_terminar.show() self.verticalLayout.addWidget(self.btn_terminar) elif self.juegoActivo == -1: #juego esta en pausa self.btn_Juego.setText("Pausar el juego") self.juegoActivo = 1 self.timer.start() else: #juego esta activo self.btn_Juego.setText("Continuar el juego") self.juegoActivo = -1 self.timer.stop() #Regresa todo al estado original def acabaJuego(self): self.juegoActivo = 0 self.btn_Juego.setText("Inicia Juego") self.verticalLayout.removeWidget(self.btn_terminar) self.btn_terminar.hide() self.table.clear() self.viboras.clear() self.timer.stop() #dibuja las serpientes def dibuja(self): for v in self.viboras: for (x, y) in v.cuerpo: if self.table.item(y, x) == None: #si cae en una celda llena se elimina, si no, entonces se llena. self.table.setItem(y, x, QtGui.QTableWidgetItem()) self.table.item(y, x).setBackground(QtGui.QColor(v.color['r'], v.color['g'], v.color['b'])) else: self.viboras.remove(v) del v break; #actualiza las viboras def actualizaViboras(self): for v in self.viboras: v.actualiza(self.table, self.table.columnCount(),self.table.rowCount()) #loop principal del juego def mainloop(self): if self.juegoActivo == 1: self.server.handle_request() self.table.clear() self.actualizaViboras() self.dibuja()
log_file = os.path.join(self.log_path, 'log_%03d.json' % self.gen_number) json.dump(list(zip(dags, ret)), open(log_file, 'w'), indent=1) self.gen_number += 1 return ret def get_param_sets(self, datafile): """ Returns the set of possible values of parameters for each method based on the given datafile. :param datafile: The name of the dataset for which the parameters should be generated. Some parameters depend e.g. on the number of attributes in the dataset (like the n_components in PCA). :return: The JSON string containing the dictionary of the parameter values for each supported method. """ ds = pd.read_csv(os.path.join('data', datafile), sep=';') num_instances, num_features = ds.shape return method_params.create_param_set(num_features - 1, num_instances) def quit(self): global stop_server stop_server = True if __name__ == '__main__': log_path = sys.argv[1] print('log', log_path) server = SimpleXMLRPCServer(('localhost', 8080)) server.register_instance(DagEvalServer(log_path)) while not stop_server: server.handle_request()
def run(self): global RUNNING RUNNING = True ### server handling all other functions than stop functions. try: server = SimpleXMLRPCServer( (conf.NOVO_daemon_host, conf.NOVO_daemon_port1), requestHandler=RequestHandler, logRequests=False, allow_none=True) server.allow_reuse_address = True except Exception as e: print('error: ', e) ### server handling the stop functions. This is to being able to send stop commands while the "while-loops" are running. try: server2 = SimpleXMLRPCServer( (conf.NOVO_daemon_host, conf.NOVO_daemon_port2), requestHandler=RequestHandler, logRequests=False, allow_none=True) server2.allow_reuse_address = True except Exception as e: print('error:', e) ################################################### #Setting a handle for the PWI2-class in PW_Class.py. #This makes it possible for the server to call the correct functions in PWI2 PWI = PW.PWI4() ################################################### # I define all the functions in PWI as a new function that the server can call them def Initialize(): PWI.__init__() return def ConnectMNT(): cmd = PWI.ConnectMNT() return cmd def ConnectFOC(): cmd = PWI.ConnectFOC() return cmd def DisconnectFOC(): cmd = PWI.DisconnectFOC() return cmd def DisconnectMNT(): cmd = PWI.DisconnectMNT() return cmd def getStatus(): cmd = PWI.getStatus() return cmd def setTargetRaDecJ2000(RA, DEC): cmd = PWI.setTargetRaDecJ2000(RA, DEC) return cmd def setTargetAltAzm(Alt, Azm): cmd = PWI.setTargetAltAzm(Alt, Azm) return cmd def setTargetRaDec(RA, DEC): cmd = PWI.setTargetRaDec(RA, DEC) return cmd def MntMoveRaDecJ2000(): cmd = PWI.MntMoveRaDecJ2000() return cmd def update(): reply = PWI.update() return reply def getALL(): reply = PWI.getALL() return reply def getRA2000(): reply = PWI.getRA2000() return reply def getDEC2000(): reply = PWI.getDEC2000() return reply def getFocuserPos(): reply = PWI.getFocuserPos() return reply def getMNT_CONNECT(): reply = PWI.getMNT_CONNECT() return reply def getFOC_CONNECT(): reply = PWI.getFOC_CONNECT() return reply def getROT_CONNECT(): reply = PWI.getROT_CONNECT() return reply def getIsTrackingOn(): reply = PWI.getIsTrackingOn() return reply def getTemps(): reply = PWI.getTemps() return reply def getRotatorDerotate(): reply = PWI.getRotatorDerotate() return reply def MoveFocuserPos(position): reply = PWI.MoveFocuserPos(position) return reply def FocSTOP(): reply = PWI.FocSTOP() return reply def MntMotorReset(): reply = PWI.MntMotorReset() return reply def checkFormatRaDec(Ra, Dec): PWI.checkFormatRaDec(Ra, Dec) return def checkFormatAltAzm(Alt, Azm): PWI.checkFormatAltAzm(Alt, Azm) return def checkFormatArcsec(Arcsec): PWI.checkFormatArcsec(Arcsec) return def stopTracking(): reply = PWI.stopTracking() return reply def parkMount(): reply = PWI.parkMount() return reply def getRotatorPos(): reply = PWI.getRotatorPos() return reply def MountSTOP(): reply = PWI.MountSTOP() return reply def MntMotorEnable(): reply = PWI.MntMotorEnable() return reply def MntMotorDisable(): reply = PWI.MntMotorDisable() return reply def MntMoveRaDec(): reply = PWI.MntMoveRaDec() return reply def MntMoveAltAzm(): reply = PWI.MntMoveAltAzm() return reply def startTracking(): reply = PWI.startTracking() return reply def LoadPointingModel(filename): reply = PWI.LoadPointingModel(filename) return reply def AddPointToModel(Ra, Dec): cmd = PWI.AddPointToModel(Ra, Dec) return cmd def SavePointingModel(filename): cmd = PWI.SavePointingModel(filename) return cmd def ClearPointingModel(): reply = PWI.ClearPointingModel() return reply def FansON(): reply = PWI.FansON() return reply def FansOFF(): reply = PWI.FansOFF() return reply def Rot_Move(position): reply = PWI.Rot_Move(position) return reply def RotSTOP(): reply = PWI.RotSTOP() return reply def Rot_derotateStart(): reply = PWI.Rot_derotateStart() return reply def Rot_derotateStop(): reply = PWI.Rot_derotateStop() return reply def getTrackingRMSError(): reply = PWI.getTrackingRMSError() return reply def startMntHoming(): reply = PWI.startMntHoming() return reply ########################################################################## register functions for server2 - handling stop commands server2.register_function(FocSTOP) server2.register_function(MountSTOP) server2.register_function(RotSTOP) server2.register_function(stop_server) ##################################################################### register functions for server - operational commands server.register_function(DisconnectMNT) server.register_function(DisconnectFOC) server.register_function(ConnectFOC) server.register_function(ConnectMNT) server.register_function(Initialize) server.register_function(getStatus) server.register_function(MntMoveRaDecJ2000) server.register_function(update) server.register_function(getALL) server.register_function(getRA2000) server.register_function(getDEC2000) server.register_function(getFocuserPos) server.register_function(getMNT_CONNECT) server.register_function(getFOC_CONNECT) server.register_function(getROT_CONNECT) server.register_function(getIsTrackingOn) server.register_function(getTemps) server.register_function(MoveFocuserPos) server.register_function(MntMotorReset) server.register_function(checkFormatRaDec) server.register_function(checkFormatAltAzm) server.register_function(checkFormatArcsec) server.register_function(stopTracking) server.register_function(parkMount) server.register_function(MntMotorEnable) server.register_function(MntMotorDisable) server.register_function(MntMoveRaDec) server.register_function(MntMoveAltAzm) server.register_function(startTracking) server.register_function(LoadPointingModel) server.register_function(AddPointToModel) server.register_function(SavePointingModel) server.register_function(ClearPointingModel) server.register_function(FansON) server.register_function(FansOFF) server.register_function(Rot_Move) server.register_function(Rot_derotateStart) server.register_function(Rot_derotateStop) server.register_function(setTargetRaDecJ2000) server.register_function(setTargetAltAzm) server.register_function(setTargetRaDec) server.register_function(getRotatorPos) server.register_function(getRotatorDerotate) server.register_function(getTrackingRMSError) server.register_function(startMntHoming) server.register_function(stop_server) ##################################################################### #Threading the two servers such that they run on their individual thread. def server2thread(): while RUNNING: server2.handle_request() thread_value = _thread.start_new_thread(server2thread, ()) print('Thread successful') #server2thread() #The server starts taking requests print("Starting handle_request loop...") while RUNNING: server.handle_request()
def run(self): global RUNNING RUNNING = True ### server handling all other functions than stop functions. try: server = SimpleXMLRPCServer( (conf.NOVO_daemon_host, conf.NOVO_daemon_port1), requestHandler=RequestHandler, logRequests=False, allow_none=True) server.allow_reuse_address = True except Exception as e: print('error: ', e) ### server handling the stop functions. This is to being able to send stop commands while the "while-loops" are running. try: server2 = SimpleXMLRPCServer( (conf.NOVO_daemon_host, conf.NOVO_daemon_port2), requestHandler=RequestHandler, logRequests=False, allow_none=True) server2.allow_reuse_address = True except Exception as e: print('error:', e) ## Setup database connection try: dbconn = psycopg2.connect("host=" + conf.dbhost + " dbname=" + conf.dbname + " user="******" password="******"=")[0]: x.split("=")[1] for x in PWI.getALL().split("\n")[:-1] } for key in info.keys(): if info[key] == "true" or info[key] == "false": info[key] = 1 if info[key] == "true" else 0 else: try: info[key] = float(info[key]) except: info[key] = 0 cmd = "UPDATE %s SET value=%f WHERE info_id='%s'" % ( conf.inftable, float(info[key]), key) cursor.execute(cmd) dbconn.commit() if info["mount.is_connected"] == 0: ConnectMNT() command_dict = { "FOLLOW_AZ_ALT": { "nr": 2, "type": int, "func": followAzAlt }, "FOLLOW_RA_DEC": { "nr": 2, "type": str, "func": followRaDec }, "MOVE_AZ_ALT": { "nr": 2, "type": int, "func": gotoAzAlt }, "MOVE_RA_DEC": { "nr": 2, "type": str, "func": gotoRaDec }, "STOP": { "nr": 0, "func": STOP }, "MNT_CON": { "nr": 0, "func": ConnectMNT }, "MNT_DISCON": { "nr": 0, "func": DisconnectMNT }, "PARK": { "nr": 0, "func": parkMount }, "TRACK": { "nr": 0, "func": startTracking }, "STOP_TRACK": { "nr": 0, "func": stopTracking } } def readcoms(): cursor = dbconn.cursor() cmd = "SELECT com_idx,com,timestamp FROM %s WHERE %s.done=false" % ( conf.comtable, conf.comtable) cursor.execute(cmd) commands = cursor.fetchall() for row in commands: com = row[1].split(" ") idx = row[0] tel_com = command_dict.get(com[0], False) tdelta = row[2] - datetime.utcnow() min_delta = abs(tdelta.total_seconds() / 60) if min_delta >= 20: log_str = "Command too old: %.1f minutes" % min_delta print(log_str) cmd = "UPDATE %s SET done=true, log='%s' WHERE com_idx=%i" % ( conf.comtable, log_str, idx) cursor.execute(cmd) dbconn.commit() continue elif not tel_com: log_str = "Command %s not defined" % com[0] print(log_str) cmd = "UPDATE %s SET done=true, log='%s' WHERE com_idx=%i" % ( conf.comtable, log_str, idx) cursor.execute(cmd) dbconn.commit() continue try: print("Executing command now") if tel_com["nr"] > 0: tel_com["func"](*[tel_com["type"](x) for x in com[1:]]) else: tel_com["func"]() cmd = "UPDATE %s SET done=true, log='%s' WHERE com_idx=%i" % ( conf.comtable, "", idx) print("Command done") except Exception as e: cmd = "UPDATE %s SET done=true, log='%s' WHERE com_idx=%i" % ( conf.comtable, "ERROR!", idx) print(e) updatedb() cursor.execute(cmd) dbconn.commit() #################################### ########################################################################## register functions for server2 - handling stop commands server2.register_function(FocSTOP) server2.register_function(MountSTOP) server2.register_function(RotSTOP) server2.register_function(stop_server) ##################################################################### register functions for server - operational commands server.register_function(DisconnectMNT) server.register_function(DisconnectFOC) server.register_function(ConnectFOC) server.register_function(ConnectMNT) server.register_function(Initialize) server.register_function(getStatus) server.register_function(MntMoveRaDecJ2000) server.register_function(update) server.register_function(getALL) server.register_function(getRA2000) server.register_function(getDEC2000) server.register_function(getFocuserPos) server.register_function(getMNT_CONNECT) server.register_function(getFOC_CONNECT) server.register_function(getROT_CONNECT) server.register_function(getIsTrackingOn) server.register_function(getTemps) server.register_function(MoveFocuserPos) server.register_function(MntMotorReset) server.register_function(checkFormatRaDec) server.register_function(checkFormatAltAzm) server.register_function(checkFormatArcsec) server.register_function(stopTracking) server.register_function(parkMount) server.register_function(MntMotorEnable) server.register_function(MntMotorDisable) server.register_function(MntMoveRaDec) server.register_function(MntMoveAltAzm) server.register_function(startTracking) server.register_function(LoadPointingModel) server.register_function(AddPointToModel) server.register_function(SavePointingModel) server.register_function(ClearPointingModel) server.register_function(FansON) server.register_function(FansOFF) server.register_function(Rot_Move) server.register_function(Rot_derotateStart) server.register_function(Rot_derotateStop) server.register_function(setTargetRaDecJ2000) server.register_function(setTargetAltAzm) server.register_function(setTargetRaDec) server.register_function(getRotatorPos) server.register_function(getRotatorDerotate) server.register_function(getTrackingRMSError) server.register_function(startMntHoming) server.register_function(stop_server) ##################################################################### #Threading the two servers such that they run on their individual thread. print("Starting server threds") def server2thread(): while RUNNING: server2.handle_request() thread_value = _thread.start_new_thread(server2thread, ()) print('Thread successful') #Db thread. Updates sql db values def dbthread(): while RUNNING: updatedb() time.sleep(5) thread_value = _thread.start_new_thread(dbthread, ()) print('Update Thread successful') def comthread(): while RUNNING: readcoms() time.sleep(5) thread_value = _thread.start_new_thread(comthread, ()) print('Com Thread successful') #server2thread() #The server starts taking requests print("Starting handle_request loop...") while RUNNING: server.handle_request()
class TCPNode(Node): def __init__(self, id, object, type, port): super().__init__(id) self.portno = port self.type = type self.rname = filename.filename self.host = 'data.cs.purdue.edu' self.object = object def reader(self): return self.object def createProxy(self): self.server.register_function(self.reader, 'reader') def serverStart(self): self.server = SimpleXMLRPCServer((self.host, self.portno)) self.createProxy() print("Listening on port " + str(self.portno) + " ...") self.server.handle_request() ''' Turn on (deploy) the node. ''' def start(self): super().start() def startTCPServer(self): self.server = SimpleXMLRPCServer(("data.cs.purdue.edu", self.portno)) # self.createProxy() # print("Listening on port "+str(self.portno)+" ...") # self.server.handle_request() def startTCPClient(self): self.proxy = xmlrpc.client.ServerProxy("http://" + self.host + ":" + str(self.portno) + "/") ''' Turn off (undeploy) the node. ''' def stop(self, disconnect=True): super().stop() ''' Connect an undeployed node to this one directly through memory. If duplex is true, the given node will also be connected to this one. ''' def connectTCP( self, node ): #TODO: add code to connect to a remote TCPNode at host:port. self._connectConn(node) # Store info in self.conns dict to map the id to the connection object. # Make sure you can internally distinguish between tcp and local conns. def _connectConn(self, node): connRec = self._buildConnRec(node) self.conns[node.id] = connRec def _buildConnRec(self, node): connRec = dict() connRec["line"] = node.inputLine connRec["type"] = node.type return connRec def send(self, id, msg): self._checkNodeOn() try: connRec = self.conns[id] self._send(connRec, msg) except KeyError: raise ValueError("[ProcNode]: Error. ID %s not found." % str(id)) def _send(self, connRec, msg): if connRec["type"] == "TCP": self.object = msg self.createProxy() print("Listening on port " + str(self.portno) + " ...") self.server.handle_request() else: connRec["line"].put(msg) ''' Turn a present connection into a duplex. ''' def duplexify( self, id ): #TODO: All tcp conns are duplexes, so check if id is a tcp node. raise NotImplementedError # If so, ignore the call. else, call super version. super().duplexify(id) ''' Disconnect the node from node1 with given id. If notify is true, node1 will be instructed to disconnect from this node too. ''' def disconnect( self, id, notify=True ): #TODO: If id is a tcp node, disconnect in your own way. else, call super version. raise NotImplementedError super().disconnect(id, notify=notify) ''' Quickly handle all updates on the inputLine. Node msgs are relocated to the msgQueue. ''' def update(self): #TODO: Implement for super version and tcp nodes. raise NotImplementedError super().update() ''' Send a node msg to the node indexed by id. If the id is not connected, raise a ValueError. ''' # def send(self, id, msg): #TODO: Implement for super version and tcp nodes. # raise NotImplementedError # super().send(id, msg) ''' Gets a node msg. If block is true, recv will only return when a msg is found, but will continue to update internally. If block is false, recv will finish updating and either return a found msg or raise Empty. ''' def recv(self, block=True): #TODO: Implement for super version and tcp nodes. print("IN NODE :" + str(self.id)) flag = 0 if self.type == "TCP": self.proxy = xmlrpc.client.ServerProxy("http://" + self.host + ":" + str(self.portno) + "/") dictionary = self.proxy.reader() a1 = c1.CustomObject(**dictionary) print(a1.returnList()) print(a1.returnStr()) print(a1.returnDic()) else: super().recv(block=block) #===============================================================================
class SharedMemoryStoreServer(object): """The graph store server. The server loads graph structure and node embeddings and edge embeddings and store them in shared memory. The loaded graph can be identified by the graph name in the input argument. Parameters ---------- graph_data : graph data Data to initialize graph. Same as networkx's semantics. edge_dir : string the edge direction for the graph structure ("in" or "out") graph_name : string Define the name of the graph, so the client can use the name to access the graph. multigraph : bool, optional Whether the graph would be a multigraph (default: False) num_workers : int The number of workers that will connect to the server. port : int The port that the server listens to. """ def __init__(self, graph_data, edge_dir, graph_name, multigraph, num_workers, port): graph_idx = GraphIndex(multigraph=multigraph, readonly=True) indptr, indices = _to_csr(graph_data, edge_dir, multigraph) graph_idx.from_csr_matrix(indptr, indices, edge_dir, _get_graph_path(graph_name)) self._graph = DGLGraph(graph_idx, multigraph=multigraph, readonly=True) self._num_workers = num_workers self._graph_name = graph_name self._edge_dir = edge_dir # RPC command: get the graph information from the graph store server. def get_graph_info(): return self._graph.number_of_nodes(), self._graph.number_of_edges(), \ self._graph.is_multigraph, edge_dir # RPC command: initialize node embedding in the server. def init_ndata(ndata_name, shape, dtype): if ndata_name in self._graph.ndata: ndata = self._graph.ndata[ndata_name] assert np.all(ndata.shape == tuple(shape)) return 0 assert self._graph.number_of_nodes() == shape[0] data = empty_shared_mem(_get_ndata_path(graph_name, ndata_name), True, shape, dtype) dlpack = data.to_dlpack() self._graph.ndata[ndata_name] = F.zerocopy_from_dlpack(dlpack) return 0 # RPC command: initialize edge embedding in the server. def init_edata(edata_name, shape, dtype): if edata_name in self._graph.edata: edata = self._graph.edata[edata_name] assert np.all(edata.shape == tuple(shape)) return 0 assert self._graph.number_of_edges() == shape[0] data = empty_shared_mem(_get_edata_path(graph_name, edata_name), True, shape, dtype) dlpack = data.to_dlpack() self._graph.edata[edata_name] = F.zerocopy_from_dlpack(dlpack) return 0 # RPC command: get the names of all node embeddings. def list_ndata(): ndata = self._graph.ndata return [[key, F.shape(ndata[key]), np.dtype(F.dtype(ndata[key])).name] for key in ndata] # RPC command: get the names of all edge embeddings. def list_edata(): edata = self._graph.edata return [[key, F.shape(edata[key]), np.dtype(F.dtype(edata[key])).name] for key in edata] # RPC command: notify the server of the termination of the client. def terminate(): self._num_workers -= 1 return 0 self.server = SimpleXMLRPCServer(("localhost", port)) self.server.register_function(get_graph_info, "get_graph_info") self.server.register_function(init_ndata, "init_ndata") self.server.register_function(init_edata, "init_edata") self.server.register_function(terminate, "terminate") self.server.register_function(list_ndata, "list_ndata") self.server.register_function(list_edata, "list_edata") def __del__(self): self._graph = None @property def ndata(self): """Return the data view of all the nodes. DGLGraph.ndata is an abbreviation of DGLGraph.nodes[:].data See Also -------- dgl.DGLGraph.nodes """ return NodeDataView(self._graph, ALL, self._graph_name) @property def edata(self): """Return the data view of all the edges. DGLGraph.data is an abbreviation of DGLGraph.edges[:].data See Also -------- dgl.DGLGraph.edges """ return EdgeDataView(self._graph, ALL, self._graph_name) def run(self): """Run the graph store server. The server runs to process RPC requests from clients. """ while self._num_workers > 0: self.server.handle_request() self._graph = None
def run(self): global RUNNING RUNNING = True ### server handling all other functions than stop functions. try: server = SimpleXMLRPCServer(('localhost', 8000), requestHandler=RequestHandler, logRequests=False,allow_none=True) server.allow_reuse_address = True except Exception as e: print('error: ',e) ### server handling the stop functions. This is to being able to send stop commands while the "while-loops" are running. try: server2 = SimpleXMLRPCServer(("localhost", 9000),requestHandler=RequestHandler,logRequests=False,allow_none=True) server2.allow_reuse_address = True except Exception as e: print('error:',e) ################################################### #Setting a handle for the PWI2-class in PW_Class.py. #This makes it possible for the server to call the correct functions in PWI2 PWI=PW.PWI2() ################################################### # I define all the functions in PWI as a new function that the server can call them def Initialize(): PWI.__init__() return def ConnectMNT(): cmd = PWI.ConnectMNT() return cmd def ConnectFOC(): cmd = PWI.ConnectFOC() return cmd def DisconnectFOC(): cmd = PWI.DisconnectFOC() return cmd def DisconnectMNT(): cmd = PWI.DisconnectMNT() return cmd def getStatus(): cmd = PWI.getStatus() return cmd def setTargetRaDecJ2000(RA,DEC): cmd = PWI.setTargetRaDecJ2000(RA,DEC) return cmd def setTargetAltAzm(Alt,Azm): cmd = PWI.setTargetAltAzm(Alt,Azm) return cmd def setTargetRaDec(RA,DEC): cmd = PWI.setTargetRaDec(RA,DEC) return cmd def MntMoveRaDecJ2000(): cmd = PWI.MntMoveRaDecJ2000() return cmd def getUTC(): reply = PWI.getUTC() return reply def update(): reply = PWI.update() return reply def getALL(): reply = PWI.getALL() return reply def getRA2000(): reply = PWI.getRA2000() return reply def getDEC2000(): reply = PWI.getDEC2000() return reply def getJD(): reply = PWI.getJD() return reply def getFocuserPos(): reply = PWI.getFocuserPos() return reply def getMNT_CONNECT(): reply = PWI.getMNT_CONNECT() return reply def getFOC_CONNECT(): reply = PWI.getFOC_CONNECT() return reply def getROT_CONNECT(): reply = PWI.getROT_CONNECT() return reply def getIsTrackingOn(): reply = PWI.getIsTrackingOn() return reply def getTemps(): reply = PWI.getTemps() return reply def getRotatorDerotate(): reply = PWI.getRotatorDerotate() return reply def MoveFocuserPos(position): reply = PWI.MoveFocuserPos(position) return reply def MoveFocuserInc(Inc): reply = PWI.MoveFocuserInc(Inc) return reply #DOES NOT WORK YET! def FocSTOP(): reply = PWI.FocSTOP() return reply def FocFindHome(): reply = PWI.FocFindHome() return reply def FocAutofocus(): PWI.FocAutofocus() return def AZM_motor_error(): PWI.AZM_motor_error() return def ALT_motor_error(): PWI.ALT_motor_error() return def MntResetMotors(): reply = PWI.MntResetMotors() return reply def checkFormatRaDec(Ra,Dec): PWI.checkFormatRaDec(Ra,Dec) return def checkFormatAltAzm(Alt,Azm): PWI.checkFormatAltAzm(Alt,Azm) return def checkFormatArcsec(Arcsec): PWI.checkFormatArcsec(Arcsec) return def stopTracking(): reply = PWI.stopTracking() return reply def parkMount(): reply = PWI.parkMount() return reply def getRotatorPos(): reply = PWI.getRotatorPos() return reply def MountSTOP(): reply = PWI.MountSTOP() return reply def MntMotorEnable(): reply = PWI.MntMotorEnable() return reply def MntMotorDisable(): reply = PWI.MntMotorDisable() return reply def MntMoveIncRaDec(Ra,Dec): reply = PWI.MntMoveIncRaDec(Ra,Dec) return reply def MntMoveIncAltAzm(Alt,Azm): reply = PWI.MntMoveIncAltAzm(Alt,Azm) return reply def MntMoveRaDec(): reply = PWI.MntMoveRaDec() return reply def MntMoveAltAzm(): reply = PWI.MntMoveAltAzm() return reply def startTracking(): reply = PWI.startTracking() return reply def LoadPointingModel(filename): reply = PWI.LoadPointingModel(filename) return reply #Needs more work! def setTrackingRates(RaRate,DecRate): PWI.setTrackingRates(RaRate,DecRate) return #Does not work yet - is a catapult function currently def JogAltAzm(Alt,Azm): PWI.JogAltAzm(Alt,Azm) return #Does not work - crashes motor and points to -78 deg Alt #Need to send input def SyncMountCoorJ2000(RA,DEC): PWI.SyncMountCoorJ2000(RA,DEC) return def AddPointToModel(Ra,Dec): PWI.AddPointToModel(Ra,Dec) return #Problem: Doesn't save anything at the moment: 28/11/2019 def SavePointingModel(filename): PWI.SavePointingModel(filename) return def FansON(): reply = PWI.FansON() return reply def FansOFF(): reply = PWI.FansOFF() return reply def Rot_Move(position): reply = PWI.Rot_Move(position) return reply def RotSTOP(): reply = PWI.RotSTOP() return reply def Rot_StartHoming(): reply = PWI.Rot_StartHoming() return reply def Rot_derotateStart(): reply = PWI.Rot_derotateStart() return reply def Rot_derotateStop(): reply = PWI.Rot_derotateStop() return reply def Rot_MoveInc(deg): reply = PWI.Rot_MoveInc(deg) return reply def getTrackingRMSError(): reply = PWI.getTrackingRMSError() return reply ########################################################################## register functions for server2 - handling stop commands server2.register_function(FocSTOP) server2.register_function(MountSTOP) server2.register_function(RotSTOP) server2.register_function(stop_server) ##################################################################### register functions for server - operational commands server.register_function(DisconnectMNT) server.register_function(DisconnectFOC) server.register_function(ConnectFOC) server.register_function(ConnectMNT) server.register_function(Initialize) server.register_function(getStatus) server.register_function(MntMoveRaDecJ2000) server.register_function(getUTC) server.register_function(update) server.register_function(getALL) server.register_function(getRA2000) server.register_function(getDEC2000) server.register_function(getJD) server.register_function(getFocuserPos) server.register_function(getMNT_CONNECT) server.register_function(getFOC_CONNECT) server.register_function(getROT_CONNECT) server.register_function(getIsTrackingOn) server.register_function(getTemps) server.register_function(MoveFocuserPos) server.register_function(MoveFocuserInc) server.register_function(FocFindHome) server.register_function(FocAutofocus) server.register_function(AZM_motor_error) server.register_function(ALT_motor_error) server.register_function(MntResetMotors) server.register_function(checkFormatRaDec) server.register_function(checkFormatAltAzm) server.register_function(checkFormatArcsec) server.register_function(stopTracking) server.register_function(parkMount) server.register_function(MntMotorEnable) server.register_function(MntMotorDisable) server.register_function(MntMoveIncRaDec) server.register_function(MntMoveIncAltAzm) server.register_function(MntMoveRaDec) server.register_function(MntMoveAltAzm) server.register_function(startTracking) server.register_function(LoadPointingModel) server.register_function(setTrackingRates) server.register_function(JogAltAzm) server.register_function(SyncMountCoorJ2000) server.register_function(AddPointToModel) server.register_function(SavePointingModel) server.register_function(FansON) server.register_function(FansOFF) server.register_function(Rot_Move) server.register_function(Rot_derotateStart) server.register_function(Rot_derotateStop) server.register_function(Rot_StartHoming) server.register_function(Rot_MoveInc) server.register_function(setTargetRaDecJ2000) server.register_function(setTargetAltAzm) server.register_function(setTargetRaDec) server.register_function(getRotatorPos) server.register_function(getRotatorDerotate) server.register_function(getTrackingRMSError) server.register_function(stop_server) ##################################################################### #Threading the two servers such that they run on their individual thread. def server2thread(): while RUNNING: server2.handle_request() thread_value = _thread.start_new_thread(server2thread,()) print('Thread successful') #server2thread() #The server starts taking requests print("Starting handle_request loop...") while RUNNING: server.handle_request()
class MainWindow(QtGui.QMainWindow): def __init__(self): super(MainWindow, self).__init__() uic.loadUi('servidor.ui', self) self.setStyleSheet("QMainWindow {background-color: #ACE7EF;}") self.pushButton_3.hide() self.pushButton.clicked.connect(self.iniciar_servidor) self.incio = False self.pausado = False self.timer = None self.timer_s = None self.timer_camino = None self.num_snakes = [] self.table() self.pintar_tabla() self.Tabla.setSelectionMode(QtGui.QTableWidget.NoSelection) self.spinBox_2.valueChanged.connect(self.actualiza_tabla) self.spinBox_3.valueChanged.connect(self.actualiza_tabla) self.spinBox.valueChanged.connect(self.actualiza_timer) self.time.valueChanged.connect(self.actualizar_timeout) self.pushButton_2.clicked.connect(self.inicia_juego) self.pushButton_3.clicked.connect(self.terminar_juego) self.show() def inicia_juego(self): if not self.incio: self.pushButton_3.show() self.crear_serpiente() self.pushButton_2.setText("Pausar el Juego") self.dibujar_snakes() self.timer = QtCore.QTimer(self) self.timer.timeout.connect(self.mover_serpientes) self.timer.start(200) self.timer_camino = QtCore.QTimer(self) self.timer_camino.timeout.connect(self.ac_camino) self.timer_camino.start(100) self.Tabla.installEventFilter(self) self.incio = True elif self.incio and not self.pausado: self.timer.stop() self.pausado = True self.pushButton_2.setText("Reanudar el Juego") elif self.pausado: self.timer.start() self.pausado = False self.pushButton_2.setText("Pausar el Juego") def terminar_juego(self): self.num_snakes = [] self.lcdNumber.display(0) self.timer.stop() self.incio = False self.pushButton_3.hide() self.pushButton_2.setText("Inicia Juego") def iniciar_servidor(self): puerto = self.spinBox_4.value() direccion = self.lineEdit.text() self.servidor = SimpleXMLRPCServer((direccion, 0)) puerto = self.servidor.server_address[1] self.spinBox_4.setValue(puerto) self.spinBox_4.setReadOnly(True) self.lineEdit.setReadOnly(True) self.pushButton.setEnabled(False) self.servidor.register_function(self.ping) self.servidor.register_function(self.yo_juego) self.servidor.register_function(self.cambia_direccion) self.servidor.register_function(self.estado_del_juego) self.servidor.timeout = 0 self.timer_s = QtCore.QTimer(self) self.timer_s.timeout.connect(self.hacer) self.timer_s.start(self.servidor.timeout) def cambia_direccion(self, identificador, numero): for s in self.num_snakes: if s.id == identificador: if numero == 0: if s.direccion is not "Abajo": s.direccion = "Arriba" if numero == 1: if s.direccion is not "Izquierda": s.direccion = "Derecha" if numero == 2: if s.direccion is not "Arriba": s.direccion = "Abajo" if numero == 3: if s.direccion is not "Derecha": s.direccion = "Izquierda" return True def estado_del_juego(self): diccionario = dict() diccionario = { 'espera': self.spinBox.value(), 'tamX': self.Tabla.columnCount(), 'tamY': self.Tabla.rowCount(), 'viboras': self.lista_snakes() } return diccionario def crear_serpiente(self): serpiente_nueva = Snake() creada = False while not creada: creada = True uno = randint(1, self.Tabla.rowCount() / 2) dos = uno + 1 tres = dos + 1 ancho = randint(1, self.Tabla.columnCount() - 1) achecar_1, achecar_2, achecar_3 = [uno, ancho], [dos, ancho], [tres, ancho] for s in self.num_snakes: if achecar_1 in s.casillas or achecar_2 in s.casillas or achecar_3 in s.casillas: creada = False break serpiente_nueva.casillas = [achecar_1, achecar_2, achecar_3] self.num_snakes.append(serpiente_nueva) return serpiente_nueva def eventFilter(self, source, event): if (event.type() == QtCore.QEvent.KeyPress and source is self.Tabla): key = event.key() if (key == QtCore.Qt.Key_Up and source is self.Tabla): for serpiente in self.num_snakes: if serpiente.direccion is not "Abajo": serpiente.direccion = "Arriba" elif (key == QtCore.Qt.Key_Down and source is self.Tabla): for serpiente in self.num_snakes: if serpiente.direccion is not "Arriba": serpiente.direccion = "Abajo" elif (key == QtCore.Qt.Key_Right and source is self.Tabla): for serpiente in self.num_snakes: if serpiente.direccion is not "Izquierda": serpiente.direccion = "Derecha" elif (key == QtCore.Qt.Key_Left and source is self.Tabla): for serpiente in self.num_snakes: if serpiente.direccion is not "Derecha": serpiente.direccion = "Izquierda" return QtGui.QMainWindow.eventFilter(self, source, event) def mover_serpientes(self): for serpiente in self.num_snakes: if self.sucidarte(serpiente) or self.te_mataron(serpiente): self.num_snakes.remove(serpiente) self.pintar_tabla() serpiente_1 = self.crear_serpiente() self.num_snakes = [serpiente_1] self.Tabla.item(serpiente.casillas[0][0], serpiente.casillas[0][1]).setBackground( QtGui.QColor(206, 254, 241)) x = 0 for tupla in serpiente.casillas[0:len(serpiente.casillas) - 1]: x += 1 tupla[0] = serpiente.casillas[x][0] tupla[1] = serpiente.casillas[x][1] x if serpiente.direccion is "Abajo": if serpiente.casillas[-1][0] + 1 < self.Tabla.rowCount(): serpiente.casillas[-1][0] += 1 else: serpiente.casillas[-1][0] = 0 if serpiente.direccion is "Derecha": if serpiente.casillas[-1][1] + 1 < self.Tabla.columnCount(): serpiente.casillas[-1][1] += 1 else: serpiente.casillas[-1][1] = 0 if serpiente.direccion is "Arriba": if serpiente.casillas[-1][0] != 0: serpiente.casillas[-1][0] -= 1 else: serpiente.casillas[-1][0] = self.Tabla.rowCount() - 1 if serpiente.direccion is "Izquierda": if serpiente.casillas[-1][1] != 0: serpiente.casillas[-1][1] -= 1 else: serpiente.casillas[-1][1] = self.Tabla.columnCount() - 1 self.dibujar_snakes() def sucidarte(self, serpiente): for seccion_corporal in serpiente.casillas[0:len(serpiente.casillas) - 2]: if serpiente.casillas[-1][0] == seccion_corporal[ 0] and serpiente.casillas[-1][1] == seccion_corporal[1]: return True return False def te_mataron(self, serpiente_a_checar): for serpiente in self.num_snakes: if serpiente.id != serpiente_a_checar.id: for seccion_corporal in serpiente.casillas[:]: if serpiente_a_checar.casillas[-1][0] == seccion_corporal[ 0] and serpiente_a_checar.casillas[-1][ 1] == seccion_corporal[1]: self.num_snakes.remove(serpiente_a_checar) def pintar_tabla(self): for i in range(self.Tabla.rowCount()): for j in range(self.Tabla.columnCount()): self.Tabla.setItem(i, j, QtGui.QTableWidgetItem()) self.Tabla.item(i, j).setBackground(QtGui.QColor(206, 254, 241)) def table(self): self.Tabla.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch) self.Tabla.verticalHeader().setResizeMode(QtGui.QHeaderView.Stretch) def lista_snakes(self): lista = list() for serpiente in self.num_snakes: lista.append(serpiente.obtener_diccionario()) return lista def ping(self): return "¡Pong!" def yo_juego(self): serpiente_nueva = self.crear_serpiente() diccionario = { "id": serpiente_nueva.id, "color": serpiente_nueva.color } return diccionario def hacer(self): self.servidor.handle_request() def ac_camino(self): for serpiente in self.num_snakes: serpiente.camino = [] for casilla in serpiente.casillas: serpiente.camino.append((casilla[0], casilla[1])) def actualizar_timeout(self): self.servidor.timeout = self.time.value() self.timer_s.setInterval(self.time.value()) def actualiza_timer(self): valor = self.spinBox.value() self.timer.setInterval(valor) def dibujar_snakes(self): for serpiente in self.num_snakes: for seccion_corporal in serpiente.casillas: self.Tabla.item(seccion_corporal[0], seccion_corporal[1]).setBackground( QtGui.QColor(serpiente.color['r'], serpiente.color['g'], serpiente.color['b'])) def actualiza_tabla(self): num_filas = self.spinBox_3.value() num_columnas = self.spinBox_2.value() self.Tabla.setRowCount(num_filas) self.Tabla.setColumnCount(num_columnas) self.pintar_tabla()
class Servidor(QtGui.QMainWindow, servidorUi): def __init__(self, parent=None): #Constructor de la ventana QtGui.QMainWindow.__init__(self, parent) self.setupUi(self) #Inicializa la interfaz del tipo ui self.tableWidget.horizontalHeader().setResizeMode( QHeaderView.Stretch ) #Como su nombre lo dice estira a las columnas horizontales para adaptarse a la widget self.tableWidget.verticalHeader().setResizeMode( QHeaderView.Stretch) #Lo mismo para las verticales self.tableWidget.setHorizontalScrollBarPolicy( Qt.ScrollBarAlwaysOff ) #Cuando las celdas son bastantes, la scrollbar aparece, este basicamente las hace desaparecer self.tableWidget.setVerticalScrollBarPolicy( Qt.ScrollBarAlwaysOff ) #Tambien las verticales (Con las de 20 columnas, 20 filas, aparecía) self.columnas.setMaximum( 99 ) #Ajusta cuantos se puede recibir como maximo en la spinbox para las columnas self.columnas.setMinimum( 10 ) #Ajusta cuantos se puede recibir como minimo en la spinbox para las columnas self.columnas.valueChanged.connect( self.ajustaColumnas) #Conecta los valores de la spinbox al metodo self.filas.setMaximum( 99 ) #Ajusta cuantos se puede recibir como maximo en la spinbox para las filas self.filas.setMinimum( 10 ) #Ajusta cuantos se puede recibir como minimo en la spinbox para las filas self.espera.setMaximum(999) self.espera.setMinimum(10) self.espera.setValue(150) self.timeout.valueChanged.connect(self.esperame) self.filas.valueChanged.connect(self.ajustaRenglones) self.espera.valueChanged.connect( self.speed) #Conecta los valores de la spinbox con el metodo self.tableWidget.setColumnCount(self.columnas.value( )) #Inicia las columnas en el minimo de la spinbox self.tableWidget.setRowCount( self.filas.value()) #Inicia las filas en el minimo de la spinbox self.tableWidget.keyPressEvent = self.keyPressEvent self.iniciajuego.clicked.connect(self.playGameButton) self.pushButton_2.clicked.connect(self.termina) self.pushButton_2.hide() self.serverstart.clicked.connect(self.sirve) self.dire = 2 self.misViboras = [] self.misViborasInfo = [] def ajustaColumnas( self, columnas ): #Cambia las columnas cuando se cambia el valor de la spinbox self.tableWidget.setColumnCount(columnas) def ajustaRenglones( self, renglones ): #Cambia las filas cuando se cambia el valor de la spinbox self.tableWidget.setRowCount(renglones) def speed(self, velocidad): self.timer.setInterval(velocidad) def esperame(self, cuanto): self.timeout.setValue(cuanto) def matame(self): if self.snake.coordenadas[1] == self.snake.coordenadas[ 9] and self.snake.coordenadas[0] == self.snake.coordenadas[8]: return True #Inicia el juego def playGameButton(self): if self.iniciajuego.text() == "Inicia Juego": self.snake = self.snakeMaker() self.dire = self.snake.direccion self.misViboras.append(self.snake.id) self.iniciajuego.setText( "Pausar el juego") #Cambia el texto del boton self.pushButton_2.show() self.timer = QTimer() self.timer.timeout.connect(self.condicional) self.timer.start(150) self.espera.setValue(150) elif self.iniciajuego.text() == "Pausar el juego": self.timer.stop() self.iniciajuego.setText("Reanudar juego") else: self.timer.start(self.espera.value()) self.iniciajuego.setText("Pausar el juego") def caminaDerecha(self): self.desaparece(self.snake) self.snake.todenuevo() self.snake.coordenadas[8], self.snake.coordenadas[ 9] = self.snake.coordenadas[6], self.snake.coordenadas[7] self.snake.coordenadas[6], self.snake.coordenadas[ 7] = self.snake.coordenadas[4], self.snake.coordenadas[5] self.snake.coordenadas[4], self.snake.coordenadas[ 5] = self.snake.coordenadas[2], self.snake.coordenadas[3] self.snake.coordenadas[2], self.snake.coordenadas[ 3] = self.snake.coordenadas[0], self.snake.coordenadas[1] self.snake.coordenadas[0], self.snake.coordenadas[ 1] = self.snake.coordenadas[0], ( self.snake.coordenadas[1] + 1) % self.tableWidget.columnCount() self.aparece(self.snake) def caminaIzquierda(self): self.desaparece(self.snake) self.snake.todenuevo() self.snake.coordenadas[8], self.snake.coordenadas[ 9] = self.snake.coordenadas[6], self.snake.coordenadas[7] self.snake.coordenadas[6], self.snake.coordenadas[ 7] = self.snake.coordenadas[4], self.snake.coordenadas[5] self.snake.coordenadas[4], self.snake.coordenadas[ 5] = self.snake.coordenadas[2], self.snake.coordenadas[3] self.snake.coordenadas[2], self.snake.coordenadas[ 3] = self.snake.coordenadas[0], self.snake.coordenadas[1] self.snake.coordenadas[0], self.snake.coordenadas[ 1] = self.snake.coordenadas[0], ( self.snake.coordenadas[1] - 1) % self.tableWidget.columnCount() self.aparece(self.snake) def caminaArriba(self): self.desaparece(self.snake) self.snake.todenuevo() self.snake.coordenadas[8], self.snake.coordenadas[ 9] = self.snake.coordenadas[6], self.snake.coordenadas[7] self.snake.coordenadas[6], self.snake.coordenadas[ 7] = self.snake.coordenadas[4], self.snake.coordenadas[5] self.snake.coordenadas[4], self.snake.coordenadas[ 5] = self.snake.coordenadas[2], self.snake.coordenadas[3] self.snake.coordenadas[2], self.snake.coordenadas[ 3] = self.snake.coordenadas[0], self.snake.coordenadas[1] self.snake.coordenadas[0], self.snake.coordenadas[1] = ( self.snake.coordenadas[0] - 1) % self.tableWidget.rowCount(), self.snake.coordenadas[1] self.aparece(self.snake) def caminaAbajo(self): self.desaparece(self.snake) self.snake.todenuevo() self.snake.coordenadas[8], self.snake.coordenadas[ 9] = self.snake.coordenadas[6], self.snake.coordenadas[7] self.snake.coordenadas[6], self.snake.coordenadas[ 7] = self.snake.coordenadas[4], self.snake.coordenadas[5] self.snake.coordenadas[4], self.snake.coordenadas[ 5] = self.snake.coordenadas[2], self.snake.coordenadas[3] self.snake.coordenadas[2], self.snake.coordenadas[ 3] = self.snake.coordenadas[0], self.snake.coordenadas[1] self.snake.coordenadas[0], self.snake.coordenadas[1] = ( self.snake.coordenadas[0] + 1) % self.tableWidget.rowCount(), self.snake.coordenadas[1] self.aparece(self.snake) def condicional(self): if self.dire == 0: self.mueveVib(0) elif self.dire == 1: self.mueveVib(1) elif self.dire == 2: self.mueveVib(2) elif self.dire == 3: self.mueveVib(3) if self.matame(): self.termina() def mueveVib(self, dir): if dir == 0: self.caminaArriba() elif dir == 1: self.caminaDerecha() elif dir == 2: self.caminaAbajo() elif self.dire == 3: self.caminaIzquierda() def keyPressEvent(self, event): if event.key() == QtCore.Qt.Key_Left and self.dire != 1: self.dire = 3 elif event.key() == QtCore.Qt.Key_Right and self.dire != 3: self.dire = 1 elif event.key() == QtCore.Qt.Key_Up and self.dire != 2: self.dire = 0 elif event.key() == QtCore.Qt.Key_Down and self.dire != 0: self.dire = 2 def termina(self): self.iniciajuego.setText("Inicia Juego") #Cambia el texto del boton self.desaparece(self.snake) self.pushButton_2.hide() self.timer.stop() def sirve(self): if self.puerto.value() == 0: self.servidor = SimpleXMLRPCServer( (self.url.text(), 8000), allow_none=True) #Creamos nuestro objeto servidor en la clase else: self.servidor = SimpleXMLRPCServer( (self.url.text(), self.puerto.value()), allow_none=True) self.servidor.timeout = self.timeout.value() self.servidor.register_function(self.ping) self.servidor.register_function(self.yo_juego) self.servidor.register_function(self.estado_del_juego) self.servidor.register_function(self.camba_direccion) self.krusty = QTimer(self) self.krusty.timeout.connect(self.cliente) self.krusty.start(100) #Así como en el ejemplo esta funcion va a escuchar por una llamada del cliente, si la escucha regresara una funcion def cliente(self): self.servidor.handle_request() #Metodo que regresa un pong por cada ping def ping(self): return "¡Pong!" #metodo que devuelve las propiedades de la vibora def yo_juego(self): vivora = self.snakeMaker() self.misViboras.append(vivora) return { "id": vivora.id, "color": { "r": vivora.color[0], "g": vivora.color[1], "b": vivora.color[2] } } def camba_direccion(self, identificador, direccioname): ladvd = None for i in range(len(self.misViboras)): if self.misViboras[i].id == identificador: ladvd = self.misViboras[i] ladvd.direccion = direccioname def estado_del_juego(self): return { "espera": self.espera.value(), "tamX": self.tableWidget.columnCount(), "tamY": self.tableWidget.rowCount(), "vivoras": self.misViborasInfo } #Creamos el objeto vivora def snakeMaker(self): id = self.identificadores( ) #Le damos en forma de string un identificador a la vivora color = self.colores() coordenadas = self.coordenates() vivora = Vivora(id, color, coordenadas, 2) self.misViborasInfo.append({ "id": id, "camino": coordenadas, "color": color }) return vivora def aparece(self, vivora): self.tableWidget.setItem(vivora.coordenadas[0], vivora.coordenadas[1], vivora.cabezaSnake) self.tableWidget.setItem(vivora.coordenadas[2], vivora.coordenadas[3], vivora.cuerpoSnake1) self.tableWidget.setItem(vivora.coordenadas[4], vivora.coordenadas[5], vivora.cuerpoSnake2) self.tableWidget.setItem(vivora.coordenadas[6], vivora.coordenadas[7], vivora.cuerpoSnake3) self.tableWidget.setItem(vivora.coordenadas[8], vivora.coordenadas[9], vivora.colaSnake) def desaparece(self, vivora): self.tableWidget.takeItem(vivora.coordenadas[0], vivora.coordenadas[1]) self.tableWidget.takeItem(vivora.coordenadas[2], vivora.coordenadas[3]) self.tableWidget.takeItem(vivora.coordenadas[4], vivora.coordenadas[5]) self.tableWidget.takeItem(vivora.coordenadas[6], vivora.coordenadas[7]) self.tableWidget.takeItem(vivora.coordenadas[8], vivora.coordenadas[9]) #Dada la exigencia, crea una lista de colores que va de r,g,b y oscila entre 0 y 255, rango de colores de python def colores(self): r = random.randint(0, 255) g = random.randint(0, 255) b = random.randint(0, 255) return [r, g, b] #Le asigna in id unico a la vivora def identificadores(self): return str(uuid.uuid4()) #Tenemos una lista con las coordenadas de la vivora def coordenates(self): laX = random.randint(0, self.tableWidget.columnCount()) laY = random.randint(0, self.tableWidget.rowCount()) corCabeza = [laY, laX] corCuerpo1 = [laY, (laX - 1) % self.tableWidget.columnCount()] corCuerpo2 = [laY, (laX - 2) % self.tableWidget.columnCount()] corCuerpo3 = [laY, (laX - 3) % self.tableWidget.columnCount()] corCola = [laY, (laX - 4) % self.tableWidget.columnCount()] return [ corCabeza[0], corCabeza[1], corCuerpo1[0], corCuerpo1[1], corCuerpo2[0], corCuerpo2[1], corCuerpo3[0], corCuerpo3[1], corCola[0], corCola[1] ]
class ServerWindow(QtGui.QMainWindow): """ Ventana principal del servidor. """ def __init__(self): """ Constructor de la clase. """ super(ServerWindow, self).__init__() uic.loadUi('servidor.ui', self) # Vamos a poner unos atributos a la clase # Variables para saber el estado del juego self.game_started = self.game_paused = False # Se inicia el servidor sólo al oprimir el boton self.pushButton.clicked.connect(self.start_server) # agregamos el timer del servidor self.timer_server = 0 # Para que la ventana tenga contadores self.timer = None # Lista con todas las serpientes del juego self.snakes = [] self.snakes_len = len(self.snakes) self.current_id = 0 # Que no resalten las celdas al dar click self.tableWidget.setSelectionMode(QtGui.QTableWidget.NoSelection) # Método para expandir las celdas de la tabla de forma que estén bien # acomodadas self.expand_table_cells() # Pondremos items en toda la tabla para poder pintarla como queramos self.fill_table() # Conectamos que se cambie las columnas y filas de la tabla al método # update_table # Columnas self.spinBox_2.valueChanged.connect(self.update_table) # Filas self.spinBox_3.valueChanged.connect(self.update_table) # Conectamos que se cambie la velocidad de las serpientes al método # update_timer self.spinBox.valueChanged.connect(self.update_timer) # Conectamos el boton de iniciar juego al método de start_game self.pushButton_2.clicked.connect(self.change_game_state) # Enconderemos el boton de terminar juego ya que este sólo # aparece cuando se inicia el juego self.pushButton_3.hide() # Conectamos el boton de terminar juego al método de game_over self.pushButton_3.clicked.connect(self.game_over) # Mostramos la ventana self.show() def fill_table(self): """ Se encarga de llenar la tabla con items en cada celda """ for i in range(self.tableWidget.rowCount()): for j in range(self.tableWidget.columnCount()): self.tableWidget.setItem(i, j, QtGui.QTableWidgetItem()) self.tableWidget.item(i, j).setBackground( QtGui.QColor(255, 255, 255)) def expand_table_cells(self): """ Se encarga de poner en el tamaño correcto las celdas """ self.tableWidget.horizontalHeader().setResizeMode( QtGui.QHeaderView.Stretch) self.tableWidget.verticalHeader().setResizeMode( QtGui.QHeaderView.Stretch) def update_table(self): """ Actualiza la tabla si se incremente el numero de filas o de columnas """ # Obtenemos los valores de los spinBox y actualizamos el número # de columnas y filas rows = self.spinBox_3.value() columns = self.spinBox_2.value() self.tableWidget.setRowCount(rows) self.tableWidget.setColumnCount(columns) self.fill_table() def update_timer(self): """ Este método se encarga de cambiar la velocidad de la serpiente si es que la cambia el jugador en el spinBox """ value = self.spinBox.value() self.timer.setInterval(value) def start_server(self): """ Método encarfado de crear y empezar el servidor xmlrpc. Se le da una ip y un puerto. Además agregamos las funciones que tendran acceso """ ip = self.lineEdit.text() port = self.spinBox_4.value() self.server = SimpleXMLRPCServer((ip, port)) if port == 0: port = self.server.server_address[1] # Ponemos en la interfaz el puerto que tiene self.spinBox_4.setValue(port) # Ahora vamos a bloquear las configuraciones para que no sean # modificadas self.spinBox_4.setReadOnly(True) self.lineEdit.setReadOnly(True) self.pushButton.setEnabled(False) # Vamos a agregar las funciones del servidor # Están en español porque así los pide la práctica self.server.register_function(self.ping) self.server.register_function(self.yo_juego) self.server.register_function(self.cambia_direccion) self.server.register_function(self.estado_del_juego) # Intervalo del servidor self.server.timeout = 0 self.timer_server = QtCore.QTimer(self) self.timer_server.timeout.connect(self.do_something_server) # Inicializamos el Timer con el intervalo del servidor self.timer_server.start(self.server.timeout) def do_something_server(self): """ El servidor va ejecutando las peticiones que están en la cola. """ self.server.handle_request() def change_game_state(self): """ Inicializa o pausa el juego """ if not self.game_started: # Mostramos el boton de terminar el juego self.pushButton_3.show() # Ponemos el boton de iniciar juego a pausar juego self.pushButton_2.setText('Pausar el Juego') # La pintamos en la tabla self.draw_snakes() # Le asignamos la velocidad self.timer = QtCore.QTimer(self) # Para cada timer se le conecta con el metodo move_snakes self.timer.timeout.connect(self.move_snakes) self.timer.start(200) # Le ponemos un EventFilter para escuchar a la # tabla self.tableWidget.installEventFilter(self) # Si no hay ningun error, ponemos que el juego ha sido # empezado self.game_started = True # Esto es para cuando el juego ha empezado y no está pausado elif self.game_started and not self.game_paused: # Paramos el timer self.timer.stop() self.game_paused = True self.pushButton_2.setText("Continuar juego") # Al final cuando el juego esta pausado elif self.game_started and self.game_paused: # Continuamos el timer self.timer.start() self.game_paused = False self.pushButton_2.setText("Pausar Juego") def game_over(self): """ Termina el juego """ # Paramos el timer self.timer.stop() # Borramos todas la serpientes self.snakes = [] self.game_started = False self.game_paused = False # Volvemos a esconder el boton de terminar juego self.pushButton_3.hide() self.pushButton_2.setText('Iniciar Juego') # Volvemos a llenar la tabla self.fill_table() def draw_snakes(self): """ Dibuja todas las serpientes en la tabla """ for snake in self.snakes: for body_part in snake.body: self.tableWidget.item(body_part[0], body_part[1]).\ setBackground(QtGui.QColor( snake.color['r'], snake.color['g'], snake.color['b'] )) def move_snakes(self): """ Hace el movimiento de las serpientes """ for snake in self.snakes: if self.check_snake_has_crash(snake): # Quitamos la serpiente si es que ha chocado self.snakes.remove(snake) self.snakes_len -= 1 if self.snakes_len == 0: self.game_over() return # Debemos de rellenar la tabla self.fill_table() # Poner de blanco el item donde estaba la cola de la serpiente self.tableWidget.item(snake.body[0][0], snake.body[0][1]).setBackground( QtGui.QColor(255, 255, 255)) aux = 1 # Cada parte del cuerpo debe de moverse a donde está la # siguiente for body_part in snake.body[0:-1]: body_part[0] = snake.body[aux][0] body_part[1] = snake.body[aux][1] aux += 1 # Vemos la dirección hacía donde se dirige la serpiente y # verificamos si la cabeza llega al borde de la tabla if snake.direction == 0: if snake.body[-1][0] != 0: snake.body[-1][0] -= 1 else: snake.body[-1][0] = self.tableWidget.rowCount() - 1 elif snake.direction == 1: if snake.body[-1][1] < self.tableWidget.columnCount() - 1: snake.body[-1][1] += 1 else: snake.body[-1][1] = 0 elif snake.direction == 2: if snake.body[-1][0] < self.tableWidget.rowCount() - 1: snake.body[-1][0] += 1 else: snake.body[-1][0] = 0 elif snake.direction == 3: if snake.body[-1][1] != 0: snake.body[-1][1] -= 1 else: snake.body[-1][1] = self.tableWidget.columnCount() - 1 # Al final de todo se vuelven a dibujar las serpientes self.draw_snakes() def check_snake_has_crash(self, snake): """ Checa que la serpiente no haya chocado. """ for current_snake in self.snakes: # Checamos 2 casos, si la serpiente actual es la serpiente # que estamos iterando ahora y si no. Esto es para que # una serpiente no choque con su misma cabeza ya que esto es # imposible if snake != current_snake: # Verificamos si chocaron ambas cabezas if snake.body[-1][0] == current_snake.body[-1][0] and ( snake.body[-1][1] == current_snake.body[-1][1]): return True # Aquí ya verificamos todo el cuerpo excepto la cabeza for body_part in current_snake.body[0:-1]: if snake.body[-1][0] == body_part[0] and (snake.body[-1][1] == body_part[1]): return True return False def eventFilter(self, source, event): """ Este método lo utilizaremos para los eventos cuando oprimamos las teclas y que la serpiente se mueva """ if (event.type() == QtCore.QEvent.KeyPress) and (source is self.tableWidget): #Obtenemos que tecla es la que fue presionada key = event.key() # Checamos los casos cuando la tecla presionada es una de las # flechas if (key == QtCore.Qt.Key_Up and source is self.tableWidget): for snake in self.snakes: if snake.direction != 2: snake.direction = 0 elif (key == QtCore.Qt.Key_Down and source is self.tableWidget): for snake in self.snakes: if snake.direction != 0: snake.direction = 2 elif (key == QtCore.Qt.Key_Right and source is self.tableWidget): for snake in self.snakes: if snake.direction != 3: snake.direction = 1 elif (key == QtCore.Qt.Key_Left and source is self.tableWidget): for snake in self.snakes: if snake.direction != 1: snake.direction = 3 return QtGui.QMainWindow.eventFilter(self, source, event) def ping(self): """ Utilizado por el cliente. Método que sólo regresa ¡Pong! """ return '¡Pong!' def add_snake(self): """ Agrega una serpiente en el juego """ new_snake_id = str(self.current_id) self.current_id += 1 new_snake = Snake(new_snake_id) correct_snake = False while not correct_snake: # Creamos las serpientes de forma horizontal head_y = randint(1, self.tableWidget.rowCount() / 2) body_1_y = head_y + 1 body_2_y = head_y + 2 snake_x = randint(1, self.tableWidget.columnCount() - 1) head, body_1, body_2 = ([head_y, snake_x], [body_1_y, snake_x], [body_2_y, snake_x]) # Verificamos que no choque con alguna otra serpiente for snake in self.snakes: if (head in snake.body or body_1 in snake.body or body_2 in snake.body): break else: correct_snake = True if correct_snake: new_snake.body = [body_2, body_1, head] self.snakes.append(new_snake) return new_snake def yo_juego(self): """ Utilizado por el cliente. Registra una serpiente """ new_snake = self.add_snake() snake_dict = {'id': new_snake.id, 'color': new_snake.color} return snake_dict def cambia_direccion(self, id, direction): """ Utilizado por el cliente. Cambia la direccion de una serpiente """ # Buscamos la serpiente con el id que queremos for snake in self.snakes: if snake.id == id: if direction == 0 and snake.direction != 2: snake.direction = direction elif direction == 1 and snake.direction != 3: snake.direction = direction elif direction == 2 and snake.direction != 0: snake.direction = direction elif direction == 3 and snake.direction != 1: snake.direction = direction # Esto es porque las funciones de servidor deben de regresar algo # siempre return True def get_snakes(self): """ Nos trae la lista de serpientes dentro del juego """ snakes = [] for snake in self.snakes: snakes.append(snake.get_dict()) return snakes def estado_del_juego(self): """ Utilizado por el cliente. Regresa la información importante del juego """ game_dict = { 'espera': self.server.timeout, 'tamx': self.tableWidget.columnCount(), 'tamy': self.tableWidget.rowCount(), 'viboras': self.get_snakes() } return game_dict def update_server_timeout(self): self.server.timeout = self.timer.value() self.timer_server.setInterval(self.time.value())
class VentanaServidor(QtGui.QWidget, w): def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.setupUi(self) self.timer_estado = None self.timer_servidor = None self.pushButton_iniciar_servidor.clicked.connect(self.IniciarServidor) self.spinBox_espera.valueChanged.connect(self.CambiaTiempo) self.tableWidget.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch) self.tableWidget.verticalHeader().setResizeMode(QtGui.QHeaderView.Stretch) self.tableWidget.keyPressEvent = self.keyPressEventTable self.tableWidget.setSelectionMode(QtGui.QTableWidget.NoSelection) self.spinBox_columnas.valueChanged.connect(self.CambiarColumnas) self.spinBox_filas.valueChanged.connect(self.CambiarFilas) self.pushButton_terminar_juego.setVisible(False) self.pushButton_iniciar_juego.setCheckable(True) self.pushButton_iniciar_juego.clicked.connect(self.IniciarJuego) self.pushButton_terminar_juego.clicked.connect(self.TerminarJuego) self.AgrgarItem() self.show() def CambiarColumnas(self): self.tableWidget.setColumnCount(self.spinBox_columnas.value()) self.AgrgarItem() def CambiarFilas(self): self.tableWidget.setRowCount(self.spinBox_filas.value()) self.AgrgarItem() def IniciarJuego(self): if self.pushButton_iniciar_juego.isChecked(): self.snake = Snake() print(Snake().ID) self.timer_estado = QtCore.QTimer(self) self.timer_estado.timeout.connect(self.MoverSnake) self.timer_estado.start(250) self.tableWidget.installEventFilter(self) self.pushButton_terminar_juego.setVisible(True) self.pushButton_iniciar_juego.setText("Pausar el Juego") for x in range(self.snake.Tam()): i = self.snake.Cuerpo[x] j = self.tableWidget.itemAt(i[0],i[1]) self.tableWidget.item(i[0],i[1]).setBackground(QtGui.QColor(254,000,000)) else: self.pushButton_iniciar_juego.setText("Reanudar Juego") def TerminarJuego(self): if self.pushButton_iniciar_juego.isChecked(): self.timer_estado.stop() self.snake = None self.pushButton_iniciar_juego.setCheckable(False) self.pushButton_iniciar_juego.setCheckable(True) self.pushButton_iniciar_juego.setText("Iniciar Juego") self.pushButton_terminar_juego.setVisible(False) self.AgrgarItem() def MoverSnake(self): x = self.snake.Cuerpo[0] y = self.snake.Cuerpo[-1] t = [y[0],y[1]] if self.pushButton_iniciar_juego.isChecked(): if self.snake.Direccion == "AR": z = (x[0] - 1) % self.tableWidget.rowCount() self.snake.Camino.insert(z,x[1]) self.snake.Cuerpo.insert(0,[z,x[1]]) l = [z,x[1]] try: self.AgregarItemTable(t,l) except: pass del self.snake.Cuerpo[-1] elif self.snake.Direccion == "AB": z = (x[0] + 1) % self.tableWidget.rowCount() self.snake.Camino.insert(z,x[1]) self.snake.Cuerpo.insert(0,[z,x[1]]) l = [z,x[1]] try: self.AgregarItemTable(t,l) except: pass del self.snake.Cuerpo[-1] elif self.snake.Direccion == "D": z = (x[1] + 1) % self.tableWidget.columnCount() self.snake.Camino.insert(x[0],z) self.snake.Cuerpo.insert(0,[x[0],z]) l = [x[0],z] try: self.AgregarItemTable(t,l) except: pass del self.snake.Cuerpo[-1] elif self.snake.Direccion == "I": z = (x[1] - 1) % self.tableWidget.columnCount() self.snake.Camino.insert(x[0],z) self.snake.Cuerpo.insert(0,[x[0],z]) l = [x[0],z] try: self.AgregarItemTable(t,l) except: pass del self.snake.Cuerpo[-1] if (self.snake.Cuerpo[0] in self.snake.Cuerpo[1:self.snake.Tam()]): self.TerminarJuego() print("Muere") def CambiaTiempo(self): self.timer_estado.setInterval(self.spinBox_espera.value()) def keyPressEventTable(self, event): key = event.key() if key == QtCore.Qt.Key_Up: self.snake.Cdireccion("AR") elif key == QtCore.Qt.Key_Down: self.snake.Cdireccion("AB") elif key == QtCore.Qt.Key_Left: self.snake.Cdireccion("I") elif key == QtCore.Qt.Key_Right: self.snake.Cdireccion("D") def AgrgarItem(self): for i in range(self.tableWidget.rowCount()): for j in range(self.tableWidget.columnCount()): self.tableWidget.setItem(i,j, QtGui.QTableWidgetItem()) self.tableWidget.item(i,j).setBackground(QtGui.QColor(255,255,255)) def AgregarItemTable(self, x,y): self.tableWidget.setItem(x[0],x[1], QtGui.QTableWidgetItem()) self.tableWidget.item(x[0],x[1]).setBackground(QtGui.QColor(255,255,255)) self.tableWidget.setItem(y[0],y[1], QtGui.QTableWidgetItem()) self.tableWidget.item(y[0],y[1]).setBackground(QtGui.QColor(Snake().rojo,Snake().verde,Snake().azul)) def IniciarServidor(self): puerto = self.spinBox_puerto.value() if puerto == 0: puerto = 8000 ip = str(self.lineEdit_url.text()) self.Servidor = SimpleXMLRPCServer((ip,puerto), allow_none = True) self.spinBox_puerto.setValue(puerto) self.Servidor.timeout = self.doubleSpinBox_timeout.value() self.doubleSpinBox_timeout.setValue(self.Servidor.timeout) self.doubleSpinBox_timeout.setReadOnly(True) self.spinBox_puerto.setReadOnly(True) self.timer_servidor = QtCore.QTimer() self.timer_servidor.timeout.connect(self.timepoConexion) self.Servidor.register_function(self.ping) self.Servidor.register_function(self.yo_juego) self.Servidor.register_function(self.cambia_direccion) self.Servidor.register_function(self.estado_del_juego) self.timer_servidor.start(100) def timepoConexion(self): self.Servidor.handle_request() def cambia_direccion(self, identidad, n): if(self.snake.ID == identidad): if(n == 0): self.snake.Cdireccion("AR") if(n == 1): self.snake.Cdireccion("D") if(n == 2): self.snake.Cdireccion("AB") if(n == 3): self.snake.Cdireccion("I") def yo_juego(self): self.tableWidget.clear() self.snake = Snake() est = {'ID': Snake().ID, 'Color': Snake().Color} for x in Snake().Cuerpo: self.tableWidget.setItem(x[0],x[1], QtGui.QTableWidgetItem()) self.tableWidget.item(x[0],x[1]).setBackground(QtGui.QColor(Snake().rojo,Snake().verde,Snake().azul)) return est def ping(self): return "¡Pong!" def estado_del_juego(self): estado_juego = dict() estado_juego = {'espera': self.Servidor.timeout, 'tamX': self.tableWidget.columnCount(), 'tamY': self.tableWidget.rowCount(), 'vivoras': self.snake.DatosSnake()} return estado_juego
class CloudArrayServer(object): def __init__(self, host, port): # self.spec = ("localhost", 9090) self.spec = (host, port) self.server = SimpleXMLRPCServer(self.spec) self.server.register_function(self.stop, 'stop') self.server.register_function(self.save_as, 'save_as') self.server.register_function(self.rpc_for_module, 'rpc_for_module') self.server.register_function(self.rpc_for_arrays, 'rpc_for_arrays') self.stopped = False self.arrays = {} def serve(self): print('serving on:', self.spec) while not self.stopped: self.server.handle_request() self.server.server_close() def force_stop(self): url = 'http://%s:%s' % self.spec with ServerProxy(url) as client: client.stop() def stop(self): self.stopped = True return 'ok' def debug_print(self): print('') print('---- debug: my arrays ----') for key, arr in self.arrays.items(): print('-', key) print(arr) print('') print('-' * 40) print('') def random_id(self): return 's-' + str(uuid.uuid4()) def create_cloud_array(self, arr): cloud_arr_id = self.random_id() self.arrays[cloud_arr_id] = arr return cloud_arr_id def pack_response(self, rval, bring_local): # print('isinstance(rval, np.ndarray)?', isinstance(rval, np.ndarray)) if isinstance(rval, np.ndarray) and not bring_local: rval = self.create_cloud_array(rval) is_cloud_array = True else: is_cloud_array = False ser_resp = util.serialize(rval) return (ser_resp, is_cloud_array) def save_as(self, old_id, new_id): arr = self.arrays[old_id] self.arrays[new_id] = arr del self.arrays[old_id] return 'ok' def rpc_for_module(self, name, ser_args_data=None): # print('name', name) # print('server ser_args_data', ser_args_data) if ser_args_data: args, kwargs = util.deserialize_args(ser_args_data, self.arrays) else: args = [] kwargs = {} # print('server args_data', args_data) # args = args_data.get('args', []) # kwargs = args_data.get('kwargs', {}) # print('args', args) # print('kwargs', kwargs) cloud_arr_id = self.random_id() # print('rpc for module: %s, %s' % (cloud_arr_id, name)) rval = getattr(np, name)(*args, **kwargs) # print('server side rval:', rval) return self.pack_response(rval, False) def rpc_for_arrays(self, cloud_arr_id, name, access_as, bring_local, ser_args_data=None): if ser_args_data: args_data = pickle.loads(base64.b64decode(str(ser_args_data))) else: args_data = {} print('SERVER: rpc for array: %s, %s' % (cloud_arr_id, name)) # print('args data:', args_data) # self.debug_print() arr = self.arrays[cloud_arr_id] # print('execute the ' + name + ' function on this array:', arr) attr = getattr(arr, name) if access_as == 'attr': rval = attr elif access_as == 'method': args = args_data.get('args', []) kwargs = args_data.get('kwargs', {}) # print('executing %s with %s %s' % (attr, args, kwargs)) rval = attr(*args, **kwargs) # print('packing response', rval, bring_local) rval = self.pack_response(rval, bring_local) # print('rval', rval) return rval
class Pipeline: def __init__(self, config): self._stages = [] self._input_queue = MyInputQueue() self._keepalive_thread = None self._remote_pipe_thread = None self._cache_folder = None self._context = Context() self._config = config self._server = None self._server_mode = None self._load_server(config.get('server')) self._load_remotes(config.get('remotes', [])) self._load_profiler(config.get('profiler')) self._load_stages_with_config(config['stages']) def _load_server(self, server_config): if not server_config: return host = server_config['host'] port = server_config['port'] self._server_mode = server_config.get('mode') print('[+] listening on {}:{}'.format(host, port)) self._server = SimpleXMLRPCServer((host, port), logRequests=False) self._server.register_function(self._put_in_pipe, 'put_remote') def _put_in_pipe(self, name, item): try: # print('[+] _put_in_pipe', name) for s in self._stages: # print('[+] _put_in_pipe loop:', s.name, name) if s.name == name: # print('[+] _put_in_pipe::putting in {}'.format(name)) s.output_queue.put(pickle.loads(item.data)) # print('[+] _done in {}'.format(name)) return 0 # print('[+] _put_in_pipe::found no pipe to put in.. dropping..') return 0 except: traceback.print_exc() raise def _load_profiler(self, profiler): if not profiler: return self._context.profiler = Profiler(profiler) def _load_remotes(self, remotes_config): for remote in remotes_config: name = remote['name'] self._context.remotes[name] = MyQueue() def _load_stages_with_config(self, stages_config): for sc in stages_config: _cls = getattr(pipeline_stage, sc['type']) self.add_stage(_cls(sc, self._context)) def get_samples(self, dtype, num): raise NotImplementedError() def _get_tip_queue(self): if not self._stages: return self._input_queue return self._stages[-1].output_queue def add_stage(self, stage): tip = self._get_tip_queue() stage.input_queue = tip stage.index = len(self._stages) self._stages.append(stage) def _serve_forever(self): print('[+] serving...') while True: self._server.handle_request() def run(self): if 'remotes' in self._config: self._remote_pipe(block=False) if self._server: threading.Thread(target=self._serve_forever).start() if self._server_mode == 'idle': print('[!] going idle mode') return # make sure all threads are initialized before start working init_barrier = multiprocessing.Barrier(len(self._stages) + 1) thread_sem = multiprocessing.BoundedSemaphore( multiprocessing.cpu_count()) ps = [] for s in self._stages: print('[+] intializing process:', s.name) target = pipeline_stage_worker if s.get_max_parallel() == 1: target = no_fork_pipeline_stage_worker kwargs = { 'init_barrier': init_barrier, 'thread_sem': thread_sem, 'stage': s, 'context': self._context, } p = multiprocessing.Process(target=target, kwargs=kwargs) ps.append(p) print('[+] starting processes') [p.start() for p in ps] init_barrier.wait() @property def name(self): return self.__class__.__name__ def iterate(self, size): while True: ret = self.read(size) yield ret def _remote_pipe(self, block=False, timeout=None): self._remote_pipe_thread = multiprocessing.Process( target=remote_pipe_send_worker, args=(self._config, self._context)) self._remote_pipe_thread.daemon = True self._remote_pipe_thread.start() if not block: return self._remote_pipe_thread.join(timeout) def keepalive(self, block=False, timeout=None): self._input_queue.put(1) self._keepalive_thread = multiprocessing.Process( target=keepalive_worker, args=(self._context, self._stages)) self._keepalive_thread.daemon = True self._keepalive_thread.start() if not block: return self._keepalive_thread.join(timeout)
class SharedMemoryStoreServer(object): """The graph store server. The server loads graph structure and node embeddings and edge embeddings and store them in shared memory. The loaded graph can be identified by the graph name in the input argument. DGL graph accepts graph data of multiple formats: * NetworkX graph, * scipy matrix, * DGLGraph. If the input graph data is DGLGraph, the constructed DGLGraph only contains its graph index. Parameters ---------- graph_data : graph data Data to initialize graph. edge_dir : string the edge direction for the graph structure ("in" or "out") graph_name : string Define the name of the graph, so the client can use the name to access the graph. multigraph : bool, optional Whether the graph would be a multigraph (default: False) num_workers : int The number of workers that will connect to the server. port : int The port that the server listens to. """ def __init__(self, graph_data, edge_dir, graph_name, multigraph, num_workers, port): self.server = None if isinstance(graph_data, (GraphIndex, DGLGraph)): self._graph = DGLGraph(graph_data, multigraph=multigraph, readonly=True) else: indptr, indices = _to_csr(graph_data, edge_dir, multigraph) graph_idx = from_csr(utils.toindex(indptr), utils.toindex(indices), multigraph, edge_dir, _get_graph_path(graph_name)) self._graph = DGLGraph(graph_idx, multigraph=multigraph, readonly=True) self._num_workers = num_workers self._graph_name = graph_name self._edge_dir = edge_dir self._registered_nworkers = 0 self._barrier = BarrierManager(num_workers) self._init_manager = InitializerManager() # RPC command: register a graph to the graph store server. def register(graph_name): if graph_name != self._graph_name: print("graph store has %s, but the worker wants %s" % (self._graph_name, graph_name)) return (-1, -1) worker_id = self._registered_nworkers self._registered_nworkers += 1 return worker_id, self._num_workers # RPC command: get the graph information from the graph store server. def get_graph_info(graph_name): assert graph_name == self._graph_name # if the integers are larger than 2^31, xmlrpc can't handle them. # we convert them to strings to send them to clients. return str(self._graph.number_of_nodes()), str(self._graph.number_of_edges()), \ self._graph.is_multigraph, edge_dir # RPC command: initialize node embedding in the server. def init_ndata(init, ndata_name, shape, dtype): if ndata_name in self._graph.ndata: ndata = self._graph.ndata[ndata_name] assert np.all(tuple(F.shape(ndata)) == tuple(shape)) return 0 assert self._graph.number_of_nodes() == shape[0] init = self._init_manager.deserialize(init) data = init(shape, dtype, _get_ndata_path(graph_name, ndata_name)) self._graph.ndata[ndata_name] = data return 0 # RPC command: initialize edge embedding in the server. def init_edata(init, edata_name, shape, dtype): if edata_name in self._graph.edata: edata = self._graph.edata[edata_name] assert np.all(tuple(F.shape(edata)) == tuple(shape)) return 0 assert self._graph.number_of_edges() == shape[0] init = self._init_manager.deserialize(init) data = init(shape, dtype, _get_edata_path(graph_name, edata_name)) self._graph.edata[edata_name] = data return 0 # RPC command: get the names of all node embeddings. def list_ndata(): ndata = self._graph.ndata return [[ key, tuple(F.shape(ndata[key])), dtype_dict[F.dtype(ndata[key])] ] for key in ndata] # RPC command: get the names of all edge embeddings. def list_edata(): edata = self._graph.edata return [[ key, tuple(F.shape(edata[key])), dtype_dict[F.dtype(edata[key])] ] for key in edata] # RPC command: notify the server of the termination of the client. def terminate(): self._num_workers -= 1 return 0 # RPC command: a worker enters a barrier. def enter_barrier(worker_id): return self._barrier.enter(worker_id) # RPC command: a worker leaves a barrier. def leave_barrier(worker_id, barrier_id): self._barrier.leave(worker_id, barrier_id) return 0 # RPC command: test if all workers have left a barrier. def all_enter(worker_id, barrier_id): return self._barrier.all_enter(worker_id, barrier_id) self.server = SimpleXMLRPCServer(("127.0.0.1", port), logRequests=False) self.server.register_function(register, "register") self.server.register_function(get_graph_info, "get_graph_info") self.server.register_function(init_ndata, "init_ndata") self.server.register_function(init_edata, "init_edata") self.server.register_function(terminate, "terminate") self.server.register_function(list_ndata, "list_ndata") self.server.register_function(list_edata, "list_edata") self.server.register_function(enter_barrier, "enter_barrier") self.server.register_function(leave_barrier, "leave_barrier") self.server.register_function(all_enter, "all_enter") def __del__(self): if self.server is not None: self.server.server_close() self._graph = None @property def ndata(self): """Return the data view of all the nodes. DGLGraph.ndata is an abbreviation of DGLGraph.nodes[:].data See Also -------- dgl.DGLGraph.nodes """ return NodeDataView(self._graph, ALL, self._graph_name) @property def edata(self): """Return the data view of all the edges. DGLGraph.data is an abbreviation of DGLGraph.edges[:].data See Also -------- dgl.DGLGraph.edges """ return EdgeDataView(self._graph, ALL, self._graph_name) def run(self): """Run the graph store server. The server runs to process RPC requests from clients. """ while self._num_workers > 0: self.server.handle_request() self._graph = None
class AppsRegister: _instance = None __accessories = {} def init(self): self.__startXMLRPCServer() def uninit(self): self.__stopXMLRPCServer() def add(self, name, accessory): self.__accessories[name] = accessory def remove(self, name): self.__accessories.pop(name) def removeAll(self): self.__accessories = {} def poll(self): for accessory in self.__accessories.values(): status = accessory.poll() if status is not None: return status return None def kill(self, name): accessory = self.__accessories[name] if accessory: accessory.kill() def killAll(self): for accessory in self.__accessories.values(): accessory.kill() def start(self, name, discriminator): accessory = self.__accessories[name] if accessory: return accessory.start(discriminator) return False def stop(self, name): accessory = self.__accessories[name] if accessory: return accessory.stop() return False def reboot(self, name, discriminator): accessory = self.__accessories[name] if accessory: return accessory.stop() and accessory.start(discriminator) return False def factoryResetAll(self): for accessory in self.__accessories.values(): accessory.factoryReset() def factoryReset(self, name): accessory = self.__accessories[name] if accessory: return accessory.factoryReset() return False def waitForCommissionableAdvertisement(self, name): accessory = self.__accessories[name] if accessory: return accessory.waitForCommissionableAdvertisement() return False def waitForOperationalAdvertisement(self, name): accessory = self.__accessories[name] if accessory: return accessory.waitForOperationalAdvertisement() return False def ping(self): return True def __startXMLRPCServer(self): self.server = SimpleXMLRPCServer((IP, PORT)) self.server.register_function(self.start, 'start') self.server.register_function(self.stop, 'stop') self.server.register_function(self.reboot, 'reboot') self.server.register_function(self.factoryReset, 'factoryReset') self.server.register_function( self.waitForCommissionableAdvertisement, 'waitForCommissionableAdvertisement') self.server.register_function( self.waitForOperationalAdvertisement, 'waitForOperationalAdvertisement') self.server.register_function(self.ping, 'ping') self.server_thread = threading.Thread(target=self.__handle_request) self.server_thread.start() def __handle_request(self): self.__should_handle_requests = True while self.__should_handle_requests: self.server.handle_request() def __stopXMLRPCServer(self): self.__should_handle_requests = False # handle_request will wait until it receives a message, so let's send a ping to the server client = ServerProxy('http://' + IP + ':' + str(PORT) + '/', allow_none=True) client.ping()
self.log = [] self.gen_number += 1 if __name__ == '__main__': log_path = sys.argv[1] n_cpus = 1 if len(sys.argv) > 2: n_cpus = int(sys.argv[2]) port_number = 8080 if len(sys.argv) > 3: config = json.load(open(sys.argv[3])) server_url = config['serverUrl'] port_number = int(server_url.split(':')[-1]) print('log', log_path) print('port_number', port_number) eval_server = DagEvalServer(log_path, n_cpus) server = SimpleXMLRPCServer(('localhost', port_number)) server.register_instance(eval_server) while not stop_server: server.handle_request() eval_server.kill_workers()
class XmlRpcServer(threading.Thread): """Simple XMLRPC server implementation. In theory, Python should provide a sane XMLRPC server implementation as part of its standard library. In practice the provided implementation doesn't handle signals, not even EINTR. As a result, we have this class. Usage: server = XmlRpcServer(('localhost', 43212)) server.register_delegate(my_delegate_instance) server.run() """ def __init__(self, host, port): """Construct an XmlRpcServer. @param host string hostname to bind to. @param port int port number to bind to. """ super(XmlRpcServer, self).__init__() logging.info('Binding server to %s:%d', host, port) self._server = SimpleXMLRPCServer((host, port), allow_none=True) self._server.register_introspection_functions() self._keep_running = True self._delegates = [] # Gracefully shut down on signals. This is how we expect to be shut # down by autotest. signal.signal(signal.SIGTERM, self._handle_signal) signal.signal(signal.SIGINT, self._handle_signal) def register_delegate(self, delegate): """Register delegate objects with the server. The server will automagically look up all methods not prefixed with an underscore and treat them as potential RPC calls. These methods may only take basic Python objects as parameters, as noted by the SimpleXMLRPCServer documentation. The state of the delegate is persisted across calls. @param delegate object Python object to be exposed via RPC. """ self._server.register_instance(delegate) self._delegates.append(delegate) def run(self): """Block and handle many XmlRpc requests.""" logging.info('XmlRpcServer starting...') with contextlib.ExitStack() as stack: for delegate in self._delegates: stack.enter_context(delegate) while self._keep_running: try: self._server.handle_request() except select.error as v: # In a cruel twist of fate, the python library doesn't # handle this kind of error. if v[0] != errno.EINTR: raise except Exception as e: logging.error("Error in handle request: %s" % str(e)) logging.info('XmlRpcServer exited.') def _handle_signal(self, _signum, _frame): """Handle a process signal by gracefully quitting. SimpleXMLRPCServer helpfully exposes a method called shutdown() which clears a flag similar to _keep_running, and then blocks until it sees the server shut down. Unfortunately, if you call that function from a signal handler, the server will just hang, since the process is paused for the signal, causing a deadlock. Thus we are reinventing the wheel with our own event loop. """ self._server.server_close() self._keep_running = False
class Server(Thread): _server = None _system = None _run = True PILOT_MODE = 0 SUIVI_MODE = 1 PARCOURS_MODE = 2 def __init__(self, system=None): Thread.__init__(self) self._server = SimpleXMLRPCServer(("", 8028), allow_none=True, use_builtin_types=True) self._server.register_introspection_functions() print(self._server.server_address[0]) self._system = system def getPort(self): return self._server.server_address[1] def setSpeed(self, speed): print("setSpeed") self._system.setSpeed(speed) return 0 def getSpeed(self): return self._system.getSpeed() def stop(self): print("stop") self._system.stop() self._run = False return 0 def setMotor(self, direction): print("setDirection") if direction == 1: self._system.motorForward() elif direction == -1: self._system.motorBackward() elif direction == 0: self._system.motorStop() return 0 def setAngle(self, angle): print("setAngle") self._system.setAngle(angle) def setMode(self, mode): print("setMode") if mode == PILOT_MODE: self._system.notify(Event(System.E_METH, self._system.F_GUIDE)) elif mode == SUIVI_MODE: self._system.notify(Event(System.E_METH, self._system.F_FOLLOW)) elif mode == PARCOURS_MODE: self._system.notify(Event(System.E_METH, self._system.F_PARKOUR)) return 0 # def addTarget(self,name,target): # print("addTarget") # self._system.addTarget([name,target]) # return 0 def setTarget(self, data): print("setTarget") self._system.setTarget(data) return 0 def moveCamera(self, direction): print("moveCamera") self._system.moveCamera(direction) return 0 def cameraHome(self): print("cameraHome") self._system.cameraHome() return 0 def setCoord(self, latitude, longitude): print("setCoord") self._system.parkourTo(latitude, longitude) return 0 def run(self): self._server.register_function(self.setSpeed, 'setSpeed') self._server.register_function(self.getSpeed, 'getSpeed') self._server.register_function(self.setMotor, 'setMotor') self._server.register_function(self.setAngle, 'setAngle') self._server.register_function(self.moveCamera, 'moveCamera') self._server.register_function(self.cameraHome, 'cameraHome') self._server.register_function(self.setMode, 'setMode') self._server.register_function(self.setTarget, 'setTarget') self._server.register_function(self.setCoord, 'setCoord') self._server.register_function(self.stop, 'stop') # self._system.start() while self._run: self._server.handle_request()
class CallbackThread(threading.Thread): """Thread for XML-RPC callback server To prevent SimpleXMLRPCServer blocking whole app it is started in a thread """ def __init__(self, port): log("%s.%s port=%r", self.__class__.__name__, self.__init__.__name__, port) super().__init__() self.server = None self.callback = ClientCallback() self.port = port self.current_test_case = None self.end = False def run(self): """Starts the xmlrpc callback server""" log("%s.%s", self.__class__.__name__, self.run.__name__) log("Serving on port %s ...", self.port) self.server = SimpleXMLRPCServer(("", self.port), allow_none=True, logRequests=False) self.server.register_instance(self.callback) self.server.register_introspection_functions() self.server.timeout = 1.0 while not self.end: self.server.handle_request() self.server.server_close() def stop(self): self.end = True def set_current_test_case(self, name): log("%s.%s %s", self.__class__.__name__, self.set_current_test_case.__name__, name) self.current_test_case = name def get_current_test_case(self): log("%s.%s %s", self.__class__.__name__, self.get_current_test_case.__name__, self.current_test_case) return self.current_test_case def error_code(self): log("%s.%s", self.__class__.__name__, self.error_code.__name__) return self.callback.error_code() def set_pending_response(self, pending_response): log("%s.%s, %r", self.__class__.__name__, self.set_pending_response.__name__, pending_response) return self.callback.set_pending_response(pending_response) def clear_pending_responses(self): log("%s.%s", self.__class__.__name__, self.clear_pending_responses.__name__) return self.callback.clear_pending_responses() def cleanup(self): log("%s.%s", self.__class__.__name__, self.cleanup.__name__) return self.callback.cleanup()