libipc-old/zig-impl/apps/pong.zig

const std = @import("std");
const net = std.net;
const fmt = std.fmt;
const os = std.os;

const print = std.debug.print;

const ipc = @import("ipc");
const hexdump = ipc.hexdump;
const Message = ipc.Message;

pub fn main() !u8 {
    const config = .{.safety = true};
    var gpa = std.heap.GeneralPurposeAllocator(config){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var ctx = try ipc.Context.init(allocator);
    defer ctx.deinit(); // There. Can't leak. Isn't Zig wonderful?

    // The service to contact, either provided with the SERVICE envvar
    // or simply using "pong".
    var should_free_service_to_contact: bool = true;
    var service_to_contact = std.process.getEnvVarOwned(allocator, "SERVICE") catch blk: {
        should_free_service_to_contact = false;
        break :blk "pong";
    };
    defer {
        if (should_free_service_to_contact)
            allocator.free(service_to_contact);
    }

    var pongfd = try ctx.connect_ipc(service_to_contact);
    var message = try Message.init(pongfd, allocator, "bounce me");
    try ctx.schedule(message);

    var some_event: ipc.Event = undefined;
    ctx.timer = 2000; // 2 seconds
    while(true) {
        some_event = try ctx.wait_event();
        switch (some_event.t) {
            .TIMER => {
                print("Timer!\n", .{});
            },

            .MESSAGE => {
                if (some_event.m) |m| {
                    print("message has been bounced: {}\n", .{m});
                    m.deinit();
                    break;
                }
                else {
                    print("Received empty message, ERROR.\n", .{});
                    break;
                }
            },

            .TX => {
                print("Message sent.\n", .{});
            },

            else => {
                print("Unexpected event: {}, let's suicide\n", .{some_event});
                break;
            },
        }
    }

    print("Goodbye\n", .{});
    return 0;
}