Server.hpp

#pragma once
#include <samchon/API.hpp>

#include <samchon/protocol/WebServer.hpp>
#include <samchon/protocol/IProtocol.hpp>

#include <samchon/templates/service/User.hpp>

#include <thread>
#include <samchon/HashMap.hpp>
#include <samchon/library/RWMutex.hpp>

namespace samchon
{
namespace templates
{

namespace service
{
    class User;
    class Client;

    class Server
        : public protocol::WebServer,
        public virtual protocol::IProtocol
    {
        friend class User;

    private:
        typedef WebServer super;

        HashMap<std::string, std::shared_ptr<User>> session_map;
        HashMap<std::string, std::shared_ptr<User>> account_map;

        library::RWMutex session_map_mtx;
        library::RWMutex account_map_mtx;

    public:
        /* ---------------------------------------------------------
            CONSTRUCTORS
        --------------------------------------------------------- */
        Server()
            : super()
        {
        };

        virtual ~Server() = default;

    protected:
        virtual auto createUser() -> User* = 0;

    public:
        /* ---------------------------------------------------------
            ACCESSORS
        --------------------------------------------------------- */
        auto has(const std::string &accountID) const -> bool
        {
            return account_map.has(accountID);
        };

        auto get(const std::string &accountID) const -> std::shared_ptr<User>
        {
            return account_map.get(accountID);
        };

        /* ---------------------------------------------------------
            MESSAGE CHAIN
        --------------------------------------------------------- */
        virtual void sendData(std::shared_ptr<protocol::Invoke> invoke) override
        {
            std::vector<std::thread> threadArray;
            library::UniqueReadLock uk(session_map_mtx);

            threadArray.reserve(session_map.size());
            for (auto it = session_map.begin(); it != session_map.end(); it++)
                threadArray.emplace_back(&User::sendData, it->second.get(), invoke);

            uk.unlock();
            for (auto it = threadArray.begin(); it != threadArray.end(); it++)
                it->join();
        };

        virtual void replyData(std::shared_ptr<protocol::Invoke>) = 0;

    private:
        /* ---------------------------------------------------------
            CLIENT I/O
        --------------------------------------------------------- */
        virtual void addClient(std::shared_ptr<protocol::ClientDriver> driver) final
        {
            std::shared_ptr<protocol::WebClientDriver> web_driver = std::dynamic_pointer_cast<protocol::WebClientDriver>(driver);

            // IDENTIFIERS
            const std::string &session_id = web_driver->getSessionID(); // SESSION_ID -> USER
            const std::string &path = web_driver->getPath(); // PATH -> SERVICE

            // CONSTRUCT USER
            std::shared_ptr<User> user;
            HashMap<std::string, std::shared_ptr<User>>::iterator it;
            {
                library::UniqueReadLock uk(session_map_mtx);
                it = session_map.find(session_id);
            }

            if (it == session_map.end())
            {
                // CREATE USER
                user.reset(this->createUser());
                user->my_weak_ptr = user;

                // REGISTER TO THIS SERVER
                library::UniqueWriteLock uk(session_map_mtx);
                session_map.insert({ session_id, user });
            }
            else
                user = it->second; // FETCH ORDINARY USER

            user->account_map = &account_map;
            user->account_map_mtx = &account_map_mtx;
            user->erase_user_function = std::bind(&Server::erase_user, this, user.get());

            // CREATE CLIENT
            std::shared_ptr<Client> client(user->createClient());
            client->user_weak_ptr = user;
            client->my_weak_ptr = client;

            // REGISTER TO USER
            {
                library::UniqueWriteLock uk(user->mtx);

                client->no = ++user->sequence;
                user->insert({ client->no, client });
            }

            // CREATE SERVICE
            Service *service = client->createService(path);
            service->client = client.get();
            service->path = path;

            service->user_weak_ptr = user;
            service->client_weak_ptr = client;

            // REGISTER TO CLIENT
            client->service.reset(service);

            // BEGINS COMMUNICATION
            client->driver->listen(client.get());

            // DISCONNECTED - ERASE CLIENT.
            // IF THE USER HAS NO CLIENT LEFT, THEN THE USER WILL ALSO BE ERASED.
            user->erase(client->no);
            user->check_empty();
        };

        void erase_user(User *user)
        {
            // USER DOESN'T BE ERASED AT THAT TIME
            // IT WAITS UNTIL 30 SECONDS TO KEEP SESSION
            std::this_thread::sleep_for(std::chrono::seconds(30));

            if (user->empty() == false)
            {
                // ERASE FROM ACCOUNT_MAP
                if (user->account.empty() == false)
                {
                    library::UniqueWriteLock w_uk(account_map_mtx);
                    account_map.erase(user->account);
                }

                // ERASE FROM SESSION_MAP
                {
                    library::UniqueWriteLock w_uk(session_map_mtx);
                    session_map.erase(user->session_id);
                }
            }
        };
    };
};
};
};