def configure_socket_functions(config, logger=None):
if logger is True:
logger = make_logger("APPFACTORY")
elif logger is None:
logger = make_logger("CONF:SOCKETFUNCTIONS")
logger.setLevel(logging.ERROR)
try:
if config.LOG_SOCKETS_INCOMING:
socketio.on = get_wrapped_on()
logger.debug("Logging added to all incoming socket event")
else:
logger.debug(
"Logging will not be added to incoming socket events by default. Use `log_socket` from server.logging to log incoming events."
)
except AttributeError:
logger.debug(
"Logging will not be added to incoming socket events by default. Use `log_socket` from server.logging to log incoming events."
)
try:
if config.LOG_SOCKETS_OUTGOING:
socketio.emit = get_wrapped_emit()
socketio.send = get_wrapped_send()
logger.debug("Logging added to all outgoing socket events")
else:
log_outgoing = False
logger.debug(
"Logging will not be added to outgoing socket events by default. Call `get_wrapped_emit()` and `get_wrapped_send()` from server.socketevents.socketutils to get a functions that log outgoing events."
)
except AttributeError:
try:
if config.WRAP_SOCKETS_EMIT:
socketio.emit = get_wrapped_emit()
logger.debug("Logging added to socketio.emit")
else:
logger.debug(
"Logging will not be added to socketio.emit by default. Call `get_wrapped_emit()` from server.socketevents.socketutils to get an emit function that logs outgoing events."
)
except AttributeError:
logger.debug(
"Logging will not be added to socketio.emit by default. Call `get_wrapped_emit()` from server.socketevents.socketutils to get an emit function that logs outgoing events."
)
try:
if config.WRAP_SOCKETS_SEND:
socketio.send = get_wrapped_send()
logger.debug("Logging added to socketio.send")
else:
logger.debug(
"Logging will not be added to socketio.send by default. Call `get_wrapped_send()` from server.socketevents.socketutils to get a send function that logs outgoing events."
)
except AttributeError:
logger.debug(
"Logging will not be added to socketio.send by default. Call `get_wrapped_send()` from server.socketevents.socketutils to get a send function that logs outgoing events."
)
def __init__(self, host=None, port=None, db=None):
self._key = (host, port, db)
self._host = host
self._port = port
self._db = db
self.logger = make_logger("poolmanager:instance")
self._pool = None
self.init_pool()
def required_or_400(required=[], logger=make_logger("required_or_400")):
"""Decorator that adds required parameters from the
request object to the global context
"""
if isinstance(required, str):
required = [required]
elif not isinstance(required, list):
raise TypeError("`required` must be a list or str")
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
try:
payload = request.get_json()
for req_item in required:
if req_item in g.__dict__:
logger.critical(
f"`g` contained `{req_item}` before definition")
return INTERNAL_SERVER_ERROR
g.__setattr__(req_item, payload[req_item])
except BadRequest:
if logger:
logger.debug(f"Throwing `BadRequest`")
logger.error(f"Could not parse JSON")
return make_bad_request(f"Requires JSON Object")
except KeyError:
if logger:
logger.debug(f"Throwing `KeyError`")
logger.error(f"Could not acquire {req_item} from request")
return make_bad_request(f"Missing Parameter: {req_item}")
except Exception as e:
if logger:
logger.debug(f"Throwing {type(e)}")
logger.error("Error parsing request")
return make_bad_request(reason=f"Requires JSON Object")
return func(*args, **kwargs)
return wrapper
return decorator
def get_wrapped_send():
socket_logger = make_logger(
"socketevent", console_format="%(levelname)s:%(name)s: %(msg)s")
line_padding = 18 * " " + "-"
@wraps(socketio.send)
def wrap_send(*args, **kwargs):
try:
print_namespace = str(
kwargs["namespace"]) if kwargs["namespace"] else "/"
except KeyError:
print_namespace = "/"
try:
print_data = f"\n{line_padding}Payload: {args[0]}" if args[
0] else ""
except IndexError:
print_data = ""
socket_logger.debug(
f"SEND: Sending to {request.sid} on namespace {print_namespace}){print_data}"
)
_send(*args, **kwargs)
return wrap_send
import json
import logging
from flask import Blueprint, request, jsonify
from server.db.user_actions import (
create_account,
query_user_by_username,
query_user_by_email,
)
from server.logging import request_log, make_logger
registration_log = make_logger(__name__)
registration_bp = Blueprint("register", __name__, url_prefix="/register")
"""
API endpoint for creating new user.
"""
@registration_bp.route("/create", methods=["POST"])
@request_log(request)
def create_account():
try:
payload = request.get_json()
username = payload["username"]
password = payload["password"]
email = payload["email"]
return create_account(username, password, email)
except KeyError as e:
DEFAULT_MESSAGE_EXPIRE = 7200
"""
Messaging Structures:
thread:next-id -- (int) Next id to be created
thread:<id:int> -- (hash) meta data of thread
thread:<id:int>:members -- (set) list of ids of members in the thread
thread:<id:int>:messages -- (zet) list of ids of messages sent in the thread
message:next-id -- (int) Next id to be created
message:<id:int> -- (hash) message data
"""
logger = make_logger(__name__)
class ThreadEntry(RedisEntry):
THREAD_SIG = {"id": int, "name": str}
THREAD_START = "-1"
def __init__(
self,
thread_id: int,
thread_name: str = None,
users: list = None,
messages: list = None,
):
self._messages = messages
self.thread_id = thread_id
from flask_socketio import SocketIO, emit, join_room, leave_room, disconnect, send
from redis.exceptions import DataError
from server.auth import require_auth
from server.db.user_actions import query_user_by_id
from server.db.models import Thread
from server.redis_cache.user_cache import UserEntry
from server.redis_cache.message_cache import ThreadEntry, MessageEntry
from server.logging import make_logger, log_socket
try:
from __main__ import socketio
except:
from app import socketio
logger = make_logger("ConnectionEvents")
@socketio.on("LOGIN_IDENTIFICATION")
def user_login(user_id):
pass
# logged_user = query_user_by_id(user_id)
# if not logged_user:
# user = UserEntry
# set_user_online(logged_user, request.sid)
# user_dict = {
# "user_id": logged_user.id,
# "username": logged_user.username,
# "online": True,
# }
# emit("USER_JOINED", user_dict, broadcast=True)
def create_app(conf=None, log=False, return_ext=None):
global init
logger = make_logger("APPFACTORY")
if not log:
logger.setLevel(logging.WARNING)
# Configures App
app = Flask(__name__)
config = conf if conf else get_config()
logger.debug(f"Config name: {config.CONFIG_NAME}")
# Session(app)
app.config.from_object(config)
logger.debug(f"App configured with {config.CONFIG_NAME}")
# Logs app initialization type for debug mode
if not config.DEBUG:
logger.debug("Creating Application")
elif not init:
logger.debug("Creating watch instance")
else:
logger.debug("Creating Server instance")
# Mock Setup
if config.DEBUG or config.TESTING:
from server.mocks import setup_mocks
setup_mocks()
# Configures socketio function wrappers
from server.socket_events.socket_utils import configure_socket_functions
# configure_socket_functions(config, logger=logger)
# Socket event imports
#! Dont move this or it will break things
import server.socket_events.message_events
import server.socket_events.debug_events
import server.socket_events.connection_events
import server.socket_events.game_events
# Extention initialization
CORS(app)
db.init_app(app)
migrate.init_app(app, db=db)
socketio.init_app(
app,
logger=socketio_logger,
engineio_logger=engineio_logger,
cors_allowed_origins="*",
)
celery.conf.update(app.config)
# Helper class initialization
poolman.init_app(app)
auth.init_app(app)
# Attaches helper classes to g
@app.before_request
def attach_globs():
g.poolman = poolman
g.auth = auth
serverlogger.debug("Globals attached")
logger.debug("Extensions initialized")
# Registering Blueprints
from server.blueprints.registration_bp import registration_bp
from server.blueprints.auth_bp import auth_bp
from server.blueprints.user_bp import user_bp
from server.blueprints.message_bp import message_bp
from server.blueprints.load_bp import load_bp
app.register_blueprint(auth_bp)
logger.debug("Added authbp")
app.register_blueprint(registration_bp)
logger.debug("Added registrationbp")
app.register_blueprint(user_bp)
logger.debug("Added userbp")
app.register_blueprint(message_bp)
logger.debug("Added message_bp")
app.register_blueprint(load_bp)
logger.debug("Added load_bp")
logger.debug("Blueprints Added")
@app.route("/", methods=["GET", "POST"])
def index_page():
import server.db.game_actions
server.db.game_actions.test3()
return "<h1>hello world</h1>"
# Logs app initialization type for debug mode
if not config.DEBUG:
logger.debug(f"App Created. Config: {app.config['CONFIG_NAME']}")
elif not init:
logger.debug(
f"Application watch instance created. Config: {app.config['CONFIG_NAME']}"
)
init += 1
else:
logger.debug(
f"Application server instance created. Config: {app.config['CONFIG_NAME']}"
)
if return_ext:
if return_ext == "socketio":
return app, socketio
return app
import re
import logging
from datetime import datetime
from sqlalchemy.orm import validates, composite
from sqlalchemy.ext.hybrid import hybrid_property, hybrid_method
from app import db
from werkzeug.security import generate_password_hash, check_password_hash
from server.auth import make_thread_hash, members_from_thread_hash
from server.logging import make_logger
from server.game.geometric_types.vector import Vector
from server.game.geometric_types.rectangle import Rectangle
model_log = make_logger(__name__)
class CreatedTimestampMixin(object):
model_log.info("Creating CreatedTimestampMixin")
created = db.Column(db.DateTime, default=datetime.utcnow)
@validates("created")
def _validate_created(self, key, created):
assert Thread.validate_created(created) == True
return created
@staticmethod
def validate_created(created):
if datetime.utcnow >= created:
return True