Пример #1
0
def do_analyze():
    # 変数不足時は終了
    if not sys.argv[1]:
        return

    youtube_url = sys.argv[1]

    # ID部分の取り出し
    youtube_id = al.get_youtube_id(youtube_url)
    if not youtube_id:
        return

    queue_path = ap.queue_dir + str(youtube_id)
    pending_path = ap.pending_dir + str(youtube_id)

    cached = cm.cache_check(youtube_id)

    # 5分経過した3xx キャッシュ以外は再解析しない
    if cached:
        cm.clear_path(queue_path)
        cm.clear_path(pending_path)
        return

    url = "http://" + is_server() + "/rest/analyze?Url=" + youtube_url

    req = urllib.request.Request(url)
    try:
        with urllib.request.urlopen(req) as res:
            body = json.load(res)

            title = body.get("result").get("title")
            time_line = body.get("result").get("timeline")
            time_line_enemy = body.get("result").get("timeline_enemy")
            total_damage = body.get("result").get("total_damage")
            debuff_value = body.get("result").get("debuff_value")
            url_result = body.get("status")
    except HTTPError:
        title = ""
        url_result = state.ERR_APP_SERVER_HTTP
    except URLError:
        title = ""
        url_result = state.ERR_APP_SERVER_URL
    except TimeoutError:
        title = ""
        url_result = state.ERR_ANALYZE_TIMEOUT

    if url_result % 100 // 10 == 2:
        cm.save_cache(youtube_id, title, False, False, False, False, False,
                      url_result)
    else:
        # キャッシュ保存
        cm.save_cache(youtube_id, title, time_line, time_line_enemy, False,
                      total_damage, debuff_value, url_result)

    cm.clear_path(queue_path)
    cm.clear_path(pending_path)
Пример #2
0
def do_analyze():
    # 変数不足時は終了
    if not sys.argv[1]:
        return

    youtube_url = sys.argv[1]

    # ID部分の取り出し
    youtube_id = al.get_youtube_id(youtube_url)
    if not youtube_id:
        return

    queue_path = ap.queue_dir + str(youtube_id)
    pending_path = ap.pending_dir + str(youtube_id)

    cached = cm.cache_check(youtube_id)

    # 5分経過した3xx キャッシュ以外は再解析しない
    if cached:
        cm.clear_path(queue_path)
        cm.clear_path(pending_path)
        return

    # youtube動画検索/検証
    path, title, length, thumbnail, url_result = al.search(youtube_id)
    if url_result % 100 // 10 == 2:
        cm.save_cache(youtube_id, title, False, False, False, False, False,
                      url_result)
    else:
        # TL解析
        time_line, time_line_enemy, time_data, total_damage, debuff_value, damages, analyze_result = al.analyze_movie(
            path)
        # キャッシュ保存
        cm.save_cache(youtube_id, title, time_line, time_line_enemy, False,
                      total_damage, debuff_value, damages, analyze_result)

    cm.clear_path(queue_path)
    cm.clear_path(pending_path)
Пример #3
0
def do_analyze(url):

    # ID部分の取り出し
    youtube_id = al.get_youtube_id(url)
    if not youtube_id:
        return

    cached = cm.cache_check(youtube_id)
    # 5分経過した3xx キャッシュ以外は再解析しない
    if cached:
        return

    # youtube動画検索/検証
    path, title, length, thumbnail, url_result = al.search(youtube_id)
    if url_result % 100 // 10 == 2:
        cm.save_cache(youtube_id, title, False, False, False, False,
                      url_result)
    else:
        # TL解析
        time_line, time_data, total_damage, debuff_value, analyze_result = al.analyze_movie(
            path)
        # キャッシュ保存
        cm.save_cache(youtube_id, title, time_line, False, total_damage,
                      debuff_value, analyze_result)
