samchon::protocol::service Namespace Reference

Package of cloud service as a server. More...

Classes
class	Client
	A network boundary with the client in an User. More...
class	IPUserPair
	Relationship between IP address and User for issuing session. More...
class	Server
	A server for (cloud) service. More...
class	Service
	A service. More...
class	ServiceKeeper
	A keeper blocking destrunction of User and Client. More...
class	User
	User containing Client(s) with session-id. More...

Detailed Description

Package of cloud service as a server.

In Samchon Framework, realizing cloud service, there're two classes representing physical server and client as Server and Client. Between the two classes representing boundaries, there is a class representing logical conception user as User. In the terminal node under the Client, Service class represents a control.

The default protocol of the service package is not 'web socket'. The default only has message protocol of Invoke, does not have handshake or another pre-defined protocol. By the default protocol, you can connect to the cloud server (built from c++, by service package) as a client by a program or plug-in like Flex or C#. However you can't connect by web-browser only allowing socket protocol as web-socket.

To build a cloud service to follow web-socket protocol, inherits derviced classes not from Server, Client, but from WebServer, WebClient or implements IWebServer, IWebClient which are derived from Server and Client.

Class Diagram

Sequence Diagram - A client's connection

Sequence Diagram - Network communication

Simple example - Chat service

example/chat_service/ChatServer.hpp

#pragma once
#include <samchon/protocol/service/Server.hpp>

namespace samchon
{
    namespace example
    {
        namespace chat_service
        {
            class ChatRoomArray;
            class ChatRoom;

            class ChatServer
                : public protocol::service::Server
            {
            protected:
                typedef protocol::service::Server super;

                virtual auto PORT() const -> int override
                {
                    return 37749;
                };

            private:
                ChatRoomArray *roomArray;

            public:
                ChatServer();
                virtual ~ChatServer();

            protected:
                virtual auto createUser() -> protocol::service::User* override;

            public:
                auto getChatRoomArray() const -> ChatRoomArray*;
            };
        };
    };
};

example/chat_service/ChatUser.hpp

#pragma once
#include <samchon/protocol/service/User.hpp>

namespace samchon
{
    namespace example
    {
        namespace chat_service
        {
            class ChatUser
                : public protocol::service::User
            {
            public:
                ChatUser(protocol::service::Server*);
                virtual ~ChatUser() = default;

            protected:
                virtual auto createClient() -> protocol::service::Client* override;
            };
        };
    };
};

example/chat_service/ChatClient.hpp

#pragma once
#include <samchon/protocol/service/Client.hpp>

namespace samchon
{
    namespace example
    {
        namespace chat_service
        {
            class ChatClient
                : public protocol::service::Client
            {
            public:
                ChatClient(protocol::service::User*);
                virtual ~ChatClient() = default;

            protected:
                auto createService(const std::string &) -> protocol::service::Service* override;
            };
        };
    };
};

example/chat_service/ChatService.hpp

#pragma once
#include <samchon/protocol/service/Service.hpp>

namespace samchon
{
    namespace example
    {
        namespace chat_service
        {
            class ChatRoom;

            class ChatService
                : public protocol::service::Service
            {
            private:
                typedef protocol::service::Service super;

                ChatRoom *room;

            public:
                ChatService(protocol::service::Client*);
                virtual ~ChatService();

                virtual void replyData(std::shared_ptr<protocol::Invoke>) override;
            };
        };
    };
};

example/chat_service/ListService.hpp

#pragma once
#include <samchon/protocol/service/Service.hpp>

namespace samchon
{
    namespace example
    {
        namespace chat_service
        {
            class ListService;

            class ListService
                : public protocol::service::Service
            {
            private:
                typedef protocol::service::Service super;

            public:
                ListService(protocol::service::Client*);
                virtual ~ListService() = default;

                virtual void replyData(std::shared_ptr<protocol::Invoke> invoke) override;

            private:
                void createRoom(const std::string &);

                void handleRoomArray(std::shared_ptr<library::XML>);
                void handleMakeRoom(bool);
                void handleRoomArray(bool);
            };
        };
    };
};

example/chat_service/ChatRoomArray.hpp

#pragma once
#include <samchon/library/CriticalDictionary.hpp>
#include <samchon/protocol/IEntityGroup.hpp>

namespace samchon
{
    namespace library { class XML; };
    namespace protocol { class Invoke; };

    namespace example
    {
        namespace chat_service
        {
            class ChatRoom;
            
            class ChatServer;
            class ChatUser;

            class ChatRoomArray
                : public CriticalDictionary<std::shared_ptr<ChatRoom>>,
                public protocol::IEntityGroup
            {
            protected:
                typedef CriticalDictionary<std::shared_ptr<ChatRoom>> super;
                
                virtual auto TAG() const -> std::string { return "roomArray"; };
                virtual auto CHILD_TAG() const -> std::string { return "room"; };

            private:
                ChatServer *server;
                
