admin_backend/model/server.go

package model

import (
	"backend/common"
	"backend/msg"
	util "backend/uitl"
	"encoding/json"
	"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"`
}

type App struct {
	AppId   int    `json:"AppId" db:"AppId"`
	AppName string `json:"AppName" db:"AppName"`
	Update  int    `json:"Update" db:"Update"`
}

type ServerInfo struct {
	AppId          int    `json:"AppId" db:"AppId"`
	ServerId       int    `json:"ServerId" db:"ServerId"`
	ServerName     string `json:"ServerName" db:"ServerName"`
	Status         int    `json:"Status" db:"Status"`
	CreateTime     int    `json:"CreateTime" db:"CreateTime"`
	OpenServerTime int    `json:"OpenServerTime" db:"OpenServerTime"`
	StartTime      int64  `json:"StartTime"`
	PlayerNum      int    `json:"PlayerNum"`
}

func (s *Server) AppList() ([]*App, error) {
	Db := GetGameDB()
	var app []*App
	err := Db.Select(&app, "SELECT `AppId`, `AppName`, `Update` FROM app")
	if err != nil {
		return nil, fmt.Errorf("failed to scan rows: %v", err)
	}
	return app, nil
}

func (s *Server) ServerList() ([]*ServerInfo, error) {
	Db := GetGameDB()
	var server []*ServerInfo
	err := Db.Select(&server, "SELECT `AppId`, `ServerId`, `ServerName`, `Status`, `CreateTime`, `OpenServerTime` FROM server where AppId = ?", s.AppId)
	if err != nil {
		return nil, fmt.Errorf("failed to scan rows: %v", err)
	}
	if s.Type == 1 {
		return server, nil
	}
	for _, v := range server {
		ws, err := getWebsocket(v.AppId, v.ServerId)
		if err != nil {
			v.Status = 0
			continue
		}
		req := &msg.ReqServerInfo{}
		reqBuf := util.PackMsg(req)
		_, err = ws.Write(reqBuf)
		if err != nil {
			continue
		}

		readbuf := make([]byte, 4096)
		n, err := ws.Read(readbuf)
		if err != nil {
			continue
		}
		resBuf, _ := util.UnpackMsg(readbuf, n)
		// fmt.Println(string(resBuf))
		r := make(map[string]interface{})
		json.Unmarshal(resBuf, &r)
		if r["StartTime"] != nil {
			v.StartTime = int64(r["StartTime"].(float64))
		}
		if r["PlayerNum"] != nil {
			v.PlayerNum = int(r["PlayerNum"].(float64))
		}
		v.Status = 1
		ws.Close()
	}

	return server, nil
}

func (s *Server) AddServer() error {
	Db := GetGameDB()
	_, 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) UpdateApp() (string, error) {
	AppConfig, err := 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
	}
	_, 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 := GetGameDB()
	DB.Exec("UPDATE app SET `Update` = ? WHERE `AppId` = ?", util.Now(), s.AppId)
	common.SendFeishuMsg(fmt.Sprintf("AppName: %s, 执行文件更新完成", AppConfig.AppName))
	return output, nil
}

func (s *Server) UpdateAppFeishu() (string, error) {
	AppConfig, err := 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
	}
	_, 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 := GetGameDB()
	DB.Exec("UPDATE app SET `Update` = ? WHERE `AppId` = ?", util.Now(), s.AppId)
	common.SendFeishuMsg(fmt.Sprintf("AppName: %s, 执行文件更新完成", AppConfig.AppName))
	return output, nil
}

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

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

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

	ws, err := 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)
	}
	common.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), // 替换为你要扫描的端口
	)
	if err != nil {
		return err
	}

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

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

	for _, host := range result.Hosts {
		if len(host.Ports) == 0 || host.Status.State != "up" {
			return fmt.Errorf("主机不可达")
		}
	}
	return nil
}