Skip to content

Commit

Permalink
refactor: use vle to store data, needs to refactor all of those commands
Browse files Browse the repository at this point in the history
  • Loading branch information
@sectasy0
sectasy0 committed Jul 4, 2024
1 parent 3fe7539 commit e170c01
Show file tree
Hide file tree
Showing 4 changed files with 242 additions and 217 deletions.
2 changes: 1 addition & 1 deletion src/protocol/binary.zig
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
const std = @import("std");
const ZType = @import("types/ztype.zig");
const ZType = @import("types/ztype.zig").ZType;
const sets = @import("types/sets.zig");

/// Enum representing the type of data in a binary header.
Expand Down
237 changes: 119 additions & 118 deletions src/server/processing/commands.zig
View file
Original file line number Diff line number Diff line change
Expand Up @@ -65,37 +65,38 @@ pub const Handler = struct {
if (command_set.items.len < 3) return .{ .err = error.InvalidCommand };
return self.set(command_set.items[1], command_set.items[2]);
},
.DELETE => {
if (command_set.items.len < 2) return .{ .err = error.InvalidCommand };
return self.delete(command_set.items[1]);
},
.SIZEOF => {
if (command_set.items.len < 2) return .{ .err = error.InvalidCommand };
return self.sizeof(command_set.items[1]);
},
.RENAME => {
if (command_set.items.len < 3) return .{ .err = error.InvalidCommand };
return self.rename(command_set.items[1], command_set.items[2]);
},
.ECHO => {
if (command_set.items.len < 2) return .{ .err = error.InvalidCommand };
switch (command_set.items[1]) {
.str, .sstr => |text| return .{ .ok = .{ .str = text } },
else => return .{ .err = error.KeyNotString }, // Maybe rename it to FieldNotString or ValueNotString?
}
},
.COPY => {
if (command_set.items.len < 3) return .{ .err = error.InvalidCommand };
return self.copy(command_set.items[1..command_set.items.len]);
},
.MGET => return self.mget(command_set.items[1..command_set.items.len]),
.MSET => return self.mset(command_set.items[1..command_set.items.len]),
// .DELETE => {
// if (command_set.items.len < 2) return .{ .err = error.InvalidCommand };
// return self.delete(command_set.items[1]);
// },
// .SIZEOF => {
// if (command_set.items.len < 2) return .{ .err = error.InvalidCommand };
// return self.sizeof(command_set.items[1]);
// },
// .RENAME => {
// if (command_set.items.len < 3) return .{ .err = error.InvalidCommand };
// return self.rename(command_set.items[1], command_set.items[2]);
// },
// .ECHO => {
// if (command_set.items.len < 2) return .{ .err = error.InvalidCommand };
// switch (command_set.items[1]) {
// .str, .sstr => |text| return .{ .ok = .{ .str = text } },
// else => return .{ .err = error.KeyNotString }, // Maybe rename it to FieldNotString or ValueNotString?
// }
// },
// .COPY => {
// if (command_set.items.len < 3) return .{ .err = error.InvalidCommand };
// return self.copy(command_set.items[1..command_set.items.len]);
// },
// .MGET => return self.mget(command_set.items[1..command_set.items.len]),
// .MSET => return self.mset(command_set.items[1..command_set.items.len]),
.PING => return .{ .ok = .{ .sstr = @constCast("PONG") } },
.DBSIZE => return .{ .ok = .{ .int = self.memory.size() } },
.LASTSAVE => return .{ .ok = .{ .int = self.memory.last_save } },
.SAVE => return self.save(),
.KEYS => return self.zkeys(),
.FLUSH => return self.flush(),
// .DBSIZE => return .{ .ok = .{ .int = self.memory.size() } },
// .LASTSAVE => return .{ .ok = .{ .int = self.memory.last_save } },
// .SAVE => return self.save(),
// .KEYS => return self.zkeys(),
// .FLUSH => return self.flush(),
else => unreachable,
};
}

Expand All @@ -118,122 +119,122 @@ pub const Handler = struct {
return .{ .ok = .{ .sstr = @constCast("OK") } };
}

fn delete(self: *Handler, key: ZType) Result {
const result = self.memory.delete(key.str);
// fn delete(self: *Handler, key: ZType) Result {
// const result = self.memory.delete(key.str);

if (result) {
return .{ .ok = .{ .sstr = @constCast("OK") } };
} else {
return .{ .err = error.NotFound };
}
}
// if (result) {
// return .{ .ok = .{ .sstr = @constCast("OK") } };
// } else {
// return .{ .err = error.NotFound };
// }
// }

fn flush(self: *Handler) Result {
self.memory.flush();
return .{ .ok = .{ .sstr = @constCast("OK") } };
}
// fn flush(self: *Handler) Result {
// self.memory.flush();
// return .{ .ok = .{ .sstr = @constCast("OK") } };
// }

fn save(self: *Handler) Result {
if (self.memory.size() == 0) return .{ .err = error.SaveFailure };
// fn save(self: *Handler) Result {
// if (self.memory.size() == 0) return .{ .err = error.SaveFailure };

const size = self.memory.save() catch |err| {
self.logger.log(.Error, "# failed to save data: {?}", .{err});
// const size = self.memory.save() catch |err| {
// self.logger.log(.Error, "# failed to save data: {?}", .{err});

return .{ .err = error.SaveFailure };
};
// return .{ .err = error.SaveFailure };
// };

self.logger.log(.Debug, "# saved {d} bytes", .{size});
// self.logger.log(.Debug, "# saved {d} bytes", .{size});

if (size > 0) return .{ .ok = .{ .sstr = @constCast("OK") } };
// if (size > 0) return .{ .ok = .{ .sstr = @constCast("OK") } };

return .{ .err = error.SaveFailure };
}
// return .{ .err = error.SaveFailure };
// }

