You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

375 lines
8.7 KiB

8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
  1. package rpc
  2. import (
  3. "bytes"
  4. "context"
  5. crand "crypto/rand"
  6. "encoding/json"
  7. "fmt"
  8. "math/rand"
  9. "net/http"
  10. "os"
  11. "os/exec"
  12. "testing"
  13. "time"
  14. "github.com/go-kit/kit/log/term"
  15. "github.com/stretchr/testify/assert"
  16. "github.com/stretchr/testify/require"
  17. "github.com/tendermint/go-wire/data"
  18. client "github.com/tendermint/tendermint/rpc/lib/client"
  19. server "github.com/tendermint/tendermint/rpc/lib/server"
  20. types "github.com/tendermint/tendermint/rpc/lib/types"
  21. "github.com/tendermint/tmlibs/log"
  22. )
  23. // Client and Server should work over tcp or unix sockets
  24. const (
  25. tcpAddr = "tcp://0.0.0.0:47768"
  26. unixSocket = "/tmp/rpc_test.sock"
  27. unixAddr = "unix://" + unixSocket
  28. websocketEndpoint = "/websocket/endpoint"
  29. )
  30. type ResultEcho struct {
  31. Value string `json:"value"`
  32. }
  33. type ResultEchoInt struct {
  34. Value int `json:"value"`
  35. }
  36. type ResultEchoBytes struct {
  37. Value []byte `json:"value"`
  38. }
  39. type ResultEchoDataBytes struct {
  40. Value data.Bytes `json:"value"`
  41. }
  42. // Define some routes
  43. var Routes = map[string]*server.RPCFunc{
  44. "echo": server.NewRPCFunc(EchoResult, "arg"),
  45. "echo_ws": server.NewWSRPCFunc(EchoWSResult, "arg"),
  46. "echo_bytes": server.NewRPCFunc(EchoBytesResult, "arg"),
  47. "echo_data_bytes": server.NewRPCFunc(EchoDataBytesResult, "arg"),
  48. "echo_int": server.NewRPCFunc(EchoIntResult, "arg"),
  49. }
  50. func EchoResult(v string) (*ResultEcho, error) {
  51. return &ResultEcho{v}, nil
  52. }
  53. func EchoWSResult(wsCtx types.WSRPCContext, v string) (*ResultEcho, error) {
  54. return &ResultEcho{v}, nil
  55. }
  56. func EchoIntResult(v int) (*ResultEchoInt, error) {
  57. return &ResultEchoInt{v}, nil
  58. }
  59. func EchoBytesResult(v []byte) (*ResultEchoBytes, error) {
  60. return &ResultEchoBytes{v}, nil
  61. }
  62. func EchoDataBytesResult(v data.Bytes) (*ResultEchoDataBytes, error) {
  63. return &ResultEchoDataBytes{v}, nil
  64. }
  65. func TestMain(m *testing.M) {
  66. setup()
  67. code := m.Run()
  68. os.Exit(code)
  69. }
  70. var colorFn = func(keyvals ...interface{}) term.FgBgColor {
  71. for i := 0; i < len(keyvals)-1; i += 2 {
  72. if keyvals[i] == "socket" {
  73. if keyvals[i+1] == "tcp" {
  74. return term.FgBgColor{Fg: term.DarkBlue}
  75. } else if keyvals[i+1] == "unix" {
  76. return term.FgBgColor{Fg: term.DarkCyan}
  77. }
  78. }
  79. }
  80. return term.FgBgColor{}
  81. }
  82. // launch unix and tcp servers
  83. func setup() {
  84. logger := log.NewTMLoggerWithColorFn(log.NewSyncWriter(os.Stdout), colorFn)
  85. cmd := exec.Command("rm", "-f", unixSocket)
  86. err := cmd.Start()
  87. if err != nil {
  88. panic(err)
  89. }
  90. if err = cmd.Wait(); err != nil {
  91. panic(err)
  92. }
  93. tcpLogger := logger.With("socket", "tcp")
  94. mux := http.NewServeMux()
  95. server.RegisterRPCFuncs(mux, Routes, tcpLogger)
  96. wm := server.NewWebsocketManager(Routes, nil, server.ReadWait(5*time.Second), server.PingPeriod(1*time.Second))
  97. wm.SetLogger(tcpLogger)
  98. mux.HandleFunc(websocketEndpoint, wm.WebsocketHandler)
  99. go func() {
  100. _, err := server.StartHTTPServer(tcpAddr, mux, tcpLogger)
  101. if err != nil {
  102. panic(err)
  103. }
  104. }()
  105. unixLogger := logger.With("socket", "unix")
  106. mux2 := http.NewServeMux()
  107. server.RegisterRPCFuncs(mux2, Routes, unixLogger)
  108. wm = server.NewWebsocketManager(Routes, nil)
  109. wm.SetLogger(unixLogger)
  110. mux2.HandleFunc(websocketEndpoint, wm.WebsocketHandler)
  111. go func() {
  112. _, err := server.StartHTTPServer(unixAddr, mux2, unixLogger)
  113. if err != nil {
  114. panic(err)
  115. }
  116. }()
  117. // wait for servers to start
  118. time.Sleep(time.Second * 2)
  119. }
  120. func echoViaHTTP(cl client.HTTPClient, val string) (string, error) {
  121. params := map[string]interface{}{
  122. "arg": val,
  123. }
  124. result := new(ResultEcho)
  125. if _, err := cl.Call("echo", params, result); err != nil {
  126. return "", err
  127. }
  128. return result.Value, nil
  129. }
  130. func echoIntViaHTTP(cl client.HTTPClient, val int) (int, error) {
  131. params := map[string]interface{}{
  132. "arg": val,
  133. }
  134. result := new(ResultEchoInt)
  135. if _, err := cl.Call("echo_int", params, result); err != nil {
  136. return 0, err
  137. }
  138. return result.Value, nil
  139. }
  140. func echoBytesViaHTTP(cl client.HTTPClient, bytes []byte) ([]byte, error) {
  141. params := map[string]interface{}{
  142. "arg": bytes,
  143. }
  144. result := new(ResultEchoBytes)
  145. if _, err := cl.Call("echo_bytes", params, result); err != nil {
  146. return []byte{}, err
  147. }
  148. return result.Value, nil
  149. }
  150. func echoDataBytesViaHTTP(cl client.HTTPClient, bytes data.Bytes) (data.Bytes, error) {
  151. params := map[string]interface{}{
  152. "arg": bytes,
  153. }
  154. result := new(ResultEchoDataBytes)
  155. if _, err := cl.Call("echo_data_bytes", params, result); err != nil {
  156. return []byte{}, err
  157. }
  158. return result.Value, nil
  159. }
  160. func testWithHTTPClient(t *testing.T, cl client.HTTPClient) {
  161. val := "acbd"
  162. got, err := echoViaHTTP(cl, val)
  163. require.Nil(t, err)
  164. assert.Equal(t, got, val)
  165. val2 := randBytes(t)
  166. got2, err := echoBytesViaHTTP(cl, val2)
  167. require.Nil(t, err)
  168. assert.Equal(t, got2, val2)
  169. val3 := data.Bytes(randBytes(t))
  170. got3, err := echoDataBytesViaHTTP(cl, val3)
  171. require.Nil(t, err)
  172. assert.Equal(t, got3, val3)
  173. val4 := rand.Intn(10000)
  174. got4, err := echoIntViaHTTP(cl, val4)
  175. require.Nil(t, err)
  176. assert.Equal(t, got4, val4)
  177. }
  178. func echoViaWS(cl *client.WSClient, val string) (string, error) {
  179. params := map[string]interface{}{
  180. "arg": val,
  181. }
  182. err := cl.Call(context.Background(), "echo", params)
  183. if err != nil {
  184. return "", err
  185. }
  186. select {
  187. case msg := <-cl.ResultsCh:
  188. result := new(ResultEcho)
  189. err = json.Unmarshal(msg, result)
  190. if err != nil {
  191. return "", nil
  192. }
  193. return result.Value, nil
  194. case err := <-cl.ErrorsCh:
  195. return "", err
  196. }
  197. }
  198. func echoBytesViaWS(cl *client.WSClient, bytes []byte) ([]byte, error) {
  199. params := map[string]interface{}{
  200. "arg": bytes,
  201. }
  202. err := cl.Call(context.Background(), "echo_bytes", params)
  203. if err != nil {
  204. return []byte{}, err
  205. }
  206. select {
  207. case msg := <-cl.ResultsCh:
  208. result := new(ResultEchoBytes)
  209. err = json.Unmarshal(msg, result)
  210. if err != nil {
  211. return []byte{}, nil
  212. }
  213. return result.Value, nil
  214. case err := <-cl.ErrorsCh:
  215. return []byte{}, err
  216. }
  217. }
  218. func testWithWSClient(t *testing.T, cl *client.WSClient) {
  219. val := "acbd"
  220. got, err := echoViaWS(cl, val)
  221. require.Nil(t, err)
  222. assert.Equal(t, got, val)
  223. val2 := randBytes(t)
  224. got2, err := echoBytesViaWS(cl, val2)
  225. require.Nil(t, err)
  226. assert.Equal(t, got2, val2)
  227. }
  228. //-------------
  229. func TestServersAndClientsBasic(t *testing.T) {
  230. serverAddrs := [...]string{tcpAddr, unixAddr}
  231. for _, addr := range serverAddrs {
  232. cl1 := client.NewURIClient(addr)
  233. fmt.Printf("=== testing server on %s using %v client", addr, cl1)
  234. testWithHTTPClient(t, cl1)
  235. cl2 := client.NewJSONRPCClient(addr)
  236. fmt.Printf("=== testing server on %s using %v client", addr, cl2)
  237. testWithHTTPClient(t, cl2)
  238. cl3 := client.NewWSClient(addr, websocketEndpoint)
  239. cl3.SetLogger(log.TestingLogger())
  240. _, err := cl3.Start()
  241. require.Nil(t, err)
  242. fmt.Printf("=== testing server on %s using %v client", addr, cl3)
  243. testWithWSClient(t, cl3)
  244. cl3.Stop()
  245. }
  246. }
  247. func TestHexStringArg(t *testing.T) {
  248. cl := client.NewURIClient(tcpAddr)
  249. // should NOT be handled as hex
  250. val := "0xabc"
  251. got, err := echoViaHTTP(cl, val)
  252. require.Nil(t, err)
  253. assert.Equal(t, got, val)
  254. }
  255. func TestQuotedStringArg(t *testing.T) {
  256. cl := client.NewURIClient(tcpAddr)
  257. // should NOT be unquoted
  258. val := "\"abc\""
  259. got, err := echoViaHTTP(cl, val)
  260. require.Nil(t, err)
  261. assert.Equal(t, got, val)
  262. }
  263. func TestWSNewWSRPCFunc(t *testing.T) {
  264. cl := client.NewWSClient(tcpAddr, websocketEndpoint)
  265. cl.SetLogger(log.TestingLogger())
  266. _, err := cl.Start()
  267. require.Nil(t, err)
  268. defer cl.Stop()
  269. val := "acbd"
  270. params := map[string]interface{}{
  271. "arg": val,
  272. }
  273. err = cl.Call(context.Background(), "echo_ws", params)
  274. require.Nil(t, err)
  275. select {
  276. case msg := <-cl.ResultsCh:
  277. result := new(ResultEcho)
  278. err = json.Unmarshal(msg, result)
  279. require.Nil(t, err)
  280. got := result.Value
  281. assert.Equal(t, got, val)
  282. case err := <-cl.ErrorsCh:
  283. t.Fatal(err)
  284. }
  285. }
  286. func TestWSHandlesArrayParams(t *testing.T) {
  287. cl := client.NewWSClient(tcpAddr, websocketEndpoint)
  288. cl.SetLogger(log.TestingLogger())
  289. _, err := cl.Start()
  290. require.Nil(t, err)
  291. defer cl.Stop()
  292. val := "acbd"
  293. params := []interface{}{val}
  294. err = cl.CallWithArrayParams(context.Background(), "echo_ws", params)
  295. require.Nil(t, err)
  296. select {
  297. case msg := <-cl.ResultsCh:
  298. result := new(ResultEcho)
  299. err = json.Unmarshal(msg, result)
  300. require.Nil(t, err)
  301. got := result.Value
  302. assert.Equal(t, got, val)
  303. case err := <-cl.ErrorsCh:
  304. t.Fatalf("%+v", err)
  305. }
  306. }
  307. // TestWSClientPingPong checks that a client & server exchange pings
  308. // & pongs so connection stays alive.
  309. func TestWSClientPingPong(t *testing.T) {
  310. cl := client.NewWSClient(tcpAddr, websocketEndpoint)
  311. cl.SetLogger(log.TestingLogger())
  312. _, err := cl.Start()
  313. require.Nil(t, err)
  314. defer cl.Stop()
  315. time.Sleep(6 * time.Second)
  316. }
  317. func randBytes(t *testing.T) []byte {
  318. n := rand.Intn(10) + 2
  319. buf := make([]byte, n)
  320. _, err := crand.Read(buf)
  321. require.Nil(t, err)
  322. return bytes.Replace(buf, []byte("="), []byte{100}, -1)
  323. }