async def main(self):
print(f'Connecting to websocket server: {ConfigManager.get("websocket_uri").format("xxxxx")}')
self.server = ServerAdapterFactory.get_adapter(
ConfigManager.get('server_adapter'),
ConfigManager.get('websocket_uri').format(ConfigManager.get('auth_token'))
)
await self.saved_data.init_db()
await self.server.exec_with_context(self.run)
def test_fron_stream(self):
stream = open("../config/test_config/chat.yaml", "r")
cfg = ConfigManager(stream)
self.assertIsNotNone(cfg.config)
self.assertIsInstance(cfg.config, dict)
self.assertIsNotNone(cfg.get("meta"))
self.assertEqual(cfg.get("meta"), cfg["meta"])
stream.close()
async def store_match(self, match: GameInstance, score_white: int, score_black: int):
if match.color == 'white':
white_username = ConfigManager.get('username') or ''
black_username = match.opponent
else:
black_username = ConfigManager.get('username') or ''
white_username = match.opponent
if white_username == black_username:
winner = 'self-challenge'
elif score_white > score_black:
winner = 'white'
elif score_black > score_white:
winner = 'black'
else:
winner = 'tie'
match_params = (
self.next_match_id,
match.board_id,
match.start,
match.end,
white_username,
black_username,
score_white,
score_black,
winner,
)
match_id = self.next_match_id
cursor = await self.conn.execute(self.match_check_query, (match.board_id,))
if await cursor.fetchone():
print(f'Duplicate match: {match.board_id}')
return
cursor = await self.conn.execute(self.match_insert_query, match_params)
print(f'Saved match: {match.board_id} as {match_id}')
self.next_match_id = cursor.lastrowid
if match.save_history:
await self.store_moves(match_id, match.move_history)
else:
print(f'Moves not available for match {match_id}')
async def exec_with_context(self, callback: callable):
while True:
try:
async with websockets.connect(self.uri) as self.websocket:
logger.info('Connected to websocket server')
await callback()
except Exception as e:
print(f'Error: {e}')
logger.error(f'Error: {e}')
print('Reconnecting...')
logger.info('Reconnecting...')
if ConfigManager.get('debug'):
raise
def start():
# Logging
logging.basicConfig(filename="FA_bot.log", level=logging.DEBUG, format="%(asctime)-15s %(message)s")
logging.info("FAbot starting up")
# Configuration file
logging.info("Reading configuration")
config = ConfigManager("config.ini")
client_email = config.get("email")
client_pass = config.get("password")
event_manager.announcement_channels = config.get_json("announcement_channels", default=[])
# TODO: probably event manager should take channels from client instead?
main_client.channel_whitelist = config.get_json("channel_whitelist", default=[])
main_client.announcement_channels = config.get_json("announcement_channels", default=[])
main_client.welcome_pm = config.get("welcome_pm")
main_client.join_announcement = config.get("join_announcement")
main_client.leave_announcement = config.get("leave_announcement")
# Game servers
game_servers.game_servers['arma'] = game_servers.ArmaServer(
ip=config.get("arma_server_ip"),
port=int(config.get("arma_server_port"))
)
game_servers.game_servers['insurgency'] = game_servers.InsurgencyServer(
ip=config.get("insurgency_server_ip"),
port=int(config.get("insurgency_server_port"))
)
# Discord client
logging.info("Logging into Discord")
main_client.login(client_email, client_pass)
if not main_client.is_logged_in:
logging.critical("Logging into Discord failed")
print('Logging in to Discord failed')
exit(1)
logging.info("Entering main message event loop")
main_client.run()
def __init__(
self,
board_id: str,
opponent: str,
color: str,
board: str,
strategy: AIStrategy,
):
self.player = ConfigManager.get('username') or ''
self.board_id = board_id
self.opponent = opponent
self.color = color
self.strategy = strategy
self.board = Board(board)
self.start = datetime.now()
self.save_history = True
self.move_history = []
async def play(self,
turn_token: str,
server: BaseServerAdapter,
color: str,
moves_left: int,
board: str = None):
if board and self.player != self.opponent:
opponent_color = 'white' if color != 'white' else 'black'
try:
opponent_move = self.board.update(board, opponent_color)
if opponent_move.is_valid():
opponent_move.execute(self.board)
except BoardDesyncException:
if self.save_history:
print('Disabling move history for this game')
self.save_history = False
self.move_history = []
else:
if self.save_history:
self.move_history.append(opponent_move)
move = self.strategy.play(self.board, color, moves_left)
move.execute(self.board)
if self.save_history:
self.move_history.append(move)
x1, y1, x2, y2 = move.to_coords()
await server.send(
'move', {
'board_id': self.board_id,
'turn_token': turn_token,
'from_row': y1,
'from_col': x1,
'to_row': y2,
'to_col': x2,
})
if ConfigManager.get('print_match'):
print(f'{color} vs {self.opponent}:')
for row in self.board.current:
print(row)
print()
def create_tables():
config = ConfigManager()
conn = sqlite3.connect(config.get("application", "dbname"))
cursor = conn.cursor()
cursor.execute("DROP TABLE IF EXISTS config")
cursor.execute("DROP TABLE IF EXISTS methods")
cursor.execute("DROP TABLE IF EXISTS methods_config")
cursor.execute("DROP TABLE IF EXISTS models")
conn.commit()
cursor.execute(
"""CREATE TABLE config
(
id integer NOT NULL,
host character varying NOT NULL,
user character varying NOT NULL,
password character varying NOT NULL,
port integer NOT NULL,
database character varying NOT NULL,
PRIMARY KEY (id)
)"""
)
cursor.execute(
"""CREATE TABLE models
(
id integer NOT NULL,
name character varying NOT NULL,
class_name character varying,
use boolean DEFAULT 0,
PRIMARY KEY (id)
)"""
)
cursor.execute(
"""CREATE TABLE methods_config
(
id integer NOT NULL,
model_id integer NOT NULL,
method_name character varying NOT NULL,
async boolean DEFAULT 0,
use boolean DEFAULT 1,
UNIQUE(method_name, model_id),
PRIMARY KEY (id),
FOREIGN KEY(model_id) REFERENCES models(id)
)"""
)
cursor.execute(
"""CREATE TABLE methods
(
id integer NOT NULL,
model_id integer NOT NULL,
method_name character varying NOT NULL,
field_name character varying NOT NULL,
use boolean DEFAULT 0,
PRIMARY KEY (id),
UNIQUE(method_name, field_name, model_id),
FOREIGN KEY(model_id) REFERENCES models(id)
)"""
)
conn.commit()
insert_db_tables()
from config_manager import ConfigManager
############################
## HTTP POSTS
############################
import httplib
from xml.dom import minidom
def getText(nodelist):
rc = []
for node in nodelist:
if node.nodeType == node.TEXT_NODE:
rc.append(node.data)
return ''.join(rc)
http_host = ConfigManager.get("app", "callback_host");
http_site = ConfigManager.get("app", "callback_site");
connection = httplib.HTTPConnection(http_host)
connection.request("GET", "/" + http_site)
response = connection.getresponse()
if response.status == 200:
data = response.read()
dom = minidom.parseString(data)
elements = dom.getElementsByTagName("href")
if len(elements) > 0:
print getText(elements[0].childNodes)
else:
print "ErrorCode: %d", response.status
connection.close()
if os.path.exists(file):
fp = open(file, "r")
content = fp.read()
fp.close()
return content
def writeFile(file, content):
fp = open(file, "w")
fp.write(content)
fp.close()
config_manager = ConfigManager()
config = config_manager.get()
#Run all languages to group all the words
try:
for language in config['languages']:
words = []
try:
if not (config['wake_word'] in words):
words.append(config['wake_word'])
except KeyError:
print('Wake word required')
sys.exit(1)
pass
WSGI_APPLICATION = 'vilogged.wsgi.application'
# Database
# https://docs.djangoproject.com/en/1.8/ref/settings/#databases
DATABASES = {
'default': {}
}
DATABASES['default']['NAME'] = DB_CONFIG['name']
DATABASES['default']['ENGINE'] = DB_CONFIG['engine']
DATABASES['default']['HOST'] = DB_CONFIG['host']
DATABASES['default']['USER'] = DB_CONFIG['user']
DATABASES['default']['PASSWORD'] = DB_CONFIG['password']
if DB_CONFIG.get('port'):
DATABASES['default']['PORT'] = DB_CONFIG['port']
if DB_CONFIG.get('options'):
DATABASES['default']['OPTIONS'] = DB_CONFIG['options']
# Internationalization
# https://docs.djangoproject.com/en/1.8/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'Africa/Lagos'
#USE_I18N = True
#USE_L10N = True
from flask_jwt import JWT
from security import authenticate, identity as identity_function
from user import UserRegister
from app_logging import AppLogger
from config_manager import ConfigManager
from connection.db import DbInit
from item import Item, ItemList
from datetime import timedelta
import os
DEFAULT_PORT = 5050
logger = AppLogger.get_logger(__name__)
app = Flask(__name__)
app.secret_key = os.environ.get("JWT_SECRET",
ConfigManager.get("jwt_secret", "jose"))
api = Api(app)
app.config["JWT_EXPIRATION_DELTA"] = timedelta(
seconds=3600) # 1 hour expiration time
# config JWT auth key name to be 'email' instead of default 'username'
app.config["JWT_AUTH_USERNAME_KEY"] = "email"
jwt = JWT(app, authenticate, identity_function) # new endpont '/auth'
# Requires Authorization header
# JWT <token>
@jwt.auth_response_handler
def customized_response_handler(access_token, identity):
async def run(self):
if ConfigManager.get('interface'):
asyncio.create_task(self.cli_listener())
while True:
try:
response = await self.server.recv()
if response['event'] == 'update_user_list':
if self.user_list != response['data']['users_list']:
self.user_list = response['data']['users_list']
print(f'Online users: {self.user_list}')
elif response['event'] == 'gameover':
game_instance = self.game_list.pop(response['data']['board_id'], None)
white_score = int(response['data']['white_score'])
black_score = int(response['data']['black_score'])
if game_instance:
color = game_instance.color
opponent = game_instance.opponent
game_instance.end = datetime.now()
asyncio.create_task(self.saved_data.store_match(game_instance, white_score, black_score))
else:
if response['data']['white_username'] == ConfigManager.get('username') or '':
color = 'white'
opponent = response['data']['black_username']
else:
color = 'black'
opponent = response['data']['white_username']
print(f'Game results for board: {response["data"]["board_id"]}')
print(f'Opponent: {opponent}')
if response['data']['white_username'] == response['data']['black_username']:
print(f'Self-challenge: w -> {white_score} | b -> {black_score}')
else:
if white_score > black_score:
if color == 'white':
print(f'Victory as white: {white_score} to {black_score} points')
else:
print(f'Defeat as black: {black_score} to {white_score} points')
elif black_score > white_score:
if color == 'black':
print(f'Victory as black: {black_score} to {white_score} points')
else:
print(f'Defeat as white: {white_score} to {black_score} points')
else:
print(f'Tie: {white_score} points')
elif response['event'] == 'ask_challenge':
if selfchallenge := response['data']['username'] == ConfigManager.get('username'):
print('Self-challenge requested')
else:
print(f'Challenger: {response["data"]["username"]}')
if (ConfigManager.get('accept_challenges')
or selfchallenge)\
and len(self.game_list) < (ConfigManager.get('max_games') or 1):
game_count = 0
for game in self.game_list.values():
if game.opponent == response["data"]["username"]:
game_count += 1
if not selfchallenge or game_count <= (ConfigManager.get('max_games_per_user') or 1):
await self.server.send(
action='accept_challenge',
data={'board_id': response['data']['board_id']}
)
print(f'Challenge accepted:\n'
f'Challenger: {response["data"]["username"]}\n'
f'Board ID: {response["data"]["board_id"]}')
else:
print(f'Challenge rejected:\n'
f'Challenger: {response["data"]["username"]}\n'
f'Board ID: {response["data"]["board_id"]}')
elif response['event'] == 'your_turn':
if game_instance := self.game_list.get(response['data']['board_id']):
asyncio.create_task(game_instance.play(
turn_token=response['data']['turn_token'],
server=self.server,
board=response['data']['board'],
color=response['data']['actual_turn'],
moves_left=response['data']['move_left'],
))
else:
new_instance = GameInstance(
board_id=response['data']['board_id'],
opponent=response['data']['opponent_username'],
color=response['data']['actual_turn'],
board=response['data']['board'],
strategy=AIStrategy(),
)
self.game_list[response['data']['board_id']] = new_instance
asyncio.create_task(new_instance.play(
turn_token=response['data']['turn_token'],
server=self.server,
color=response['data']['actual_turn'],
moves_left=response['data']['move_left'],
))
print(f'New game - id: {new_instance.board_id} '
f'- color: {new_instance.color} '
f'- opponent: {new_instance.opponent}')
def __init__(self):
self.db_file = ConfigManager.get(
"database", Path(__file__).parent / DEFAULT_DB
)
board=response['data']['board'],
color=response['data']['actual_turn'],
moves_left=response['data']['move_left'],
))
else:
new_instance = GameInstance(
board_id=response['data']['board_id'],
opponent=response['data']['opponent_username'],
color=response['data']['actual_turn'],
board=response['data']['board'],
strategy=AIStrategy(),
)
self.game_list[response['data']['board_id']] = new_instance
asyncio.create_task(new_instance.play(
turn_token=response['data']['turn_token'],
server=self.server,
color=response['data']['actual_turn'],
moves_left=response['data']['move_left'],
))
print(f'New game - id: {new_instance.board_id} '
f'- color: {new_instance.color} '
f'- opponent: {new_instance.opponent}')
else:
print(response)
except self.server.exception:
raise
except Exception as e:
print(f'Error: {e}')
if ConfigManager.get('debug'):
raise
format='[%(asctime)s] %(levelname)s (%(name)s): %(message)s')
logger = logging.getLogger(__name__)
# Override stored configuration with parameters
if cmd_args.token:
logger.info('Using token from command line')
config['auth_token'] = cmd_args.token
if cmd_args.interface:
logger.info('Command line interface enabled')
config['interface'] = True
# Create configuration manager instance
cfg_manager = ConfigManager(config)
# Override log level with config
if log_level := ConfigManager.get('log_level'):
logger.level = log_level
# Create game instance
game = GameClient()
# Start cli interface
if config.get('interface'):
ui = UI(game)
logger.info('Starting UI thread')
T = threading.Thread(target=ui.cli, daemon=True)
T.start()
# Call event loop
logger.info('Starting game loop')
try:
from security import authenticate, identity as identity_function
from resources.user import UserRegister
from app_logger import AppLogger
from connection.db import DbInit
from resources.item import Item, ItemList
from datetime import timedelta
from config_manager import ConfigManager
import logging
DEFAULT_PORT = 5050
logger = AppLogger.get_logger(__name__)
ConfigManager.init()
app = Flask(__name__)
app.secret_key = os.environ.get(
"JWT_SECRET", ConfigManager.get("jwt_secret", "jose")
)
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
api = Api(app)
# app.config['JWT_AUTH_URL_RULE'] = '/login'
app.config["JWT_EXPIRATION_DELTA"] = timedelta(
seconds=3600
) # 1 hour expiration time
# app.logger.addHandler()
for logr in (app.logger, logging.getLogger("werkzeug")):
logr.addHandler(AppLogger.file_handler())
logr.addHandler(AppLogger.console_handler())
# config JWT auth key name to be 'email' instead of default 'username'
import yaml
import os, sys
currentdir = os.path.dirname(os.path.realpath(__file__))
parentdir = os.path.dirname(currentdir)
sys.path.append(parentdir)
# Import parent libs
from app_logging import AppLogger
from config_manager import ConfigManager
from utils import AppUtils
logger = AppLogger.get_logger(__name__)
DEFAULT_DB = "resources/data.db"
DATABASE = os.getcwd() + "/" + ConfigManager.get("database", DEFAULT_DB)
class DbInit:
@staticmethod
def users():
with DbConnection() as db:
logger.info("Initializing users")
create_table = "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, username text, password text)" # INTEGER PRIMARY KEY allows Auto incrementing id
db.cursor.execute(create_table)
@staticmethod
def items():
with DbConnection() as db:
logger.info("Initializing items")
create_table = "CREATE TABLE IF NOT EXISTS items (id INTEGER PRIMARY KEY, name text, price real)" # INTEGER PRIMARY KEY allows Auto incrementing id
try:
return manager.get_model(name).name, 200
except (IndexError):
return "Model not found", 404
class Predict(Resource):
def get(self, name):
return "Post requests only"
def post(self, name):
data = request.json
try:
model = manager.get_model(name)
return model.predict(data), 200
except IndexError:
return "Model not found", 404
except ValueError:
return "Inputshape incorrect", 500
else:
return "An unkown error occurred", 500
api.add_resource(ModelList, '/', '/model')
api.add_resource(Model, '/model/<string:name>')
api.add_resource(Predict, '/model/<string:name>/predict')
if __name__ == '__main__':
app.run(debug=config.get("debug"),
host=config.get("host"),
port=config.get("port"))
def test_from_file(self):
cfg = ConfigManager("../config/test_config/chat.yaml")
self.assertIsNotNone(cfg.config)
self.assertIsInstance(cfg.config, dict)
self.assertIsNotNone(cfg.get("meta"))
self.assertEqual(cfg.get("meta"), cfg["meta"])
class Server:
def __init__(self, server_config_path, handler):
"""
Creates a new websocket server
Args:
server_config_path (str): path to server configuration
"""
self.config = ConfigManager(server_config_path)
self.host = self.config["host"]
self.port = self.config["port"]
self.max_message_len = self.config.get("max_message_len", -1)
self.running = False
self.handler = handler
@log(logger, logging.INFO)
def start(self):
"""
Starts the server
"""
self.running = True
start_server_async = websockets.serve(self.ws_handler_async, self.host,
self.port)
asyncio.get_event_loop().run_until_complete(start_server_async)
asyncio.get_event_loop().run_forever()
@log(logger, logging.INFO)
async def ws_handler_async(self, websocket, path):
"""
Async websocket handler
Args:
websocket (Websocket): incoming connection
path (str): incoming connection resource path
"""
# new connection
await self.handler.handle_connection(websocket)
try:
# message in connection
async for message in websocket:
# If max_message_len is a valid value, slice message before handling
if self.max_message_len >= 0:
await self.handler.handle_message(
websocket, message[:self.max_message_len])
else:
await self.handler.handle_message(websocket, message)
except websockets.exceptions.ConnectionClosed:
# Log connection exception
log_message(
logger,
f"Exception: ConnectionClosed in websocket {websocket}",
logging.WARNING)
finally:
# websocket disconnects
await self.handler.handle_disconnect(websocket)
@log(logger, logging.CRITICAL)
async def stop(self):
"""
Handles a server shutdown, waits for the handler to do whatever it needs to first
"""
await self.handler.handle_shutdown()
asyncio.get_event_loop().stop()
self.running = False
log_message(logger, "SHUTDOWN COMPLETE", logging.CRITICAL)
def __repr__(self):
return f"<Server @{self.host}:{self.port}, running: {self.running}, handler: \n\t{str(self.handler)}>"
import os, sys
currentdir = os.path.dirname(os.path.realpath(__file__))
parentdir = os.path.dirname(currentdir)
sys.path.append(parentdir)
# Import parent libs
from app_logging import AppLogger
from config_manager import ConfigManager
import logging
from user import User
logger = AppLogger.get_logger(__name__,
level=logging.INFO,
log_file="test.log")
if __name__ == "__main__":
logger.info("info statement")
logger.debug("debug statement")
jwt_secret = ConfigManager.get("jwt_secret", "jose")
logger.info(f"jwt_secret: {jwt_secret}")
user = User.find_by_username("douglas")
logger.info(f"user: {user}")
currentdir = os.path.dirname(os.path.realpath(__file__))
parentdir = os.path.dirname(currentdir)
logger.info(f"currentdir: {currentdir}, parentdir: {parentdir}")
def test_default(self):
cfg = ConfigManager("../config/test_config/chat.yaml")
self.assertEqual(cfg.get("BADKEY", "DEFAULT"), "DEFAULT")
self.assertIsNone(cfg.get("BADKEY"))