            public:
                /* -----------------------------------------------------------------
                    CONSTRUCTORS
                ----------------------------------------------------------------- */
                ChatRoomArray(ChatServer*);
                virtual ~ChatRoomArray() = default;
                
                /* -----------------------------------------------------------------
                    NOTIFIER
                ----------------------------------------------------------------- */
                void notify();

            private:
                /* -----------------------------------------------------------------
                    EXPORTERS
                ----------------------------------------------------------------- */
                auto toXML() const -> std::shared_ptr<library::XML>;

                auto toInvoke() const -> std::shared_ptr<protocol::Invoke>;
            };
        };
    };
};

example/chat_service/ChatRoom.hpp

#pragma once
#include <samchon/protocol/Entity.hpp>
#include <samchon/protocol/IProtocol.hpp>

#include <string>
#include <samchon/library/CriticalSet.hpp>


namespace samchon
{
    namespace example
    {
        namespace chat_service
        {
            class ChatUser;
            class ChatService;

            class ChatRoomArray;

            class ChatRoom
                : public protocol::Entity,
                public protocol::IProtocol
            {
            protected:
                typedef protocol::Entity super;

                virtual auto TAG() const -> std::string { return "room"; };

            private:
                ChatRoomArray *roomArray;

                std::string name;

                ChatUser *host;

                library::CriticalSet<ChatService*> participants;

            public:
                /* -----------------------------------------------------------
                    CONSTRUCTORS
                ----------------------------------------------------------- */
                ChatRoom(ChatRoomArray*, const std::string &, ChatUser*);
                virtual ~ChatRoom() = default;
                
                void registerClient(ChatService*);

                void eraseClient(ChatService*);

                /* -----------------------------------------------------------
                    CHAIN OF RESPONSIBILITY
                ----------------------------------------------------------- */
                virtual void replyData(std::shared_ptr<protocol::Invoke>) override;
                virtual void sendData(std::shared_ptr<protocol::Invoke>) override;  

            public:
                /* -----------------------------------------------------------
                    GETTERS
                ----------------------------------------------------------- */
                virtual auto toXML() const -> std::shared_ptr<library::XML> override;
            };
        };
    };
};

example/chat_service/ChatMessage.hpp

#pragma once
#include <set>
#include <string>

#include <samchon/protocol/Entity.hpp>

namespace samchon
{
    namespace example
    {
        namespace chat_service
        {
            class ChatMessage
                : public protocol::Entity
            {
            protected:
                typedef protocol::Entity super;

                virtual auto TAG() const -> std::string
                {
                    return "message";
                };

            private:
                std::string orator;

                std::string listener;

                std::string message;

            public:
                /* -----------------------------------------------------------
                    CONSTRUCTORS
                ----------------------------------------------------------- */
                ChatMessage();
                virtual ~ChatMessage() = default;

                virtual void construct(std::shared_ptr<library::XML>);

                /* -----------------------------------------------------------
                    GETTERS
                ----------------------------------------------------------- */
                auto getListener() const -> std::string;

                virtual auto toXML() const -> std::shared_ptr<library::XML>;
            };
        };
    };
};

example/chat_service/ChatServer.cpp

example/chat_service/ChatUser.cpp

example/chat_service/ChatClient.cpp

example/chat_service/ChatService.cpp

#include "ChatService.hpp"
#include "ChatRoom.hpp"

#include <samchon/protocol/Invoke.hpp>

using namespace std;
using namespace samchon::protocol;
using namespace samchon::protocol::service;
using namespace samchon::example::chat_service;

ChatService::ChatService(Client *client)
    : super(client)
{
    
}
ChatService::~ChatService()
{
    if(room == nullptr)
        return;

    room->eraseClient(this);
}

void ChatService::replyData(shared_ptr<Invoke> invoke)
{
    if(invoke->getListener() == "sendMessage")
        room->replyData(invoke);
}

example/chat_service/ListService.cpp

example/chat_service/ChatRoomArray.cpp

#include "ChatRoomArray.hpp"
#include "ChatRoom.hpp"

#include "ChatServer.hpp"
#include "ChatUser.hpp"
#include "ChatClient.hpp"
#include "ListService.hpp"

#include <thread>
#include <samchon/library/XML.hpp>
#include <samchon/protocol/Invoke.hpp>

using namespace std;
using namespace samchon::library;
using namespace samchon::protocol;
using namespace samchon::example::chat_service;

ChatRoomArray::ChatRoomArray(ChatServer *server)
    : super(),
    IEntityGroup()
{
    this->server = server;
}

void ChatRoomArray::notify()
{
    shared_ptr<Invoke> &invoke = this->toInvoke();

    UniqueReadLock uk(get_allocator().getMutex());
    for (auto it = server->begin(); it != server->end(); it++)
    {
        auto user = it->second;

        for (auto u_it = user->begin(); u_it != user->end(); u_it++)
        {
            auto client = u_it->second;
            auto service = client->getService();

            if (dynamic_cast<ListService>(service) != nullptr)
                thread(&IProtocol::sendData, service, invoke).detach();
        }
    }
}

