refactor: use WaitExecControllerRunningTyped over manual type assertions

Replace WaitExecControllerRunning + type assertion pattern with the
generic WaitExecControllerRunningTyped across all call sites.

Signed-off-by: Christian Stewart <christian@aperture.us>

Author: paralin

daemon/api/api_accept.go

@@ -24,12 +24,11 @@ func (a *API) AcceptStream(serv stream_api.SRPCStreamService_AcceptStreamStream)
 	dir := resolver.NewLoadControllerWithConfig(conf)
 
 	// wait until it's ready
-	val, _, valRef, err := loader.WaitExecControllerRunning(ctx, a.bus, dir, nil)
+	ctrl, _, ctrlRef, err := loader.WaitExecControllerRunningTyped[*stream_api_accept.Controller](ctx, a.bus, dir, nil)
 	if err != nil {
 		return err
 	}
-	defer valRef.Release()
+	defer ctrlRef.Release()
 
-	ctrl := val.(*stream_api_accept.Controller)
 	return ctrl.AttachRPC(stream_api.NewAcceptServerRPC(serv))
 }

examples/mesh-chat/main.go

@@ -190,14 +190,14 @@ func run(listenAddr, dialAddr, keyPath string) error {
 	}
 
 	// Start the UDP transport.
-	udpCtrl, _, udpRef, err := loader.WaitExecControllerRunning(ctx, b,
+	tc, _, udpRef, err := loader.WaitExecControllerRunningTyped[*tptc.Controller](ctx, b,
 		resolver.NewLoadControllerWithConfig(&udptpt.Config{ListenAddr: listenAddr}), nil)
 	if err != nil {
 		return err
 	}
 	defer udpRef.Release()
 
-	tpt, _ := udpCtrl.(*tptc.Controller).GetTransport(ctx)
+	tpt, _ := tc.GetTransport(ctx)
 	udp := tpt.(*udptpt.UDP)
 
 	// Dial the remote peer if specified.

examples/udp-link/main.go

@@ -92,7 +92,7 @@ func execute() error {
 	defer hr2.Release()
 
 	// Execute the UDP transport on the first daemon.
-	tptc1, _, udpRef1, err := loader.WaitExecControllerRunning(
+	tc1, _, udpRef1, err := loader.WaitExecControllerRunningTyped[*tptc.Controller](
 		ctx,
 		bus1,
 		resolver.NewLoadControllerWithConfig(&udptpt.Config{
@@ -105,10 +105,10 @@ func execute() error {
 	}
 	defer udpRef1.Release()
 	le.Info("UDP listening on: :5553")
-	tpt1, _ := tptc1.(*tptc.Controller).GetTransport(ctx)
+	tpt1, _ := tc1.GetTransport(ctx)
 
 	// Execute the UDP transport on the second daemon.
-	tptc2, _, udpRef2, err := loader.WaitExecControllerRunning(
+	tc2, _, udpRef2, err := loader.WaitExecControllerRunningTyped[*tptc.Controller](
 		ctx,
 		bus2,
 		resolver.NewLoadControllerWithConfig(&udptpt.Config{
@@ -121,7 +121,7 @@ func execute() error {
 	}
 	defer udpRef2.Release()
 	le.Info("UDP listening on: :5554")
-	_, _ = tptc2.(*tptc.Controller).GetTransport(ctx)
+	_, _ = tc2.GetTransport(ctx)
 
 	tpt1.(*udptpt.UDP).DialPeer(ctx, p2, (&net.UDPAddr{
 		IP:   net.IP{127, 0, 0, 1},

link/hold-open/hold_open_test.go

@@ -48,7 +48,7 @@ func execPeer(ctx context.Context, t *testing.T, tb *testbed.Testbed, conf *inpr
 	}
 	conf.TransportPeerId = peerId.String()
 
-	tpci1, _, tp1Ref, err := loader.WaitExecControllerRunning(
+	tpc1, _, tp1Ref, err := loader.WaitExecControllerRunningTyped[*transport_controller.Controller](
 		ctx,
 		tb.Bus,
 		resolver.NewLoadControllerWithConfig(conf),
@@ -57,7 +57,6 @@ func execPeer(ctx context.Context, t *testing.T, tb *testbed.Testbed, conf *inpr
 	if err != nil {
 		t.Fatal(err.Error())
 	}
-	tpc1 := tpci1.(*transport_controller.Controller)
 	tpt1, err := tpc1.GetTransport(ctx)
 	if err != nil {
 		t.Fatal(err.Error())