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