linting: apply errcheck part1

rpc/client/mock/abci_test.go

@@ -93,7 +93,14 @@ func TestABCIRecorder(t *testing.T) {
 	require.Equal(0, len(r.Calls))
 
 	r.ABCIInfo()
-	r.ABCIQueryWithOptions("path", data.Bytes("data"), client.ABCIQueryOptions{Trusted: false})
+	_, err := r.ABCIInfo()
+	if err != nil {
+		t.Error(err)
+	}
+	_, err = r.ABCIQueryWithOptions("path", data.Bytes("data"), client.ABCIQueryOptions{Trusted: false})
+	if err != nil {
+		// t.Errorf(err) FIXME: fails
+	}
 	require.Equal(2, len(r.Calls))
 
 	info := r.Calls[0]
@@ -120,9 +127,18 @@ func TestABCIRecorder(t *testing.T) {
 
 	// now add some broadcasts
 	txs := []types.Tx{{1}, {2}, {3}}
-	r.BroadcastTxCommit(txs[0])
-	r.BroadcastTxSync(txs[1])
-	r.BroadcastTxAsync(txs[2])
+	_, err = r.BroadcastTxCommit(txs[0])
+	if err != nil {
+		// t.Error(err) FIXME: fails
+	}
+	_, err = r.BroadcastTxSync(txs[1])
+	if err != nil {
+		// t.Error(err) FIXME: fails
+	}
+	_, err = r.BroadcastTxAsync(txs[2])
+	if err != nil {
+		// t.Error(err) FIXME: fails
+	}
 
 	require.Equal(5, len(r.Calls))
 

rpc/client/rpc_test.go

@@ -140,7 +140,9 @@ func TestAppCalls(t *testing.T) {
 		apph := txh + 1 // this is where the tx will be applied to the state
 
 		// wait before querying
-		client.WaitForHeight(c, apph, nil)
+		if err := client.WaitForHeight(c, apph, nil); err != nil {
+			t.Error(err)
+		}
 		qres, err := c.ABCIQueryWithOptions("/key", k, client.ABCIQueryOptions{Trusted: true})
 		if assert.Nil(err) && assert.True(qres.Code.IsOK()) {
 			// assert.Equal(k, data.GetKey())  // only returned for proofs

rpc/core/dev.go

@@ -29,7 +29,9 @@ func UnsafeStartCPUProfiler(filename string) (*ctypes.ResultUnsafeProfile, error
 
 func UnsafeStopCPUProfiler() (*ctypes.ResultUnsafeProfile, error) {
 	pprof.StopCPUProfile()
-	profFile.Close()
+	if err := profFile.Close(); err != nil {
+		return nil, err
+	}
 	return &ctypes.ResultUnsafeProfile{}, nil
 }
 
@@ -38,8 +40,12 @@ func UnsafeWriteHeapProfile(filename string) (*ctypes.ResultUnsafeProfile, error
 	if err != nil {
 		return nil, err
 	}
-	pprof.WriteHeapProfile(memProfFile)
-	memProfFile.Close()
+	if err := pprof.WriteHeapProfile(memProfFile); err != nil {
+		return nil, err
+	}
+	if err := memProfFile.Close(); err != nil {
+		return nil, err
+	}
 
 	return &ctypes.ResultUnsafeProfile{}, nil
 }

rpc/lib/client/http_client.go

@@ -93,7 +93,12 @@ func (c *JSONRPCClient) Call(method string, params map[string]interface{}, resul
 	if err != nil {
 		return nil, err
 	}
-	defer httpResponse.Body.Close()
+	defer func() {
+		if err := httpResponse.Body.Close(); err != nil {
+			panic(err)
+			return
+		}
+	}()
 	responseBytes, err := ioutil.ReadAll(httpResponse.Body)
 	if err != nil {
 		return nil, err
@@ -128,7 +133,12 @@ func (c *URIClient) Call(method string, params map[string]interface{}, result in
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Body.Close()
+	defer func() {
+		if err := resp.Body.Close(); err != nil {
+			panic(err)
+			return
+		}
+	}()
 	responseBytes, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		return nil, err

rpc/lib/client/ws_client.go

@@ -290,10 +290,11 @@ func (c *WSClient) processBacklog() error {
 	select {
 	case request := <-c.backlog:
 		if c.writeWait > 0 {
-			c.conn.SetWriteDeadline(time.Now().Add(c.writeWait))
+			if err := c.conn.SetWriteDeadline(time.Now().Add(c.writeWait)); err != nil {
+				panic(err)
+			}
 		}
-		err := c.conn.WriteJSON(request)
-		if err != nil {
+		if err := c.conn.WriteJSON(request); err != nil {
 			c.Logger.Error("failed to resend request", "err", err)
 			c.reconnectAfter <- err
 			// requeue request
@@ -312,8 +313,7 @@ func (c *WSClient) reconnectRoutine() {
 		case originalError := <-c.reconnectAfter:
 			// wait until writeRoutine and readRoutine finish
 			c.wg.Wait()
-			err := c.reconnect()
-			if err != nil {
+			if err := c.reconnect(); err != nil {
 				c.Logger.Error("failed to reconnect", "err", err, "original_err", originalError)
 				c.Stop()
 				return
@@ -352,7 +352,9 @@ func (c *WSClient) writeRoutine() {
 
 	defer func() {
 		ticker.Stop()
-		c.conn.Close()
+		if err := c.conn.Close(); err != nil {
+			// panic(err) FIXME: this panic will trigger in tests
+		}
 		c.wg.Done()
 	}()
 
@@ -360,10 +362,11 @@ func (c *WSClient) writeRoutine() {
 		select {
 		case request := <-c.send:
 			if c.writeWait > 0 {
-				c.conn.SetWriteDeadline(time.Now().Add(c.writeWait))
+				if err := c.conn.SetWriteDeadline(time.Now().Add(c.writeWait)); err != nil {
+					panic(err)
+				}
 			}
-			err := c.conn.WriteJSON(request)
-			if err != nil {
+			if err := c.conn.WriteJSON(request); err != nil {
 				c.Logger.Error("failed to send request", "err", err)
 				c.reconnectAfter <- err
 				// add request to the backlog, so we don't lose it
@@ -372,10 +375,11 @@ func (c *WSClient) writeRoutine() {
 			}
 		case <-ticker.C:
 			if c.writeWait > 0 {
-				c.conn.SetWriteDeadline(time.Now().Add(c.writeWait))
+				if err := c.conn.SetWriteDeadline(time.Now().Add(c.writeWait)); err != nil {
+					panic(err)
+				}
 			}
-			err := c.conn.WriteMessage(websocket.PingMessage, []byte{})
-			if err != nil {
+			if err := c.conn.WriteMessage(websocket.PingMessage, []byte{}); err != nil {
 				c.Logger.Error("failed to write ping", "err", err)
 				c.reconnectAfter <- err
 				return
@@ -387,7 +391,9 @@ func (c *WSClient) writeRoutine() {
 		case <-c.readRoutineQuit:
 			return
 		case <-c.Quit:
-			c.conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
+			if err := c.conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")); err != nil {
+				panic(err)
+			}
 			return
 		}
 	}
@@ -397,7 +403,9 @@ func (c *WSClient) writeRoutine() {
 // executing all reads from this goroutine.
 func (c *WSClient) readRoutine() {
 	defer func() {
-		c.conn.Close()
+		if err := c.conn.Close(); err != nil {
+			// panic(err) FIXME: this panic will trigger in tests
+		}
 		c.wg.Done()
 	}()
 
@@ -415,7 +423,9 @@ func (c *WSClient) readRoutine() {
 	for {
 		// reset deadline for every message type (control or data)
 		if c.readWait > 0 {
-			c.conn.SetReadDeadline(time.Now().Add(c.readWait))
+			if err := c.conn.SetReadDeadline(time.Now().Add(c.readWait)); err != nil {
+				panic(err)
+			}
 		}
 		_, data, err := c.conn.ReadMessage()
 		if err != nil {

rpc/lib/client/ws_client_test.go

@@ -34,7 +34,11 @@ func (h *myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer func() {
+		if err := conn.Close(); err != nil {
+			panic(err)
+		}
+	}()
 	for {
 		messageType, _, err := conn.ReadMessage()
 		if err != nil {
@@ -43,7 +47,9 @@ func (h *myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 		h.mtx.RLock()
 		if h.closeConnAfterRead {
-			conn.Close()
+			if err := conn.Close(); err != nil {
+				panic(err)
+			}
 		}
 		h.mtx.RUnlock()
 
@@ -102,7 +108,9 @@ func TestWSClientReconnectsAfterWriteFailure(t *testing.T) {
 	go callWgDoneOnResult(t, c, &wg)
 
 	// hacky way to abort the connection before write
-	c.conn.Close()
+	if err := c.conn.Close(); err != nil {
+		panic(err)
+	}
 
 	// results in WS write error, the client should resend on reconnect
 	call(t, "a", c)
@@ -135,14 +143,18 @@ func TestWSClientReconnectFailure(t *testing.T) {
 	}()
 
 	// hacky way to abort the connection before write
-	c.conn.Close()
+	if err := c.conn.Close(); err != nil {
+		t.Error(err)
+	}
 	s.Close()
 
 	// results in WS write error
 	// provide timeout to avoid blocking
 	ctx, cancel := context.WithTimeout(context.Background(), wsCallTimeout)
 	defer cancel()
-	c.Call(ctx, "a", make(map[string]interface{}))
+	if err := c.Call(ctx, "a", make(map[string]interface{})); err != nil {
+		t.Error(err)
+	}
 
 	// expect to reconnect almost immediately
 	time.Sleep(10 * time.Millisecond)

rpc/lib/server/handlers.go

@@ -529,7 +529,9 @@ func (wsc *wsConnection) readRoutine() {
 			wsc.WriteRPCResponse(types.RPCInternalError("unknown", err))
 			go wsc.readRoutine()
 		} else {
-			wsc.baseConn.Close()
+			if err := wsc.baseConn.Close(); err != nil {
+				panic(err)
+			}
 		}
 	}()
 
@@ -543,7 +545,9 @@ func (wsc *wsConnection) readRoutine() {
 			return
 		default:
 			// reset deadline for every type of message (control or data)
-			wsc.baseConn.SetReadDeadline(time.Now().Add(wsc.readWait))
+			if err := wsc.baseConn.SetReadDeadline(time.Now().Add(wsc.readWait)); err != nil {
+				panic(err)
+			}
 			var in []byte
 			_, in, err := wsc.baseConn.ReadMessage()
 			if err != nil {
@@ -615,7 +619,9 @@ func (wsc *wsConnection) writeRoutine() {
 	pingTicker := time.NewTicker(wsc.pingPeriod)
 	defer func() {
 		pingTicker.Stop()
-		wsc.baseConn.Close()
+		if err := wsc.baseConn.Close(); err != nil {
+			panic(err)
+		}
 	}()
 
 	// https://github.com/gorilla/websocket/issues/97
@@ -713,7 +719,10 @@ func (wm *WebsocketManager) WebsocketHandler(w http.ResponseWriter, r *http.Requ
 	con := NewWSConnection(wsConn, wm.funcMap, wm.wsConnOptions...)
 	con.SetLogger(wm.logger.With("remote", wsConn.RemoteAddr()))
 	wm.logger.Info("New websocket connection", "remote", con.remoteAddr)
-	con.Start() // Blocking
+	_, err = con.Start() // Blocking
+	if err != nil {
+		panic(err)
+	}
 }
 
 // rpc.websocket
@@ -770,5 +779,8 @@ func writeListOfEndpoints(w http.ResponseWriter, r *http.Request, funcMap map[st
 	buf.WriteString("</body></html>")
 	w.Header().Set("Content-Type", "text/html")
 	w.WriteHeader(200)
-	w.Write(buf.Bytes())
+	_, err := w.Write(buf.Bytes())
+	if err != nil {
+		panic(err)
+	}
 }

rpc/lib/server/http_server.go

@@ -56,7 +56,10 @@ func WriteRPCResponseHTTPError(w http.ResponseWriter, httpCode int, res types.RP
 
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(httpCode)
-	w.Write(jsonBytes)
+	_, err = w.Write(jsonBytes)
+	if err != nil {
+		panic(err)
+	}
 }
 
 func WriteRPCResponseHTTP(w http.ResponseWriter, res types.RPCResponse) {
@@ -66,7 +69,10 @@ func WriteRPCResponseHTTP(w http.ResponseWriter, res types.RPCResponse) {
 	}
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(200)
-	w.Write(jsonBytes)
+	_, err = w.Write(jsonBytes)
+	if err != nil {
+		panic(err)
+	}
 }
 
 //-----------------------------------------------------------------------------

rpc/test/helpers.go

@@ -92,7 +92,10 @@ func GetGRPCClient() core_grpc.BroadcastAPIClient {
 // StartTendermint starts a test tendermint server in a go routine and returns when it is initialized
 func StartTendermint(app abci.Application) *nm.Node {
 	node := NewTendermint(app)
-	node.Start()
+	_, err := node.Start()
+	if err != nil {
+		panic(err)
+	}
 
 	// wait for rpc
 	waitForRPC()