tree-wide: Drop the old btrfstree.TreeOperator API

3 files changed, 5 insertions, 153 deletions

diff --git a/lib/btrfs/btrfstree/btree.go b/lib/btrfs/btrfstree/btree.go
index cbaa6d0..25259c0 100644
--- a/lib/btrfs/btrfstree/btree.go
+++ b/lib/btrfs/btrfstree/btree.go
@@ -137,59 +137,6 @@ type TreeWalkHandler struct {
 	BadItem    func(Path, Item)
 }
 
-// Compat //////////////////////////////////////////////////////////////////////
-
-// TreeOperator is an interface for performing basic btree operations.
-type TreeOperator interface {
-	// TreeWalk walks a tree, triggering callbacks for every node,
-	// key-pointer, and item; as well as for any errors encountered.
-	//
-	// If the tree is valid, then everything is walked in key-order; but
-	// if the tree is broken, then ordering is not guaranteed.
-	//
-	// Canceling the Context causes TreeWalk to return early; no values
-	// from the Context are used.
-	//
-	// The lifecycle of callbacks is:
-	//
-	//	000  (read superblock) (maybe cbs.BadSuperblock())
-	//
-	//	001  (read node)
-	//	002  cbs.Node() or cbs.BadNode()
-	//	     if interior:
-	//	       for kp in node.items:
-	//	003a     if cbs.PreKeyPointer == nil || cbs.PreKeyPointer() {
-	//	004b       (recurse)
-	//	     else:
-	//	       for item in node.items:
-	//	003b     cbs.Item() or cbs.BadItem()
-	TreeWalk(ctx context.Context, treeID btrfsprim.ObjID, errHandle func(*TreeError), cbs TreeWalkHandler)
-
-	TreeLookup(treeID btrfsprim.ObjID, key btrfsprim.Key) (Item, error)
-	TreeSearch(treeID btrfsprim.ObjID, search TreeSearcher) (Item, error)
-
-	// If some items are able to be read, but there is an error reading the
-	// full set, then it might return *both* a list of items and an error.
-	//
-	// If the tree is not found, an error that is ErrNoTree is
-	// returned.
-	//
-	// If no such item is found, an error that is ErrNoItem is
-	// returned.
-	TreeSearchAll(treeID btrfsprim.ObjID, search TreeSearcher) ([]Item, error)
-}
-
-type TreeError struct {
-	Path Path
-	Err  error
-}
-
-func (e *TreeError) Unwrap() error { return e.Err }
-
-func (e *TreeError) Error() string {
-	return fmt.Sprintf("%v: %v", e.Path, e.Err)
-}
-
 type NodeSource interface {
 	Superblock() (*Superblock, error)
 	AcquireNode(ctx context.Context, addr btrfsvol.LogicalAddr, exp NodeExpectations) (*Node, error)
diff --git a/lib/btrfs/btrfstree/btree_forrest.go b/lib/btrfs/btrfstree/btree_forrest.go
index 4a4a4c0..1a80504 100644
--- a/lib/btrfs/btrfstree/btree_forrest.go
+++ b/lib/btrfs/btrfstree/btree_forrest.go
@@ -40,27 +40,6 @@ type TreeRoot struct {
 // LookupTreeRoot, as LookupTreeRoot will not call ForrestLookup for
 // ROOT_TREE_OBJECTID; so it will not be an infinite recursion.
 func LookupTreeRoot(ctx context.Context, forrest Forrest, sb Superblock, treeID btrfsprim.ObjID) (*TreeRoot, error) {
-	return OldLookupTreeRoot(
-		ctx,
-		func(rootTreeID btrfsprim.ObjID, searcher TreeSearcher) (Item, error) {
-			rootTree, err := forrest.ForrestLookup(ctx, rootTreeID)
-			if err != nil {
-				return Item{}, err
-			}
-			rootItem, err := rootTree.TreeSearch(ctx, searcher)
-			if err != nil {
-				return Item{}, err
-			}
-			return rootItem, nil
-		},
-		sb,
-		treeID,
-	)
-}
-
-// OldLookupTreeRoot is a utility function to help with implementing
-// the old 'TreeOperator' interface.
-func OldLookupTreeRoot(_ context.Context, treeSearch func(treeID btrfsprim.ObjID, _ TreeSearcher) (Item, error), sb Superblock, treeID btrfsprim.ObjID) (*TreeRoot, error) {
 	switch treeID {
 	case btrfsprim.ROOT_TREE_OBJECTID:
 		return &TreeRoot{
@@ -91,7 +70,11 @@ func OldLookupTreeRoot(_ context.Context, treeSearch func(treeID btrfsprim.ObjID
 			Generation: sb.BlockGroupRootGeneration,
 		}, nil
 	default:
-		rootItem, err := treeSearch(btrfsprim.ROOT_TREE_OBJECTID, SearchRootItem(treeID))
+		rootTree, err := forrest.ForrestLookup(ctx, btrfsprim.ROOT_TREE_OBJECTID)
+		if err != nil {
+			return nil, fmt.Errorf("tree %s: %w", treeID.Format(btrfsprim.ROOT_TREE_OBJECTID), err)
+		}
+		rootItem, err := rootTree.TreeSearch(ctx, SearchRootItem(treeID))
 		if err != nil {
 			if errors.Is(err, ErrNoItem) {
 				err = fmt.Errorf("%w: %s", ErrNoTree, err)
@@ -152,57 +135,3 @@ func (forrest RawForrest) ForrestLookup(ctx context.Context, treeID btrfsprim.Ob
 	}
 	return tree, nil
 }
-
-// Compat //////////////////////////////////////////////////////////////////////
-
-var _ TreeOperator = RawForrest{}
-
-type TreeOperatorImpl = RawForrest
-
-// TreeWalk implements the 'TreeOperator' interface.
-func (forrest RawForrest) TreeWalk(ctx context.Context, treeID btrfsprim.ObjID, errHandle func(*TreeError), cbs TreeWalkHandler) {
-	tree, err := forrest.RawTree(ctx, treeID)
-	if err != nil {
-		errHandle(&TreeError{Path: Path{PathRoot{TreeID: treeID}}, Err: err})
-		return
-	}
-	tree.TreeWalk(ctx, cbs)
-}
-
-// TreeLookup implements the 'TreeOperator' interface.
-func (forrest RawForrest) TreeLookup(treeID btrfsprim.ObjID, key btrfsprim.Key) (Item, error) {
-	ctx := context.TODO()
-	tree, err := forrest.RawTree(ctx, treeID)
-	if err != nil {
-		return Item{}, err
-	}
-	return tree.TreeLookup(ctx, key)
-}
-
-// TreeSearch implements the 'TreeOperator' interface.
-func (forrest RawForrest) TreeSearch(treeID btrfsprim.ObjID, searcher TreeSearcher) (Item, error) {
-	ctx := context.TODO()
-	tree, err := forrest.RawTree(ctx, treeID)
-	if err != nil {
-		return Item{}, err
-	}
-	return tree.TreeSearch(ctx, searcher)
-}
-
-// TreeSearchAll implements the 'TreeOperator' interface.
-func (forrest RawForrest) TreeSearchAll(treeID btrfsprim.ObjID, searcher TreeSearcher) ([]Item, error) {
-	ctx := context.TODO()
-	tree, err := forrest.RawTree(ctx, treeID)
-	if err != nil {
-		return nil, err
-	}
-
-	var ret []Item
-	err = tree.TreeSubrange(ctx, 1, searcher, func(item Item) bool {
-		item.Body = item.Body.CloneItem()
-		ret = append(ret, item)
-		return true
-	})
-
-	return ret, err
-}
diff --git a/lib/btrfs/io3_btree.go b/lib/btrfs/io3_btree.go
index 59e4c1d..01797df 100644
--- a/lib/btrfs/io3_btree.go
+++ b/lib/btrfs/io3_btree.go
@@ -89,30 +89,6 @@ func (fs *FS) ForrestLookup(ctx context.Context, treeID btrfsprim.ObjID) (btrfst
 
 var _ btrfstree.Forrest = (*FS)(nil)
 
-// btrfstree.TreeOperator //////////////////////////////////////////////////////
-
-// TreeWalk implements btrfstree.TreeOperator.
-func (fs *FS) TreeWalk(ctx context.Context, treeID btrfsprim.ObjID, errHandle func(*btrfstree.TreeError), cbs btrfstree.TreeWalkHandler) {
-	btrfstree.TreeOperatorImpl{NodeSource: fs}.TreeWalk(ctx, treeID, errHandle, cbs)
-}
-
-// TreeLookup implements btrfstree.TreeOperator.
-func (fs *FS) TreeLookup(treeID btrfsprim.ObjID, key btrfsprim.Key) (btrfstree.Item, error) {
-	return btrfstree.TreeOperatorImpl{NodeSource: fs}.TreeLookup(treeID, key)
-}
-
-// TreeSearch implements btrfstree.TreeOperator.
-func (fs *FS) TreeSearch(treeID btrfsprim.ObjID, searcher btrfstree.TreeSearcher) (btrfstree.Item, error) {
-	return btrfstree.TreeOperatorImpl{NodeSource: fs}.TreeSearch(treeID, searcher)
-}
-
-// TreeSearchAll implements btrfstree.TreeOperator.
-func (fs *FS) TreeSearchAll(treeID btrfsprim.ObjID, searcher btrfstree.TreeSearcher) ([]btrfstree.Item, error) {
-	return btrfstree.TreeOperatorImpl{NodeSource: fs}.TreeSearchAll(treeID, searcher)
-}
-
-var _ btrfstree.TreeOperator = (*FS)(nil)
-
 // ReadableFS //////////////////////////////////////////////////////////////////
 
 type ReadableFS interface {