whispering_gophers/part6/main.go

// Solution to part 6 of the Whispering Gophers code lab.
//
// This program is functionally equivalent to part 5,
// but the reading from standard input and writing to the
// network connection are done by separate goroutines.
//
package main

import (
	"bufio"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"net"
	"os"

	"code.osinet.fr/fgm/whispering_gophers/util"
)

var (
	listenAddr = flag.String("listen", "", "peer host:port")
	peerAddr   = flag.String("peer", "", "peer host:port")
	self       string
)

type Message struct {
	Addr string
	Body string
}

func main() {
	flag.Parse()

	var l net.Listener
	var err error
	// Create a new listener using util.Listen and put it in a variable named l.
	if *listenAddr == "" {
		l, err = util.ListenOnFirstUsableInterface()
	} else {
		l, err = net.Listen("tcp4", *listenAddr)
	}
	if err != nil {
		log.Fatal(err)
	}
	self = l.Addr().String()
	log.Println("Listening on", self)

	go dial(*peerAddr)
	go readInput()

	for {
		c, err := l.Accept()
		if err != nil {
			log.Fatal(err)
		}
		go serve(c)
	}
}

func serve(c net.Conn) {
	defer c.Close()
	d := json.NewDecoder(c)
	for {
		var m Message
		err := d.Decode(&m)
		if err != nil {
			log.Println(err)
			return
		}
		fmt.Printf("%#v\n", m)
	}
}

// Make a new channel of Messages.
var peer = make(chan Message)

func readInput() {
	s := bufio.NewScanner(os.Stdin)
	for s.Scan() {
		m := Message{
			Addr: self,
			Body: s.Text(),
		}
		// Send the message to the channel of messages.
		peer <- m
	}
	if err := s.Err(); err != nil {
		log.Fatal(err)
	}
	os.Exit(0)
}

func dial(addr string) {
	c, err := net.Dial("tcp", addr)
	if err != nil {
		log.Println(addr, err)
		return
	}
	defer c.Close()

	e := json.NewEncoder(c)

	/* Receive messages from the channel using range, storing them in the variable m. */
	for m := range peer {
		err := e.Encode(m)
		if err != nil {
			log.Println(addr, err)
			return
		}
	}
}