Go to C communication

client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <uv.h>

uv_loop_t *loop;

void on_connect(uv_connect_t *req, int status);
void on_write_end(uv_write_t *req, int status);
void echo_read(uv_stream_t *server, ssize_t nread, const uv_buf_t *buf);
void send_message(uv_stream_t *tcp);

void echo_read(uv_stream_t *server, ssize_t nread, const uv_buf_t* buf) {
  if (nread > 0) {
    printf("result: %s\n", buf->base);
    send_message(server);
  }
  if (nread < 0) {
    if (nread != UV_EOF) {
      fprintf(stderr, "error echo_read");
    }
    uv_close((uv_handle_t *)server, NULL);
  }
}

void alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
    buf->base = (char *) malloc(suggested_size);
    buf->len = suggested_size;
}

void on_write_end(uv_write_t *req, int status) {
  if (status == -1) {
    fprintf(stderr, "error on_write_end\n");
    return;
  }

  uv_read_start(req->handle, alloc_buffer, echo_read);
}

void send_message(uv_stream_t *tcp) {
  char *message = "hello from client";
  int len = strlen(message);

  char buffer[100];
  uv_buf_t buf = uv_buf_init(buffer, sizeof(buffer));

  buf.len = len;
  buf.base = message;

  uv_write_t write_req;

  uv_write(&write_req, tcp, &buf, 1, on_write_end);
}

void on_connect(uv_connect_t *req, int status) {
  if (status == -1) {
    fprintf(stderr, "error on_connect");
    return;
  }
  send_message(req->handle);
}

int main(void) {
  loop = uv_default_loop();

  uv_tcp_t client;

  uv_tcp_init(loop, &client);

  struct sockaddr_in req_addr;
  uv_ip4_addr("127.0.0.1", 3491, &req_addr);

  uv_connect_t connect_req;

  uv_tcp_connect(&connect_req, &client, (const struct sockaddr*)&req_addr, on_connect);

  return uv_run(loop, UV_RUN_DEFAULT);
}

server.go

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net"
	"os/exec"
	"runtime"
	"sync"
	"time"

	"github.com/abhi-bit/gouch/jobpool"
)

type work struct {
	conn net.Conn
	wp   *pool.WorkPool
}

type message struct {
	Command    string
	Metadata   string
	RawMessage string
}

func (w *work) DoWork(workRoutine int) {

	m := message{
		Command:    "sample_command",
		Metadata:   "nothing_extra",
		RawMessage: "hello from the other side",
	}

	var buffer []byte
	content, err := json.Marshal(m)
	if err != nil {
		log.Fatal(err)
	} else {
		for i := 0; i < 5; i++ {
			w.conn.Write(content)
		}
	}

	w.conn.Close()
}

func main() {
	workPool := pool.New(runtime.NumCPU(), 100)
	var wg sync.WaitGroup

	ln, err := net.Listen("tcp", "127.0.0.1:3491")
	if err != nil {
		log.Fatal(err)
		ln.Close()
	}

	wg.Add(2)

	go func(workPool *pool.WorkPool, ln net.Listener) {
		defer wg.Done()
		for {
			c, err := ln.Accept()
			fmt.Printf("Post accept call:: remote addr: %s local addr: %s\n",
				c.RemoteAddr(), c.LocalAddr())
			if err != nil {
				log.Fatal(err)
			}

			w := work{
				conn: c,
				wp:   workPool,
			}

			if err := workPool.PostWork("routine", &w); err != nil {
				log.Println(err)
			}
		}
	}(workPool, ln)

	time.Sleep(1 * time.Second)

	go func() {
		defer wg.Done()
		cmd := exec.Command("./client", "3491")
		out, err := cmd.CombinedOutput()
		if err != nil {
			log.Fatal("Cmd")
		}
		log.Printf("out: %s\n", out)
	}()

	wg.Wait()
	ln.Close()
}