feat!: namesys refactor, ipns TTL bubbled up to gateway

CHANGELOG.md

@@ -16,6 +16,9 @@ The following emojis are used to highlight certain changes:
 
 ### Added
 
+* The gateway now sets a `Cache-Control` header for requests under the `/ipns/` namespace
+  if the TTL for the corresponding IPNS Records or DNSLink entities is known.
+
 ### Changed
 
 * `boxo/gateway`
@@ -35,6 +38,18 @@ The following emojis are used to highlight certain changes:
     - Eliminate `..` elements that begin a rooted path: that is, replace "`/..`" by "`/`" at the beginning of a path.
 * 🛠 The signature of `CoreAPI.ResolvePath` in  `coreiface` has changed to now return
   the remainder segments as a second return value, matching the signature of `resolver.ResolveToLastNode`.
+* 🛠 The `namesys` package has been refactored. The following are the largest modifications:
+  * The options in `coreiface/options/namesys` have been moved to `namesys` and their names
+    have been made more consistent.
+  * Many of the exported structs and functions have been renamed in order to be consistent with
+    the remaining packages.
+  * `namesys.Resolver.Resolve` now returns a TTL, in addition to the resolved path. If the
+    TTL is unknown, 0 is returned. `IPNSResolver` is able to resolve a TTL, while `DNSResolver`
+    is not.
+  * `namesys/resolver.ResolveIPNS` has been moved to `namesys.ResolveIPNS` and now returns a TTL
+    in addition to the resolved path.
+* 🛠 The `gateway`'s `IPFSBackend.ResolveMutable` is now expected to return a TTL in addition to
+    the resolved path. If the TTL is unknown, 0 should be returned.
 
 ### Removed
 

coreiface/options/name.go

