At this point, the chapter has covered the minimum networking components necessary to create client and service programs. The remainder of the chapter will discuss different versions of a server that implement a monetary currency information service. The service returns ISO 4217 monetary currency information with each request. The intent is to show the implications of creating networked services, along with their clients, using different application-level protocols.

Earlier we introduced a very simple server to demonstrate the necessary steps required to set up a networked service. This section dives deeper into network programming by creating a TCP server that scales to handle many concurrent connections. The server code presented in this section has the following design goals:

The following lists an abbreviated version of the server code. The program uses the curr package (found at https://github.com/vladimirvivien/learning-go/ch11/curr0), not discussed here, to load monetary currency data from a local CSV file into slice currencies.

Upon successful connection to a client, the server parses the incoming client commands specified with a simple text protocol with the format GET <currency-filter-value> where <currency-filter-value> specifies a string value used to search for currency information:

import ( 
   "net" 
   ... 
   curr "https://github.com/vladimirvivien/learning-go/ch11/curr0" 
) 
 
var currencies = curr.Load("./data.csv") 
 
func main() { 
   ln, _ := net.Listen("tcp", ":4040") 
   defer ln.Close() 
    
   // connection loop 
   for { 
         conn, err := ln.Accept() 
         if err != nil { 
               fmt.Println(err) 
               conn.Close() 
               continue 
         }      
         go handleConnection(conn) 
   } 
} 
 
// handle client connection 
func handleConnection(conn net.Conn) { 
   defer conn.Close() 
 
   // loop to stay connected with client 
   for { 
         cmdLine := make([]byte, (1024 * 4)) 
         n, err := conn.Read(cmdLine) 
         if n == 0 || err != nil { 
               return 
         } 
         cmd, param := parseCommand(string(cmdLine[0:n])) 
         if cmd == "" { 
               continue 
         } 
 
         // execute command 
         switch strings.ToUpper(cmd) { 
         case "GET": 
               result := curr.Find(currencies, param) 
               // stream result to client 
               for _, cur := range result { 
                     _, err := fmt.Fprintf( 
                           conn, 
                           "%s %s %s %s
", 
                           cur.Name, cur.Code, 
                           cur.Number, cur.Country, 
                     ) 
                     if err != nil { 
                           return 
                     } 
                     // reset deadline while writing, 
                     // closes conn if client is gone 
                     conn.SetWriteDeadline( 
                           time.Now().Add(time.Second * 5)) 
               } 
               // reset read deadline for next read 
               conn.SetReadDeadline( 
                     time.Now().Add(time.Second * 300)) 
 
         default: 
               conn.Write([]byte("Invalid command
")) 
         } 
   } 
} 
 
func parseCommand(cmdLine string) (cmd, param string) { 
   parts := strings.Split(cmdLine, " ") 
   if len(parts) != 2 { 
         return "", "" 
   } 
   cmd = strings.TrimSpace(parts[0]) 
   param = strings.TrimSpace(parts[1]) 
   return 
} 

golang.fyi/ch11/tcpserv0.go

Unlike the simple server introduced in the last section, this server is able to service multiple client connections at the same time. Upon accepting a new connection, with ln.Accept(), it delegates the handling of new client connections to a goroutine with go handleConnection(conn). The connection loop then continues immediately and waits for the next client connection.

The handleConnection function manages the server communication with the connected client. It first reads and parses a slice of bytes, from the client, into a command string using cmd, param := parseCommand(string(cmdLine[0:n])). Next, the code tests the command with a switch statement. If the cmd is equal to "GET", the code searches slice currencies for values that matches param with a call to curr.Find(currencies, param). Finally, it streams the search result to the client's connection using fmt.Fprintf(conn, "%s %s %s %s ", cur.Name, cur.Code, cur.Number, cur.Country).

The simple text protocol supported by the server does not include any sort of session control or control messages. Therefore, the code uses the conn.SetWriteDeadline method to ensure the connection to the client does not linger unnecessarily for long periods of time. The method is called during the loop that streams out a response to the client. It is set for a deadline of 5 seconds to ensure the client is always ready to receive the next chunk of bytes within that time, otherwise it times the connection out.

$> telnet localhost 4040
Trying ::1...
Connected to localhost.
Escape character is '^]'.
GET Gourde
Gourde HTG 332 HAITI
GET USD
US Dollar USD 840 AMERICAN SAMOA
US Dollar USD 840 BONAIRE, SINT EUSTATIUS AND SABA
US Dollar USD 840 GUAM
US Dollar USD 840 HAITI
US Dollar USD 840 MARSHALL ISLANDS (THE)
US Dollar USD 840 UNITED STATES OF AMERICA (THE)
...
get india
Indian Rupee INR 356 BHUTAN
US Dollar USD 840 BRITISH INDIAN OCEAN TERRITORY (THE)
Indian Rupee INR 356 INDIA

var host, port = "127.0.0.1", "4040" 
var addr = net.JoinHostPort(host, port) 
const prompt = "curr" 
const buffLen = 1024 
 
func main() { 
   conn, err := net.Dial("tcp", addr) 
   if err != nil { 
         fmt.Println(err) 
         return 
   } 
   defer conn.Close() 
   var cmd, param string 
   // repl - interactive shell for client 
   for { 
         fmt.Print(prompt, "> ") 
         _, err = fmt.Scanf("%s %s", &cmd, &param) 
         if err != nil { 
               fmt.Println("Usage: GET <search string or *>") 
               continue 
         } 
         // send command line 
         cmdLine := fmt.Sprintf("%s %s", cmd, param) 
         if n, err := conn.Write([]byte(cmdLine)); 
         n == 0 || err != nil { 
               fmt.Println(err) 
               return 
         } 
 
         // stream and display response 
         conn.SetReadDeadline( 
               time.Now().Add(time.Second * 5)) 
         for { 
               buff := make([]byte, buffLen) 
               n, err := conn.Read(buff) 
               if err != nil { break } 
               fmt.Print(string(buff[0:n])) 
               conn.SetReadDeadline( 
                     time.Now().Add(time.Millisecond * 700)) 
         } 
   } 
} 

$> Connected to Global Currency Service
curr> get pound
Egyptian Pound EGP 818 EGYPT
Gibraltar Pound GIP 292 GIBRALTAR
Sudanese Pound SDG 938 SUDAN (THE)
...
Syrian Pound SYP 760 SYRIAN ARAB REPUBLIC
Pound Sterling GBP 826 UNITED KINGDOM OF GREAT BRITAIN (THE)
curr>

         conbuf := bufio.NewReaderSize(conn, 1024) 
         for { 
               str, err := conbuf.ReadString('
') 
               if err != nil { 
                     break 
               } 
               fmt.Print(str) 
               conn.SetReadDeadline( 
                     time.Now().Add(time.Millisecond * 700)) 
         }