Improve network throughput

CMakeLists.txt

@@ -4,21 +4,35 @@ project(tablo)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-# Tablo shared libraries
+# Build options
 
-# libtabcrypt
-add_subdirectory(lib/libtabcrypt)
+option(DEF_LIBTABCRYPT "Build libtabcrypt" ON)
+option(DEF_LIBTABNET "Build libtabnet" ON)
 
-# libtabnet
-add_subdirectory(lib/libtabnet)
+option(DEF_CLIENT "Build TabloClient" ON)
+option(DEF_MASTER "Build TabloMaster" ON)
+option(DEF_NODE "Build TabloNode" ON)
 
-# Test executables
+# Shared libraries
 
-add_subdirectory(TCTest)
+if(DEF_LIBTABCRYPT)
+    add_subdirectory(lib/libtabcrypt)
+endif()
 
+if(DEF_LIBTABNET)
+    add_subdirectory(lib/libtabnet)
+endif()
 
-# TabloClient, TabloMaster and TabloNode executables (provided by own CMakeLists.txt files)
+# Executables
 
-add_subdirectory(TabloClient)
-add_subdirectory(TabloMaster)
-add_subdirectory(TabloNode)
+if(DEF_CLIENT)
+    add_subdirectory(TabloClient)
+endif()
+
+if(DEF_MASTER)
+    add_subdirectory(TabloMaster)
+endif()
+
+if(DEF_NODE)
+    add_subdirectory(TabloNode)
+endif()

README.md

@@ -14,11 +14,11 @@ The following ports are used to establish the network tablo needs:
 ### 2 Deploy
 
 ```cmd
-nix shell
-./build-image-nix.sh
-tablo-master --interface YOURINTERFACE
-tablo-node --interface YOURINTERFACE
-tablo-client --master YOURMASTERSIP
+sudo nix-collect-garbage -d
+nix build --log-format bar-with-logs
+nix run .#tablo-master -- --interface INTERFACENAME
+nix run .#tablo-node -- --interface INTERFACENAME
+nix run .#tablo-client -- --master MASTERIPV4
 ```
 
 ## Deploy with DOCKER
@@ -45,3 +45,7 @@ The flake in this repository allowes you to build minimal docker images that avo
 
 To use this feature, you NEED to use nix. Download available at: https://nixos.org/
 
+# Take a look at Tablos networking libs:
+<b>Tablo Transfer Protocol:</b><a href="https://github.com/Sobottasgithub/TTP2">TTP2</a>
+
+<b>Tablo UDP Discovery:</b> <a href="https://github.com/Sobottasgithub/TUD">TUD</a>

TabloClient/CMakeLists.txt

@@ -8,8 +8,9 @@ file(GLOB_RECURSE SOURCES "src/*.cpp" "src/*.h")
 
 add_executable(tablo-client ${SOURCES})
 
-# Link against the tabcrypt library
+# Link against libs
 target_link_libraries(tablo-client PRIVATE tabcrypt)
 target_link_libraries(tablo-client PRIVATE tabnet)
+target_link_libraries(tablo-client PRIVATE ttp2)
 
 install(TARGETS tablo-client DESTINATION bin)

TabloClient/src/tabloClient.cpp

@@ -3,18 +3,27 @@
 #include <cstring>
 
 #include "utils/cli.h"
