def __init__(self):
self.rcon = Rcon(SERVER_INFO)
self.rcon_2 = RecordedRcon(SERVER_INFO)
self.red = get_redis_client()
self.duplicate_guard_key = "unique_logs"
self.log_history = self.get_log_history_list()
logger.info("Registered hooks: %s", HOOKS)
def set_welcome_message(self, msg):
red = get_redis_client()
from rcon.broadcast import format_message
try:
formatted = format_message(self, msg)
except Exception:
logger.exception("Unable to format message")
formatted = msg
return super().set_welcome_message(formatted)
def live_stats_loop():
live = LiveStats()
config = get_config()
last_loop_session = datetime.datetime(year=2020, month=1, day=1)
last_loop_game = datetime.datetime(year=2020, month=1, day=1)
live_session_sleep_seconds = config.get("LIVE_STATS",
{}).get("refresh_stats_seconds",
30)
live_game_sleep_seconds = config.get("LIVE_STATS", {}).get(
"refresh_current_game_stats_seconds", 5)
logger.debug(
"live_session_sleep_seconds: {}".format(live_session_sleep_seconds))
logger.debug("live_game_sleep_seconds: {}".format(live_game_sleep_seconds))
red = get_redis_client()
while True:
# Keep track of session and game timers seperately
last_loop_session_seconds = (datetime.datetime.now() -
last_loop_session).total_seconds()
last_loop_game_seconds = (datetime.datetime.now() -
last_loop_game).total_seconds()
if last_loop_session_seconds >= live_session_sleep_seconds:
last_loop_session = datetime.datetime.now()
try:
live.set_live_stats()
logger.debug("Refreshed set_live_stats")
except Exception:
logger.exception("Error while producing stats")
if last_loop_game_seconds >= live_game_sleep_seconds:
last_loop_game = datetime.datetime.now()
try:
snapshot_ts = datetime.datetime.now().timestamp()
stats = current_game_stats()
logger.debug("Refreshed current_game_stats")
red.set(
"LIVE_GAME_STATS",
pickle.dumps(
dict(snapshot_timestamp=snapshot_ts,
stats=list(stats.values()),
refresh_interval_sec=live_game_sleep_seconds)),
)
except Exception:
logger.exception("Failed to compute live game stats")
time.sleep(0.1)
def get_job_results(job_key):
job = Job.fetch(job_key, connection=get_redis_client())
if not job:
return {
"status": "Job not found or expired",
"result": None,
"started_at": None,
"ended_at": None,
"func_name": None
}
return {
"status": job.get_status(),
# avoid showing previous' job result if they use the same id
"result": job.result if job.get_status() == "finished" else None,
"started_at": job.started_at,
"ended_at": job.ended_at,
"func_name": job.func_name,
"check_timestamp": datetime.datetime.now().timestamp(),
}
def set_broadcast(self, msg, save=True):
from rcon.broadcast import format_message
prev = None
try:
red = get_redis_client()
if save:
prev = red.getset("BROADCAST_MESSAGE", msg)
else:
prev = red.get("BROADCAST_MESSAGE")
red.expire("BROADCAST_MESSAGE", 60 * 30)
except Exception:
logger.exception("Can't save message in redis: %s", msg)
try:
formatted = format_message(self, msg)
except Exception:
logger.exception("Unable to format message")
formatted = msg
super().set_broadcast(formatted)
return prev.decode() if prev else ""
def get_broadcast_message(self):
red = get_redis_client()
msg = red.get("BROADCAST_MESSAGE")
if isinstance(msg, (str, bytes)):
return msg.decode()
return msg
def get_welcome_message(self):
red = get_redis_client()
msg = red.get("WELCOME_MESSAGE")
if msg:
return msg.decode()
return msg
def __init__(self) -> None:
self.red = get_redis_client()
def __init__(self):
self.rcon = RecordedRcon(SERVER_INFO)
self.voted_yes_regex = re.compile(".*PV_Favour.*")
self.voted_no_regex = re.compile(".*PV_Against.*")
self.red = get_redis_client()
def get_cached_live_game_stats():
red = get_redis_client()
stats = red.get("LIVE_GAME_STATS")
if stats:
stats = pickle.loads(stats)
return stats
def set_welcome_message(self, msg):
red = get_redis_client()
from rcon.broadcast import format_message
formatted = format_message(self, msg)
return super().set_welcome_message(formatted)
def get_queue(redis_client=None):
red = get_redis_client()
return Queue(connection=red)
