core: deprecate CoreAPI.Dht, introduce CoreAPI.Routing

client/rpc/api.go

@@ -227,6 +227,8 @@ func (api *HttpApi) Object() iface.ObjectAPI {
 	return (*ObjectAPI)(api)
 }
 
+// nolint deprecated
+// Deprecated: use [HttpApi.Routing] instead.
 func (api *HttpApi) Dht() iface.DhtAPI {
 	return (*DhtAPI)(api)
 }

client/rpc/dht.go

@@ -2,110 +2,30 @@ package rpc
 
 import (
 	"context"
-	"encoding/json"
 
 	"github.com/ipfs/boxo/path"
 	caopts "github.com/ipfs/kubo/core/coreiface/options"
 	"github.com/libp2p/go-libp2p/core/peer"
-	"github.com/libp2p/go-libp2p/core/routing"
 )
 
 type DhtAPI HttpApi
 
+// nolint deprecated
+// Deprecated: use [RoutingAPI.FindPeer] instead.
 func (api *DhtAPI) FindPeer(ctx context.Context, p peer.ID) (peer.AddrInfo, error) {
-	var out struct {
-		Type      routing.QueryEventType
-		Responses []peer.AddrInfo
-	}
-	resp, err := api.core().Request("dht/findpeer", p.String()).Send(ctx)
-	if err != nil {
-		return peer.AddrInfo{}, err
-	}
-	if resp.Error != nil {
-		return peer.AddrInfo{}, resp.Error
-	}
-	defer resp.Close()
-	dec := json.NewDecoder(resp.Output)
-	for {
-		if err := dec.Decode(&out); err != nil {
-			return peer.AddrInfo{}, err
-		}
-		if out.Type == routing.FinalPeer {
-			return out.Responses[0], nil
-		}
-	}
+	return api.core().Routing().FindPeer(ctx, p)
 }
 
+// nolint deprecated
+// Deprecated: use [RoutingAPI.FindProviders] instead.
 func (api *DhtAPI) FindProviders(ctx context.Context, p path.Path, opts ...caopts.DhtFindProvidersOption) (<-chan peer.AddrInfo, error) {
-	options, err := caopts.DhtFindProvidersOptions(opts...)
-	if err != nil {
-		return nil, err
-	}
-
-	rp, _, err := api.core().ResolvePath(ctx, p)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := api.core().Request("dht/findprovs", rp.RootCid().String()).
-		Option("num-providers", options.NumProviders).
-		Send(ctx)
-	if err != nil {
-		return nil, err
-	}
-	if resp.Error != nil {
-		return nil, resp.Error
-	}
-	res := make(chan peer.AddrInfo)
-
-	go func() {
-		defer resp.Close()
-		defer close(res)
-		dec := json.NewDecoder(resp.Output)
-
-		for {
-			var out struct {
-				Extra     string
-				Type      routing.QueryEventType
-				Responses []peer.AddrInfo
-			}
-
-			if err := dec.Decode(&out); err != nil {
-				return // todo: handle this somehow
-			}
-			if out.Type == routing.QueryError {
-				return // usually a 'not found' error
-				// todo: handle other errors
-			}
-			if out.Type == routing.Provider {
-				for _, pi := range out.Responses {
-					select {
-					case res <- pi:
-					case <-ctx.Done():
-						return
-					}
-				}
-			}
-		}
-	}()
-
-	return res, nil
+	return api.core().Routing().FindProviders(ctx, p, opts...)
 }
 
