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()