Пример #4
0
def index():
    if request.method == "POST":
        url = (request.form["Url"])

        # urlからid部分の抽出
        youtube_id = an.get_youtube_id(url)
        if youtube_id is False:
            error = el.get_error_message(el.ERR_BAD_URL)
            return render_template("index.html", error=error)

        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:
                debuff_dict, data_txt, data_url, total_damage = get_web_txt(youtube_id, title,
                                                                            time_line, debuff_value, total_damage)

                return render_template("result.html", title=title, timeLine=time_line,
                                       timeData=time_data, totalDamage=total_damage, debuffDict=debuff_dict,
                                       data_txt=data_txt, data_url=data_url)

            elif past_status // 100 == 3:
                pass
            else:
                error = el.get_error_message(past_status)
                return render_template("index.html", error=error)

        path, title, length, thumbnail, url_result = an.search(youtube_id)

        if url_result // 100 == 4:
            error = el.get_error_message(url_result)
            cm.save_cache(youtube_id, title, False, False, False, False, url_result)
            return render_template("index.html", error=error)

        elif url_result == el.ERR_CANT_GET_HD:
            error = el.get_error_message(url_result)
            return render_template("index.html", error=error)

        session["path"] = path
        session["title"] = title
        session["youtube_id"] = youtube_id
        length = int(int(length) / 8) + 3

        return render_template("analyze.html", title=title, length=length, thumbnail=thumbnail)

    elif request.method == "GET":
        if "v" in request.args:  # ?v=YoutubeID 形式のGETであればリザルト返却
            youtube_id = request.args.get("v")
            if re.fullmatch(r"^([a-zA-Z0-9_-]{11})$", youtube_id):
                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:
                        debuff_dict, data_txt, data_url, total_damage = get_web_txt(youtube_id, title,
                                                                                    time_line, debuff_value,
                                                                                    total_damage)

                        return render_template("result.html", title=title, timeLine=time_line,
                                               timeData=time_data, totalDamage=total_damage, debuffDict=debuff_dict,
                                               data_txt=data_txt, data_url=data_url)

                    elif past_status // 100 == 3:
                        pass

                    else:
                        error = el.get_error_message(past_status)
                        return render_template("index.html", error=error)

                else:  # キャッシュが存在しない場合は解析
                    path, title, length, thumbnail, url_result = an.search(youtube_id)

                    if url_result // 100 == 4:
                        error = el.get_error_message(url_result)
                        cm.save_cache(youtube_id, title, False, False, False, False, url_result)
                        return render_template("index.html", error=error)

                    elif url_result == el.ERR_CANT_GET_HD:
                        error = el.get_error_message(url_result)
                        return render_template("index.html", error=error)

                    session["path"] = path
                    session["title"] = title
                    session["youtube_id"] = youtube_id
                    length = int(int(length) / 8) + 3

                    return render_template("analyze.html", title=title, length=length, thumbnail=thumbnail)

            else:  # prilog.jp/(YoutubeID)に該当しないリクエスト
                error = "不正なリクエストです"
                return render_template("index.html", error=error)
            
        else:
            path = session.get("path")
            session.pop("path", None)
            session.pop("title", None)
            session.pop("youtube_id", None)

            error = None
            if path is el.ERR_BAD_RESOLUTION:
                error = el.get_error_message(path)

            elif path is not None:
                cm.clear_path(path)

            return render_template("index.html", error=error)
