cmd/neofs-lens: add error handler after execution command

Use `RunE` instead of `Run` and throw an error to main function. Then handle
error with custom error handler.
Update CHANGELOG.md.

Closes #2890.

Signed-off-by: Andrey Butusov <andrey@nspcc.io>

CHANGELOG.md

@@ -11,10 +11,12 @@ Changelog for NeoFS Node
 
 ### Fixed
 - Do not search for tombstones when handling their expiration, use local indexes instead (#2929)
+- `defer` func is not skipped in cobra-based programs (#2942)
 
 ### Changed
 - `ObjectService`'s `Put` RPC handler caches up to 10K lists of per-object sorted container nodes (#2901)
 - Metabase graveyard scheme (#2929)
+- When an error is returned, no additional help output is displayed in cobra-based programs (#2942)
 
 ### Removed
 

cmd/neofs-lens/internal/meta/get.go

@@ -16,28 +16,35 @@ var getCMD = &cobra.Command{
 	Short: "Object inspection",
 	Long:  `Get specific object from a metabase.`,
 	Args:  cobra.NoArgs,
-	Run:   getFunc,
+	RunE:  getFunc,
 }
 
 func init() {
 	common.AddAddressFlag(getCMD, &vAddress)
 	common.AddComponentPathFlag(getCMD, &vPath)
 }
 
-func getFunc(cmd *cobra.Command, _ []string) {
+func getFunc(cmd *cobra.Command, _ []string) error {
 	var addr oid.Address
 
 	err := addr.DecodeString(vAddress)
-	common.ExitOnErr(cmd, common.Errf("invalid address argument: %w", err))
+	if err != nil {
+		return fmt.Errorf("invalid address argument: %w", err)
+	}
 
-	db := openMeta(cmd, true)
+	db, err := openMeta(true)
+	if err != nil {
+		return err
+	}
 	defer db.Close()
 
 	storageID := meta.StorageIDPrm{}
 	storageID.SetAddress(addr)
 
 	resStorageID, err := db.StorageID(storageID)
-	common.ExitOnErr(cmd, common.Errf("could not check if the obj is small: %w", err))
+	if err != nil {
+		return fmt.Errorf("could not check if the obj is small: %w", err)
+	}
 
 	if id := resStorageID.StorageID(); id != nil {
 		cmd.Printf("Object storageID: %x (%q)\n\n", id, id)
@@ -66,9 +73,13 @@ func getFunc(cmd *cobra.Command, _ []string) {
 			cmd.Println("\tLast:", last)
 		}
 
-		return
+		return nil
+	}
+	if err != nil {
+		return fmt.Errorf("could not get object: %w", err)
 	}
-	common.ExitOnErr(cmd, common.Errf("could not get object: %w", err))
 
 	common.PrintObjectHeader(cmd, *res.Header())
+
+	return nil
 }

cmd/neofs-lens/internal/meta/id.go

@@ -1,6 +1,8 @@
 package meta
 
 import (
+	"fmt"
+
 	"github.com/mr-tron/base58"
 	common "github.com/nspcc-dev/neofs-node/cmd/neofs-lens/internal"
 	"github.com/spf13/cobra"
@@ -10,19 +12,26 @@ var idCMD = &cobra.Command{
 	Use:   "id",
 	Short: "Read shard ID the metabase is attached to",
 	Args:  cobra.NoArgs,
-	Run:   idFunc,
+	RunE:  idFunc,
 }
 
 func init() {
 	common.AddComponentPathFlag(idCMD, &vPath)
 }
 
-func idFunc(cmd *cobra.Command, _ []string) {
-	db := openMeta(cmd, true)
+func idFunc(cmd *cobra.Command, _ []string) error {
+	db, err := openMeta(true)
+	if err != nil {
+		return err
+	}
 	defer db.Close()
 
 	idRaw, err := db.ReadShardID()
-	common.ExitOnErr(cmd, common.Errf("metabase's `ReadShardID`: %w", err))
+	if err != nil {
+		return fmt.Errorf("metabase's `ReadShardID`: %w", err)
+	}
 
 	cmd.Println(base58.Encode(idRaw))
+
+	return nil
 }

cmd/neofs-lens/internal/meta/list-garbage.go

@@ -1,6 +1,8 @@
 package meta
 
 import (
+	"fmt"
+
 	common "github.com/nspcc-dev/neofs-node/cmd/neofs-lens/internal"
 	meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
 	"github.com/spf13/cobra"
@@ -11,15 +13,18 @@ var listGarbageCMD = &cobra.Command{
 	Short: "Garbage listing",
 	Long:  `List all the objects that have received GC Mark.`,
 	Args:  cobra.NoArgs,
-	Run:   listGarbageFunc,
+	RunE:  listGarbageFunc,
 }
 
 func init() {
 	common.AddComponentPathFlag(listGarbageCMD, &vPath)
 }
 
-func listGarbageFunc(cmd *cobra.Command, _ []string) {
-	db := openMeta(cmd, true)
+func listGarbageFunc(cmd *cobra.Command, _ []string) error {
+	db, err := openMeta(true)
+	if err != nil {
+		return err
+	}
 	defer db.Close()
 
 	var garbPrm meta.GarbageIterationPrm
@@ -29,6 +34,10 @@ func listGarbageFunc(cmd *cobra.Command, _ []string) {
 			return nil
 		})
 
-	err := db.IterateOverGarbage(garbPrm)
-	common.ExitOnErr(cmd, common.Errf("could not iterate over garbage bucket: %w", err))
+	err = db.IterateOverGarbage(garbPrm)
+	if err != nil {
+		return fmt.Errorf("could not iterate over garbage bucket: %w", err)
+	}
+
+	return nil
 }

cmd/neofs-lens/internal/meta/list-graveyard.go

@@ -1,6 +1,8 @@
 package meta
 
 import (
+	"fmt"
+
 	common "github.com/nspcc-dev/neofs-node/cmd/neofs-lens/internal"
 	meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
 	"github.com/spf13/cobra"
@@ -11,15 +13,18 @@ var listGraveyardCMD = &cobra.Command{
 	Short: "Graveyard listing",
 	Long:  `List all the objects that have been covered with a Tomb Stone.`,
 	Args:  cobra.NoArgs,
-	Run:   listGraveyardFunc,
+	RunE:  listGraveyardFunc,
 }
 
 func init() {
 	common.AddComponentPathFlag(listGraveyardCMD, &vPath)
 }
 
-func listGraveyardFunc(cmd *cobra.Command, _ []string) {
-	db := openMeta(cmd, true)
+func listGraveyardFunc(cmd *cobra.Command, _ []string) error {
+	db, err := openMeta(true)
+	if err != nil {
+		return err
+	}
 	defer db.Close()
 
 	var gravePrm meta.GraveyardIterationPrm
@@ -35,6 +40,10 @@ func listGraveyardFunc(cmd *cobra.Command, _ []string) {
 			return nil
 		})
 
-	err := db.IterateOverGraveyard(gravePrm)
-	common.ExitOnErr(cmd, common.Errf("could not iterate over graveyard bucket: %w", err))
+	err = db.IterateOverGraveyard(gravePrm)
+	if err != nil {
+		return fmt.Errorf("could not iterate over graveyard bucket: %w", err)
+	}
+
+	return nil
 }

cmd/neofs-lens/internal/meta/list.go

@@ -12,7 +12,7 @@ var listCMD = &cobra.Command{
 	Use:   "list",
 	Short: "List objects in metabase (metabase's List method)",
 	Args:  cobra.NoArgs,
-	Run:   listFunc,
+	RunE:  listFunc,
 }
 
 var vLimit uint32
@@ -29,21 +29,28 @@ func init() {
 	common.AddComponentPathFlag(listCMD, &vPath)
 }
 
-func listFunc(cmd *cobra.Command, _ []string) {
-	db := openMeta(cmd, true)
+func listFunc(cmd *cobra.Command, _ []string) error {
+	db, err := openMeta(true)
+	if err != nil {
+		return err
+	}
 	defer db.Close()
 
 	if vLimit == 0 {
-		common.ExitOnErr(cmd, fmt.Errorf("%s flag must be positive", limitFlagName))
+		return fmt.Errorf("%s flag must be positive", limitFlagName)
 	}
 
 	var prm meta.ListPrm
 	prm.SetCount(vLimit)
 
 	res, err := db.ListWithCursor(prm)
-	common.ExitOnErr(cmd, common.Errf("metabase's `ListWithCursor`: %w", err))
+	if err != nil {
+		return fmt.Errorf("metabase's `ListWithCursor`: %w", err)
+	}
 
 	for _, addressWithType := range res.AddressList() {
 		cmd.Printf("%s, Type: %s\n", addressWithType.Address, addressWithType.Type)
 	}
+
+	return nil
 }

cmd/neofs-lens/internal/meta/put.go

@@ -2,6 +2,7 @@ package meta
 
 import (
 	"errors"
+	"fmt"
 	"os"
 
 	common "github.com/nspcc-dev/neofs-node/cmd/neofs-lens/internal"
@@ -15,43 +16,56 @@ var writeObjectCMD = &cobra.Command{
 	Short: "Put object to metabase",
 	Long:  "Put object from file to metabase",
 	Args:  cobra.NoArgs,
-	Run:   writeObject,
+	RunE:  writeObject,
 }
 
 func init() {
 	common.AddComponentPathFlag(writeObjectCMD, &vPath)
 	common.AddInputPathFile(writeObjectCMD, &vInputObj)
 }
 
-func writeObject(cmd *cobra.Command, _ []string) {
-	db := openMeta(cmd, false)
+func writeObject(cmd *cobra.Command, _ []string) error {
+	db, err := openMeta(false)
+	if err != nil {
+		return err
+	}
 	defer db.Close()
 
-	err := db.Init()
-	common.ExitOnErr(cmd, common.Errf("can't init metabase: %w", err))
+	err = db.Init()
+	if err != nil {
+		return fmt.Errorf("can't init metabase: %w", err)
+	}
 
 	buf, err := os.ReadFile(vInputObj)
-	common.ExitOnErr(cmd, common.Errf("unable to read given file: %w", err))
+	if err != nil {
+		return fmt.Errorf("unable to read given file: %w", err)
+	}
 
 	obj := object.New()
-	common.ExitOnErr(cmd, common.Errf("can't unmarshal object from given file: %w", obj.Unmarshal(buf)))
+	if err := obj.Unmarshal(buf); err != nil {
+		return fmt.Errorf("can't unmarshal object from given file: %w", err)
+	}
 
 	id, ok := obj.ID()
 	if !ok {
-		common.ExitOnErr(cmd, errors.New("missing ID in object"))
+		return errors.New("missing ID in object")
 	}
 
 	cnr, ok := obj.ContainerID()
 	if !ok {
-		common.ExitOnErr(cmd, errors.New("missing container ID in object"))
+		return errors.New("missing container ID in object")
 	}
 
 	var pPrm meta.PutPrm
 	pPrm.SetObject(obj)
 
 	_, err = db.Put(pPrm)
-	common.ExitOnErr(cmd, common.Errf("can't put object: %w", err))
+	if err != nil {
+		return fmt.Errorf("can't put object: %w", err)
+	}
 
 	cmd.Printf("[%s] Object successfully stored\n", vInputObj)
 	cmd.Printf("  OID: %s\n  CID: %s\n", id, cnr)
+
+	return nil
 }

cmd/neofs-lens/internal/meta/root.go

@@ -1,10 +1,10 @@
 package meta
 
 import (
+	"fmt"
 	"os"
 	"time"
 
-	common "github.com/nspcc-dev/neofs-node/cmd/neofs-lens/internal"
 	meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
 	"github.com/spf13/cobra"
 	"go.etcd.io/bbolt"
@@ -39,9 +39,11 @@ func init() {
 	)
 }
 
-func openMeta(cmd *cobra.Command, readOnly bool) *meta.DB {
+func openMeta(readOnly bool) (*meta.DB, error) {
 	_, err := os.Stat(vPath)
-	common.ExitOnErr(cmd, err)
+	if err != nil {
+		return nil, err
+	}
 
 	db := meta.New(
 		meta.WithPath(vPath),
@@ -51,7 +53,9 @@ func openMeta(cmd *cobra.Command, readOnly bool) *meta.DB {
 		}),
 		meta.WithEpochState(epochState{}),
 	)
-	common.ExitOnErr(cmd, common.Errf("could not open metabase: %w", db.Open(readOnly)))
+	if err := db.Open(readOnly); err != nil {
+		return nil, fmt.Errorf("could not open metabase: %w", err)
+	}
 
-	return db
+	return db, nil
 }