refactor: implement shared network architecture for service coordination and streamline startup process

Author: grishy

AGENTS.md

@@ -52,11 +52,55 @@ The bundle integrates four Anytype sync services into a single binary:
 
 ### Critical: Service Startup Order
 
-**ORDER MATTERS!** Services must start in this exact order (`cmd/start.go:83-87`):
-1. **Coordinator** - provides network coordination for all other services
-2. **Consensus, File, Sync** - can start in any order (all depend on coordinator)
+**ORDER MATTERS!** Services must start in this exact order:
+1. **Coordinator** - MUST start first (provides shared network stack for all services)
+2. **Consensus, File, Sync** - start after coordinator (reuse its network stack)
 
-If coordinator doesn't start first, other services will fail to connect.
+The coordinator creates the network infrastructure (TCP/UDP listeners, DRPC mux, connection pool).
+Other services extract and reuse these components via `SharedNetworkManager`.
+
+### Shared Network Architecture
+
+**Key Innovation**: Instead of each service creating its own network stack, all services share ONE network infrastructure:
+
+```
+Coordinator App (Primary)
+├── Creates network stack
+│   ├── yamux (TCP listener on port 33010)
+│   ├── quic (UDP listener on port 33020)
+│   ├── server (DRPC multiplexer)
+│   ├── pool (connection pool)
+│   └── peerservice (peer management)
+└── Registers CoordinatorService RPC handlers
+
+SharedNetworkManager
+├── Extracts network components from coordinator
+└── Provides them to secondary services
+
+Secondary Apps (Consensus, FileNode, Sync)
+├── Receive shared network via SharedNetworkManager
+├── Register their own RPC handlers to shared DRPC mux
+└── Service-specific components only
+```
+
+**Benefits**:
+- Single port pair (33010 TCP, 33020 UDP) instead of 8 ports
+- Shared connection pool - all services reuse peer connections
+- Reduced memory usage - one network stack instead of four
+- True service bundling
+
+**Implementation** (`lightnode/sharednetwork.go`):
+- `ExtractSharedNetwork(app)` - extracts network components from coordinator
+- `RegisterToApp(app)` - injects shared components into secondary services
+
+**Startup Flow** (`cmd/start.go`):
+1. Create coordinator app (full network stack)
+2. Start coordinator
+3. Extract shared network via `ExtractSharedNetwork(coordinatorApp)`
+4. Create secondary apps with `sharedNet` parameter
+5. Start secondary apps (they reuse coordinator's network)
+
+**Backward Compatibility**: Services can still run standalone by passing `nil` for `sharedNet` parameter.
 
 ### Key Components
 
@@ -80,8 +124,17 @@ If coordinator doesn't start first, other services will fail to connect.
 
 ## Service Port Mapping
 
-- TCP ports: 33010-33013 (various sync services)
-- UDP ports: 33020-33023 (QUIC transport)
+**New Shared Network Architecture** (default):
+- TCP port: 33010 (ALL services share ONE listener)
+- UDP port: 33020 (ALL services share ONE listener)
+
+All services (coordinator, consensus, filenode, sync) register their RPC handlers to a single DRPC multiplexer:
+- Coordinator: `/CoordinatorService/*`
+- Consensus: `/ConsensusService/*`
+- FileNode: `/FileService/*`
+- SyncNode: `/SpaceSyncService/*`
+
+These method namespaces don't conflict, so they coexist in one mux.
 
 ## Configuration Patterns
 

cmd/start.go

@@ -77,16 +77,19 @@ func startAction(ctx context.Context) cli.ActionFunc {
 			}
 		}
 
-		// Initialize nodes. Coordinator MUST start first - others depend on it.
+		// Create bundle with all services (coordinator, consensus, filenode, sync)
 		cfgNodes := bundleCfg.NodeConfigs()
+		bundle := lightnode.NewBundle(cfgNodes)
 
+		// Create node list for startup
 		apps := []node{
-			{name: "coordinator", app: lightnode.NewCoordinatorApp(cfgNodes.Coordinator)},
-			{name: "consensus", app: lightnode.NewConsensusApp(cfgNodes.Consensus)},
-			{name: "filenode", app: lightnode.NewFileNodeApp(cfgNodes.Filenode, cfgNodes.FilenodeStorePath)},
-			{name: "sync", app: lightnode.NewSyncApp(cfgNodes.Sync)},
+			{name: "coordinator", app: bundle.Coordinator},
+			{name: "consensus", app: bundle.Consensus},
+			{name: "filenode", app: bundle.FileNode},
+			{name: "sync", app: bundle.Sync},
 		}
 
