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, #623. Signed-off-by: Andrey Butusov <[email protected]>
nspcc-dev · Sep 19, 2024 · 85bf87d · 85bf87d
1 parent bce4dfe
commit 85bf87d
Show file tree

Hide file tree

Showing 24 changed files with 322 additions and 157 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -9,9 +9,11 @@ Changelog for NeoFS Node
 - Expose health status of inner ring via Prometheus (#2934)
 
 ### Fixed
+- `defer` func is not skipped in cobra-based programs (#2938)
 
 ### Changed
 - `ObjectService`'s `Put` RPC handler caches up to 10K lists of per-object sorted container nodes (#2901)
+- When an error is returned, no additional help output is displayed in cobra-based programs (#2938)
 
 ### Removed
 

diff --git a/cmd/neofs-lens/internal/errors.go b/cmd/neofs-lens/internal/errors.go
@@ -2,9 +2,6 @@ package common
 
 import (
 	"fmt"
-	"os"
-
-	"github.com/spf13/cobra"
 )
 
 // Errf returns formatted error in errFmt format if err is not nil.
@@ -15,17 +12,3 @@ func Errf(errFmt string, err error) error {
 
 	return fmt.Errorf(errFmt, err)
 }
-
-// ExitOnErr calls exitOnErrCode with code 1.
-func ExitOnErr(cmd *cobra.Command, err error) {
-	exitOnErrCode(cmd, err, 1)
-}
-
-// exitOnErrCode prints error via cmd and calls os.Exit with passed exit code.
-// Does nothing if err is nil.
-func exitOnErrCode(cmd *cobra.Command, err error, code int) {
-	if err != nil {
-		cmd.PrintErrln(err)
-		os.Exit(code)
-	}
-}
diff --git a/cmd/neofs-lens/internal/meta/get.go b/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 common.Errf("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 common.Errf("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 common.Errf("could not get object: %w", err)
 	}
-	common.ExitOnErr(cmd, common.Errf("could not get object: %w", err))
 
 	common.PrintObjectHeader(cmd, *res.Header())
+
+	return nil
 }
diff --git a/cmd/neofs-lens/internal/meta/id.go b/cmd/neofs-lens/internal/meta/id.go
@@ -10,19 +10,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 common.Errf("metabase's `ReadShardID`: %w", err)
+	}
 
 	cmd.Println(base58.Encode(idRaw))
+
+	return nil
 }
diff --git a/cmd/neofs-lens/internal/meta/list-garbage.go b/cmd/neofs-lens/internal/meta/list-garbage.go
@@ -11,15 +11,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 +32,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 common.Errf("could not iterate over garbage bucket: %w", err)
+	}
+
+	return nil
 }
diff --git a/cmd/neofs-lens/internal/meta/list-graveyard.go b/cmd/neofs-lens/internal/meta/list-graveyard.go
@@ -11,15 +11,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
@@ -34,6 +37,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 common.Errf("could not iterate over graveyard bucket: %w", err)
+	}
+
+	return nil
 }
diff --git a/cmd/neofs-lens/internal/meta/list.go b/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 common.Errf("metabase's `ListWithCursor`: %w", err)
+	}
 
 	for _, addressWithType := range res.AddressList() {
 		cmd.Printf("%s, Type: %s\n", addressWithType.Address, addressWithType.Type)
 	}
+
+	return nil
 }
diff --git a/cmd/neofs-lens/internal/meta/put.go b/cmd/neofs-lens/internal/meta/put.go
@@ -15,43 +15,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 common.Errf("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 common.Errf("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 common.Errf("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 common.Errf("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
 }
diff --git a/cmd/neofs-lens/internal/meta/root.go b/cmd/neofs-lens/internal/meta/root.go
@@ -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, common.Errf("could not open metabase: %w", err)
+	}
 
-	return db
+	return db, nil
 }
diff --git a/cmd/neofs-lens/internal/meta/status.go b/cmd/neofs-lens/internal/meta/status.go
@@ -13,25 +13,33 @@ var statCMD = &cobra.Command{
 	Short: "Object status information",
 	Long:  `Get metabase's indexes related to an object.`,
 	Args:  cobra.NoArgs,
-	Run:   statusFunc,
+	RunE:  statusFunc,
 }
 
 func init() {
 	common.AddAddressFlag(statCMD, &vAddress)
 	common.AddComponentPathFlag(statCMD, &vPath)
 }
 
-func statusFunc(cmd *cobra.Command, _ []string) {
+func statusFunc(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 common.Errf("invalid address argument: %w", err)
+	}
+
+	db, err := openMeta(true)
+	if err != nil {
+		return err
+	}
 
-	db := openMeta(cmd, true)
 	defer db.Close()
 
 	res, err := db.ObjectStatus(addr)
-	common.ExitOnErr(cmd, common.Errf("reading object status: %w", err))
+	if err != nil {
+		return common.Errf("reading object status: %w", err)
+	}
 
 	const emptyValPlaceholder = "<empty>"
 	storageID := res.StorageID
@@ -52,4 +60,6 @@ func statusFunc(cmd *cobra.Command, _ []string) {
 		cmd.Printf("\tBucket: %d\n"+
 			"\tValue (HEX): %s\n", bucket.BucketIndex, valStr)
 	}
+
+	return nil
 }