为什么redis-benchmark命令不遵循redis协议？(How come the redis-benchmark command is not following the redis protocol?)

 在运行redis-benchmark命令之后，我直接从tcp连接读取，据我所知， redis-benchmark不遵循redis协议。 
 
 redis协议如其网站所述： 
 
 
 
 RESP在Redis中用作请求 - 响应协议的方式如下： 
 
 
 
  
 客户端将命令作为Bulk Strings的RESP数组发送到Redis服务器。 
 
  
 服务器根据命令实现回复一种RESP类型。 
 
 
 
 
 这意味着正确的客户端实现必须始终发送批量字符串的RESP数组。 
 
 如果这是真的，那么任何不以*开头的东西都被认为是语法错误（因为它不是RESP数组）。 
 
 因此，如果要将一个ping命令发送到redis-server，则必须将其作为长度为1的resp数组发送，其中包含1个包含单词ping的批量字符串。 例如： 
 
 
 
 “* 1 \ r \ n $ 4 \ r \ nPING \ r \ n” 
 
 
 但是，每当我直接监听redis-benchmark命令并读取其tcp连接时，我得到的是： 
 
 
 
 “PING \ r \ n” 
 
 
 它不遵循redis协议。 这是一个错误还是redis协议中隐含的一些东西让ping变得特别？ 据我所知，我找不到任何说ping特别的东西，也没有说长度1命令是特别的。 有人知道发生了什么事吗？ 
 
 要查看自己重现这些结果，您可以复制我的代码以直接检查它： 
 
package main

import (
    "fmt"
    "log"
    "net"
)

func main() {
    RedisBenchmark()
}

func RedisBenchmark() {
    url := "127.0.0.1:6379"
    fmt.Println("listen: ", url)
    ln, err := net.Listen("tcp", url) //announces on local network
    if err != nil {
        log.Fatal(err)
    }
    for {
        conn, err := ln.Accept() //waits and returns the next connection to the listener
        if err != nil {
            log.Fatal(err)
        }

        tcpConn := conn.(*net.TCPConn)
        go HandleConnection(tcpConn)
    }
}

func HandleConnection(tcpConn *net.TCPConn) {
    b := make([]byte, 256) //TODO how much should I read at a time?
    n, err := tcpConn.Read(b)
    if err != nil {
        fmt.Println("n: ", n)
        log.Fatal(err)
    }
    fmt.Printf("+++++> raw input string(b): %q\n", string(b))
    msg := string(b[:n])
    fmt.Printf("+++++> raw input msg: %q\n", msg)
}
 
 并使用go运行它： 
 
 go run main.go 
 
 跟随在不同的终端（或tmux窗格）： 
 
 redis-benchmark 
 
 对于所有测试或者如果您只想与1个客户端运行ping： 
 
 redis-benchmark -c 1 -t ping -n 1 
 
 你可以在http://redis.io/topics/benchmarks看到有关我如何运行它的详细信息 

I was reading in directly from a tcp connection after running the redis-benchmark command and as far as I can tell, redis-benchmark is NOT following the redis protocol.
 
The redis protocol is as stated in its website:
 
 
 
The way RESP is used in Redis as a request-response protocol is the following:
 
 
 
  
Clients send commands to a Redis server as a RESP Array of Bulk Strings. 
 
  
The server replies with one of the RESP types according to the command implementation.
 
 
 
 
Meaning that a correct client implementation must always send RESP arrays of bulk strings.
 
If that is true, then, anything that does not start with a * is considered a syntax error (since its not an RESP array).
 
Thus, if one were to send a ping command to a redis-server, then it must be sent as a resp array of length 1 with 1 bulk string containing the word ping. For example:
 
 
 
"*1\r\n$4\r\nPING\r\n"
 
 
However, whenever I listen directly to the redis-benchmark command and read its tcp connection I get instead:
 
 
 
"PING\r\n"
 
 
which does not follow the redis protocol. Is that a bug or is there something implied in the redis protocol that makes pings special? As far as I could tell I couldn't find anything that said that pings were special, nor that length 1 commands were special. Does someone know whats going on?
 
To see reproduce these results yourself you can copy my code to inspect it directly:
 
package main

import (
    "fmt"
    "log"
    "net"
)

func main() {
    RedisBenchmark()
}

func RedisBenchmark() {
    url := "127.0.0.1:6379"
    fmt.Println("listen: ", url)
    ln, err := net.Listen("tcp", url) //announces on local network
    if err != nil {
        log.Fatal(err)
    }
    for {
        conn, err := ln.Accept() //waits and returns the next connection to the listener
        if err != nil {
            log.Fatal(err)
        }

        tcpConn := conn.(*net.TCPConn)
        go HandleConnection(tcpConn)
    }
}

func HandleConnection(tcpConn *net.TCPConn) {
    b := make([]byte, 256) //TODO how much should I read at a time?
    n, err := tcpConn.Read(b)
    if err != nil {
        fmt.Println("n: ", n)
        log.Fatal(err)
    }
    fmt.Printf("+++++> raw input string(b): %q\n", string(b))
    msg := string(b[:n])
    fmt.Printf("+++++> raw input msg: %q\n", msg)
}
 
and run it using go with:
 
go run main.go
 
followed on a different terminal (or tmux pane):
 
redis-benchmark
 
for all the test or if you only want to run ping with 1 client:
 
redis-benchmark -c 1 -t ping -n 1
 
you can see the details of how I am running it with the flags at: http://redis.io/topics/benchmarks

原文：https://stackoverflow.com/questions/25225333