Channels of channels

The online Go tutorial at golang.org has an example of multiplexing, where channels of channels are used. The idea is that instead of sharing one channel, a new communicator is given their own channel to have a private conversation. That is, a client is sent a channel from a server through a shared channel, and uses that private channel.

This doesn’t work directly with network channels: a channel cannot be sent over a network channel. So we have to be a little more indirect. Each time a client connects to a server, the server builds new network channels and exports them with new names. Then it sends the names of these new channels to the client which imports them. It uses these new channels for communication.

A server is

  1. /* EchoChanServer
  2.  */
  3. package main
  5. import (
  6.     "fmt"
  7.     "os"
  8.     "old/netchan"
  9.     "strconv"
  10. )
  12. var count int = 0
  14. func main() {
  16.     exporter := netchan.NewExporter()
  17.     err := exporter.ListenAndServe("tcp", ":2345")
  18.     checkError(err)
  20.     echo := make(chan string)
  21.     exporter.Export("echo", echo, netchan.Send)
  22.     for {
  23.         sCount := strconv.Itoa(count)
  24.         lock := make(chan string)
  25.         go handleSession(exporter, sCount, lock)
  27.         <-lock
  28.         echo <- sCount
  29.         count++
  30.         exporter.Drain(-1)
  31.     }
  32. }
  34. func handleSession(exporter *netchan.Exporter, sCount string, lock chan string) {
  35.     echoIn := make(chan string)
  36.     exporter.Export("echoIn"+sCount, echoIn, netchan.Send)
  38.     echoOut := make(chan string)
  39.     exporter.Export("echoOut"+sCount, echoOut, netchan.Recv)
  40.     fmt.Println("made " + "echoOut" + sCount)
  42.     lock <- "done"
  44.     for {
  45.         s := <-echoOut
  46.         echoIn <- s
  47.     }
  48.     // should unexport net channels
  49. }
  51. func checkError(err error) {
  52.     if err != nil {
  53.         fmt.Println("Fatal error ", err.Error())
  54.         os.Exit(1)
  55.     }
  56. }

and a client is

  1. /* EchoChanClient
  2.  */
  3. package main
  5. import (
  6.     "fmt"
  7.     "old/netchan"
  8.     "os"
  9. )
  11. func main() {
  12.     if len(os.Args) != 2 {
  13.         fmt.Println("Usage: ", os.Args[0], "host:port")
  14.         os.Exit(1)
  15.     }
  16.     service := os.Args[1]
  18.     importer, err := netchan.Import("tcp", service)
  19.     checkError(err)
  21.     fmt.Println("Got importer")
  22.     echo := make(chan string)
  23.     importer.Import("echo", echo, netchan.Recv, 1)
  24.     fmt.Println("Imported in")
  26.     count := <-echo
  27.     fmt.Println(count)
  29.     echoIn := make(chan string)
  30.     importer.Import("echoIn"+count, echoIn, netchan.Recv, 1)
  32.     echoOut := make(chan string)
  33.     importer.Import("echoOut"+count, echoOut, netchan.Send, 1)
  35.     for n := 1; n < 10; n++ {
  36.         echoOut <- "hello "
  37.         s := <-echoIn
  38.         fmt.Println(s, n)
  39.     }
  40.     close(echoOut)
  41.     os.Exit(0)
  42. }
  44. func checkError(err error) {
  45.     if err != nil {
  46.         fmt.Println("Fatal error ", err.Error())
  47.         os.Exit(1)
  48.     }
  49. }

Conclusion

Network channels are a distributed analogue of local channels. They behave approximately the same, but due to limitations of the model some things have to be done a little differently.