admin_backend/model/server.go

package model

import (
	"backend/Type"
	"backend/common"
	"backend/feishu"
	"backend/msg"
	util "backend/util"
	"fmt"
	"log"

	"github.com/Ullaakut/nmap"
)

const (
	DEVOPS_SERVER = "log"
)

type Server struct {
	AppId          int    `json:"AppId"`
	ServerId       int    `json:"ServerId"`
	ServerName     string `json:"ServerName"`
	Status         int    `json:"Status"`
	OpenServerTime int    `json:"OpenServerTime"`
	Type           int    `json:"Type"`
	Tags           string `json:"Tags"`
	ClientVersion  string `json:"ClientVersion"`
}

func (s *Server) AppList() ([]*Type.App, error) {
	Db := util.MPool.GetGameDB()
	var app []*Type.App
	err := Db.Select(&app, "SELECT `AppId`, `AppName`, `NodeName`, `MysqlName`, `Topic`, `tz`, `WsHost`, `Database`, `Update`, `Path` FROM app")
	defer Db.Close()
	if err != nil {
		return nil, fmt.Errorf("failed to scan rows: %v", err)
	}
	return app, nil
}

func (s *Server) ServerList() ([]*Type.ServerInfo, error) {
	Db := util.MPool.GetGameDB()
	var server []*Type.ServerInfo
	defer Db.Close()
	err := Db.Select(&server, "SELECT `AppId`, `ServerId`, `ServerName`, `Status`, `CreateTime`, `OpenServerTime`, `Online`, `cpu`, `free_mem`, `version`, `node_tags`  FROM server where AppId = ? order by `ServerId`", s.AppId)
	if err != nil {
		return nil, fmt.Errorf("failed to scan rows: %v", err)
	}
	for _, s := range server {
		s.Tags = util.ParseNodeTags(s.NodeTags)
	}
	if s.Type == 1 {
		return server, nil
	}
	return server, nil
}

func (s *Server) AddServer() error {
	Db := util.MPool.GetGameDB()
	defer Db.Close()
	_, err := Db.Exec("INSERT INTO server (`AppId`, `ServerId`, `ServerName`, `Status`, `CreateTime`, `OpenServerTime`) VALUES (?, ?, ?, ?, ?, ?)",
		s.AppId, s.ServerId, s.ServerName, s.Status, util.Now(), s.OpenServerTime)
	if err != nil {
		return fmt.Errorf("failed to insert: %v", err)
	}
	return nil
}

func (s *Server) EditServer() error {
	Db := util.MPool.GetGameDB()
	defer Db.Close()
	_, err := Db.Exec("UPDATE server SET `ServerName` = ?, `version` = ?, `node_tags` = ? WHERE `AppId` = ? AND `ServerId` = ?",
		s.ServerName, s.ClientVersion, s.Tags, s.AppId, s.ServerId)
	if err != nil {
		return fmt.Errorf("failed to update: %v", err)
	}
	return nil
}

func (s *Server) UpdateApp() (string, error) {
	AppConfig, err := util.GetAppConfig(s.AppId)
	if err != nil {
		return "", err
	}
	ServerConfig, err := common.GetServerConfig(DEVOPS_SERVER)
	if err != nil {
		return "", err
	}

	SshClient, err := NewSshClient(ServerConfig)
	if err != nil {
		return "", err
	}
	defer SshClient.client.Close()
	_, err = SshClient.RunCommand("cd /data/devops && git pull")
	if err != nil {
		return "", fmt.Errorf("failed to git pull: %v", err)
	}
	cmd := fmt.Sprintf("ansible-playbook /data/devops/playbook/%s.yml -i /data/devops/playbook/hosts", AppConfig.AppName)
	output, err := SshClient.RunCommand(cmd)
	if err != nil {
		return "", err
	}
	DB := util.MPool.GetGameDB()
	defer DB.Close()
	DB.Exec("UPDATE app SET `Update` = ? WHERE `AppId` = ?", util.Now(), s.AppId)
	feishu.SendFeishuMsg(fmt.Sprintf("AppName: %s, 执行文件更新完成", AppConfig.AppName))

	return output, nil
}

