fediglam/src/api/services/files.zig

235 lines
6.7 KiB
Zig
Raw Normal View History

2022-11-21 11:58:54 +00:00
const std = @import("std");
const util = @import("util");
const Uuid = util.Uuid;
const DateTime = util.DateTime;
pub const FileOwner = union(enum) {
user_id: Uuid,
community_id: Uuid,
};
pub const DriveFile = struct {
id: Uuid,
2022-12-03 15:09:29 +00:00
path: []const u8,
2022-11-21 11:58:54 +00:00
filename: []const u8,
2022-12-03 15:09:29 +00:00
2022-11-21 11:58:54 +00:00
owner: FileOwner,
2022-12-03 15:09:29 +00:00
2022-11-21 11:58:54 +00:00
size: usize,
2022-12-03 15:09:29 +00:00
description: []const u8,
content_type: []const u8,
sensitive: bool,
2022-11-21 11:58:54 +00:00
created_at: DateTime,
2022-12-03 15:09:29 +00:00
updated_at: DateTime,
};
const EntryType = enum {
dir,
file,
};
pub const CreateFileArgs = struct {
dir: []const u8,
filename: []const u8,
owner: FileOwner,
created_by: Uuid,
description: ?[]const u8,
content_type: ?[]const u8,
sensitive: bool,
2022-11-21 11:58:54 +00:00
};
2022-12-03 15:09:29 +00:00
fn lookupDirectory(db: anytype, owner: FileOwner, path: []const u8, alloc: std.mem.Allocator) !Uuid {
return (try db.queryRow(
std.meta.Tuple(
&.{util.Uuid},
),
\\SELECT id
\\FROM drive_entry_path
\\WHERE
\\ path = (CASE WHEN LENGTH($1) = 0 THEN '/' ELSE '/' || $1 || '/' END)
\\ AND account_owner_id IS NOT DISTINCT FROM $2
\\ AND community_owner_id IS NOT DISTINCT FROM $3
\\ AND kind = 'dir'
\\LIMIT 1
,
.{
std.mem.trim(u8, path, "/"),
if (owner == .user_id) owner.user_id else null,
if (owner == .community_id) owner.community_id else null,
},
alloc,
))[0];
}
fn lookup(db: anytype, owner: FileOwner, path: []const u8, alloc: std.mem.Allocator) !Uuid {
return (try db.queryRow(
std.meta.Tuple(
&.{util.Uuid},
),
\\SELECT id
\\FROM drive_entry_path
\\WHERE
\\ path = (CASE WHEN LENGTH($1) = 0 THEN '/' ELSE '/' || $1 || '/' END)
\\ AND account_owner_id IS NOT DISTINCT FROM $2
\\ AND community_owner_id IS NOT DISTINCT FROM $3
\\LIMIT 1
,
.{
std.mem.trim(u8, path, "/"),
if (owner == .user_id) owner.user_id else null,
if (owner == .community_id) owner.community_id else null,
},
alloc,
))[0];
}
pub fn mkdir(db: anytype, owner: FileOwner, path: []const u8, alloc: std.mem.Allocator) !void {
var split = std.mem.splitBackwards(u8, std.mem.trim(u8, path, "/"), "/");
const name = split.first();
const dir = split.rest();
std.log.debug("'{s}' / '{s}'", .{ name, dir });
if (name.len == 0) return error.EmptyName;
const id = Uuid.randV4(util.getThreadPrng());
const tx = try db.begin();
errdefer tx.rollback();
const parent = try lookupDirectory(tx, owner, dir, alloc);
try tx.insert("drive_entry", .{
.id = id,
.account_owner_id = if (owner == .user_id) owner.user_id else null,
.community_owner_id = if (owner == .community_id) owner.community_id else null,
.name = name,
.parent_directory_id = parent,
}, alloc);
try tx.commit();
}
pub fn rmdir(db: anytype, owner: FileOwner, path: []const u8, alloc: std.mem.Allocator) !void {
const tx = try db.begin();
errdefer tx.rollback();
const id = try lookupDirectory(tx, owner, path, alloc);
try tx.exec("DELETE FROM drive_directory WHERE id = $1", .{id}, alloc);
try tx.commit();
}
fn insertFileRow(tx: anytype, id: Uuid, filename: []const u8, owner: FileOwner, dir: Uuid, alloc: std.mem.Allocator) !void {
try tx.insert("drive_entry", .{
.id = id,
2022-11-21 11:58:54 +00:00
2022-12-03 15:09:29 +00:00
.account_owner_id = if (owner == .user_id) owner.user_id else null,
.community_owner_id = if (owner == .community_id) owner.community_id else null,
.parent_directory_id = dir,
.name = filename,
.file_id = id,
}, alloc);
}
pub fn createFile(db: anytype, args: CreateFileArgs, data: []const u8, alloc: std.mem.Allocator) !void {
const id = Uuid.randV4(util.getThreadPrng());
const now = DateTime.now();
{
var tx = try db.begin();
errdefer tx.rollback();
const dir_id = try lookupDirectory(tx, args.owner, args.dir, alloc);
try tx.insert("file_upload", .{
2022-11-21 11:58:54 +00:00
.id = id,
2022-12-03 15:09:29 +00:00
.filename = args.filename,
.created_by = args.created_by,
2022-12-03 07:44:27 +00:00
.size = data.len,
2022-12-03 15:09:29 +00:00
.description = args.description,
.content_type = args.content_type,
.sensitive = args.sensitive,
.is_deleted = false,
.created_at = now,
.updated_at = now,
}, alloc);
var sub_tx = try tx.savepoint();
if (insertFileRow(sub_tx, id, args.filename, args.owner, dir_id, alloc)) |_| {
try sub_tx.release();
} else |err| {
std.log.debug("{}", .{err});
switch (err) {
error.UniqueViolation => {
try sub_tx.rollbackSavepoint();
// Rename the file before trying again
var split = std.mem.split(u8, args.filename, ".");
const name = split.first();
const ext = split.rest();
var buf: [256]u8 = undefined;
const drive_filename = try std.fmt.bufPrint(&buf, "{s}.{}.{s}", .{ name, id, ext });
try insertFileRow(tx, id, drive_filename, args.owner, dir_id, alloc);
},
else => return error.DatabaseFailure,
}
2022-11-21 11:58:54 +00:00
}
2022-12-03 15:09:29 +00:00
try tx.commit();
2022-11-21 11:58:54 +00:00
}
2022-12-03 15:09:29 +00:00
errdefer {
db.exec("DELETE FROM file_upload WHERE ID = $1", .{id}, alloc) catch |err| {
std.log.err("Unable to remove file record in DB: {}", .{err});
};
db.exec("DELETE FROM drive_entry WHERE ID = $1", .{id}, alloc) catch |err| {
std.log.err("Unable to remove file record in DB: {}", .{err});
};
}
2022-11-21 11:58:54 +00:00
2022-12-03 15:09:29 +00:00
try saveFile(id, data);
}
2022-11-21 11:58:54 +00:00
2022-12-03 15:09:29 +00:00
const data_root = "./files";
fn saveFile(id: Uuid, data: []const u8) !void {
var dir = try std.fs.cwd().openDir(data_root, .{});
defer dir.close();
2022-11-21 11:58:54 +00:00
2022-12-03 15:09:29 +00:00
var file = try dir.createFile(&id.toCharArray(), .{ .exclusive = true });
defer file.close();
2022-11-21 11:58:54 +00:00
2022-12-03 15:09:29 +00:00
try file.writer().writeAll(data);
try file.sync();
}
2022-11-21 11:58:54 +00:00
2022-12-03 15:09:29 +00:00
pub fn deref(alloc: std.mem.Allocator, id: Uuid) ![]const u8 {
var dir = try std.fs.cwd().openDir(data_root, .{});
defer dir.close();
2022-11-21 11:58:54 +00:00
2022-12-03 15:09:29 +00:00
return dir.readFileAlloc(alloc, &id.toCharArray(), 1 << 32);
}
2022-11-21 11:58:54 +00:00
2022-12-03 15:09:29 +00:00
pub fn deleteFile(db: anytype, alloc: std.mem.Allocator, id: Uuid) !void {
var dir = try std.fs.cwd().openDir(data_root, .{});
defer dir.close();
try dir.deleteFile(id.toCharArray());
const tx = try db.beginOrSavepoint();
errdefer tx.rollback();
tx.exec("DELETE FROM drive_entry WHERE ID = $1", .{id}, alloc) catch return error.DatabaseFailure;
tx.exec("DELETE FROM file_upload WHERE ID = $1", .{id}, alloc) catch return error.DatabaseFailure;
try tx.commitOrRelease();
}