Пример #5
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)
Пример #6
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)
Пример #7
0
def index():
    if request.method == "POST":
        url = (request.form["Url"])

        # urlからid部分の抽出
        youtube_id = al.get_youtube_id(url)
        if youtube_id is False:
            error = state.get_error_message(state.ERR_BAD_URL)
            return render_template("index.html", error=error)

        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:
                debuff_dict, data_txt, data_url, total_damage = get_web_txt(
                    youtube_id, title, time_line, debuff_value, total_damage)

                return render_template("result.html",
                                       title=title,
                                       timeLine=time_line,
                                       timeLineEnemy=time_line_enemy,
                                       timeData=time_data,
                                       totalDamage=total_damage,
                                       debuffDict=debuff_dict,
                                       data_txt=data_txt,
                                       data_url=data_url)

            else:
                error = state.get_error_message(past_status)
                return render_template("index.html", error=error)

        if SERVER_ERROR_STATE:
            error = state.get_error_message(state.ERR_SERVICE_UNAVAILABLE)
            return render_template("index.html", error=error)

        # start download
        dl_queue_path = dl_queue_dir + str(youtube_id)
        dl_ongoing_path = dl_ongoing_dir + str(youtube_id)

        # 既にキューに登録されているか確認
        queued = os.path.exists(dl_queue_path)
        if not queued:  # 既にダウンロード待機中ではない場合、ダウンロード待機キューに登録
            cm.queue_append(dl_queue_path)
            # キューが回ってきたか確認し、来たらダウンロード実行
            while True:
                if not cm.is_path_exists(dl_ongoing_path) and cm.is_path_due(
                        dl_queue_path):
                    if cm.is_pending_download(15):  # check pending download
                        break

                timeout = cm.watchdog_download(youtube_id, 300)  # 5分間タイムアウト監視

                if timeout:
                    cm.clear_path(dl_queue_path)
                    error = "動画の解析待ちでタイムアウトが発生しました。再実行をお願いします。"
                    return render_template("index.html", error=error)

                tm.sleep(1)

        else:  # ダウンロード待機中の場合エラーメッセージ表示
            cm.clear_path(dl_queue_path)
            error = "同一の動画が解析中です。時間を置いて再実行をお願いします。"
            return render_template("index.html", error=error)

        path, title, length, thumbnail, url_result = al.search(youtube_id)
        cm.clear_path(dl_queue_path)

        if url_result % 100 // 10 == 2:
            error = state.get_error_message(url_result)
            cm.save_cache(youtube_id, title, False, False, False, False, False,
                          url_result)
            return render_template("index.html", error=error)

        session["path"] = path
        session["title"] = title
        session["youtube_id"] = youtube_id
        length = int(int(length) / 8) + 3

        return render_template("analyze.html",
                               title=title,
                               length=length,
                               thumbnail=thumbnail)

    elif request.method == "GET":
        if "v" in request.args:  # ?v=YoutubeID 形式のGETであればリザルト返却
            youtube_id = request.args.get("v")
            if re.fullmatch(r"^([a-zA-Z0-9_-]{11})$", youtube_id):
                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:
                        debuff_dict, data_txt, data_url, total_damage = get_web_txt(
                            youtube_id, title, time_line, debuff_value,
                            total_damage)

                        return render_template("result.html",
                                               title=title,
                                               timeLine=time_line,
                                               timeLineEnemy=time_line_enemy,
                                               timeData=time_data,
                                               totalDamage=total_damage,
                                               debuffDict=debuff_dict,
                                               data_txt=data_txt,
                                               data_url=data_url)

                    else:
                        error = state.get_error_message(past_status)
                        return render_template("index.html", error=error)

                else:  # キャッシュが存在しない場合は解析
                    if SERVER_ERROR_STATE:
                        error = state.get_error_message(
                            state.ERR_SERVICE_UNAVAILABLE)
                        return render_template("index.html", error=error)

                    # start download
                    dl_queue_path = dl_queue_dir + str(youtube_id)
                    dl_ongoing_path = dl_ongoing_dir + str(youtube_id)

                    # 既にキューに登録されているか確認
                    queued = os.path.exists(dl_queue_path)
                    if not queued:  # 既にダウンロード待機中ではない場合、ダウンロード待機キューに登録
                        cm.queue_append(dl_queue_path)
                        # キューが回ってきたか確認し、来たらダウンロード実行
                        while True:
                            if not cm.is_path_exists(
                                    dl_ongoing_path) and cm.is_path_due(
                                        dl_queue_path):
                                if cm.is_pending_download(
                                        15):  # check pending download
                                    break

                            timeout = cm.watchdog_download(youtube_id,
                                                           300)  # 5分間タイムアウト監視

                            if timeout:
                                cm.clear_path(dl_queue_path)
                                error = "動画の解析待ちでタイムアウトが発生しました。再実行をお願いします。"
                                return render_template("index.html",
                                                       error=error)

                            tm.sleep(1)

                    else:  # ダウンロード待機中の場合エラーメッセージ表示
                        cm.clear_path(dl_queue_path)
                        error = "同一の動画が解析中です。時間を置いて再実行をお願いします。"
                        return render_template("index.html", error=error)

                    path, title, length, thumbnail, url_result = al.search(
                        youtube_id)
                    cm.clear_path(dl_queue_path)

                    if url_result % 100 // 10 == 2:
                        error = state.get_error_message(url_result)
                        cm.save_cache(youtube_id, title, False, False, False,
                                      False, False, url_result)
                        return render_template("index.html", error=error)

                    session["path"] = path
                    session["title"] = title
                    session["youtube_id"] = youtube_id
                    length = int(int(length) / 8) + 3

                    return render_template("analyze.html",
                                           title=title,
                                           length=length,
                                           thumbnail=thumbnail)

            else:  # prilog.jp/(YoutubeID)に該当しないリクエスト
                error = "不正なリクエストです"
                return render_template("index.html", error=error)

        else:
            path = session.get("path")
            session.pop("path", None)
            session.pop("title", None)
            session.pop("youtube_id", None)

            error = None
            if str(path).isdecimal():
                error = state.get_error_message(path)

            elif path is not None:
                cm.clear_path(path)

            return render_template("index.html", error=error)
Пример #8
0
def rest_analyze():
    status = err.ERR_REQ_UNEXPECTED
    is_parent = False
    rest_result = {}
    ret = {}
    url = ""
    raw_url = ""
    if request.method == "POST":
        if "Url" not in request.form:
            status = err.ERR_BAD_REQ

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

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

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

    # 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)
    if youtube_id is False:
        # 不正なurlの場合
        status = err.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 // 10 == 0:
                rest_result = get_rest_result(title, time_line, time_data,
                                              total_damage, debuff_value)

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

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

        # start analyze
        do_analyze(url)
        cache = cm.cache_check(youtube_id)
        if cache is not False:
            title, time_line, time_data, total_damage, debuff_value, past_status = cache
            rest_result = get_rest_result(title, time_line, time_data,
                                          total_damage, debuff_value)

            status = past_status

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