zDWSI/launcher/main.go

package main

import (
	"fmt"
	go_lazy_quiter "git.swzry.com/zry/go-lazy-quiter"
	"git.swzry.com/zry/pathutils"
	"gopkg.in/natefinch/lumberjack.v2"
	"gopkg.in/yaml.v2"
	"io"
	"io/ioutil"
	"os"
	"os/exec"
	"sync"
)

var ConfigData ConfigYAML
var FrontendShellLogger *lumberjack.Logger
var BackendShellLogger *lumberjack.Logger
var mainWaitGroup sync.WaitGroup
var lazyQuiter *go_lazy_quiter.LazyQuiter
var pFrontend *os.Process
var pBackend *os.Process

func main() {
	fmt.Println("zDWSI Launcher Start.")
	CheckInit()
	LoadYAML()
	SetSignalCatcher()
	StartFrontend()
	StartBackend()
	fmt.Println("Launcher Sleeping.")
	RoutineSleep()
}

func SetSignalCatcher() {
	lazyQuiter = go_lazy_quiter.NewLazyQuiter(os.Kill)
	go func() {
		lazyQuiter.Wait()
		if pFrontend != nil {
			_ = pFrontend.Signal(os.Kill)
		}
		if pBackend != nil {
			_ = pBackend.Signal(os.Kill)
		}
	}()
}

func CheckInit() {
	pe, err := pathutils.PathExists("/data/config.yaml")
	if err == nil && pe {
		return
	}
	fmt.Println("Initializing Container...")
	pathutils.MkDirIfNotExist("/data/frontend/", 0777)
	pathutils.MkDirIfNotExist("/data/backend/", 0777)
	pathutils.MkDirIfNotExist("/data/wwwroot/", 0777)
	pathutils.MkDirIfNotExist("/data/logs/", 0777)
	pathutils.CopyFile("/data/config.yaml", "/rel/config.default.yaml")
	pathutils.CopyFile("/data/wwwroot/index.html", "/rel/index.default.html")
	pathutils.CopyFile("/data/frontend/zDWSIFrontend", "/rel/zDWSIFrontend_linux")
	pathutils.CopyFile("/data/backend/Backend", "/rel/zDWSIBlankBackend_linux")
	pathutils.CopyFile("/data/frontend/zdwsi.frontend.config.yaml", "/rel/zdwsi.frontend.config.default.yaml")
	os.Chmod("/data/frontend/zDWSIFrontend", 0755)
	os.Chmod("/data/backend/Backend", 0755)
	fmt.Println("Container Initialized. Please Edit 'config.yaml'.")
}

func LoadYAML() {
	fmt.Println("Load Config '/data/config.yaml'")
	jdata, err := ioutil.ReadFile("/data/config.yaml")
	if err != nil {
		fmt.Println("failed read file 'config.yaml': ", err)
		Dead()
	}
	err = yaml.Unmarshal(jdata, &ConfigData)
	if err != nil {
		fmt.Println("failed parse 'config.yaml': ", err)
		Dead()
	}
	fmt.Println("Config Loaded.")
}

func Dead() {
	fmt.Println("Program Dead By Fatal Error. Please Restart.")
	FailureServer()
}

func RoutineSleep() {
	mainWaitGroup.Wait()
	fmt.Println("All GoRoutine Stopped. Please Restart.")
	FailureServer()
}

func InitLogger(cfg LumberjackLoggerYAML) *lumberjack.Logger {
	ljl := &lumberjack.Logger{
		Filename:   cfg.FileName,
		MaxSize:    cfg.MaxSize,
		MaxAge:     cfg.MaxAge,
		MaxBackups: cfg.MaxBackups,
		LocalTime:  cfg.UseLocalTime,
		Compress:   cfg.Compress,
	}
	return ljl
}

func StartFrontend() {
	if !ConfigData.Frontend.Enable {
		fmt.Println("Frontend Not Enable.")
		return
	}
	pe, err := pathutils.PathExists(ConfigData.Frontend.EntryPoint)
	if err != nil || !pe {
		fmt.Println("frontend entrypoint not exists")
		return
	}
	FrontendShellLogger = InitLogger(ConfigData.Frontend.ShellLog)
	mainWaitGroup.Add(1)
	go func() {
		runenv := make([]string, 0)
		runenv = append(runenv, makeEnvMember("listen", ConfigData.Frontend.ListenAddr))
		runenv = append(runenv, makeEnvMember("wwwroot", ConfigData.Frontend.WWWRoot))
		runenv = append(runenv, makeEnvMember("backend_prefix", ConfigData.Frontend.BackendProxy.Prefix))
		runenv = append(runenv, makeEnvMember("backend_target", ConfigData.Frontend.BackendProxy.ProxyTaret))
		err = StartProcess(ConfigData.Frontend.EntryPoint, runenv, FrontendShellLogger, "frontend")
		if err != nil {
			fmt.Println("failed start frontend or frontend exited with error: ", err)
		}
		mainWaitGroup.Done()
	}()
}

func makeEnvMember(key string, value string) string {
	return fmt.Sprintf("%s=%s", key, value)
}

func StartBackend() {
	if !ConfigData.Backend.Enable {
		fmt.Println("Backend Not Enable.")
		return
	}
	pe, err := pathutils.PathExists(ConfigData.Backend.EntryPoint)
	if err != nil || !pe {
		fmt.Println("backend entrypoint not exists")
		return
	}
	BackendShellLogger = InitLogger(ConfigData.Backend.ShellLog)
	mainWaitGroup.Add(1)
	go func() {
		runenv := make([]string, 0)
		runenv = append(runenv, makeEnvMember("listen", ConfigData.Backend.ListenAddr))
		err = StartProcess(ConfigData.Backend.EntryPoint, runenv, BackendShellLogger, "backend")
		if err != nil {
			fmt.Println("failed start backend or backend exited with error: ", err)
		}
		mainWaitGroup.Done()
	}()
}

func StartProcess(entry string, runenv []string, logger io.Writer, ptype string) error {
	cmd := exec.Command(entry)
	cmd.Env = runenv
	pipe_r, pipe_w := io.Pipe()
	cmd.Stdout = pipe_w
	cmd.Stderr = pipe_w
	go func() {
		io.Copy(logger, pipe_r)
	}()
	err := cmd.Start()
	switch ptype {
	case "frontend":
		pFrontend = cmd.Process
		break
	case "backend":
		pBackend = cmd.Process
		break
	}
	if err != nil {
		return err
	}
	err = cmd.Wait()
	return err
}