zomq/main.odin

package main

import "core:bufio"
import "core:fmt"
import "core:log"
import "core:os"
import "zmq"

main :: proc() {
	context.logger = log.create_console_logger(.Debug, {})

	major, minor, patch := zmq.version()
	log.infof(
		"zmq echo (libzmq %d.%d.%d) over inproc; type lines, Ctrl-D to quit",
		major,
		minor,
		patch,
	)

	ctx := zmq.ctx_new()
	defer zmq.ctx_term(ctx)

	rep, serr := zmq.socket(ctx, .REP)
	if serr != nil {
		log.panic(zmq.strerror(serr))
	}
	defer zmq.close(rep)
	if err := zmq.bind(rep, "inproc://echo"); err != nil {
		log.panic(zmq.strerror(err))
	}

	req, cerr := zmq.socket(ctx, .REQ)
	if cerr != nil {
		log.panic(zmq.strerror(cerr))
	}
	defer zmq.close(req)
	if err := zmq.connect(req, "inproc://echo"); err != nil {
		log.panic(zmq.strerror(err))
	}

	echo(req, rep)
}

echo :: proc(req, rep: zmq.Socket) {
	scanner: bufio.Scanner
	bufio.scanner_init(&scanner, os.to_reader(os.stdin))
	defer bufio.scanner_destroy(&scanner)

	buf: [255]u8
	for bufio.scan(&scanner) {
		line := bufio.scanner_text(&scanner)
		if len(line) == 0 {
			continue
		}
		if _, err := zmq.send(req, transmute([]u8)line); err != nil {
			fmt.eprintfln("send: %s", zmq.strerror(err))
			return
		}
		n, rerr := zmq.recv(rep, buf[:])
		if rerr != nil {
			fmt.eprintfln("rep recv: %s", zmq.strerror(rerr))
			return
		}
		if _, werr := zmq.send(rep, buf[:n]); werr != nil {
			fmt.eprintfln("rep send: %s", zmq.strerror(werr))
			return
		}
		m, qerr := zmq.recv(req, buf[:])
		if qerr != nil {
			fmt.eprintfln("req recv: %s", zmq.strerror(qerr))
			return
		}
		fmt.println(string(buf[:m]))
	}
}