ran-proc/pkgtest/pmtest-server/web.go

package main

import (
	"context"
	"fmt"
	"git.swzry.com/zry/GoHiedaLogger/hieda_ginutil"
	"git.swzry.com/zry/GoHiedaLogger/hiedalog"
	"git.swzry.com/zry/ran-proc/rpcore"
	"github.com/gin-gonic/gin"
	"github.com/hashicorp/go-uuid"
	"github.com/liushuochen/gotable"
	"net/http"
	"os"
	"time"
)

type WebServerClass struct {
	engine     *gin.Engine
	httpServer *http.Server
	apiGroup   *gin.RouterGroup
	wsGroup    *gin.RouterGroup
}

func NewWebServer() *WebServerClass {
	web := &WebServerClass{
		engine: gin.New(),
	}
	glf := hieda_ginutil.GinLoggerWithComplexLogger(hieda_ginutil.GinLoggerConfig{
		Logger:       Logger,
		ModuleName:   "web",
		LevelMapFunc: hieda_ginutil.GetDefaultLevelMapFunc(),
	})
	web.engine.Use(glf, gin.Recovery())
	web.httpServer = &http.Server{
		Addr:    "0.0.0.0:9198",
		Handler: web.engine,
	}
	return web
}

func (s *WebServerClass) Run() error {
	s.defineRoutes()
	return s.httpServer.ListenAndServe()
}

func (s *WebServerClass) Stop(_ error) {
	ctx, cncl := context.WithTimeout(context.Background(), 10*time.Second)
	defer cncl()
	err := s.httpServer.Shutdown(ctx)
	if err != nil {
		Logger.LogPrint("main", hiedalog.DLN_ERROR, "error in shutting down web server: ", err)
	}
}

func (s *WebServerClass) defineRoutes() {
	s.engine.GET("/", s.wh_ListAllStatus)
	s.apiGroup = s.engine.Group("/api/")
	s.wsGroup = s.engine.Group("/ws/")
	s.wsGroup.GET("/get-cmd-output.satori", s.wh_ReadCmdOutput)
	s.apiGroup.POST("/new-task.satori", s.wh_NewTask)
}

func (s *WebServerClass) wh_ListAllStatus(ctx *gin.Context) {
	st, err := PM.ListAllStatus()
	if err != nil {
		ctx.String(500, "500 Internal Server Error")
		Logger.LogPrint("web-api", hiedalog.DLN_WARN, "failed list status: ", err)
		return
	}
	tb, err := gotable.Create("CPID", "Name", "Status", "PID", "Last Start Time")
	if err != nil {
		ctx.String(500, "500 Internal Server Error")
		Logger.LogPrint("web-api", hiedalog.DLN_WARN, "failed create table: ", err)
		return
	}
	for _, v := range st {
		err = tb.AddRow(v.ToPrintableTableData())
		if err != nil {
			Logger.LogPrint("debug", hiedalog.DLN_INFO, "Failed Print Table:", err)
		}
	}
	ctx.String(200, tb.String())
}

func (s *WebServerClass) ApiChecker(ctx *gin.Context, BindObj interface{}) bool {
	key := ctx.GetHeader("AuthKey")
	if key != AccessKey {
		ctx.JSON(403, &gin.H{
			"status": "403",
			"errMsg": "auth failed",
		})
		Logger.LogPrintf("web-api", hiedalog.DLN_VERBOSE, "client %s auth failed", ctx.Request.RemoteAddr)
		return false
	}
	err := ctx.BindJSON(BindObj)
	if err != nil {
		ctx.JSON(400, &gin.H{
			"status": "400",
			"errMsg": "bad request json format",
		})
		Logger.LogPrintf("web-api", hiedalog.DLN_VERBOSE, "client %s request json invalid: %v", ctx.Request.RemoteAddr, err)
		return false
	}
	return true
}

func (s *WebServerClass) wh_ReadCmdOutput(ctx *gin.Context) {
	key := ctx.Query("auth-key")
	if key != AccessKey {
		ctx.JSON(403, &gin.H{
			"status": "403",
			"errMsg": "auth failed",
		})
		Logger.LogPrintf("web-api", hiedalog.DLN_VERBOSE, "client %s auth failed", ctx.Request.RemoteAddr)
		return
	}
	WsLogDistr.HandleNewConnections(ctx)
}

func (s *WebServerClass) wh_NewTask(ctx *gin.Context) {
	var input ApiJsonDef_NewTask
	if !s.ApiChecker(ctx, &input) {
		return
	}
	taskName := input.TaskName
	if taskName == "" {
		ustr, _ := uuid.GenerateUUID()
		taskName = fmt.Sprintf("task-%s", ustr)
	}
	cpid, err := PM.CreateTask(&rpcore.NewTaskConfig{
		Name: taskName,
		CmdInfo: &rpcore.CmdInfoClass{
			Name:   input.ExecutablePath,
			Args:   append([]string{input.ExecutablePath}, input.Args...),
			Env:    os.Environ(),
			Dir:    input.WorkDir,
			Stdin:  nil,
			Stdout: WsLogDistr,
			Stderr: WsLogDistr,
		},
		DoneCallback: func(cpid int64, name string) {
			Logger.LogPrintf("task-done", hiedalog.DLN_INFO, "task (cpid=%16X, name='%s') done.", cpid, name)
		},
		ExecTimeout:     time.Duration(input.ExecTimeout) * time.Millisecond,
		ShutdownTimeout: 10 * time.Second,
		ShutdownActor:   GracefulShutdownActorForThis,
	})
	if err != nil {
		ctx.JSON(500, &gin.H{
			"status": "500",
			"errMsg": "failed create task: internal error",
		})
		Logger.LogPrint("web-api", hiedalog.DLN_WARN, "failed create task: ", err)
		return
	}
	ctx.JSON(200, &gin.H{
		"status":  "200",
		"infoMsg": "task created",
		"cpid":    fmt.Sprintf("%16X", cpid),
		"name":    taskName,
	})
}

func (s *WebServerClass) wh_NewDaemon(ctx *gin.Context) {
	var input ApiJsonDef_NewDaemon
	if !s.ApiChecker(ctx, &input) {
		return
	}
	daemonName := input.DaemonName
	if daemonName == "" {
		ctx.JSON(500, &gin.H{
			"status": "400",
			"errMsg": "failed create daemon: daemonName should not be empty",
		})
		Logger.LogPrint("web-api", hiedalog.DLN_WARN, "failed create task: daemonName should not be empty")
		return
	}
	cpid, err := PM.CreateDaemon(&rpcore.NewDaemonConfig{
		Name: daemonName,
		CmdInfo: &rpcore.CmdInfoClass{
			Name:   input.ExecutablePath,
			Args:   append([]string{input.ExecutablePath}, input.Args...),
			Env:    os.Environ(),
			Dir:    input.WorkDir,
			Stdin:  nil,
			Stdout: WsLogDistr,
			Stderr: WsLogDistr,
		},
		ShutdownTimeout:   10 * time.Second,
		ShutdownActor:     GracefulShutdownActorForThis,
		EnableAfterCreate: input.EnableAfterCreate,
	})
	if err != nil {
		ctx.JSON(500, &gin.H{
			"status": "500",
			"errMsg": "failed create daemon: internal error",
		})
		Logger.LogPrint("web-api", hiedalog.DLN_WARN, "failed create daemon: ", err)
		return
	}
	ctx.JSON(200, &gin.H{
		"status":  "200",
		"infoMsg": "task created",
		"cpid":    fmt.Sprintf("%16X", cpid),
		"name":    daemonName,
	})
}