def ping_db(self): try: connection.connection.ping() except (OperationalError, AttributeError): from django import db db.close_old_connections() call_later(settings.SERVER_DB_KEEPALIVE, self.ping_db)
def startService(self): logger.info('[%s] starting on port: %s' % (self.name, settings.SOCKET_SERVER_PORT)) self.udp_service = reactor.listenUDP(settings.SOCKET_SERVER_PORT, self.game_protocol) call_later(0, self.ping_db)
def __init__(self, game_service): self.game_service = game_service self.actions = {"auth": self.auth, "ping": self.ping} DatagramProtocol.__init__(self) self.reset_db() call_later(0, self.consume_broadcast_messages) call_later(0, self.check_disconnect)
def consume_broadcast_messages(self): for address, conn_data in list(self.connections.items()): if conn_data.get('player'): messages = yield defer_to_thread( get_message_queued_for_client, conn_data['player'].state.address) for action, data in messages: self.send(address, action=action, data=data) call_later(0, self.consume_broadcast_messages)
def update_remote_addresses_in_current_game(self): if self.disconnected: return if self.state.game: addresses_in_current_game = yield defer_to_thread( get_clients_from_group, self.state.game.key) addresses_in_current_game.remove(self.state.address) self.remote_addresses_in_current_game = addresses_in_current_game call_later(1, self.update_remote_addresses_in_current_game)
def __init__(self, protocol, state): self.disconnected = False self.protocol = protocol self.state = state self.remote_addresses_in_current_game = [] call_later(1, self.update_remote_addresses_in_current_game) self.actions = { "move": self.move, }
def delayed_listen_loop(self): if tasks.Task.has_delayed_task_available(): try: tasks.Task.queue_next_delayed_task(prioritize=True) except IndexError: log.err('\x1b[0;37;41m' + "Failed delaying next task." " Was presumably already picked " "up" + '\x1b[0m') return call_later(0, self.delayed_listen_loop) return call_later(self.LISTEN_LOOP_IDLE_INTERVAL, self.delayed_listen_loop)
def check_players(self): addresses = yield defer_to_thread(get_clients_from_group, self.state.key) addresses = set(addresses) new_players = addresses - self.addresses gone_players = self.addresses - addresses for address in new_players: yield self.add_address(address) for address in gone_players: yield self.remove_address(address) if not self.addresses: self.parent.removeService(self) return call_later(1, self.check_players)
def startService(self): log.msg("Setting up tasker engine...") call_later(0, self.heartbeat) self.delayed_listen_loop() self.launch_workers() log.msg( splash.format( **{ 'idx': self.idx, 'handler_count': len(tasks.Task.handlers), 'message': 'tasker ready for action', 'redis_host': settings.REDIS_HOST, 'redis_port': settings.REDIS_PORT, 'redis_tasker_db': settings.REDIS_TASKER_DB }))
def worker_loop(self, n): self.check_for_idle() task_data = tasks.Task.fetch_task() if not task_data: call_later(1, self.worker_loop, n) return self._last_action_time = time.time() try: self.process_task(task_data) except Exception as e: print('\x1b[0;37;41m' + "Task failed.. Continuing loop" + '\x1b[0m') call_later(0, self.worker_loop, n)
def startService(self): super().startService() call_later(0, self.check_players)
def heartbeat(self): self.update_mothership() self.check_for_idle() call_later(self.HEARTBEAT_INTERVAL, self.heartbeat)
def check_disconnect(self): for address, conn_data in list(self.connections.items()): if time.time() - conn_data['t'] > 10: yield self.disconnnect(address) call_later(1, self.check_disconnect)