Initialization and Termination of Diarkis Module

This page introduces part of the code from the directmessage_simple sample to explain the overall flow when using the Diarkis Module. The actual source code of the sample is located in samples\directmessage_simple\directmessage_simple.cpp.

Initialization of Diarkis Runtime Library and Diarkis Module

First, call DiarkisInterfaceBase::DiarkisInit() to initialize the Diarkis Runtime Library and Diarkis Module. This process must be executed only once at the very start across the entire application.

    // Initialization process of Diarkis Runtime
    // Must be called once across the entire application before using Diarkis functionalities.
    // In this sample, we initialize the runtime with settings to output logs to a file.
    DiarkisInterface::DiarkisInit(uid, LogOutType::FILE_OUT, true, nullptr);

Creating an Instance of DiarkisInterfaceBase

Next, to connect to the Diarkis server and use various features of Diarkis, create an instance of a class that inherits from DiarkisInterfaceBase. At this time, pass the UID (User ID) used to connect to the Diarkis server.

    // Create a class inherited from DiarkisInterface to access all functions of Diarkis.
    diarkis = Diarkis::DiarkisAllocShared<DiarkisInterfaceDirectMessageSimple>(uid);

Initialization of Low-Level Communication Layer

After creating an instance of DiarkisInterfaceBase, set up TCP/UDP communication used for communicating with the Diarkis server.

    diarkis->SetupUdp();

Obtaining Connection Information to Diarkis Server

Next, obtain the information required to connect to the Diarkis server. (TODO) Explain briefly about client key, server type, etc. The included sample implements two patterns: obtaining connection information from an HTTP server within the Diarkis cluster and via an API server (external server).

Pattern of Obtaining Connection Information from HTTP Server within Diarkis Cluster

Use DiarkisInterfaceBase::GetEndpoint() to obtain connection information. The obtained connection information is automatically stored within DiarkisInterfaceBase and used when connecting.

#if API_AUTH == 0
    // Access the HTTP server within the Diarkis cluster to obtain the server endpoint used for DirectMessage communication.
    // Depending on the communication method used, it is necessary to specify the appropriate server type to obtain the endpoint from the server.
    if (diarkis->GetEndpoint(host.c_str(), clientKey.c_str(), serverType.c_str(), endpoint, 256) == false)
    {
        DiarkisUtils::Print("Failed to get %s endpoint: host=%s uid=%s clientKey=%s", serverType.c_str(), host.c_str(), uid.c_str(), clientKey.c_str());
        DiarkisInterface::DiarkisDestroy();
        return 1;
    }

    DiarkisUtils::Print("Endpoint: %s", endpoint);
    DiarkisUtils::Print("UID     : %s\n", uid.c_str());
#endif // API_AUTH

Additionally, although not used in the sample,

• DiarkisInterfaceBase::RequestEndpointAsync()

• DiarkisInterfaceBase::GetEndpointAsyncStatus()

• DiarkisInterfaceBase::GetAsyncEndpointResult()

can be used to obtain endpoint information asynchronously.

Pattern of Obtaining Connection Information via API Server (External Server)

Save the connection information obtained by some method such as an API server (external server) into AuthInfo, and pass this information during the actual connection process.

#if API_AUTH
    struct AuthInfo auth;
    //diarkis->GetAuthInfo(&auth);

    // The following is a sample code to connect to a UDP server using UDP connection information obtained via an API server (external server).
    // If GetEndpoint() is not called, it is necessary to set the connection information obtained via the API server.
    // The following is merely a sample connection information and cannot be used to connect to a UDP server as is.
    std::string endpointString = "192.168.10.5:7100";
    std::string sidString = "a19c5dbb52de43e4a1fad47e5df166e0";
    std::string keyString = "495c0ca446704cb3ab37a8bd986c57a1";
    std::string ivString = "5b0ca9eb9de34df0b333eccd878d524f";
    std::string mackeyString = "88253f5c994a45bc9d9a6eb9ed502075";

    // Below is a sample code to set the endpoint and auth structure's sid, cred.key, cred.iv, cred.mac.
    strcpy(endpoint, endpointString.c_str());
    HexadecimalStringToByteArray(sidString.c_str(), auth.sid, DIARKIS_AUTHKEY_LEN);
    HexadecimalStringToByteArray(keyString.c_str(), auth.cred.key, DIARKIS_AUTHKEY_LEN);
    HexadecimalStringToByteArray(ivString.c_str(), auth.cred.iv, DIARKIS_AUTHKEY_LEN);
    HexadecimalStringToByteArray(mackeyString.c_str(), auth.cred.mac, DIARKIS_AUTHKEY_LEN);
#endif // API_AUTH

Connecting to Diarkis Server

If connection information is obtained externally, pass the obtained information at this timing. Additionally, since it may take time for the connection to actually complete after executing the connection process, periodically check the connection status to confirm if the connection has been completed.

    // Connect to the endpoint obtained via HTTP access and establish communication with the Diarkis server.
    // In this sample, connect to the Diarkis server using TCP/UDP sockets.
    bool connectResult = false;
#if API_AUTH == 0
    connectResult = diarkis->ConnectUdp(endpoint);
#else
    connectResult = diarkis->ConnectUdp(endpoint, serverType.c_str(), &auth);
#endif

    // Although the connection process starts by calling DiarkisInterface::ConnectUdp/Tcp(), it may take some time for the connection to actually complete.
    // Check the TCP/UDP connection status to ensure connection is confirmed.
    while (!diarkis->GetUdpBase()->IsConnected())
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }

Initialization of Each Module

After the connection to the Diarkis server is completed, set up each module you want to use and perform the communication process required by the application.

    // Initialize the DirectMessage module managed within DiarkisInterface.
    // Allocate an instance of the DirectMessage module and associate it with the TCP/UDP module used for communication.
    // From here on, access the DirectMessage functionalities by obtaining the DirectMessage module pointer from DiarkisInterface.
    diarkis->SetupDirectMessage();

Disconnecting from Diarkis Server

Start the disconnection process from the Diarkis server by calling DiarkisInterfaceBase::Disconnect(). Similar to the connection, it may take time for the disconnection to actually complete, so check the connection status after executing the disconnection process to confirm if the disconnection has been completed.

    // Disconnect from the Diarkis server
    diarkis->Disconnect();

    // The disconnection process starts with the call to DiarkisInterface::Disconnect(), but it may take some time for the disconnection to actually complete.
    // Check the TCP/UDP connection status to move to termination process after ensuring the disconnect is complete.
    while (diarkis->GetUdpBase()->IsConnected() == true)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }

Releasing Used Instances

Once the disconnection from the Diarkis server is completed and DiarkisInterfaceBase is no longer needed, release the instance.

    diarkis = nullptr;

Termination Process

At the termination of the application, call DiarkisInterfaceBase::DiarkisDestroy() to perform the overall termination process of Diarkis. This process pairs with DiarkisInterfaceBase::DiarkisInit(), and similar to DiarkisInit, it should be called only once across the entire lifecycle of the application.

    // Termination process of Diarkis Runtime
    // Once the use of Diarkis is complete, call DiarkisInterface::DiarkisDestroy() once when, for example, the application ends.
    DiarkisInterface::DiarkisDestroy();