DAOS-18304 ddb: Add unit test to ddb code

Refactoring DDB code to allow unit testing of the go part code:
- The GO interface DdbApi is introduced to allow the use of GO test stub.
- Refactor initialisation of the C structure from the Go Code to allow the use of GO test stub.
- The useless C attributes dc_pool_path and dc_db_path are removed.

Following issues are also fixed:
- Remove invalid restrictions on pool file path size.
- Improper cleanup of the function ddb_run_feature().
- Fix invalid return code with non-interactive mode
- Fix rm_pool command:
  - Add db_path parameter to pool destroy command.
  - Makes vos_path parameter mandatory to pool destroy command.
- Cleanup of the ddb error message with invalid command.

Features: recovery
Signed-off-by: Cedric Koch-Hofer <cedric.koch-hofer@hpe.com>

Author: kanard38

src/control/cmd/ddb/commands_wrapper.go

@@ -270,14 +270,18 @@ func (ctx *DdbContext) Feature(path, db_path, enable, disable string, show bool)
 	options.db_path = C.CString(db_path)
 	defer freeString(options.db_path)
 	if enable != "" {
-		err := daosError(C.ddb_feature_string2flags(&ctx.ctx, C.CString(enable),
+		cEnable := C.CString(enable)
+		defer freeString(cEnable)
+		err := daosError(C.ddb_feature_string2flags(&ctx.ctx, cEnable,
 			&options.set_compat_flags, &options.set_incompat_flags))
 		if err != nil {
 			return err
 		}
 	}
 	if disable != "" {
-		err := daosError(C.ddb_feature_string2flags(&ctx.ctx, C.CString(disable),
+		cDisable := C.CString(disable)
+		defer freeString(cDisable)
+		err := daosError(C.ddb_feature_string2flags(&ctx.ctx, cDisable,
 			&options.clear_compat_flags, &options.clear_incompat_flags))
 		if err != nil {
 			return err
@@ -336,8 +340,8 @@ func (ctx *DdbContext) DtxStat(path string, details bool) error {
 	/* Set up the options */
 	options := C.struct_dtx_stat_options{}
 	options.path = C.CString(path)
-	options.details = C.bool(details)
 	defer freeString(options.path)
+	options.details = C.bool(details)
 	/* Run the c code command */
 	return daosError(C.ddb_run_dtx_stat(&ctx.ctx, &options))
 }

src/control/cmd/ddb/main.go

@@ -29,14 +29,23 @@ import (
 	"github.com/daos-stack/daos/src/control/server/engine"
 )
 
+type unknownCmdError struct {
+	cmd string
+}
+
+func (e *unknownCmdError) Error() string {
+	return fmt.Sprintf("Error running command '%s' unknown command, try 'help'", e.cmd)
+}
+
 func exitWithError(err error) {
 	cmdName := filepath.Base(os.Args[0])
 	msg := fmt.Sprintf("ERROR: %s: %v", cmdName, err)
 	if fault.HasResolution(err) {
 		msg = fmt.Sprintf("%s (%s)", msg, fault.ShowResolutionFor(err))
 	}
 	fmt.Fprintln(os.Stderr, msg)
-	if err.Error() == grumbleUnknownCmdErr {
+
+	if _, ok := err.(*unknownCmdError); ok {
 		app := createGrumbleApp(nil)
 		printCommands(os.Stderr, app)
 	}
@@ -157,16 +166,9 @@ func printGeneralHelp(app *grumble.App, generalMsg string) {
 // Caveat: There is no known easy way of forcing grumble to use log to print the generated message
 // so the output goes directly to stdout.
 func printCmdHelp(app *grumble.App, opts *cliOptions) {
-	err := runCmdStr(app, nil, string(opts.Args.RunCmd), "--help")
-	if err == nil {
-		// This branch should never be reached: printCmdHelp is only called when go-flags returns a
-		// flags.ErrHelp error (see parseOpts), which means "--help" was recognized as a valid flag.
-		// Grumble will therefore always return an error when attempting to run the command with "--help".
-		fmt.Fprintf(os.Stderr, "FATAL: Unexpected: command help returned no error.\n")
-		os.Exit(1)
+	if err := runCmdStr(app, nil, string(opts.Args.RunCmd), "--help"); err != nil {
+		exitWithError(&unknownCmdError{cmd: opts.Args.RunCmd})
 	}
-	fmt.Fprintf(os.Stderr, "%v\n", err)
-	printCommands(os.Stderr, app)
 }
 
 // Prints either general or command-specific help message.
@@ -319,16 +321,19 @@ func parseOpts(args []string, api DdbApi) error {
 	app := createGrumbleApp(api)
 
 	if opts.VosPath != "" {
-		prefixesToSkip := []string{"feature", "open", "close", "prov_mem", "smd_sync", "rm_pool", "dev_list", "dev_replace"}
-		needsConnection := !func() bool {
-			for _, prefix := range prefixesToSkip {
-				if strings.HasPrefix(string(opts.Args.RunCmd), prefix) {
-					return true
-				}
-			}
-			return false
-		}()
-		if needsConnection {
+		// Commands that manage the pool open/close lifecycle themselves and must
+		// not have the pool pre-opened by the CLI layer.
+		noAutoOpen := map[string]bool{
+			"feature":     true,
+			"open":        true,
+			"close":       true,
+			"prov_mem":    true,
+			"smd_sync":    true,
+			"rm_pool":     true,
+			"dev_list":    true,
+			"dev_replace": true,
+		}
+		if !noAutoOpen[opts.Args.RunCmd] {
 			log.Debugf("Connect to path: %s\n", opts.VosPath)
 			if err := api.Open(string(opts.VosPath), string(opts.SysdbPath), opts.WriteMode); err != nil {
 				return errors.Wrapf(err, vosPathOpenErr, opts.VosPath)
@@ -344,6 +349,9 @@ func parseOpts(args []string, api DdbApi) error {
 		} else {
 			err = runFileCmds(log, app, opts.CmdFile)
 		}
+		if err != nil && err.Error() == grumbleUnknownCmdErr {
+			return &unknownCmdError{cmd: opts.Args.RunCmd}
+		}
 		return err
 	}