diff --git a/namesys/base.go b/namesys/base.go index 175675d7b858..b2fd77d663c7 100644 --- a/namesys/base.go +++ b/namesys/base.go @@ -17,45 +17,33 @@ type onceResult struct { } type resolver interface { - // resolveOnce looks up a name once (without recursion). - resolveOnce(ctx context.Context, name string, options opts.ResolveOpts) (value path.Path, ttl time.Duration, err error) - resolveOnceAsync(ctx context.Context, name string, options opts.ResolveOpts) <-chan onceResult } // resolve is a helper for implementing Resolver.ResolveN using resolveOnce. func resolve(ctx context.Context, r resolver, name string, options opts.ResolveOpts, prefix string) (path.Path, error) { - depth := options.Depth - for { - p, _, err := r.resolveOnce(ctx, name, options) - if err != nil { - return "", err - } - log.Debugf("resolved %s to %s", name, p.String()) + ctx, cancel := context.WithCancel(ctx) + defer cancel() - if strings.HasPrefix(p.String(), "/ipfs/") { - // we've bottomed out with an IPFS path - return p, nil - } + err := ErrResolveFailed + var p path.Path - if depth == 1 { - return p, ErrResolveRecursion - } + resCh := resolveAsync(ctx, r, name, options, prefix) - if !strings.HasPrefix(p.String(), prefix) { - return p, nil - } - name = strings.TrimPrefix(p.String(), prefix) - - if depth > 1 { - depth-- + for res := range resCh { + p, err = res.Path, res.Err + if err != nil { + break } } + + return p, err } //TODO: // - better error handling -func resolveAsyncDo(ctx context.Context, r resolver, name string, options opts.ResolveOpts, prefix string) <-chan Result { +// - select on writes +func resolveAsync(ctx context.Context, r resolver, name string, options opts.ResolveOpts, prefix string) <-chan Result { resCh := r.resolveOnceAsync(ctx, name, options) depth := options.Depth outCh := make(chan Result) @@ -70,7 +58,7 @@ func resolveAsyncDo(ctx context.Context, r resolver, name string, options opts.R case res, ok := <-resCh: if !ok { resCh = nil - continue + break } if res.err != nil { @@ -79,14 +67,13 @@ func resolveAsyncDo(ctx context.Context, r resolver, name string, options opts.R } log.Debugf("resolved %s to %s", name, res.value.String()) if strings.HasPrefix(res.value.String(), "/ipfs/") { - outCh <- Result{Err: res.err} - continue + outCh <- Result{Path: res.value} + break } - p := strings.TrimPrefix(res.value.String(), prefix) if depth == 1 { - outCh <- Result{Err: ErrResolveRecursion} - continue + outCh <- Result{Path: res.value, Err: ErrResolveRecursion} + break } subopts := options @@ -102,26 +89,21 @@ func resolveAsyncDo(ctx context.Context, r resolver, name string, options opts.R subCtx, cancelSub = context.WithCancel(ctx) defer cancelSub() - subCh = resolveAsyncDo(subCtx, r, p, subopts, prefix) + p := strings.TrimPrefix(res.value.String(), prefix) + subCh = resolveAsync(subCtx, r, p, subopts, prefix) case res, ok := <-subCh: if !ok { subCh = nil - continue - } - - if res.Err != nil { - outCh <- Result{Err: res.Err} - return + break } outCh <- res case <-ctx.Done(): } + if resCh == nil && subCh == nil { + return + } } }() return outCh } - -func resolveAsync(ctx context.Context, r resolver, name string, options opts.ResolveOpts, prefix string) <-chan Result { - return resolveAsyncDo(ctx, r, name, options, prefix) -} diff --git a/namesys/dns.go b/namesys/dns.go index 7a9d1d6be7a0..c5cb5e1883f9 100644 --- a/namesys/dns.go +++ b/namesys/dns.go @@ -3,13 +3,11 @@ package namesys import ( "context" "errors" - "net" - "strings" - "time" - opts "github.com/ipfs/go-ipfs/namesys/opts" isd "gx/ipfs/QmZmmuAXgX73UQmX1jRKjTGmjzq24Jinqkq8vzkBtno4uX/go-is-domain" - path "gx/ipfs/QmdMPBephdLYNESkruDX2hcDTgFYhoCt4LimWhgnomSdV2/go-path" + "gx/ipfs/QmdMPBephdLYNESkruDX2hcDTgFYhoCt4LimWhgnomSdV2/go-path" + "net" + "strings" ) type LookupTXTFunc func(name string) (txt []string, err error) @@ -43,51 +41,6 @@ type lookupRes struct { // 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, options opts.ResolveOpts) (path.Path, time.Duration, error) { - segments := strings.SplitN(name, "/", 2) - domain := segments[0] - - if !isd.IsDomain(domain) { - return "", 0, errors.New("not a valid domain name") - } - log.Debugf("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 "", 0, 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 "", 0, ctx.Err() - } - if rootRes.error == nil { - p = rootRes.path - } else { - return "", 0, ErrResolveFailed - } - } - var err error - if len(segments) > 1 { - p, err = path.FromSegments("", strings.TrimRight(p.String(), "/"), segments[1]) - } - return p, 0, err -} - func (r *DNSResolver) resolveOnceAsync(ctx context.Context, name string, options opts.ResolveOpts) <-chan onceResult { out := make(chan onceResult, 1) segments := strings.SplitN(name, "/", 2) @@ -106,6 +59,13 @@ func (r *DNSResolver) resolveOnceAsync(ctx context.Context, name string, options subChan := make(chan lookupRes, 1) go workDomain(r, "_dnslink."+domain, subChan) + appendPath := func(p path.Path) (path.Path, error) { + if len(segments) > 1 { + return path.FromSegments("", strings.TrimRight(p.String(), "/"), segments[1]) + } + return p, nil + } + go func() { defer close(out) for { @@ -113,21 +73,25 @@ func (r *DNSResolver) resolveOnceAsync(ctx context.Context, name string, options case subRes, ok := <-subChan: if !ok { subChan = nil + break } if subRes.error == nil { + p, err := appendPath(subRes.path) select { - case out <- onceResult{value: subRes.path}: + case out <- onceResult{value: p, err: err}: case <-ctx.Done(): } return } case rootRes, ok := <-rootChan: if !ok { - subChan = nil + rootChan = nil + break } if rootRes.error == nil { + p, err := appendPath(rootRes.path) select { - case out <- onceResult{value: rootRes.path}: + case out <- onceResult{value: p, err: err}: case <-ctx.Done(): } } @@ -144,8 +108,9 @@ func (r *DNSResolver) resolveOnceAsync(ctx context.Context, name string, options } func workDomain(r *DNSResolver, name string, res chan lookupRes) { - txt, err := r.lookupTXT(name) + defer close(res) + txt, err := r.lookupTXT(name) if err != nil { // Error is != nil res <- lookupRes{"", err} diff --git a/namesys/ipns_resolver_validation_test.go b/namesys/ipns_resolver_validation_test.go index dd84308f2d4c..58dc0079cfa7 100644 --- a/namesys/ipns_resolver_validation_test.go +++ b/namesys/ipns_resolver_validation_test.go @@ -56,14 +56,13 @@ func TestResolverValidation(t *testing.T) { } // Resolve entry - resp, _, err := resolver.resolveOnce(ctx, id.Pretty(), opts.DefaultResolveOpts()) + resp, err := resolve(ctx, resolver, id.Pretty(), opts.DefaultResolveOpts(), "/ipns/") if err != nil { t.Fatal(err) } if resp != path.Path(p) { t.Fatalf("Mismatch between published path %s and resolved path %s", p, resp) } - // Create expired entry expiredEntry, err := ipns.Create(priv, p, 1, ts.Add(-1*time.Hour)) if err != nil { @@ -77,7 +76,7 @@ func TestResolverValidation(t *testing.T) { } // Record should fail validation because entry is expired - _, _, err = resolver.resolveOnce(ctx, id.Pretty(), opts.DefaultResolveOpts()) + _, err = resolve(ctx, resolver, id.Pretty(), opts.DefaultResolveOpts(), "/ipns/") if err == nil { t.Fatal("ValidateIpnsRecord should have returned error") } @@ -99,7 +98,7 @@ func TestResolverValidation(t *testing.T) { // Record should fail validation because public key defined by // ipns path doesn't match record signature - _, _, err = resolver.resolveOnce(ctx, id2.Pretty(), opts.DefaultResolveOpts()) + _, err = resolve(ctx, resolver, id2.Pretty(), opts.DefaultResolveOpts(), "/ipns/") if err == nil { t.Fatal("ValidateIpnsRecord should have failed signature verification") } @@ -117,7 +116,7 @@ func TestResolverValidation(t *testing.T) { // Record should fail validation because public key is not available // in peer store or on network - _, _, err = resolver.resolveOnce(ctx, id3.Pretty(), opts.DefaultResolveOpts()) + _, err = resolve(ctx, resolver, id3.Pretty(), opts.DefaultResolveOpts(), "/ipns/") if err == nil { t.Fatal("ValidateIpnsRecord should have failed because public key was not found") } @@ -132,7 +131,7 @@ func TestResolverValidation(t *testing.T) { // public key is available in the peer store by looking it up in // the DHT, which causes the DHT to fetch it and cache it in the // peer store - _, _, err = resolver.resolveOnce(ctx, id3.Pretty(), opts.DefaultResolveOpts()) + _, err = resolve(ctx, resolver, id3.Pretty(), opts.DefaultResolveOpts(), "/ipns/") if err != nil { t.Fatal(err) } diff --git a/namesys/namesys.go b/namesys/namesys.go index e2fa4aff083d..ae27df9ae711 100644 --- a/namesys/namesys.go +++ b/namesys/namesys.go @@ -82,48 +82,6 @@ func (ns *mpns) ResolveAsync(ctx context.Context, name string, options ...opts.R } // resolveOnce implements resolver. -func (ns *mpns) resolveOnce(ctx context.Context, name string, options opts.ResolveOpts) (path.Path, time.Duration, error) { - if !strings.HasPrefix(name, "/ipns/") { - name = "/ipns/" + name - } - segments := strings.SplitN(name, "/", 4) - if len(segments) < 3 || segments[0] != "" { - log.Debugf("invalid name syntax for %s", name) - return "", 0, ErrResolveFailed - } - - key := segments[2] - - p, ok := ns.cacheGet(key) - var err error - if !ok { - // Resolver selection: - // 1. if it is a multihash resolve through "ipns". - // 2. if it is a domain name, resolve through "dns" - // 3. otherwise resolve through the "proquint" resolver - var res resolver - if _, err := mh.FromB58String(key); err == nil { - res = ns.ipnsResolver - } else if isd.IsDomain(key) { - res = ns.dnsResolver - } else { - res = ns.proquintResolver - } - - var ttl time.Duration - p, ttl, err = res.resolveOnce(ctx, key, options) - if err != nil { - return "", 0, ErrResolveFailed - } - ns.cacheSet(key, p, ttl) - } - - if len(segments) > 3 { - p, err = path.FromSegments("", strings.TrimRight(p.String(), "/"), segments[3]) - } - return p, 0, err -} - func (ns *mpns) resolveOnceAsync(ctx context.Context, name string, options opts.ResolveOpts) <-chan onceResult { out := make(chan onceResult, 1) diff --git a/namesys/namesys_test.go b/namesys/namesys_test.go index 344410f59e68..569349da66bf 100644 --- a/namesys/namesys_test.go +++ b/namesys/namesys_test.go @@ -3,16 +3,14 @@ package namesys import ( "context" "fmt" - "testing" - "time" - opts "github.com/ipfs/go-ipfs/namesys/opts" "gx/ipfs/QmQjEpRiwVvtowhq69dAtB4jhioPVFXiCcWZm9Sfgn7eqc/go-unixfs" - path "gx/ipfs/QmdMPBephdLYNESkruDX2hcDTgFYhoCt4LimWhgnomSdV2/go-path" + "gx/ipfs/QmdMPBephdLYNESkruDX2hcDTgFYhoCt4LimWhgnomSdV2/go-path" + "testing" - ipns "gx/ipfs/QmNqBhXpBKa5jcjoUZHfxDgAFxtqK3rDA5jtW811GBvVob/go-ipns" + "gx/ipfs/QmNqBhXpBKa5jcjoUZHfxDgAFxtqK3rDA5jtW811GBvVob/go-ipns" ci "gx/ipfs/QmPvyPwuCgJ7pDmrKDxRtsScJgBaM5h4EpRL2qQJsmXf4n/go-libp2p-crypto" - peer "gx/ipfs/QmQsErDt8Qgw1XrsXf2BpEzDgGWtB1YLsTAARBup5b6B9W/go-libp2p-peer" + "gx/ipfs/QmQsErDt8Qgw1XrsXf2BpEzDgGWtB1YLsTAARBup5b6B9W/go-libp2p-peer" ds "gx/ipfs/QmVG5gxteQNEMhrS8prJSmU2C9rebtFuTd3SYZ5kE3YZ5k/go-datastore" dssync "gx/ipfs/QmVG5gxteQNEMhrS8prJSmU2C9rebtFuTd3SYZ5kE3YZ5k/go-datastore/sync" offroute "gx/ipfs/Qmd45r5jHr1PKMNQqifnbZy1ZQwHdtXUDJFamUEvUJE544/go-ipfs-routing/offline" @@ -38,13 +36,12 @@ func testResolution(t *testing.T, resolver Resolver, name string, depth uint, ex } } -func (r *mockResolver) resolveOnce(ctx context.Context, name string, opts opts.ResolveOpts) (path.Path, time.Duration, error) { - p, err := path.ParsePath(r.entries[name]) - return p, 0, err -} - func (r *mockResolver) resolveOnceAsync(ctx context.Context, name string, options opts.ResolveOpts) <-chan onceResult { - panic("stub") + p, err := path.ParsePath(r.entries[name]) + out := make(chan onceResult, 1) + out <- onceResult{value: p, err: err} + close(out) + return out } func mockResolverOne() *mockResolver { diff --git a/namesys/proquint.go b/namesys/proquint.go index 6da1f1645acb..4e2b0635b66e 100644 --- a/namesys/proquint.go +++ b/namesys/proquint.go @@ -1,14 +1,12 @@ package namesys import ( + "context" "errors" - "time" - - context "context" opts "github.com/ipfs/go-ipfs/namesys/opts" - proquint "gx/ipfs/QmYnf27kzqR2cxt6LFZdrAFJuQd6785fTkBvMuEj9EeRxM/proquint" - path "gx/ipfs/QmdMPBephdLYNESkruDX2hcDTgFYhoCt4LimWhgnomSdV2/go-path" + "gx/ipfs/QmYnf27kzqR2cxt6LFZdrAFJuQd6785fTkBvMuEj9EeRxM/proquint" + "gx/ipfs/QmdMPBephdLYNESkruDX2hcDTgFYhoCt4LimWhgnomSdV2/go-path" ) type ProquintResolver struct{} @@ -19,15 +17,6 @@ func (r *ProquintResolver) Resolve(ctx context.Context, name string, options ... } // resolveOnce implements resolver. Decodes the proquint string. -func (r *ProquintResolver) resolveOnce(ctx context.Context, name string, options opts.ResolveOpts) (path.Path, time.Duration, error) { - ok, err := proquint.IsProquint(name) - if err != nil || !ok { - return "", 0, errors.New("not a valid proquint string") - } - // Return a 0 TTL as caching this result is pointless. - return path.FromString(string(proquint.Decode(name))), 0, nil -} - func (r *ProquintResolver) resolveOnceAsync(ctx context.Context, name string, options opts.ResolveOpts) <-chan onceResult { out := make(chan onceResult, 1) defer close(out) diff --git a/namesys/routing.go b/namesys/routing.go index 771808f8ee8e..314c933ad813 100644 --- a/namesys/routing.go +++ b/namesys/routing.go @@ -14,6 +14,7 @@ import ( peer "gx/ipfs/QmQsErDt8Qgw1XrsXf2BpEzDgGWtB1YLsTAARBup5b6B9W/go-libp2p-peer" logging "gx/ipfs/QmRREK2CAZ5Re2Bd9zZFG6FeYDppUWt5cMgsoUEp3ktgSr/go-log" routing "gx/ipfs/QmS4niovD1U6pRjUBXivr1zvvLBqiTKbERjFo994JU7oQS/go-libp2p-routing" + ropts "gx/ipfs/QmS4niovD1U6pRjUBXivr1zvvLBqiTKbERjFo994JU7oQS/go-libp2p-routing/options" dht "gx/ipfs/QmTRj8mj6X5LtjVochPPSNX6MTbJ6iVojcfakWJKG13re7/go-libp2p-kad-dht" cid "gx/ipfs/QmZFbDTY9jfSBms2MchvYM9oYRbAF19K7Pby47yDBfpPrb/go-cid" proto "gx/ipfs/QmdxUuburamoF6zF9qjeQC4WYcWGbWuRmdLacMEsW8ioD8/gogo-protobuf/proto" @@ -48,103 +49,14 @@ func (r *IpnsResolver) ResolveAsync(ctx context.Context, name string, options .. // resolveOnce implements resolver. Uses the IPFS routing system to // resolve SFS-like names. -func (r *IpnsResolver) resolveOnce(ctx context.Context, name string, options opts.ResolveOpts) (path.Path, time.Duration, error) { - log.Debugf("RoutingResolver resolving %s", name) - - if options.DhtTimeout != 0 { - // Resolution must complete within the timeout - var cancel context.CancelFunc - ctx, cancel = context.WithTimeout(ctx, options.DhtTimeout) - defer cancel() - } - - name = strings.TrimPrefix(name, "/ipns/") - hash, err := mh.FromB58String(name) - if err != nil { - // name should be a multihash. if it isn't, error out here. - log.Debugf("RoutingResolver: bad input hash: [%s]\n", name) - return "", 0, err - } - - pid, err := peer.IDFromBytes(hash) - if err != nil { - log.Debugf("RoutingResolver: could not convert public key hash %s to peer ID: %s\n", name, err) - return "", 0, err - } - - // Name should be the hash of a public key retrievable from ipfs. - // We retrieve the public key here to make certain that it's in the peer - // store before calling GetValue() on the DHT - the DHT will call the - // ipns validator, which in turn will get the public key from the peer - // store to verify the record signature - _, err = routing.GetPublicKey(r.routing, ctx, pid) - if err != nil { - log.Debugf("RoutingResolver: could not retrieve public key %s: %s\n", name, err) - return "", 0, err - } - - // Use the routing system to get the name. - // Note that the DHT will call the ipns validator when retrieving - // the value, which in turn verifies the ipns record signature - ipnsKey := ipns.RecordKey(pid) - val, err := r.routing.GetValue(ctx, ipnsKey, dht.Quorum(int(options.DhtRecordCount))) - if err != nil { - log.Debugf("RoutingResolver: dht get for name %s failed: %s", name, err) - return "", 0, err - } - - entry := new(pb.IpnsEntry) - err = proto.Unmarshal(val, entry) - if err != nil { - log.Debugf("RoutingResolver: could not unmarshal value for name %s: %s", name, err) - return "", 0, err - } - - var p path.Path - // check for old style record: - if valh, err := mh.Cast(entry.GetValue()); err == nil { - // Its an old style multihash record - log.Debugf("encountered CIDv0 ipns entry: %s", valh) - p = path.FromCid(cid.NewCidV0(valh)) - } else { - // Not a multihash, probably a new record - p, err = path.ParsePath(string(entry.GetValue())) - if err != nil { - return "", 0, err - } - } - - ttl := DefaultResolverCacheTTL - if entry.Ttl != nil { - ttl = time.Duration(*entry.Ttl) - } - switch eol, err := ipns.GetEOL(entry); err { - case ipns.ErrUnrecognizedValidity: - // No EOL. - case nil: - ttEol := eol.Sub(time.Now()) - if ttEol < 0 { - // It *was* valid when we first resolved it. - ttl = 0 - } else if ttEol < ttl { - ttl = ttEol - } - default: - log.Errorf("encountered error when parsing EOL: %s", err) - return "", 0, err - } - - return p, ttl, nil -} - func (r *IpnsResolver) resolveOnceAsync(ctx context.Context, name string, options opts.ResolveOpts) <-chan onceResult { out := make(chan onceResult, 1) log.Debugf("RoutingResolver resolving %s", name) + cancel := func() {} + if options.DhtTimeout != 0 { // Resolution must complete within the timeout - var cancel context.CancelFunc ctx, cancel = context.WithTimeout(ctx, options.DhtTimeout) - defer cancel() } name = strings.TrimPrefix(name, "/ipns/") @@ -154,6 +66,7 @@ func (r *IpnsResolver) resolveOnceAsync(ctx context.Context, name string, option log.Debugf("RoutingResolver: bad input hash: [%s]\n", name) out <- onceResult{err: err} close(out) + cancel() return out } @@ -162,6 +75,7 @@ func (r *IpnsResolver) resolveOnceAsync(ctx context.Context, name string, option log.Debugf("RoutingResolver: could not convert public key hash %s to peer ID: %s\n", name, err) out <- onceResult{err: err} close(out) + cancel() return out } @@ -175,6 +89,7 @@ func (r *IpnsResolver) resolveOnceAsync(ctx context.Context, name string, option log.Debugf("RoutingResolver: could not retrieve public key %s: %s\n", name, err) out <- onceResult{err: err} close(out) + cancel() return out } @@ -183,15 +98,17 @@ func (r *IpnsResolver) resolveOnceAsync(ctx context.Context, name string, option // the value, which in turn verifies the ipns record signature ipnsKey := ipns.RecordKey(pid) - vals, err := r.routing.(*dht.IpfsDHT).SearchValue(ctx, ipnsKey, dht.Quorum(int(options.DhtRecordCount))) + vals, err := r.searchValue(ctx, ipnsKey, dht.Quorum(int(options.DhtRecordCount))) if err != nil { log.Debugf("RoutingResolver: dht get for name %s failed: %s", name, err) out <- onceResult{err: err} close(out) + cancel() return out } go func() { + defer cancel() defer close(out) for { select { @@ -265,3 +182,14 @@ func (r *IpnsResolver) resolveOnceAsync(ctx context.Context, name string, option return out } + +func (r *IpnsResolver) searchValue(ctx context.Context, key string, opts ...ropts.Option) (<-chan []byte, error) { + if ir, ok := r.routing.(*dht.IpfsDHT); ok { + return ir.SearchValue(ctx, key, opts...) + } + out := make(chan []byte, 1) + val, err := r.routing.GetValue(ctx, key, opts...) + out <- val + close(out) + return out, err +}