@@ -3,7 +3,7 @@ package options
 import (
 	"time"
 
-	ropts "github.com/ipfs/boxo/coreiface/options/namesys"
+	"github.com/ipfs/boxo/namesys"
 )
 
 const (
@@ -21,7 +21,7 @@ type NamePublishSettings struct {
 type NameResolveSettings struct {
 	Cache bool
 
-	ResolveOpts []ropts.ResolveOpt
+	ResolveOpts []namesys.ResolveOption
 }
 
 type (
@@ -123,7 +123,7 @@ func (nameOpts) Cache(cache bool) NameResolveOption {
 	}
 }
 
-func (nameOpts) ResolveOption(opt ropts.ResolveOpt) NameResolveOption {
+func (nameOpts) ResolveOption(opt namesys.ResolveOption) NameResolveOption {
 	return func(settings *NameResolveSettings) error {
 		settings.ResolveOpts = append(settings.ResolveOpts, opt)
 		return nil

gateway/blocks_backend.go

@@ -8,18 +8,18 @@ import (
 	"io"
 	"net/http"
 	"strings"
+	"time"
 
 	"github.com/ipfs/boxo/blockservice"
 	blockstore "github.com/ipfs/boxo/blockstore"
-	nsopts "github.com/ipfs/boxo/coreiface/options/namesys"
 	"github.com/ipfs/boxo/fetcher"
 	bsfetcher "github.com/ipfs/boxo/fetcher/impl/blockservice"
 	"github.com/ipfs/boxo/files"
 	"github.com/ipfs/boxo/ipld/merkledag"
 	ufile "github.com/ipfs/boxo/ipld/unixfs/file"
 	uio "github.com/ipfs/boxo/ipld/unixfs/io"
+	"github.com/ipfs/boxo/ipns"
 	"github.com/ipfs/boxo/namesys"
-	"github.com/ipfs/boxo/namesys/resolve"
 	"github.com/ipfs/boxo/path"
 	"github.com/ipfs/boxo/path/resolver"
 	blocks "github.com/ipfs/go-block-format"
@@ -39,7 +39,6 @@ import (
 	"github.com/ipld/go-ipld-prime/traversal/selector"
 	selectorparse "github.com/ipld/go-ipld-prime/traversal/selector/parse"
 	routinghelpers "github.com/libp2p/go-libp2p-routing-helpers"
-	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/libp2p/go-libp2p/core/routing"
 	mc "github.com/multiformats/go-multicodec"
 
@@ -615,18 +614,23 @@ func (bb *BlocksBackend) getPathRoots(ctx context.Context, contentPath path.Immu
 	return pathRoots, lastPath, remainder, nil
 }
 
-func (bb *BlocksBackend) ResolveMutable(ctx context.Context, p path.Path) (path.ImmutablePath, error) {
+func (bb *BlocksBackend) ResolveMutable(ctx context.Context, p path.Path) (path.ImmutablePath, time.Duration, time.Time, error) {
 	switch p.Namespace() {
 	case path.IPNSNamespace:
-		p, err := resolve.ResolveIPNS(ctx, bb.namesys, p)
+		res, err := namesys.Resolve(ctx, bb.namesys, p)
 		if err != nil {
-			return path.ImmutablePath{}, err
+			return path.ImmutablePath{}, 0, time.Time{}, err
 		}
-		return path.NewImmutablePath(p)
+		ip, err := path.NewImmutablePath(res.Path)
+		if err != nil {
+			return path.ImmutablePath{}, 0, time.Time{}, err
+		}
+		return ip, res.TTL, res.LastMod, nil
 	case path.IPFSNamespace:
-		return path.NewImmutablePath(p)
+		ip, err := path.NewImmutablePath(p)
+		return ip, 0, time.Time{}, err
 	default:
-		return path.ImmutablePath{}, NewErrorStatusCode(fmt.Errorf("unsupported path namespace: %s", p.Namespace()), http.StatusNotImplemented)
+		return path.ImmutablePath{}, 0, time.Time{}, NewErrorStatusCode(fmt.Errorf("unsupported path namespace: %s", p.Namespace()), http.StatusNotImplemented)
 	}
 }
 
@@ -635,28 +639,25 @@ func (bb *BlocksBackend) GetIPNSRecord(ctx context.Context, c cid.Cid) ([]byte,
 		return nil, NewErrorStatusCode(errors.New("IPNS Record responses are not supported by this gateway"), http.StatusNotImplemented)
 	}
 
-	// Fails fast if the CID is not an encoded Libp2p Key, avoids wasteful
-	// round trips to the remote routing provider.
-	if mc.Code(c.Type()) != mc.Libp2pKey {
-		return nil, NewErrorStatusCode(errors.New("cid codec must be libp2p-key"), http.StatusBadRequest)
-	}
-
-	// The value store expects the key itself to be encoded as a multihash.
-	id, err := peer.FromCid(c)
+	name, err := ipns.NameFromCid(c)
 	if err != nil {
-		return nil, err
+		return nil, NewErrorStatusCode(err, http.StatusBadRequest)
 	}
 
-	return bb.routing.GetValue(ctx, "/ipns/"+string(id))
+	return bb.routing.GetValue(ctx, string(name.RoutingKey()))
 }
 
 func (bb *BlocksBackend) GetDNSLinkRecord(ctx context.Context, hostname string) (path.Path, error) {
 	if bb.namesys != nil {
-		p, err := bb.namesys.Resolve(ctx, "/ipns/"+hostname, nsopts.Depth(1))
+		p, err := path.NewPath("/ipns/" + hostname)
+		if err != nil {
+			return nil, err
+		}
+		res, err := bb.namesys.Resolve(ctx, p, namesys.ResolveWithDepth(1))
 		if err == namesys.ErrResolveRecursion {
 			err = nil
 		}
-		return p, err
+		return res.Path, err
 	}
 
 	return nil, NewErrorStatusCode(errors.New("not implemented"), http.StatusNotImplemented)
@@ -688,10 +689,11 @@ func (bb *BlocksBackend) ResolvePath(ctx context.Context, path path.ImmutablePat
 func (bb *BlocksBackend) resolvePath(ctx context.Context, p path.Path) (path.ImmutablePath, []string, error) {
 	var err error
 	if p.Namespace() == path.IPNSNamespace {
-		p, err = resolve.ResolveIPNS(ctx, bb.namesys, p)
+		res, err := namesys.Resolve(ctx, bb.namesys, p)
 		if err != nil {
 			return path.ImmutablePath{}, nil, err
 		}
+		p = res.Path
 	}
 
 	if p.Namespace() != path.IPFSNamespace {

gateway/gateway.go

@@ -8,6 +8,7 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/ipfs/boxo/files"
 	"github.com/ipfs/boxo/gateway/assets"
@@ -369,11 +370,11 @@ type IPFSBackend interface {
 	GetIPNSRecord(context.Context, cid.Cid) ([]byte, error)
 
 	// ResolveMutable takes a mutable path and resolves it into an immutable one. This means recursively resolving any
-	// DNSLink or IPNS records.
+	// DNSLink or IPNS records. It should also return a TTL. If the TTL is unknown, 0 should be returned.
 	//
 	// For example, given a mapping from `/ipns/dnslink.tld -> /ipns/ipns-id/mydirectory` and `/ipns/ipns-id` to
 	// `/ipfs/some-cid`, the result of passing `/ipns/dnslink.tld/myfile` would be `/ipfs/some-cid/mydirectory/myfile`.
-	ResolveMutable(context.Context, path.Path) (path.ImmutablePath, error)
+	ResolveMutable(context.Context, path.Path) (path.ImmutablePath, time.Duration, time.Time, error)
 
 	// GetDNSLinkRecord returns the DNSLink TXT record for the provided FQDN.
 	// Unlike ResolvePath, it does not perform recursive resolution. It only