bl/modules/config/service/server.go

package service

import (
	"blazing/common/utils"
	"blazing/cool"
	"blazing/modules/config/model"
	"fmt"
	"sort"
	"time"

	"github.com/gogf/gf/v2/container/gmap"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/qiniu/go-sdk/v7/auth/qbox"
	"github.com/qiniu/go-sdk/v7/storage"
)

type ServerService struct {
	*cool.Service
	manager *storage.BucketManager
	bucket  string
}

type ServerShowInfo struct {
	OnlineID   uint32            `json:"online_id"`
	Name       string            `json:"name"`
	IP         string            `json:"ip"`
	Port       uint32            `json:"port"`
	IsVip      uint32            `json:"is_vip"`
	IsDebug    uint8             `json:"is_debug"`
	IsOpen     uint8             `json:"is_open"`
	Owner      uint32            `json:"owner"`
	ExpireTime time.Time         `json:"expire_time"`
	ServerShow *model.ServerShow `json:"servershow,omitempty"`
}

func NewServerService() *ServerService {
	cf := &ServerService{
		Service: &cool.Service{
			Model: model.NewServerList(),
		},
	}
	cf.PageQueryOp = &cool.QueryOp{
		ModifyResult: func(ctx g.Ctx, data interface{}) interface{} {
			var rr []g.MapStrAny
			r, _ := gconv.Map(data)["list"].(gdb.Result)

			now := time.Now()
			serverIDs := make([]uint32, 0, len(r))
			for i := 0; i < len(r); i++ {
				serverID := gconv.Uint32(r[i].Map()["online_id"])
				if serverID == 0 {
					continue
				}
				serverIDs = append(serverIDs, serverID)
			}
			showMap := cf.getPrimaryActiveServerShowMap(serverIDs, now)

			for i := 0; i < len(r); i++ {
				t, ok := cool.GetClient(gconv.Uint32(r[i].Map()["online_id"]), gconv.Uint32(r[i].Map()["port"]))
				subm := r[i].GMap()
				cf.applyServerShowMap(subm, gconv.Uint32(r[i].Map()["online_id"]), showMap)

				if ok {
					err := t.KickPerson(0) //实现指定服务器踢人
					if err == nil {
						r, _ := utils.TcpPing(fmt.Sprintf("%s:%d", r[i].Map()["ip"], r[i].Map()["port"]))
						subm.Set("isonline", r)
					} else {
						subm.Set("isonline", 0)
					}
				} else {
					subm.Set("isonline", 0)
				}
				rr = append(rr, subm.MapStrAny())
			}

			data.(map[string]interface{})["list"] = rr
			return data
		},
	}

	cfg := storage.Config{
		Zone:          &storage.ZoneHuadong,
		UseHTTPS:      true,
		UseCdnDomains: true,
	}
	mac := qbox.NewMac("DzMpomnPxqBHkIcvxTbC-hl_8LjVB0LXZuhCky_u", "bhoxrpG1s7MBmSS2I1k5t9zMpuiderpBDZoIPQKU")
	cf.bucket = "blazingt"
	cf.manager = storage.NewBucketManager(mac, &cfg)
	return cf
}

func (s *ServerService) GetPort(DepartmentID uint) []ServerShowInfo {
	servers := s.getRawServers()
	now := time.Now()
	showMap := s.getActiveServerShowListMap(s.collectServerIDs(servers), now)
	items := make([]ServerShowInfo, 0, len(servers))
	for _, server := range servers {
		if server.IsOpen != 1 {
			continue
		}
		if DepartmentID == 1 && server.IsDebug != 0 {
			continue
		}
		items = append(items, ServerShowInfo{
			OnlineID:   server.OnlineID,
			Name:       server.Name,
			IP:         server.IP,
			Port:       server.Port,
			IsVip:      server.IsVip,
			IsDebug:    server.IsDebug,
			IsOpen:     server.IsOpen,
			Owner:      0,
			ExpireTime: time.Time{},
		})
		for i := range showMap[server.OnlineID] {
			show := &showMap[server.OnlineID][i]
			item := ServerShowInfo{
				OnlineID:   server.OnlineID,
				Name:       server.Name,
				IP:         server.IP,
				Port:       server.Port,
				IsVip:      server.IsVip,
				IsDebug:    server.IsDebug,
				IsOpen:     server.IsOpen,
				Owner:      show.Owner,
				ExpireTime: show.ExpireTime,
				ServerShow: show,
			}
			if show.Name != "" {
				item.Name = show.Name
			}
			items = append(items, item)
		}
	}
	return items
}

func (s *ServerService) GetServer() []model.ServerList {
	item := s.getRawServers()
	s.applyServerShowList(item, time.Now())
	return item
}

func (s *ServerService) StartUPdate(OnlineID uint16, isinstall int) model.ServerList {
	m := cool.DBM(s.Model).Where("online_id", OnlineID)
	var tttt model.ServerList
	m.Scan(&tttt)
	if isinstall == 1 {
		tttt.IsOpen = uint8(0)
		m.Save(tttt)
	}
	return tttt
}

func (s *ServerService) SetServerID(OnlineID uint32, Port uint32) error {
	m := cool.DBM(s.Model).Where("online_id", OnlineID)
	var tttt model.ServerList
	m.Scan(&tttt)
	tttt.Port = Port
	tttt.OnlineID = OnlineID
	tttt.IsOpen = 1
	m.Save(tttt)
	return nil
}

func (s *ServerService) GetServerID(OnlineID uint32) model.ServerList {
	var tttt model.ServerList
	dbm_nocache_noenable(s.Model).Where("online_id", OnlineID).Scan(&tttt)
	showMap := s.getPrimaryActiveServerShowMap([]uint32{OnlineID}, time.Now())
	s.applyServerShow(&tttt, showMap[OnlineID], time.Now())
	return tttt
}

