Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 5f8cfc9

Browse files
whyrusleepingwhyrusleeping
committedNov 19, 2015
Merge pull request #1965 from ipfs/fix/add-mem-4
Fix/add mem 4
2 parents 09d34db + 02e14c4 commit 5f8cfc9

File tree

10 files changed

+133
-72
lines changed

10 files changed

+133
-72
lines changed
 

‎core/commands/add.go

+9-7
Original file line numberDiff line numberDiff line change
@@ -149,13 +149,15 @@ remains to be implemented.
149149
return err
150150
}
151151

152-
if !hash {
153-
// copy intermediary nodes from editor to our actual dagservice
154-
err := fileAdder.WriteOutputTo(n.DAG)
155-
if err != nil {
156-
log.Error("WRITE OUT: ", err)
157-
return err
158-
}
152+
if hash {
153+
return nil
154+
}
155+
156+
// copy intermediary nodes from editor to our actual dagservice
157+
_, err := fileAdder.Finalize(n.DAG)
158+
if err != nil {
159+
log.Error("WRITE OUT: ", err)
160+
return err
159161
}
160162

161163
return fileAdder.PinRoot()

‎core/commands/object.go

+10-4
Original file line numberDiff line numberDiff line change
@@ -599,14 +599,17 @@ func rmLinkCaller(req cmds.Request, root *dag.Node) (key.Key, error) {
599599

600600
path := req.Arguments()[2]
601601

602-
e := dagutils.NewDagEditor(nd.DAG, root)
602+
e := dagutils.NewDagEditor(root, nd.DAG)
603603

604604
err = e.RmLink(req.Context(), path)
605605
if err != nil {
606606
return "", err
607607
}
608608

609-
nnode := e.GetNode()
609+
nnode, err := e.Finalize(nd.DAG)
610+
if err != nil {
611+
return "", err
612+
}
610613

611614
return nnode.Key()
612615
}
@@ -636,7 +639,7 @@ func addLinkCaller(req cmds.Request, root *dag.Node) (key.Key, error) {
636639
}
637640
}
638641

639-
e := dagutils.NewDagEditor(nd.DAG, root)
642+
e := dagutils.NewDagEditor(root, nd.DAG)
640643

641644
childnd, err := nd.DAG.Get(req.Context(), childk)
642645
if err != nil {
@@ -648,7 +651,10 @@ func addLinkCaller(req cmds.Request, root *dag.Node) (key.Key, error) {
648651
return "", err
649652
}
650653

651-
nnode := e.GetNode()
654+
nnode, err := e.Finalize(nd.DAG)
655+
if err != nil {
656+
return "", err
657+
}
652658

653659
return nnode.Key()
654660
}

‎core/corehttp/gateway_handler.go

+8-2
Original file line numberDiff line numberDiff line change
@@ -320,14 +320,20 @@ func (i *gatewayHandler) putHandler(w http.ResponseWriter, r *http.Request) {
320320
return
321321
}
322322

323-
e := dagutils.NewDagEditor(i.node.DAG, rnode)
323+
e := dagutils.NewDagEditor(rnode, i.node.DAG)
324324
err = e.InsertNodeAtPath(ctx, newPath, newnode, uio.NewEmptyDirectory)
325325
if err != nil {
326326
webError(w, "putHandler: InsertNodeAtPath failed", err, http.StatusInternalServerError)
327327
return
328328
}
329329

