Feature: podman can be an alternative container engine

Signed-off-by: caoxianfei1 <[email protected]>

Author: caoxianfei1

cli/cli/cli.go

@@ -94,11 +94,11 @@ func NewCurveAdm() (*CurveAdm, error) {
 
 	rootDir := fmt.Sprintf("%s/.curveadm", home)
 	curveadm := &CurveAdm{
-		rootDir:   rootDir,
-		dataDir:   path.Join(rootDir, "data"),
-		pluginDir: path.Join(rootDir, "plugins"),
-		logDir:    path.Join(rootDir, "logs"),
-		tempDir:   path.Join(rootDir, "temp"),
+		rootDir:      rootDir,
+		dataDir:      path.Join(rootDir, "data"),
+		pluginDir:    path.Join(rootDir, "plugins"),
+		logDir:       path.Join(rootDir, "logs"),
+		tempDir:      path.Join(rootDir, "temp"),
 		httpConfPath: path.Join(rootDir, "http/conf"),
 		httpLogPath:  path.Join(rootDir, "http/logs"),
 	}
@@ -294,6 +294,7 @@ func (curveadm *CurveAdm) LogPath() string                   { return curveadm.l
 func (curveadm *CurveAdm) Config() *configure.CurveAdmConfig { return curveadm.config }
 func (curveadm *CurveAdm) SudoAlias() string                 { return curveadm.config.GetSudoAlias() }
 func (curveadm *CurveAdm) SSHTimeout() int                   { return curveadm.config.GetSSHTimeout() }
+func (curveadm *CurveAdm) Engine() string                    { return curveadm.config.GetEngine() }
 func (curveadm *CurveAdm) In() io.Reader                     { return curveadm.in }
 func (curveadm *CurveAdm) Out() io.Writer                    { return curveadm.out }
 func (curveadm *CurveAdm) Err() io.Writer                    { return curveadm.err }
@@ -421,6 +422,7 @@ func (curveadm *CurveAdm) ExecOptions() module.ExecOptions {
 		ExecInLocal:    false,
 		ExecSudoAlias:  curveadm.config.GetSudoAlias(),
 		ExecTimeoutSec: curveadm.config.GetTimeout(),
+		ExecWithEngine: curveadm.config.GetEngine(),
 	}
 }
 

internal/configure/curveadm/curveadm.go

@@ -44,6 +44,7 @@ import (
 const (
 	KEY_LOG_LEVEL    = "log_level"
 	KEY_SUDO_ALIAS   = "sudo_alias"
+	KEY_ENGINE       = "engine"
 	KEY_TIMEOUT      = "timeout"
 	KEY_AUTO_UPGRADE = "auto_upgrade"
 	KEY_SSH_RETRIES  = "retries"
@@ -56,6 +57,7 @@ type (
 	CurveAdmConfig struct {
 		LogLevel    string
 		SudoAlias   string
+		Engine      string
 		Timeout     int
 		AutoUpgrade bool
 		SSHRetries  int
@@ -74,6 +76,7 @@ var (
 	defaultCurveAdmConfig = &CurveAdmConfig{
 		LogLevel:    "error",
 		SudoAlias:   "sudo",
+		Engine:      "docker",
 		Timeout:     180,
 		AutoUpgrade: true,
 		SSHRetries:  3,
@@ -133,6 +136,10 @@ func parseDefaultsSection(cfg *CurveAdmConfig, defaults map[string]interface{})
 		case KEY_SUDO_ALIAS:
 			cfg.SudoAlias = v.(string)
 
+		// container engine
+		case KEY_ENGINE:
+			cfg.Engine = v.(string)
+
 		// timeout
 		case KEY_TIMEOUT:
 			num, err := requirePositiveInt(KEY_TIMEOUT, v)
@@ -229,6 +236,7 @@ func (cfg *CurveAdmConfig) GetTimeout() int      { return cfg.Timeout }
 func (cfg *CurveAdmConfig) GetAutoUpgrade() bool { return cfg.AutoUpgrade }
 func (cfg *CurveAdmConfig) GetSSHRetries() int   { return cfg.SSHRetries }
 func (cfg *CurveAdmConfig) GetSSHTimeout() int   { return cfg.SSHTimeout }
+func (cfg *CurveAdmConfig) GetEngine() string    { return cfg.Engine }
 func (cfg *CurveAdmConfig) GetSudoAlias() string {
 	if len(cfg.SudoAlias) == 0 {
 		return WITHOUT_SUDO

internal/errno/errno.go

@@ -107,6 +107,15 @@ func (e *ErrorCode) F(format string, a ...interface{}) *ErrorCode {
 	return e
 }
 
+func (e *ErrorCode) FD(format string, s ...interface{}) *ErrorCode {
+	newEC := &ErrorCode{
+		code:        e.code,
+		description: e.description,
+	}
+	newEC.description = fmt.Sprintf(newEC.description+" "+format, s...)
+	return newEC
+}
+
 func (e *ErrorCode) Error() string {
 	if e.code == CODE_CANCEL_OPERATION {
 		return ""
@@ -470,10 +479,10 @@ var (
 	ERR_SSH_CONNECT_FAILED = EC(510000, "SSH connect failed")
 
 	// 520: checker (permission)
-	ERR_USER_NOT_FOUND                           = EC(520000, "user not found")
-	ERR_HOSTNAME_NOT_RESOLVED                    = EC(520001, "hostname not resolved")
-	ERR_CREATE_DIRECOTRY_PERMISSION_DENIED       = EC(520002, "create direcotry permission denied")
-	ERR_EXECUTE_DOCKER_COMMAND_PERMISSION_DENIED = EC(520003, "execute docker command permission denied")
+	ERR_USER_NOT_FOUND                                     = EC(520000, "user not found")
+	ERR_HOSTNAME_NOT_RESOLVED                              = EC(520001, "hostname not resolved")
+	ERR_CREATE_DIRECOTRY_PERMISSION_DENIED                 = EC(520002, "create direcotry permission denied")
+	ERR_EXECUTE_CONTAINER_ENGINE_COMMAND_PERMISSION_DENIED = EC(520003, "execute docker/podman command permission denied")
 
 	// 530: checker (kernel)
 	ERR_UNRECOGNIZED_KERNEL_VERSION              = EC(530000, "unrecognized kernel version")
@@ -500,9 +509,9 @@ var (
 	ERR_INVALID_CURVEFS_CLIENT_S3_BUCKET_NAME = EC(570003, "invalid curvefs client S3 bucket name")
 
 	// 590: checker (others)
-	ERR_DOCKER_NOT_INSTALLED         = EC(590000, "docker not installed")
-	ERR_DOCKER_DAEMON_IS_NOT_RUNNING = EC(590001, "docker daemon is not running")
-	ERR_NO_SPACE_LEFT_ON_DEVICE      = EC(590002, "no space left on device")
+	ERR_CONTAINER_ENGINE_NOT_INSTALLED = EC(590000, "container engine docker/podman not installed")
+	ERR_DOCKER_DAEMON_IS_NOT_RUNNING   = EC(590001, "docker daemon is not running")
+	ERR_NO_SPACE_LEFT_ON_DEVICE        = EC(590002, "no space left on device")
 
 	// 600: exeute task (common)
 	ERR_EXECUTE_COMMAND_TIMED_OUT = EC(600000, "execute command timed out")
@@ -547,22 +556,22 @@ var (
 	ERR_RUN_SCRIPT_FAILED                          = EC(620998, "run script failed (bash script.sh)")
 	ERR_RUN_A_BASH_COMMAND_FAILED                  = EC(620999, "run a bash command failed (bash -c)")
 
-	// 630: execute task (docker command)
-	ERR_GET_DOCKER_INFO_FAILED          = EC(630000, "get docker info failed (docker info)")
-	ERR_PULL_IMAGE_FAILED               = EC(630001, "pull image failed (docker pull IMAGE)")
-	ERR_CREATE_CONTAINER_FAILED         = EC(630002, "create container failed (docker create IMAGE)")
-	ERR_START_CONTAINER_FAILED          = EC(630003, "start container failed (docker start CONTAINER)")
-	ERR_STOP_CONTAINER_FAILED           = EC(630004, "stop container failed (docker stop CONTAINER)")
-	ERR_RESTART_CONTAINER_FAILED        = EC(630005, "restart container failed (docker restart CONTAINER)")
-	ERR_WAIT_CONTAINER_STOP_FAILED      = EC(630006, "wait container stop failed (docker wait CONTAINER)")
-	ERR_REMOVE_CONTAINER_FAILED         = EC(630007, "remove container failed (docker rm CONTAINER)")
-	ERR_LIST_CONTAINERS_FAILED          = EC(630008, "list containers failed (docker ps)")
-	ERR_RUN_COMMAND_IN_CONTAINER_FAILED = EC(630009, "run a command in container failed (docker exec CONTAINER COMMAND)")
-	ERR_COPY_FROM_CONTAINER_FAILED      = EC(630010, "copy file from container failed (docker cp CONTAINER:SRC_PATH DEST_PATH)")
-	ERR_COPY_INTO_CONTAINER_FAILED      = EC(630011, "copy file into container failed (docker cp SRC_PATH CONTAINER:DEST_PATH)")
-	ERR_INSPECT_CONTAINER_FAILED        = EC(630012, "get container low-level information failed (docker inspect ID)")
-	ERR_GET_CONTAINER_LOGS_FAILED       = EC(630013, "get container logs failed (docker logs ID)")
-	ERR_UPDATE_CONTAINER_FAILED         = EC(630014, "update container failed (docker update ID)")
+	// 630: execute task (docker/podman command)
+	ERR_GET_CONTAINER_ENGINE_INFO_FAILED = EC(630000, "get container engine info failed")
+	ERR_PULL_IMAGE_FAILED                = EC(630001, "pull image failed")
+	ERR_CREATE_CONTAINER_FAILED          = EC(630002, "create container failed")
+	ERR_START_CONTAINER_FAILED           = EC(630003, "start container failed")
+	ERR_STOP_CONTAINER_FAILED            = EC(630004, "stop container failed")
+	ERR_RESTART_CONTAINER_FAILED         = EC(630005, "restart container failed")
+	ERR_WAIT_CONTAINER_STOP_FAILED       = EC(630006, "wait container stop failed")
+	ERR_REMOVE_CONTAINER_FAILED          = EC(630007, "remove container failed")
+	ERR_LIST_CONTAINERS_FAILED           = EC(630008, "list containers failed")
+	ERR_RUN_COMMAND_IN_CONTAINER_FAILED  = EC(630009, "run a command in container failed")
+	ERR_COPY_FROM_CONTAINER_FAILED       = EC(630010, "copy file from container failed")
+	ERR_COPY_INTO_CONTAINER_FAILED       = EC(630011, "copy file into container failed")
+	ERR_INSPECT_CONTAINER_FAILED         = EC(630012, "get container low-level information failed")
+	ERR_GET_CONTAINER_LOGS_FAILED        = EC(630013, "get container logs failed")
+	ERR_UPDATE_CONTAINER_FAILED          = EC(630014, "update container failed")
 
 	// 690: execuetr task (others)
 	ERR_START_CRONTAB_IN_CONTAINER_FAILED = EC(690000, "start crontab in container failed")

internal/task/scripts/script.go

@@ -30,7 +30,7 @@ const (
 
 var (
 	SCRIPT_WAIT              string = WAIT
-	SCRIPT_COLLECT           string = COLLECT
+	SCRIPT_COLLECT           string = COLLECT // not used
 	SCRIPT_REPORT            string = REPORT
 	SCRIPT_FORMAT            string = FORMAT
 	SCRIPT_MAP               string = MAP

internal/task/step/container.go

@@ -31,7 +31,7 @@ import (
 )
 
 type (
-	DockerInfo struct {
+	EngineInfo struct {
 		Success *bool
 		Out     *string
 		module.ExecOptions
@@ -164,16 +164,16 @@ type (
 	}
 )
 
-func (s *DockerInfo) Execute(ctx *context.Context) error {
+func (s *EngineInfo) Execute(ctx *context.Context) error {
 	cli := ctx.Module().DockerCli().DockerInfo()
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(s.Success, s.Out, out, err, errno.ERR_GET_DOCKER_INFO_FAILED)
+	return PostHandle(s.Success, s.Out, out, err, errno.ERR_GET_CONTAINER_ENGINE_INFO_FAILED.FD("(%s info)", s.ExecWithEngine))
 }
 
 func (s *PullImage) Execute(ctx *context.Context) error {
 	cli := ctx.Module().DockerCli().PullImage(s.Image)
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(nil, s.Out, out, err, errno.ERR_PULL_IMAGE_FAILED)
+	return PostHandle(nil, s.Out, out, err, errno.ERR_PULL_IMAGE_FAILED.FD("(%s pull IMAGE)", s.ExecWithEngine))
 }
 
 func (s *CreateContainer) Execute(ctx *context.Context) error {
@@ -239,13 +239,13 @@ func (s *CreateContainer) Execute(ctx *context.Context) error {
 	}
 
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(nil, s.Out, out, err, errno.ERR_CREATE_CONTAINER_FAILED)
+	return PostHandle(nil, s.Out, out, err, errno.ERR_CREATE_CONTAINER_FAILED.FD("(%s create IMAGE)", s.ExecWithEngine))
 }
 
 func (s *StartContainer) Execute(ctx *context.Context) error {
 	cli := ctx.Module().DockerCli().StartContainer(*s.ContainerId)
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(s.Success, s.Out, out, err, errno.ERR_START_CONTAINER_FAILED)
+	return PostHandle(s.Success, s.Out, out, err, errno.ERR_START_CONTAINER_FAILED.FD("(%s start CONTAINER)", s.ExecWithEngine))
 }
 
 func (s *StopContainer) Execute(ctx *context.Context) error {
@@ -255,25 +255,25 @@ func (s *StopContainer) Execute(ctx *context.Context) error {
 	}
 
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(nil, s.Out, out, err, errno.ERR_STOP_CONTAINER_FAILED)
+	return PostHandle(nil, s.Out, out, err, errno.ERR_STOP_CONTAINER_FAILED.FD("(%s stop CONTAINER)", s.ExecWithEngine))
 }
 
 func (s *RestartContainer) Execute(ctx *context.Context) error {
 	cli := ctx.Module().DockerCli().RestartContainer(s.ContainerId)
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(nil, s.Out, out, err, errno.ERR_RESTART_CONTAINER_FAILED)
+	return PostHandle(nil, s.Out, out, err, errno.ERR_RESTART_CONTAINER_FAILED.FD("(%s restart CONTAINER)", s.ExecWithEngine))
 }
 
 func (s *WaitContainer) Execute(ctx *context.Context) error {
 	cli := ctx.Module().DockerCli().WaitContainer(s.ContainerId)
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(nil, s.Out, out, err, errno.ERR_WAIT_CONTAINER_STOP_FAILED)
+	return PostHandle(nil, s.Out, out, err, errno.ERR_WAIT_CONTAINER_STOP_FAILED.FD("(%s wait CONTAINER)", s.ExecWithEngine))
 }
 
 func (s *RemoveContainer) Execute(ctx *context.Context) error {
 	cli := ctx.Module().DockerCli().RemoveContainer(s.ContainerId)
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(s.Success, s.Out, out, err, errno.ERR_REMOVE_CONTAINER_FAILED)
+	return PostHandle(s.Success, s.Out, out, err, errno.ERR_REMOVE_CONTAINER_FAILED.FD("(%s rm CONTAINER)", s.ExecWithEngine))
 }
 
 func (s *ListContainers) Execute(ctx *context.Context) error {
@@ -292,25 +292,25 @@ func (s *ListContainers) Execute(ctx *context.Context) error {
 	}
 
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(nil, s.Out, out, err, errno.ERR_LIST_CONTAINERS_FAILED)
+	return PostHandle(nil, s.Out, out, err, errno.ERR_LIST_CONTAINERS_FAILED.FD("(%s ps)", s.ExecWithEngine))
 }
 
 func (s *ContainerExec) Execute(ctx *context.Context) error {
 	cli := ctx.Module().DockerCli().ContainerExec(*s.ContainerId, s.Command)
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(s.Success, s.Out, out, err, errno.ERR_RUN_COMMAND_IN_CONTAINER_FAILED)
+	return PostHandle(s.Success, s.Out, out, err, errno.ERR_RUN_COMMAND_IN_CONTAINER_FAILED.FD("(%s exec CONTAINER COMMAND)", s.ExecWithEngine))
 }
 
 func (s *CopyFromContainer) Execute(ctx *context.Context) error {
 	cli := ctx.Module().DockerCli().CopyFromContainer(s.ContainerId, s.ContainerSrcPath, s.HostDestPath)
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(nil, s.Out, out, err, errno.ERR_COPY_FROM_CONTAINER_FAILED)
+	return PostHandle(nil, s.Out, out, err, errno.ERR_COPY_FROM_CONTAINER_FAILED.FD("(%s cp CONTAINER:SRC_PATH DEST_PATH)", s.ExecWithEngine))
 }
 
 func (s *CopyIntoContainer) Execute(ctx *context.Context) error {
 	cli := ctx.Module().DockerCli().CopyIntoContainer(s.HostSrcPath, s.ContainerId, s.ContainerDestPath)
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(nil, s.Out, out, err, errno.ERR_COPY_INTO_CONTAINER_FAILED)
+	return PostHandle(nil, s.Out, out, err, errno.ERR_COPY_INTO_CONTAINER_FAILED.FD("(%s cp SRC_PATH CONTAINER:DEST_PATH)", s.ExecWithEngine))
 }
 
 func (s *InspectContainer) Execute(ctx *context.Context) error {
@@ -320,13 +320,13 @@ func (s *InspectContainer) Execute(ctx *context.Context) error {
 	}
 
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(s.Success, s.Out, out, err, errno.ERR_INSPECT_CONTAINER_FAILED)
+	return PostHandle(s.Success, s.Out, out, err, errno.ERR_INSPECT_CONTAINER_FAILED.FD("(%s inspect ID)", s.ExecWithEngine))
 }
 
 func (s *ContainerLogs) Execute(ctx *context.Context) error {
 	cli := ctx.Module().DockerCli().ContainerLogs(s.ContainerId)
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(s.Success, s.Out, out, err, errno.ERR_GET_CONTAINER_LOGS_FAILED)
+	return PostHandle(s.Success, s.Out, out, err, errno.ERR_GET_CONTAINER_LOGS_FAILED.FD("(%s logs ID)", s.ExecWithEngine))
 }
 
 func (s *UpdateContainer) Execute(ctx *context.Context) error {
@@ -335,5 +335,5 @@ func (s *UpdateContainer) Execute(ctx *context.Context) error {
 		cli.AddOption("--restart %s", s.Restart)
 	}
 	out, err := cli.Execute(s.ExecOptions)
-	return PostHandle(s.Success, s.Out, out, err, errno.ERR_UPDATE_CONTAINER_FAILED)
+	return PostHandle(s.Success, s.Out, out, err, errno.ERR_UPDATE_CONTAINER_FAILED.FD("(%s update ID)", s.ExecWithEngine))
 }

internal/task/step/file.go

@@ -124,7 +124,7 @@ func (s *ReadFile) Execute(ctx *context.Context) error {
 		dockerCli := ctx.Module().DockerCli().CopyFromContainer(s.ContainerId, s.ContainerSrcPath, remotePath)
 		_, err := dockerCli.Execute(s.ExecOptions)
 		if err != nil {
-			return errno.ERR_COPY_FROM_CONTAINER_FAILED.E(err)
+			return errno.ERR_COPY_FROM_CONTAINER_FAILED.FD("(%s cp CONTAINER:SRC_PATH DEST_PATH)", s.ExecWithEngine).E(err)
 		}
 	}
 
@@ -189,7 +189,7 @@ func (s *InstallFile) Execute(ctx *context.Context) error {
 		cli := ctx.Module().DockerCli().CopyIntoContainer(remotePath, *s.ContainerId, s.ContainerDestPath)
 		_, err = cli.Execute(s.ExecOptions)
 		if err != nil {
-			return errno.ERR_COPY_INTO_CONTAINER_FAILED.E(err)
+			return errno.ERR_COPY_INTO_CONTAINER_FAILED.FD(" (%scp SRC_PATH CONTAINER:DEST_PATH)", s.ExecWithEngine).E(err)
 		}
 	}
 	return nil

internal/task/task/bs/start_nebd.go

@@ -156,13 +156,13 @@ func NewStartNEBDServiceTask(curveadm *cli.CurveAdm, cc *configure.ClientConfig)
 	hostname := containerName
 	host2addr := fmt.Sprintf("%s:%s", hostname, hc.GetHostname())
 
-	t.AddStep(&step.DockerInfo{
+	t.AddStep(&step.EngineInfo{
 		Success:     &success,
 		Out:         &out,
 		ExecOptions: curveadm.ExecOptions(),
 	})
 	t.AddStep(&step.Lambda{
-		Lambda: checker.CheckDockerInfo(options.Host, &success, &out),
+		Lambda: checker.CheckEngineInfo(options.Host, curveadm.ExecOptions().ExecWithEngine, &success, &out),
 	})
 	t.AddStep(&step.ListContainers{
 		ShowAll:     true,

internal/task/task/checker/permission.go

@@ -87,21 +87,21 @@ func checkCreateDirectory(dc *topology.DeployConfig, path string, success *bool,
 	}
 }
 
-func CheckDockerInfo(host string, success *bool, out *string) step.LambdaType {
+func CheckEngineInfo(host, engine string, success *bool, out *string) step.LambdaType {
 	return func(ctx *context.Context) error {
 		if *success {
 			return nil
 		}
 
 		*out = strings.ToLower(*out)
 		if strings.Contains(*out, SIGNATURE_COMMAND_NOT_FOUND) {
-			return errno.ERR_DOCKER_NOT_INSTALLED.
+			return errno.ERR_CONTAINER_ENGINE_NOT_INSTALLED.
 				F("host=%s\n%s", host, *out)
 		} else if strings.Contains(*out, SIGNATURE_PERMISSION_DENIED) {
-			return errno.ERR_EXECUTE_DOCKER_COMMAND_PERMISSION_DENIED.
+			return errno.ERR_EXECUTE_CONTAINER_ENGINE_COMMAND_PERMISSION_DENIED.
 				F("host=%s\n%s", host, *out)
 		} else if strings.Contains(*out, SIGNATURE_PERMISSION_WITH_PASSWORD) {
-			return errno.ERR_EXECUTE_DOCKER_COMMAND_PERMISSION_DENIED.
+			return errno.ERR_EXECUTE_CONTAINER_ENGINE_COMMAND_PERMISSION_DENIED.
 				F("host=%s (need password)", host)
 		} else if strings.Contains(*out, SIGNATURE_DOCKER_DEAMON_IS_NOT_RUNNING) {
 			return errno.ERR_DOCKER_DAEMON_IS_NOT_RUNNING.
@@ -164,14 +164,14 @@ func NewCheckPermissionTask(curveadm *cli.CurveAdm, dc *topology.DeployConfig) (
 			Lambda: checkCreateDirectory(dc, dir.Path, &success, &out),
 		})
 	}
-	// (4) check docker command {exist, permission, running}
-	t.AddStep(&step.DockerInfo{
+	// (4) check docker/podman engine command {exist, permission, running}
+	t.AddStep(&step.EngineInfo{
 		Success:     &success,
 		Out:         &out,
 		ExecOptions: curveadm.ExecOptions(),
 	})
 	t.AddStep(&step.Lambda{
-		Lambda: CheckDockerInfo(dc.GetHost(), &success, &out),
+		Lambda: CheckEngineInfo(dc.GetHost(), curveadm.ExecOptions().ExecWithEngine, &success, &out),
 	})
 
 	return t, nil