Arcaea-server/latest version/main.py

# encoding: utf-8

import os
import sys
from importlib import import_module
from logging.config import dictConfig
from multiprocessing import Process, set_start_method
from traceback import format_exc

from flask import Flask, make_response, request, send_from_directory

from core.config_manager import Config, ConfigManager

if os.path.exists('config.py') or os.path.exists('config'):
    ConfigManager.load(import_module('config').Config)


import api
import server
import server.init
import web.index
import web.login
from core.constant import Constant
from core.download import (UserDownload, get_only_3_song_ids,
                           initialize_songfile)
from core.error import ArcError, NoAccess, RateLimit
from core.sql import Connect
from server.func import error_return

app = Flask(__name__)

# from werkzeug.middleware.proxy_fix import ProxyFix
# app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1)
# from flask_cors import CORS
# CORS(app, supports_credentials=True)


os.chdir(sys.path[0])  # 更改工作路径，以便于愉快使用相对路径


app.config.from_mapping(SECRET_KEY=Config.SECRET_KEY)
app.config['SESSION_TYPE'] = 'filesystem'
app.register_blueprint(web.login.bp)
app.register_blueprint(web.index.bp)
app.register_blueprint(api.bp)
app.register_blueprint(server.bp)


@app.route('/')
def hello():
    return "Hello World!"


@app.route('/favicon.ico', methods=['GET'])  # 图标
def favicon():
    # Pixiv ID: 82374369
    # 我觉得这张图虽然并不是那么精细，但很有感觉，色彩的强烈对比下给人带来一种惊艳
    # 然后在压缩之下什么也看不清了:(

    return app.send_static_file('favicon.ico')


@app.route('/download/<path:file_path>', methods=['GET'])  # 下载
def download(file_path):
    with Connect() as c:
        try:
            x = UserDownload(c)
            x.token = request.args.get('t')
            x.song_id, x.file_name = file_path.split('/', 1)
            x.select_for_check()
            if x.is_limited:
                raise RateLimit('You have reached the download limit.', 903)
            if not x.is_valid:
                raise NoAccess('Expired token.')
            x.download_hit()
            # response = make_response()
            # response.headers['Content-Type'] = 'application/octet-stream'
            # response.headers['X-Accel-Redirect'] = '/nginx_download/' + file_path
            # return response
            return send_from_directory(Constant.SONG_FILE_FOLDER_PATH, file_path, as_attachment=True, conditional=True)
        except ArcError as e:
            if Config.ALLOW_WARNING_LOG:
                app.logger.warning(format_exc())
            return error_return(e)
    return error_return()


def tcp_server_run():
    if False:
        from gevent.pywsgi import WSGIServer
        WSGIServer(("127.0.0.1", 5000), app).serve_forever()
    else:
        if Config.SSL_CERT and Config.SSL_KEY:
            app.run(Config.HOST, Config.PORT, ssl_context=(
                Config.SSL_CERT, Config.SSL_KEY))
        else:
            app.run(Config.HOST, Config.PORT)


def main():
    log_dict = {
        'version': 1,
        'root': {
            'level': 'INFO',
            'handlers': ['wsgi', 'error_file']
        },
        'handlers': {
            'wsgi': {
                'class': 'logging.StreamHandler',
                'stream': 'ext://flask.logging.wsgi_errors_stream',
                'formatter': 'default'
            },
            "error_file": {
                "class": "logging.handlers.RotatingFileHandler",
                "maxBytes": 1024 * 1024,
                "backupCount": 1,
                "encoding": "utf-8",
                "level": "ERROR",
                "formatter": "default",
                "filename": "./log/error.log"
            }
        },
        'formatters': {
            'default': {
                'format': '[%(asctime)s] %(levelname)s in %(module)s: %(message)s'
            }
        }
    }
    if Config.ALLOW_INFO_LOG:
        log_dict['root']['handlers'].append('info_file')
        log_dict['handlers']['info_file'] = {
            "class": "logging.handlers.RotatingFileHandler",
            "maxBytes": 1024 * 1024,
            "backupCount": 1,
            "encoding": "utf-8",
            "level": "INFO",
            "formatter": "default",
            "filename": "./log/info.log"
        }
    if Config.ALLOW_WARNING_LOG:
        log_dict['root']['handlers'].append('warning_file')
        log_dict['handlers']['warning_file'] = {
            "class": "logging.handlers.RotatingFileHandler",
            "maxBytes": 1024 * 1024,
            "backupCount": 1,
            "encoding": "utf-8",
            "level": "WARNING",
            "formatter": "default",
            "filename": "./log/warning.log"
        }

    dictConfig(log_dict)

    if not server.init.check_before_run(app):
        app.logger.error('Something wrong. The server will not run.')
        input('Press ENTER key to exit.')
        sys.exit()

    app.logger.info("Start to initialize song data...")
    try:
        initialize_songfile()
        get_only_3_song_ids()
        app.logger.info('Complete!')
    except:
        app.logger.warning('Initialization error!')

    if Config.LINKPLAY_HOST and Config.SET_LINKPLAY_SERVER_AS_SUB_PROCESS:
        from linkplay_server import link_play
        process = [Process(target=link_play, args=(
            Config.LINKPLAY_HOST, int(Config.LINKPLAY_UDP_PORT), int(Config.LINKPLAY_TCP_PORT)))]
        [p.start() for p in process]
        app.logger.info("Link Play UDP server is running on " +
                        Config.LINKPLAY_HOST + ':' + str(Config.LINKPLAY_UDP_PORT) + " ...")
        app.logger.info("Link Play TCP server is running on " +
                        Config.LINKPLAY_HOST + ':' + str(Config.LINKPLAY_TCP_PORT) + " ...")
        tcp_server_run()
        [p.join() for p in process]
    else:
        tcp_server_run()


if __name__ == '__main__':
    set_start_method("spawn")
    main()


# Made By Lost  2020.9.11