+// nolint deprecated
+// Deprecated: use [RoutingAPI.Provide] instead.
 func (api *DhtAPI) Provide(ctx context.Context, p path.Path, opts ...caopts.DhtProvideOption) error {
-	options, err := caopts.DhtProvideOptions(opts...)
-	if err != nil {
-		return err
-	}
-
-	rp, _, err := api.core().ResolvePath(ctx, p)
-	if err != nil {
-		return err
-	}
-
-	return api.core().Request("dht/provide", rp.RootCid().String()).
-		Option("recursive", options.Recursive).
-		Exec(ctx, nil)
+	return api.core().Routing().Provide(ctx, p, opts...)
 }
 
 func (api *DhtAPI) core() *HttpApi {

client/rpc/routing.go

@@ -6,7 +6,9 @@ import (
 	"encoding/base64"
 	"encoding/json"
 
+	"github.com/ipfs/boxo/path"
 	"github.com/ipfs/kubo/core/coreiface/options"
+	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/libp2p/go-libp2p/core/routing"
 )
 
@@ -58,6 +60,102 @@ func (api *RoutingAPI) Put(ctx context.Context, key string, value []byte, opts .
 	return nil
 }
 
+func (api *RoutingAPI) FindPeer(ctx context.Context, p peer.ID) (peer.AddrInfo, error) {
+	var out struct {
+		Type      routing.QueryEventType
+		Responses []peer.AddrInfo
+	}
+	resp, err := api.core().Request("routing/findpeer", p.String()).Send(ctx)
+	if err != nil {
+		return peer.AddrInfo{}, err
+	}
+	if resp.Error != nil {
+		return peer.AddrInfo{}, resp.Error
+	}
+	defer resp.Close()
+	dec := json.NewDecoder(resp.Output)
+	for {
+		if err := dec.Decode(&out); err != nil {
+			return peer.AddrInfo{}, err
+		}
+		if out.Type == routing.FinalPeer {
+			return out.Responses[0], nil
+		}
+	}
+}
+
+func (api *RoutingAPI) FindProviders(ctx context.Context, p path.Path, opts ...options.RoutingFindProvidersOption) (<-chan peer.AddrInfo, error) {
+	options, err := options.RoutingFindProvidersOptions(opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	rp, _, err := api.core().ResolvePath(ctx, p)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := api.core().Request("routing/findprovs", rp.RootCid().String()).
+		Option("num-providers", options.NumProviders).
+		Send(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if resp.Error != nil {
+		return nil, resp.Error
+	}
+	res := make(chan peer.AddrInfo)
+
+	go func() {
+		defer resp.Close()
+		defer close(res)
+		dec := json.NewDecoder(resp.Output)
+
+		for {
+			var out struct {
+				Extra     string
+				Type      routing.QueryEventType
+				Responses []peer.AddrInfo
+			}
+
+			if err := dec.Decode(&out); err != nil {
+				return // todo: handle this somehow
+			}
+			if out.Type == routing.QueryError {
+				return // usually a 'not found' error
+				// todo: handle other errors
+			}
+			if out.Type == routing.Provider {
+				for _, pi := range out.Responses {
+					select {
+					case res <- pi:
+					case <-ctx.Done():
+						return
+					}
+				}
+			}
+		}
+	}()
+
+	return res, nil
+}
+
+func (api *RoutingAPI) Provide(ctx context.Context, p path.Path, opts ...options.RoutingProvideOption) error {
+	options, err := options.RoutingProvideOptions(opts...)
+	if err != nil {
+		return err
+	}
+
+	rp, _, err := api.core().ResolvePath(ctx, p)
+	if err != nil {
+		return err
+	}
+
+	return api.core().Request("routing/provide", rp.RootCid().String()).
+		Option("recursive", options.Recursive).
+		Exec(ctx, nil)
+}
+
 func (api *RoutingAPI) core() *HttpApi {
 	return (*HttpApi)(api)
 }

core/coreapi/coreapi.go

@@ -130,7 +130,8 @@ func (api *CoreAPI) Pin() coreiface.PinAPI {
 	return (*PinAPI)(api)
 }
 
-// Dht returns the DhtAPI interface implementation backed by the go-ipfs node
+// nolint deprecated
+// Deprecated: use [CoreAPI.Routing] instead.
 func (api *CoreAPI) Dht() coreiface.DhtAPI {
 	return (*DhtAPI)(api)
 }