docs: added echo server and client examples

Author: Alexandre jublot

examples/tcpEcho/MessageDto.hpp

@@ -0,0 +1,56 @@
+/*
+** EPITECH PROJECT, 2020
+** MessageDto.hpp
+** File description:
+** header for MessageDto.c
+*/
+
+#pragma once
+
+#include <string>
+#include "Polymorph/Network/SerializerTrait.hpp"
+
+/**
+ * @brief Message DTO that will be sent over the network
+ */
+#ifdef _WIN32
+#pragma pack(push, 1)
+#endif
+struct MessageDto
+{
+    static constexpr polymorph::network::OpId opId = 3;
+    std::string message;
+}
+#ifdef _WIN32
+    ;
+    #pragma pack(pop)
+#else
+    __attribute__((packed));
+#endif
+
+/**
+ * @brief SerializerTrait specialization for MessageDto because is it not a standard layout type
+ */
+namespace polymorph::network
+{
+    template<>
+    struct SerializerTrait<MessageDto>
+    {
+        static std::vector<std::byte> serialize(const MessageDto &data)
+        {
+            std::vector<std::byte> buffer(data.message.size());
+
+            std::memcpy(buffer.data(), data.message.data(), data.message.size());
+            return buffer;
+        }
+
+        static MessageDto deserialize(const std::vector<std::byte> &buffer)
+        {
+            MessageDto dto;
+
+            dto.message = std::string(reinterpret_cast<const char *>(buffer.data()), buffer.size());
+            return dto;
+        }
+    };
+}
+

examples/tcpEcho/echoClient.cpp

@@ -0,0 +1,58 @@
+#include <iostream>
+#include "Polymorph/Network/tcp/Client.hpp"
+#include "MessageDto.hpp"
+
+
+int main(int ac, char **av)
+{
+    using namespace polymorph::network;
+    using namespace polymorph::network::tcp;
+
+    if (ac != 3) {
+        std::cerr << "Usage: " << av[0] << " <host> <port>" << std::endl;
+        return 1;
+    }
+
+    // we create a client and bind its connector
+    Client client(av[1], std::stoi(av[2]));
+
+    // check variables for the example
+    std::atomic<bool> received(false);
+    std::atomic<bool> connected(false);
+    MessageDto dto { .message = "Hello World!" };
+
+    // we register a callback that will handle the received MessageDto
+    client.registerReceiveHandler<MessageDto>(MessageDto::opId, [&received](const PacketHeader &, const MessageDto &payload) {
+        received = true;
+        std::cout << "Received: " << payload.message << std::endl;
+        return true; // The received data is correct, we do not want to disconnect the client
+    });
+
+    // Then we connect to the server and pass a callback that will be called when the connection is established
+    client.connect([&connected](bool authorized, SessionId) {
+        if (authorized) {
+            std::cout << "Connected" << std::endl;
+            connected = true;
+        } else {
+            std::cout << "Connection failed" << std::endl;
+        }
+    });
+
+    // we wait for the connection to be established or the timeout to be reached (5 * 100ms)
+    int connected_max_tries = 5;
+    while (!connected && --connected_max_tries > 0) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+    assert(connected); // abort if we couldn't connect
+
+    // we send the MessageDto to the server
+    client.send<MessageDto>(MessageDto::opId, dto, [](const PacketHeader &header, const MessageDto &payload) {
+        std::cout << "Message has been sent" << std::endl;
+    });
+
+    // we wait the registered callback to be called
+    while(!received)
+        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // sleep until we received the echoed message
+
+    return 0;
+}

examples/tcpEcho/echoServer.cpp

@@ -0,0 +1,40 @@
+#include <iostream>
+#include <future>
+#include "Polymorph/Network/tcp/Server.hpp"
+#include "MessageDto.hpp"
+
+
+int main(int ac, char **av)
+{
+    using namespace polymorph::network;
+    using namespace polymorph::network::tcp;
+
+    if (ac != 2) {
+        std::cerr << "Usage: " << av[0] << " <port>" << std::endl;
+        return 1;
+    }
+
+    // we create a SessionStore that will attribute the sessions
+    SessionStore sessionStore;
+    // we create a server and bind its connector
+    Server server(std::stoi(av[1]), sessionStore);
+
+    // we register a callback that will handle the received MessageDto and send it back to the client
+    server.registerReceiveHandler<MessageDto>(MessageDto::opId, [&server](const PacketHeader &header, const MessageDto &payload) {
+        std::cout << "Received: " << payload.message << std::endl;
+        MessageDto toResend = payload;
+        server.sendTo<MessageDto>(MessageDto::opId, toResend, header.sId, [](const PacketHeader &header, const MessageDto &payload) {
+            std::cout << "Message has been echoed" << std::endl;
+        });
+        return true; // The received data is correct, we do not want to disconnect the client
+    });
+
+    // we start the server
+    server.start();
+
+    // make the main thread sleep forever
+    std::promise<void> p;
+    p.get_future().wait();
+
+    return 0;
+}

examples/udpEcho/MessageDto.hpp

