add file uploading and multi-threading

2 files changed, 139 insertions, 0 deletions

diff --git a/src/storage/image-manager/image.zig b/src/storage/image-manager/image.zig
new file mode 100644
index 0000000..91a094e
--- /dev/null
+++ b/src/storage/image-manager/image.zig
@@ -0,0 +1,73 @@
+const std = @import("std");
+const Storage = @import("../root.zig");
+
+const id_size = 32;
+
+const log = std.log.scoped(.image);
+
+fn new_id() [id_size]u8 {
+    var buffer: [id_size]u8 = undefined;
+    var raw_buffer: [id_size / 2]u8 = undefined;
+    std.crypto.random.bytes(&raw_buffer);
+
+    var writer = std.Io.Writer.fixed(buffer[0..]);
+    writer.print("{x}", .{raw_buffer}) catch unreachable;
+
+    return buffer[0..].*;
+}
+
+const Self = @This();
+
+id: []const u8,
+
+pub fn new(
+    storage: *Storage,
+    reader: *std.Io.Reader,
+    size: usize,
+) !Self {
+    var dir = try storage.dir.openDir("image", .{});
+    defer dir.close();
+
+    var file_name: [id_size+4]u8 = undefined;
+    const self: Self = .{ .id = &new_id() };
+    @memcpy(file_name[0..id_size], self.id);
+    @memcpy(file_name[id_size..], ".jpg");
+
+    var image_file = try dir.createFile(&file_name, .{});
+    defer image_file.close();
+
+    var buffer: [1024]u8 = undefined;
+    var file_writer = image_file.writer(&buffer);
+
+    try reader.streamExact(&file_writer.interface, size);
+
+    try file_writer.interface.flush();
+
+    log.info("uploaded {s} [{} bytes]", .{self.id, size});
+
+    return self;
+}
+
+pub fn init(allocator: std.mem.Allocator, id: []const u8) !Self {
+    return .{
+        .id = try allocator.dupe(u8, id),
+    };
+}
+
+pub fn file(self: *Self, storage: *Storage) !std.fs.File {
+    var dir = storage.dir.openDir("image", .{}) catch blk: {
+        try storage.dir.makeDir("image");
+        break :blk try storage.dir.openDir("image", .{});
+    };
+    defer dir.close();
+
+    var file_name: [id_size+4]u8 = undefined;
+    @memcpy(file_name[0..id_size], self.id);
+    @memcpy(file_name[id_size..], ".jpg");
+
+    return dir.openFile(&file_name, .{});
+}
+
+pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
+    allocator.free(self.id);
+}
diff --git a/src/storage/image-manager/root.zig b/src/storage/image-manager/root.zig
new file mode 100644
index 0000000..7742df2
--- /dev/null
+++ b/src/storage/image-manager/root.zig
@@ -0,0 +1,66 @@
+const std = @import("std");
+
+const Storage = @import("../root.zig");
+pub const Image = @import("image.zig");
+
+const Self = @This();
+
+pub const empty: Self = .{};
+
+items: std.ArrayList(Image) = .empty,
+rw_lock: std.Thread.RwLock = .{},
+
+pub const LockedImages = struct {
+    images: []Image,
+    rw_lock: *std.Thread.RwLock,
+
+    pub fn deinit(self: *const @This()) void {
+        self.rw_lock.unlockShared();
+    }
+};
+
+pub fn init(
+    self: *Self,
+    storage: *Storage,
+) !void {
+    var dir = storage.dir.openDir("image", .{ .iterate = true }) catch blk: {
+        try storage.dir.makeDir("image");
+        break :blk try storage.dir.openDir("image", .{ .iterate = true });
+    };
+    defer dir.close();
+
+    var iterator = dir.iterate();
+
+    errdefer self.items.deinit(storage.allocator);
+
+    while (try iterator.next()) |entry| {
+        if (entry.kind == .file and std.mem.endsWith(u8, entry.name, ".jpg")) {
+            try self.items.append(
+                storage.allocator,
+                try .init(storage.allocator, entry.name[0..entry.name.len - 4])
+            );
+        }
+    }
+}
+
+pub fn add(
+    self: *Self,
+    storage: *Storage,
+    reader: *std.Io.Reader,
+    size: usize,
+) !void {
+    self.rw_lock.lock();
+    defer self.rw_lock.unlock();
+
+    try self.items.append(
+        storage.allocator,
+        try Image.new(storage, reader, size),
+    );
+}
+
+pub fn list(self: *Self) LockedImages {
+    return .{
+        .images = self.items.items,
+        .rw_lock = &self.rw_lock,
+    };
+}