// resolveOnce implements resolver. // TXT records for a given domain name should contain a b58 // encoded multihash. func (r *DNSResolver) resolveOnce(ctx context.Context, name string) (path.Path, error) { segments := strings.SplitN(name, "/", 2) if !isd.IsDomain(segments[0]) { return "", errors.New("not a valid domain name") } log.Infof("DNSResolver resolving %s", segments[0]) txt, err := r.lookupTXT(segments[0]) if err != nil { return "", err } for _, t := range txt { p, err := parseEntry(t) if err == nil { if len(segments) > 1 { return path.FromSegments("", strings.TrimRight(p.String(), "/"), segments[1]) } return p, nil } } return "", ErrResolveFailed }
func TestRecurivePathResolution(t *testing.T) { ctx := context.Background() dstore := sync.MutexWrap(datastore.NewMapDatastore()) bstore := blockstore.NewBlockstore(dstore) bserv, err := blockservice.New(bstore, offline.Exchange(bstore)) if err != nil { t.Fatal(err) } dagService := merkledag.NewDAGService(bserv) a, _ := randNode() b, _ := randNode() c, cKey := randNode() err = b.AddNodeLink("grandchild", c) if err != nil { t.Fatal(err) } err = a.AddNodeLink("child", b) if err != nil { t.Fatal(err) } err = dagService.AddRecursive(a) if err != nil { t.Fatal(err) } aKey, err := a.Key() if err != nil { t.Fatal(err) } segments := []string{aKey.String(), "child", "grandchild"} p, err := path.FromSegments("/ipfs/", segments...) if err != nil { t.Fatal(err) } resolver := &path.Resolver{DAG: dagService} node, err := resolver.ResolvePath(ctx, p) if err != nil { t.Fatal(err) } key, err := node.Key() if err != nil { t.Fatal(err) } if key.String() != cKey.String() { t.Fatal(fmt.Errorf( "recursive path resolution failed for %s: %s != %s", p.String(), key.String(), cKey.String())) } }
func TestRecurivePathResolution(t *testing.T) { ctx := context.Background() dagService := dagmock.Mock() a, _ := randNode() b, _ := randNode() c, cKey := randNode() err := b.AddNodeLink("grandchild", c) if err != nil { t.Fatal(err) } err = a.AddNodeLink("child", b) if err != nil { t.Fatal(err) } for _, n := range []*merkledag.Node{a, b, c} { _, err = dagService.Add(n) if err != nil { t.Fatal(err) } } aKey, err := a.Key() if err != nil { t.Fatal(err) } segments := []string{aKey.String(), "child", "grandchild"} p, err := path.FromSegments("/ipfs/", segments...) if err != nil { t.Fatal(err) } resolver := &path.Resolver{DAG: dagService} node, err := resolver.ResolvePath(ctx, p) if err != nil { t.Fatal(err) } key, err := node.Key() if err != nil { t.Fatal(err) } if key.String() != cKey.String() { t.Fatal(fmt.Errorf( "recursive path resolution failed for %s: %s != %s", p.String(), key.String(), cKey.String())) } }
// Resolve resolves the given path by parsing out protocol-specific // entries (e.g. /ipns/<node-key>) and then going through the /ipfs/ // entries and returning the final merkledag node. Effectively // enables /ipns/, /dns/, etc. in commands. func Resolve(ctx context.Context, n *IpfsNode, p path.Path) (*merkledag.Node, error) { if strings.HasPrefix(p.String(), "/ipns/") { // resolve ipns paths // TODO(cryptix): we sould be able to query the local cache for the path if n.Namesys == nil { return nil, ErrNoNamesys } seg := p.Segments() if len(seg) < 2 || seg[1] == "" { // just "/<protocol/>" without further segments return nil, path.ErrNoComponents } extensions := seg[2:] resolvable, err := path.FromSegments("/", seg[0], seg[1]) if err != nil { return nil, err } respath, err := n.Namesys.Resolve(ctx, resolvable.String()) if err != nil { return nil, err } segments := append(respath.Segments(), extensions...) p, err = path.FromSegments("/", segments...) if err != nil { return nil, err } } // ok, we have an ipfs path now (or what we'll treat as one) return n.Resolver.ResolvePath(ctx, p) }
// resolveOnce implements resolver. // TXT records for a given domain name should contain a b58 // encoded multihash. func (r *DNSResolver) resolveOnce(ctx context.Context, name string) (path.Path, error) { segments := strings.SplitN(name, "/", 2) domain := segments[0] if !isd.IsDomain(domain) { return "", errors.New("not a valid domain name") } log.Infof("DNSResolver resolving %s", domain) rootChan := make(chan lookupRes, 1) go workDomain(r, domain, rootChan) subChan := make(chan lookupRes, 1) go workDomain(r, "_dnslink."+domain, subChan) var subRes lookupRes select { case subRes = <-subChan: case <-ctx.Done(): return "", ctx.Err() } var p path.Path if subRes.error == nil { p = subRes.path } else { var rootRes lookupRes select { case rootRes = <-rootChan: case <-ctx.Done(): return "", ctx.Err() } if rootRes.error == nil { p = rootRes.path } else { return "", ErrResolveFailed } } if len(segments) > 1 { return path.FromSegments("", strings.TrimRight(p.String(), "/"), segments[1]) } else { return p, nil } }
// resolveOnce implements resolver. func (ns *mpns) resolveOnce(ctx context.Context, name string) (path.Path, error) { if !strings.HasPrefix(name, "/ipns/") { name = "/ipns/" + name } segments := strings.SplitN(name, "/", 4) if len(segments) < 3 || segments[0] != "" { log.Warningf("Invalid name syntax for %s", name) return "", ErrResolveFailed } for protocol, resolver := range ns.resolvers { log.Debugf("Attempting to resolve %s with %s", segments[2], protocol) p, err := resolver.resolveOnce(ctx, segments[2]) if err == nil { if len(segments) > 3 { return path.FromSegments("", strings.TrimRight(p.String(), "/"), segments[3]) } else { return p, err } } } log.Warningf("No resolver found for %s", name) return "", ErrResolveFailed }