redis TCP concurrency

example-redis/main.go

@@ -10,6 +10,17 @@ import (
 	"strings"
 )
 
+type RedisCmd struct {
+	cmd string
+	key string
+	val string
+}
+
+type CommandExec struct {
+	*RedisCmd
+	Result chan string
+}
+
 func getCommand(reader io.Reader) (string, error) {
 	scanner := bufio.NewScanner(reader)
 	for scanner.Scan() {
@@ -32,8 +43,8 @@ func isCommand(str string) bool {
 	}
 }
 
-func parseCmd(line string) (string, string, string, error) {
+func parseCmd(line string) (*RedisCmd, error) {
-	cmd, key, val := "", "", ""
+	redisCmd := new(RedisCmd)
 	var err error
 	parts := strings.Split(line, " ")
 	if len(parts) != 2 && len(parts) != 3 {
@@ -43,23 +54,23 @@ func parseCmd(line string) (string, string, string, error) {
 			switch i {
 			case 0:
 				if isCommand(part) {
-					cmd = part
+					redisCmd.cmd = part
 				} else {
 					err = errors.New("Unknown command")
 					break
 				}
 			case 1:
-				key = part
+				redisCmd.key = part
 			case 2:
-				if cmd == "SET" {
+				if redisCmd.cmd == "SET" {
-					val = part
+					redisCmd.val = part
 				} else {
 					err = errors.New("Invalid number of arguments")
 				}
 			}
 		}
 	}
-	return cmd, key, val, err
+	return redisCmd, err
 }
 
 func respond(writer io.Writer, ret string) {
@@ -78,39 +89,68 @@ func main() {
 	}
 	defer ln.Close()
 
+	commands := make(chan CommandExec)
+	go func() {
+		for exec := range commands {
+			switch exec.cmd {
+			case "DEL":
+				log.Println("Deleting", exec.key)
+				delete(db, exec.key)
+				close(exec.Result)
+			case "GET":
+				log.Println("Getting", exec.key)
+				ret, ok := db[exec.key]
+				if ok {
+					log.Println("Value found", ret)
+					go func() {
+						exec.Result <- ret
+					}()
+				} else {
+					log.Println("Unknown key", exec.key)
+					close(exec.Result)
+				}
+			case "SET":
+				log.Println("Setting", exec.key)
+				db[exec.key] = exec.val
+				close(exec.Result)
+			}
+		}
+	}()
+
 	for {
 		conn, err := ln.Accept()
 		if err != nil {
 			panic(err)
 		}
+		results := make(chan string)
 
 		go func() {
-			line, err := getCommand(conn)
+			ret, ok := <-results
-			if err != nil {
-				respond(conn, fmt.Sprint(err))
-			}
-			cmd, key, val, err := parseCmd(line)
-			if err != nil {
-				respond(conn, fmt.Sprint(err))
-			}
-			switch cmd {
-			case "DEL":
-				log.Println("Deleting", key)
-				delete(db, key)
-			case "GET":
-				log.Println("Getting", key)
-				ret, ok := db[key]
 			if ok {
-					log.Println("Value found", ret)
 				respond(conn, ret)
-				} else {
-					log.Println("Unknown key", key)
-				}
-			case "SET":
-				log.Println("Setting", key)
-				db[key] = val
 			}
 			defer conn.Close()
 		}()
+
+		go func() {
+			exec := new(CommandExec)
+			exec.Result = results
+
+			line, err := getCommand(conn)
+			if err != nil {
+				go func() {
+					exec.Result <- fmt.Sprint(err)
+				}()
+			}
+			cmd, err := parseCmd(line)
+			if err != nil {
+				go func() {
+					exec.Result <- fmt.Sprint(err)
+				}()
+			}
+			exec.RedisCmd = cmd
+			commands <- *exec
+		}()
+
 	}
 }

example-redis/main_test.go

@@ -47,20 +47,18 @@ func TestRespond(t *testing.T) {
 type ParseCmdTest struct {
 	line  string
 	fails bool
-	cmd   string
+	RedisCmd
-	key   string
-	val   string
 }
 
 func TestParseCommand(t *testing.T) {
 	tests := []ParseCmdTest{
-		{"test", true, "", "", ""},
+		{"test", true, RedisCmd{"", "", ""}},
-		{"test test", true, "", "", ""},
+		{"test test", true, RedisCmd{"", "", ""}},
-		{"SET 1 2 3", true, "", "", ""},
+		{"SET 1 2 3", true, RedisCmd{"", "", ""}},
-		{"GET 1 2", true, "", "", ""},
+		{"GET 1 2", true, RedisCmd{"", "", ""}},
 	}
 	for _, test := range tests {
-		c, k, v, e := parseCmd(test.line)
+		c, e := parseCmd(test.line)
 		if test.fails {
 			if e == nil {
 				t.Log("should fail (" + test.line + ")")
@@ -71,16 +69,16 @@ func TestParseCommand(t *testing.T) {
 				t.Log("should no fail", e)
 				t.Fail()
 			}
-			if c != test.cmd {
+			if c.cmd != test.cmd {
-				t.Log("Error command", c, test.cmd)
+				t.Log("Error command", c.cmd, test.cmd)
 				t.Fail()
 			}
-			if k != test.key {
+			if c.key != test.key {
-				t.Log("Error key", k, test.key)
+				t.Log("Error key", c.key, test.key)
 				t.Fail()
 			}
-			if v != test.val {
+			if c.val != test.val {
-				t.Log("Error value", v, test.val)
+				t.Log("Error value", c.val, test.val)
 				t.Fail()
 			}
 		}