+		// Start all services
 		if err := startServices(ctx, apps); err != nil {
 			return err
 		}

config/bundle.go

@@ -163,22 +163,22 @@ func newBundleConfig(cfg *CreateOptions) *Config {
 			},
 			Consensus: NodeConsensus{
 				NodeShared: NodeShared{
-					ListenTCPAddr: "0.0.0.0:33011",
-					ListenUDPAddr: "0.0.0.0:33021",
+					ListenTCPAddr: "0.0.0.0:33010",
+					ListenUDPAddr: "0.0.0.0:33020",
 				},
 				MongoConnect:  mongoConsensusURI.String(),
 				MongoDatabase: "consensus",
 			},
 			Tree: Tree{
 				NodeShared{
-					ListenTCPAddr: "0.0.0.0:33012",
-					ListenUDPAddr: "0.0.0.0:33022",
+					ListenTCPAddr: "0.0.0.0:33010",
+					ListenUDPAddr: "0.0.0.0:33020",
 				},
 			},
 			File: NodeFile{
 				NodeShared: NodeShared{
-					ListenTCPAddr: "0.0.0.0:33013",
-					ListenUDPAddr: "0.0.0.0:33023",
+					ListenTCPAddr: "0.0.0.0:33010",
+					ListenUDPAddr: "0.0.0.0:33020",
 				},
 				RedisConnect: cfg.RedisURI,
 			},

config/client.go

@@ -50,26 +50,8 @@ func (bc *Config) YamlClientConfig() ([]byte, error) {
 				Addresses: bc.convertExternalAddrs(bc.Nodes.Coordinator.NodeShared),
 				Types: []nodeconf.NodeType{
 					nodeconf.NodeTypeCoordinator,
-				},
-			},
-			{
-				PeerId:    bc.Accounts.Consensus.PeerId,
-				Addresses: bc.convertExternalAddrs(bc.Nodes.Consensus.NodeShared),
-				Types: []nodeconf.NodeType{
 					nodeconf.NodeTypeConsensus,
-				},
-			},
-			{
-				PeerId:    bc.Accounts.Tree.PeerId,
-				Addresses: bc.convertExternalAddrs(bc.Nodes.Tree.NodeShared),
-				Types: []nodeconf.NodeType{
 					nodeconf.NodeTypeTree,
-				},
-			},
-			{
-				PeerId:    bc.Accounts.File.PeerId,
-				Addresses: bc.convertExternalAddrs(bc.Nodes.File.NodeShared),
-				Types: []nodeconf.NodeType{
 					nodeconf.NodeTypeFile,
 				},
 			},

config/convert.go

@@ -196,22 +196,12 @@ func (bc *Config) networkCfg() nodeconf.Configuration {
 			{
 				PeerId:    bc.Accounts.Coordinator.PeerId,
 				Addresses: convertListenToConnect(bc.Nodes.Coordinator.NodeShared),
-				Types:     []nodeconf.NodeType{nodeconf.NodeTypeCoordinator},
-			},
-			{
-				PeerId:    bc.Accounts.Consensus.PeerId,
-				Addresses: convertListenToConnect(bc.Nodes.Consensus.NodeShared),
-				Types:     []nodeconf.NodeType{nodeconf.NodeTypeConsensus},
-			},
-			{
-				PeerId:    bc.Accounts.Tree.PeerId,
-				Addresses: convertListenToConnect(bc.Nodes.Tree.NodeShared),
-				Types:     []nodeconf.NodeType{nodeconf.NodeTypeTree},
-			},
-			{
-				PeerId:    bc.Accounts.File.PeerId,
-				Addresses: convertListenToConnect(bc.Nodes.File.NodeShared),
-				Types:     []nodeconf.NodeType{nodeconf.NodeTypeFile},
+				Types: []nodeconf.NodeType{
+					nodeconf.NodeTypeCoordinator,
+					nodeconf.NodeTypeConsensus,
+					nodeconf.NodeTypeTree,
+					nodeconf.NodeTypeFile,
+				},
 			},
 		},
 		CreationTime: time.Now(),