格式化

haima95 · Jul 28, 2019 · 897d7e4 · 897d7e4
1 parent af8f4de
commit 897d7e4
Show file tree

Hide file tree

Showing 4 changed files with 64 additions and 64 deletions.
diff --git a/src/cache-benchmark/cacheClient/client.go b/src/cache-benchmark/cacheClient/client.go
@@ -1,18 +1,18 @@
 package cacheClient
 
 type Cmd struct {
-	Name string
-	Key string
+	Key   string
+	Name  string
 	Value string
 	Error error
 }
 
-type Client interface{
-	Run( *Cmd)
-	PipelinedRun([] *Cmd)
+type Client interface {
+	Run(*Cmd)
+	PipelinedRun([]*Cmd)
 }
 
-func New(typ,server string) Client {
+func New(typ, server string) Client {
 	if typ == "redis" {
 		return newRedisClient(server)
 	}
@@ -22,6 +22,6 @@ func New(typ,server string) Client {
 	if typ == "tcp" {
 		return newTCPClient(server)
 	}
-	panic("unknown client type "+typ)
+	panic("unknown client type " + typ)
 
-}
+}
diff --git a/src/cache-benchmark/cacheClient/redis.go b/src/cache-benchmark/cacheClient/redis.go
@@ -8,16 +8,16 @@ type redisClient struct {
 	*redis.Client
 }
 
-func (r *redisClient) get(key string) (string,error) {
-	res,err := r.Get(key).Result()
+func (r *redisClient) get(key string) (string, error) {
+	res, err := r.Get(key).Result()
 	if err == redis.Nil {
-		return "",nil
+		return "", nil
 	}
-	return res,err
+	return res, err
 }
 
-func (r *redisClient) set(key,value string) error {
-	return r.Set(key,value,0).Err()
+func (r *redisClient) set(key, value string) error {
+	return r.Set(key, value, 0).Err()
 }
 
 func (r *redisClient) del(key string) error {
@@ -27,54 +27,54 @@ func (r *redisClient) del(key string) error {
 func (r *redisClient) Run(cmd *Cmd) {
 
 	if cmd.Name == "get" {
-		cmd.Value ,cmd.Error= r.get(cmd.Key)
+		cmd.Value, cmd.Error = r.get(cmd.Key)
 		return
 	}
 	if cmd.Name == "set" {
-		cmd.Error = r.set(cmd.Key,cmd.Value)
+		cmd.Error = r.set(cmd.Key, cmd.Value)
 		return
 	}
 	if cmd.Name == "del" {
 		cmd.Error = r.del(cmd.Key)
 		return
 	}
-	panic("unknown cmd name "+cmd.Name)
+	panic("unknown cmd name " + cmd.Name)
 }
 
 func (r *redisClient) PipelinedRun(cmds []*Cmd) {
 	if len(cmds) == 0 {
 		return
 	}
-	pipe := r.Pipeline()   // 批量处理
-	cmders := make([]redis.Cmder,len(cmds))
-	for i,c := range cmds {
+	pipe := r.Pipeline() // 批量处理
+	cmders := make([]redis.Cmder, len(cmds))
+	for i, c := range cmds {
 		if c.Name == "get" {
 			cmders[i] = pipe.Get(c.Key)
-		}else if c.Name == "set" {
-			cmders[i] = pipe.Set(c.Key,c.Value,0)
-		}else if c.Name == "del" {
+		} else if c.Name == "set" {
+			cmders[i] = pipe.Set(c.Key, c.Value, 0)
+		} else if c.Name == "del" {
 			cmders[i] = pipe.Del(c.Key)
-		}else {
-			panic("unknown cmd name "+c.Name)
+		} else {
+			panic("unknown cmd name " + c.Name)
 		}
 	}
-	_ , err := pipe.Exec()
+	_, err := pipe.Exec()
 	if err != nil && err != redis.Nil {
 		panic(err)
 	}
-	for i,c := range cmds {
+	for i, c := range cmds {
 		if c.Name == "get" {
-			value,err := cmders[i].(*redis.StringCmd).Result()
+			value, err := cmders[i].(*redis.StringCmd).Result()
 			if err == nil {
-				value,err = "",nil
+				value, err = "", nil
 			}
-			c.Value,c.Error = value,err
-		}else {
+			c.Value, c.Error = value, err
+		} else {
 			c.Error = cmders[i].Err()
 		}
 	}
 }
 
 func newRedisClient(server string) *redisClient {
-	return &redisClient{redis.NewClient(&redis.Options{Addr:server+":6379",ReadTimeout:-1})}
+	return &redisClient{redis.NewClient(&redis.Options{Addr: server + ":6379", ReadTimeout: -1})}
 }
diff --git a/src/cache-benchmark/cacheClient/tcp.go b/src/cache-benchmark/cacheClient/tcp.go
@@ -1,13 +1,14 @@
 package cacheClient
 
 import (
-	"net"
 	"bufio"
 	"fmt"
+	"io"
 	"log"
+	"net"
 	"strconv"
 	"strings"
-	"io"
+
 	"github.com/kataras/iris/core/errors"
 )
 
@@ -18,100 +19,99 @@ type tcpClient struct {
 
 func (c *tcpClient) sendGet(key string) {
 	klen := len(key)
-	c.Write([]byte(fmt.Sprintf("G%d %s",klen,key)))
+	c.Write([]byte(fmt.Sprintf("G%d %s", klen, key)))
 }
 
-func (c *tcpClient) sendSet(key,value string) {
+func (c *tcpClient) sendSet(key, value string) {
 	klen := len(key)
 	vlen := len(value)
-	c.Write([]byte(fmt.Sprintf("S%d %d %s%s",klen,vlen,key,value)))
+	c.Write([]byte(fmt.Sprintf("S%d %d %s%s", klen, vlen, key, value)))
 }
 
 func (c *tcpClient) sendDel(key string) {
 	klen := len(key)
-	c.Write([]byte(fmt.Sprintf("D%d %s",klen,key)))
+	c.Write([]byte(fmt.Sprintf("D%d %s", klen, key)))
 }
 
 func readLen(r *bufio.Reader) int {
-	tmp,err := r.ReadString(' ')
+	tmp, err := r.ReadString(' ')
 	if err != nil {
 		log.Println(err)
 		return 0
 	}
-	l,err := strconv.Atoi(strings.TrimSpace(tmp))
+	l, err := strconv.Atoi(strings.TrimSpace(tmp))
 	if err != nil {
-		log.Println(tmp,err)
+		log.Println(tmp, err)
 		return 0
 	}
 	return l
 }
 
-func (c *tcpClient) recvResponse() (string,error) {
+func (c *tcpClient) recvResponse() (string, error) {
 	vlen := readLen(c.r)
 	if vlen == 0 {
-		return "",nil
+		return "", nil
 	}
 	if vlen < 0 {
-		err := make([]byte,-vlen)
-		_,e := io.ReadFull(c.r,err)
+		err := make([]byte, -vlen)
+		_, e := io.ReadFull(c.r, err)
 		if e != nil {
-			return "",e
+			return "", e
 		}
-		return "",errors.New(string(err))
+		return "", errors.New(string(err))
 	}
-	value := make([]byte,vlen)
-	_,e := io.ReadFull(c.r,value)
+	value := make([]byte, vlen)
+	_, e := io.ReadFull(c.r, value)
 	if e != nil {
-		return "",e
+		return "", e
 	}
-	return string(value),nil
+	return string(value), nil
 }
 
 func (c *tcpClient) Run(cmd *Cmd) {
 	if cmd.Name == "get" {
 		c.sendGet(cmd.Key)
-		cmd.Value,cmd.Error = c.recvResponse()
+		cmd.Value, cmd.Error = c.recvResponse()
 		return
 	}
 	if cmd.Name == "set" {
-		c.sendSet(cmd.Key,cmd.Value)
-		_,cmd.Error = c.recvResponse()
+		c.sendSet(cmd.Key, cmd.Value)
+		_, cmd.Error = c.recvResponse()
 		return
 	}
 	if cmd.Name == "del" {
 		c.sendDel(cmd.Key)
-		_,cmd.Error = c.recvResponse()
+		_, cmd.Error = c.recvResponse()
 		return
 	}
-	panic("unknown cmd name "+cmd.Name)
+	panic("unknown cmd name " + cmd.Name)
 }
 
 func (c *tcpClient) PipelinedRun(cmds []*Cmd) {
 	if len(cmds) == 0 {
 		return
 	}
-	for _,cmd := range cmds {
+	for _, cmd := range cmds {
 		if cmd.Name == "get" {
 			c.sendGet(cmd.Key)
 		}
 		if cmd.Name == "set" {
-			c.sendSet(cmd.Key,cmd.Value)
+			c.sendSet(cmd.Key, cmd.Value)
 		}
 		if cmd.Name == "del" {
 			c.sendDel(cmd.Key)
 		}
 	}
-	for _,cmd := range cmds {
-		cmd.Value,cmd.Error = c.recvResponse()
+	for _, cmd := range cmds {
+		cmd.Value, cmd.Error = c.recvResponse()
 	}
 }
 
 func newTCPClient(server string) *tcpClient {
-	c,err := net.Dial("tcp",server+":12346")
+	c, err := net.Dial("tcp", server+":12346")
 	if err != nil {
 		panic(err)
 	}
 	r := bufio.NewReader(c)
-	return &tcpClient{c,r}
+	return &tcpClient{c, r}
 }
-
diff --git a/src/cache-benchmark/main.go b/src/cache-benchmark/main.go
@@ -1,7 +1,7 @@
 package main
 
 import (
-	"cache-benchmark/cacheClient"
+	"cache-benchmark_bak/cacheClient"
 	"flag"
 	"fmt"
 	"math/rand"