330-
newkey, err = e.GetNode().Key()
330+
nnode, err := e.Finalize(i.node.DAG)
331+
if err != nil {
332+
webError(w, "putHandler: could not get node", err, http.StatusInternalServerError)
333+
return
334+
}
335+
336+
newkey, err = nnode.Key()
331337
if err != nil {
332338
webError(w, "putHandler: could not get key of edited node", err, http.StatusInternalServerError)
333339
return

‎core/coreunix/add.go

+19-19
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ import (
2020

2121
"github.com/ipfs/go-ipfs/commands/files"
2222
core "github.com/ipfs/go-ipfs/core"
23-
merkledag "github.com/ipfs/go-ipfs/merkledag"
23+
dag "github.com/ipfs/go-ipfs/merkledag"
2424
unixfs "github.com/ipfs/go-ipfs/unixfs"
2525
logging "github.com/ipfs/go-ipfs/vendor/QmQg1J6vikuXF9oDvm4wpdeAUvvkVEKW1EYDw9HhTMnP2b/go-log"
2626
)
@@ -63,7 +63,7 @@ type AddedObject struct {
6363
}
6464

6565
func NewAdder(ctx context.Context, n *core.IpfsNode, out chan interface{}) *Adder {
66-
e := dagutils.NewDagEditor(NewMemoryDagService(), newDirNode())
66+
e := dagutils.NewDagEditor(newDirNode(), nil)
6767
return &Adder{
6868
ctx: ctx,
6969
node: n,
@@ -90,11 +90,11 @@ type Adder struct {
9090
Trickle bool
9191
Wrap bool
9292
Chunker string
93-
root *merkledag.Node
93+
root *dag.Node
9494
}
9595

9696
// Perform the actual add & pin locally, outputting results to reader
97-
func (params Adder) add(reader io.Reader) (*merkledag.Node, error) {
97+
func (params Adder) add(reader io.Reader) (*dag.Node, error) {
9898
chnk, err := chunk.FromString(reader, params.Chunker)
9999
if err != nil {
100100
return nil, err
@@ -112,7 +112,7 @@ func (params Adder) add(reader io.Reader) (*merkledag.Node, error) {
112112
)
113113
}
114114

115-
func (params *Adder) RootNode() (*merkledag.Node, error) {
115+
func (params *Adder) RootNode() (*dag.Node, error) {
116116
// for memoizing
117117
if params.root != nil {
118118
return params.root, nil
@@ -153,8 +153,8 @@ func (params *Adder) PinRoot() error {
153153
return params.node.Pinning.Flush()
154154
}
155155

156-
func (params *Adder) WriteOutputTo(DAG merkledag.DAGService) error {
157-
return params.editor.WriteOutputTo(DAG)
156+
func (params *Adder) Finalize(DAG dag.DAGService) (*dag.Node, error) {
157+
return params.editor.Finalize(DAG)
158158
}
159159

160160
// Add builds a merkledag from the a reader, pinning all objects to the local
@@ -212,7 +212,7 @@ func AddR(n *core.IpfsNode, root string) (key string, err error) {
212212
// to preserve the filename.
213213
// Returns the path of the added file ("<dir hash>/filename"), the DAG node of
214214
// the directory, and and error if any.
215-
func AddWrapped(n *core.IpfsNode, r io.Reader, filename string) (string, *merkledag.Node, error) {
215+
func AddWrapped(n *core.IpfsNode, r io.Reader, filename string) (string, *dag.Node, error) {
216216
file := files.NewReaderFile(filename, filename, ioutil.NopCloser(r), nil)
217217
dir := files.NewSliceFile("", "", []files.File{file})
218218
fileAdder := NewAdder(n.Context(), n, nil)
@@ -230,7 +230,7 @@ func AddWrapped(n *core.IpfsNode, r io.Reader, filename string) (string, *merkle
230230
return gopath.Join(k.String(), filename), dagnode, nil
231231
}
232232

233-
func (params *Adder) addNode(node *merkledag.Node, path string) error {
233+
func (params *Adder) addNode(node *dag.Node, path string) error {
234234
// patch it into the root
235235
if path == "" {
236236
key, err := node.Key()
@@ -249,7 +249,7 @@ func (params *Adder) addNode(node *merkledag.Node, path string) error {
249249
}
250250

251251
// Add the given file while respecting the params.
252-
func (params *Adder) AddFile(file files.File) (*merkledag.Node, error) {
252+
func (params *Adder) AddFile(file files.File) (*dag.Node, error) {
253253
switch {
254254
case files.IsHidden(file) && !params.Hidden:
255255
log.Debugf("%s is hidden, skipping", file.FileName())
@@ -265,7 +265,7 @@ func (params *Adder) AddFile(file files.File) (*merkledag.Node, error) {
265265
return nil, err
266266
}
267267

268-
dagnode := &merkledag.Node{Data: sdata}
268+
dagnode := &dag.Node{Data: sdata}
269269
_, err = params.node.DAG.Add(dagnode)
270270
if err != nil {
271271
return nil, err
@@ -294,7 +294,7 @@ func (params *Adder) AddFile(file files.File) (*merkledag.Node, error) {
294294
return dagnode, err
295295
}
296296

297-
func (params *Adder) addDir(dir files.File) (*merkledag.Node, error) {
297+
func (params *Adder) addDir(dir files.File) (*dag.Node, error) {
298298
tree := newDirNode()
299299
log.Infof("adding directory: %s", dir.FileName())
300300

@@ -317,7 +317,7 @@ func (params *Adder) addDir(dir files.File) (*merkledag.Node, error) {
317317

318318
_, name := gopath.Split(file.FileName())
319319

320-
if err := tree.AddNodeLink(name, node); err != nil {
320+
if err := tree.AddNodeLinkClean(name, node); err != nil {
321321
return nil, err
322322
}
323323
}
@@ -334,7 +334,7 @@ func (params *Adder) addDir(dir files.File) (*merkledag.Node, error) {
334334
}
335335

336336
// outputDagnode sends dagnode info over the output channel
337-
func outputDagnode(out chan interface{}, name string, dn *merkledag.Node) error {
337+
func outputDagnode(out chan interface{}, name string, dn *dag.Node) error {
338338
if out == nil {
339339
return nil
340340
}
@@ -352,20 +352,20 @@ func outputDagnode(out chan interface{}, name string, dn *merkledag.Node) error
352352
return nil
353353
}
354354

355-
func NewMemoryDagService() merkledag.DAGService {
355+
func NewMemoryDagService() dag.DAGService {
356356
// build mem-datastore for editor's intermediary nodes
357357
bs := bstore.NewBlockstore(syncds.MutexWrap(ds.NewMapDatastore()))
358358
bsrv := bserv.New(bs, offline.Exchange(bs))
359-
return merkledag.NewDAGService(bsrv)
359+
return dag.NewDAGService(bsrv)
360360
}
361361

362362
// TODO: generalize this to more than unix-fs nodes.
363-
func newDirNode() *merkledag.Node {
364-
return &merkledag.Node{Data: unixfs.FolderPBData()}
363+
func newDirNode() *dag.Node {
364+
return &dag.Node{Data: unixfs.FolderPBData()}
365365
}
366366

367367
// from core/commands/object.go
368-
func getOutput(dagnode *merkledag.Node) (*Object, error) {
368+
func getOutput(dagnode *dag.Node) (*Object, error) {
369369
key, err := dagnode.Key()
370370
if err != nil {
371371
return nil, err

‎merkledag/merkledag.go

+11-2
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ type DAGService interface {
2020
AddRecursive(*Node) error
2121
Get(context.Context, key.Key) (*Node, error)
2222
Remove(*Node) error
23+
RemoveRecursive(*Node) error
2324

2425
// GetDAG returns, in order, all the single leve child
2526
// nodes of the passed in node.
@@ -107,10 +108,10 @@ func (n *dagService) Get(ctx context.Context, k key.Key) (*Node, error) {
107108
}
108109

109110
// Remove deletes the given node and all of its children from the BlockService
110-
func (n *dagService) Remove(nd *Node) error {
111+
func (n *dagService) RemoveRecursive(nd *Node) error {
111112
for _, l := range nd.Links {
112113
if l.Node != nil {
113-
n.Remove(l.Node)
114+
n.RemoveRecursive(l.Node)
114115
}
115116
}
116117
k, err := nd.Key()
@@ -120,6 +121,14 @@ func (n *dagService) Remove(nd *Node) error {
120121
return n.Blocks.DeleteBlock(k)
121122
}
122123

124+
func (n *dagService) Remove(nd *Node) error {
125+
k, err := nd.Key()
126+
if err != nil {
127+
return err
128+
}
129+
return n.Blocks.DeleteBlock(k)
130+
}
131+
123132
// FetchGraph fetches all nodes that are children of the given node
124133
func FetchGraph(ctx context.Context, root *Node, serv DAGService) error {
125134
return EnumerateChildrenAsync(ctx, serv, root, key.NewKeySet())

‎merkledag/node.go

+3-1
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,8 @@ import (
99
key "github.com/ipfs/go-ipfs/blocks/key"
1010
)
1111

12+
var ErrLinkNotFound = fmt.Errorf("no link by that name")
13+
1214
// Node represents a node in the IPFS Merkle DAG.
1315
// nodes have opaque data and a set of navigable links.
1416
type Node struct {
@@ -160,7 +162,7 @@ func (n *Node) GetNodeLink(name string) (*Link, error) {
160162
}, nil
161163
}
162164
}
163-
return nil, ErrNotFound
165+
return nil, ErrLinkNotFound
164166
}
165167

166168
func (n *Node) GetLinkedNode(ctx context.Context, ds DAGService, name string) (*Node, error) {

‎merkledag/utils/diff.go

+3-2
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ func (c *Change) String() string {
3737
}
3838

3939
func ApplyChange(ctx context.Context, ds dag.DAGService, nd *dag.Node, cs []*Change) (*dag.Node, error) {
40-
e := NewDagEditor(ds, nd)
40+
e := NewDagEditor(nd, ds)
4141
for _, c := range cs {
4242
switch c.Type {
4343
case Add:
@@ -71,7 +71,8 @@ func ApplyChange(ctx context.Context, ds dag.DAGService, nd *dag.Node, cs []*Cha
7171
}
7272
}
7373
}
74-
return e.GetNode(), nil
74+
75+
return e.Finalize(ds)
7576
}
7677

7778
func Diff(ctx context.Context, ds dag.DAGService, a, b *dag.Node) []*Change {

‎merkledag/utils/utils.go

+62-20
Original file line numberDiff line numberDiff line change
@@ -4,20 +4,41 @@ import (
44
"errors"
55
"strings"
66

7+
ds "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
8+
syncds "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore/sync"
79
context "github.com/ipfs/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
810

11+
bstore "github.com/ipfs/go-ipfs/blocks/blockstore"
12+
bserv "github.com/ipfs/go-ipfs/blockservice"
13+
offline "github.com/ipfs/go-ipfs/exchange/offline"
914
dag "github.com/ipfs/go-ipfs/merkledag"
1015
)
1116

1217
type Editor struct {
1318
root *dag.Node
14-
ds dag.DAGService
19+
20+
// tmp is a temporary in memory (for now) dagstore for all of the
21+
// intermediary nodes to be stored in
22+
tmp dag.DAGService
23+
24+
// src is the dagstore with *all* of the data on it, it is used to pull
25+
// nodes from for modification (nil is a valid value)
26+
src dag.DAGService
27+
}
28+
29+
func NewMemoryDagService() dag.DAGService {
30+
// build mem-datastore for editor's intermediary nodes
31+
bs := bstore.NewBlockstore(syncds.MutexWrap(ds.NewMapDatastore()))
32+
bsrv := bserv.New(bs, offline.Exchange(bs))
33+
return dag.NewDAGService(bsrv)
1534
}
1635

17-
func NewDagEditor(ds dag.DAGService, root *dag.Node) *Editor {
36+
// root is the node to be modified, source is the dagstore to pull nodes from (optional)
37+
func NewDagEditor(root *dag.Node, source dag.DAGService) *Editor {
1838
return &Editor{
1939
root: root,
20-
ds: ds,
40+
tmp: NewMemoryDagService(),
41+
src: source,
2142
}
2243
}
2344

@@ -26,7 +47,7 @@ func (e *Editor) GetNode() *dag.Node {
2647
}
2748

2849
func (e *Editor) GetDagService() dag.DAGService {
29-
return e.ds
50+
return e.tmp
3051
}
3152

3253
func addLink(ctx context.Context, ds dag.DAGService, root *dag.Node, childname string, childnd *dag.Node) (*dag.Node, error) {
@@ -40,6 +61,8 @@ func addLink(ctx context.Context, ds dag.DAGService, root *dag.Node, childname s
4061
return nil, err
4162
}
4263

64+
_ = ds.Remove(root)
65+
4366
// ensure no link with that name already exists
4467
_ = root.RemoveNodeLink(childname) // ignore error, only option is ErrNotFound
4568

@@ -55,41 +78,51 @@ func addLink(ctx context.Context, ds dag.DAGService, root *dag.Node, childname s
5578

5679
func (e *Editor) InsertNodeAtPath(ctx context.Context, path string, toinsert *dag.Node, create func() *dag.Node) error {
5780
splpath := strings.Split(path, "/")
58-
nd, err := insertNodeAtPath(ctx, e.ds, e.root, splpath, toinsert, create)
81+
nd, err := e.insertNodeAtPath(ctx, e.root, splpath, toinsert, create)
5982
if err != nil {
6083
return err
6184
}
6285
e.root = nd
6386
return nil
6487
}
6588

66-
func insertNodeAtPath(ctx context.Context, ds dag.DAGService, root *dag.Node, path []string, toinsert *dag.Node, create func() *dag.Node) (*dag.Node, error) {
89+
func (e *Editor) insertNodeAtPath(ctx context.Context, root *dag.Node, path []string, toinsert *dag.Node, create func() *dag.Node) (*dag.Node, error) {
6790
if len(path) == 1 {
68-
return addLink(ctx, ds, root, path[0], toinsert)
91+
return addLink(ctx, e.tmp, root, path[0], toinsert)
6992
}
7093

71-
nd, err := root.GetLinkedNode(ctx, ds, path[0])
94+
nd, err := root.GetLinkedNode(ctx, e.tmp, path[0])
7295
if err != nil {
7396
// if 'create' is true, we create directories on the way down as needed
74-
if err == dag.ErrNotFound && create != nil {
97+
if err == dag.ErrLinkNotFound && create != nil {
7598
nd = create()
76-
} else {
99+
err = nil // no longer an error case
100+
} else if err == dag.ErrNotFound {
101+
// try finding it in our source dagstore
102+
nd, err = root.GetLinkedNode(ctx, e.src, path[0])
103+
}
104+
105+
// if we receive an ErrNotFound, then our second 'GetLinkedNode' call
106+
// also fails, we want to error out
107+
if err != nil {
77108
return nil, err
78109
}
79110
}
80111

81-
ndprime, err := insertNodeAtPath(ctx, ds, nd, path[1:], toinsert, create)
112+
ndprime, err := e.insertNodeAtPath(ctx, nd, path[1:], toinsert, create)
82113
if err != nil {
83114
return nil, err
84115
}
85116

117+
_ = e.tmp.Remove(root)
118+
86119
_ = root.RemoveNodeLink(path[0])
87120
err = root.AddNodeLinkClean(path[0], ndprime)
88121
if err != nil {
89122
return nil, err
90123
}
91124

92-
_, err = ds.Add(root)
125+
_, err = e.tmp.Add(root)
93126
if err != nil {
94127
return nil, err
95128
}
@@ -99,56 +132,65 @@ func insertNodeAtPath(ctx context.Context, ds dag.DAGService, root *dag.Node, pa
99132

100133
func (e *Editor) RmLink(ctx context.Context, path string) error {
101134
splpath := strings.Split(path, "/")
102-
nd, err := rmLink(ctx, e.ds, e.root, splpath)
135+
nd, err := e.rmLink(ctx, e.root, splpath)
103136
if err != nil {
104137
return err
105138
}
106139
e.root = nd
107140
return nil
108141
}
109142

110-
func rmLink(ctx context.Context, ds dag.DAGService, root *dag.Node, path []string) (*dag.Node, error) {
143+
func (e *Editor) rmLink(ctx context.Context, root *dag.Node, path []string) (*dag.Node, error) {
111144
if len(path) == 1 {
112145
// base case, remove node in question
113146
err := root.RemoveNodeLink(path[0])
114147
if err != nil {
115148
return nil, err
116149
}
117150

118-
_, err = ds.Add(root)
151+
_, err = e.tmp.Add(root)
119152
if err != nil {
120153
return nil, err
121154
}
122155

123156
return root, nil
124157
}
125158

126-
nd, err := root.GetLinkedNode(ctx, ds, path[0])
159+
// search for node in both tmp dagstore and source dagstore
160+
nd, err := root.GetLinkedNode(ctx, e.tmp, path[0])
161+
if err == dag.ErrNotFound {
162+
nd, err = root.GetLinkedNode(ctx, e.src, path[0])
163+
}
164+
127165
if err != nil {
128166
return nil, err
129167
}
130168

131-
nnode, err := rmLink(ctx, ds, nd, path[1:])
169+
nnode, err := e.rmLink(ctx, nd, path[1:])
132170
if err != nil {
133171
return nil, err
134172
}
135173

174+
_ = e.tmp.Remove(root)
175+
136176
_ = root.RemoveNodeLink(path[0])
137177
err = root.AddNodeLinkClean(path[0], nnode)
138178
if err != nil {
139179
return nil, err
140180
}
141181

142-
_, err = ds.Add(root)
182+
_, err = e.tmp.Add(root)
143183
if err != nil {
144184
return nil, err
145185
}
146186

147187
return root, nil
148188
}
149189

150-
func (e *Editor) WriteOutputTo(ds dag.DAGService) error {
151-
return copyDag(e.GetNode(), e.ds, ds)
190+
func (e *Editor) Finalize(ds dag.DAGService) (*dag.Node, error) {
191+
nd := e.GetNode()
192+
err := copyDag(nd, e.tmp, ds)
193+
return nd, err
152194
}
153195

154196
func copyDag(nd *dag.Node, from, to dag.DAGService) error {

‎merkledag/utils/utils_test.go

+5-6
Original file line numberDiff line numberDiff line change
@@ -66,13 +66,12 @@ func assertNodeAtPath(t *testing.T, ds dag.DAGService, root *dag.Node, path stri
6666
}
6767

6868
func TestInsertNode(t *testing.T) {
69-
ds := mdtest.Mock()
7069
root := new(dag.Node)
71-
e := NewDagEditor(ds, root)
70+
e := NewDagEditor(root, nil)
7271

7372
testInsert(t, e, "a", "anodefortesting", false, "")
7473
testInsert(t, e, "a/b", "data", false, "")
75-
testInsert(t, e, "a/b/c/d/e", "blah", false, "merkledag: not found")
74+
testInsert(t, e, "a/b/c/d/e", "blah", false, "no link by that name")
7675
testInsert(t, e, "a/b/c/d/e", "foo", true, "")
7776
testInsert(t, e, "a/b/c/d/f", "baz", true, "")
7877
testInsert(t, e, "a/b/c/d/f", "bar", true, "")
@@ -92,7 +91,7 @@ func TestInsertNode(t *testing.T) {
9291

9392
func testInsert(t *testing.T, e *Editor, path, data string, create bool, experr string) {
9493
child := &dag.Node{Data: []byte(data)}
95-
ck, err := e.ds.Add(child)
94+
ck, err := e.tmp.Add(child)
9695
if err != nil {
9796
t.Fatal(err)
9897
}
@@ -117,8 +116,8 @@ func testInsert(t *testing.T, e *Editor, path, data string, create bool, experr
117116
}
118117

119118
if err != nil {
120-
t.Fatal(err)
119+
t.Fatal(err, path, data, create, experr)
121120
}
122121

123-
assertNodeAtPath(t, e.ds, e.root, path, ck)
122+
assertNodeAtPath(t, e.tmp, e.root, path, ck)
124123
}

‎tar/format.go

+3-9
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ func ImportTar(r io.Reader, ds dag.DAGService) (*dag.Node, error) {
4646
root := new(dag.Node)
4747
root.Data = []byte("ipfs/tar")
4848

49-
e := dagutil.NewDagEditor(ds, root)
49+
e := dagutil.NewDagEditor(root, ds)
5050

5151
for {
5252
h, err := tr.Next()
@@ -91,13 +91,7 @@ func ImportTar(r io.Reader, ds dag.DAGService) (*dag.Node, error) {
9191
}
9292
}
9393

94-
root = e.GetNode()
95-
_, err = ds.Add(root)
96-
if err != nil {
97-
return nil, err
98-
}
99-
100-
return root, nil
94+
return e.Finalize(ds)
10195
}
10296

10397
// adds a '-' to the beginning of each path element so we can use 'data' as a
@@ -178,7 +172,7 @@ func (tr *tarReader) Read(b []byte) (int, error) {
178172
tr.hdrBuf = bytes.NewReader(headerNd.Data)
179173

180174
dataNd, err := headerNd.GetLinkedNode(tr.ctx, tr.ds, "data")
181-
if err != nil && err != dag.ErrNotFound {
175+
if err != nil && err != dag.ErrLinkNotFound {
182176
return 0, err
183177
}
184178

0 commit comments

Comments
 (0)
Please sign in to comment.