cr-launcher/src/cmd/main.go

package cmd

import (
	"bufio"
	"context"
	"fmt"
	"io"
	"io/fs"
	"io/ioutil"
	"log"
	"os"
	"os/exec"
	"path"
	"path/filepath"

	"regexp"
	"runtime"
	"strconv"
	"strings"
	"syscall"
	"time"
)

type CancelCmd func()

type SubSysExe struct {
	Name               string
	SessionId          string
	CmdSuccFlag        string //启动成功标志, 如果不设置,
	CmdSuccFlag2       string
	CmdDurationForSucc int //如果没有启动标志，则启动多少时间后，没有报错，则判断启动成功
	CmdDurationForFail int //有启动标识，启动多少时间后，没有检测到成功标识判为启动失败

	ExeFile string //执行文件
	ExeDir  string //执行目录

	Envs   []string //执行环境变量
	Params []string //执行参数

	cancelRun CancelCmd

	MonitorQuit bool
	Quit        chan int

	Logger *log.Logger

	KillPreExe bool
	Pid        int
}

func (exe *SubSysExe) Log(args ...interface{}) {
	fmt.Println(args...)
}

func (exe *SubSysExe) StartForResult() (string, error) {
	exef := exe.ExeFile
	if runtime.GOOS == "windows" {
		if strings.LastIndex(exef, ".exe") == -1 {
			exef = exef + ".exe"
		}
	}
	cmd := exec.Command(exef, exe.Params...)
	ret, err := cmd.CombinedOutput()
	return string(ret), err
}
func (exe *SubSysExe) GetExeDir() string {
	if len(exe.ExeDir) > 0 {
		return path.Join(exe.ExeDir, fmt.Sprintf("%s-%s", runtime.GOOS, runtime.GOARCH))
	}
	return filepath.Dir(exe.ExeFile)
}

func (exe *SubSysExe) KillPreExeImpl() {
	//判断exename 是否存在
	if !exe.KillPreExe {
		return
	}

	pid := filepath.Join(exe.GetExeDir(), "pid")
	pidstr, _ := ioutil.ReadFile(pid)
	if len(pidstr) < 1 {
		return
	}
	p, _ := strconv.Atoi(string(pidstr))
	if p < 1 {
		return
	}
	proc, er := os.FindProcess(p)
	if er != nil {
		fmt.Println("find process fail", p, er)
		return
	}
	err := proc.Kill()
	fmt.Println("kill=>", p, err)
}

