\r + optimizations

command.zig

@@ -1,6 +1,9 @@
 const std = @import("std");
 const storage = @import("storage.zig");
 
+const FAILURE_RESPONSE = "error";
+const SUCCESS_RESPONSE = "success";
+
 const Command = enum {
     read,
     write,
@@ -15,13 +18,13 @@ fn parseKeyValue(buf: []const u8) ?[2][]const u8 {
 }
 
 pub fn parse(msg: []const u8) ?[]const u8 {
-    const trimSet = [_]u8{ '\n', ' ' };
+    const trimSet = [_]u8{ '\n', ' ', '\r' };
     const cleanMsg = std.mem.trim(u8, msg, &trimSet);
     var messageIterator = std.mem.splitAny(u8, cleanMsg, " ");
 
     const cmdString = messageIterator.first();
     const command = std.meta.stringToEnum(Command, cmdString) orelse {
-        std.debug.print("Failed to parse command\n", .{});
+        std.debug.print("Failed to parse command: {s}\n", .{cmdString});
         return null;
     };
 
@@ -31,7 +34,7 @@ pub fn parse(msg: []const u8) ?[]const u8 {
 
             const value = storage.read(key) orelse {
                 std.debug.print("Key not found in storage: {s}\n", .{key});
-                return "false";
+                return FAILURE_RESPONSE;
             };
 
             return value;
@@ -40,23 +43,27 @@ pub fn parse(msg: []const u8) ?[]const u8 {
             const kvPair = messageIterator.rest();
 
             const kv = parseKeyValue(kvPair) orelse {
-                std.debug.print("Failed to parse key-value pair\n", .{});
-                return "false";
+                std.debug.print("Failed to parse key-value pair", .{});
+                return FAILURE_RESPONSE;
             };
 
             if (storage.write(kv[0], kv[1])) {
-                return "true";
+                return SUCCESS_RESPONSE;
             }
 
-            std.debug.print("Failed to write to storage\n", .{});
-            return "false";
+            std.debug.print("Failed to write to storage", .{});
+            return FAILURE_RESPONSE;
         },
         .delete => {
-            std.debug.print("Delete command received\n", .{});
-            return "false";
+            const key = messageIterator.rest();
+            if (!storage.delete(key)) {
+                std.debug.print("Failed to delete key from storage: {s}\n", .{key});
+                return FAILURE_RESPONSE;
+            }
+
+            return SUCCESS_RESPONSE;
         },
         .status => {
-            std.debug.print("Status command received\n", .{});
             return "well going our operation";
         },
     }

main.zig

@@ -8,11 +8,13 @@ const socket = @import("socket.zig");
 const command = @import("command.zig");
 const storage = @import("storage.zig");
 
+const PORT = 8080;
+
 pub fn main() !void {
-    const listener = try socket.init(8080);
+    const listener = try socket.init(PORT);
     defer posix.close(listener);
 
-    std.debug.print("2025 pizzakv!\n<danilo.fragoso@dev>\n---------\n", .{});
+    std.debug.print("2025 pizzakv! TCP Listening on port {any}\n<danilo.fragoso@dev>\n---------\n", .{PORT});
     std.debug.print("Commands:\n\nread key\nwrite key|value\ndelete key\nstatus\n", .{});
     std.debug.print("---------\n", .{});
 
@@ -21,7 +23,7 @@ pub fn main() !void {
         var client_address_len: posix.socklen_t = @sizeOf(net.Address);
 
         const conn = posix.accept(listener, &client_address.any, &client_address_len, 0) catch |err| {
-            std.debug.print("error accept: {any}\n", .{err});
+            std.debug.print("error accept: {any}", .{err});
             continue;
         };
 
@@ -35,24 +37,24 @@ pub fn handleConnection(conn: posix.socket_t) !void {
 
     var requestBuffer: [1024 * 1024]u8 = undefined;
     var responseBuffer: [1024 * 1024]u8 = undefined;
+
     while (true) {
-        const n = try socket.readUntilNewLine(conn, &requestBuffer);
+        const n = try socket.readUntilCR(conn, &requestBuffer);
         if (n == 0) {
             break;
         }
 
         const cmdResponse = command.parse(requestBuffer[0..n]) orelse {
-            std.debug.print("Failed to parse message\n", .{});
-            socket.write(conn, "false\n") catch |err| {
-                std.debug.print("error writing: {any}\n", .{err});
+            socket.write(conn, "error\r") catch |err| {
+                std.debug.print("error writing: {any}", .{err});
             };
             continue;
         };
 
         @memcpy(responseBuffer[0..cmdResponse.len], cmdResponse);
-        responseBuffer[cmdResponse.len] = '\n';
+        responseBuffer[cmdResponse.len] = '\r';
         socket.write(conn, responseBuffer[0 .. cmdResponse.len + 1]) catch |err| {
-            std.debug.print("error writing: {any}\n", .{err});
+            std.debug.print("error writing: {any}", .{err});
         };
     }
 }

storage.zig

@@ -5,6 +5,8 @@ var buf: [backend_size][]const u8 = undefined;
 var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
 const allocator = arena.allocator();
 
+const EMPTY = "";
+
 pub fn hashKey(k: []const u8) u32 {
     return djb2(k);
     //return xoramasrosas(k);
@@ -44,5 +46,19 @@ pub fn write(key: []const u8, value: []const u8) bool {
 
 pub fn read(key: []const u8) ?[]const u8 {
     const hash = hashKey(key);
+    if (buf[hash % buf.len].len == 0) {
+        return null;
+    }
+
     return buf[hash % buf.len];
 }
+
+pub fn delete(key: []const u8) bool {
+    const hash = hashKey(key);
+    if (hash % buf.len >= buf.len) {
+        return false;
+    }
+
+    buf[hash % buf.len] = EMPTY;
+    return true;
+}