service#Start, service#Stop signatures were changed

See https://github.com/tendermint/tmlibs/issues/45

rpc/client/event_test.go

@@ -27,9 +27,8 @@ func TestHeaderEvents(t *testing.T) {
 		// start for this test it if it wasn't already running
 		if !c.IsRunning() {
 			// if so, then we start it, listen, and stop it.
-			st, err := c.Start()
+			err := c.Start()
 			require.Nil(err, "%d: %+v", i, err)
-			require.True(st, "%d", i)
 			defer c.Stop()
 		}
 
@@ -48,9 +47,8 @@ func TestBlockEvents(t *testing.T) {
 		// start for this test it if it wasn't already running
 		if !c.IsRunning() {
 			// if so, then we start it, listen, and stop it.
-			st, err := c.Start()
+			err := c.Start()
 			require.Nil(err, "%d: %+v", i, err)
-			require.True(st, "%d", i)
 			defer c.Stop()
 		}
 
@@ -80,9 +78,8 @@ func TestTxEventsSentWithBroadcastTxAsync(t *testing.T) {
 		// start for this test it if it wasn't already running
 		if !c.IsRunning() {
 			// if so, then we start it, listen, and stop it.
-			st, err := c.Start()
+			err := c.Start()
 			require.Nil(err, "%d: %+v", i, err)
-			require.True(st, "%d", i)
 			defer c.Stop()
 		}
 
@@ -113,9 +110,8 @@ func TestTxEventsSentWithBroadcastTxSync(t *testing.T) {
 		// start for this test it if it wasn't already running
 		if !c.IsRunning() {
 			// if so, then we start it, listen, and stop it.
-			st, err := c.Start()
+			err := c.Start()
 			require.Nil(err, "%d: %+v", i, err)
-			require.True(st, "%d", i)
 			defer c.Stop()
 		}
 

rpc/client/httpclient.go

@@ -215,26 +215,26 @@ func newWSEvents(remote, endpoint string) *WSEvents {
 // Start is the only way I could think the extend OnStart from
 // events.eventSwitch.  If only it wasn't private...
 // BaseService.Start -> eventSwitch.OnStart -> WSEvents.Start
-func (w *WSEvents) Start() (bool, error) {
+func (w *WSEvents) Start() error {
 	ws := rpcclient.NewWSClient(w.remote, w.endpoint, rpcclient.OnReconnect(func() {
 		w.redoSubscriptions()
 	}))
-	started, err := ws.Start()
+	err := ws.Start()
 	if err == nil {
 		w.ws = ws
 		go w.eventListener()
 	}
-	return started, errors.Wrap(err, "StartWSEvent")
+	return err
 }
 
 // Stop wraps the BaseService/eventSwitch actions as Start does
-func (w *WSEvents) Stop() bool {
+func (w *WSEvents) Stop() error {
 	// send a message to quit to stop the eventListener
 	w.quit <- true
 	<-w.done
 	w.ws.Stop()
 	w.ws = nil
-	return true
+	return nil
 }
 
 func (w *WSEvents) Subscribe(ctx context.Context, query string, out chan<- interface{}) error {

rpc/lib/client/ws_client.go

@@ -47,10 +47,10 @@ type WSClient struct {
 	onReconnect func()
 
 	// internal channels
-	send             chan types.RPCRequest // user requests
-	backlog          chan types.RPCRequest // stores a single user request received during a conn failure
-	reconnectAfter   chan error            // reconnect requests
-	readRoutineQuit  chan struct{}         // a way for readRoutine to close writeRoutine
+	send            chan types.RPCRequest // user requests
+	backlog         chan types.RPCRequest // stores a single user request received during a conn failure
+	reconnectAfter  chan error            // reconnect requests
+	readRoutineQuit chan struct{}         // a way for readRoutine to close writeRoutine
 
 	wg sync.WaitGroup
 
@@ -168,12 +168,12 @@ func (c *WSClient) OnStop() {}
 
 // Stop overrides cmn.Service#Stop. There is no other way to wait until Quit
 // channel is closed.
-func (c *WSClient) Stop() bool {
-	success := c.BaseService.Stop()
+func (c *WSClient) Stop() error {
+	err := c.BaseService.Stop()
 	// only close user-facing channels when we can't write to them
 	c.wg.Wait()
 	close(c.ResponsesCh)
-	return success
+	return err
 }
 
 // IsReconnecting returns true if the client is reconnecting right now.

rpc/lib/client/ws_client_test.go

@@ -196,7 +196,7 @@ func TestNotBlockingOnStop(t *testing.T) {
 
 func startClient(t *testing.T, addr net.Addr) *WSClient {
 	c := NewWSClient(addr.String(), "/websocket")
-	_, err := c.Start()
+	err := c.Start()
 	require.Nil(t, err)
 	c.SetLogger(log.TestingLogger())
 	return c

rpc/lib/rpc_test.go

@@ -278,7 +278,7 @@ func TestServersAndClientsBasic(t *testing.T) {
 
 		cl3 := client.NewWSClient(addr, websocketEndpoint)
 		cl3.SetLogger(log.TestingLogger())
-		_, err := cl3.Start()
+		err := cl3.Start()
 		require.Nil(t, err)
 		fmt.Printf("=== testing server on %s using %v client", addr, cl3)
 		testWithWSClient(t, cl3)
@@ -307,7 +307,7 @@ func TestQuotedStringArg(t *testing.T) {
 func TestWSNewWSRPCFunc(t *testing.T) {
 	cl := client.NewWSClient(tcpAddr, websocketEndpoint)
 	cl.SetLogger(log.TestingLogger())
-	_, err := cl.Start()
+	err := cl.Start()
 	require.Nil(t, err)
 	defer cl.Stop()
 
@@ -332,7 +332,7 @@ func TestWSNewWSRPCFunc(t *testing.T) {
 func TestWSHandlesArrayParams(t *testing.T) {
 	cl := client.NewWSClient(tcpAddr, websocketEndpoint)
 	cl.SetLogger(log.TestingLogger())
-	_, err := cl.Start()
+	err := cl.Start()
 	require.Nil(t, err)
 	defer cl.Stop()
 
@@ -357,7 +357,7 @@ func TestWSHandlesArrayParams(t *testing.T) {
 func TestWSClientPingPong(t *testing.T) {
 	cl := client.NewWSClient(tcpAddr, websocketEndpoint)
 	cl.SetLogger(log.TestingLogger())
-	_, err := cl.Start()
+	err := cl.Start()
 	require.Nil(t, err)
 	defer cl.Stop()
 

rpc/lib/server/handlers.go

@@ -723,7 +723,7 @@ 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)
-	_, err = con.Start() // Blocking
+	err = con.Start() // Blocking
 	if err != nil {
 		wm.logger.Error("Error starting connection", "err", err)
 	}

rpc/test/helpers.go

@@ -92,7 +92,7 @@ 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)
-	_, err := node.Start()
+	err := node.Start()
 	if err != nil {
 		panic(err)
 	}