Adding Zinc framework

Author: dravenk

frameworks/Zig/zinc/.gitignore

@@ -0,0 +1,2 @@
+zig-cache/**/*',
+zig-out: 'zig-out/**/*',

frameworks/Zig/zinc/README.md

@@ -0,0 +1,93 @@
+# Congratulations!
+
+You have successfully built a new test in the suite!
+
+There are some remaining tasks to do before you are ready to open a pull request, however.
+
+## Next Steps
+
+1. Gather your source code.
+
+You will need to ensure that your source code is beneath this directory. The most common solution is to include a `src` directory and place your source code there.
+
+2. Edit `benchmark_config.json`
+
+You will need alter `benchmark_config.json` to have the appropriate end-points and port specified.
+
+3. Create `zinc.dockerfile`
+
+This is the dockerfile that is built into a docker image and run when a benchmark test is run. Specifically, this file tells the suite how to build and start your test application.
+
+You can create multiple implementations and they will all conform to `[name in benchmark_config.json].dockerfile`. For example, the `default` implementation in `benchmark_config.json` will be `zinc.dockerfile`, but if you wanted to make another implementation that did only the database tests for MySQL, you could make `zinc-mysql.dockerfile` and have an entry in your `benchmark_config.json` for `zinc-mysql`.
+
+4. Test your application
+
+        $ tfb --mode verify --test zinc
+
+This will run the suite in `verify` mode for your test. This means that no benchmarks will be captured and we will test that we can hit your implementation end-points specified by `benchmark_config.json` and that the response is correct.
+
+Once you are able to successfully run your test through our suite in this way **and** your test passes our validation, you may move on to the next step.
+
+5. Add your test to `.github/workflows/build.yml`
+
+Edit `.github/workflows/build.yml` to ensure that Github Actions will automatically run our verification tests against your new test. This file is kept in alphabetical order, so find where `TESTDIR=Zig/zinc` should be inserted under `env > matrix` and put it there.
+
+6. Fix this `README.md` and open a pull request
+
+Starting on line 49 is your actual `README.md` that will sit with your test implementation. Update all the dummy values to their correct values so that when people visit your test in our Github repository, they will be greated with information on how your test implementation works and where to look for useful source code.
+
+After you have the real `README.md` file in place, delete everything above line 59 and you are ready to open a pull request.
+
+Thanks and Cheers!
+
+
+
+
+
+
+
+# Zinc Benchmarking Test
+
+### Test Type Implementation Source Code
+
+* [JSON](Relative/Path/To/Your/Source/File)
+* [PLAINTEXT](Relative/Path/To/Your/Source/File)
+* [DB](Relative/Path/To/Your/Source/File)
+* [QUERY](Relative/Path/To/Your/Source/File)
+* [CACHED QUERY](Relative/Path/To/Your/Source/File)
+* [UPDATE](Relative/Path/To/Your/Source/File)
+* [FORTUNES](Relative/Path/To/Your/Source/File)
+
+## Important Libraries
+The tests were run with:
+* [Software](https://www.example1.com/)
+* [Example](http://www.example2.com/)
+
+## Test URLs
+### JSON
+
+http://localhost:8080/json
+
+### PLAINTEXT
+
+http://localhost:8080/plaintext
+
+### DB
+
+http://localhost:8080/db
+
+### QUERY
+
+http://localhost:8080/query?queries=
+
+### CACHED QUERY
+
+http://localhost:8080/cached_query?queries=
+
+### UPDATE
+
+http://localhost:8080/update?queries=
+
+### FORTUNES
+
+http://localhost:8080/fortunes

frameworks/Zig/zinc/benchmark_config.json

@@ -0,0 +1,26 @@
+{
+  "framework": "zinc",
+  "tests": [
+    {
+      "default": {
+        "json_url": "/json",
+        "plaintext_url": "/plaintext",
+        "port": 8080,
+        "approach": "Stripped",
+        "classification": "Fullstack",
+        "database": "None",
+        "framework": "Zinc",
+        "language": "Zig",
+        "flavor": "None",
+        "orm": "None",
+        "platform": "None",
+        "webserver": "None",
+        "os": "Linux",
+        "database_os": "Linux",
+        "display_name": "Zinc",
+        "notes": "",
+        "versus": "None"
+      }
+    }
+  ]
+}

frameworks/Zig/zinc/build.zig

@@ -0,0 +1,78 @@
+const std = @import("std");
+
+// Although this function looks imperative, note that its job is to
+// declaratively construct a build graph that will be executed by an external
+// runner.
+pub fn build(b: *std.Build) void {
+    // Standard target options allows the person running `zig build` to choose
+    // what target to build for. Here we do not override the defaults, which
+    // means any target is allowed, and the default is native. Other options
+    // for restricting supported target set are available.
+    const target = b.standardTargetOptions(.{});
+
+    // Standard optimization options allow the person running `zig build` to select
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
+    // set a preferred release mode, allowing the user to decide how to optimize.
+    const optimize = b.standardOptimizeOption(.{});
+
+    const exe = b.addExecutable(.{
+        .name = "zinc",
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const zinc = b.dependency("zinc", .{
+        .target = target,
+        .optimize = optimize,
+    });
+    exe.root_module.addImport("zinc", zinc.module("zinc"));
+
+    const datetime = b.dependency("zig-datetime", .{
+        .target = target,
+        .optimize = optimize,
+    });
+    exe.root_module.addImport("datetime", datetime.module("zig-datetime"));
+
+    // This declares intent for the executable to be installed into the
+    // standard location when the user invokes the "install" step (the default
+    // step when running `zig build`).
+    b.installArtifact(exe);
+
+    // This *creates* a Run step in the build graph, to be executed when another
+    // step is evaluated that depends on it. The next line below will establish
+    // such a dependency.
+    const run_cmd = b.addRunArtifact(exe);
+
+    // By making the run step depend on the install step, it will be run from the
+    // installation directory rather than directly from within the cache directory.
+    // This is not necessary, however, if the application depends on other installed
+    // files, this ensures they will be present and in the expected location.
+    run_cmd.step.dependOn(b.getInstallStep());
+
+    // This allows the user to pass arguments to the application in the build
+    // command itself, like this: `zig build run -- arg1 arg2 etc`
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    // This creates a build step. It will be visible in the `zig build --help` menu,
+    // and can be selected like this: `zig build run`
+    // This will evaluate the `run` step rather than the default, which is "install".
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+
+    const exe_unit_tests = b.addTest(.{
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
+
+    // Similar to creating the run step earlier, this exposes a `test` step to
+    // the `zig build --help` menu, providing a way for the user to request
+    // running the unit tests.
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_exe_unit_tests.step);
+}

frameworks/Zig/zinc/build.zig.zon

@@ -0,0 +1,19 @@
+.{
+    .name = "zinc",
+    .version = "0.1.0",
+    .dependencies = .{
+        .zinc = .{
+            .url = "https://github.com/zon-dev/zinc/archive/refs/heads/main.zip",
+            .hash = "1220bbd81a53f8268d970dfbf92268c36a25b50978dd8e7dcbf551e69b2c03677e33",
+        },
+        .@"zig-datetime" = .{
+            .url = "https://github.com/frmdstryr/zig-datetime/archive/refs/heads/master.zip",
+            .hash = "122077215ce36e125a490e59ec1748ffd4f6ba00d4d14f7308978e5360711d72d77f",
+        },
+    },
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+    },
+}

frameworks/Zig/zinc/run.sh

@@ -0,0 +1,3 @@
+echo "Waiting for Zinc framework to start..."
+
+zinc

frameworks/Zig/zinc/src/main.zig

@@ -0,0 +1,38 @@
+const std = @import("std");
+const zinc = @import("zinc");
+const Datetime = @import("datetime").datetime.Datetime;
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = gpa.allocator();
+
+    var z = try zinc.init(.{ .port = 8080, .allocator = allocator, .num_threads = 255 });
+
+    var router = z.getRouter();
+    try router.use(&.{setupHeader});
+
+    try router.get("/json", json);
+    try router.get("/plaintext", plaintext);
+
+    try z.run();
+}
+
+fn plaintext(ctx: *zinc.Context) anyerror!void {
+    try ctx.text("Hello, World!", .{});
+}
+
+fn json(ctx: *zinc.Context) anyerror!void {
+    try ctx.json(.{ .message = "Hello, World!" }, .{});
+}
+
+fn setupHeader(ctx: *zinc.Context) anyerror!void {
+    try ctx.setHeader("Server", "Zinc");
+    // try ctx.setHeader("date", "Sun Sep 22 10:01:11 CEST 2024");
+    // In UTC
+    const now = Datetime.now();
+    const now_str = try now.formatHttp(ctx.allocator);
+    // defer ctx.allocator.free(now_str);
+    // std.debug.warn("The time is now: {}\n", .{now_str});
+    // The time is now: Fri, 20 Dec 2019 22:03:02 UTC
+    try ctx.setHeader("date", now_str);
+}

frameworks/Zig/zinc/zinc.dockerfile

@@ -0,0 +1,22 @@
+FROM fedora:40 AS build
+
+WORKDIR /zinc
+
+COPY src src
+COPY run.sh run.sh
+
+COPY build.zig.zon build.zig.zon
+COPY build.zig build.zig
+
+RUN dnf install -y zig
+RUN zig version
+# RUN zig build -Doptimize=ReleaseFast 
+RUN zig build
+RUN cp /zinc/zig-out/bin/zinc /usr/local/bin
+
+EXPOSE 8080
+ARG BENCHMARK_ENV
+ARG TFB_TEST_DATABASE
+ARG TFB_TEST_NAME
+
+CMD ["sh", "run.sh"]