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