@@ -0,0 +1,47 @@
+/*
+** EPITECH PROJECT, 2020
+** MessageDto.hpp
+** File description:
+** header for MessageDto.c
+*/
+
+#pragma once
+
+#include <string>
+#include "Polymorph/Network/SerializerTrait.hpp"
+
+/**
+ * @brief Message DTO that will be sent over the network
+ */
+struct MessageDto
+{
+    static constexpr polymorph::network::OpId opId = 3;
+    std::string message;
+};
+
+/**
+ * @brief SerializerTrait specialization for MessageDto because is it not a standard layout type
+ */
+namespace polymorph::network
+{
+    template<>
+    struct SerializerTrait<MessageDto>
+    {
+        static std::vector<std::byte> serialize(const MessageDto &data)
+        {
+            std::vector<std::byte> buffer(data.message.size());
+
+            std::memcpy(buffer.data(), data.message.data(), data.message.size());
+            return buffer;
+        }
+
+        static MessageDto deserialize(const std::vector<std::byte> &buffer)
+        {
+            MessageDto dto;
+
+            dto.message = std::string(reinterpret_cast<const char *>(buffer.data()), buffer.size());
+            return dto;
+        }
+    };
+}
+

examples/udpEcho/echoClient.cpp

@@ -0,0 +1,63 @@
+#include <iostream>
+#include "Polymorph/Network/udp/Client.hpp"
+#include "MessageDto.hpp"
+
+
+int main(int ac, char **av)
+{
+    using namespace polymorph::network;
+    using namespace polymorph::network::udp;
+
+    if (ac != 3) {
+        std::cerr << "Usage: " << av[0] << " <host> <port>" << std::endl;
+        return 1;
+    }
+
+    std::map<OpId, bool> safeties = {
+        { MessageDto::opId, true } // we want the client to resend the message if it doesn't receive an ACK
+    };
+    // we create a client and bind its connector
+    Client client(av[1], std::stoi(av[2]), safeties);
+    auto connector = std::make_shared<Connector>(client);
+    client.setConnector(connector);
+    connector->start();
+
+    // check variables for the example
+    std::atomic<bool> received(false);
+    std::atomic<bool> connected(false);
+    MessageDto dto { .message = "Hello World!" };
+
+    // we register a callback that will handle the received MessageDto
+    client.registerReceiveHandler<MessageDto>(MessageDto::opId, [&received](const PacketHeader &, const MessageDto &payload) {
+        received = true;
+        std::cout << "Received: " << payload.message << std::endl;
+    });
+
+    // Then we connect to the server and pass a callback that will be called when the connection is established
+    client.connect([&connected](bool authorized, SessionId) {
+        if (authorized) {
+            std::cout << "Connected" << std::endl;
+            connected = true;
+        } else {
+            std::cout << "Connection failed" << std::endl;
+        }
+    });
+
+    // we wait for the connection to be established or the timeout to be reached (5 * 100ms)
+    int connected_max_tries = 5;
+    while (!connected && --connected_max_tries > 0) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+    assert(connected); // abort if we couldn't connect
+
+    // we send the MessageDto to the server
+    client.send<MessageDto>(MessageDto::opId, dto, [](const PacketHeader &header, const MessageDto &payload) {
+        std::cout << "Message has been sent" << std::endl;
+    });
+
+    // we wait the registered callback to be called
+    while(!received)
+        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // sleep until we received the echoed message
+
+    return 0;
+}

examples/udpEcho/echoServer.cpp

@@ -0,0 +1,44 @@
+#include <iostream>
+#include <future>
+#include "Polymorph/Network/udp/Server.hpp"
+#include "MessageDto.hpp"
+
+
+int main(int ac, char **av)
+{
+    using namespace polymorph::network;
+    using namespace polymorph::network::udp;
+
+    if (ac != 2) {
+        std::cerr << "Usage: " << av[0] << " <port>" << std::endl;
+        return 1;
+    }
+
+    std::map<OpId, bool> safeties = {
+        { MessageDto::opId, true } // we want the server to resend the message if it doesn't receive an ACK
+    };
+    // we create a SessionStore that will attribute the sessions
+    SessionStore sessionStore;
+    // we create a server and bind its connector
+    Server server(std::stoi(av[1]), safeties, sessionStore);
+    auto connector = std::make_shared<Connector>(server);
+    server.setConnector(connector);
+
+    // we register a callback that will handle the received MessageDto and send it back to the client
+    server.registerReceiveHandler<MessageDto>(MessageDto::opId, [&server](const PacketHeader &header, const MessageDto &payload) {
+        std::cout << "Received: " << payload.message << std::endl;
+        MessageDto toResend = payload;
+        server.sendTo<MessageDto>(MessageDto::opId, toResend, header.sId, [](const PacketHeader &header, const MessageDto &payload) {
+            std::cout << "Message has been echoed" << std::endl;
+        });
+    });
+
+    // we start the server
+    connector->start();
+
+    // make the main thread sleep forever
+    std::promise<void> p;
+    p.get_future().wait();
+
+    return 0;
+}