// GetDonationAvailableServerIDs 返回当前可被冠名占用的服务器ID列表。
func (s *ServerService) GetDonationAvailableServerIDs() []uint32 {
	servers := s.getRawServers()
	ids := make([]uint32, 0, len(servers))
	for _, server := range servers {
		if server.OnlineID == 0 {
			continue
		}
		ids = append(ids, server.OnlineID)
	}
	sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
	return ids
}

// CanUseDonationName 校验目标服务器在当前时间点是否允许被冠名。
func (s *ServerService) CanUseDonationName(server model.ServerList, ownerID uint32, now time.Time) bool {
	return server.OnlineID != 0
}

func (s *ServerService) getRawServers() []model.ServerList {
	var item []model.ServerList
	dbm_nocache_noenable(s.Model).Scan(&item)
	return item
}

func (s *ServerService) collectServerIDs(servers []model.ServerList) []uint32 {
	serverIDs := make([]uint32, 0, len(servers))
	for i := range servers {
		if servers[i].OnlineID == 0 {
			continue
		}
		serverIDs = append(serverIDs, servers[i].OnlineID)
	}
	return serverIDs
}

// 保存版本号
func (s *ServerService) SetServerScreen(id uint32, name string) {
	cool.DBM(s.Model).Where("online_id", id).Data("old_screen", name).Update()
}

func (s *ServerService) GetFile() string {
	var files []File
	prefix := "logic"
	delimiter := "" // 用于分隔目录
	marker := ""    // 初始标记为空
	for {
		entries, _, nextMarker, hasNext, err := s.manager.ListFiles(s.bucket, prefix, delimiter, marker, 100)
		if err != nil {
			return ""
		}
		for _, entry := range entries {
			files = append(files, File{
				Name: entry.Key,
				Size: entry.Fsize,
				Path: entry.Key,
				Time: entry.PutTime,
			})
		}
		if !hasNext {
			break
		}
		marker = nextMarker
	}

	sort.Slice(files, func(i, j int) bool {
		return files[i].Time > files[j].Time
	})
	if len(files) == 0 {
		return ""
	}
	return files[0].Name
}

type File struct {
	Name     string `json:"name"`
	Path     string `json:"path"`
	Url      string `json:"url"`
	Size     int64  `json:"size"`
	Modified string `json:"modified"`
	Time     int64  `json:"time"`
}

func (s *ServerService) isActiveServerShow(show *model.ServerShow, now time.Time) bool {
	if show == nil {
		return false
	}
	if show.ServerID == 0 || show.Owner == 0 {
		return false
	}
	if show.ExpireTime.IsZero() {
		return false
	}
	return show.ExpireTime.After(now)
}

func (s *ServerService) applyServerShowList(servers []model.ServerList, now time.Time) {
	showMap := s.getPrimaryActiveServerShowMap(s.collectServerIDs(servers), now)
	for i := range servers {
		s.applyServerShow(&servers[i], showMap[servers[i].OnlineID], now)
	}
}

func (s *ServerService) applyServerShow(server *model.ServerList, show *model.ServerShow, now time.Time) {
	if server == nil {
		return
	}
	server.ServerShow = nil
	server.Owner = 0
	server.ExpireTime = time.Time{}
	if !s.isActiveServerShow(show, now) {
		return
	}
	server.ServerShow = show
	if show.Name != "" {
		server.Name = show.Name
	}
	server.Owner = show.Owner
	server.ExpireTime = show.ExpireTime
}

func (s *ServerService) getActiveServerShowListMap(serverIDs []uint32, now time.Time) map[uint32][]model.ServerShow {
	showMap := make(map[uint32][]model.ServerShow, len(serverIDs))
	if len(serverIDs) == 0 {
		return showMap
	}
	var shows []model.ServerShow
	dbm_nocache_noenable(model.NewServerShow()).WhereIn("server_id", serverIDs).Scan(&shows)
	for i := range shows {
		show := &shows[i]
		if !s.isActiveServerShow(show, now) {
			continue
		}
		showMap[show.ServerID] = append(showMap[show.ServerID], *show)
	}
	for serverID := range showMap {
		sort.Slice(showMap[serverID], func(i, j int) bool {
			left := showMap[serverID][i]
			right := showMap[serverID][j]
			if !left.ExpireTime.Equal(right.ExpireTime) {
				return left.ExpireTime.After(right.ExpireTime)
			}
			return left.ID > right.ID
		})
	}
	return showMap
}

func (s *ServerService) getPrimaryActiveServerShowMap(serverIDs []uint32, now time.Time) map[uint32]*model.ServerShow {
	listMap := s.getActiveServerShowListMap(serverIDs, now)
	showMap := make(map[uint32]*model.ServerShow, len(listMap))
	for serverID := range listMap {
		if len(listMap[serverID]) == 0 {
			continue
		}
		show := listMap[serverID][0]
		showMap[serverID] = &show
	}
	return showMap
}

func (s *ServerService) applyServerShowMap(serverMap *gmap.StrAnyMap, serverID uint32, showMap map[uint32]*model.ServerShow) {
	if serverMap == nil {
		return
	}
	serverMap.Set("owner", uint32(0))
	serverMap.Set("expire_time", time.Time{})
	show, ok := showMap[serverID]
	if !ok {
		return
	}
	if show.Name != "" {
		serverMap.Set("name", show.Name)
	}
	serverMap.Set("owner", show.Owner)
	serverMap.Set("expire_time", show.ExpireTime)
	serverMap.Set("servershow", show)
	return
}