Refactor IPC

Author: alebeck

cmd/boring/tunnels.go

@@ -226,11 +226,11 @@ func transmitCmd(cmd daemon.Cmd, resp any) error {
 	}
 	defer conn.Close()
 
-	if err := ipc.Send(cmd, conn); err != nil {
+	if err := ipc.Write(cmd, conn); err != nil {
 		return fmt.Errorf("could not send command: %v", err)
 	}
 
-	if err = ipc.Receive(resp, conn); err != nil {
+	if err = ipc.Read(resp, conn); err != nil {
 		return fmt.Errorf("could not receive response: %v", err)
 	}
 

internal/daemon/daemon.go

@@ -47,17 +47,17 @@ func respond(conn net.Conn, err *error) {
 	if *err != nil {
 		resp = Resp{Success: false, Error: (*err).Error()}
 	}
-	if err := ipc.Send(resp, conn); err != nil {
+	if err := ipc.Write(resp, conn); err != nil {
 		log.Errorf("could not send response: %v", err)
 	}
 }
 
 func (d *daemon) handleConnection(conn net.Conn) {
 	defer conn.Close()
 
-	// Receive command
+	// Read command
 	var cmd Cmd
-	if err := ipc.Receive(&cmd, conn); err != nil {
+	if err := ipc.Read(&cmd, conn); err != nil {
 		// Ignore cases where client aborts connection
 		if !errors.Is(err, io.EOF) {
 			log.Errorf("Could not receive command: %v", err)
@@ -142,7 +142,7 @@ func (d *daemon) listTunnels(conn net.Conn) {
 	d.mutex.RUnlock()
 
 	resp := Resp{Success: true, Tunnels: m}
-	if err := ipc.Send(resp, conn); err != nil {
+	if err := ipc.Write(resp, conn); err != nil {
 		log.Errorf("could not send response: %v", err)
 	}
 }

internal/ipc/ipc.go

@@ -4,30 +4,30 @@ import (
 	"bufio"
 	"encoding/json"
 	"fmt"
-	"net"
+	"io"
 
 	"github.com/alebeck/boring/internal/log"
 )
 
-func Send(s any, conn net.Conn) error {
+func Write(s any, w io.Writer) error {
 	data, err := json.Marshal(s)
 	if err != nil {
 		return fmt.Errorf("failed to serialize: %v", err)
 	}
 	log.Debugf("Sending: %v", string(data))
 
-	_, err = conn.Write(append(data, '\n'))
+	_, err = w.Write(append(data, '\n'))
 	if err != nil {
-		return fmt.Errorf("failed to send: %v", err)
+		return fmt.Errorf("failed to write: %v", err)
 	}
 	return nil
 }
 
-func Receive(s any, conn net.Conn) error {
-	reader := bufio.NewReader(conn)
-	data, err := reader.ReadBytes('\n')
+func Read(s any, r io.Reader) error {
+	br := bufio.NewReader(r)
+	data, err := br.ReadBytes('\n')
 	if err != nil {
-		return fmt.Errorf("failed to read from connection: %w", err)
+		return fmt.Errorf("failed to read: %w", err)
 	}
 	log.Debugf("Received: %v", string(data))
 

internal/ipc/ipc_test.go

@@ -1,12 +1,15 @@
 package ipc
 
 import (
-	"github.com/alebeck/boring/internal/log"
+	"io"
 	"net"
 	"os"
 	"reflect"
+	"strings"
 	"testing"
 	"time"
+
+	"github.com/alebeck/boring/internal/log"
 )
 
 func TestMain(m *testing.M) {
@@ -29,36 +32,54 @@ func TestIPC(t *testing.T) {
 	go func() {
 		defer close(done)
 		var r map[string]string
-		if err := Receive(&r, c2); err != nil {
+		if err := Read(&r, c2); err != nil {
 			t.Errorf("receive failed: %v", err)
 		}
 		if !reflect.DeepEqual(obj, r) {
 			t.Errorf("wrong data: %v != %v", obj, r)
 		}
 	}()
 
-	if err := Send(obj, c1); err != nil {
+	if err := Write(obj, c1); err != nil {
 		t.Fatalf("send failed: %v", err)
 	}
 	<-done
 }
 
-func TestSendError(t *testing.T) {
-	obj := map[string]string{"foo": "bar"}
+func TestWriteError(t *testing.T) {
+	var obj int
 	c1, c2 := net.Pipe()
 	defer c1.Close()
 	c2.Close() // peer closed
-	if err := Send(obj, c1); err == nil {
+	if err := Write(obj, c1); err == nil ||
+		!strings.Contains(err.Error(), "failed to write") {
 		t.Fatalf("did not get expected error")
 	}
 }
 
-func TestReceiveError(t *testing.T) {
+func TestReadError(t *testing.T) {
 	var obj map[string]string
 	c1, c2 := net.Pipe()
 	defer c1.Close()
 	c2.Close() // peer closed
-	if err := Receive(&obj, c1); err == nil {
+	if err := Read(&obj, c1); err == nil ||
+		!strings.Contains(err.Error(), "failed to read") {
+		t.Fatalf("did not get expected error")
+	}
+}
+
+func TestSerializeError(t *testing.T) {
+	var v = make(chan int) // not serializable
+	if err := Write(v, io.Discard); err == nil ||
+		!strings.Contains(err.Error(), "failed to serialize") {
+		t.Fatalf("did not get expected error")
+	}
+}
+
+func TestDeserializeError(t *testing.T) {
+	var v = make(chan int) // not serializable
+	if err := Read(&v, strings.NewReader("test\n")); err == nil ||
+		!strings.Contains(err.Error(), "failed to deserialize") {
 		t.Fatalf("did not get expected error")
 	}
 }