Beispiel #1
0
def rest_analyze():
    status = el.DONE
    rest_result = {}
    ret = {}
    url = ""
    if request.method == "POST":
        if "Url" not in request.form:
            status = el.ERR_BAD_REQ

            ret["result"] = rest_result
            ret["msg"] = el.get_error_message(status)
            ret["status"] = status
            return jsonify(ret)
        else:
            url = request.form["Url"]

    elif request.method == "GET":
        if "Url" not in request.args:
            status = el.ERR_BAD_REQ

            ret["result"] = rest_result
            ret["msg"] = el.get_error_message(status)
            ret["status"] = status
            return jsonify(ret)
        else:
            url = request.args.get("Url")

    # キャッシュ確認
    youtube_id = an.get_youtube_id(url)
    if youtube_id is False:
        # 不正なurlの場合
        status = el.ERR_BAD_URL
    else:
        # 正常なurlの場合
        cache = cm.cache_check(youtube_id)

        if cache is not False:
            # キャッシュ有りの場合
            # キャッシュを返信
            title, time_line, time_data, total_damage, debuff_value, past_status = cache
            if past_status // 100 == 2:
                rest_result = get_rest_result(title, time_line, time_data, total_damage, debuff_value)

                ret["result"] = rest_result
                ret["msg"] = el.get_error_message(past_status)
                ret["status"] = past_status
                return jsonify(ret)

            elif (past_status // 100) == 3:
                pass
            else:
                ret["result"] = rest_result
                ret["msg"] = el.get_error_message(past_status)
                ret["status"] = past_status
                return jsonify(ret)

        # start analyze
        # 既にキューに登録されているか確認
        queue_path = queue_dir + str(youtube_id)
        pending_path = pending_dir + str(youtube_id)
        queued = os.path.exists(queue_path)
        if queued:  # 既に解析中の場合
            while True:  # キューが消えるまで監視
                # 暫定的実装
                # 監視中にキューが30分以上残置されているのを見つけると削除する
                try:
                    now = datetime.date.today()  # 現在の時刻を取得
                    timestamp = datetime.date.fromtimestamp(int(os.path.getmtime(queue_path)))

                    if (now - timestamp).seconds >= 30 * 60:  # 30分経過してたら削除
                        cm.clear_path(queue_path)
                        cm.clear_path(pending_path)

                except FileNotFoundError:
                    pass

                queued = os.path.exists(queue_path)
                if queued:
                    tm.sleep(1)
                    continue
                else:  # 既に開始されている解析が完了したら、そのキャッシュJSONを返す
                    cache = cm.cache_check(youtube_id)
                    if cache is not False:
                        title, time_line, time_data, total_damage, debuff_value, past_status = cache
                        if past_status // 100 == 2 or past_status // 100 == 3:
                            rest_result = get_rest_result(title, time_line, time_data, total_damage, debuff_value)

                        status = past_status
                        break
                    else:  # キャッシュ未生成の場合
                        # キャッシュを書き出してから解析キューから削除されるため、本来起こり得ないはずのエラー
                        status = el.ERR_UNEXPECTED
                        break

        else:  # 既に解析中ではない場合
            # 解析キューに登録
            cm.queue_append(queue_path)

            # キューが回ってきたか確認し、来たら解析実行
            while True:
                if not cm.is_pending_exists() and cm.is_queue_current(queue_path):
                    # pendingに登録
                    pending_path = pending_dir + str(youtube_id)
                    cm.pending_append(pending_path)
                    # youtube動画検索/検証
                    path, title, length, thumbnail, url_result = an.search(youtube_id)
                    status = url_result
                    if url_result // 100 == 4:
                        cm.save_cache(youtube_id, title, False, False, False, False, url_result)
                    elif url_result == el.ERR_CANT_GET_HD:
                        pass
                    else:
                        # TL解析
                        time_line, time_data, total_damage, debuff_value, analyze_result = an.analyze_movie(path)
                        status = analyze_result
                        # キャッシュ保存
                        cm.save_cache(youtube_id, title, time_line, False, total_damage, debuff_value, status)

                        if analyze_result is el.DONE:
                            # 解析が正常終了ならば結果を格納
                            rest_result = get_rest_result(title, time_line, time_data, total_damage, debuff_value)

                    cm.clear_path(queue_path)
                    cm.clear_path(pending_path)
                    break

                tm.sleep(1)

    ret["result"] = rest_result
    ret["msg"] = el.get_error_message(status)
    ret["status"] = status
    return jsonify(ret)
Beispiel #2
0
def rest_analyze():
    status = state.ERR_REQ_UNEXPECTED
    is_parent = False
    rest_result = {}
    ret = {}
    url = ""
    raw_url = ""
    token = ""

    # clear old movie if passed 2 hours
    cm.tmp_movie_clear()

    if request.method == "POST":
        if "Url" not in request.form:
            status = state.ERR_BAD_REQ

            ret["result"] = rest_result
            ret["msg"] = state.get_error_message(status)
            ret["status"] = status
            return jsonify(ret)
        else:
            raw_url = request.form["Url"]

        if SERVER_TOKEN_AUTH and "Token" not in request.form:
            status = state.ERR_BAD_REQ

            ret["result"] = rest_result
            ret["msg"] = state.get_error_message(status)
            ret["status"] = status
            return jsonify(ret)
        else:
            token = request.form["Token"]

    elif request.method == "GET":
        if "Url" not in request.args:
            status = state.ERR_BAD_REQ

            ret["result"] = rest_result
            ret["msg"] = state.get_error_message(status)
            ret["status"] = status
            return jsonify(ret)
        else:
            raw_url = request.args.get("Url")

        if SERVER_TOKEN_AUTH and "Token" not in request.args:
            status = state.ERR_BAD_REQ

            ret["result"] = rest_result
            ret["msg"] = state.get_error_message(status)
            ret["status"] = status
            return jsonify(ret)
        else:
            token = request.args.get("Token")

    try:
        # tokenの確認とロード
        if SERVER_TOKEN_AUTH:
            json.load(open(token_dir + urllib.parse.quote(token) + ".json"))

    except FileNotFoundError:
        status = state.ERR_BAD_TOKEN

        ret["result"] = rest_result
        ret["msg"] = state.get_error_message(status)
        ret["status"] = status
        return jsonify(ret)

    # URL抽出
    tmp_group = re.search('(?:https?://)?(?P<host>.*?)(?:[:#?/@]|$)', raw_url)

    if tmp_group:
        host = tmp_group.group('host')
        if host == "www.youtube.com" or host == "youtu.be":
            url = raw_url

    # キャッシュ確認
    youtube_id = al.get_youtube_id(url)
    queue_path = queue_dir + str(youtube_id)
    pending_path = pending_dir + str(youtube_id)
    dl_queue_path = dl_queue_dir + str(youtube_id)
    if youtube_id is False:
        # 不正なurlの場合
        status = state.ERR_BAD_URL
    else:
        # 正常なurlの場合
        cache = cm.cache_check(youtube_id)

        if cache is not False:
            # キャッシュ有りの場合
            # キャッシュを返信
            title, time_line, time_line_enemy, time_data, total_damage, debuff_value, past_status = cache
            if past_status % 100 // 10 == 0:
                rest_result = get_rest_result(title, time_line,
                                              time_line_enemy, time_data,
                                              total_damage, debuff_value)

                ret["result"] = rest_result
                ret["msg"] = state.get_error_message(past_status)
                ret["status"] = past_status
                return jsonify(ret)

            else:
                ret["result"] = rest_result
                ret["msg"] = state.get_error_message(past_status)
                ret["status"] = past_status
                return jsonify(ret)

        if SERVER_ERROR_STATE:
            ret["result"] = rest_result
            ret["msg"] = state.get_error_message(state.ERR_SERVICE_UNAVAILABLE)
            ret["status"] = state.ERR_SERVICE_UNAVAILABLE
            return jsonify(ret)

        # start analyze
        # 既にキューに登録されているか確認
        queued = os.path.exists(queue_path)
        if not queued:  # 既に解析中ではない場合、解析キューに登録
            cm.queue_append(queue_path)
            # キューが回ってきたか確認し、来たら解析実行
            while True:
                cm.watchdog(youtube_id, is_parent, 1800,
                            state.TMP_QUEUE_TIMEOUT)
                rest_pending = cm.is_path_exists(pending_path)
                rest_queue = cm.is_path_due(queue_path)
                web_download = cm.is_path_exists(dl_queue_path)
                if not rest_pending and rest_queue and not web_download:
                    if cm.is_pending_download(15):  # check pending download
                        if not MULTI_SERVER:
                            analyzer_path = f'python exec_analyze.py {url}'
                            cm.pending_append(pending_path)
                            subprocess.Popen(analyzer_path.split())
                            is_parent = True
                        else:
                            analyzer_path = f'python multi_exec_analyze.py {url}'
                            cm.pending_append(pending_path)
                            subprocess.Popen(analyzer_path.split())
                            is_parent = True
                        break

                tm.sleep(1)

        while True:  # キューが消えるまで監視
            queued = os.path.exists(queue_path)
            if queued:
                if is_parent:
                    # 親ならばpendingを監視
                    cm.watchdog(youtube_id, is_parent, 300,
                                state.TMP_ANALYZE_TIMEOUT)
                else:
                    # 子ならばqueueを監視
                    cm.watchdog(youtube_id, is_parent, 2160,
                                state.TMP_QUEUE_TIMEOUT)
                tm.sleep(1)
                continue
            else:  # 解析が完了したら、そのキャッシュJSONを返す
                cache = cm.queue_cache_check(youtube_id)
                if cache is not False:
                    title, time_line, time_line_enemy, time_data, total_damage, debuff_value, past_status = cache
                    rest_result = get_rest_result(title, time_line,
                                                  time_line_enemy, time_data,
                                                  total_damage, debuff_value)

                    status = past_status
                    break
                else:  # キャッシュ未生成の場合
                    # キャッシュを書き出してから解析キューから削除されるため、本来起こり得ないはずのエラー
                    status = state.TMP_UNEXPECTED
                    break

    ret["result"] = rest_result
    ret["msg"] = state.get_error_message(status)
    ret["status"] = status
    return jsonify(ret)