move router to module New func

http-client.go

@@ -18,9 +18,9 @@ type HTTPClient struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.http.client",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 
-			return &HTTPClient{config: config}, nil
+			return &HTTPClient{config: config, router: router}, nil
 		},
 	})
 }
@@ -33,10 +33,6 @@ func (hc *HTTPClient) Type() string {
 	return hc.config.Type
 }
 
-func (hc *HTTPClient) RegisterRouter(router *Router) {
-	hc.router = router
-}
-
 func (hc *HTTPClient) Run() error {
 
 	hc.client = &http.Client{

http-server.go

@@ -23,7 +23,7 @@ type ResponseData struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.http.server",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 			params := config.Params
 			port, ok := params["port"]
 			if !ok {
@@ -36,7 +36,7 @@ func init() {
 				return nil, fmt.Errorf("net.http.server port must be uint16")
 			}
 
-			return &HTTPServer{Port: uint16(portNum), config: config}, nil
+			return &HTTPServer{Port: uint16(portNum), config: config, router: router}, nil
 		},
 	})
 }
@@ -49,10 +49,6 @@ func (hs *HTTPServer) Type() string {
 	return hs.config.Type
 }
 
-func (hs *HTTPServer) RegisterRouter(router *Router) {
-	hs.router = router
-}
-
 func (hs *HTTPServer) HandleDefault(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 

interval.go

@@ -18,7 +18,7 @@ type Interval struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "gen.interval",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 			params := config.Params
 
 			duration, ok := params["duration"]
@@ -32,7 +32,7 @@ func init() {
 				return nil, fmt.Errorf("gen.interval duration must be number")
 			}
 
-			return &Interval{Duration: uint32(durationNum), config: config}, nil
+			return &Interval{Duration: uint32(durationNum), config: config, router: router}, nil
 		},
 	})
 }
@@ -45,10 +45,6 @@ func (i *Interval) Type() string {
 	return i.config.Type
 }
 
-func (i *Interval) RegisterRouter(router *Router) {
-	i.router = router
-}
-
 func (i *Interval) Run() error {
 	ticker := time.NewTicker(time.Millisecond * time.Duration(i.Duration))
 	i.ticker = ticker

midi-client.go

@@ -23,7 +23,7 @@ func init() {
 	RegisterModule(ModuleRegistration{
 		//TODO(jwetzell): find a better namespace than "misc"
 		Type: "misc.midi.client",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 			params := config.Params
 			input, ok := params["input"]
 
@@ -49,7 +49,7 @@ func init() {
 				return nil, fmt.Errorf("misc.midi.client output must be a string")
 			}
 
-			return &MIDIClient{config: config, InputPort: inputString, OutputPort: outputString}, nil
+			return &MIDIClient{config: config, InputPort: inputString, OutputPort: outputString, router: router}, nil
 		},
 	})
 }
@@ -62,10 +62,6 @@ func (mc *MIDIClient) Type() string {
 	return mc.config.Type
 }
 
-func (mc *MIDIClient) RegisterRouter(router *Router) {
-	mc.router = router
-}
-
 func (mc *MIDIClient) Run() error {
 	defer midi.CloseDriver()
 

module.go

@@ -16,14 +16,13 @@ type ModuleError struct {
 type Module interface {
 	Id() string
 	Type() string
-	RegisterRouter(*Router)
 	Run() error
 	Output(any) error
 }
 
 type ModuleRegistration struct {
 	Type string `json:"type"`
-	New  func(config.ModuleConfig) (Module, error)
+	New  func(config.ModuleConfig, *Router) (Module, error)
 }
 
 func RegisterModule(mod ModuleRegistration) {

mqtt-client.go

@@ -21,7 +21,7 @@ type MQTTClient struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.mqtt.client",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 			params := config.Params
 			broker, ok := params["broker"]
 
@@ -59,7 +59,7 @@ func init() {
 				return nil, fmt.Errorf("net.mqtt.client clientId must be string")
 			}
 
-			return &MQTTClient{config: config, Broker: brokerString, Topic: topicString, ClientID: clientIdString}, nil
+			return &MQTTClient{config: config, Broker: brokerString, Topic: topicString, ClientID: clientIdString, router: router}, nil
 		},
 	})
 }
@@ -72,10 +72,6 @@ func (mc *MQTTClient) Type() string {
 	return mc.config.Type
 }
 
