tcm: add the tt tcm status command

@TarantoolBot document
Title: add the tt tcm status command.

Add `tt tcm status` command that displays whether TCM is running in:
- watchdog mode (with auto-recovery)
- interactive mode

Closes #TNTP-1992

Author: AlexandrLitkevich

CHANGELOG.md

@@ -2,19 +2,31 @@ package cmd
 
 import (
 	"errors"
+	"fmt"
+	"log"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"time"
 
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/jedib0t/go-pretty/v6/text"
 	"github.com/spf13/cobra"
 	"github.com/tarantool/tt/cli/cmdcontext"
 	"github.com/tarantool/tt/cli/modules"
+	"github.com/tarantool/tt/cli/process_utils"
 	tcmCmd "github.com/tarantool/tt/cli/tcm"
 	"github.com/tarantool/tt/cli/util"
+	libwatchdog "github.com/tarantool/tt/lib/watchdog"
 )
 
 var tcmCtx = tcmCmd.TcmCtx{}
 
+const (
+	tcmPidFile      = "tcmPidFile.pid"
+	watchdogPidFile = "watchdogPidFile.pid"
+)
+
 func newTcmStartCmd() *cobra.Command {
 	var tcmCmd = &cobra.Command{
 		Use:   "start",
@@ -26,7 +38,6 @@ func newTcmStartCmd() *cobra.Command {
 			cmdCtx.CommandName = cmd.Name()
 			err := modules.RunCmd(&cmdCtx, cmd.CommandPath(), &modulesInfo, internalStartTcm, args)
 			util.HandleCmdErr(cmd, err)
-
 		},
 	}
 	tcmCmd.Flags().StringVar(&tcmCtx.Executable, "path", "", "the path to the tcm binary file")
@@ -35,40 +46,73 @@ func newTcmStartCmd() *cobra.Command {
 	return tcmCmd
 }
 
+func newTcmStatusCmd() *cobra.Command {
+	var tcmCmd = &cobra.Command{
+		Use:   "status",
+		Short: "Status tcm application",
+		Long: `Status to the tcm.
+		tt tcm status`,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdCtx.CommandName = cmd.Name()
+			err := modules.RunCmd(&cmdCtx, cmd.CommandPath(), &modulesInfo, internalTcmStatus, args)
+			util.HandleCmdErr(cmd, err)
+		},
+	}
+	return tcmCmd
+}
+
+func newTcmStopCmd() *cobra.Command {
+	var tcmCmd = &cobra.Command{
+		Use:   "stop",
+		Short: "Stop tcm application",
+		Long:  `Stop to the tcm. tt tcm stop`,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdCtx.CommandName = cmd.Name()
+			err := modules.RunCmd(&cmdCtx, cmd.CommandPath(), &modulesInfo, internalTcmStop, args)
+			util.HandleCmdErr(cmd, err)
+		},
+	}
+	return tcmCmd
+}
+
 func NewTcmCmd() *cobra.Command {
 	var tcmCmd = &cobra.Command{
 		Use:   "tcm",
 		Short: "Manage tcm application",
 	}
 	tcmCmd.AddCommand(
 		newTcmStartCmd(),
+		newTcmStatusCmd(),
+		newTcmStopCmd(),
 	)
 	return tcmCmd
 }
 
 func startTcmInteractive() error {
 	tcmApp := exec.Command(tcmCtx.Executable)
 
-	tcmApp.Stdout = os.Stdout
-	tcmApp.Stderr = os.Stderr
-
-	if err := tcmApp.Run(); err != nil {
+	if err := tcmApp.Start(); err != nil {
 		return err
 	}
 
-	return nil
-}
+	if tcmApp == nil || tcmApp.Process == nil {
+		return errors.New("process is not running")
+	}
 
-func startTcmUnderWatchDog() error {
-	wd, err := tcmCmd.NewWatchdog(5 * time.Second)
+	err := process_utils.CreatePIDFile(tcmPidFile, tcmApp.Process.Pid)
 	if err != nil {
 		return err
 	}
 
+	log.Printf("(INFO): Interactive process PID %d written to %s\n", tcmApp.Process.Pid, tcmPidFile)
+	return nil
+}
+
+func startTcmUnderWatchDog() error {
+	wd := libwatchdog.NewWatchdog(tcmPidFile, watchdogPidFile, 5*time.Second)
 	if err := wd.Start(tcmCtx.Executable); err != nil {
 		return err
 	}
-
 	return nil
 }
 
@@ -87,11 +131,61 @@ func internalStartTcm(cmdCtx *cmdcontext.CmdCtx, args []string) error {
 		if err := startTcmInteractive(); err != nil {
 			return err
 		}
+	} else {
+		if err := startTcmUnderWatchDog(); err != nil {
+			return err
+		}
 	}
 
-	if err := startTcmUnderWatchDog(); err != nil {
+	return nil
+}
+
+func internalTcmStatus(cmdCtx *cmdcontext.CmdCtx, args []string) error {
+	pidAbsPath, err := filepath.Abs(tcmPidFile)
+	if err != nil {
 		return err
 	}
 
+	if _, err := os.Stat(pidAbsPath); err != nil {
+		return fmt.Errorf("path does not exist: %v", err)
+	}
+
+	ts := table.NewWriter()
+	ts.SetOutputMirror(os.Stdout)
+
+	ts.AppendHeader(
+		table.Row{"APPLICATION", "STATUS", "PID"})
+
+	ts.SetColumnConfigs([]table.ColumnConfig{
+		{Number: 1, Align: text.AlignLeft, AlignHeader: text.AlignLeft},
+		{Number: 2, Align: text.AlignLeft, AlignHeader: text.AlignLeft},
+		{Number: 3, Align: text.AlignLeft, AlignHeader: text.AlignLeft},
+		{Number: 4, Align: text.AlignLeft, AlignHeader: text.AlignLeft},
+	})
+
+	status := process_utils.ProcessStatus(pidAbsPath)
+
+	ts.AppendRows([]table.Row{
+		{"TCM", status.Status, status.PID},
+	})
+	ts.Render()
+	return nil
+}
+
+func internalTcmStop(cmdCtx *cmdcontext.CmdCtx, args []string) error {
+	if isExists, _ := process_utils.ExistsAndRecord(watchdogPidFile); isExists {
+		_, err := process_utils.StopProcess(watchdogPidFile)
+		if err != nil {
+			return err
+		}
+		log.Println("Watchdog and TCM stoped")
+	} else {
+		_, err := process_utils.StopProcess(tcmPidFile)
+		if err != nil {
+			return err
+		}
+		log.Println("TCM stoped")
+	}
+
 	return nil
 }

cli/cmd/tcm.go

@@ -104,6 +104,27 @@ func CheckPIDFile(pidFileName string) error {
 	return nil
 }
 
+// ExistsAndRecord checks if the process with the given pidFileName exists and is alive.
+// If it does, returns true, otherwise returns false.
+// If something went wrong while trying to read the PID file, returns an error.
+func ExistsAndRecord(pidFileName string) (bool, error) {
+	if _, err := os.Stat(pidFileName); err == nil {
+		// The PID file already exists. We have to check if the process is alive.
+		pid, err := GetPIDFromFile(pidFileName)
+		if err != nil {
+			return false, fmt.Errorf(`pID file exists, but PID can't be read. Error: "%v"`, err)
+		}
+		if res, _ := IsProcessAlive(pid); res {
+			return true, nil
+		}
+	} else if !os.IsNotExist(err) {
+		return false, fmt.Errorf(`something went wrong while trying to read the PID file. Error: "%v"`,
+			err)
+	}
+
+	return false, nil
+}
+
 // CreatePIDFile checks that the instance PID file is absent or
 // deprecated and creates a new one. Returns an error on failure.
 func CreatePIDFile(pidFileName string, pid int) error {

cli/process_utils/process_utils.go

@@ -2,5 +2,8 @@ package tcm
 
 type TcmCtx struct {
 	Executable string
-	Watchdog   bool
+	TcmPidFile string
+
+	Watchdog       bool
+	WathdogPidFile string
 }