Add local context to memory operation failures

[onechat] / tree.go

diff --git a/tree.go b/tree.go
index 4309597387a01ff0b6fbfc8e697a7c4a82f84830..db93b1d70357bb98e893e6ee6484b05570b24885 100644 (file)
--- a/tree.go
+++ b/tree.go
@@ -93,19 +93,19 @@ func (t *Tree) open(ctx context.Context, total int) error {
 
        t.order, err = openRecords(filepath.Join(t.dir, "tree.idx"), treeRecordBytes)
        if err != nil {
 
        t.order, err = openRecords(filepath.Join(t.dir, "tree.idx"), treeRecordBytes)
        if err != nil {

-               return err
+               return fmt.Errorf("open node order index: %w", err)

        }
 
        start := Position{}
        if t.order.count == 0 {
                err = t.removeLevels()
                if err != nil {
        }
 
        start := Position{}
        if t.order.count == 0 {
                err = t.removeLevels()
                if err != nil {

-                       return err
+                       return fmt.Errorf("remove empty level indexes: %w", err)

                }
        } else {
                record, _, err := t.order.Read(t.order.count - 1)
                if err != nil {
                }
        } else {
                record, _, err := t.order.Read(t.order.count - 1)
                if err != nil {

-                       return err
+                       return fmt.Errorf("read last node order: %w", err)

                }
 
                // A crash can stop an add between the two index writes, so the
                }
 
                // A crash can stop an add between the two index writes, so the


@@ -113,7 +113,7 @@ func (t *Tree) open(ctx context.Context, total int) error {
                node, last := treeDecodeRecord(record)
                err = t.writeLevel(node, last)
                if err != nil {
                node, last := treeDecodeRecord(record)
                err = t.writeLevel(node, last)
                if err != nil {

-                       return err
+                       return fmt.Errorf("restore last node level: %w", err)

                }
 
                start = Position{
                }
 
                start = Position{


@@ -182,7 +182,7 @@ func (t *Tree) removeLevels() error {
 func (t *Tree) writeLevel(node NodeKey, place Position) error {
        level, err := t.level(node.level)
        if err != nil {
 func (t *Tree) writeLevel(node NodeKey, place Position) error {
        level, err := t.level(node.level)
        if err != nil {

-               return err
+               return fmt.Errorf("open node level index: %w", err)

        }
 
        record := make([]byte, positionBytes)
        }
 
        record := make([]byte, positionBytes)


@@ -203,7 +203,7 @@ func (t *Tree) check(node Node) error {
 
        built, err := t.Built(node.Level, node.Index)
        if err != nil {
 
        built, err := t.Built(node.Level, node.Index)
        if err != nil {

-               return err
+               return fmt.Errorf("check target node: %w", err)

        }
 
        if built {
        }
 
        if built {


@@ -217,7 +217,7 @@ func (t *Tree) check(node Node) error {
        for _, index := range []int{2 * node.Index, 2*node.Index + 1} {
                built, err = t.Built(node.Level-1, index)
                if err != nil {
        for _, index := range []int{2 * node.Index, 2*node.Index + 1} {
                built, err = t.Built(node.Level-1, index)
                if err != nil {

-                       return err
+                       return fmt.Errorf("check child node: %w", err)

                }
 
                if !built {
                }
 
                if !built {


@@ -237,7 +237,7 @@ func (t *Tree) addIndex(node NodeKey, place Position) error {
 
        err := t.order.Append(record)
        if err != nil {
 
        err := t.order.Append(record)
        if err != nil {

-               return err
+               return fmt.Errorf("append node order: %w", err)

        }
 
        return t.writeLevel(node, place)
        }
 
        return t.writeLevel(node, place)


@@ -274,12 +274,16 @@ func (t *Tree) place(level, index int) (Position, bool, error) {
 
        records, err := t.level(level)
        if err != nil {
 
        records, err := t.level(level)
        if err != nil {

-               return Position{}, false, err
+               return Position{}, false, fmt.Errorf("open node level index: %w", err)

        }
 
        record, found, err := records.Read(index)
        if err != nil || !found {
        }
 
        record, found, err := records.Read(index)
        if err != nil || !found {

-               return Position{}, false, err
+               if err != nil {
+                       return Position{}, false, fmt.Errorf("read node level record: %w", err)
+               }
+
+               return Position{}, false, nil

        }
 
        place := decodePosition(record)
        }
 
        place := decodePosition(record)


@@ -295,7 +299,7 @@ func (t *Tree) Add(node Node) error {
 
        err := t.check(node)
        if err != nil {
 
        err := t.check(node)
        if err != nil {

-               return err
+               return fmt.Errorf("validate node: %w", err)

        }
 
        line, err := json.Marshal(node)
        }
 
        line, err := json.Marshal(node)


@@ -320,7 +324,11 @@ func (t *Tree) Add(node Node) error {
 func (t *Tree) Node(level, index int) (Node, bool, error) {
        place, built, err := t.place(level, index)
        if err != nil || !built {
 func (t *Tree) Node(level, index int) (Node, bool, error) {
        place, built, err := t.place(level, index)
        if err != nil || !built {

-               return Node{}, false, err
+               if err != nil {
+                       return Node{}, false, fmt.Errorf("find node position: %w", err)
+               }
+
+               return Node{}, false, nil

        }
 
        line, err := t.journal.Read(place)
        }
 
        line, err := t.journal.Read(place)