Something went wrong. Try again.
My version of https://github.com/vercel-labs/fx
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216const std = @import("std");const background_process_provider = @import( "../execution/background_process_provider.zig",);const io_mod = @import("../shared/io.zig");const session_child_store = @import("../session/session_child_store.zig");
const Allocator = std.mem.Allocator;
pub const Output = union(enum) { managed_session: struct { capability: *session_child_store.SessionChildCapability, file: session_child_store.ManagedFile, name: []u8, display_path: []u8, }, external: struct { file: std.Io.File, path: []u8, },
pub fn childStdioFile(self: *const Output) std.Io.File { return switch (self.*) { .managed_session => |value| value.file.childStdioFile(), .external => |value| value.file, }; }
pub fn providerCapability( self: *const Output, ) background_process_provider.OutputCapability { return .{ .context = self }; }
pub fn childStdioFileForProvider( capability: background_process_provider.OutputCapability, ) std.Io.File { const self: *const Output = @ptrCast(@alignCast(capability.context)); return self.childStdioFile(); }
pub fn displayPath(self: *const Output) []const u8 { return switch (self.*) { .managed_session => |value| value.display_path, .external => |value| value.path, }; }
pub fn managedLogName(self: *const Output) ?[]const u8 { return switch (self.*) { .managed_session => |value| value.name, .external => null, }; }
pub fn deinit(self: *Output, alloc: Allocator, remove: bool) void { switch (self.*) { .managed_session => |*value| { value.file.deinit(); if (remove) { value.capability.delete( .background_logs, value.name, ) catch {}; } alloc.free(value.name); alloc.free(value.display_path); }, .external => |value| { value.file.close(io_mod.getIo()); if (remove) { std.Io.Dir.deleteFileAbsolute( io_mod.getIo(), value.path, ) catch {}; } alloc.free(value.path); }, } self.* = undefined; }};
pub fn prepareManaged( alloc: Allocator, capability: *session_child_store.SessionChildCapability,) !Output { var attempt: usize = 0; while (attempt < 16) : (attempt += 1) { const name = try randomLogName(alloc); var file = capability.createExclusiveFile( alloc, .background_logs, name, ) catch |err| switch (err) { error.PathAlreadyExists => { alloc.free(name); continue; }, else => { alloc.free(name); return err; }, }; errdefer file.deinit(); const display_path = try alloc.dupe( u8, file.displayPath() orelse return error.SessionChildStoreFailed, ); return .{ .managed_session = .{ .capability = capability, .file = file, .name = name, .display_path = display_path, } }; } return error.BackgroundIdentityUnavailable;}
pub fn prepareExternal(alloc: Allocator) !Output { const root = io_mod.getenv("TMPDIR") orelse "/tmp"; var attempt: usize = 0; while (attempt < 16) : (attempt += 1) { const name = try randomLogName(alloc); defer alloc.free(name); const path = try std.fs.path.join(alloc, &.{ root, name }); const file = std.Io.Dir.createFileAbsolute( io_mod.getIo(), path, .{ .read = true, .truncate = false, .exclusive = true, .permissions = std.Io.File.Permissions.fromMode(0o600), }, ) catch |err| switch (err) { error.PathAlreadyExists => { alloc.free(path); continue; }, else => { alloc.free(path); return err; }, }; return .{ .external = .{ .file = file, .path = path } }; } return error.BackgroundIdentityUnavailable;}
fn randomLogName(alloc: Allocator) ![]u8 { var random: [16]u8 = undefined; try std.Io.randomSecure(io_mod.getIo(), &random); var encoded: [32]u8 = undefined; const alphabet = "0123456789abcdef"; for (random, 0..) |byte, index| { encoded[index * 2] = alphabet[byte >> 4]; encoded[index * 2 + 1] = alphabet[byte & 0x0f]; } return std.fmt.allocPrint( alloc, "fx-cmd-{s}.log", .{encoded[0..]}, );}
test "background launch output removes external log on cancellation" { const alloc = std.testing.allocator; var output = try prepareExternal(alloc); const path = try alloc.dupe(u8, output.displayPath()); defer alloc.free(path);
output.deinit(alloc, true); try std.testing.expectError( error.FileNotFound, std.Io.Dir.openFileAbsolute(io_mod.getIo(), path, .{}), );}
test "background launch output removes managed log on cancellation" { const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup();
try tmp.dir.createDir( io_mod.getIo(), "session", std.Io.File.Permissions.fromMode(0o700), ); const display_path = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "session"); defer alloc.free(display_path); var session_dir = try tmp.dir.openDir(io_mod.getIo(), "session", .{ .iterate = true, .follow_symlinks = false, }); defer session_dir.close(io_mod.getIo()); var capability = try session_child_store.SessionChildCapability.initForTesting( alloc, session_dir, display_path, .writable, .{}, ); defer capability.deinit();
var output = try prepareManaged(alloc, &capability); const name = try alloc.dupe(u8, output.managedLogName().?); defer alloc.free(name);
output.deinit(alloc, true); try std.testing.expectError( error.FileNotFound, capability.stat(.background_logs, name), );}