push Client version 1.0.0

prak3/.vscode/launch.json

@@ -42,10 +42,6 @@
             "request": "launch",
             "program": "${workspaceFolder}/build/src/myclient",
             "args": [
-                "store",
-                "id",
-                "5"
-
             ],
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}",

prak3/.vscode/settings.json

@@ -52,6 +52,7 @@
         "stop_token": "cpp",
         "streambuf": "cpp",
         "thread": "cpp",
-        "typeinfo": "cpp"
+        "typeinfo": "cpp",
+        "map": "cpp"
     }
 }
\ No newline at end of file

prak3/src/client.cpp

@@ -2,39 +2,38 @@
 #include <cstring>
 #include <unistd.h>
 #include <arpa/inet.h>
+#include <vector>
+#include <cstdlib>
+#include <ctime>
 
-
-//#define SERVER_IP "141.100.42.11"
 #define SERVER_IP "127.0.0.1"
-
 #define PORT 2525
-
 #define BUFFER_SIZE 1024
+#define REQUEST_COUNT 70000
 
-std::string createMessage(const std::string& operation, const std::string& key, const std::string& value = "") {
-    if (operation == "store") {
-        return "s," + key + "," + value + ";";
-    } else if (operation == "get") {
-        return "g," + key + ";";  // Klammern entfernt
-    } else if (operation == "delete") {
-        return "d," + key + ";";
-    }
-    return "";
+std::string generateRandomKey() {
+    return "key" + std::to_string(rand() % 1000);
 }
 
-int main(int argc, char* argv[]) {
+std::string generateRandomValue() {
+    return "value" + std::to_string(rand() % 10000);
+}
 
-    if (argc < 3 || argc > 4) {
-        std::cerr << "Usage: " << argv[0] << " <operation> <key> [value]" << std::endl;
-        return 1;
+std::string createRandomMessage() {
+    char operations[] = {'s', 'g', 'd'};
+    char operation = operations[rand() % 3];
+    std::string key = generateRandomKey();
+    
+    if (operation == 's') {
+        return "s," + key + "," + generateRandomValue() + ";";
+    } else {
+        return std::string(1, operation) + "," + key + ";";
     }
+}
 
-    std::string operation = argv[1];
-    std::string key = argv[2];
-    std::string value = (argc == 4) ? argv[3] : "";
-
+int main() {
+    srand(time(nullptr));
 
-//######################### Socket Erstellen #########################
     int sock;
     struct sockaddr_in server_address;
     char buffer[BUFFER_SIZE] = {0};
@@ -49,36 +48,30 @@ int main(int argc, char* argv[]) {
     // Serveradresse konfigurieren
     server_address.sin_family = AF_INET;
     server_address.sin_port = htons(PORT);
-
-    // IP-Adresse konvertieren
     if (inet_pton(AF_INET, SERVER_IP, &server_address.sin_addr) <= 0) {
         perror("Invalid address");
         exit(EXIT_FAILURE);
     }
-//######################### Verbindung Aufbauen #########################
+
     // Verbindung zum Server herstellen
     if (connect(sock, (struct sockaddr*)&server_address, sizeof(server_address)) < 0) {
         perror("Connection failed");
         exit(EXIT_FAILURE);
     }
-//######################### Request abschicken  #########################
-    // Nachricht basierend auf den Argumenten erstellen
-    std::string message = createMessage(operation, key, value);
-    if (message.empty()) {
-        std::cerr << "Invalid operation! Use 'store', 'get', or 'delete'." << std::endl;
-        return 1;
-    }
-    // Nachricht senden
-    send(sock, message.c_str(), message.size(), 0);
-    std::cout << "Message sent: " << message << std::endl;
-//######################### Antwort empfangen  #########################
-    // Antwort empfangen
-    ssize_t bytes_received = read(sock, buffer, BUFFER_SIZE);
-    if (bytes_received > 0) {
-        std::cout << "Server: " << buffer << std::endl;
+
+    for (int i = 0; i < REQUEST_COUNT; i++) {
+        std::string message = createRandomMessage();
+        send(sock, message.c_str(), message.size(), 0);
+        std::cout << "Sent: " << message << std::endl;
+
+        ssize_t bytes_received = read(sock, buffer, BUFFER_SIZE);
+        if (bytes_received > 0) {
+            std::cout << "Server: " << buffer << std::endl;
+        }
+        memset(buffer, 0, BUFFER_SIZE);
     }
-//######################### Client Beenden  #########################
-    // Socket schließen
+
+    std::cout << "Closing connection..." << std::endl;
     close(sock);
     return 0;
 }

prak3/src/server.cpp

@@ -8,25 +8,17 @@
 #include <map>
 
 #define PORT 2525
-
 #define BUFFER_SIZE 1024
 #define STORE_OPERATION 's'
 #define GET_OPERATION 'g'
 #define DELETE_OPERATION 'd'
 
+//=========== SLOW PARSER ====================
 struct Request {
     char operation;         
     std::string key;      
     std::string value;
 };
-
-std::mutex mtx;
-std::map<std::string,std::string> DB;
-
-
-
-
-
  Request* parseRequest(const char* buffer) {
     // Create a new Request struct
     Request* req = new Request();
@@ -63,52 +55,116 @@ std::map<std::string,std::string> DB;
 
     return req;
 }
+//=============================================
 
+std::mutex mtx;
+std::map<std::string, std::string> DB;
+
+// we assume that this function is slow
+std::string processRequest_slow(const std::string& request) {
+
+    std::string response;   
+    Request* parsedRequest = parseRequest(request.c_str());
+
+    std::lock_guard<std::mutex> lock(mtx);
+
+    switch (parsedRequest->operation) {
+        case STORE_OPERATION:
+            DB[parsedRequest->key] = parsedRequest->value;
+            response = "Stored [" + parsedRequest->key + "] = " + parsedRequest->value;
+            break;
+        case GET_OPERATION:
+            if (DB.find(parsedRequest->key) != DB.end()) {
+                response = "Value of [" + parsedRequest->key + "] is " + DB[parsedRequest->key];
+            } else {
+                response = "Key [" + parsedRequest->key + "] not found";
+            }
+            break;
+        case DELETE_OPERATION:
+            if (DB.erase(parsedRequest->key)) {
+                response = "Deleted key [" + parsedRequest->key + "]";
+            } else {
+                response = "Key [" + parsedRequest->key + "] not found for deletion";
+            }
+            break;
+        default:
+            response = "Invalid operation!";
+            break;
+    }
 
-void handle_client(int client_socket) {
-    char buffer[BUFFER_SIZE] = {0};
+    return response;
+}
+    
+// there is parsing problem the parced key is always with ; at the end
+std::string processRequest(const std::string& request) {
+    std::string response;
 
-    // Nachricht vom Client empfangen
-    ssize_t bytes_received = read(client_socket, buffer, BUFFER_SIZE);
+    size_t first = request.find(",");
+    size_t second = request.find(",", first + 1);
+    size_t end = request.find(";");
 
+    if (first == std::string::npos || end == std::string::npos) {
+        return "Bad request!";
+    }
 
-    if (bytes_received > 0) {
-        //std::cout << "Client: " << buffer << std::endl;
+    char operation = request[0];
+    std::string key;
+    std::string value;
 
-        Request* request = parseRequest(buffer);
-        std::string response;
+    if (second != std::string::npos) {
+        // Extract key without ';'
+        key = request.substr(first + 1, second - first - 1);
+        value = request.substr(second + 1, end - second - 1);
+    } else {
+        // Extract key correctly without including ';'
+        key = request.substr(first + 1, end - first - 1);
+    }
 
-        if(request->operation == STORE_OPERATION){
-            std::lock_guard<std::mutex> lock(mtx);
-            DB[request->key] = request->value;
-            response = "freue dich :)";
-        }else if (request->operation == GET_OPERATION){
-           
-            std::lock_guard<std::mutex> lock(mtx);
-            auto it = DB.find(request->key);
-            if (it != DB.end()) {
-                response = "The Value of the [" + request->key + "] is => " + it->second;
-            }else{
-                response = "Key [" + request->key +"] Not Found";
+    std::lock_guard<std::mutex> lock(mtx);
+
+    switch (operation) {
+        case STORE_OPERATION:
+            DB[key] = value;
+            response = "Stored [" + key + "] = " + value;
+            break;
+        case GET_OPERATION:
+            if (DB.find(key) != DB.end()) {
+                response = "Value of [" + key + "] is " + DB[key];
+            } else {
+                response = "Key [" + key + "] not found";
             }
-
-        }else if (request->operation == DELETE_OPERATION){
-            std::lock_guard<std::mutex> lock(mtx);
-            if(DB.erase(request->key) != 0){
-                response = "Item with Key [" + request->key +"] is deleted";
-            }else{
-                response = "Key " + request->key +" Not Found for [delete]";
+            break;
+        case DELETE_OPERATION:
+            if (DB.erase(key)) {
+                response = "Deleted key [" + key + "]";
+            } else {
+                response = "Key [" + key + "] not found for deletion";
             }
-        }else{
-            response = "bad request -_____- !";
+            break;
+        default:
+            response = "Invalid operation!";
+            break;
+    }
+
+    return response;
+}
+
+void handle_client(int client_socket) {
+    char buffer[BUFFER_SIZE] = {0};
+
+    while (true) { // the Thread is allways active
+        ssize_t bytes_received = read(client_socket, buffer, BUFFER_SIZE - 1);
+        if (bytes_received <= 0) {
+            std::cout << "Client disconnected." << std::endl;
+            break;
         }
         
-        // send Response
-        send(client_socket, response.c_str(), strlen(response.c_str()), 0);
- 
+        buffer[bytes_received] = '\0';
+        std::string response = processRequest(buffer);
+        
+        send(client_socket, response.c_str(), response.size(), 0);
     }
 
-    // Socket schließen
     close(client_socket);
 }
 
@@ -117,25 +173,21 @@ int main() {
     struct sockaddr_in address;
     socklen_t addrlen = sizeof(address);
 
-    // Socket erstellen
     server_fd = socket(AF_INET, SOCK_STREAM, 0);
     if (server_fd == -1) {
         perror("Socket failed");
         exit(EXIT_FAILURE);
     }
 
-    // Serveradresse festlegen
     address.sin_family = AF_INET;
     address.sin_addr.s_addr = INADDR_ANY;
     address.sin_port = htons(PORT);
 
-    // Socket an Port binden
     if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
         perror("Bind failed");
         exit(EXIT_FAILURE);
     }
 
-    // Server lauscht auf eingehende Verbindungen
     if (listen(server_fd, 5) < 0) {
         perror("Listen failed");
         exit(EXIT_FAILURE);
@@ -153,13 +205,9 @@ int main() {
 
         std::cout << "New client connected" << std::endl;
         
-        // Starte neuen Thread für den Client
         std::thread(handle_client, client_socket).detach();
     }
 
     close(server_fd);
     return 0;
 }
-
-
-

prak3/src/test.cpp

 #include <iostream>
-#include <string>
-#include <cstring> // for strtok and strchr
+#include <thread>
+#include <vector>
+#include <cstring>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <mutex>
+#include <map>
+
+#define PORT 2525
+
+#define BUFFER_SIZE 1024
+#define STORE_OPERATION 's'
+#define GET_OPERATION 'g'
+#define DELETE_OPERATION 'd'
+
+
+
+std::mutex mtx;
+std::map<std::string,std::string> DB;
+
+
+
 
 struct Request {
-    char operation;          // Operation: 's' (store), 'g' (get), 'd' (delete)
-    std::string key;         // Key
-    std::string value;       // Value (only for store operation)
+    char operation;         
+    std::string key;      
+    std::string value;
 };
-
-Request* parseRequest(const char* buffer) {
+ Request* parseRequest(const char* buffer) {
     // Create a new Request struct
     Request* req = new Request();
 
@@ -45,36 +64,102 @@ Request* parseRequest(const char* buffer) {
     return req;
 }
 
+
+void handle_client(int client_socket) {
+    char buffer[BUFFER_SIZE] = {0};
+
+    // Nachricht vom Client empfangen
+    ssize_t bytes_received = read(client_socket, buffer, BUFFER_SIZE);
+
+
+    if (bytes_received > 0) {
+        //std::cout << "Client: " << buffer << std::endl;
+
+        Request* request = parseRequest(buffer);
+        std::string response;
+
+        if(request->operation == STORE_OPERATION){
+            std::lock_guard<std::mutex> lock(mtx);
+            DB[request->key] = request->value;
+            response = "freue dich :)";
+        }else if (request->operation == GET_OPERATION){
+           
+            std::lock_guard<std::mutex> lock(mtx);
+            auto it = DB.find(request->key);
+            if (it != DB.end()) {
+                response = "The Value of the [" + request->key + "] is => " + it->second;
+            }else{
+                response = "Key [" + request->key +"] Not Found";
+            }
+
+        }else if (request->operation == DELETE_OPERATION){
+            std::lock_guard<std::mutex> lock(mtx);
+            if(DB.erase(request->key) != 0){
+                response = "Item with Key [" + request->key +"] is deleted";
+            }else{
+                response = "Key " + request->key +" Not Found for [delete]";
+            }
+        }else{
+            response = "bad request -_____- !";
+        }
+        
+        // send Response
+        send(client_socket, response.c_str(), strlen(response.c_str()), 0);
+ 
+    }
+
+    // Socket schließen
+    close(client_socket);
+}
+
 int main() {
-    // Test cases
-    const char* storeRequest = "s,myKey,myValue;";
-    const char* getRequest = "g,myKey;";
-    const char* deleteRequest = "d,myKey;";
-
-    // Parse requests
-    Request* storeReq = parseRequest(storeRequest);
-    Request* getReq = parseRequest(getRequest);
-    Request* deleteReq = parseRequest(deleteRequest);
-
-    // Print parsed requests
-    if (storeReq) {
-        std::cout << "Store Request: Operation=" << storeReq->operation
-                  << ", Key=" << storeReq->key
-                  << ", Value=" << storeReq->value << std::endl;
-        delete storeReq;
+    int server_fd, client_socket;
+    struct sockaddr_in address;
+    socklen_t addrlen = sizeof(address);
+
+    // Socket erstellen
+    server_fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (server_fd == -1) {
+        perror("Socket failed");
+        exit(EXIT_FAILURE);
     }
 
-    if (getReq) {
-        std::cout << "Get Request: Operation=" << getReq->operation
-                  << ", Key=" << getReq->key << std::endl;
-        delete getReq;
+    // Serveradresse festlegen
+    address.sin_family = AF_INET;
+    address.sin_addr.s_addr = INADDR_ANY;
+    address.sin_port = htons(PORT);
+
+    // Socket an Port binden
+    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
+        perror("Bind failed");
+        exit(EXIT_FAILURE);
     }
 
-    if (deleteReq) {
-        std::cout << "Delete Request: Operation=" << deleteReq->operation
-                  << ", Key=" << deleteReq->key << std::endl;
-        delete deleteReq;
+    // Server lauscht auf eingehende Verbindungen
+    if (listen(server_fd, 5) < 0) {
+        perror("Listen failed");
+        exit(EXIT_FAILURE);
     }
 
+    std::cout << "Server listening on port " << PORT << std::endl;
+
+    while (true) {
+        client_socket = accept(server_fd, (struct sockaddr*)&address, &addrlen);
+        
+        if (client_socket < 0) {
+            perror("Accept failed");
+            continue;
+        }
+
+        std::cout << "New client connected" << std::endl;
+        
+        // Starte neuen Thread für den Client
+        std::thread(handle_client, client_socket).detach();
+    }
+
+    close(server_fd);
     return 0;
-}
+}
\ No newline at end of file
+
+
+