[feat]: add support for docker start command (#1586)

* fixed docker start command bug Signed-off-by: Yaxhveer <[email protected]> --------- Signed-off-by: Yaxhveer <[email protected]> Co-authored-by: Ahmed Lotfy <[email protected]> Co-authored-by: naoki kuroda <[email protected]> Co-authored-by: Gourav kumar <[email protected]>
keploy · May 21, 2024 · 8f0abd6 · 8f0abd6
1 parent 33f40bf
commit 8f0abd6
Show file tree

Hide file tree

Showing 9 changed files with 103 additions and 22 deletions.
diff --git a/pkg/core/app/app.go b/pkg/core/app/app.go
@@ -69,12 +69,12 @@ func (a *App) Setup(_ context.Context) error {
  }
  a.docker = d
 
- if (a.kind == utils.Docker || a.kind == utils.DockerCompose) && IsDetachMode(a.cmd) {
- return fmt.Errorf("detach mode is not allowed in Keploy command")
+ if utils.IsDockerKind(a.kind) && isDetachMode(a.logger, a.cmd, a.kind) {
+ return fmt.Errorf("application could not be started in detached mode")
  }
 
  switch a.kind {
- case utils.Docker:
+ case utils.DockerRun, utils.DockerStart:
  err := a.SetupDocker()
  if err != nil {
  return err
@@ -100,7 +100,9 @@ func (a *App) ContainerIPv4Addr() string {
 
 func (a *App) SetupDocker() error {
  var err error
- cont, net, err := ParseDockerCmd(a.cmd)
+
+ cont, net, err := ParseDockerCmd(a.cmd, a.kind, a.docker)
+
  if err != nil {
  utils.LogError(a.logger, err, "failed to parse container name from given docker command", zap.String("cmd", a.cmd))
  return err
@@ -117,6 +119,16 @@ func (a *App) SetupDocker() error {
  a.logger.Warn(fmt.Sprintf("given docker network:(%v) is different from parsed docker network:(%v)", a.containerNetwork, net))
  }
 
+ if a.kind == utils.DockerStart {
+ running, err := a.docker.IsContainerRunning(cont)
+ if err != nil {
+ return err
+ }
+ if running {
+ return fmt.Errorf("docker container is already in running state")
+ }
+ }
+
  //injecting appNetwork to keploy.
  err = a.injectNetwork(a.containerNetwork)
  if err != nil {
@@ -420,7 +432,7 @@ func (a *App) runDocker(ctx context.Context) models.AppError {
 func (a *App) Run(ctx context.Context, inodeChan chan uint64) models.AppError {
  a.inodeChan = inodeChan
 
- if a.kind == utils.DockerCompose || a.kind == utils.Docker {
+ if utils.IsDockerKind(a.kind) {
  return a.runDocker(ctx)
  }
  return a.run(ctx)
@@ -431,7 +443,7 @@ func (a *App) run(ctx context.Context) models.AppError {
  userCmd := a.cmd
  username := os.Getenv("SUDO_USER")
 
- if utils.FindDockerCmd(a.cmd) == utils.Docker {
+ if utils.FindDockerCmd(a.cmd) == utils.DockerRun {
  userCmd = utils.EnsureRmBeforeName(userCmd)
  }
 

diff --git a/pkg/core/app/docker/docker.go b/pkg/core/app/docker/docker.go
@@ -518,3 +518,20 @@ func (idc *Impl) SetKeployNetwork(c *Compose) (*NetworkInfo, error) {
  }
  return networkInfo, nil
 }
+
+// IsContainerRunning check if the container is already running or not, required for docker start command.
+func (idc *Impl) IsContainerRunning(containerName string) (bool, error) {
+
+ ctx, cancel := context.WithTimeout(context.Background(), idc.timeoutForDockerQuery)
+ defer cancel()
+
+ containerJSON, err := idc.ContainerInspect(ctx, containerName)
+ if err != nil {
+ return false, err
+ }
+
+ if containerJSON.State.Running {
+ return true, nil
+ }
+ return false, nil
+}
diff --git a/pkg/core/app/docker/service.go b/pkg/core/app/docker/service.go
@@ -25,6 +25,8 @@ type Client interface {
  SetKeployNetwork(c *Compose) (*NetworkInfo, error)
  ReadComposeFile(filePath string) (*Compose, error)
  WriteComposeFile(compose *Compose, path string) error
+
+ IsContainerRunning(containerName string) (bool, error)
 }
 
 type NetworkInfo struct {

diff --git a/pkg/core/app/util.go b/pkg/core/app/util.go
@@ -5,9 +5,14 @@ import (
  "os"
  "path/filepath"
  "regexp"
+ "slices"
  "strconv"
  "strings"
  "syscall"
+
+ "go.keploy.io/server/v2/pkg/core/app/docker"
+ "go.keploy.io/server/v2/utils"
+ "go.uber.org/zap"
 )
 
 func findComposeFile() string {
@@ -47,9 +52,17 @@ func modifyDockerComposeCommand(appCmd, newComposeFile string) string {
  return fmt.Sprintf("%s -f %s", appCmd, newComposeFile)
 }
 
-func ParseDockerCmd(cmd string) (string, string, error) {
+func ParseDockerCmd(cmd string, kind utils.CmdType, idc docker.Client) (string, string, error) {
+
  // Regular expression patterns
- containerNamePattern := `--name\s+([^\s]+)`
+ var containerNamePattern string
+ switch kind {
+ case utils.DockerStart:
+ containerNamePattern = `start\s+(?:-[^\s]+\s+)*([^\s]*)`
+ default:
+ containerNamePattern = `--name\s+([^\s]+)`
+ }
+
  networkNamePattern := `(--network|--net)\s+([^\s]+)`
 
  // Extract container name
@@ -60,6 +73,17 @@ func ParseDockerCmd(cmd string) (string, string, error) {
  }
  containerName := containerNameMatches[1]
 
+ if kind == utils.DockerStart {
+ networks, err := idc.ExtractNetworksForContainer(containerName)
+ if err != nil {
+ return containerName, "", err
+ }
+ for i := range networks {
+ return containerName, i, nil
+ }
+ return containerName, "", fmt.Errorf("failed to parse network name")
+ }
+
  // Extract network name
  networkNameRegex := regexp.MustCompile(networkNamePattern)
  networkNameMatches := networkNameRegex.FindStringSubmatch(cmd)
@@ -86,10 +110,24 @@ func getInode(pid int) (uint64, error) {
  return i, nil
 }
 
-func IsDetachMode(command string) bool {
+func isDetachMode(logger *zap.Logger, command string, kind utils.CmdType) bool {
  args := strings.Fields(command)
+
+ if kind == utils.DockerStart {
+ flags := []string{"-a", "--attach", "-i", "--interactive"}
+
+ for _, arg := range args {
+ if slices.Contains(flags, arg) {
+ return false
+ }
+ }
+ utils.LogError(logger, fmt.Errorf("docker start require --attach/-a or --interactive/-i flag"), "failed to start command")
+ return true
+ }
+
  for _, arg := range args {
  if arg == "-d" || arg == "--detach" {
+ utils.LogError(logger, fmt.Errorf("detach mode is not allowed in Keploy command"), "failed to start command")
  return true
  }
  }

diff --git a/pkg/core/core.go b/pkg/core/core.go
@@ -79,7 +79,7 @@ func (c *Core) Hook(ctx context.Context, id uint64, opts models.HookOptions) err
  isDocker := false
  appKind := a.Kind(ctx)
  //check if the app is docker/docker-compose or native
- if appKind == utils.Docker || appKind == utils.DockerCompose {
+ if utils.IsDockerKind(appKind) {
  isDocker = true
  }
 

diff --git a/pkg/service/record/record.go b/pkg/service/record/record.go
@@ -348,8 +348,8 @@ func (r *Recorder) ReRecord(ctx context.Context, appID uint64) error {
  return nil
 
  }
- cmdType := utils.FindDockerCmd(r.config.Command)
- if cmdType == utils.Docker || cmdType == utils.DockerCompose {
+ cmdType := utils.CmdType(r.config.CommandType)
+ if utils.IsDockerKind(cmdType) {
  host = r.config.ContainerName
  }
 
@@ -360,7 +360,7 @@ func (r *Recorder) ReRecord(ctx context.Context, appID uint64) error {
 
  allTestCasesRecorded := true
  for _, tc := range tcs {
- if cmdType == utils.Docker || cmdType == utils.DockerCompose {
+ if utils.IsDockerKind(cmdType) {
 
  userIP, err := r.instrumentation.GetContainerIP(ctx, appID)
  if err != nil {

diff --git a/pkg/service/replay/replay.go b/pkg/service/replay/replay.go
@@ -334,9 +334,9 @@ func (r *Replayer) RunTestSet(ctx context.Context, testSetID string, testRunID s
  return models.TestSetStatusUserAbort, context.Canceled
  }
 
- cmdType := utils.FindDockerCmd(r.config.Command)
+ cmdType := utils.CmdType(r.config.CommandType)
  var userIP string
- if cmdType == utils.Docker || cmdType == utils.DockerCompose {
+ if utils.IsDockerKind(cmdType) {
  userIP, err = r.instrumentation.GetContainerIP(ctx, appID)
  if err != nil {
  return models.TestSetStatusFailed, err
@@ -410,7 +410,7 @@ func (r *Replayer) RunTestSet(ctx context.Context, testSetID string, testRunID s
 
  started := time.Now().UTC()
 
- if cmdType == utils.Docker || cmdType == utils.DockerCompose {
+ if utils.IsDockerKind(cmdType) {
 
  testCase.HTTPReq.URL, err = utils.ReplaceHostToIP(testCase.HTTPReq.URL, userIP)
  if err != nil {

diff --git a/utils/docker.go b/utils/docker.go
@@ -68,7 +68,7 @@ func StartInDocker(ctx context.Context, logger *zap.Logger, conf *config.Config)
  // If it does, then we would run the docker version of keploy and
  // pass the command and control to it.
  cmdType := FindDockerCmd(conf.Command)
- if conf.InDocker || !(cmdType == Docker || cmdType == DockerCompose) {
+ if conf.InDocker || !(IsDockerKind(cmdType)) {
  return nil
  }
  // pass the all the commands and args to the docker version of Keploy

diff --git a/utils/utils.go b/utils/utils.go
@@ -333,7 +333,8 @@ func FindDockerCmd(cmd string) CmdType {
  cmdLower := strings.TrimSpace(strings.ToLower(cmd))
 
  // Define patterns for Docker and Docker Compose
- dockerPatterns := []string{"docker", "sudo docker"}
+ dockerRunPatterns := []string{"docker run", "sudo docker run"}
+ dockerStartPatterns := []string{"docker start", "sudo docker start"}
  dockerComposePatterns := []string{"docker-compose", "sudo docker-compose", "docker compose", "sudo docker compose"}
 
  // Check for Docker Compose command patterns and file extensions
@@ -342,10 +343,16 @@ func FindDockerCmd(cmd string) CmdType {
  return DockerCompose
  }
  }
- // Check for Docker command patterns
- for _, pattern := range dockerPatterns {
+ // Check for Docker start command patterns
+ for _, pattern := range dockerStartPatterns {
  if strings.HasPrefix(cmdLower, pattern) {
- return Docker
+ return DockerStart
+ }
+ }
+ // Check for Docker run command patterns
+ for _, pattern := range dockerRunPatterns {
+ if strings.HasPrefix(cmdLower, pattern) {
+ return DockerRun
  }
  }
  return Native
@@ -355,7 +362,8 @@ type CmdType string
 
 // CmdType constants
 const (
- Docker CmdType = "docker"
+ DockerRun CmdType = "docker-run"
+ DockerStart CmdType = "docker-start"
  DockerCompose CmdType = "docker-compose"
  Native CmdType = "native"
 )
@@ -712,3 +720,7 @@ func EnsureRmBeforeName(cmd string) string {
 
  return strings.Join(parts, " ")
 }
+
+func IsDockerKind(kind CmdType) bool {
+ return (kind == DockerRun || kind == DockerStart || kind == DockerCompose)
+}