A simple echo server testing a few interesting Go language features, goroutines and channels.

echo.go

// $ 6g echo.go && 6l -o echo echo.6
// $ ./echo
//
//  ~ in another terminal ~
//
// $ nc localhost 3540

package main

import (
    "net"
    "bufio"
    "strconv"
    "fmt"
)

const PORT = 3540

func main() {
    server, err := net.Listen("tcp", ":" + strconv.Itoa(PORT))
    if server == nil {
        panic("couldn't start listening: " + err.String())
    }
    conns := clientConns(server)
    for {
        go handleConn(<-conns)
    }
}

func clientConns(listener net.Listener) chan net.Conn {
    ch := make(chan net.Conn)
    i := 0
    go func() {
        for {
            client, err := listener.Accept()
            if client == nil {
                fmt.Printf("couldn't accept: " + err.String())
                continue
            }
            i++
            fmt.Printf("%d: %v <-> %v\n", i, client.LocalAddr(), client.RemoteAddr())
            ch <- client
        }
    }()
    return ch
}

func handleConn(client net.Conn) {
    b := bufio.NewReader(client)
    for {
        line, err := b.ReadBytes('\n')
        if err != nil { // EOF, or worse
            break
        }
        client.Write(line)
    }
}

this is good stuff

Wow, thanks man !

Cool Thanks

thank you so much!

Solved it... Thanks

why use a unbuffered channel ?

one can just do simple copy if there's no need to check for new line:

import "io"
...
func handleConn(client net.Conn) {
   io.Copy(client, client);
}

So at some point Golang's CPU limit for running Goroutines at the same time got raised to the numbers of cores present in your machine.
That would make this server only run two Goroutines at the same time in the best case scenario...
I have seen another example that has a Goroutine per connection, but that sounds like a RAM eater if the amount of connections scales up.
What would be best for the sake of efficiency, a Goroutine per connection or a channel and one Goroutine per part of the server or perhaps the example above but with more Goroutines handling connections?
Let's assume a 8 core machine.
I'm pretty new to Golang but perhaps a more experienced person could weigh in on my dilemma

@tmjvonboss golangs http implementation uses 1 goroutine per connection