condense provide and providepeer

server_routers.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"errors"
+	"math"
 	"sync"
 	"time"
 
@@ -217,6 +218,57 @@ func (mi *manyIter[T]) Close() error {
 	return err
 }
 
+func (r parallelRouter) Provide(ctx context.Context, req *server.ProvideRequest) (time.Duration, error) {
+	return provide(ctx, r.routers, func(ctx context.Context, r router) (time.Duration, error) {
+		return r.Provide(ctx, req)
+	})
+}
+
+func (r parallelRouter) ProvidePeer(ctx context.Context, req *server.ProvidePeerRequest) (time.Duration, error) {
+	return provide(ctx, r.routers, func(ctx context.Context, r router) (time.Duration, error) {
+		return r.ProvidePeer(ctx, req)
+	})
+}
+
+func provide(ctx context.Context, routers []router, call func(context.Context, router) (time.Duration, error)) (time.Duration, error) {
+	switch len(routers) {
+	case 0:
+		return 0, nil
+	case 1:
+		return call(ctx, routers[0])
+	}
+
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	var wg sync.WaitGroup
+	resultsTTL := make([]time.Duration, len(routers))
+	resultsErr := make([]error, len(routers))
+	wg.Add(len(routers))
+	for i, ri := range routers {
+		go func(ri router, i int) {
+			resultsTTL[i], resultsErr[i] = call(ctx, ri)
+			wg.Done()
+		}(ri, i)
+	}
+	wg.Wait()
+
+	var err error
+	for _, e := range resultsErr {
+		err = errors.Join(err, e)
+	}
+
+	// Choose lowest TTL to return.
+	var ttl time.Duration = math.MaxInt64
+	for _, t := range resultsTTL {
+		if t < ttl {
+			ttl = t
+		}
+	}
+
+	return ttl, err
+}
+
 func (r parallelRouter) GetIPNS(ctx context.Context, name ipns.Name) (*ipns.Record, error) {
 	switch len(r.routers) {
 	case 0:
@@ -307,46 +359,6 @@ func (r parallelRouter) PutIPNS(ctx context.Context, name ipns.Name, record *ipn
 	return errs
 }
 
-func (r parallelRouter) Provide(ctx context.Context, req *server.ProvideRequest) (time.Duration, error) {
-	switch len(r.routers) {
-	case 0:
-		return req.TTL, nil
-	case 1:
-		return r.routers[0].Provide(ctx, req)
-	}
-
-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	var wg sync.WaitGroup
-	ttl := req.TTL
-	results := make([]error, len(r.routers))
-	wg.Add(len(r.routers))
-	for i, ri := range r.routers {
-		go func(ri router, i int) {
-			var ittl time.Duration
-			ittl, results[i] = ri.Provide(ctx, req)
-
-			if results[i] == nil && ittl < ttl {
-				ttl = ittl
-			}
-
-			wg.Done()
-		}(ri, i)
-	}
-	wg.Wait()
-
-	var errs error
-	for _, err := range results {
-		errs = errors.Join(errs, err)
-	}
-	return ttl, errs
-}
-
-func (r parallelRouter) ProvidePeer(ctx context.Context, req *server.ProvidePeerRequest) (time.Duration, error) {
-	return 0, routing.ErrNotSupported
-}
-
 var _ router = libp2pRouter{}
 
 type libp2pRouter struct {