-func (mc *MQTTClient) RegisterRouter(router *Router) {
-	mc.router = router
-}
-
 func (mc *MQTTClient) Run() error {
 	opts := mqtt.NewClientOptions()
 	opts.AddBroker(mc.Broker)

nats-client.go

@@ -20,7 +20,7 @@ type NATSClient struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.nats.client",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 			params := config.Params
 			url, ok := params["url"]
 
@@ -46,7 +46,7 @@ func init() {
 				return nil, fmt.Errorf("net.nats.client subject must be string")
 			}
 
-			return &NATSClient{config: config, URL: urlString, Subject: subjectString}, nil
+			return &NATSClient{config: config, URL: urlString, Subject: subjectString, router: router}, nil
 		},
 	})
 }
@@ -59,10 +59,6 @@ func (nc *NATSClient) Type() string {
 	return nc.config.Type
 }
 
-func (nc *NATSClient) RegisterRouter(router *Router) {
-	nc.router = router
-}
-
 func (nc *NATSClient) Run() error {
 	client, err := nats.Connect(nc.URL, nats.RetryOnFailedConnect(true))
 

psn-client.go

@@ -20,9 +20,9 @@ type PSNClient struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.psn.client",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 
-			return &PSNClient{config: config, decoder: psn.NewDecoder()}, nil
+			return &PSNClient{config: config, decoder: psn.NewDecoder(), router: router}, nil
 		},
 	})
 }
@@ -35,10 +35,6 @@ func (pc *PSNClient) Type() string {
 	return pc.config.Type
 }
 
-func (pc *PSNClient) RegisterRouter(router *Router) {
-	pc.router = router
-}
-
 func (pc *PSNClient) Run() error {
 
 	addr, err := net.ResolveUDPAddr("udp", "236.10.10.10:56565")

router.go

@@ -75,7 +75,7 @@ func NewRouter(ctx context.Context, config config.Config) (*Router, []ModuleErro
 		}
 
 		if !moduleInstanceExists {
-			moduleInstance, err := moduleInfo.New(moduleDecl)
+			moduleInstance, err := moduleInfo.New(moduleDecl, &router)
 			if err != nil {
 				if moduleErrors == nil {
 					moduleErrors = []ModuleError{}
@@ -110,18 +110,12 @@ func NewRouter(ctx context.Context, config config.Config) (*Router, []ModuleErro
 		router.RouteInstances = append(router.RouteInstances, route)
 	}
 
-	for _, moduleInstance := range router.ModuleInstances {
-		slog.Debug("registering router with module", "id", moduleInstance.Id())
-		moduleInstance.RegisterRouter(&router)
-	}
-
 	return &router, moduleErrors, routeErrors
 }
 
 func (r *Router) Run() {
 	slog.Info("running router")
 	for _, moduleInstance := range r.ModuleInstances {
-		moduleInstance.RegisterRouter(r)
 		r.moduleWait.Add(1)
 		go func() {
 			err := moduleInstance.Run()

serial-client.go

@@ -25,7 +25,7 @@ func init() {
 	RegisterModule(ModuleRegistration{
 		//TODO(jwetzell): find a better namespace than "misc"
 		Type: "misc.serial.client",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 			params := config.Params
 			port, ok := params["port"]
 
@@ -70,7 +70,7 @@ func init() {
 				BaudRate: int(baudRateNum),
 			}
 
-			return &SerialClient{config: config, Port: portString, Framer: framer, Mode: &mode}, nil
+			return &SerialClient{config: config, Port: portString, Framer: framer, Mode: &mode, router: router}, nil
 		},
 	})
 }
@@ -83,10 +83,6 @@ func (mc *SerialClient) Type() string {
 	return mc.config.Type
 }
 
-func (mc *SerialClient) RegisterRouter(router *Router) {
-	mc.router = router
-}
-
 func (mc *SerialClient) SetupPort() error {
 
 	port, err := serial.Open(mc.Port, mc.Mode)

tcp-client.go

@@ -21,7 +21,7 @@ type TCPClient struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.tcp.client",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 			params := config.Params
 			host, ok := params["host"]
 
@@ -68,7 +68,7 @@ func init() {
 				return nil, err
 			}
 
-			return &TCPClient{framer: framer, Addr: addr, config: config}, nil
+			return &TCPClient{framer: framer, Addr: addr, config: config, router: router}, nil
 		},
 	})
 }
@@ -81,10 +81,6 @@ func (tc *TCPClient) Type() string {
 	return tc.config.Type
 }
 
-func (tc *TCPClient) RegisterRouter(router *Router) {
-	tc.router = router
-}
-
 func (tc *TCPClient) Run() error {
 
 	// TODO(jwetzell): shutdown with router.Context properly

tcp-server.go

@@ -28,7 +28,7 @@ type TCPServer struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.tcp.server",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 			params := config.Params
 			port, ok := params["port"]
 			if !ok {
@@ -76,7 +76,7 @@ func init() {
 				return nil, err
 			}
 
-			return &TCPServer{Framer: framer, Addr: addr, config: config, quit: make(chan interface{})}, nil
+			return &TCPServer{Framer: framer, Addr: addr, config: config, quit: make(chan interface{}), router: router}, nil
 		},
 	})
 }
