async def players(ctx):
global datamode
global sunip
global sun1port
global sun2port
global ngsip
global ngsport
if datamode == ["steam"]:
await ctx.send("Obtaining players from Steam data")
suncity = gs.a2s_info((sunip, sun1port))
await ctx.send("SuN City Players: {}/32".format(suncity['players']))
suntest = gs.a2s_info((sunip, defport))
await ctx.send("SuN Test Players: {}/32".format(suntest['players']))
ngs = gs.a2s_info((ngsip, defport))
await ctx.send("NGS Players: {}/32".format(ngs['players']))
print("[SuN Bot] Obtained players from Steam!")
return
elif datamode == ["webscrape"]:
await ctx.send("Obtaining players from webscraping data")
SuN1_SC = requests.get(
'https://www.gametracker.com/server_info/192.223.27.72:27016/'
).text
sun1soup = BeautifulSoup(SuN1_SC, 'html.parser')
SuN1Players = sun1soup.find('span', id='HTML_num_players')
await ctx.send("SuN City Players: {}/32".format(SuN1Players.get_text())
)
SuN2_SC = requests.get(
'https://www.gametracker.com/server_info/192.223.27.72:27015/'
).text
sun2soup = BeautifulSoup(SuN2_SC, 'html.parser')
SuN2Players = sun2soup.find('span', id='HTML_num_players')
await ctx.send("SuN Test Players: {}/32".format(SuN2Players.get_text())
)
NGS_SC = requests.get(
'https://www.gametracker.com/server_info/104.153.106.174:27015/'
).text
ngssoup = BeautifulSoup(NGS_SC, 'html.parser')
NGSPlayers = ngssoup.find('span', id='HTML_num_players')
await ctx.send("NGS Players: {}/32".format(NGSPlayers.get_text()))
print("[SuN Bot] Obtained players from webscraping!")
return
await ctx.send("An internal error has occured")
print("[SuN Bot] Unable to obtain players!")
def __init__(self):
print("Initializing Server Manager...")
self.loop = asyncio.get_event_loop()
self.tasks = []
self.server_files = SquadFileUtils()
print("Loaded Squad file utils.")
self.loop.run_until_complete(self.create_rcon())
if type(self.server_files.sq_ftp) is not bool:
self.tasks.append(self.server_files.sq_ftp.keep_alive)
if self.rcon_dict['Password'] == "":
print("RCON is not enabled in Rcon.cfg (no password).")
exit()
self.rcon = SquadRconClient(
self.rcon_dict['IP'],
self.rcon_dict['Port'],
self.rcon_dict['Password']
)
self.vote_map = VoteMap(self.rcon, generate_layer_list, a2s_info((server_ip, query_port))['map'])
self.loop.run_until_complete(self.vote_map.evaluate_votes())
self.discord = ServerBot(self.rcon, self.server_files, self.vote_map)
self.tasks.append(self.broadcast_rules)
self.last_layer = a2s_info((server_ip, query_port))['map']
self.last_broadcast = round(time.time())
"""ASYNC LOOP"""
try:
self.loop.run_until_complete(
asyncio.wait(
[self.discord.client.start(bot_token)] +
[asyncio.ensure_future(f()) for f in self.tasks]
)
)
except KeyboardInterrupt:
# This code only works after an error has occurred...
print("KB Interput")
self.loop.run_until_complete(self.discord.client.logout())
pending = asyncio.Task.all_tasks(loop=self.loop)
gathered = asyncio.gather(*pending, loop=self.loop)
try:
gathered.cancel()
self.loop.run_until_complete(gathered)
# we want to retrieve any exceptions to make sure that
# they don't nag us about it being un-retrieved.
gathered.exception()
except:
pass
finally:
self.loop.close()
def home():
try:
if "0.0.0.0" in os.environ["SERVERIP"]:
return render_template('homedefault.html', version=__version__)
server_addr = next(
gs.query_master(r'\appid\581320\gameaddr\%s' %
os.environ["SERVERIP"]))
serverInfo = gs.a2s_info(server_addr)
serverRules = gs.a2s_rules(server_addr)
serverPlayers = gs.a2s_players(server_addr)
return render_template('home.html',
addr=server_addr,
ip=os.environ["SERVERIP"],
data=serverInfo,
players=serverPlayers,
rules=serverRules,
quote=randomQuote())
except StopIteration as e:
e = "Unable to resolve server ip."
return render_template('error.html', error=e)
except socket.timeout as e:
e = "Unable to resolve server ip."
return render_template('error.html', error=e)
except: # noqa
e = "Unknown error."
return render_template('error.html', error=e)
def rcon(ip):
try:
if not request.cookies.get('rconpwd'):
res = make_response("")
res.set_cookie('rconpwd', 'NotSet', max_age=60 * 60)
else:
res = make_response("{}".format(request.cookies.get('rconpwd')))
server_addr = next(gs.query_master(r'\appid\581320\gameaddr\%s' % ip))
serverInfo = gs.a2s_info(server_addr)
serverRules = gs.a2s_rules(server_addr)
serverPlayers = gs.a2s_players(server_addr)
return render_template('rcon.html',
addr=server_addr[0],
ip=ip,
data=serverInfo,
players=serverPlayers,
rules=serverRules,
quote=randomQuote(),
maplist=mapList)
except StopIteration as e:
e = "Unable to resolve server ip."
return render_template('error.html', error=e)
except socket.timeout as e:
e = "Unable to resolve server ip."
return render_template('error.html', error=e)
except: # noqa
e = "Unknown error."
return render_template('error.html', error=e)
def getServerInfoSteam(ip, port):
#print("getServerInfoSteam()")
server = (ip, int(port))
return {
"info": gs.a2s_info(server),
"players": gs.a2s_players(server),
"rules": gs.a2s_rules(server)
}
def get_info_short(host, port):
shost = host + ':' + str(port)
try:
data = gs.a2s_info((host, port), timeout=1)
except Exception as exp:
return "{:<21} | Error: {}".format(shost, str(exp))
else:
return "{shost:<21} | {name:<63} | {game} | {players:>2}/{max_players:>2} | {map:<20} | {_ping:>4.0f} ms".format(
shost=shost,
**data,
)
def steam_getPlayerCount(server_addr):
"""Gets player count via steam (-1 indicates offline)"""
ret = -1
try:
info = game_servers.a2s_info(server_addr, timeout=1)
ret = info["players"]
except (ConnectionResetError, socket.timeout) as e:
# print(" TRACE: steam_getPlayerCount {} = {}".format(server_addr, e))
pass
# print(" TRACE:[steam_getPlayerCount({})]: {}".format(server_addr, ret))
return ret
def steam_checkServer(serverNick, server_addr):
"""Checks server status via steam"""
ret = ""
try:
info = game_servers.a2s_info(server_addr, timeout=1)
ret = "{}: [{} Players] [{} {}]".format(serverNick, info["players"],
info["game"], info["map"])
except (ConnectionResetError, socket.timeout) as e:
print("Error when checking on server {} = {}".format(serverNick, e))
ret = "{}: OFFLINE".format(serverNick)
print("[steam_checkServer({},{})]: {}".format(serverNick, server_addr,
ret))
return ret
async def broadcast_rules(self, interval=5):
if self.last_layer != a2s_info((server_ip, query_port))['map']:
print('NEW ROUND STARTED')
print('BROADCAST FOR NEW ROUND')
[await self.rcon.send_command(f'broadcast {msg}') for msg in rules_broadcasts]
print("RULE BROADCAST SUCCESSFUL")
await asyncio.sleep(1)
self.last_layer = a2s_info((server_ip, query_port))['map']
self.last_broadcast = round(time.time())
self.vote_map.reinit(self.last_layer)
await self.vote_map.evaluate_votes()
await init_voting_channel(self.discord, vote_channel_id)
elif round(time.time())-(60*20) > self.last_broadcast:
print('BROADCAST FOR TIME DELTA')
[await self.rcon.send_command(f'broadcast {msg}') for msg in rules_broadcasts]
await asyncio.sleep(1)
self.last_broadcast = round(time.time())
else:
await asyncio.sleep(interval)
await self.broadcast_rules()
def dashboard():
if request.remote_addr != '142.93.124.24':
abort(403) # Forbidden
players = 0
try:
for server_addr in gs.query_master(
r'\app_id\107410\gameaddr\51.89.155.186'):
players += gs.a2s_info(server_addr)["players"]
except:
print("No servers online")
return jsonify(cpu=psutil.cpu_percent(),
players=players,
ram=psutil.virtual_memory().percent)
async def status(ctx):
try:
server = next(gs.query_master(ADDR))
if not (info := gs.a2s_info(server)):
raise RuntimeError
embed_dict = {
"title":
f'Status of __{info["name"]}__ ',
"fields": [
{
"name": "Map:",
"value": info["map"],
"inline": True
},
{
"name": "Players:",
"value": f"{info['players']}/{info['max_players']}",
"inline": True,
},
],
"color":
COLORS[min(info["players"], 64)], # 64 is max players
}
def banner(ip):
try:
server_addr = next(gs.query_master(r'\appid\581320\gameaddr\%s' % ip))
serverInfo = gs.a2s_info(server_addr)
serverRules = gs.a2s_rules(server_addr)
serverPlayers = gs.a2s_players(server_addr)
return render_template('banner.html',
addr=server_addr,
ip=ip,
data=serverInfo,
rules=serverRules,
players=serverPlayers)
except: # noqa
e = "Unknown error."
return render_template('bannererror.html', error=e)
def cmd_hlmaster_info(args):
host, port = parse_host(args.server)
flags = [args.info, args.players, args.rules].count(True)
if args.info or flags == 0:
if flags > 1:
print('--- {:-<60}'.format("Server Info "))
if args.short:
print(get_info_short(host, port))
else:
try:
data = gs.a2s_info((host, port))
except Exception as exp:
print("Error: {}".format(exp))
else:
for pair in sorted(data.items()):
print("{} = {}".format(*pair))
if args.players:
if flags > 1:
print('--- {:-<60}'.format("Players "))
try:
plist = gs.a2s_players((host, port))
except Exception as exp:
print("Error: {}".format(exp))
else:
print_table([[
player['name'],
str(player['score']),
fmt_duration(player['duration']),
] for player in plist],
['Name', '>Score', '>Duration'],
)
if args.rules:
if flags > 1:
print('--- {:-<60}'.format("Rules "))
try:
rules = gs.a2s_rules((host, port))
except Exception as exp:
print("Error: {}".format(exp))
else:
for rule in rules.items():
print("{} = {}".format(*rule))
def status(self, request, pk=None):
server = self.get_object()
ip_port = '{}:{}'.format(server.ip, server.port)
server_address = next(
gs.query_master(r'\appid\{}\gameaddr\{}'.format(
server.game.app_id, ip_port)))
server_info = gs.a2s_info(server_address)
server_data = {
'name': server_info['name'],
'ip': ip_port,
'players': server_info['players'],
'max_players': server_info['max_players'],
'map': server_info['map'],
'game': server.game.tag
}
serializer = ServerStatusSerializer(server_data)
return Response(serializer.data)
def serverInfo(port):
if request.remote_addr != '142.93.124.24':
abort(403) # Forbidden
x = ""
try:
x = subprocess.check_output(['screen', '-list'])
except:
print("Wrong")
if "arma_" + str(port) in str(x):
for server_addr in gs.query_master(
r'\app_id\107410\gameaddr\51.89.155.186:' + str(port)):
serverinfo = gs.a2s_info(server_addr)
return jsonify(running=2,
maxplayers=serverinfo["max_players"],
players=serverinfo["players"],
version=serverinfo["version"],
map=serverinfo["map"],
mission=serverinfo["game"],
hostname=serverinfo["name"])
return jsonify(running=1)
return jsonify(running=0)
def remote(ip):
try:
server_addr = next(gs.query_master(r'\appid\581320\gameaddr\%s' % ip))
serverInfo = gs.a2s_info(server_addr)
serverRules = gs.a2s_rules(server_addr)
serverPlayers = gs.a2s_players(server_addr)
return render_template('remote.html',
addr=server_addr,
ip=ip,
data=serverInfo,
players=serverPlayers,
rules=serverRules,
quote=randomQuote())
except StopIteration as e:
e = "Unable to resolve server ip."
return render_template('error.html', error=e)
except socket.timeout as e:
e = "Unable to resolve server ip."
return render_template('error.html', error=e)
except: # noqa
e = "Unknown error."
return render_template('error.html', error=e)
def get(self, request, format=None):
queryset = Server.objects.all()
servers = []
for server in queryset:
ip_port = '{}:{}'.format(server.ip, server.port)
server_address = next(
gs.query_master(r'\appid\{}\gameaddr\{}'.format(
server.game.app_id, ip_port)))
server_info = gs.a2s_info(server_address)
server_data = {
'name': server_info['name'],
'ip': ip_port,
'players': server_info['players'],
'max_players': server_info['max_players'],
'map': server_info['map'],
'game': server.game.tag
}
servers.append(server_data)
serializer = ServerStatusSerializer(servers, many=True)
return Response(serializer.data)
async def steamserver(ctx, arg1, arg2: int):
server = gs.a2s_info((arg1, arg2))
players = gs.a2s_players((arg1, arg2))
embed = discord.Embed(color=discord.Color.green())
embed.set_author(
name='Game Info',
icon_url=
'https://upload.wikimedia.org/wikipedia/commons/thumb/8/83/Steam_icon_logo.svg/64px-Steam_icon_logo.svg.png'
)
if server['app_id'] == 440:
embed.set_thumbnail(
url=
'https://res.cloudinary.com/teepublic/image/private/s--ec3A9OxT--/t_Preview/b_rgb:191919,c_limit,f_jpg,h_630,q_90,w_630/v1539296609/production/designs/3303784_0.jpg'
)
embed.add_field(name='Name: `{}`'.format(server['name']),
value='\u200b',
inline=False)
embed.add_field(name='IP Address: `{}:{}`'.format(arg1, arg2),
value='\u200b',
inline=False)
embed.add_field(name='Game: `{}`'.format(server['game']),
value='\u200b',
inline=False)
embed.add_field(name='Map: `{}`'.format(server['map']),
value='\u200b',
inline=False)
embed.add_field(name='Players: `{}/{}`'.format(server['players'],
server['max_players']),
value='\u200b',
inline=False)
embed.add_field(name='Latency: `{}`'.format(server['_ping']),
value='\u200b',
inline=False)
await ctx.send(embed=embed)
def get_steam_data(game):
steam_data = {game: []}
for server in get_servers()[game]:
try:
steam_info = gs.a2s_info((server["ip"], server["port"]))
server_json = {"name": server["name"],
"status": "ok",
"ping": round(steam_info["_ping"], 2),
"ip": f"{server['ip']}:{server['port']}",
# "online_players": gs.a2s_players((server["ip"], server["port"])),
"players": steam_info["players"],
"max_players": steam_info["max_players"],
"version": steam_info["version"]}
steam_data[game].append(server_json)
except:
server_json = {"name": server["name"],
"status": "Down",
"ping": 0,
"ip": f"{server['ip']}:{server['port']}",
"players": 0,
"max_players": 0,
"version": 0}
steam_data[game].append(server_json)
return steam_data