f8/f8/app.cc

#include <signal.h>
#include <unistd.h>

#include <mutex>
#include <condition_variable>

#include <a8/a8.h>
#include <a8/uuid.h>

#include <f8/f8.h>
#include <f8/udplog.h>
#include <f8/app.h>
#include <f8/msgqueue.h>
#include <f8/timer.h>

const int MAX_NODE_ID = 8;
const int MAX_INSTANCE_ID = 500;

const char* const PROJ_NAME_FMT = "game%d_wsproxy";
const char* const PROJ_ROOT_FMT = "/data/logs/%s";
const char* const PROJ_LOG_ROOT_FMT = "/data/logs/%s/logs";
const char* const PROJ_LOG_FILENAME_FMT = "log_$pid_%Y%m%d.log";

namespace f8
{

    void App::Init()
    {
        signal(SIGPIPE, SIG_IGN);
        srand(time(nullptr));

        uuid_ = std::make_shared<a8::uuid::SnowFlake>();
        loop_mutex_ = new std::mutex();
        loop_cond_ = new std::condition_variable();

        if (!ParseOpt()) {
            terminated_ = true;
            if (node_id_ <= 0) {
                a8::XPrintf("启动失败,缺少-n参数\n", {});
            } else if (node_id_ > MAX_NODE_ID) {
                a8::XPrintf("启动失败,-n参数不能大于%d\n", {MAX_NODE_ID});
            } else if (instance_id_ <= 0) {
                a8::XPrintf("启动失败,缺少-i参数\n", {});
            } else if (instance_id_ > MAX_INSTANCE_ID) {
                a8::XPrintf("启动失败,-i参数不能大于%d\n", {MAX_INSTANCE_ID});
            }
        }
        a8::XPrintf("wsproxy starting node_id:%d instance_id:%d pid:%d\n",
                    {
                     node_id_,
                     instance_id_,
                     GetPid()
                    });

        uuid_->SetMachineId((node_id_ - 1) * MAX_NODE_ID + instance_id_);
        f8::MsgQueue::Instance()->Init();
        f8::Timer::Instance()->Init();
        user_app_->Init();
    }

    void App::UnInit()
    {
        user_app_->UnInit();
        f8::Timer::Instance()->UnInit();
        f8::MsgQueue::Instance()->UnInit();

        delete loop_cond_;
        loop_cond_ = nullptr;
        delete loop_mutex_;
        loop_mutex_ = nullptr;
    }

    int App::Run(int argc, char* argv[], UserApp* user_app)
    {
        argc_ = argc;
        argv_ = argv;
        user_app_ = user_app;
        Init();
        while (!Terminated()) {
            f8::Timer::Instance()->Update();
            f8::MsgQueue::Instance()->Update();
            user_app->Update();
            Schedule();
        }
        UnInit();
        return 0;
    }

    bool App::ParseOpt()
    {
        int ch = 0;
        while ((ch = getopt(argc_, argv_, "n:i:f:")) != -1) {
            switch (ch) {
            case 'n':
                {
                    node_id_ = a8::XValue(optarg);
                }
                break;
            case 'i':
                {
                    instance_id_ = a8::XValue(optarg);
                }
                break;
            case 'f':
                {
                    std::vector<std::string> strings;
                    a8::Split(optarg, strings, ',');
                    for (auto& str : strings) {
                        flags_.insert(a8::XValue(str).GetInt());
                    }
                }
                break;
            }
        }
        return instance_id_ > 0 && node_id_ > 0;
    }

    bool App::HasFlag(int flag)
    {
        return false;
    }

    void App::NotifyLoopCond()
    {

    }

    long long App::NewNodeUuid()
    {
        return 0;
    }

    const std::string App::NewGlobalUuid()
    {
        return "";
    }

    int App::GetPid()
    {
        return getpid();
    }

    void App::InitLog()
    {
        std::string filename_fmt = PROJ_LOG_FILENAME_FMT;
        a8::ReplaceString(filename_fmt, "$pid",
                          a8::XValue(f8::App::Instance()->GetPid()));

        std::string proj_root_dir = a8::Format
            (PROJ_ROOT_FMT,
             {a8::Format(PROJ_NAME_FMT,{GAME_ID})});
        std::string proj_log_root_dir = a8::Format
            (PROJ_LOG_ROOT_FMT,
             {a8::Format(PROJ_NAME_FMT, {GAME_ID})});
        std::string log_file_name = a8::Format
            (PROJ_LOG_ROOT_FMT,
             {a8::Format(PROJ_NAME_FMT, {GAME_ID})}) + "/" + filename_fmt;

        a8::MkDir(proj_root_dir);
        a8::MkDir(proj_log_root_dir);
        f8::UdpLog::Instance()->SetLogFileName(log_file_name);
        f8::UdpLog::Instance()->Init();
        f8::UdpLog::Instance()->Info("proj_root_dir:%s", {proj_root_dir});
        f8::UdpLog::Instance()->Info("proj_log_root_dir:%s", {proj_log_root_dir});
        f8::UdpLog::Instance()->Info("log_file_name:%s", {log_file_name});
    }

    void App::UnInitLog()
    {
        f8::UdpLog::Instance()->UnInit();
    }

    void App::Schedule()
    {
        std::unique_lock<std::mutex> lk(*loop_mutex_);
        if (!user_app_->HasTask()) {
#if 1
            int sleep_time = 1;
            loop_cond_->wait_for(lk, std::chrono::milliseconds(sleep_time));
#else
            int sleep_time = f8::Timer::Instance()->GetIdleableMillSeconds();
            loop_cond_->wait_for(lk, std::chrono::milliseconds(sleep_time));
            if (sleep_time > perf.max_timer_idle) {
                perf.max_timer_idle = sleep_time;
            }
#endif
        }
    }

}