130 lines
4.1 KiB
Go
130 lines
4.1 KiB
Go
package server_bak
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/hibiken/asynq"
|
|
"github.com/perfect-panel/server/internal/model/server"
|
|
"github.com/perfect-panel/server/internal/svc"
|
|
"github.com/perfect-panel/server/internal/types"
|
|
"github.com/perfect-panel/server/pkg/logger"
|
|
"github.com/perfect-panel/server/pkg/tool"
|
|
"github.com/perfect-panel/server/pkg/xerr"
|
|
queue "github.com/perfect-panel/server/queue/types"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
type CreateNodeLogic struct {
|
|
logger.Logger
|
|
ctx context.Context
|
|
svcCtx *svc.ServiceContext
|
|
}
|
|
|
|
func NewCreateNodeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateNodeLogic {
|
|
return &CreateNodeLogic{
|
|
Logger: logger.WithContext(ctx),
|
|
ctx: ctx,
|
|
svcCtx: svcCtx,
|
|
}
|
|
}
|
|
|
|
func (l *CreateNodeLogic) CreateNode(req *types.CreateNodeRequest) error {
|
|
config, err := json.Marshal(req.Config)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var serverInfo server.Server
|
|
tool.DeepCopy(&serverInfo, req)
|
|
serverInfo.Config = string(config)
|
|
nodeRelay, err := json.Marshal(req.RelayNode)
|
|
if err != nil {
|
|
l.Errorw("[UpdateNode] Marshal RelayNode Error: ", logger.Field("error", err.Error()))
|
|
return err
|
|
}
|
|
if len(req.Tags) > 0 {
|
|
serverInfo.Tags = strings.Join(req.Tags, ",")
|
|
}
|
|
|
|
serverInfo.LastReportedAt = time.UnixMicro(1218124800)
|
|
|
|
serverInfo.City = req.City
|
|
serverInfo.Country = req.Country
|
|
|
|
serverInfo.RelayNode = string(nodeRelay)
|
|
if req.Protocol == "vless" {
|
|
var cfg types.Vless
|
|
if err = json.Unmarshal(config, &cfg); err != nil {
|
|
return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "json.Unmarshal error: %v", err.Error())
|
|
}
|
|
if cfg.Security == "reality" && cfg.SecurityConfig.RealityPublicKey == "" {
|
|
public, private, err := tool.Curve25519Genkey(false, "")
|
|
if err != nil {
|
|
return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "generate curve25519 key error")
|
|
}
|
|
cfg.SecurityConfig.RealityPublicKey = public
|
|
cfg.SecurityConfig.RealityPrivateKey = private
|
|
cfg.SecurityConfig.RealityShortId = tool.GenerateShortID(private)
|
|
}
|
|
if cfg.SecurityConfig.RealityServerAddr == "" {
|
|
cfg.SecurityConfig.RealityServerAddr = cfg.SecurityConfig.SNI
|
|
}
|
|
if cfg.SecurityConfig.RealityServerPort == 0 {
|
|
cfg.SecurityConfig.RealityServerPort = 443
|
|
}
|
|
config, _ = json.Marshal(cfg)
|
|
serverInfo.Config = string(config)
|
|
} else if req.Protocol == "shadowsocks" {
|
|
var cfg types.Shadowsocks
|
|
if err = json.Unmarshal(config, &cfg); err != nil {
|
|
l.Errorf("[CreateNode] Unmarshal Shadowsocks Config Error: %v", err.Error())
|
|
return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "json.Unmarshal error: %v", err.Error())
|
|
}
|
|
if strings.Contains(cfg.Method, "2022") {
|
|
var length int
|
|
switch cfg.Method {
|
|
case "2022-blake3-aes-128-gcm":
|
|
length = 16
|
|
default:
|
|
length = 32
|
|
}
|
|
if len(cfg.ServerKey) != length {
|
|
cfg.ServerKey = tool.GenerateCipher(cfg.ServerKey, length)
|
|
}
|
|
}
|
|
config, _ = json.Marshal(cfg)
|
|
serverInfo.Config = string(config)
|
|
}
|
|
|
|
err = l.svcCtx.ServerModel.Insert(l.ctx, &serverInfo)
|
|
if err != nil {
|
|
l.Errorw("[CreateNode] Insert Database Error: ", logger.Field("error", err.Error()))
|
|
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create server error: %v", err)
|
|
}
|
|
|
|
if req.City == "" || req.Country == "" {
|
|
// Marshal the task payload
|
|
payload, err := json.Marshal(queue.GetNodeCountry{
|
|
Protocol: serverInfo.Protocol,
|
|
ServerAddr: serverInfo.ServerAddr,
|
|
})
|
|
if err != nil {
|
|
l.Errorw("[GetNodeCountry]: Marshal Error", logger.Field("error", err.Error()))
|
|
return errors.Wrap(xerr.NewErrCode(xerr.ERROR), "Failed to marshal task payload")
|
|
}
|
|
// Create a queue task
|
|
task := asynq.NewTask(queue.ForthwithGetCountry, payload)
|
|
// Enqueue the task
|
|
taskInfo, err := l.svcCtx.Queue.Enqueue(task)
|
|
if err != nil {
|
|
l.Errorw("[GetNodeCountry]: Enqueue Error", logger.Field("error", err.Error()), logger.Field("payload", string(payload)))
|
|
return errors.Wrap(xerr.NewErrCode(xerr.ERROR), "Failed to enqueue task")
|
|
}
|
|
l.Infow("[GetNodeCountry]: Enqueue Success", logger.Field("taskID", taskInfo.ID), logger.Field("payload", string(payload)))
|
|
}
|
|
|
|
return nil
|
|
}
|