auto ChatRoomArray::toXML() const -> shared_ptr<XML>
{
    shared_ptr<XML> xml(new XML());
    xml->setTag(TAG());

    UniqueReadLock uk(get_allocator().getMutex());
    for(auto it = begin(); it != end(); it++)
        xml->push_back(it->second->toXML());

    return xml;
}
auto ChatRoomArray::toInvoke() const -> shared_ptr<Invoke>
{
    Invoke *invoke = new Invoke("handleRoomArray", toXML());
    return shared_ptr<Invoke>(invoke);
}

example/chat_service/ChatRoom.cpp

#include "ChatRoom.hpp"
#include "ChatRoomArray.hpp"
#include "ChatMessage.hpp"

#include "ChatUser.hpp"
#include "ChatClient.hpp"
#include "ChatService.hpp"

#include <samchon/library/XML.hpp>
#include <samchon/protocol/Invoke.hpp>

using namespace std;
using namespace samchon::library;
using namespace samchon::protocol;
using namespace samchon::example::chat_service;

/* -----------------------------------------------------------
    CONSTRUCTORS
----------------------------------------------------------- */
ChatRoom::ChatRoom(ChatRoomArray *roomArray, const string &name, ChatUser *host)
    : super(),
    IProtocol()
{
    this->roomArray = roomArray;

    this->name = name;
    this->host = host;
}

void ChatRoom::registerClient(ChatService *service)
{
    participants.insert(service);

    sendData(shared_ptr<Invoke>(new Invoke("handleRoom", toXML())));
    roomArray->notify();
}
void ChatRoom::eraseClient(ChatService *service)
{
    if (participants.erase(service) == 0)
        roomArray->erase(this->name);
    else
        sendData(shared_ptr<Invoke>(new Invoke("handleRoom", toXML())));

    roomArray->notify();
}

/* -----------------------------------------------------------
    CHAIN OF RESPONSIBILITY
----------------------------------------------------------- */
void ChatRoom::replyData(shared_ptr<Invoke> invoke)
{
    if(invoke->getListener() == "sendMessage")
    {
        shared_ptr<Invoke> ivk(new Invoke("handleMessage"));
        ivk->at(0) = invoke->at(0);

        sendData(ivk);
    }
}
void ChatRoom::sendData(shared_ptr<Invoke> invoke)
{
    UniqueReadLock uk(participants.get_allocator().getMutex());

    if(invoke->getListener() == "handleMessage")
    {
        ChatMessage message;
        message.construct(invoke->at(0)->getValueAsXML());

        if(message.getListener().empty() == true)
            for (auto it = participants.begin(); it != participants.end(); it++)
                (*it)->sendData(invoke);
        else
            for (auto it = participants.begin(); it != participants.end(); it++)
                if((*it)->getClient()->getUser()->getID() == message.getListener())
                    (*it)->sendData(invoke);
    }
    else
        for (auto it = participants.begin(); it != participants.end(); it++)
            (*it)->sendData(invoke);
}

/* -----------------------------------------------------------
    EXPORTS
----------------------------------------------------------- */
auto ChatRoom::toXML() const -> shared_ptr<XML>
{
    shared_ptr<XML> &xml = super::toXML();
    xml->setProperty("name", name);
    xml->setProperty("host", host->getID());

    for (auto it = participants.begin(); it != participants.end(); it++)
    {
        shared_ptr<XML> participant(new XML());
        participant->setTag("participant");
        participant->setValue((*it)->getClient()->getUser()->getID());

        xml->push_back(participant);
    }
    return xml;
}

example/chat_service/ChatMessage.cpp

#include "ChatMessage.hpp"

#include <samchon/library/XML.hpp>

using namespace std;
using namespace samchon::library;
using namespace samchon::protocol;
using namespace samchon::example::chat_service;

/* -----------------------------------------------------------
    CONSTRUCTORS
----------------------------------------------------------- */
ChatMessage::ChatMessage()
    : super()
{
}
void ChatMessage::construct(shared_ptr<XML> xml)
{
    this->orator = xml->getProperty("orator");
    this->message = xml->getProperty("message");

    if(xml->hasProperty("listener") == true)
        this->listener = xml->getProperty("listener");
    else
        this->listener.clear();
}

/* -----------------------------------------------------------
    GETTERS
----------------------------------------------------------- */
auto ChatMessage::getListener() const -> string
{
    return listener;
}
auto ChatMessage::toXML() const -> shared_ptr<XML>
{
    shared_ptr<XML> &xml = super::toXML();
    xml->setProperty("orator", orator);
    xml->setProperty("message", message);

    if(listener.empty() == false)
        xml->setProperty("listener", listener);
    return xml;
}

Author

Jeongho Nam http://samchon.org