func (exe *SubSysExe) Start() error {

	ctx, cancel := context.WithCancel(context.Background())

	exef := exe.ExeFile
	if runtime.GOOS == "windows" {
		if strings.LastIndex(exef, ".exe") == -1 {
			exef = exef + ".exe"
		}
	}

	exe.KillPreExeImpl()

	cmd := exec.CommandContext(ctx, exef, exe.Params...)
	if len(exe.ExeDir) > 0 {
		cmd.Dir = path.Join(exe.ExeDir, fmt.Sprintf("%s-%s", runtime.GOOS, runtime.GOARCH))
	}
	if len(exe.Envs) > 0 {
		cmd.Env = exe.Envs
	}
	canceled := false
	exe.Log(cmd.Dir, exef, exe.Params)

	exe.cancelRun = func() {
		if canceled {
			return
		}
		canceled = true
		cancel()
		exe.Log("cmd exe canceled")
	}

	stdoutIn, _ := cmd.StdoutPipe()
	stderrIn, _ := cmd.StderrPipe()

	reader := bufio.NewReader(stdoutIn)
	reader2 := bufio.NewReader(stderrIn)

	retChan := make(chan int)

	hasSuccFlag := len(exe.CmdSuccFlag) > 0

	go func() {
		checked := false
		for {
			line, err2 := reader.ReadString('\n')
			if err2 != nil || io.EOF == err2 {
				exe.Log("stdoutIn err=>", err2)
				retChan <- 1
				break
			}
			exe.Log(line)
			if !checked && hasSuccFlag && ((strings.LastIndex(line, exe.CmdSuccFlag) != -1) || (len(exe.CmdSuccFlag2) > 0 && strings.LastIndex(line, exe.CmdSuccFlag2) != -1)) {
				checked = true
				retChan <- 2
			}
		}
	}()

	go func() {
		checked := false
		for {
			line, err2 := reader2.ReadString('\n')
			if err2 != nil || io.EOF == err2 {
				exe.Log("stderrIn err=>", err2)
				retChan <- 1
				break
			}
			exe.Log(line)
			if !checked && hasSuccFlag && ((strings.LastIndex(line, exe.CmdSuccFlag) != -1) || (len(exe.CmdSuccFlag2) > 0 && strings.LastIndex(line, exe.CmdSuccFlag2) != -1)) {
				checked = true
				retChan <- 2
			}
		}
	}()
	exeBase := path.Base(exe.ExeFile)

	err := cmd.Start()
	if err != nil {
		exe.Log(exeBase, " start failed", err.Error())
		return err
	}
	waitSec := 0

	exe.Pid = cmd.Process.Pid
	if exe.KillPreExe {
		ioutil.WriteFile(filepath.Join(exe.GetExeDir(), "pid"), []byte(fmt.Sprintf("%d", exe.Pid)), fs.ModePerm)
	}

	for {
		conti := true
		waitSec += 1

		select {
		case ret := <-retChan:
			if ret == 1 {
				return fmt.Errorf("%s start failed", exeBase)
			}
			if ret == 2 { //启动成功
				conti = false
				time.Sleep(time.Second)
			}
		default:
			exe.Log("waiting ", exeBase, "to start ", waitSec, "/", exe.CmdDurationForFail)
			time.Sleep(1 * time.Second)
		}

		if !conti {
			break
		}

		if hasSuccFlag {
			if waitSec > exe.CmdDurationForFail {
				exe.cancelRun()
				e := fmt.Errorf("%s start failed", path.Base(exe.ExeFile))
				exe.Log(e)
				return e
			}
		} else {
			if waitSec > exe.CmdDurationForSucc { //启动成功
				break
			}
		}
	}

	exe.Log(path.Base(exe.ExeFile), "started")

	if exe.MonitorQuit {
		go func() {
			err := cmd.Wait()
			if err != nil {
				exe.Log("subsys ", exeBase, " quit error", err)
				exe.Quit <- 1
				return
			}
			exe.Quit <- 0
		}()
	}
	return nil
}

func (exe *SubSysExe) StartBack() error {
	exef := exe.ExeFile
	if runtime.GOOS == "windows" {
		if strings.LastIndex(exef, ".exe") == -1 {
			exef = exef + ".exe"
		}
	}

	fmt.Println("run=>", exef, exe.Params)

	cmd := exec.Command(exef, exe.Params...)
	if len(exe.ExeDir) > 0 {
		cmd.Dir = exe.ExeDir
	}
	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true, CreationFlags: syscall.CREATE_NEW_PROCESS_GROUP}
	cmd.Stderr = os.Stderr
	cmd.Stdin = os.Stdin

	_, exeName := filepath.Split(exef)
	stdoutIn, e := cmd.StdoutPipe()
	if e != nil {
		return e
	}
	reader := bufio.NewReader(stdoutIn)
	chDown := make(chan int, 1)
	go func() {
		regex, _ := regexp.Compile(fmt.Sprintf("%s is running", exeName))
		checked := false
		for {
			line, err2 := reader.ReadString('\n')
			if err2 != nil || io.EOF == err2 {
				chDown <- 2
			}
			fmt.Println(line)

			if !checked {
				match := regex.MatchString(line)
				if match {
					checked = true
					chDown <- 1
				}
			}
		}
	}()
	err := cmd.Start()
	if err != nil {
		fmt.Println(err)
		return err
	}
	t := <-chDown
	if t != 1 {
		fmt.Println("quited")

		return fmt.Errorf("启动%s失败", exeName)
	}
	return nil
}

func (exe *SubSysExe) Stop() {
	if exe.cancelRun != nil {
		exe.cancelRun()
		exe.cancelRun = nil
	}
}

func (exe *SubSysExe) Destroy() {
	if exe.cancelRun != nil {
		exe.cancelRun()
	}
}