fn mget(self: *Handler, keys: []ZType) Result {
var result = std.StringHashMap(ZType).init(self.allocator);
// fn mget(self: *Handler, keys: []ZType) Result {
// var result = std.StringHashMap(ZType).init(self.allocator);

for (keys) |key| {
if (key != .str) return .{ .err = error.KeyNotString };
// for (keys) |key| {
// if (key != .str) return .{ .err = error.KeyNotString };

const value: ZType = self.memory.get(key.str) catch .{ .null = void{} };
// const value: ZType = self.memory.get(key.str) catch .{ .null = void{} };

result.put(key.str, value) catch |err| {
return .{ .err = err };
};
}
// result.put(key.str, value) catch |err| {
// return .{ .err = err };
// };
// }

return .{ .ok = .{ .map = result } };
}
// return .{ .ok = .{ .map = result } };
// }

fn mset(self: *Handler, entries: []ZType) Result {
if (entries.len == 0 or entries.len & 1 == 1) return .{ .err = error.InvalidArgs };
// fn mset(self: *Handler, entries: []ZType) Result {
// if (entries.len == 0 or entries.len & 1 == 1) return .{ .err = error.InvalidArgs };

for (entries, 0..) |entry, index| {
// cause its an array so i have to assume every even element is a value.
if (index & 1 == 1 or index + 1 == entries.len) continue;
if (entry != .str) return .{ .err = error.KeyNotString };
// for (entries, 0..) |entry, index| {
// // cause its an array so i have to assume every even element is a value.
// if (index & 1 == 1 or index + 1 == entries.len) continue;
// if (entry != .str) return .{ .err = error.KeyNotString };

const value = entries[index + 1];
// const value = entries[index + 1];

self.memory.put(entry.str, value) catch |err| {
return .{ .err = err };
};
}
return .{ .ok = .{ .sstr = @constCast("OK") } };
}
// self.memory.put(entry.str, value) catch |err| {
// return .{ .err = err };
// };
// }
// return .{ .ok = .{ .sstr = @constCast("OK") } };
// }

fn zkeys(self: *Handler) Result {
const result = self.memory.keys() catch |err| {
return .{ .err = err };
};
return .{ .ok = .{ .array = result } };
}
// fn zkeys(self: *Handler) Result {
// const result = self.memory.keys() catch |err| {
// return .{ .err = err };
// };
// return .{ .ok = .{ .array = result } };
// }

fn sizeof(self: *Handler, key: ZType) Result {
const value: ZType = self.memory.get(key.str) catch |err| {
return .{ .err = err };
};
// fn sizeof(self: *Handler, key: ZType) Result {
// const value: ZType = self.memory.get(key.str) catch |err| {
// return .{ .err = err };
// };

const value_size: usize = switch (value) {
.str, .sstr => |str| str.len,
.array => value.array.items.len,
inline .map, .set, .uset => |v| v.count(),
inline .int, .float, .bool => |x| @sizeOf(@TypeOf(x)),
else => 0,
};
// const value_size: usize = switch (value) {
// .str, .sstr => |str| str.len,
// .array => value.array.items.len,
// inline .map, .set, .uset => |v| v.count(),
// inline .int, .float, .bool => |x| @sizeOf(@TypeOf(x)),
// else => 0,
// };

return .{ .ok = .{ .int = @intCast(value_size) } };
}
// return .{ .ok = .{ .int = @intCast(value_size) } };
// }

fn rename(self: *Handler, key: ZType, value: ZType) Result {
if (key != .str or value != .str) return .{ .err = error.KeyNotString };
// fn rename(self: *Handler, key: ZType, value: ZType) Result {
// if (key != .str or value != .str) return .{ .err = error.KeyNotString };

self.memory.rename(key.str, value.str) catch |err| {
return .{ .err = err };
};
// self.memory.rename(key.str, value.str) catch |err| {
// return .{ .err = err };
// };

return .{ .ok = .{ .str = @constCast("OK") } };
}
// return .{ .ok = .{ .str = @constCast("OK") } };
// }

fn copy(self: *Handler, entries: []ZType) Result {
const CopyArgs = enum { REPLACE };
// fn copy(self: *Handler, entries: []ZType) Result {
// const CopyArgs = enum { REPLACE };

var replace: bool = false;
if (entries[0] != .str or entries[1] != .str) return .{ .err = error.KeyNotString };
// var replace: bool = false;
// if (entries[0] != .str or entries[1] != .str) return .{ .err = error.KeyNotString };

if (entries.len > 2) {
if (entries[2] != .str) return .{ .err = error.KeyNotString };
// if (entries.len > 2) {
// if (entries[2] != .str) return .{ .err = error.KeyNotString };

// To check if entries[2] is "REPLACE" string.
// If not, return error.BadRequest.
_ = utils.enum_type_from_str(CopyArgs, entries[2].str) orelse return .{ .err = error.BadRequest };
replace = true;
}
self.memory.copy(entries[0].str, entries[1].str, replace) catch |err| {
return .{ .err = err };
};
return .{ .ok = .{ .str = @constCast("OK") } };
}
// // To check if entries[2] is "REPLACE" string.
// // If not, return error.BadRequest.
// _ = utils.enum_type_from_str(CopyArgs, entries[2].str) orelse return .{ .err = error.BadRequest };
// replace = true;
// }
// self.memory.copy(entries[0].str, entries[1].str, replace) catch |err| {
// return .{ .err = err };
// };
// return .{ .ok = .{ .str = @constCast("OK") } };
// }

// method to free data needs to be freeded, for example keys command
// is creating std.ArrayList so it have to be freed after
Expand Down
Loading

0 comments on commit e170c01

Please sign in to comment.