def __init__(self):
self.game_table = GameTable(helpers.load_table(GAME_CONFIG_FILE))
try:
import pygeoip
try:
open(GEOIP_DATA_FILE)
helpers.debug_msg([
CORE_MSG,
i18n.
_("GeoIP data file %(geoip_data_file)s opened successfully."
) % {
'geoip_data_file': GEOIP_DATA_FILE
}
])
self.geolocation = pygeoip
except FileNotFoundError:
helpers.debug_msg([
CORE_MSG,
i18n._("GeoIP data file not found. Disabling geolocation.")
])
self.geolocation = None
except ImportError:
helpers.debug_msg([
CORE_MSG,
i18n._("PyGeoIP not found. Disabling geolocation.")
])
self.geolocation = None
def stat_master(game: str, game_info: dict, master_list: list):
"""Stats the master server"""
server_table = []
backend_config_object = helpers.load_table(BACKEND_CONFIG)
protocol = backend_config_object["protocol"]["version"]
for master_uri in master_list:
master_page_uri = master_uri.strip("/") + "/?version=" + protocol
try:
master_page_object = requests.get(master_page_uri)
master_page = master_page_object.text
except:
print(
i18n._(RIGSOFRODS_MSG),
i18n._("Accessing URI %(uri)s failed with error code %(code)s.")
% {"uri": master_page_uri, "code": "unknown"},
)
continue
try:
temp_table = adapt_server_list(game, master_page)
except:
print(i18n._(RIGSOFRODS_MSG), i18n._("Error parsing URI %(uri)s.") % {"uri": master_page_uri})
continue
server_table += temp_table
ping.add_rtt_info(server_table)
return server_table, None
def stat_master(game: str, game_info: dict, master_list: list):
"""Stats the master server"""
try:
backend_config_object = helpers.load_table(BACKEND_CONFIG)
server_json_table = []
server_table = []
for master_uri in master_list:
server_json_table += get_json(master_uri)
for entry in server_json_table:
entry_dict = parse_json_entry(entry)
server_table.append(entry_dict)
ping.add_rtt_info(server_table)
for i in range(len(server_table)):
entry = server_table[i]
entry["game_id"] = game
server_table[i] = entry
return server_table
except Exception as e:
raise Exception(helpers.debug_msg_str([BACKENDCAT_MSG + MINETEST_MSG, e.args[0]]))
def stat_master(game: str, game_info: dict, master_list: list):
"""Stats the master server"""
try:
backend_config_object = helpers.load_table(BACKEND_CONFIG)
server_json_table = []
server_table = []
for master_uri in master_list:
server_json_table += get_json(master_uri)
for entry in server_json_table:
entry_dict = parse_json_entry(entry)
server_table.append(entry_dict)
ping.add_rtt_info(server_table)
for i in range(len(server_table)):
entry = server_table[i]
entry["game_id"] = game
server_table[i] = entry
return server_table
except Exception as e:
raise Exception(
helpers.debug_msg_str([BACKENDCAT_MSG + MINETEST_MSG, e.args[0]]))
def stat_master(game, game_info, master_list, proxy=None):
"""Stats the master server"""
backend_config_object = helpers.load_table(BACKEND_CONFIG)
server_json_table = []
server_table = []
for master_uri in master_list:
master_page_uri = master_uri.strip('/') + '/list'
try:
server_json_table += get_json(master_page_uri)
except (ConnectionError, ValueError) as e:
print(BACKENDCAT_MSG + MINETEST_MSG, e)
for entry in server_json_table:
entry_dict = parse_json_entry(entry)
server_table.append(entry_dict)
ping.add_rtt_info(server_table)
if proxy is not None:
for entry in server_table:
proxy.append(entry)
return server_table
def stat_master(game: str, game_info: dict, master_list: list, proxy=None) -> List[Dict[str, Union[str, int, bool]]]:
"""Stats the master server"""
backend_config_object = helpers.load_table(BACKEND_CONFIG)
protocol = backend_config_object["protocol"]["version"]
server_table = []
for master_uri in master_list:
master_page_uri = master_uri.strip('/') + '/?version=' + protocol
try:
master_page_object = requests.get(master_page_uri)
master_page = master_page_object.text
except:
print(i18n._(RIGSOFRODS_MSG), i18n._("Accessing URI %(uri)s failed with error code %(code)s.") % {'uri': master_page_uri, 'code': "unknown"})
continue
try:
temp_table = adapt_server_list(game, master_page)
except:
print(i18n._(RIGSOFRODS_MSG), i18n._("Error parsing URI %(uri)s.") % {'uri': master_page_uri})
continue
server_table += temp_table
ping.add_rtt_info(server_table)
if proxy is not None:
for entry in server_table:
proxy.append(entry)
return server_table
def load(self, callback_postgenload=None):
"""Loads configuration."""
default_common_settings_table = helpers.load_table(
self.default_common_settings_path)
default_game_settings_table = helpers.load_table(
self.default_game_settings_path)
user_common_settings_table = helpers.load_table(
self.user_common_settings_path)
# Load into common settings table
for group in self.common_settings_table:
self.settings_table[group] = {} # type: dict
for option in self.common_settings_table[group]:
# Define variables
value = default_common_settings_table[group][option]
try:
value = user_common_settings_table[group][option]
except (ValueError, KeyError, TypeError):
pass
self.settings_table[group][option] = value
if callback_postgenload is not None:
callback_postgenload(self.common_settings_table, group,
option, value)
# Load game settings table
user_game_settings_table = helpers.load_table(
self.user_game_settings_path)
# Set game settings
for game in self.core.game_table.get_game_set():
for option in self.core.game_table.get_game_settings(game):
value = default_game_settings_table[game][option]
try:
value = user_game_settings_table[game][option]
except (ValueError, KeyError, TypeError):
pass
self.core.game_table.set_game_setting(game, option, value)
def load(self, callback_postgenload=None):
"""Loads configuration."""
default_common_settings_table = helpers.load_table(self.default_common_settings_path)
default_game_settings_table = helpers.load_table(self.default_game_settings_path)
user_common_settings_table = helpers.load_table(self.user_common_settings_path)
# Load into common settings table
for group in self.common_settings_table:
self.settings_table[group] = {} # type: dict
for option in self.common_settings_table[group]:
# Define variables
value = default_common_settings_table[group][option]
try:
value = user_common_settings_table[group][option]
except (ValueError, KeyError, TypeError):
pass
self.settings_table[group][option] = value
if callback_postgenload is not None:
callback_postgenload(self.common_settings_table, group, option, value)
# Load game settings table
user_game_settings_table = helpers.load_table(self.user_game_settings_path)
# Set game settings
for game in self.core.game_table.get_game_set():
for option in self.core.game_table.get_game_settings(game):
value = default_game_settings_table[game][option]
try:
value = user_game_settings_table[game][option]
except (ValueError, KeyError, TypeError):
pass
self.core.game_table.set_game_setting(game, option, value)
def __init__(self):
self.game_table = GameTable(helpers.load_table(GAME_CONFIG_FILE))
try:
import pygeoip
try:
open(GEOIP_DATA_FILE)
helpers.debug_msg(
[
CORE_MSG,
i18n._("GeoIP data file %(geoip_data_file)s opened successfully.")
% {"geoip_data_file": GEOIP_DATA_FILE},
]
)
self.geolocation = pygeoip
except FileNotFoundError:
helpers.debug_msg([CORE_MSG, i18n._("GeoIP data file not found. Disabling geolocation.")])
self.geolocation = None
except ImportError:
helpers.debug_msg([CORE_MSG, i18n._("PyGeoIP not found. Disabling geolocation.")])
self.geolocation = None
def stat_master(game: str, game_info: dict, master_list: list):
"""Stats the master server"""
server_table = []
backend_config_object = helpers.load_table(BACKEND_CONFIG)
protocol = backend_config_object["protocol"]["version"]
for master_uri in master_list:
master_page_uri = master_uri.strip('/') + '/?version=' + protocol
try:
master_page_object = requests.get(master_page_uri)
master_page = master_page_object.text
except:
print(
i18n._(RIGSOFRODS_MSG),
i18n._(
"Accessing URI %(uri)s failed with error code %(code)s.") %
{
'uri': master_page_uri,
'code': "unknown"
})
continue
try:
temp_table = adapt_server_list(game, master_page)
except:
print(
i18n._(RIGSOFRODS_MSG),
i18n._("Error parsing URI %(uri)s.") %
{'uri': master_page_uri})
continue
server_table += temp_table
ping.add_rtt_info(server_table)
return server_table, None
def stat_master(game: str, game_info: dict, master_list: list):
hosts_array = []
qstat_stdin_object = ""
master_server_uri = None
stat_start_time = None
stat_end_time = None
game_name = game_info["name"]
backend_config_object = helpers.load_table(BACKEND_CONFIG)
qstat_master_type = backend_config_object['game'][game]['master_type']
qstat_server_type = backend_config_object['game'][game]['server_type']
if "server_gamename" not in backend_config_object['game'][game].keys():
backend_config_object['game'][game]['server_gamename'] = None
server_game_name = backend_config_object['game'][game]['server_gamename']
if "server_gamename" in backend_config_object['game'][game].keys():
server_game_name = backend_config_object['game'][game][
'server_gamename']
server_game_type = None
if "server_gametype" in backend_config_object['game'][game].keys():
server_game_type = backend_config_object['game'][game][
'server_gametype']
for entry in master_list:
entry = entry.strip()
if '://' in entry:
entry_protocol, entry_host = entry.split('://')
else:
entry_protocol = 'master'
entry_host = entry
hosts_array.append(entry_host)
hosts_array = list(set(hosts_array))
qstat_cmd = [
"qstat", "-xml", "-utf8", "-maxsim", "9999", "-sendinterval", "1",
"-R", "-P", "-f", "-"
]
qstat_stdin_descriptor = backend_config_object['game'][game]['master_type']
if server_game_type is not None:
qstat_stdin_descriptor = qstat_stdin_descriptor + ",game=" + server_game_type
for entry in hosts_array:
qstat_stdin_object = qstat_stdin_object + qstat_stdin_descriptor + " " + entry + "\n"
debug_msg(game_name, i18n._("Requesting server info."))
stat_start_time = time.time()
try:
qstat_output_raw, _ = subprocess.Popen(
qstat_cmd, stdin=subprocess.PIPE,
stdout=subprocess.PIPE).communicate(
input=qstat_stdin_object.strip().encode())
qstat_output = qstat_output_raw.decode()
except Exception as e:
raise Exception(
helpers.debug_msg_str([QSTAT_MSG, game_name, e.args[0]]))
stat_end_time = time.time()
stat_total_time = stat_end_time - stat_start_time
debug_msg(
game_name,
i18n._("Received server info. Elapsed time: %(stat_time)s s.") %
{'stat_time': round(stat_total_time, 2)})
parse_start_time = time.time()
server_table = adapt_server_list(qstat_output, game, game_name,
qstat_master_type, qstat_server_type,
server_game_name, server_game_type)
parse_end_time = time.time()
debug_msg(
game_name,
i18n._("Parsed QStat response. Elapsed time: %(parse_time)s ms") %
{'parse_time': round((parse_end_time - parse_start_time) * 1000, 2)})
return server_table
def stat_master(game, game_info, master_list, proxy=None):
hosts_array = []
qstat_stdin_object = ""
master_server_uri = None
stat_start_time = None
stat_end_time = None
game_name = game_info["name"]
backend_config_object = helpers.load_table(BACKEND_CONFIG)
qstat_master_type = backend_config_object["game"][game]["master_type"]
qstat_server_type = backend_config_object["game"][game]["server_type"]
if "server_gamename" not in backend_config_object["game"][game].keys():
backend_config_object["game"][game]["server_gamename"] = None
server_game_name = backend_config_object["game"][game]["server_gamename"]
if "server_gamename" in backend_config_object["game"][game].keys():
server_game_name = backend_config_object["game"][game]["server_gamename"]
server_game_type = None
if "server_gametype" in backend_config_object["game"][game].keys():
server_game_type = backend_config_object["game"][game]["server_gametype"]
for entry in master_list:
entry = entry.strip()
if "://" in entry:
entry_protocol, entry_host = entry.split("://")
else:
entry_protocol = "master"
entry_host = entry
hosts_array.append(entry_host)
hosts_array = list(set(hosts_array))
qstat_cmd = ["qstat", "-xml", "-utf8", "-maxsim", "9999", "-sendinterval", "1", "-R", "-P", "-f", "-"]
qstat_stdin_descriptor = backend_config_object["game"][game]["master_type"]
if server_game_type is not None:
qstat_stdin_descriptor = qstat_stdin_descriptor + ",game=" + server_game_type
for entry in hosts_array:
qstat_stdin_object = qstat_stdin_object + qstat_stdin_descriptor + " " + entry + "\n"
debug_msg(game_name, i18n._("Requesting server info."))
stat_start_time = time.time()
try:
qstat_output_raw, _ = subprocess.Popen(qstat_cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE).communicate(
input=qstat_stdin_object.strip().encode()
)
qstat_output = qstat_output_raw.decode()
except Exception as e:
debug_msg(game_name, e.args[0])
proxy.append(Exception)
return Exception
stat_end_time = time.time()
stat_total_time = stat_end_time - stat_start_time
debug_msg(
game_name,
i18n._("Received server info. Elapsed time: %(stat_time)s s.") % {"stat_time": round(stat_total_time, 2)},
)
parse_start_time = time.time()
server_table = adapt_server_list(
qstat_output, game, game_name, qstat_master_type, qstat_server_type, server_game_name, server_game_type
)
parse_end_time = time.time()
debug_msg(
game_name,
i18n._("Parsed QStat response. Elapsed time: %(parse_time)s ms")
% {"parse_time": round((parse_end_time - parse_start_time) * 1000, 2)},
)
if proxy is not None:
for entry in server_table:
proxy.append(entry)
return server_table
