mirror of
https://github.com/ipfs/kubo.git
synced 2026-02-23 03:17:43 +08:00
ee45b8d32f
The new coreiface.Path maps a path to the cid.Cid resulting from a full path resolution. The path is internally represented as a go-ipfs/path.Path, but that doesn't matter to the outside. Apart from the path-to-CID mapping, it also aims to hold all resolved segment CIDs of the path. Right now it only exposes Root(), and only for flat paths a la /ipfs/Qmfoo. In other cases, the root is nil. In the future, resolution will internally use go-ipfs/path.Resolver.ResolvePathComponents and thus always return the proper resolved segments, via Root(), or a future Segments() func. - Add coreiface.Path with Cid() and Root(). - Add CoreAPI.ResolvePath() for getting a coreiface.Path. - All functions now expect and return coreiface.Path. - Add ParsePath() and ParseCid() for constructing a coreiface.Path. - Add coreiface.Node and Link which are simply go-ipld-node.Node and Link. - Add CoreAPI.ResolveNode() for getting a Node from a Path. License: MIT Signed-off-by: Lars Gierth <larsg@systemli.org>
88 lines
2.0 KiB
Go
88 lines
2.0 KiB
Go
package coreapi
|
|
|
|
import (
|
|
"context"
|
|
|
|
core "github.com/ipfs/go-ipfs/core"
|
|
coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
|
|
ipfspath "github.com/ipfs/go-ipfs/path"
|
|
|
|
cid "gx/ipfs/QmV5gPoRsjN1Gid3LMdNZTyfCtP2DsvqEbMAmz82RmmiGk/go-cid"
|
|
)
|
|
|
|
type CoreAPI struct {
|
|
node *core.IpfsNode
|
|
}
|
|
|
|
func NewCoreAPI(n *core.IpfsNode) coreiface.CoreAPI {
|
|
api := &CoreAPI{n}
|
|
return api
|
|
}
|
|
|
|
func (api *CoreAPI) Unixfs() coreiface.UnixfsAPI {
|
|
return (*UnixfsAPI)(api)
|
|
}
|
|
|
|
func (api *CoreAPI) ResolveNode(ctx context.Context, p coreiface.Path) (coreiface.Node, error) {
|
|
p, err := api.ResolvePath(ctx, p)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
node, err := api.node.DAG.Get(ctx, p.Cid())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return node, nil
|
|
}
|
|
|
|
// TODO: store all of ipfspath.Resolver.ResolvePathComponents() in Path
|
|
func (api *CoreAPI) ResolvePath(ctx context.Context, p coreiface.Path) (coreiface.Path, error) {
|
|
if p.Resolved() {
|
|
return p, nil
|
|
}
|
|
|
|
p2 := ipfspath.FromString(p.String())
|
|
node, err := core.Resolve(ctx, api.node.Namesys, api.node.Resolver, p2)
|
|
if err == core.ErrNoNamesys {
|
|
return nil, coreiface.ErrOffline
|
|
} else if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var root *cid.Cid
|
|
if p2.IsJustAKey() {
|
|
root = node.Cid()
|
|
}
|
|
|
|
return ResolvedPath(p.String(), node.Cid(), root), nil
|
|
}
|
|
|
|
// Implements coreiface.Path
|
|
type path struct {
|
|
path ipfspath.Path
|
|
cid *cid.Cid
|
|
root *cid.Cid
|
|
}
|
|
|
|
func ParsePath(p string) (coreiface.Path, error) {
|
|
pp, err := ipfspath.ParsePath(p)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &path{path: pp}, nil
|
|
}
|
|
|
|
func ParseCid(c *cid.Cid) coreiface.Path {
|
|
return &path{path: ipfspath.FromCid(c), cid: c, root: c}
|
|
}
|
|
|
|
func ResolvedPath(p string, c *cid.Cid, r *cid.Cid) coreiface.Path {
|
|
return &path{path: ipfspath.FromString(p), cid: c, root: r}
|
|
}
|
|
|
|
func (p *path) String() string { return p.path.String() }
|
|
func (p *path) Cid() *cid.Cid { return p.cid }
|
|
func (p *path) Root() *cid.Cid { return p.root }
|
|
func (p *path) Resolved() bool { return p.cid != nil }
|