@@ -89,10 +89,6 @@ func (ts *TCPServer) Type() string {
 	return ts.config.Type
 }
 
-func (ts *TCPServer) RegisterRouter(router *Router) {
-	ts.router = router
-}
-
 func (ts *TCPServer) handleClient(client *net.TCPConn) {
 	ts.connectionsMu.Lock()
 	ts.connections = append(ts.connections, client)

timer.go

@@ -18,7 +18,7 @@ type Timer struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "gen.timer",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 			params := config.Params
 
 			duration, ok := params["duration"]
@@ -32,7 +32,7 @@ func init() {
 				return nil, fmt.Errorf("gen.timer duration must be a number")
 			}
 
-			return &Timer{Duration: uint32(durationNum), config: config}, nil
+			return &Timer{Duration: uint32(durationNum), config: config, router: router}, nil
 		},
 	})
 }
@@ -45,10 +45,6 @@ func (t *Timer) Type() string {
 	return t.config.Type
 }
 
-func (t *Timer) RegisterRouter(router *Router) {
-	t.router = router
-}
-
 func (t *Timer) Run() error {
 	t.timer = time.NewTimer(time.Millisecond * time.Duration(t.Duration))
 	defer t.timer.Stop()

udp-client.go

@@ -19,7 +19,7 @@ type UDPClient struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.udp.client",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 			params := config.Params
 			host, ok := params["host"]
 
@@ -49,7 +49,7 @@ func init() {
 				return nil, err
 			}
 
-			return &UDPClient{Addr: addr, config: config}, nil
+			return &UDPClient{Addr: addr, config: config, router: router}, nil
 		},
 	})
 }
@@ -62,10 +62,6 @@ func (uc *UDPClient) Type() string {
 	return uc.config.Type
 }
 
-func (uc *UDPClient) RegisterRouter(router *Router) {
-	uc.router = router
-}
-
 func (uc *UDPClient) Run() error {
 
 	client, err := net.DialUDP("udp", nil, uc.Addr)

udp-multicast.go

@@ -19,7 +19,7 @@ type UDPMulticast struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.udp.multicast",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 			params := config.Params
 			ip, ok := params["ip"]
 
@@ -48,7 +48,7 @@ func init() {
 			if err != nil {
 				return nil, err
 			}
-			return &UDPMulticast{config: config, Addr: addr}, nil
+			return &UDPMulticast{config: config, Addr: addr, router: router}, nil
 		},
 	})
 }
@@ -61,10 +61,6 @@ func (um *UDPMulticast) Type() string {
 	return um.config.Type
 }
 
-func (um *UDPMulticast) RegisterRouter(router *Router) {
-	um.router = router
-}
-
 func (um *UDPMulticast) Run() error {
 
 	client, err := net.ListenMulticastUDP("udp", nil, um.Addr)

udp-server.go

@@ -19,7 +19,7 @@ type UDPServer struct {
 func init() {
 	RegisterModule(ModuleRegistration{
 		Type: "net.udp.server",
-		New: func(config config.ModuleConfig) (Module, error) {
+		New: func(config config.ModuleConfig, router *Router) (Module, error) {
 			params := config.Params
 			port, ok := params["port"]
 			if !ok {
@@ -50,7 +50,7 @@ func init() {
 				log.Fatalf("error resolving UDP address: %v", err)
 			}
 
-			return &UDPServer{Addr: addr, config: config}, nil
+			return &UDPServer{Addr: addr, config: config, router: router}, nil
 		},
 	})
 }
@@ -63,10 +63,6 @@ func (us *UDPServer) Type() string {
 	return us.config.Id
 }
 
-func (us *UDPServer) RegisterRouter(router *Router) {
-	us.router = router
-}
-
 func (us *UDPServer) Run() error {
 
 	listener, err := net.ListenUDP("udp", us.Addr)