bsm/cmd/ps.go

package cmd

import (
	"encoding/json"
	"fmt"
	"os/exec"
	"strings"

	"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"
	"gorm.io/gorm"
)

type ActionsReleases struct {
	gorm.Model
	Identity   string
	Origin     string
	ServiceKey string
	Version    string
	FullName   string
	OssUrl     string
	EtcPath    string
	FilePath   string
	ImagePath  string
}

type PsTable struct {
	ServiceKey      string
	Origin          string
	Status          string
	Performance     string
	CurrentVersion  string
	RegisterVersion string
	UpdatedAt       string
}

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

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

	var ms []ActionsReleases
	err = json.Unmarshal(body, &ms)
	checkError(err)

	for _, v := range ms {
		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 {
	isRun := checkProcessRunning(srv)
	var status string = " - "
	if isRun {
		status = "Running"
	}

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

}

func getPerformance(srv string) string {

}

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

	cmd := exec.Command(env.MeshEnv.Prefix+srv, "--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 {
	var info string = " - "
	cmd := exec.Command("ps", "-eo", "pid,%cpu,%mem") // 使用ps命令查询进程信息
	output, err := cmd.Output()                       // 获取命令输出结果
	if err != nil {
		return info
	}

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

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

	return 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
}