def setupRcon(self, serverMessage=None):
try:
Events = None
if self.arma_rcon:
Events = self.arma_rcon.Events.copy()
del self.arma_rcon
self.arma_rcon = bec_rcon.ARC(
self.rcon_settings["ip"], self.rcon_settings["password"],
self.rcon_settings["port"],
{'timeoutSec': self.rcon_settings["timeoutSec"]})
if Events:
#restore Event Handlers
self.arma_rcon.Events = Events
else:
#Add Event Handlers
self.arma_rcon.add_Event("received_ServerMessage",
self.rcon_on_msg_received)
self.arma_rcon.add_Event("on_disconnect",
self.rcon_on_disconnect)
if (serverMessage):
self.arma_rcon.serverMessage = serverMessage
else:
#Extend the chat storage
data = self.arma_rcon.serverMessage.copy()
self.arma_rcon.serverMessage = deque(maxlen=500) #Default: 100
data.reverse()
for d in data:
self.arma_rcon.serverMessage.append(d)
except Exception as e:
log.print_exc()
log.error(e)
async def mission_script_error(self, event, stime, text, regxm, line):
try:
if (time() - self.mission_error_last < 60 * 10):
self.mission_error_suppressed += 1
return
self.mission_error_last = time()
if (self.mission_error_suppressed > 0):
await self.channel.send(
":warning: {} Errors were suppressed\n``{}`` ``{}`` line ``{}``\nAdditional Errors will be suppressed for 10min."
.format(self.mission_error_suppressed, text,
self.readLog.current_log, line))
else:
await self.channel.send(
":warning: ``{}`` ``{}`` line ``{}``\nAdditional Errors will be suppressed for 10min."
.format(text, self.readLog.current_log, line))
self.mission_error_suppressed = 0
#regex = "Error in expression <(?P<expression>.*?)>.*?Error position: <(?P<position>.*?)>.*?Error Undefined variable in expression: (?P<err_cause>.*?)File (?P<file>.*?)\.\.\., line (?P<line>[0-9]*)"
#m = re.match(regex, error, flags=re.S)
# if m:
# await self.channel.send("{}... line {}\nAdditional Errors will be suppressed for 10min.".format(text, line)
# else:
# await self.channel.send("```sqf\n{}```".format(error))
except Exception as e:
log.print_exc()
log.error(e)
def pre_scan(self):
try:
if (self.maxMissions <= 0):
return
#disable Event handlers, so they dont trigger
self.EH.disabled = True
logs = self.getLogs()
tempdataMissions = deque(maxlen=self.maxMissions)
#scan most recent log. Until enough data is collected
#go from newest to oldest log until the data buffer is filled
for _log in reversed(logs):
log.info("Pre-scanning: " + _log)
self.scanfile(_log)
if (len(tempdataMissions) + len(self.Missions) <=
self.maxMissions):
tempdataMissions.extendleft(reversed(self.Missions))
self.Missions = deque(maxlen=self.maxMissions)
self.Missions.append({"dict": {}, "data": []})
else:
break
if (len(tempdataMissions) >= self.maxMissions):
break
self.Missions = tempdataMissions
self.EH.disabled = False
except Exception as e:
log.print_exc()
log.error(e)
def json_load(self):
try:
cfg = None
if (os.path.isfile(self.cfg_path)):
cfg_t = json.load(open(self.cfg_path, "r"))
if (self.default_cfg_path):
cfg = self.cfg_default.copy()
cfg.update(cfg_t)
#TODO: remove description etc
with open(self.cfg_path, 'w') as outfile:
json.dump(self.remove_ignored(cfg),
outfile,
indent=4,
separators=(',', ': '),
default=serialize)
else:
cfg = cfg_t
else:
if (self.default_cfg_path):
with open(self.cfg_path, 'w') as outfile:
#TODO: remove description etc
json.dump(self.remove_ignored(self.cfg_default),
outfile,
indent=4,
separators=(',', ': '),
default=serialize)
cfg = self.cfg_default
if (cfg == None):
return {}
return cfg
except Exception as e:
log.print_exc()
raise Exception("{} for '{}'".format(e, self.cfg_path))
async def watch_log(self):
try:
update_counter = 0
while (True): #Wait till a log file exsists
logs = self.getLogs()
if (len(logs) > 0):
self.current_log = logs[-1]
log.info("current log: " + self.current_log)
self.currentLinePos = 0
file = open(self.log_path + self.current_log, "r")
for i, l in enumerate(file):
pass
self.currentLinePos = i + 1
#file.seek(0, 2) #jump to the end of the file
try:
while (True):
#where = file.tell()
try:
line = file.readline()
update_counter += 1
except:
line = None
if not line:
await asyncio.sleep(1)
#file.seek(where)
if (
update_counter >= 60
): #only check for new log files every 60s, to reduce IOPS
update_counter = 0
if (self.current_log !=
self.getLogs()[-1]):
old_log = self.current_log
self.current_log = self.getLogs()[
-1] #update to new recent log
self.currentLinePos = 0
file = open(
self.log_path + self.current_log,
"r")
log.info("current log: " +
self.current_log)
self.EH.check_Event(
"Log new", old_log,
self.current_log)
else:
self.currentLinePos += 1
self.line = line #access to last read line (debugging)
self.processLogLine(line)
except (KeyboardInterrupt, asyncio.CancelledError):
log.info("[asyncio] exiting {}".format(watch_log))
except Exception as e:
log.error(e)
log.print_exc()
else:
await asyncio.sleep(10 * 60)
except (KeyboardInterrupt, asyncio.CancelledError):
log.info("[asyncio] exiting {}".format(watch_log))
except Exception as e:
log.print_exc()
log.error(e)
def find_by_linked(self, beid, beids = None, ips = None, names = None):
try:
if(beids == None):
beids = set()
if(ips == None):
ips = set()
if(names == None):
names = set()
self.c.execute("SELECT count(beid) FROM users WHERE beid='{}'".format(beid))
if self.c.fetchone()[0]==0:
return {"beids": beids, "ips": ips, "names": names}
entries = self.c.execute("SELECT * FROM users WHERE beid = '{}'".format(beid))
entries = entries.fetchall()
for data in entries:
beids.add(data[2])
ips.add(data[3])
names.add(data[1])
ip_list = self.c.execute("SELECT * FROM users WHERE ip = '{}'".format(data[3]))
ip_list = ip_list.fetchall()
for row in ip_list:
ips.add(row[3])
if(row[1] not in names):
names.add(row[1])
if(row[2] not in beids):
beids.add(row[2])
r = self.find_by_linked(row[2], beids, ips, names)
beids = beids.union(r["beids"])
ips = ips.union(r["ips"])
names = names.union(r["names"])
return {"beids": beids, "ips": ips, "names": names}
except Exception as e:
log.print_exc()
log.error(e)
def processMission(self, event, data):
try:
#new mission is being started
if (event == "Mission readname"):
self.Missions.append({
"dict": {
"Server sessionID": self.server_sessionID,
event: data
},
"data": []
})
elif (event == "Server sessionID"):
self.server_sessionID = data[2].group(2)
#mission is complete, switching to between mission block
elif (event == "Mission finished" or event == "Mission restarted"):
log.info("{} {}".format(
self.Missions[-1]["dict"]["Mission id"][0],
self.Missions[-1]["dict"]["Mission id"][1]))
self.Missions[-1]["dict"][event] = data
self.Missions.append({
"dict": {
"Server sessionID": self.server_sessionID
},
"data": []
})
#process data within a mission
elif ("Mission" in event):
self.Missions[-1]["dict"][event] = data
self.Missions[-1]["data"].append(data)
except Exception as e:
log.print_exc()
log.error(e)
async def playerConnected(self, event, data):
try:
player_name = data["event_match"].group(2)
player_profileID = int(data["event_match"].group(3))
for i in range(2):
for player in self.players:
name = player[4]
if (name.endswith(" (Lobby)")): #Strip lobby from name
name = name[:-8]
if name == player_name:
beid = player[3]
ip = player[1].split(":")[0]
sql = """ UPDATE users
SET profileid = ?
WHERE name = ?
AND beid = ?
AND ip = ?
AND stamp > date('now','-1 day')"""
log.debug(sql)
self.c.execute(sql, (player_profileID, name, beid, ip))
self.con.commit()
break
await asyncio.sleep(60)
except Exception as e:
log.print_exc()
log.error(e)
async def checkPermission(self, rctx, cmd):
try:
cmd = "command_{}".format(cmd)
pr = self.PermissionConfig.cfgPermissions_Roles
role = "@everyone"
#check if everybody can use it
if (cmd in pr[role] and pr[role][cmd]):
#anyone can use the cmd
return True
#check if user can use it
#Lookup user in linked accounts:
for user_id, data in self.user_data.items():
log.info("{} {}".format(data["account_arma3"], rctx.user_guid))
if ("account_arma3" in data
and data["account_arma3"][0] == rctx.user_guid):
#check if user has permission:
server = self.bot.guilds[0]
user = discord.utils.get(server.members, id=int(user_id))
if (user):
#get user roles, and check if role has permission
for role in user.roles:
if str(role) in pr.keys():
if (cmd in pr[str(role)]
and pr[str(role)][cmd]):
return True
return False
except Exception as e:
log.print_exc()
log.error(e)
return False
def processLogLine(self, line):
payload = {}
try:
timestamp, msg = self.splitTimestamp(line)
payload["timestamp"] = timestamp
payload["msg"] = msg
payload["currentLinePos"] = self.currentLinePos
self.EH.check_Event("Log line", payload)
event, event_match = self.check_log_events(msg, self.events)
# if(self.EH.disabled==False):
# log.info("{} {} {}".format(line, event, event_match))
#log.info(event, msg, self.multiEventLockData)
if (event_match):
payload["event_match"] = event_match
self.EH.check_Event(event, payload)
if ("clutter" not in event):
#log.info("{} {}".format(event, event_match))
self.processMission(event, (timestamp, msg, event_match))
self.EH.check_Event("Log line filtered", payload)
else:
self.processMission("", (timestamp, msg))
self.EH.check_Event("Log line filtered", payload)
except Exception as e:
log.print_exc()
log.error(e)
def rcon_on_msg_received(self, args):
try:
message = args[0].strip()
if (message.startswith("Player #")):
#log.info(message)
if (self.cfg["send_player_connect_msg"]):
#"disconnect"
if (message.endswith(" disconnected")
and ":" not in message):
if (self.cfg["send_player_connect_msg_hide_details"]):
message = ":x: " + " ".join(
message.split(" ")[2:-1])
asyncio.ensure_future(self.channel.send(message))
#"connect"
elif (message.endswith(") connected")):
if (self.cfg["send_player_connect_msg_hide_details"]):
msg = "(".join(message.split(
"(")[:-1]) #removes the last block with the ip
msg = ":white_check_mark: " + " ".join(
msg.split(" ")[2:])
else:
msg = message
asyncio.ensure_future(self.channel.send(msg))
except Exception as e:
log.print_exc()
log.error(e)
async def memory_guard(self):
while True:
try:
if (self.cfg["server_memory_protection"]):
if (psutil.virtual_memory().percent > 70):
await self.CommandRcon.arma_rcon.command(
"#shutdownaftermission")
await self.CommandRcon.arma_rcon.sayGlobal(
"A Server shutdown has been scheduled at the end of this mission."
)
if (self.memoryRestart == False):
await self.channel.send(
":warning: Memory usage exceeded! Server shutdown scheduled after mission end"
)
self.memoryRestart = True
log.warning(
":warning: Memory usage exceeded! Server shutdown scheduled after mission end"
)
elif (
psutil.virtual_memory().percent > 95
): #might be too aggressive should short memory spikes occur
await self.CommandRcon.arma_rcon.shutdown()
log.warning(
":warning: Memory usage exceeded! Server was forced shutdown"
)
except Exception as e:
log.print_exc()
log.error(e)
await asyncio.sleep(10 * 60)
async def statusSetter(self):
while True:
try:
if (self.cfg["set_custom_status"]):
await self.set_status()
except Exception as e:
log.print_exc()
log.error(e)
await asyncio.sleep(60)
def upgrade_database(self):
try:
json_f = self.path + "/player_db.json"
if (not os.path.isfile(json_f)):
return
#get the count of tables with the name
self.c.execute(
''' SELECT count(name) FROM sqlite_master WHERE type='table' AND name='users' '''
)
if self.c.fetchone()[0] == 0:
#load old table
with open(json_f) as json_file:
data_db = json.load(json_file)
data = []
for key, item in data_db.items():
for _item in item:
id = None
name = None
beid = None
ip = None
date = None
if "ID" in _item:
id = int(_item["ID"])
if "name" in _item:
name = _item["name"]
if "beid" in _item:
beid = _item["beid"]
if "ip" in _item:
ip = _item["ip"]
if "last-seen" in _item:
date = _item["last-seen"]
data.append((id, name, beid, ip, date))
self.c.execute("""
CREATE TABLE users (
id INTEGER NOT NULL,
name TEXT,
beid TEXT,
ip TEXT,
stamp DATETIME,
profileid INTEGER
);
""")
#date yyyy-MM-dd HH:mm:ss
sql = 'INSERT INTO users (id, name, beid, ip, stamp) values(?, ?, ?, ?, ?)'
self.c.executemany(sql, data)
self.con.commit()
json_f_new = json_f.replace(".json", "_old.json")
os.rename(json_f, json_f_new)
log.info("*** Database has been upgraded! ***")
except Exception as e:
log.print_exc()
log.error(e)
async def task_setStatus(self):
while True:
try:
await asyncio.sleep(60)
await self.setStatus()
except (KeyboardInterrupt, asyncio.CancelledError):
log.info("[asyncio] exiting", task_setStatus)
except Exception as e:
log.error("setting status failed", e)
log.print_exc()
async def saveErrors(self):
while True:
try:
if ((self.mission_error_last + 60) < time()):
with open(self.path + "/logs/script_errors.log",
'w+') as outfile:
json.dump(self.script_errors, outfile, indent=4)
except Exception as e:
log.print_exc()
log.error(e)
await asyncio.sleep(60)
async def on_ready(self):
try:
await self.bot.wait_until_ready()
self.CommandRcon = self.bot.cogs["CommandRcon"]
self.channel = self.bot.get_channel(int(self.cfg["post_channel"]))
if(self.cfg["report_script_errors"] and self.channel):
self.readLog.EH.add_Event("Mission script error", self.mission_script_error)
self.readLog.EH.add_Event("Log new", self.newLog)
asyncio.ensure_future(self.readLog.watch_log())
asyncio.ensure_future(self.memory_guard())
except Exception as e:
log.print_exc()
log.error(e)
async def task_updatePlayerStats(self):
await asyncio.sleep(60 * 2)
while True:
try:
log.info("[JMW] Updating Player stats")
t = threading.Thread(target=self.psg.generateStats())
t.start()
self.psg_updated = datetime.datetime.now(datetime.timezone.utc)
except (KeyboardInterrupt, asyncio.CancelledError):
pass
except Exception as e:
log.error("Failed to update player stats", e)
log.print_exc()
await asyncio.sleep(60 * 60 * 24)
def scanfile(self, name):
with open(self.log_path + name, encoding='utf-8',
errors='replace') as fp:
try:
line = fp.readline()
except:
line = None
while line:
self.processLogLine(line)
try:
line = fp.readline()
except Exception as e:
log.print_exc()
log.error(e)
line = None
async def processOldGame(self,
channel,
admin=False,
gameindex=0,
sendraw=False):
if (self.bot.is_closed()):
return False
if (gameindex <= 0):
return await self.processGame(channel, admin, 0, sendraw)
try:
#get list of old game files
path = self.cfg['image_path']
ignore = ["-CUR", "currentGame"] #log files that will be ignored
if (os.path.exists(path)):
files = []
for file in os.listdir(path):
if ((file.endswith(".png") and "-ADV" in file)
and not any(x in file for x in ignore)):
files.append(file)
files = sorted(files, reverse=True)
else:
files = []
if (gameindex > len(files)):
msg = "Sorry, I could not find any games"
await channel.send(com_west)
return
picname = files[gameindex - 1]
print(picname)
gamefile = picname.replace(".png", ".json")
timestamp = " ".join(picname.split("#")[:2])
gameduration = picname.split("#")[2]
lastwinner = picname.split("#")[3]
if (sendraw == True):
filename = self.cfg['data_path'] + gamefile
else:
filename = self.cfg['image_path'] + picname
msg = "[" + timestamp + "] " + str(
gameduration) + "min game. Winner:" + lastwinner
msg += "\n<http://www.jammywarfare.eu/replays/?file={}>".format(
urllib.parse.quote(gamefile))
await channel.send(file=discord.File(filename), content=msg)
except Exception as e:
log.print_exc()
await channel.send("An error occurred: " + str(e))
def rcon_on_msg_received(self, args):
try:
message = args[0]
if (":" in message):
header, body = message.split(":", 1)
if (self.CommandRcon.isChannel(header)
): #was written in a channel
player_name = header.split(") ")[1]
else:
#is join or disconnect, or similaar
#log.info(message)
asyncio.ensure_future(self.banned_user_kick(message))
except Exception as e:
log.print_exc()
log.error(e)
async def on_ready(self):
await self.bot.wait_until_ready()
self.channel = self.bot.get_channel(self.cfg["post_channel"])
if ("CommandRcon" not in self.bot.cogs):
log.info(
"[module] 'CommandRcon' required, but not found in '{}'. Module unloaded"
.format(type(self).__name__))
del self
return
try:
self.CommandRcon = self.bot.cogs["CommandRcon"]
self.CommandRcon.arma_rcon.add_Event("received_ServerMessage",
self.rcon_on_msg_received)
except Exception as e:
log.print_exc()
log.error(e)
def alter_database(self):
try:
## Alter table (upgrade by adding the profileid column)
self.c.execute(
"SELECT COUNT(*) AS CNTREC FROM pragma_table_info('users') WHERE name='profileid'"
)
if self.c.fetchone()[0] == 0:
sql = """ ALTER TABLE users
ADD COLUMN profileid INTEGER;"""
self.c.execute(sql)
self.con.commit()
log.info("Altered DB Table: 'Added COLUMN profileid'")
except Exception as e:
log.print_exc()
log.error(e)
def __init__(self, cfg_path=None, default_cfg_path=None):
self.cfg = {}
self.cfg_path = cfg_path
self.default_cfg_path = default_cfg_path
self.save = True
self.ignored = [
"description"
] #any item, will not be carried outside the default_cfg
if (default_cfg_path):
try:
self.cfg_default = json.load(open(self.default_cfg_path, "r"))
except Exception as e:
log.print_exc()
raise Exception("{} for '{}'".format(e, self.cfg_path))
if (cfg_path):
self.load()
async def mission_script_error(self, event, payload):
try:
text = payload["msg"]
line = payload["currentLinePos"]
stime = datetime.datetime.now().strftime("%Y-%m-%d %H-%M-%S")
if text in self.script_errors:
self.script_errors[text]["log"] = self.readLog.current_log
self.script_errors[text]["line"] = line
self.script_errors[text]["count"] += 1
self.script_errors[text]["last"] = payload["timestamp"]
self.script_errors[text]["positions"].append({
"log":
self.readLog.current_log,
"line":
line,
"time":
stime
})
else:
self.script_errors[text] = {
"log":
self.readLog.current_log,
"line":
line,
"count":
1,
"last":
stime,
"positions": [{
"log": self.readLog.current_log,
"line": line,
"time": stime
}]
}
await self.channel.send(
":warning: ``{}`` ``{}`` line ``{}``".format(
text, self.readLog.current_log, line))
self.mission_error_last = time()
except Exception as e:
log.print_exc()
log.error(e)
async def fetch_player_data_loop(self):
while True:
await asyncio.sleep(60)
try:
if(self.CommandRcon.arma_rcon.disconnected==True):
continue
try:
self.players = await self.CommandRcon.arma_rcon.getPlayersArray()
except Exception as e:
continue
#self.player_db.save = False
c_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
#Set status
if(self.cfg["set_custom_status"]==True):
await self.set_status(self.players)
if(self.cfg["setTopicPlayerList_channel"]>0):
await self.setTopicPlayerList(self.players)
for player in self.players:
name = player[4]
if(name.endswith(" (Lobby)")): #Strip lobby from name
name = name[:-8]
d_row = {
"id": player[0],
"name": name,
"beid": player[3],
"ip": player[1].split(":")[0], #removes port from ip
"note": None,
"stamp": c_time
}
self.update_insert(d_row)
#self.player_db.save = True
#self.player_db.json_save()
except Exception as e:
log.print_exc()
log.error(e)
def loadCogs(bot):
Modules.module_list = sorted(list(glob.glob("modules/*")))
for module in Modules.module_list:
module = module.replace("\\", "/")
try:
cfg = Modules.loadCfg(module)
if (cfg):
CoreConfig.modules[module] = {
Modules.general_settings_file: cfg
}
if (cfg["load_module"] == True):
bot.load_extension(
module.replace("/", ".") + ".module")
else:
log.info("[Modules] Skipped Cogs in '{}'".format(module))
except (discord.ClientException, ModuleNotFoundError) as e:
log.print_exc()
log.error(f'Failed to load extension: {module} ({e})')
Modules.fix_wrappers()
async def on_ready(self):
await self.bot.wait_until_ready()
try:
self.CommandRcon = self.bot.cogs["CommandRcon"]
self.CommandArma = self.bot.cogs["CommandArma"]
self.processLog = ProcessLog(self.CommandArma.readLog, self.cfg)
self.processLog.readLog.EH.add_Event("Mission readname",
self.gameStart)
self.processLog.readLog.EH.add_Event("Mission finished",
self.gameEnd)
#self.processLog.EH.add_Event("on_missionHeader", self.gameStart)
#self.processLog.EH.add_Event("on_missionGameOver", self.gameEnd)
#self.processLog.readLog.pre_scan()
# log.info(len(self.processLog.readLog.Missions))
# for m in self.processLog.readLog.Missions:
# if("Mission id" in m["dict"]):
# log.info(len(m["data"]), len(self.processLog.processGameBlock(m)), m["dict"]["Mission id"])
#--> working correctly
# log.info("#"*20)
# for e in list(self.processLog.readLog.dataRows)[-100:]:
# log.info(e[1])
# game = self.processLog.readLog.Missions_current
# game = self.processLog.processGameBlock(game)
# log.info(len(game))
# for i in range(8):
# try:
# game = self.processLog.buildGameBlock(i)
# game = self.processLog.processGameBlock(game)
# log.info(len(game))
# except IndexError:
# log.info("Game '{}' not found".format(i))
#log.info(self.processLog.readData(False, 0))
self.playerMapGenerator = playerMapGenerator(self.cfg["data_path"])
except Exception as e:
log.print_exc()
log.error(e)
async def on_ready(self):
await self.bot.wait_until_ready()
#await asyncio.sleep(60) #wait addional time for everything to be ready
try:
if ("CommandRcon" not in self.bot.cogs):
log.info(
"[module] 'CommandRcon' required, but not found in '{}'. Module unloaded"
.format(type(self).__name__))
del self
return
self.CommandRcon = self.bot.cogs["CommandRcon"]
self.post_channel = self.bot.get_channel(
self.cfg["post_channel"]) #channel id
self.CommandRcon.arma_rcon.add_Event("received_ServerMessage",
self.rcon_on_msg_received)
await self.init_bans_watchdog()
except (KeyboardInterrupt, asyncio.CancelledError):
log.info("[asyncio] exiting {}".format(on_ready))
except Exception as e:
log.print_exc()
log.error(e)
def processLogLine(self, timestamp, line):
#check if line contains a datapacket
m = re.match('^(\[\["CTI_DataPacket","(.*?)"],.*])', line)
if(m):
type = m.group(2)
try:
datarow = self.parseLine(line) #convert string into array object
if(type == "Header"):
datarow["timestamp"] = timestamp
return datarow
elif("Data_" in type):
index = int(re.match('.*_([0-9]*)', type).group(1))
if(len(self.databuilder)>0):
index_db = int(re.match('.*_([0-9]*)', self.databuilder["CTI_DataPacket"]).group(1))
#check if previous 'Data_x' is present
if(index_db+1 == index):
self.databuilder = self.updateDicArray(self.databuilder, datarow)
#If last element "Data_EOD" is present,
if("EOD" in type):
self.databuilder["CTI_DataPacket"] = "Data"
datarow = self.databuilder.copy()
self.databuilder = {}
return datarow
elif(type == "Data_1"):
#add first element
self.databuilder = self.updateDicArray(self.databuilder, datarow)
elif(type == "EOF"):
pass
#raise Exception("Read mission EOF")
#return datarow #return EOF (should usually never be called)
elif(type == "GameOver"):
datarow["timestamp"] = timestamp #finish time
return datarow #return Gameover / End
except Exception as e:
log.error(e)
log.info(line)
log.print_exc()
