Initial Release

.github/workflows/linux.yml

@@ -0,0 +1,20 @@
+name: linux
+on:
+  push:
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: goto-bus-stop/setup-zig@v2
+        with:
+          version: 0.13.0
+      - name: Unit Test
+        run: zig build test

.gitignore

@@ -1,2 +1,4 @@
 zig-out/
 .zig-cache/
+perf*
+heaptrack*

README.md

@@ -0,0 +1,46 @@
+# zzz
+![zzz logo](./docs/img/zzz.png)
+
+Tracking Latest Zig Stable: `0.13.0`
+
+`zig fetch --save https://github.com/mookums/zzz/archive/main.tar.gz`
+
+## zzz?
+zzz is a framework for writing performant and reliable networked services in Zig. It currently only supports TCP as the underlying transport layer but allows for any arbitrary protocol to run on top.
+
+*zzz is currently **alpha** software and while it is generally stable, there is still a lot changing at a fairly quick pace and certain places where things are less polished.*
+
+It focuses on modularity and portability, allowing you to swap in your own implementations for various things. Consumers can provide both a protocol and an async implementation, allowing for maximum flexibility. This allows for use in standard servers as well as embedded/bare metal domains.
+
+## Optimization
+zzz is **very** fast. Through a combination of methods, such as allocation at start up and avoiding thread contention, we are able to extract tons of performance.
+
+zzz currently out performs both [http.zig](https://github.com/karlseguin/http.zig) and [zap](https://github.com/zigzap/zap), while being almost entirely written in Zig. 
+
+zzz can be configured to utilize minimal memory while remaining performant. The provided `minram` example only uses 392 kB!
+
+## Features
+- [Modular Asyncronous Implementation](https://muki.gg/post/modular-async)
+    - Allows for passing in your own Async implementation.
+    - Comes with:
+        - io_uring for Linux.
+        - IOCP for Windows (planned).
+        - kqueue for BSD (planned).
+- Modular Protocol Implementation [#](#supported-protocols)
+    - Allows for defining your own Protocol on top of TCP.
+- Single and Multi-threaded Support
+- TLS using BearSSL
+- (Almost) all memory allocated at startup
+    - Only allocations happen while storing received data for parsing.
+
+## Supported Protocols
+- [HTTP/1.1](https://github.com/mookums/zzz/blob/main/src/http)
+- HTTP/2 (planned)
+- MQTT (planned)
+- Custom, you can write your own
+
+
+## Platform Support
+zzz currently focuses on Linux as the primary platform. Windows, MacOS, and BSD support is planned in the near future.
+
+Due to the modular nature, any platform (that works with Zig) can be supported as long as you define an Async backend. This includes embedded and bare metal!

build.zig

@@ -4,32 +4,72 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const exe = b.addExecutable(.{
-        .name = "zzz",
-        .root_source_file = b.path("src/main.zig"),
+    const bearssl = b.dependency("bearssl", .{
+        .target = target,
+        .optimize = optimize,
+        // Without this, you get an illegal instruction error on certain paths.
+        // This makes it slightly.slower but prevents faults.
+        .BR_LE_UNALIGNED = false,
+        .BR_BE_UNALIGNED = false,
+    }).artifact("bearssl");
+
+    const zzz = b.addModule("zzz", .{
+        .root_source_file = b.path("src/lib.zig"),
         .target = target,
         .optimize = optimize,
     });
 
-    exe.linkLibC();
-    b.installArtifact(exe);
+    zzz.linkLibrary(bearssl);
 
-    const run_cmd = b.addRunArtifact(exe);
-    run_cmd.step.dependOn(b.getInstallStep());
-    if (b.args) |args| {
-        run_cmd.addArgs(args);
-    }
+    addExample(b, "basic", false, target, optimize, zzz);
+    addExample(b, "custom", false, target, optimize, zzz);
+    addExample(b, "tls", true, target, optimize, zzz);
+    addExample(b, "minram", false, target, optimize, zzz);
+    addExample(b, "fs", false, target, optimize, zzz);
+    addExample(b, "multithread", false, target, optimize, zzz);
+    addExample(b, "benchmark", false, target, optimize, zzz);
+    addExample(b, "valgrind", true, target, optimize, zzz);
 
-    const run_step = b.step("run", "Run the app");
-    run_step.dependOn(&run_cmd.step);
+    const tests = b.addTest(.{
+        .name = "tests",
+        .root_source_file = b.path("./src/test.zig"),
+    });
 
-    const exe_unit_tests = b.addTest(.{
-        .root_source_file = b.path("src/main.zig"),
+    const run_test = b.addRunArtifact(tests);
+    run_test.step.dependOn(&tests.step);
+
+    const test_step = b.step("test", "Run general unit tests");
+    test_step.dependOn(&run_test.step);
+}
+
+fn addExample(
+    b: *std.Build,
+    name: []const u8,
+    link_libc: bool,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.Mode,
+    zzz_module: *std.Build.Module,
+) void {
+    const example = b.addExecutable(.{
+        .name = b.fmt("zzz_example_{s}", .{name}),
+        .root_source_file = b.path(b.fmt("src/examples/{s}/main.zig", .{name})),
         .target = target,
         .optimize = optimize,
     });
-    const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
 
-    const test_step = b.step("test", "Run unit tests");
-    test_step.dependOn(&run_exe_unit_tests.step);
+    if (link_libc) {
+        example.linkLibC();
+    }
+
+    example.root_module.addImport("zzz", zzz_module);
+    const install_artifact = b.addInstallArtifact(example, .{});
+
+    const run_cmd = b.addRunArtifact(example);
+    run_cmd.step.dependOn(&install_artifact.step);
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    const run_step = b.step(b.fmt("run_{s}", .{name}), b.fmt("Run zzz example ({s})", .{name}));
+    run_step.dependOn(&run_cmd.step);
 }

build.zig.zon

@@ -2,7 +2,12 @@
     .name = "zzz",
     .version = "0.0.0",
     .minimum_zig_version = "0.11.0",
-    .dependencies = .{},
+    .dependencies = .{
+        .bearssl = .{
+            .url = "https://github.com/mookums/bearssl-zig/archive/37a96eee56fe2543579bbc6da148ca886f3dd32b.tar.gz",
+            .hash = "12200e89d16612100a2f145cfa292537ac25b2205735fc1c644c799d2995f94e8e20",
+        },
+    },
 
     .paths = .{
         "build.zig",