+#include "utils/argv_struct.h"
 
 int main(int argc, char *argv[])
 {
     if (argc > 0) {
+    struct Argv commandLineArguments;
+
         for(int index = 0; index < argc; index++) {
             if (std::string(argv[index]).rfind("--master", 0) == 0) {
-                   Cli cli(argv[index+1]);
+                commandLineArguments.tabloMaster = argv[index+1];
+            } else if (std::string(argv[index]).rfind("--file", 0) == 0) {
+                commandLineArguments.filePath = argv[index+1];
             }
         }
+
+        if (commandLineArguments.tabloMaster.length() != 0) {
+            Cli cli(commandLineArguments);
+        }
     } else {
         // Use config file (TODO)
-        Cli cli("");
+        std::wcout << "failed" << std::endl;
     }
 
     return 0;

TabloClient/src/utils/argv_struct.h

@@ -0,0 +1,11 @@
+#ifndef ARGV_STRUCT_H
+#define ARGV_STRUCT_H
+
+#include<string>
+
+struct Argv {
+    std::string tabloMaster;
+    std::string filePath;
+};
+
+#endif

TabloClient/src/utils/cli.cpp

@@ -1,40 +1,134 @@
 #include "cli.h"
 
-#include <ostream>
+#include <client_session_controller.h>
 #include <string>
 #include <iostream>
-#include <regex>
+#include <fstream>
 #include <thread>
+#include <variant>
 
-#include "networking.h"
+#include "network_manager.h"
 
-Cli::Cli(std::string tabloMaster) {
+Cli::Cli(struct Argv argv) {
+  std::string tabloMaster = argv.tabloMaster;
+  std::string filePath = argv.filePath;
+
   std::wcout << "Client! Tablo master at: " << tabloMaster.c_str() << std::endl;
-  Networking networking;
+
+  NetworkManager networkManager;
+
+  if (networkManager.createSocket(tabloMaster) < 0) {
+    std::wcout << "Create network manager failed!" << std::endl;
+    return;
+  }
 
-  std::thread networkingThread(
-      &Networking::networkingCycle,
-      &networking,
-      tabloMaster
-  );
+  sendFile(filePath, &networkManager);
 
   while (true) {
-    int method;
-    std::wcout << "Method: ";
-    std::cin >> method;
-    std::wcout << std::endl;
+    std::wcout << "Choose option\n(1) send Packet\n(2) read Packets\n(3) send File\n(4) get Viewport\noption:";
+    std::string option = "";
+    std::cin >> option;
+    if (option == "1") {
+      std::string content;
+      std::wcout << "Content: ";
+      std::cin >> content;
 
-    std::string content;
-    std::wcout << "Content: ";
-    std::cin >> content;
-    std::wcout << std::endl;
+      ttp2::Networking::Packet packet;
 
-    networking.pushOrder(method, content);
+      ttp2::Networking::Standard payload;
+      payload.payload = content;
+      packet.payload = payload;
 
-    std::wcout << "Waiting for solution..." << std::endl;
-    while (!networking.hasSolution()) {} // Wait for solution
+      networkManager.pushRequest(packet);
+    } else if (option == "2") {
+      if (networkManager.hasResponse()) {
+        while (networkManager.hasResponse()) {
+          ttp2::ClientSessionController::Packet response = networkManager.popResponse();
+
+          if (std::holds_alternative<ttp2::ClientSessionController::Standard>(response.payload)) {
+            ttp2::ClientSessionController::Standard responsePayload = std::get<ttp2::ClientSessionController::Standard>(response.payload);
+            std::wcout << "Response:\nID: " << response.id << "\nPayload: " << responsePayload.payload.c_str() << std::endl;
+          } else if (std::holds_alternative<ttp2::ClientSessionController::File>(response.payload)) {
+            ttp2::ClientSessionController::File responsePayload = std::get<ttp2::ClientSessionController::File>(response.payload);
+            std::wcout << "Response:\nID: " << response.id
+                       << "\n----payload----\nFilePath: " << responsePayload.filePath.c_str()
+                       << "\nStart: " << responsePayload.start
+                       << "\nEnd: " << responsePayload.end
+                       << "\nPayload: " << responsePayload.payload.c_str()
+                       << "\n---------------" << std::endl; 
+          } else if (std::holds_alternative<ttp2::ClientSessionController::Viewport>(response.payload)) {
+            ttp2::ClientSessionController::Viewport responseViewport = std::get<ttp2::ClientSessionController::Viewport>(response.payload);
+            if (responseViewport.payload.length() > 0) {
+              std::wcout << responseViewport.payload.c_str() << std::endl;
+            } else {
+              std::wcout << "Empty Viewport" << std::endl;
+            }
+          }
+        }
+      } else {
+        std::wcout << "There are currently no packets to read!" << std::endl;
+      }
+    } else if (option == "3") {
+      std::string filePath;
+      std::wcout << "CSV Filepath:";
+      std::cin >> filePath;
+
+      sendFile(filePath, &networkManager);
+    } else if (option == "4") {
+      int xStart;
+      int xEnd;
+      int yStart;
+      int yEnd;
 
-    std::wcout << networking.popSolution().c_str() << std::endl;
+      std::wcout << "xStart:";
+      std::cin >> xStart;
+      std::wcout << "xEnd:";
+      std::cin >> xEnd;
+      std::wcout << "yStart:";
+      std::cin >> yStart;
+      std::wcout << "yEnd:";
+      std::cin >> yEnd;
+
+      ttp2::Networking::Packet packet;
+      ttp2::Networking::Viewport payload;
+      payload.xStart = xStart;
+      payload.xEnd = xEnd;
+      payload.yStart = yStart;
+      payload.yEnd = yEnd;
+      packet.payload = payload;
+
+      networkManager.pushRequest(packet);
+      std::wcout << "Send Viewport request!" << std::endl;
+    } else {
+      std::wcout << "invalid" << std::endl;
+    }
   }
 }
 
+void Cli::sendFile(std::string filePath, NetworkManager* networkManager) {
+  if (filePath.length() != 0) {
+    std::ifstream file(filePath);
+
+    if (file.is_open()) {
+        std::string fileContent;
+        std::string line;
+        int lineCount = 0;
+        while (std::getline(file, line)) {
+          lineCount++;
+          fileContent = fileContent + line.c_str() + "\n";
+        }
+        file.close();
+
+        ttp2::Networking::Packet packet;
+        ttp2::Networking::File payload;
+        payload.filePath = filePath;
+        payload.start = 0;
+        payload.end = lineCount;
+        payload.payload = fileContent;
+        packet.payload = payload;
+
+        networkManager->pushRequest(packet);
+        std::wcout << "Send file with FilePath: " << filePath.c_str() << std::endl;
+    }
+  }
+}

TabloClient/src/utils/cli.h

@@ -1,12 +1,17 @@
 #ifndef CLI_H
 #define CLI_H
 
-#include <string>
+#include "network_manager.h"
+
+#include "argv_struct.h"
 
 class Cli
 {
   public:
-    Cli(std::string tabloMaster);
+    Cli(struct Argv argv);
+
+  private:
+    void sendFile(std::string filePath, NetworkManager* networkManager);
 };
 
 #endif