feat: start mockda server only if it's not running already (#1882)

Closes [#1818](#1818)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **New Features**
	- Enhanced error handling for starting the mock DA server.
	- Added mock server capabilities for improved testing.

- **Bug Fixes**
- Improved robustness in handling scenarios where the mock DA server is
already running, allowing the application to continue without crashing.
- Expanded error handling scenarios in testing to cover various
outcomes, including server start and invalid URL handling.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
Co-authored-by: Matthew Sevey <[email protected]>
Co-authored-by: Manav Aggarwal <[email protected]>

Author: 4 people

cmd/rollkit/commands/run_node.go

@@ -2,11 +2,13 @@ package commands
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"math/rand"
 	"net"
 	"net/url"
 	"os"
+	"syscall"
 	"time"
 
 	cmtcmd "github.com/cometbft/cometbft/cmd/cometbft/commands"
@@ -24,6 +26,7 @@ import (
 	"github.com/mitchellh/mapstructure"
 	"google.golang.org/grpc"
 
+	"github.com/rollkit/go-da"
 	proxy "github.com/rollkit/go-da/proxy/jsonrpc"
 	goDATest "github.com/rollkit/go-da/test"
 	seqGRPC "github.com/rollkit/go-sequencing/proxy/grpc"
@@ -47,6 +50,8 @@ var (
 
 	// initialize the logger with the cometBFT defaults
 	logger = cometlog.NewTMLogger(cometlog.NewSyncWriter(os.Stdout))
+
+	errDAServerAlreadyRunning = errors.New("DA server already running")
 )
 
 // MockSequencerAddress is a sample address used by the mock sequencer
@@ -127,12 +132,16 @@ func NewRunNodeCmd() *cobra.Command {
 
 			// use mock jsonrpc da server by default
 			if !cmd.Flags().Lookup("rollkit.da_address").Changed {
-				srv, err := startMockDAServJSONRPC(cmd.Context())
-				if err != nil {
+				srv, err := startMockDAServJSONRPC(cmd.Context(), nodeConfig.DAAddress, proxy.NewServer)
+				if err != nil && !errors.Is(err, errDAServerAlreadyRunning) {
 					return fmt.Errorf("failed to launch mock da server: %w", err)
 				}
 				// nolint:errcheck,gosec
-				defer func() { srv.Stop(cmd.Context()) }()
+				defer func() {
+					if srv != nil {
+						srv.Stop(cmd.Context())
+					}
+				}()
 			}
 
 			// use mock grpc sequencer server by default
@@ -236,13 +245,27 @@ func addNodeFlags(cmd *cobra.Command) {
 }
 
 // startMockDAServJSONRPC starts a mock JSONRPC server
-func startMockDAServJSONRPC(ctx context.Context) (*proxy.Server, error) {
-	addr, _ := url.Parse(nodeConfig.DAAddress)
-	srv := proxy.NewServer(addr.Hostname(), addr.Port(), goDATest.NewDummyDA())
-	err := srv.Start(ctx)
+func startMockDAServJSONRPC(
+	ctx context.Context,
+	daAddress string,
+	newServer func(string, string, da.DA) *proxy.Server,
+) (*proxy.Server, error) {
+	addr, err := url.Parse(daAddress)
 	if err != nil {
 		return nil, err
 	}
+
+	srv := newServer(addr.Hostname(), addr.Port(), goDATest.NewDummyDA())
+	if err := srv.Start(ctx); err != nil {
+		if errors.Is(err, syscall.EADDRINUSE) {
+			logger.Info("DA server is already running", "address", nodeConfig.DAAddress)
+			return nil, errDAServerAlreadyRunning
+		}
+		return nil, err
+	}
+
+	logger.Info("Starting mock DA server", "address", nodeConfig.DAAddress)
+
 	return srv, nil
 }
 

cmd/rollkit/commands/run_node_test.go

@@ -1,9 +1,18 @@
 package commands
 
 import (
+	"context"
+	"errors"
+	"net/url"
 	"reflect"
+	"syscall"
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/rollkit/go-da"
+	proxy "github.com/rollkit/go-da/proxy/jsonrpc"
 )
 
 func TestParseFlags(t *testing.T) {
@@ -133,3 +142,83 @@ func TestAggregatorFlagInvariants(t *testing.T) {
 		}
 	}
 }
+
+// MockServer wraps proxy.Server to allow us to control its behavior in tests
+type MockServer struct {
+	*proxy.Server
+	StartFunc func(context.Context) error
+	StopFunc  func(context.Context) error
+}
+
+func (m *MockServer) Start(ctx context.Context) error {
+	if m.StartFunc != nil {
+		return m.StartFunc(ctx)
+	}
+	return m.Server.Start(ctx)
+}
+
+func (m *MockServer) Stop(ctx context.Context) error {
+	if m.StopFunc != nil {
+		return m.StopFunc(ctx)
+	}
+	return m.Server.Stop(ctx)
+}
+
+func TestStartMockDAServJSONRPC(t *testing.T) {
+	tests := []struct {
+		name          string
+		daAddress     string
+		mockServerErr error
+		expectedErr   error
+	}{
+		{
+			name:          "Success",
+			daAddress:     "http://localhost:26657",
+			mockServerErr: nil,
+			expectedErr:   nil,
+		},
+		{
+			name:          "Invalid URL",
+			daAddress:     "://invalid",
+			mockServerErr: nil,
+			expectedErr:   &url.Error{},
+		},
+		{
+			name:          "Server Already Running",
+			daAddress:     "http://localhost:26657",
+			mockServerErr: syscall.EADDRINUSE,
+			expectedErr:   errDAServerAlreadyRunning,
+		},
+		{
+			name:          "Other Server Error",
+			daAddress:     "http://localhost:26657",
+			mockServerErr: errors.New("other error"),
+			expectedErr:   errors.New("other error"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			newServerFunc := func(hostname, port string, da da.DA) *proxy.Server {
+				mockServer := &MockServer{
+					Server: proxy.NewServer(hostname, port, da),
+					StartFunc: func(ctx context.Context) error {
+						return tt.mockServerErr
+					},
+				}
+				return mockServer.Server
+			}
+
+			srv, err := startMockDAServJSONRPC(context.Background(), tt.daAddress, newServerFunc)
+
+			if tt.expectedErr != nil {
+				assert.Error(t, err)
+				assert.IsType(t, tt.expectedErr, err)
+				assert.Nil(t, srv)
+			} else {
+				assert.NoError(t, err)
+				assert.NotNil(t, srv)
+			}
+		})
+	}
+}