def otherlist():
ip0 = '134.175.62.172'
port0 = '27131'
port0 = int(port0)
try:
server0_info = a2s.info((ip0, port0), timeout=0.1)
except socket.timeout as e:
server0_info = 'null'
except a2s.BrokenMessageError as e:
server0_info = 'null'
else:
pass
ip = ['119.188.247.66', '119.188.247.66', '119.188.247.66', '119.188.247.66', '119.188.247.66', '119.188.247.66',
'119.188.247.66', '119.188.247.66', '119.188.247.66', '119.188.247.66', '119.188.247.66', '119.188.247.66',
'119.188.247.66', '119.188.247.66']
port = ['27201', '27211', '27221', '27231', '27251', '27261', '27271', '27281', '27291', '27301', '27311',
'27321', '27331', '27341']
servers_info = []
for (info_ip, info_port) in zip(ip, port):
info_port = int(info_port)
try:
server_info = a2s.info((info_ip, info_port), timeout=0.2)
except socket.timeout as e:
server_info = 'null'
except a2s.BrokenMessageError as e:
server_info = 'null'
else:
pass
servers_info.append(server_info)
return render_template("otherserverlist.html", infos=servers_info, info0=server0_info), 200
async def update_player_count():
try:
Player = a2s.info(config.SERVER_ADDRESS).player_count
MaxPlayers = a2s.info(config.SERVER_ADDRESS).max_players
except socket.timeout as error:
await client.change_presence(activity=discord.Game(
name=f"Server is off"))
else:
await client.change_presence(activity=discord.Game(
name=f"{Player}/{MaxPlayers} Players Online"))
async def GetServerInfo(addr):
'''Coroutine. Request source server info through a2s protocol.
Args:
addr: Source server str(IP) and int(PORT) in tuple.
Returns:
if successfull:
a2s.SourceInfo
else:
None
'''
recv = False
iter = 0
while recv != True:
try:
i = a2s.info(addr)
except Exception as e:
log('GetServerInfo', f'Server: {str(addr)} – {e}', 'warn')
if iter <= 5:
return None
else:
iter += 1
continue
else:
recv = True
return i
async def server(channel):
"""Checks if the server is running or not.
Parameters
----------
channel : str
Chat channel of the server
Returns
-------
Server info if server is online otherwise False.
"""
for serverdict in server_list:
if serverdict["commands_channel"] == str(channel) or serverdict["admin_channel"] == str(channel)\
or serverdict["chat_channel"] == str(channel):
address = serverdict["server_address"]
break
try:
svr_info = a2s.info(address, 1.0)
svr_players = a2s.players(address)
return {"server_info": svr_info, "server_players": svr_players}
except Exception as e:
logging.warning(
f'[Pyre-Bot:Commands][{datetime.now(tz).strftime(t_fmt)}] Error checking server status: {e}'
)
return False
def _get_server_info_worker(cls,
address_list,
query_timeout: float = 1.0,
full_update: bool = False) -> list:
server_info_ls: List[dict] = list()
for address in address_list:
try:
# -- Get Server info
info = a2s.info(address, query_timeout)
info.players = list()
# -- Get Player Info if requested
if info and full_update:
try:
players = a2s.players(address, query_timeout * 4)
info.players = cls._serialize_player_info(players)
info.player_count = len(info.players)
except Exception as exc:
logging.error(
'Error while querying for player info: %s', exc)
# -- Remove AI from player count
info.player_count = max(0, info.player_count - info.bot_count)
# -- Serialize data to JSON dict
if info:
server_info_ls.append(
cls._source_info_to_server_dict(info, address))
except Exception as exc:
logging.error('Error while querying for server info: %s', exc)
return server_info_ls
def update_info(self):
#a2s = valve.source.a2s.ServerQuerier((self.host, self.port))
try:
info = dict(a2s.info((self.host, self.port)))
self.up = True
self.save()
#except valve.source.a2s.NoResponseError:
except:
self.up = False
self.save()
return False
info_model = Info(server=self)
info_model.server_name = info['server_name']
info_model.map = info['map_name']
info_model.folder = info['folder']
info_model.game = info['game']
info_model.app_id = info['app_id']
info_model.player_count = info['player_count']
print('player_count' + info['player_count'])
info_model.max_players = info['max_players']
info_model.bot_count = info['bot_count']
info_model.server_type = info['server_type']
info_model.platform = info['platform']
info_model.password_protected = info['password_protected']
info_model.vac_enabled = info['vac_enabled']
info_model.version = info['version']
self.info_set.all().delete()
info_model.save()
print("player_count" + info_model.player_count)
return True
def get_server_info(ipaddress):
ipport = ipaddress.split(':')
server_address = (ipport[0], int(ipport[1]))
try:
info = str(a2s.info(server_address))
except Exception as e:
write_log(
("[Error][" + ipaddress + ":" + str(e) + "]" +
str(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) + '\n'))
return "服务器暂未开放", 0, 0
# 切出地图信息
pos_start = info.find("map_name='") + 10
pos_end = info.find("', folder", pos_start)
map_name = str(info[pos_start:pos_end])
# 切出当前玩家信息
pos_start = info.find("player_count=") + 13
pos_end = info.find(", max_players", pos_start)
player_count = str(info[pos_start:pos_end])
# 切出最大玩家信息
pos_start = info.find("max_players=") + 12
pos_end = info.find(", bot_count", pos_start)
max_player = str(info[pos_start:pos_end])
# 用于重复验证，但加重负担先不考虑
# if player_count == 0 and not check:
# time.sleep(5)
# return get_server_info(ipaddress, True)
return map_name, player_count, max_player
def GCAPI_ServerSearch(self):
while True:
try:
for provider in self.serverList:
provider_serverlist = self.serverList[provider]
#Go through each server.
for server in provider_serverlist:
#Ping with A2S.
a2s_server = a2s.info(
(server.ServerIP, server.ServerPort), timeout=2)
#Change information.
server.ServerName = a2s_server.server_name
server.ServerMap = a2s_server.map_name
server.ServerPlayers = a2s_server.player_count
gameModeTemp = server.ServerMap.split("_")
server.ServerGameMode = gameModeTemp[0]
#print(f"[SERVER SEARCH - GOOD] Name: {server.ServerName}, Map: {server.ServerMap}, Players: {server.ServerPlayers}/{server.ServerMaxPlayers}")
except BaseException as exception:
#print(f"[SERVER SEARCH - FAIL] Failed to connect to server: {server.ServerIP}:{server.ServerPort}. Reasoning: {exception}")
server.ServerName = ""
server.ServerMap = ""
server.ServerPlayers = -1
def get_server_map(address: str, query_port: int):
a2s_connection = (address, query_port)
try:
map_name = a2s.info(a2s_connection).map_name
return map_name
except socket.timeout:
print("connection timed out")
return
def query(self):
"""
Query the steam server
"""
self.__playerList = [] # clear the playerList
serverAddress = (self.__serverIP, self.__queryPort)
try:
info = a2s.info(serverAddress)
if self.__nameOverride == False:
self.__name = info.server_name
if self.__gameOverride == False:
self.__game = info.game
self.__gameType = info.game # self.__decodeGameType("{server_tags}".format(**info))
self.__map = info.map_name
self.__currentPlayers = info.player_count
self.__maxPlayers = info.max_players
for player in a2s.players(serverAddress):
self.__playerList.append(player.name)
self.__writeToDictionary()
# except valve.source.messages.BrokenMessageError as err:
# print(err)
# if self.__port is not None:
# print("Server " + str(self.__serverIP) + ":" + str(self.__port) + " exists, but "
# + str(self.__queryPort) + " is not the correct query port.")
# else:
# print("Server " + str(self.__serverIP) + " exists, but "
# + str(self.__queryPort) + " is not the correct query port.")
# # give the data dict for the server the minimum amount of data needed to create a ServerInfo object
# self.__dataDict["Status"] = "Offline"
# self.__dataDict["Name"] = self.getName()
# self.__dataDict["Game"] = self.getGame()
except Exception as err: # python-a2s error handling is less than stellar, so this is as good as I can get it
print(err)
if self.__port is not None:
print(
"Server \"" + str(self.__serverIP) + " " +
str(self.__name) + ":" + str(self.__port) +
"\" is either offline, is not a source server, or does not exist"
)
else:
print(
"Server \"" + str(self.__serverIP) + " " +
str(self.__name) +
"\" is either offline, is not a source server, or does not exist"
)
# give the data dict for the server the minimum amount of data needed to create a ServerInfo object
self.__dataDict["Status"] = "Offline"
self.__dataDict["Name"] = self.getName()
self.__dataDict["Game"] = self.getGame()
def get_game_info(self):
info = a2s.info(self.address)
players = a2s.players(self.address)
serv_details = {
'serv_name': info.server_name,
'map': info.map_name,
'player_count': info.player_count,
'max_players': info.max_players,
'bot_count': info.bot_count,
'ping': info.ping,
"players": players
}
return serv_details
async def query_info(self, ctx):
ip = await self.config.guild(ctx.guild).ip()
query_port = await self.config.guild(ctx.guild).query_port()
if ip and query_port:
try:
return a2s.info((ip, int(query_port)), 2)
except socket.timeout:
await ctx.send("Connection timed out to server.")
return None
except socket.gaierror:
await ctx.send("Invalid host address.")
return None
else:
await ctx.send("IP and Port must be set.")
return None
def query_server_info(self, address):
# logger.info("Querying server %s..." % (address_to_str(address)))
try:
info = a2s.info(address)
return info
except socket.timeout:
logger.info("Couldn't contact server %s!" %
address_to_str(address))
self.num_offline += 1
except (a2s.BrokenMessageError, a2s.BufferExhaustedError,
socket.gaierror, ConnectionError, OSError) as e:
logger.error("Connection error querying server: %s" % (e))
self.num_offline += 1
return None
def main():
query_port = os.environ.get("APP_PORT", "2457")
try:
port = int(query_port)
except Exception as e:
raise ValueError(
"APP_PORT must be set to an integer! Was {0}\n{1}".format(
query_port, e))
addr = ('127.0.0.1', port)
try:
query = a2s.info(addr)
except Exception:
raise
print(query.player_count)
def get_server_data(server):
players = None
serverinfo = None
for x in range(2):
try:
players = a2s.players(server)
break
except: # probably socket.timeout...
pass
if players:
for x in range(2):
try:
serverinfo = a2s.info(server)
break
except: # probably socket.timeout...
pass
return (players, serverinfo)
def get(self):
try:
server_info = a2s.info((self.ip_address, self.server_port ))
self.player_list = a2s.players((self.ip_address, self.server_port))
self.server_name = server_info.server_name
self.curr_map = server_info.map_name.split('/')[-1]
self.players = str(server_info.player_count) + '/' + str(server_info.max_players)
self.ping = str(int((server_info.ping* 1000))) + 'ms'
except:
print('Server down :(')
self.server_name = 'Server down :('
self.curr_map = 'Unknown'
self.players = '0'
self.playerstats = 'Unknown'
self.ping = '999ms'
def servers_list(request):
servers = Servers.objects.all()
k = {}
for i in servers:
try:
k[i.id] = a2s.info((i.ip, i.port))
except socket.gaierror:
k[i.id] = False
continue
except socket.timeout:
k[i.id] = False
continue
return render(request, 'servers/servers_list.html', {'servers': k})
async def info(self):
server_info = a2s.info(self.address, 1.0)
server_players = a2s.players(self.address)
# Creates the string of player names used in the embed
player_names = []
for player in server_players:
player_names.append(player.name)
player_names = ("\n".join(map(str, player_names)))
# Update server variables
self.name = str(server_info.server_name)
self.players = player_names
self.player_num = server_info.player_count
self.max_players = server_info.max_players
return {"server_info": server_info, "server_players": server_players}
def get(self):
try:
server_info = a2s.info((self.ip_address, self.server_port))
self.server_name = server_info.server_name
self.connect_link = 'steam://connect/' + str(
self.ip_address) + ':' + str(self.server_port) + '/'
self.curr_map = server_info.map_name.split('/')[-1]
self.players = str(server_info.player_count) + '/' + str(
server_info.max_players)
self.ping = str(int((server_info.ping * 1000))) + 'ms'
except:
self.server_name = '-'
self.connect_link = 'Server is Offline :('
self.curr_map = 'Unknown'
self.players = '-1'
self.playerstats = 'Unknown'
self.ping = '-1ms'
def get_data(request, server_name):
labels = []
number = []
Name_id = Server.objects.get(Name=server_name)
queryset = PlayerCount.objects.filter(Name=Name_id)[:]
for data in queryset:
labels.append(data.timestamp)
number.append(data.player_count)
server = Server.objects.get(Name=server_name)
address = (server.IP, server.Port)
queryset = a2s.info(address, timeout=3.0, encoding=None)
max_player = queryset.max_players
playerdata = {
'labels': labels,
'data': number,
'max': max_player,
}
return JsonResponse(playerdata)
def xiaocaolist():
ip = ['119.188.247.66', '119.188.247.66', '119.188.247.66', '119.188.247.66', '119.188.247.66', '119.188.247.66',
'119.188.247.66', '119.188.247.66', '119.188.247.66', '119.188.247.66']
port = ['27101', '27111', '27121', '27131', '27141', '27151', '27161', '27171', '27181', '27191']
servers_info = []
for (info_ip, info_port) in zip(ip, port):
info_port = int(info_port)
try:
server_info = a2s.info((info_ip, info_port), timeout=0.1)
except socket.timeout as e:
server_info = 'null'
except a2s.BrokenMessageError as e:
server_info = 'null'
else:
pass
servers_info.append(server_info)
return render_template("xiaocaoserverlist.html", infos=servers_info), 200
def respond():
informacion = []
for server in servers:
ip = server.split(":", 1)
address = (ip[0], int(ip[1]))
try:
info = a2s.info(address)
serverinfo = {
"ip": server.replace('45.235.99.158', 'cs.cscagames.com.ar'),
"name": info.server_name,
"map": info.map_name,
"max_players": info.max_players,
"player_count": info.player_count,
}
informacion.append(serverinfo)
except:
pass
return jsonify(informacion)
def __init__(self, game):
super().__init__(game)
try:
a2s_info = a2s.info(tuple(self.address))
except socket_timeout:
return
self.info.online = True
self.info.server_name = a2s_info.server_name
self.info.game_name = a2s_info.game
self.info.map_name = a2s_info.map_name
self.info.player_count = a2s_info.player_count
self.info.max_player_count = a2s_info.max_players
self.info.a2s = {
"folder": a2s_info.folder,
"app_id": a2s_info.app_id,
"bot_count": a2s_info.bot_count,
"password_protected": a2s_info.password_protected,
"vac_enabled": a2s_info.vac_enabled,
"version": a2s_info.version,
}
def playercounter():
labels = []
number = []
for server in Server.objects.all():
address = (server.IP, server.Port)
query = a2s.info(address, timeout=3.0, encoding=None)
playernumber = query.player_count
maxplayer = query.max_players
now = strftime("%H:%M")
serverstat = PlayerCount(timestamp=now, player_count=playernumber, max_player=maxplayer, Name=server)
serverstat.save()
queryset = PlayerCount.objects.all()[:]
for data in queryset:
labels.append(data.timestamp)
number.append(data.player_count)
if len(labels) >= 288:
Name_id = Server.objects.get(Name=server.Name)
queryset = PlayerCount.objects.filter(Name=Name_id)[:]
to_delete = PlayerCount.objects.values()[:1].get()
PlayerCount.objects.filter(id=to_delete['id']).delete()
def get_servers():
try:
with open(CONFIG_FILE, 'r') as f:
PATH = f.readlines()[0]
except FileNotFoundError:
typer.echo(
"Config file not found, run 'csgo configure' to setup the config.")
raise typer.Exit(1)
try:
serverbrowser = vdf.load(open(PATH))
except FileNotFoundError:
typer.echo(
"Path to favourite servers file not correct, change path by running 'csgo configure'"
)
raise typer.Exit(1)
favorite_servers = serverbrowser['Filters']['Favorites']
server_infos = []
for server in favorite_servers:
server = favorite_servers[server]
server_ip = server['address'].split(':')[0]
server_port = int(server['address'].split(':')[1])
address = (server_ip, server_port)
try:
info = a2s.info(address,
timeout=a2s.defaults.DEFAULT_TIMEOUT,
encoding=a2s.defaults.DEFAULT_ENCODING)
server_info = {
"INDEX": len(server_infos),
"NAME": info.server_name,
"MAP": info.map_name,
"PLAYERS": f"{info.player_count}/{info.max_players}",
"ADDRESS": f"{server_ip}:{server_port}",
}
server_infos.append(server_info)
except socket.timeout:
pass
return server_infos
def servers_detail(request, id):
obj = get_object_or_404(Servers, id=id)
try:
s = a2s.info((obj.ip, obj.port))
p = a2s.players((obj.ip, obj.port))
for i in p:
i.duration = time.strftime("%H:%M:%S", time.gmtime(i.duration))
except socket.gaierror:
raise Http404
except socket.timeout:
raise Http404
return render(request, 'servers/servers_detail.html', {
'addr': f'{obj.ip}:{obj.port}',
'players': p,
'server': s
})
def get_status(query_host: str, query_port: int) -> Dict:
status = {
"last_status_update": datetime.utcnow().replace(tzinfo=timezone.utc),
"error": None,
}
try:
info = a2s.info((query_host, query_port))
players = a2s.players((query_host, query_port))
except Exception as e:
status.update({"error": e})
else:
status.update({
"server_name":
info.server_name,
"server_type":
info.server_type,
"platform":
info.platform,
"player_count":
len(players),
"password_protected":
info.password_protected,
"vac_enabled":
info.vac_enabled,
"port":
info.port,
"steam_id":
info.steam_id,
"keywords":
info.keywords,
"game_id":
info.game_id,
"players": [{
"name": pl.name,
"score": pl.score,
"duration": pl.duration
} for pl in players],
})
return status
async def query_logic(ctx, address, bot, sender=None, name=None, guild=None):
sender = sender or ctx.send
data = address.split(":")
try:
info = a2s.info((data[0], int(data[1])))
except socket.timeout:
return await sender("Server timeout! Check the IP:Port")
except socket.gaierror:
return await sender("Resolution error! Check the IP:Port")
except IndexError:
if guild is not None:
return await sender("Please format your command like: `" +
get_prefix(bot, guild.id) +
"query 144.12.123.51:27017`")
return
except Exception as e:
return await sender(
"Unknown error! Check the command, and contact support if this continues."
)
if guild is not None:
last_amount = check_last_amount(bot, guild, name)
if "last" in last_amount and last_amount["last"] == info.player_count:
return
set_last_amount(bot, guild, name, info.player_count)
embed = discord.Embed(title="Server information", type='rich')
embed.add_field(name="Address",
value=address + "%s%s" %
((" 🛡" if info.vac_enabled else ""),
(" 🔒" if info.password_protected else "")))
embed.add_field(name="Server Name", value=info.server_name)
embed.add_field(name="Map", value=info.map_name)
embed.add_field(name="Players",
value=f'{info.player_count}/{info.max_players}%s' %
f' ({info.bot_count} Bot%s)' %
("s" if (info.bot_count != 1) else ""))
embed.add_field(name="Game", value=info.game)
return await sender(embed=embed)
def update_info(self):
try:
self.info = a2s.info(self.address)
except (socket.timeout, OSError, a2s.exceptions.BrokenMessageError):
print("%s: error updating info" % self.name)
self.info = None
def get_srcds_server_info(host, port=27015):
return a2s.info((host, port))
