ch_read

main.go

package main

import (
	"bufio"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"net"
	"time"
)

var (
	port = flag.Int("port", 8765, "The server port")
)

func main() {
	flag.Parse()
	// Listen on TCP port *port on all interfaces.
	l, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
	if err != nil {
		log.Fatal(err)
	}
	defer l.Close()
	for {
		// Wait for a connection.
		conn, err := l.Accept()
		if err != nil {
			log.Println(err)
			continue
		}

		c, ok := conn.(*net.TCPConn)
		if !ok {
			log.Println(err)
			continue
		}

		// Handle the connection in a new goroutine.
		// The loop then returns to accepting, so that
		// multiple connections may be served concurrently.
		// go handleConn(conn)
		go handleConn(c)
	}
}

func handleConn(c net.Conn) {
	defer c.Close()

	time.Sleep(1 * time.Second) // for debug to accept more than one message at once

	e := json.NewEncoder(c)
	for i := 0; i < 10; i++ {
		if err := e.Encode([]interface{}{-i, "hi"}); err != nil {
			log.Println(err)
		}
	}

	scanner := bufio.NewScanner(c)
	for scanner.Scan() {
		msgID, expr, err := unmarshalMsg(scanner.Bytes())
		if err != nil {
			log.Println(err)
			continue
		}
		log.Println(msgID, expr)
		log.Println("ex echo")
	}
	if err := scanner.Err(); err != nil {
		log.Println(err)
	}

	log.Println("handleConn ends")
}

// unmarshalMsg unmarshals json message from Vim.
// msg format: [{number},{expr}]
func unmarshalMsg(data []byte) (msgID int, expr interface{}, err error) {
	var vimMsg [2]interface{}
	if err := json.Unmarshal(data, &vimMsg); err != nil {
		return 0, nil, fmt.Errorf("fail to decode vim message: %v", err)
	}
	number, ok := vimMsg[0].(float64)
	if !ok {
		return 0, nil, fmt.Errorf("expects message ID, but got %+v", vimMsg[0])
	}
	msgID = int(number)
	expr = vimMsg[1]
	return msgID, expr, nil
}