def __process_server(self):
try:
stats = self.interface.do_query()
logginghelper.log_debug('Received stats from ' + self.interface.server.name)
if stats is None:
return
except Exception as ex:
logginghelper.log_error("Error trying to query server " + self.interface.server.name + ": " + ex.message)
return
try:
with self.database.connect() as db_session:
db_session.begin()
restore_point = self.state.copy()
try:
self.state.update(db_session, stats)
db_session.commit()
logginghelper.log_debug('Updated database for ' + self.interface.server.name)
except Exception as ex:
db_session.rollback()
logginghelper.log_error("Error updating database from query " + self.interface.server.name + ": " + ex.message)
JsonHelper.to_json_file({
'error': traceback.format_exc(),
'company_info': self.state.last_snapshot.company_info,
'game_info': self.state.last_snapshot.game_info,
'client_info': self.state.last_snapshot.client_info
}, "ERROR_" +datetime.datetime.now().strftime("%Y-%m-%d_%H.%M.%S") + "_snapshot_sid" + str(self.state.server_id) + ".json")
self.state.restore(restore_point)
except Exception as ex:
logginghelper.log_error("Error connecting to db while trying to update " + self.interface.server.name + ": " + ex.message)
def search_read(self, model, fields=False, offset=0, limit=False, domain=None, sort=None, groupby=None, api_key=None):
try:
if not verify_api_key(api_key):
return JsonHelper.make_jsondata("AccessError: Verify your api_key", 1)
if groupby:
return self.do_search_read_group(model, fields, offset,limit, domain, sort, groupby)
return JsonHelper.make_jsondata("Sucessful", 0, self.do_search_read(model, fields, offset, limit, domain, sort))
except AccessError:
return JsonHelper.make_jsondata("AccessError: You don't have permission to get data", 1)
except:
return JsonHelper.make_jsondata("ValidationError: ... ", 2)
def do_query(self):
url = self.server.url
post_data = JsonHelper.to_json({
'payload': {
'action': 'get'
},
'password': self.server.password
})
try:
resp = requests.post(url, post_data)
except requests.exceptions.Timeout:
logginghelper.log_warning("Timeout while trying to contact " + self.server.name)
return None
except requests.exceptions.ConnectionException:
logginghelper.log_warning("Error while contacting " + self.server.name)
return None
if not resp.status_code is 200:
logginghelper.log_warning("Http Error " + str(resp.status_code) + " while connecting to " + self.server.name)
return None
resp_dict = JsonHelper.from_json(resp.text)
if not 'status' in resp_dict:
logginghelper.log_warning("Invalid response - no status - from " + self.server.name)
return None
if not resp_dict['status'] is 0:
if 'error' in resp_dict:
logginghelper.log_warning("Error received from Poxy on " + self.server.name +": '" + resp_dict['error'] + "'")
else:
logginghelper.log_warning("Unspecified error response from " + self.server.name)
return None
if not 'payload' in resp_dict:
logginghelper.log_warning("Invalid response - no payload - from " + self.server.name)
else:
if not 'stats' in resp_dict['payload']:
logginghelper.log_warning("Empty stats from " + self.server.name)
else:
stats = resp_dict['payload']['stats']
ottd_stats = OpenTTDStats()
ottd_stats.client_info = stats['client_info']
ottd_stats.game_info = stats['game_info']
ottd_stats.company_info = stats['company_info']
return ottd_stats
return None
def get_fields(self, tname, api_key=None):
try:
if not verify_api_key(api_key):
return JsonHelper.make_jsonresponse("AccessError: Verify your api_key", 1)
Objects = get_object(tname)
if not Objects:
return JsonHelper.make_jsondata("Invalid URL",1)
Model = request.env[Objects.model]
record = Model.fields_get([])
return JsonHelper.make_jsonresponse("Sucessful", 0, record)
except:
return JsonHelper.make_jsondata("AccessError: You dont' have permission to get fields of record!",1)
def __process_server(self):
try:
stats = self.interface.do_query()
logginghelper.log_debug('Received stats from ' +
self.interface.server.name)
if stats is None:
return
except Exception as ex:
logginghelper.log_error("Error trying to query server " +
self.interface.server.name + ": " +
ex.message)
return
try:
with self.database.connect() as db_session:
db_session.begin()
restore_point = self.state.copy()
try:
self.state.update(db_session, stats)
db_session.commit()
logginghelper.log_debug('Updated database for ' +
self.interface.server.name)
except Exception as ex:
db_session.rollback()
logginghelper.log_error(
"Error updating database from query " +
self.interface.server.name + ": " + ex.message)
JsonHelper.to_json_file(
{
'error': traceback.format_exc(),
'company_info':
self.state.last_snapshot.company_info,
'game_info': self.state.last_snapshot.game_info,
'client_info': self.state.last_snapshot.client_info
}, "ERROR_" +
datetime.datetime.now().strftime("%Y-%m-%d_%H.%M.%S") +
"_snapshot_sid" + str(self.state.server_id) + ".json")
self.state.restore(restore_point)
except Exception as ex:
logginghelper.log_error(
"Error connecting to db while trying to update " +
self.interface.server.name + ": " + ex.message)
def load(self, db):
db.execute("SELECT * FROM state WHERE server_id = %(server_id)s",
{'server_id': self.server_id})
state = db.fetch_results()
cols = db.columns()
if len(state) == 1:
state = state[0]
snapshot = JsonHelper.from_json(state[cols['last_snapshot']])
self.last_snapshot = OpenTTDStats()
self.last_snapshot.company_info = snapshot['company_info']
self.last_snapshot.game_info = snapshot['game_info']
self.last_snapshot.client_info = snapshot['client_info']
self.last_snapshot_time = state[cols['last_snapshot_time']]
self.current_game_id = state[cols['game_id']]
assert self.current_game_id > -1
if self.current_game_id > -1:
db.execute(
"SELECT * FROM game_company WHERE game_id = %(game_id)s AND end IS NULL",
{'game_id': self.current_game_id})
companies = db.fetch_results()
if len(companies) > 0:
cols = db.columns()
for company in companies:
company_id = company[cols['company_id']]
self.current_companies[company_id] = {
'id': company[cols['id']],
'game_id': company[cols['game_id']],
'company_id': company_id,
'start': company[cols['start']],
'color': company[cols['color']],
'manager': company[cols['manager']],
'name': company[cols['name']],
'clients': {}
}
# load clients...
db.execute(
"SELECT * FROM game_company_client WHERE game_id = %(game_id)s AND "
"company_id = %(company_id)s", {
'game_id': self.current_game_id,
'company_id': company[cols['id']]
})
clients = db.fetch_results()
client_cols = db.columns()
if len(clients) > 0:
for client in clients:
key = client[
client_cols['name']] + '|' + client[
client_cols['hostname']]
self.current_companies[company_id]['clients'][
key] = client[client_cols['client_id']]
def create(self, tname, record, api_key=None):
logging.warning("assssssssssss")
try:
if not verify_api_key(api_key):
return JsonHelper.make_jsondata("AccessError: Verify your api_key", 1)
Objects = get_object(tname)
if not Objects:
return JsonHelper.make_jsondata("Invalid URL", 1)
logging.warning("vvvvvvvvvvvvvvvvvvvvvv")
logging.warning(record['value_ids'])
# if(tname == )
record['value_ids'] = [(4,record['value_ids'],0)]
# record['value_ids'] = json.dumps(record['value_ids'])
logging.warning(record['value_ids'])
Model = request.session.model(Objects.model)
model = Model.create(record)
return JsonHelper.make_jsondata("Create Successful", 0)
except ValueError:
logging.warning(ValueError)
return JsonHelper.make_jsondata("AccessError: You dont' have permission to create a record!", 1)
def get(self, tname,id=None, api_key=None):
try:
if not verify_api_key(api_key):
return JsonHelper.make_jsonresponse("AccessError: Verify your api_key", 1)
Objects = get_object(tname)
if not Objects:
return JsonHelper.make_jsonresponse("Invalid URL", 1)
model = Objects.model
fields = string_to_fields(Objects.field)
offset = Objects.offset
limit = Objects.limit
domain = string_to_domain(Objects.domain)
if id:
domain.append(['id','=', id])
sort = string_to_sort(Objects.sort)
if Objects.groupby is not False:
return JsonHelper.make_jsonresponse("Sucessful", 0, self.do_search_read_group(model, fields, offset,limit, domain, sort, Objects.groupby))
else:
return JsonHelper.make_jsonresponse("Sucessful", 0, self.do_search_read(model, fields, offset, limit, domain, sort))
except :
return JsonHelper.make_jsonresponse("AccessError: You don't have permission to get data", 1)
def load(self, db):
db.execute("SELECT * FROM state WHERE server_id = %(server_id)s", {'server_id': self.server_id})
state = db.fetch_results()
cols = db.columns()
if len(state) == 1:
state = state[0]
snapshot = JsonHelper.from_json(state[cols['last_snapshot']])
self.last_snapshot = OpenTTDStats()
self.last_snapshot.company_info = snapshot['company_info']
self.last_snapshot.game_info = snapshot['game_info']
self.last_snapshot.client_info = snapshot['client_info']
self.last_snapshot_time = state[cols['last_snapshot_time']]
self.current_game_id = state[cols['game_id']]
assert self.current_game_id > -1
if self.current_game_id > -1:
db.execute("SELECT * FROM game_company WHERE game_id = %(game_id)s AND end IS NULL",
{'game_id': self.current_game_id})
companies = db.fetch_results()
if len(companies) > 0:
cols = db.columns()
for company in companies:
company_id = company[cols['company_id']]
self.current_companies[company_id]= {
'id': company[cols['id']],
'game_id': company[cols['game_id']],
'company_id': company_id,
'start': company[cols['start']],
'color': company[cols['color']],
'manager': company[cols['manager']],
'name': company[cols['name']],
'clients': {}
}
# load clients...
db.execute("SELECT * FROM game_company_client WHERE game_id = %(game_id)s AND "
"company_id = %(company_id)s", {'game_id': self.current_game_id, 'company_id': company[cols['id']]})
clients = db.fetch_results()
client_cols = db.columns()
if len(clients) > 0:
for client in clients:
key = client[client_cols['name']] + '|' + client[client_cols['hostname']]
self.current_companies[company_id]['clients'][key] = client[client_cols['client_id']]
def update_delete(self, tname, id, record=None,api_key=None):
try:
if not verify_api_key(api_key):
return JsonHelper.make_jsondata("AccessError: Verify your api_key", 1)
Objects = get_object(tname)
if not Objects:
return JsonHelper.make_jsondata("Invalid URL",1)
Model = request.session.model(Objects.model)
model = Model.browse([id])
if not model.exists():
return JsonHelper.make_jsondata("Record id = " + str(id) +" is not exists", 1)
if request.httprequest.method == 'PUT':
model.write(record)
return JsonHelper.make_jsondata("UPDATE Successful",0)
if request.httprequest.method == 'DELETE':
model.unlink()
return JsonHelper.make_jsondata("DELETE Successful",0)
except:
return JsonHelper.make_jsondata("AccessError: You dont' have permission to update a record!",1)
def do_query(self):
connection = AdminConnection()
connection.configure(
name="ottdstats",
password=self.server.password,
host=self.server.host,
port=self.server.port
)
if not connection.connect():
logging.warning("Could not connect to " + self.server.name)
return None
# The order is important here - since the first poll (game_info) should return version / welcome
stats = OpenTTDStats()
stats.game_info = self.__poll_game_info(connection)
stats.company_info = self.__poll_admin_array_info(connection, UpdateType.COMPANY_INFO, ServerCompanyInfo.packetID)
stats.client_info = self.__poll_admin_array_info(connection, UpdateType.CLIENT_INFO, ServerClientInfo.packetID)
company_stats = self.__poll_admin_array_info(connection, UpdateType.COMPANY_STATS, ServerCompanyStats.packetID)
company_economy = self.__poll_admin_array_info(connection, UpdateType.COMPANY_ECONOMY, ServerCompanyEconomy.packetID)
if company_stats:
self.__match_company_stats(stats.company_info, company_stats)
if company_economy:
self.__match_company_economy(stats.company_info, company_economy)
connection.disconnect()
# normalize values (convert to unicode)
stats.game_info = JsonHelper.from_json(JsonHelper.to_json(stats.game_info))
stats.company_info = JsonHelper.from_json(JsonHelper.to_json(stats.company_info))
stats.client_info = JsonHelper.from_json(JsonHelper.to_json(stats.client_info))
return stats
def save(self):
try:
JsonHelper.to_json_file(self.config, Config.__full_path)
except IOError:
pass
def load(self):
try:
self.config = JsonHelper.from_json_file(Config.__full_path)
return True
except IOError:
return False
def get_json(self):
return JsonHelper.to_json({
'company_info': self.company_info,
'game_info': self.game_info,
'client_info': self.client_info
})
def save(self):
try:
JsonHelper.to_json_file(self.config, Config.__full_path)
except IOError:
pass
def load(self):
try:
self.config = JsonHelper.from_json_file(Config.__full_path)
return True
except IOError:
return False