func (s *Server) UpdateAppFeishu() (string, error) {
	AppConfig, err := util.GetAppConfig(s.AppId)
	if err != nil {
		return "", err
	}
	ServerConfig, err := common.GetServerConfig(DEVOPS_SERVER)
	if err != nil {
		return "", err
	}

	SshClient, err := NewSshClient(ServerConfig)
	if err != nil {
		return "", err
	}
	defer SshClient.client.Close()
	_, err = SshClient.RunCommand("cd /data/devops && git pull")
	if err != nil {
		return "", fmt.Errorf("failed to git pull: %v", err)
	}
	cmd := fmt.Sprintf("ansible-playbook /data/devops/playbook/%s.yml -i /data/devops/playbook/hosts", AppConfig.AppName)
	output, err := SshClient.RunCommand(cmd)
	if err != nil {
		return "", err
	}
	DB := util.MPool.GetGameDB()
	defer DB.Close()
	DB.Exec("UPDATE app SET `Update` = ? WHERE `AppId` = ?", util.Now(), s.AppId)
	feishu.SendFeishuMsg(fmt.Sprintf("AppName: %s, 执行文件更新完成", AppConfig.AppName))
	return output, nil
}

func (s *Server) RestartServer() (string, error) {
	AppConfig, err := util.GetAppConfig(s.AppId)
	if err != nil {
		return "", err
	}
	ServerConfig, err := common.GetServerConfig(AppConfig.NodeName)
	if err != nil {
		return "", err
	}

	SshClient, err := NewSshClient(ServerConfig)
	if err != nil {
		return "", err
	}
	defer SshClient.client.Close()

	cmd := fmt.Sprintf("cd %s && ./tool/tool restart node %d", AppConfig.Path, s.ServerId)
	output, err := SshClient.RunCommand(cmd)
	if err != nil {
		return "", err
	}
	feishu.SendFeishuMsg(fmt.Sprintf("AppName: %s, ServerName: %s, 重启完成", AppConfig.AppName, s.ServerName))
	return output, nil
}

func (s *Server) ReloadServer() (string, error) {
	AppConfig, err := util.GetAppConfig(s.AppId)
	if err != nil {
		return "", err
	}

	ws, err := util.GetWebsocket(s.AppId, s.ServerId)
	if err != nil {
		return "", fmt.Errorf("failed to get websocket: %v", err)
	}
	defer ws.Close()
	req := &msg.ReqReload{}
	_, err = util.SendAdminMsg(ws, req)
	if err != nil {
		log.Printf("failed to send admin message: %v", err)
	}
	feishu.SendFeishuMsg(fmt.Sprintf("AppName: %s, ServerName: %s, 配置重载完成", AppConfig.AppName, s.ServerName))
	return "success", nil
}

// 端口扫描
func PortMap(Ip string, Port string) error {
	// 创建一个新的Nmap扫描器
	scanner, err := nmap.NewScanner(
		nmap.WithTargets(Ip), // 替换为你要扫描的目标IP地址
		nmap.WithPorts(Port), // 替换为你要扫描的端口
		// nmap.WithTCPFINScan(), // 使用TCP扫描
		nmap.WithTimingTemplate(nmap.TimingSneaky),
	)
	if err != nil {
		return err
	}

	// 执行扫描
	result, warnings, err := scanner.Run()
	if err != nil {
		return err
	}

	// 打印扫描结果
	for _, warning := range warnings {
		log.Printf("nmap 警告: %v", warning)
	}

	for _, host := range result.Hosts {
		if len(host.Ports) == 0 || host.Status.State != "up" {
			continue
		}
		for _, port := range host.Ports {
			if port.State.State == "filtered" {
				continue
			}
			if port.State.State != "open" {
				return fmt.Errorf("端口 %d 未监听 %v", port.ID, port)
			}
		}
	}
	return nil
}

func GetServerInfo(AppId, ServerId int) (interface{}, error) {
	req := &msg.ReqServerInfo{}
	ws, err := util.GetWebsocket(AppId, ServerId)
	if err != nil {
		return nil, fmt.Errorf("failed to get websocket: %v", err)
	}
	defer ws.Close()
	r, err := util.SendAdminMsg(ws, req)
	if err != nil {
		return nil, fmt.Errorf("failed to send admin message: %v", err)
	}
	return r, nil
}