FlexiLib/src/interface.zig
Emil Lerch 48c0e893da
All checks were successful
Build / build (push) Successful in 1m22s
Build / sign (push) Successful in 53s
Build / deploy (push) Successful in 59s
change response object header type to be immutable
2024-05-06 11:18:08 -07:00

201 lines
6.5 KiB
Zig

const std = @import("std");
const builtin = @import("builtin");
// C interfaces between main and libraries
pub const Header = extern struct {
name_ptr: [*]u8,
name_len: usize,
value_ptr: [*]u8,
value_len: usize,
};
pub const Response = extern struct {
ptr: [*]u8,
len: usize,
headers: [*]Header,
headers_len: usize,
status: usize,
reason_ptr: [*]u8,
reason_len: usize,
};
pub const Request = extern struct {
target: [*]const u8,
target_len: usize,
method: [*:0]u8,
method_len: usize,
content: [*]u8,
content_len: usize,
headers: [*]Header,
headers_len: usize,
};
// If the library is Zig, we can use these helpers
threadlocal var allocator: ?*std.mem.Allocator = null;
const log = std.log.scoped(.interface);
pub const ZigRequest = struct {
target: []const u8,
method: [:0]u8,
content: []u8,
headers: []std.http.Header,
};
pub const ZigHeader = struct {
name: []u8,
value: []u8,
};
pub const ZigResponse = struct {
status: std.http.Status = .ok,
reason: ?[]const u8 = null,
body: *std.ArrayList(u8),
headers: []const std.http.Header,
request: ZigRequest,
prepend: std.ArrayList(u8),
pub fn write(res: *ZigResponse, bytes: []const u8) !usize {
return res.prepend.writer().write(bytes);
}
pub fn writeAll(res: *ZigResponse, bytes: []const u8) !void {
return res.prepend.writer().writeAll(bytes);
}
pub fn writer(res: *ZigResponse) std.io.Writer {
return res.prepend.writer().writer();
}
pub fn finish(res: *ZigResponse) !void {
if (res.prepend.items.len > 0)
try res.body.insertSlice(0, res.prepend.items);
res.prepend.deinit();
}
};
pub const ZigRequestHandler = *const fn (std.mem.Allocator, *ZigResponse) anyerror!void;
/// This function is optional and can be exported by zig libraries for
/// initialization. If exported, it will be called once in the beginning of
/// a request and will be provided a pointer to std.mem.Allocator, which is
/// useful for reusing the parent allocator. If you're planning on using
/// the handleRequest helper below, you must use zigInit or otherwise
/// set the interface allocator in your own version of zigInit
pub fn zigInit(parent_allocator: *anyopaque) callconv(.C) void {
allocator = @ptrCast(@alignCast(parent_allocator));
}
/// Converts a StringHashMap to the structure necessary for passing through the
/// C boundary. This will be called automatically for you via the handleRequest function
/// and is also used by the main processing loop to coerce request headers
fn toHeaders(alloc: std.mem.Allocator, headers: []const std.http.Header) ![*]Header {
var header_array = try std.ArrayList(Header).initCapacity(alloc, headers.len);
for (headers) |*field| {
header_array.appendAssumeCapacity(.{
.name_ptr = @constCast(field.name.ptr),
.name_len = field.name.len,
.value_ptr = @constCast(field.value.ptr),
.value_len = field.value.len,
});
}
return header_array.items.ptr;
}
/// handles a request, implementing the C interface to communicate between the
/// main program and a zig library. Most importantly, it will catch/report
/// errors appropriately and allow zig code to use standard Zig error semantics
pub fn handleRequest(request: *Request, zigRequestHandler: ZigRequestHandler) ?*Response {
// TODO: implement another library in C or Rust or something to show
// that anything using a C ABI can be successful
const alloc = if (allocator) |a| a.* else {
log.err("zigInit not called prior to handle_request. This is a coding error", .{});
return null;
};
// setup response body
var response = std.ArrayList(u8).init(alloc);
// setup headers
var request_headers = std.ArrayList(std.http.Header).init(alloc);
for (0..request.headers_len) |i|
request_headers.append(.{
.name = request.headers[i].name_ptr[0..request.headers[i].name_len],
.value = request.headers[i].value_ptr[0..request.headers[i].value_len],
}) catch |e| {
logError("Unexpected error processing request: {any}", .{e}, @errorReturnTrace());
return null;
};
const prepend = std.ArrayList(u8).init(alloc);
var zig_response = ZigResponse{
.headers = &.{},
.body = &response,
.prepend = prepend,
.request = .{
.content = request.content[0..request.content_len],
.target = request.target[0..request.target_len],
.method = request.method[0..request.method_len :0],
.headers = request_headers.toOwnedSlice() catch |e| {
logError("Unexpected error processing request: {any}", .{e}, @errorReturnTrace());
return null;
},
},
};
zigRequestHandler(
alloc,
&zig_response,
) catch |e| {
logError("Unexpected error processing request: {any}", .{e}, @errorReturnTrace());
if (zig_response.status == .ok) // this was an unexpected throw
zig_response.status = .internal_server_error;
return buildResponse(alloc, &zig_response);
};
// Marshall data back for handling by server
return buildResponse(alloc, &zig_response);
}
fn logError(comptime format: []const u8, args: anytype, stack_trace: anytype) void {
if (builtin.is_test) return;
log.err(format, args);
if (stack_trace) |trace| {
std.debug.dumpStackTrace(trace.*);
}
}
fn buildResponse(alloc: std.mem.Allocator, zig_response: *ZigResponse) ?*Response {
var rc = alloc.create(Response) catch {
log.err("Could not allocate memory for response object. This may be fatal", .{});
return null;
};
zig_response.finish() catch {
log.err("Could not allocate memory for response object. This may be fatal", .{});
return null;
};
rc.ptr = zig_response.body.items.ptr;
rc.len = zig_response.body.items.len;
rc.headers = toHeaders(alloc, zig_response.headers) catch |e| {
log.err("Unexpected error processing request: {any}", .{e});
if (@errorReturnTrace()) |trace| {
std.debug.dumpStackTrace(trace.*);
}
return null;
};
rc.headers_len = zig_response.headers.len;
rc.status = if (zig_response.status == .ok) 0 else @intFromEnum(zig_response.status);
rc.reason_len = 0;
if (zig_response.reason) |*r| {
rc.reason_ptr = @constCast(r.ptr);
rc.reason_len = r.len;
}
return rc;
}