bsm/cmd/ps.go

package cmd

import (
	"encoding/json"
	"fmt"
	"os/exec"
	"path/filepath"
	"strings"
	"time"

	"git.apinb.com/bsm-sdk/engine/env"
	"git.apinb.com/bsm-sdk/engine/utils"
	"git.apinb.com/bsm-sdk/engine/vars"
	"github.com/modood/table"
	"github.com/spf13/cobra"
)

type JSONData struct {
	Msg  string            `json:"msg"`
	Code int               `json:"code"`
	Data []ActionsReleases `json:"data"`
}

type ActionsReleases struct {
	ID         uint `gorm:"primarykey"`
	CreatedAt  time.Time
	UpdatedAt  time.Time
	Identity   string
	Origin     string
	ServiceKey string
	Version    string
	FullName   string
	OssUrl     string
	EtcPath    string
	FilePath   string
	ImagePath  string
}

type PsTable struct {
	ServiceKey      string `table:"Service Key"`
	Origin          string
	Status          string
	Performance     string
	CurrentVersion  string `table:"Current Version"`
	RegisterVersion string `table:"Register Version"`
	UpdatedAt       string `table:"Updated At"`
}

var psCmd = &cobra.Command{
	Use:   "ps",
	Short: "list restiry and local installed microservice.",
	Run: func(cmd *cobra.Command, args []string) {
		psExecute()
	},
}

func psExecute() {
	fmt.Println("Blocks Registry:", registryUrl)
	pt := make([]PsTable, 0)
	body, err := utils.HttpGet(registryUrl)
	checkError(err)

	var ms JSONData
	err = json.Unmarshal(body, &ms)
	checkError(err)

	if len(ms.Data) == 0 {
		pt = append(pt, PsTable{})
	}

	for _, v := range ms.Data {
		srvLine := getSrvStatus(v.ServiceKey)
		srvLine.ServiceKey = v.ServiceKey
		srvLine.Origin = v.Origin
		srvLine.RegisterVersion = v.Version
		srvLine.UpdatedAt = v.UpdatedAt.Format(vars.YYYY_MM_DD_HH_MM_SS)
		pt = append(pt, srvLine)
	}

	// Output to stdout
	table.Output(pt)
}

func getSrvStatus(srv string) PsTable {

	var status string = " - "
	binExists := utils.PathExists(env.MeshEnv.Prefix + srv)
	if binExists {
		status = "\033[32mRunning\033[0m\n"
	}

	isRun := checkProcessRunning(srv)
	if binExists && !isRun {
		status = "\033[31mStop\033[0m\n"
	}

	_, cm := getProcessInfo(srv)

	return PsTable{
		Status:         status,
		CurrentVersion: getCurrentVersion(srv),
		Performance:    cm,
	}

}

func getCurrentVersion(srv string) string {
	var data map[string]string

	execbin := filepath.Join(env.MeshEnv.Prefix, srv)
	cmd := exec.Command(execbin, "--json") // 替换为适合操作系统的命令
	output, err := cmd.Output()
	if err != nil {
		return " - "
	}

	err = json.Unmarshal(output, &data)
	if err != nil {
		return " - "
	}

	if val, ok := data["version"]; ok {
		return val
	}

	return " - "
}

func getProcessInfo(processName string) (string, string) {
	var info string = " - "
	cmd := exec.Command("ps", "-eo", "pid,%cpu,%mem,cmd") // 使用ps命令查询进程信息
	output, err := cmd.Output()                           // 获取命令输出结果
	if err != nil {
		return info, info
	}

	// 将输出按换行符分隔成多行字符串数组
	lines := strings.Split(string(output), "\n")[1:]

	for _, line := range lines {
		if strings.Contains(line, processName) {
			fields := strings.Fields(line) // 将每行按空格分隔为字段数组
			if len(fields) >= 3 {
				pid := fields[0]         // PID（进程标识）
				cpuUsage := fields[1]    // CPU使用情况
				memoryUsage := fields[2] // 内存使用情况
				info = fmt.Sprintf("CPU:%s%% / MEM:%s%%", cpuUsage, memoryUsage)
				return pid, info
			}
		}
	}

	return info, info
}

func checkProcessRunning(processName string) bool {
	cmd := exec.Command("ps", "-ef") // 替换为适合操作系统的命令
	output, err := cmd.Output()
	if err != nil {
		return false
	}

	// 将输出按行分割成切片
	lines := strings.Split(string(output), "\n")

	for _, line := range lines {
		if strings.Contains(line, processName) {
			return true
		}
	}

	return false
}