异数OS 星星之火（三）--异数OS-织梦师云微服务编写入门

2022-07-11 11:30:32

异数OS 星星之火（三）–异数OS-织梦师云微服务编写入门

本文来自异数OS社区

github： https://github.com/yds086/HereticOS

异数OS社区QQ群： 652455784

异数OS-织梦师（消息中间件，游戏开发方向）群： 476260389

异数OS-织梦师-Xnign（Nginx方向）群： 859548384

什么是异数OS微服务

异数OS在做容器化改造后提供了容器多服务实例能力，以此提供多租户多用户的使用环境，未来异数OS的系统组件以及用户应用组件都以微服务的形式来设计实现，比如文件系统，自定义tcp协议栈等。用户可以考虑在异数OS闭源授权协议下编写自己的服务产品来集成到异数OS平台，因此本文介绍用户如何编写微服务。

异数OS微服务怎么写

异数OS是高性能操作系统，高性能的程序是不能随便写的，还是需要注意一些事项，目前只提供C++的微服务写法，未来可能的话也可能会提供php js等扩展。

下面是Xnign服务的代码案例，完整代码请去社区寻共享翻阅

class XnignService : public HereticThread<XnignService>

{

public:

    XnignService() {};

    ~XnignService() {};

    ULONGLONG nWaitTime;

    XnignStatisticsInfo m_OwnInfo;

    HereticEvent<int, true> m_WaitEvent;

    struct XnignState

    {

        unsigned int bNeedClose : 1;        //系统请求关闭服务

        unsigned int bCanClose : 1;         //表示服务目前可以关闭

        unsigned int bClosed : 1;           //表示服务目前已关闭

        unsigned int bNeedEntryPower : 1;   //系统请求进入目标电源状态

        unsigned int nNeedEntryPower : 2;   //表示系统当前请求的电源状态

        unsigned int nCanEntryPower : 2; //表示服务目前可以进入的最低电源状态

    };

    unsigned int m_nServiceID;

    XnignState m_XnignState;

    bool Input(const char * pszInput) {

        ContainerThreadError(_T("XnignService-%d Input %s"), m_nServiceID, pszInput);

        return true;

    };

    bool PowerEntry(SystemPowerState & State) {

        /*

        enum SystemPowerState

        {

            PowerState_S0 = 1,  // 高性能全速

            PowerState_S1,      // IDLE低负载

            PowerState_S2,      // RAM驻留，任务调度暂停

            PowerState_S3       // 关机，需要做数据持久化

        };

        */

        switch (State)

        {

        case SystemPowerState::PowerState_S0:

            break;

        case SystemPowerState::PowerState_S1:

            break;

        case SystemPowerState::PowerState_S2:

            break;

        case SystemPowerState::PowerState_S3:

            break;

        }

        m_XnignState.bNeedEntryPower = 1;

        m_XnignState.nNeedEntryPower = State;

        if (m_XnignState.nCanEntryPower > State)

        {

            return true;

        }

        return false;

    };

    bool StartService(unsigned int nServiceID,const char * pszCommand) {

        bool bOk=BindTcpServerByContainerThread(HttpCacheStubThreadT::TcpRpcServerT, 79,this);

        if(bOk)BindTcpServerByContainerThread(HttpServer::TcpSocketT, 80,this);

        ContainerThreadError(_T("XnignService-%d StartService %s %s"), nServiceID, pszCommand,(bOk)?_T("OK"):_T("Fail"));

        if (bOk == false)

        {

            m_XnignState.bNeedClose = true;

            m_WaitEvent.SetEvent();

        }

        m_nServiceID = nServiceID;

        memset(&m_OwnInfo, 0, sizeof(m_OwnInfo));

        return bOk;

    };

    bool StopService() {

        ContainerThreadError(_T("XnignService-%d StopService "), m_nServiceID);

        return true;

    };

    bool CloseService() {

        ContainerThreadError(_T("XnignService-%d CloseService bCanClose=%d"), m_nServiceID, m_XnignState.bCanClose);

        if (m_XnignState.bCanClose)

        {

            return true;

        }

        UnBindTcpServerByContainerThread(HttpCacheStubThreadT::TcpRpcServerT, 79, this);

        UnBindTcpServerByContainerThread(HttpServer::TcpSocketT, 80, this);

        m_XnignState.bNeedClose = 1;

        m_WaitEvent.SetEvent();

        return false;

    };

    void Init() {

        nWaitTime = ::GetTickCount64();

        memset(&m_XnignState, 0, sizeof(m_XnignState));

    };

    void Close() {

        ContainerThreadError(_T("XnignService-%d Thread Close "), m_nServiceID);

    };

    void Loop(void * pContext = NULL);

private:

};

OPTIMIZE_OFF

void XnignService::Loop(void * pContext)

{

    USING_HERETICOS_THREAD;

    ContainerThreadError(_T("XnignService begin..."));

    for (;;)

    {

        XOS_Wait(m_WaitEvent);

        if (m_XnignState.bNeedClose)

        {

            for (;;)

            {

                if (m_OwnInfo.g_nCurrentServerLinkCount == 0)

                {

                    m_XnignState.bCanClose = 1;//系统可以关闭服务了

                    break;

                }

                XOS_Sleep_Name(_WaitHttpServerClose, 100);

            }

        }

    }

    ContainerThreadError(_T("XnignService exit..."));

    ExitThread();

}

OPTIMIZE_OFF_END

微服务的组成接口介绍

1.成为一个异数OS线程

建一个类Test，public HereticThread,然后实现线程需要的3个接口init close loop.

2.实现微服务接口

bool StartService(unsigned int nServiceID,const char * pszCommand)，用户启动服务是调用

bool CloseService()，用户关闭服务是调用

bool PowerEntry(SystemPowerState & State) 用户关闭系统或者系统电源状态发生改变是请求服务是否能进入目标状态，如果不能进入目标状态则返回false ,系统会再下一个电源周期再次请求进入，用户需要自己实现一个服务状态机来交互式响应系统电源状态以满足需求，比如关机数据持久化等能力。

bool Input(const char * pszInput) 服务运行后，用户可以对服务输入运行时命令，服务通过该接口响应用户输入的命令。

3.微服务的注册，填充如下结构体，标明服务名，类实例，版权信息，启动类型（系统自启，容器自启，单例）



struct ServiceInfo

{

    ServiceFactoryInterface * pServiceFactory;

    unsigned int nServiceType;

    char * pszServiceName;

    char * pszServiceDesc;

    char * pszServiceVer;

    char * pszAuthor;

    char * pszCopyright;

    char * pszHelp;

};

#define SERVICE_TYPE_NONE               0x0     //默认启动类型，用户手动启动，可多例启动

#define SERVICE_TYPE_SYSTEM_ROOT        0x1     //系统启动时自启

#define SERVICE_TYPE_CONTAINER_ROOT     0x2     //容器启动时自启

#define SERVICE_TYPE_CONTAINER_SINGLE_INSTANCE  0x4     //单例启动(每容器)

#define SERVICE_TYPE_SYSTEM_SINGLE_INSTANCE     0x8     //单例启动(每系统)

定义一个ServiceInfo服务注册信息结构

{

    &ServiceFactory<XnignService>::GetInstance(),

    SERVICE_TYPE_CONTAINER_ROOT,

    "Xnign",

    "织梦师-Xnign http server.",

    "0.1",

    "往事",

    "HereticOS,往事",

    ""

}

未来计划

目前由于没有做文件系统，因此没有完整的实现容器镜像功能，后面会实现虚拟容器概念，来将镜像动态分配类运行时的物理容器。

码农公寓