formatter.go 8.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295
  1. package service
  2. import (
  3. "context"
  4. "encoding/json"
  5. "fmt"
  6. "github.com/AlekSi/pointer"
  7. v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
  8. "github.com/go-nunu/nunu-layout-advanced/internal/model"
  9. "github.com/go-nunu/nunu-layout-advanced/internal/repository"
  10. "maps"
  11. "sort"
  12. "strconv"
  13. "strings"
  14. "github.com/spf13/cast"
  15. )
  16. type FormatterService interface {
  17. FormatBackendData(ctx context.Context, req *v1.GameShieldBackendArrayRequest, output map[string]v1.SendGameShieldBackend, keyCounter int) (string, error)
  18. FormatPort(ctx context.Context, req interface{}) []int
  19. OldFormat(ctx context.Context, req *[]model.GameShieldBackend) (map[string]v1.SendGameShieldBackend, error)
  20. TidyFormatBackendData(ctx context.Context, req *v1.GameShieldBackendArrayRequest, keyCounter int) (map[string]v1.SendGameShieldBackend, error)
  21. Sort(ctx context.Context, mapData map[string]v1.SendGameShieldBackend) (map[string]v1.SendGameShieldBackend, error)
  22. ValidateBackendData(ctx context.Context, mapData map[string]v1.SendGameShieldBackend, hostId int) error
  23. }
  24. func NewFormatterService(
  25. service *Service,
  26. gameShieldPublicIpService GameShieldPublicIpService,
  27. gameShieldBackendRepository repository.GameShieldBackendRepository,
  28. hostService HostService,
  29. ) FormatterService {
  30. return &formatterService{
  31. Service: service,
  32. gameShieldPublicIpService: gameShieldPublicIpService,
  33. gameShieldBackendRepository: gameShieldBackendRepository,
  34. hostService: hostService,
  35. }
  36. }
  37. type formatterService struct {
  38. *Service
  39. gameShieldPublicIpService GameShieldPublicIpService
  40. gameShieldBackendRepository repository.GameShieldBackendRepository
  41. hostService HostService
  42. }
  43. func (service *formatterService) FormatBackendData(ctx context.Context, req *v1.GameShieldBackendArrayRequest, oldFormat map[string]v1.SendGameShieldBackend, keyCounter int) (string, error) {
  44. formData, err := service.TidyFormatBackendData(ctx, req, keyCounter)
  45. for _, v := range formData {
  46. v.Type = ""
  47. }
  48. if err != nil {
  49. return "", err
  50. }
  51. maps.Copy(formData, oldFormat)
  52. // 验证
  53. err = service.ValidateBackendData(ctx, formData, req.HostId)
  54. if err != nil {
  55. return "", err
  56. }
  57. sortedOutput, err := service.Sort(ctx, formData)
  58. if err != nil {
  59. return "", err
  60. }
  61. jsonBytes, err := json.MarshalIndent(sortedOutput, "", " ")
  62. if err != nil {
  63. return "", err
  64. }
  65. return string(jsonBytes), nil
  66. }
  67. func (service *formatterService) FormatPort(ctx context.Context, req interface{}) []int {
  68. if req == nil {
  69. return []int{}
  70. }
  71. reqStr := cast.ToString(req)
  72. if reqStr == "" {
  73. return []int{}
  74. }
  75. reqStr = strings.ReplaceAll(reqStr, ",", ",")
  76. // 分割字符串并转换为整数
  77. var res []int
  78. for _, v := range strings.Split(reqStr, ",") {
  79. // 去除空格
  80. v = strings.TrimSpace(v)
  81. if v != "" {
  82. port := cast.ToInt(v)
  83. res = append(res, port)
  84. }
  85. }
  86. return res
  87. }
  88. func (service *formatterService) OldFormat(ctx context.Context, req *[]model.GameShieldBackend) (map[string]v1.SendGameShieldBackend, error) {
  89. res := make(map[string]v1.SendGameShieldBackend)
  90. var UdpSessionTimeout string
  91. var MaxBandwidth string
  92. for _, v := range *req {
  93. addr := fmt.Sprintf("%s:%s", v.SourceMachineIP, v.ConnectPort)
  94. sdkPort, err := strconv.Atoi(v.SdkPort)
  95. if err != nil {
  96. return nil, err
  97. }
  98. if v.Protocol == "udp" {
  99. UdpSessionTimeout = "300s"
  100. } else {
  101. UdpSessionTimeout = ""
  102. }
  103. keyName := fmt.Sprintf("key%d", v.KeySort)
  104. if v.Type != "pc" {
  105. v.SdkIp = ""
  106. }
  107. if v.MaxBandwidth == 1 {
  108. MaxBandwidth = "100m"
  109. } else {
  110. MaxBandwidth = ""
  111. }
  112. res[keyName] = v1.SendGameShieldBackend{
  113. Addr: []string{addr},
  114. Protocol: v.Protocol,
  115. ProxyAddr: v.ProxyAddr,
  116. SdkPort: sdkPort,
  117. UdpSessionTimeout: UdpSessionTimeout,
  118. SdkIp: v.SdkIp,
  119. MaxBandwidth: MaxBandwidth,
  120. }
  121. }
  122. return res, nil
  123. }
  124. func (service *formatterService) TidyFormatBackendData(ctx context.Context, req *v1.GameShieldBackendArrayRequest, keyCounter int) (map[string]v1.SendGameShieldBackend, error) {
  125. output := make(map[string]v1.SendGameShieldBackend)
  126. userIp, err := service.gameShieldPublicIpService.GetUserIp(ctx, req.Uid)
  127. if err != nil {
  128. return nil, err
  129. }
  130. for _, item := range req.Items {
  131. // 提取必要字段
  132. sourceIP := item.SourceMachineIP // 假设结构体中有这个字段
  133. if sourceIP == "" {
  134. return nil, fmt.Errorf("没有有效源IP的配置") // 跳过没有有效源IP的配置
  135. }
  136. protocol := item.Protocol // 假设结构体中有这个字段
  137. if protocol == "" {
  138. return nil, fmt.Errorf("没有有效协议的配置") // 跳过没有有效协议的配置
  139. }
  140. // 获取端口数组
  141. conPorts := service.FormatPort(ctx, item.ConnectPort)
  142. sdkPorts := service.FormatPort(ctx, item.SdkPort)
  143. // 验证端口数量
  144. if len(sdkPorts) > 0 && len(conPorts) != len(sdkPorts) {
  145. return nil, fmt.Errorf("端口数量不匹配")
  146. }
  147. // 处理每一对端口
  148. for i := 0; i < len(conPorts); i++ {
  149. keyCounter++
  150. key := fmt.Sprintf("key%d", keyCounter)
  151. // 使用数组中的具体端口
  152. addr := fmt.Sprintf("%s:%d", sourceIP, conPorts[i])
  153. itemMap := v1.SendGameShieldBackend{
  154. Addr: []string{addr},
  155. Protocol: protocol,
  156. Type: item.Type,
  157. }
  158. //// 设置主机名(如果存在)
  159. //if item.Host != "" {
  160. // itemMap["host"] = item.Host
  161. //}
  162. // 根据协议设置不同属性
  163. if protocol != "udp" {
  164. if item.Checked == "agent" {
  165. itemMap.AgentAddr = fmt.Sprintf("%s:%s", sourceIP, "23350")
  166. }
  167. itemMap.ProxyAddr = userIp + ":32353"
  168. } else {
  169. itemMap.ProxyAddr = ""
  170. itemMap.UdpSessionTimeout = "300s"
  171. }
  172. if item.Type != "pc" {
  173. itemMap.SdkIp = ""
  174. } else {
  175. itemMap.SdkIp = item.SdkIp
  176. }
  177. if pointer.GetInt(item.MaxBandwidth) == 1 {
  178. itemMap.MaxBandwidth = "100m"
  179. } else {
  180. itemMap.MaxBandwidth = ""
  181. }
  182. // 设置SDK端口 - 使用数组中的具体端口
  183. if len(sdkPorts) != 0 {
  184. if sdkPorts[i] <= 1024 {
  185. if item.Type == "mobile" {
  186. return nil, fmt.Errorf("移动端不支持SSH端口")
  187. }
  188. }
  189. itemMap.SdkPort = sdkPorts[i]
  190. }
  191. output[key] = itemMap
  192. }
  193. }
  194. return output, nil
  195. }
  196. func (service *formatterService) Sort(ctx context.Context, mapData map[string]v1.SendGameShieldBackend) (map[string]v1.SendGameShieldBackend, error) {
  197. var keys []int
  198. for key := range mapData {
  199. intKey, err := strconv.Atoi(strings.TrimPrefix(key, "key"))
  200. if err != nil {
  201. return nil, err
  202. }
  203. keys = append(keys, intKey)
  204. }
  205. // 2. 排序键
  206. sort.Ints(keys)
  207. // 3. 创建一个新的 output 切片或 map 来存储排序后的值
  208. sortedOutput := make(map[string]v1.SendGameShieldBackend)
  209. // 4. 按排序后的键遍历 map,并存储对应的值到 sortedOutput
  210. for _, key := range keys {
  211. sortedOutput["key"+strconv.Itoa(key)] = mapData["key"+strconv.Itoa(key)]
  212. }
  213. return sortedOutput, nil
  214. }
  215. // 验证后端数据
  216. func (service *formatterService) ValidateBackendData(ctx context.Context, data map[string]v1.SendGameShieldBackend, hostId int) error {
  217. // 获取配置限制
  218. configCount, err := service.hostService.GetGameShieldConfig(ctx, hostId)
  219. if err != nil {
  220. return fmt.Errorf("获取配置限制失败: %w", err)
  221. }
  222. // 提取源机IP
  223. sourceIPs := make(map[string]bool)
  224. ruleEntriesCount := int64(0)
  225. maxBandwidthCount := int64(0)
  226. for _, item := range data {
  227. // 计算规则条目数
  228. ruleEntriesCount += int64(len(item.Addr))
  229. // 计算源机IP数
  230. for _, addr := range item.Addr {
  231. parts := strings.Split(addr, ":")
  232. if len(parts) > 0 {
  233. sourceIPs[parts[0]] = true
  234. }
  235. }
  236. // 计算最大带宽设置数
  237. if item.MaxBandwidth != "" {
  238. maxBandwidthCount++
  239. }
  240. }
  241. // 验证源机数量
  242. if int64(len(sourceIPs)) > configCount.SourceMachinesCount {
  243. return fmt.Errorf("超出最大源机数量,当前配置允许%d个源机,合并后有%d个源机",
  244. configCount.SourceMachinesCount, len(sourceIPs))
  245. }
  246. // 验证规则条目数
  247. if ruleEntriesCount > configCount.RuleEntriesCount {
  248. return fmt.Errorf("超出最大规则数量,当前配置允许%d个规则,合并后有%d个规则",
  249. configCount.RuleEntriesCount, ruleEntriesCount)
  250. }
  251. // 验证最大带宽设置数
  252. if maxBandwidthCount > configCount.MaxBandwidthCount {
  253. return fmt.Errorf("超出最大带宽数量,当前配置允许%d个带宽设置,合并后有%d个",
  254. configCount.MaxBandwidthCount, maxBandwidthCount)
  255. }
  256. return nil
  257. }