添加DNS服务

This commit is contained in:
junleea 2026-05-02 14:45:51 +08:00
parent 5525fe6f2f
commit 07a5c81fb2
10 changed files with 1727 additions and 14 deletions

View File

@ -122,6 +122,19 @@ func Init() error {
log.Println("sqlrunhistory table:", err) log.Println("sqlrunhistory table:", err)
} }
err = db.AutoMigrate(&proto.DNSServer{})
if err != nil {
log.Println("dnsserver table:", err)
}
err = db.AutoMigrate(&proto.DNSZone{})
if err != nil {
log.Println("dnszone table:", err)
}
err = db.AutoMigrate(&proto.DNSRecord{})
if err != nil {
log.Println("dnsrecord table:", err)
}
DB = db DB = db
return err return err
} }

289
dao/dns.go Normal file
View File

@ -0,0 +1,289 @@
package dao
import (
"videoplayer/proto"
"gorm.io/gorm"
)
// ==================== DNSServer 相关操作 ====================
func CreateDNSServer(server proto.DNSServer) (uint, error) {
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Create(&server)
if res.Error != nil {
return 0, res.Error
}
return server.ID, nil
}
func FindDNSServerByID(id uint) (proto.DNSServer, error) {
var server proto.DNSServer
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Where("id = ?", id).First(&server)
if res.Error != nil {
return proto.DNSServer{}, res.Error
}
return server, nil
}
func FindDNSServerByUserID(userID uint) ([]proto.DNSServer, error) {
var servers []proto.DNSServer
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Where("user_id = ?", userID).Find(&servers)
if res.Error != nil {
return nil, res.Error
}
return servers, nil
}
func FindAllDNSServer() ([]proto.DNSServer, error) {
var servers []proto.DNSServer
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Find(&servers)
if res.Error != nil {
return nil, res.Error
}
return servers, nil
}
func UpdateDNSServer(id uint, server *proto.DNSServer) error {
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Model(&proto.DNSServer{}).Where("id = ?", id).Updates(server)
return res.Error
}
func DeleteDNSServerByID(id uint) error {
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Where("id = ?", id).Delete(&proto.DNSServer{})
return res.Error
}
func DeleteDNSServerByUserID(userID uint) error {
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Where("user_id = ?", userID).Delete(&proto.DNSServer{})
return res.Error
}
// ==================== DNSZone 相关操作 ====================
func CreateDNSZone(zone proto.DNSZone) (uint, error) {
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Create(&zone)
if res.Error != nil {
return 0, res.Error
}
return zone.ID, nil
}
func FindDNSZoneByID(id uint) (proto.DNSZone, error) {
var zone proto.DNSZone
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Where("id = ?", id).First(&zone)
if res.Error != nil {
return proto.DNSZone{}, res.Error
}
return zone, nil
}
func FindDNSZoneByServerID(serverID uint) ([]proto.DNSZone, error) {
var zones []proto.DNSZone
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Where("server_id = ?", serverID).Find(&zones)
if res.Error != nil {
return nil, res.Error
}
return zones, nil
}
func FindAllDNSZone() ([]proto.DNSZone, error) {
var zones []proto.DNSZone
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Find(&zones)
if res.Error != nil {
return nil, res.Error
}
return zones, nil
}
func UpdateDNSZone(id uint, zone *proto.DNSZone) error {
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Model(&proto.DNSZone{}).Where("id = ?", id).Updates(zone)
return res.Error
}
func DeleteDNSZoneByID(id uint) error {
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Where("id = ?", id).Delete(&proto.DNSZone{})
return res.Error
}
func DeleteDNSZoneByServerID(serverID uint) error {
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Where("server_id = ?", serverID).Delete(&proto.DNSZone{})
return res.Error
}
// ==================== DNSRecord 相关操作 ====================
func CreateDNSRecord(record proto.DNSRecord) (uint, error) {
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Create(&record)
if res.Error != nil {
return 0, res.Error
}
return record.ID, nil
}
func FindDNSRecordByID(id uint) (proto.DNSRecord, error) {
var record proto.DNSRecord
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Where("id = ?", id).First(&record)
if res.Error != nil {
return proto.DNSRecord{}, res.Error
}
return record, nil
}
func FindDNSRecordByZoneID(zoneID uint) ([]proto.DNSRecord, error) {
var records []proto.DNSRecord
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Where("zone_id = ?", zoneID).Find(&records)
if res.Error != nil {
return nil, res.Error
}
return records, nil
}
func FindAllDNSRecord() ([]proto.DNSRecord, error) {
var records []proto.DNSRecord
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Find(&records)
if res.Error != nil {
return nil, res.Error
}
return records, nil
}
func UpdateDNSRecord(id uint, record *proto.DNSRecord) error {
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Model(&proto.DNSRecord{}).Where("id = ?", id).Updates(record)
return res.Error
}
func DeleteDNSRecordByID(id uint) error {
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Where("id = ?", id).Delete(&proto.DNSRecord{})
return res.Error
}
func DeleteDNSRecordByZoneID(zoneID uint) error {
var db2 *gorm.DB
if proto.Config.SERVER_SQL_LOG {
db2 = DB.Debug()
} else {
db2 = DB
}
res := db2.Where("zone_id = ?", zoneID).Delete(&proto.DNSRecord{})
return res.Error
}

17
go.mod
View File

@ -1,6 +1,6 @@
module videoplayer module videoplayer
go 1.21 go 1.24.0
require ( require (
github.com/gin-gonic/gin v1.10.0 github.com/gin-gonic/gin v1.10.0
@ -8,9 +8,11 @@ require (
github.com/golang-jwt/jwt v3.2.2+incompatible github.com/golang-jwt/jwt v3.2.2+incompatible
github.com/google/uuid v1.6.0 github.com/google/uuid v1.6.0
github.com/gorilla/websocket v1.5.3 github.com/gorilla/websocket v1.5.3
github.com/miekg/dns v1.1.72
github.com/robfig/cron/v3 v3.0.1 github.com/robfig/cron/v3 v3.0.1
gorm.io/driver/mysql v1.5.6 gorm.io/driver/mysql v1.5.6
gorm.io/driver/postgres v1.5.9 gorm.io/driver/postgres v1.5.9
gorm.io/driver/sqlite v1.6.0
gorm.io/gorm v1.30.0 gorm.io/gorm v1.30.0
) )
@ -47,12 +49,13 @@ require (
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
github.com/ugorji/go/codec v1.2.12 // indirect github.com/ugorji/go/codec v1.2.12 // indirect
golang.org/x/arch v0.8.0 // indirect golang.org/x/arch v0.8.0 // indirect
golang.org/x/crypto v0.23.0 // indirect golang.org/x/crypto v0.46.0 // indirect
golang.org/x/net v0.25.0 // indirect golang.org/x/mod v0.31.0 // indirect
golang.org/x/sync v0.9.0 // indirect golang.org/x/net v0.48.0 // indirect
golang.org/x/sys v0.20.0 // indirect golang.org/x/sync v0.19.0 // indirect
golang.org/x/text v0.20.0 // indirect golang.org/x/sys v0.39.0 // indirect
golang.org/x/text v0.32.0 // indirect
golang.org/x/tools v0.40.0 // indirect
google.golang.org/protobuf v1.34.1 // indirect google.golang.org/protobuf v1.34.1 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect
gorm.io/driver/sqlite v1.6.0 // indirect
) )

16
go.sum
View File

@ -73,6 +73,8 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU= github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
github.com/miekg/dns v1.1.72 h1:vhmr+TF2A3tuoGNkLDFK9zi36F2LS+hKTRW0Uf8kbzI=
github.com/miekg/dns v1.1.72/go.mod h1:+EuEPhdHOsfk6Wk5TT2CzssZdqkmFhf8r+aVyDEToIs=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@ -113,20 +115,34 @@ golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys= golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI= golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
golang.org/x/crypto v0.46.0 h1:cKRW/pmt1pKAfetfu+RCEvjvZkA9RimPbh7bhFjGVBU=
golang.org/x/crypto v0.46.0/go.mod h1:Evb/oLKmMraqjZ2iQTwDwvCtJkczlDuTmdJXoZVzqU0=
golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI=
golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg=
golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac= golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM= golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU=
golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY=
golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ= golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ=
golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk= golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug= golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4= golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA=
golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg= google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=

View File

@ -1,7 +1,6 @@
package handler package handler
import ( import (
"bytes"
"encoding/json" "encoding/json"
"fmt" "fmt"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
@ -125,7 +124,7 @@ func RunCID(c *gin.Context) {
c.JSON(200, gin.H{"error": "CID not found", "code": proto.OperationFailed, "message": "failed"}) c.JSON(200, gin.H{"error": "CID not found", "code": proto.OperationFailed, "message": "failed"})
return return
} else { } else {
cidTaskQueue &lt;- CIDTask{ cidTaskQueue <- CIDTask{
Name: cid.Name, Name: cid.Name,
Url: cid.Url, Url: cid.Url,
Script: cid.Script, Script: cid.Script,
@ -268,7 +267,7 @@ func CIDCallback(c *gin.Context) {
return return
} }
if res.ID != 0 { if res.ID != 0 {
cidTaskQueue &lt;- CIDTask{ cidTaskQueue <- CIDTask{
Name: res.Name, Name: res.Name,
Url: res.Url, Url: res.Url,
Script: res.Script, Script: res.Script,

406
handler/dns.go Normal file
View File

@ -0,0 +1,406 @@
package handler
import (
"net/http"
"videoplayer/proto"
"videoplayer/service"
"github.com/gin-gonic/gin"
)
func SetDNSGroup(router *gin.Engine) {
dns := router.Group("/dns")
dns.POST("/server/create", CreateDNSServerHandler)
dns.POST("/server/get", GetDNSServerHandler)
dns.POST("/server/update", UpdateDNSServerHandler)
dns.POST("/server/delete", DeleteDNSServerHandler)
dns.POST("/server/start", StartDNSServerHandler)
dns.POST("/server/stop", StopDNSServerHandler)
dns.POST("/server/restart", RestartDNSServerHandler)
dns.POST("/server/status", GetDNSServerStatusHandler)
dns.POST("/zone/create", CreateDNSZoneHandler)
dns.POST("/zone/get", GetDNSZoneHandler)
dns.POST("/zone/update", UpdateDNSZoneHandler)
dns.POST("/zone/delete", DeleteDNSZoneHandler)
dns.POST("/record/create", CreateDNSRecordHandler)
dns.POST("/record/get", GetDNSRecordHandler)
dns.POST("/record/update", UpdateDNSRecordHandler)
dns.POST("/record/delete", DeleteDNSRecordHandler)
}
// ==================== DNSServer 相关 Handler ====================
func CreateDNSServerHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := uint(id.(float64))
var req proto.CreateDNSServerReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
server, err := service.CreateDNSServer(&req, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "创建DNS服务器失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "创建DNS服务器成功"
resp.Data = server
}
}
c.JSON(http.StatusOK, resp)
}
func GetDNSServerHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := uint(id.(float64))
var req proto.GetDNSServerReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
servers, err := service.GetDNSServerList(&req, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "获取DNS服务器失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "获取DNS服务器成功"
resp.Data = servers
}
}
c.JSON(http.StatusOK, resp)
}
func UpdateDNSServerHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := int(id.(float64))
var req proto.UpdateDNSServerReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
server, err := service.UpdateDNSServer(&req, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "更新DNS服务器失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "更新DNS服务器成功"
resp.Data = server
}
}
c.JSON(http.StatusOK, resp)
}
func DeleteDNSServerHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := int(id.(float64))
var req proto.DeleteDNSServerReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
err := service.DeleteDNSServer(&req, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "删除DNS服务器失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "删除DNS服务器成功"
}
}
c.JSON(http.StatusOK, resp)
}
// ==================== DNSZone 相关 Handler ====================
func CreateDNSZoneHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := uint(id.(float64))
var req proto.CreateDNSZoneReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
zone, err := service.CreateDNSZone(&req, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "创建DNS区域失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "创建DNS区域成功"
resp.Data = zone
}
}
c.JSON(http.StatusOK, resp)
}
func GetDNSZoneHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := uint(id.(float64))
var req proto.GetDNSZoneReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
zones, err := service.GetDNSZoneList(&req, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "获取DNS区域失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "获取DNS区域成功"
resp.Data = zones
}
}
c.JSON(http.StatusOK, resp)
}
func UpdateDNSZoneHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := int(id.(float64))
var req proto.UpdateDNSZoneReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
zone, err := service.UpdateDNSZone(&req, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "更新DNS区域失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "更新DNS区域成功"
resp.Data = zone
}
}
c.JSON(http.StatusOK, resp)
}
func DeleteDNSZoneHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := int(id.(float64))
var req proto.DeleteDNSZoneReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
err := service.DeleteDNSZone(&req, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "删除DNS区域失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "删除DNS区域成功"
}
}
c.JSON(http.StatusOK, resp)
}
// ==================== DNSRecord 相关 Handler ====================
func CreateDNSRecordHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := uint(id.(float64))
var req proto.CreateDNSRecordReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
record, err := service.CreateDNSRecord(&req, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "创建DNS记录失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "创建DNS记录成功"
resp.Data = record
}
}
c.JSON(http.StatusOK, resp)
}
func GetDNSRecordHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := uint(id.(float64))
var req proto.GetDNSRecordReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
records, err := service.GetDNSRecordList(&req, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "获取DNS记录失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "获取DNS记录成功"
resp.Data = records
}
}
c.JSON(http.StatusOK, resp)
}
func UpdateDNSRecordHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := int(id.(float64))
var req proto.UpdateDNSRecordReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
record, err := service.UpdateDNSRecord(&req, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "更新DNS记录失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "更新DNS记录成功"
resp.Data = record
}
}
c.JSON(http.StatusOK, resp)
}
func DeleteDNSRecordHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := int(id.(float64))
var req proto.DeleteDNSRecordReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
err := service.DeleteDNSRecord(&req, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "删除DNS记录失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "删除DNS记录成功"
}
}
c.JSON(http.StatusOK, resp)
}
// 启动DNS服务器
func StartDNSServerHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := int(id.(float64))
var req proto.StartDNSServerReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
instance, err := service.StartDNSServer(req.ServerID, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "启动DNS服务器失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "启动DNS服务器成功"
resp.Data = instance
}
}
c.JSON(http.StatusOK, resp)
}
// 停止DNS服务器
func StopDNSServerHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := int(id.(float64))
var req proto.StopDNSServerReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
err := service.StopDNSServer(req.ServerID, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "停止DNS服务器失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "停止DNS服务器成功"
}
}
c.JSON(http.StatusOK, resp)
}
// 重启DNS服务器
func RestartDNSServerHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := int(id.(float64))
var req proto.RestartDNSServerReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
instance, err := service.RestartDNSServer(req.ServerID, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "重启DNS服务器失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "重启DNS服务器成功"
resp.Data = instance
}
}
c.JSON(http.StatusOK, resp)
}
// 获取DNS服务器状态
func GetDNSServerStatusHandler(c *gin.Context) {
id, _ := c.Get("id")
userID := int(id.(float64))
var req proto.GetDNSServerStatusReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
resp.Code = proto.ParameterError
resp.Message = "请求参数解析错误"
} else {
status, err := service.GetDNSServerStatus(req.ServerID, userID)
if err != nil {
resp.Code = proto.ErrorCode
resp.Message = "获取DNS服务器状态失败: " + err.Error()
} else {
resp.Code = proto.SuccessCode
resp.Message = "获取DNS服务器状态成功"
resp.Data = status
}
}
c.JSON(http.StatusOK, resp)
}

View File

@ -3,9 +3,6 @@ package main
import ( import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"github.com/gin-gonic/gin"
"github.com/golang-jwt/jwt"
"github.com/robfig/cron/v3"
"io" "io"
"log" "log"
"net/http" "net/http"
@ -17,6 +14,10 @@ import (
"videoplayer/proto" "videoplayer/proto"
"videoplayer/service" "videoplayer/service"
"videoplayer/worker" "videoplayer/worker"
"github.com/gin-gonic/gin"
"github.com/golang-jwt/jwt"
"github.com/robfig/cron/v3"
) )
func main() { func main() {
@ -49,6 +50,7 @@ func main() {
handler.SetUpFileGroup(r) // File handler.SetUpFileGroup(r) // File
handler.SetUpShellGroup(r) // Shell handler.SetUpShellGroup(r) // Shell
handler.SetDBManageGroup(r) // DBM handler.SetDBManageGroup(r) // DBM
handler.SetDNSGroup(r) // DNS
defer dao.Close() defer dao.Close()
defer worker.CloseRedis() defer worker.CloseRedis()
//定时任务 //定时任务

200
proto/dns.go Normal file
View File

@ -0,0 +1,200 @@
package proto
import (
"gorm.io/gorm"
)
const (
DNS_STATUS_STOPPED = 0 // DNS服务器状态已停止
DNS_STATUS_RUNNING = 1 // DNS服务器状态运行中
DNS_STATUS_ERROR = 2 // DNS服务器状态错误
RECORD_TYPE_A = 1 // A记录
RECORD_TYPE_AAAA = 28 // AAAA记录
RECORD_TYPE_CNAME = 5 // CNAME记录
RECORD_TYPE_MX = 15 // MX记录
RECORD_TYPE_NS = 2 // NS记录
RECORD_TYPE_SOA = 6 // SOA记录
RECORD_TYPE_TXT = 16 // TXT记录
RECORD_TYPE_SRV = 33 // SRV记录
)
type DNSServer struct {
gorm.Model
UserID uint `gorm:"column:user_id;index" json:"user_id" form:"user_id"` // 用户ID
Name string `gorm:"column:name;type:varchar(255)" json:"name" form:"name"` // DNS服务器名称
Port uint `gorm:"column:port;default:53" json:"port" form:"port"` // 监听端口默认53
ListenIP string `gorm:"column:listen_ip;type:varchar(255)" json:"listen_ip" form:"listen_ip"` // 监听IP默认0.0.0.0
UpstreamDNS string `gorm:"column:upstream_dns;type:varchar(255)" json:"upstream_dns" form:"upstream_dns"` // 上游DNS服务器多个用逗号分隔
EnableRecursion bool `gorm:"column:enable_recursion;default:true" json:"enable_recursion" form:"enable_recursion"` // 是否启用递归查询
Status uint `gorm:"column:status;default:0" json:"status" form:"status"` // 状态0停止1运行中2错误
Description string `gorm:"column:description;type:text" json:"description" form:"description"` // 描述
Zones []DNSZone `gorm:"foreignKey:ServerID" json:"zones,omitempty"` // 关联的Zone
}
type DNSZone struct {
gorm.Model
ServerID uint `gorm:"column:server_id;index" json:"server_id" form:"server_id"` // 所属DNS服务器ID
Domain string `gorm:"column:domain;type:varchar(255);index" json:"domain" form:"domain"` // 域名,如 example.com
SOA_MName string `gorm:"column:soa_mname;type:varchar(255)" json:"soa_mname" form:"soa_mname"` // SOA记录的主域名服务器
SOA_RName string `gorm:"column:soa_rname;type:varchar(255)" json:"soa_rname" form:"soa_rname"` // SOA记录的管理员邮箱
SOA_Serial uint `gorm:"column:soa_serial;default:1" json:"soa_serial" form:"soa_serial"` // SOA记录的序列号
SOA_Refresh uint `gorm:"column:soa_refresh;default:86400" json:"soa_refresh" form:"soa_refresh"` // SOA记录的刷新时间
SOA_Retry uint `gorm:"column:soa_retry;default:7200" json:"soa_retry" form:"soa_retry"` // SOA记录的重试时间
SOA_Expire uint `gorm:"column:soa_expire;default:3600000" json:"soa_expire" form:"soa_expire"` // SOA记录的过期时间
SOA_Minimum uint `gorm:"column:soa_minimum;default:3600" json:"soa_minimum" form:"soa_minimum"` // SOA记录的最小TTL
TTL uint `gorm:"column:ttl;default:3600" json:"ttl" form:"ttl"` // 默认TTL
Description string `gorm:"column:description;type:text" json:"description" form:"description"` // 描述
Server DNSServer `gorm:"foreignKey:ServerID" json:"server,omitempty"` // 关联的DNS服务器
Records []DNSRecord `gorm:"foreignKey:ZoneID" json:"records,omitempty"` // 关联的记录
}
type DNSRecord struct {
gorm.Model
ZoneID uint `gorm:"column:zone_id;index" json:"zone_id" form:"zone_id"` // 所属Zone ID
Name string `gorm:"column:name;type:varchar(255);index" json:"name" form:"name"` // 记录名称,如 www 或 @
Type uint `gorm:"column:type;index" json:"type" form:"type"` // 记录类型1=A, 28=AAAA, 5=CNAME, 15=MX等
Value string `gorm:"column:value;type:text" json:"value" form:"value"` // 记录值
TTL uint `gorm:"column:ttl;default:3600" json:"ttl" form:"ttl"` // TTL如果为0则使用Zone的默认TTL
Priority uint `gorm:"column:priority;default:0" json:"priority" form:"priority"` // 优先级用于MX、SRV等记录
Weight uint `gorm:"column:weight;default:0" json:"weight" form:"weight"` // 权重用于SRV记录
Port uint `gorm:"column:port;default:0" json:"port" form:"port"` // 端口用于SRV记录
Target string `gorm:"column:target;type:varchar(255)" json:"target" form:"target"` // 目标用于SRV记录
Zone DNSZone `gorm:"foreignKey:ZoneID" json:"zone,omitempty"` // 关联的Zone
}
// DNSServer 创建请求
type CreateDNSServerReq struct {
Name string `json:"name" form:"name"` // DNS服务器名称
Port uint `json:"port" form:"port"` // 监听端口默认53
ListenIP string `json:"listen_ip" form:"listen_ip"` // 监听IP默认0.0.0.0
UpstreamDNS string `json:"upstream_dns" form:"upstream_dns"` // 上游DNS服务器多个用逗号分隔
EnableRecursion bool `json:"enable_recursion" form:"enable_recursion"` // 是否启用递归查询
Description string `json:"description" form:"description"` // 描述
}
// DNSServer 更新请求
type UpdateDNSServerReq struct {
ServerID uint `json:"server_id" form:"server_id"` // DNS服务器ID
Name string `json:"name" form:"name"` // DNS服务器名称
Port uint `json:"port" form:"port"` // 监听端口
ListenIP string `json:"listen_ip" form:"listen_ip"` // 监听IP
UpstreamDNS string `json:"upstream_dns" form:"upstream_dns"` // 上游DNS服务器
EnableRecursion bool `json:"enable_recursion" form:"enable_recursion"` // 是否启用递归查询
Status uint `json:"status" form:"status"` // 状态0停止1运行中2错误
Description string `json:"description" form:"description"` // 描述
}
// DNSServer 获取请求
type GetDNSServerReq struct {
ServerID uint `json:"server_id" form:"server_id"` // DNS服务器ID0表示获取全部
GetType int `json:"get_type" form:"get_type"` // 获取类型0获取自己的1获取全部管理员
}
// DNSServer 删除请求
type DeleteDNSServerReq struct {
ServerID uint `json:"server_id" form:"server_id"` // DNS服务器ID
DelType uint `json:"del_type" form:"del_type"` // 删除类型0删除单条1删除所有
}
// DNSZone 创建请求
type CreateDNSZoneReq struct {
ServerID uint `json:"server_id" form:"server_id"` // 所属DNS服务器ID
Domain string `json:"domain" form:"domain"` // 域名,如 example.com
SOA_MName string `json:"soa_mname" form:"soa_mname"` // SOA记录的主域名服务器
SOA_RName string `json:"soa_rname" form:"soa_rname"` // SOA记录的管理员邮箱
SOA_Serial uint `json:"soa_serial" form:"soa_serial"` // SOA记录的序列号
SOA_Refresh uint `json:"soa_refresh" form:"soa_refresh"` // SOA记录的刷新时间
SOA_Retry uint `json:"soa_retry" form:"soa_retry"` // SOA记录的重试时间
SOA_Expire uint `json:"soa_expire" form:"soa_expire"` // SOA记录的过期时间
SOA_Minimum uint `json:"soa_minimum" form:"soa_minimum"` // SOA记录的最小TTL
TTL uint `json:"ttl" form:"ttl"` // 默认TTL
Description string `json:"description" form:"description"` // 描述
}
// DNSZone 更新请求
type UpdateDNSZoneReq struct {
ZoneID uint `json:"zone_id" form:"zone_id"` // Zone ID
Domain string `json:"domain" form:"domain"` // 域名
SOA_MName string `json:"soa_mname" form:"soa_mname"` // SOA记录的主域名服务器
SOA_RName string `json:"soa_rname" form:"soa_rname"` // SOA记录的管理员邮箱
SOA_Serial uint `json:"soa_serial" form:"soa_serial"` // SOA记录的序列号
SOA_Refresh uint `json:"soa_refresh" form:"soa_refresh"` // SOA记录的刷新时间
SOA_Retry uint `json:"soa_retry" form:"soa_retry"` // SOA记录的重试时间
SOA_Expire uint `json:"soa_expire" form:"soa_expire"` // SOA记录的过期时间
SOA_Minimum uint `json:"soa_minimum" form:"soa_minimum"` // SOA记录的最小TTL
TTL uint `json:"ttl" form:"ttl"` // 默认TTL
Description string `json:"description" form:"description"` // 描述
}
// DNSZone 获取请求
type GetDNSZoneReq struct {
ZoneID uint `json:"zone_id" form:"zone_id"` // Zone ID0表示获取全部
ServerID uint `json:"server_id" form:"server_id"` // DNS服务器ID用于过滤
GetType int `json:"get_type" form:"get_type"` // 获取类型0获取自己的1获取全部管理员
}
// DNSZone 删除请求
type DeleteDNSZoneReq struct {
ZoneID uint `json:"zone_id" form:"zone_id"` // Zone ID
DelType uint `json:"del_type" form:"del_type"` // 删除类型0删除单条1删除所有
}
// DNSRecord 创建请求
type CreateDNSRecordReq struct {
ZoneID uint `json:"zone_id" form:"zone_id"` // 所属Zone ID
Name string `json:"name" form:"name"` // 记录名称,如 www 或 @
Type uint `json:"type" form:"type"` // 记录类型1=A, 28=AAAA, 5=CNAME, 15=MX等
Value string `json:"value" form:"value"` // 记录值
TTL uint `json:"ttl" form:"ttl"` // TTL
Priority uint `json:"priority" form:"priority"` // 优先级用于MX、SRV等记录
Weight uint `json:"weight" form:"weight"` // 权重用于SRV记录
Port uint `json:"port" form:"port"` // 端口用于SRV记录
Target string `json:"target" form:"target"` // 目标用于SRV记录
}
// DNSRecord 更新请求
type UpdateDNSRecordReq struct {
RecordID uint `json:"record_id" form:"record_id"` // 记录ID
Name string `json:"name" form:"name"` // 记录名称
Type uint `json:"type" form:"type"` // 记录类型
Value string `json:"value" form:"value"` // 记录值
TTL uint `json:"ttl" form:"ttl"` // TTL
Priority uint `json:"priority" form:"priority"` // 优先级
Weight uint `json:"weight" form:"weight"` // 权重
Port uint `json:"port" form:"port"` // 端口
Target string `json:"target" form:"target"` // 目标
}
// DNSRecord 获取请求
type GetDNSRecordReq struct {
RecordID uint `json:"record_id" form:"record_id"` // 记录ID0表示获取全部
ZoneID uint `json:"zone_id" form:"zone_id"` // Zone ID用于过滤
GetType int `json:"get_type" form:"get_type"` // 获取类型0获取自己的1获取全部管理员
}
// DNSRecord 删除请求
type DeleteDNSRecordReq struct {
RecordID uint `json:"record_id" form:"record_id"` // 记录ID
DelType uint `json:"del_type" form:"del_type"` // 删除类型0删除单条1删除所有
}
// 启动DNS服务器请求
type StartDNSServerReq struct {
ServerID uint `json:"server_id" form:"server_id" binding:"required"` // DNS服务器ID
}
// 停止DNS服务器请求
type StopDNSServerReq struct {
ServerID uint `json:"server_id" form:"server_id" binding:"required"` // DNS服务器ID
}
// 重启DNS服务器请求
type RestartDNSServerReq struct {
ServerID uint `json:"server_id" form:"server_id" binding:"required"` // DNS服务器ID
}
// 获取DNS服务器状态请求
type GetDNSServerStatusReq struct {
ServerID uint `json:"server_id" form:"server_id" binding:"required"` // DNS服务器ID
}

786
service/dnsService.go Normal file
View File

@ -0,0 +1,786 @@
package service
import (
"errors"
"fmt"
"net"
"sync"
"videoplayer/dao"
"videoplayer/proto"
"github.com/miekg/dns"
)
// DNSServiceInstance 运行中的DNS服务实例
type DNSServiceInstance struct {
ServerID uint `json:"server_id"`
Config *proto.DNSServer `json:"config"`
Server *dns.Server `json:"-"`
Running bool `json:"running"`
mutex sync.Mutex `json:"-"`
}
// DNSServiceManager DNS服务管理器
type DNSServiceManager struct {
instances map[uint]*DNSServiceInstance
rwMutex sync.RWMutex
}
var dnsServiceManager *DNSServiceManager
func init() {
dnsServiceManager = &DNSServiceManager{
instances: make(map[uint]*DNSServiceInstance),
}
}
// ==================== DNSServer 相关操作 ====================
func CreateDNSServer(req *proto.CreateDNSServerReq, userID uint) (proto.DNSServer, error) {
server := proto.DNSServer{
UserID: userID,
Name: req.Name,
Port: req.Port,
ListenIP: req.ListenIP,
UpstreamDNS: req.UpstreamDNS,
EnableRecursion: req.EnableRecursion,
Status: proto.DNS_STATUS_STOPPED,
Description: req.Description,
}
if server.Port == 0 {
server.Port = 53
}
if server.ListenIP == "" {
server.ListenIP = "0.0.0.0"
}
id, err := dao.CreateDNSServer(server)
if err != nil {
return proto.DNSServer{}, err
}
server.ID = id
return server, nil
}
func GetDNSServerList(req *proto.GetDNSServerReq, userID uint) ([]proto.DNSServer, error) {
var servers []proto.DNSServer
var err error
if req.ServerID > 0 {
server, err := dao.FindDNSServerByID(req.ServerID)
if err != nil {
return nil, err
}
if server.UserID != userID && GetUserByIDFromUserCenter(int(userID)).Role != "admin" {
return nil, errors.New("未授权访问DNS服务器")
}
servers = append(servers, server)
} else {
if req.GetType == 0 {
servers, err = dao.FindDNSServerByUserID(userID)
} else if req.GetType == 1 {
user := GetUserByIDFromUserCenter(int(userID))
if user.Role != "admin" {
return nil, errors.New("未授权访问仅管理员可获取全部DNS服务器")
}
servers, err = dao.FindAllDNSServer()
} else {
return nil, errors.New("无效的获取类型")
}
}
if err != nil {
return nil, err
}
return servers, nil
}
func UpdateDNSServer(req *proto.UpdateDNSServerReq, userID int) (proto.DNSServer, error) {
server, err := dao.FindDNSServerByID(req.ServerID)
if err != nil {
return proto.DNSServer{}, err
}
if server.UserID != uint(userID) && GetUserByIDFromUserCenter(userID).Role != "admin" {
return proto.DNSServer{}, errors.New("未授权访问DNS服务器")
}
server.Name = req.Name
server.Port = req.Port
server.ListenIP = req.ListenIP
server.UpstreamDNS = req.UpstreamDNS
server.EnableRecursion = req.EnableRecursion
server.Status = req.Status
server.Description = req.Description
err = dao.UpdateDNSServer(server.ID, &server)
if err != nil {
return proto.DNSServer{}, err
}
// 如果服务正在运行,自动重启以应用新配置
go RestartDNSServerIfRunning(req.ServerID, userID)
return server, nil
}
func DeleteDNSServer(req *proto.DeleteDNSServerReq, userID int) error {
user := GetUserByIDFromUserCenter(userID)
if req.DelType == 0 && req.ServerID > 0 {
server, err := dao.FindDNSServerByID(req.ServerID)
if err != nil {
return err
}
if server.UserID != uint(userID) && user.Role != "admin" {
return errors.New("未授权访问DNS服务器")
}
err = dao.DeleteDNSZoneByServerID(req.ServerID)
if err != nil {
return err
}
err = dao.DeleteDNSServerByID(req.ServerID)
if err != nil {
return err
}
} else if req.DelType == 1 {
if user.Role != "admin" {
return errors.New("未授权访问仅管理员可删除所有DNS服务器")
}
servers, err := dao.FindAllDNSServer()
if err != nil {
return err
}
for _, server := range servers {
err = dao.DeleteDNSZoneByServerID(server.ID)
if err != nil {
return err
}
err = dao.DeleteDNSServerByID(server.ID)
if err != nil {
return err
}
}
} else {
return errors.New("无效的删除类型或参数")
}
return nil
}
// ==================== DNSZone 相关操作 ====================
func CreateDNSZone(req *proto.CreateDNSZoneReq, userID uint) (proto.DNSZone, error) {
server, err := dao.FindDNSServerByID(req.ServerID)
if err != nil {
return proto.DNSZone{}, err
}
if server.UserID != userID && GetUserByIDFromUserCenter(int(userID)).Role != "admin" {
return proto.DNSZone{}, errors.New("未授权访问DNS服务器")
}
zone := proto.DNSZone{
ServerID: req.ServerID,
Domain: req.Domain,
SOA_MName: req.SOA_MName,
SOA_RName: req.SOA_RName,
SOA_Serial: req.SOA_Serial,
SOA_Refresh: req.SOA_Refresh,
SOA_Retry: req.SOA_Retry,
SOA_Expire: req.SOA_Expire,
SOA_Minimum: req.SOA_Minimum,
TTL: req.TTL,
Description: req.Description,
}
if zone.SOA_Serial == 0 {
zone.SOA_Serial = 1
}
if zone.SOA_Refresh == 0 {
zone.SOA_Refresh = 86400
}
if zone.SOA_Retry == 0 {
zone.SOA_Retry = 7200
}
if zone.SOA_Expire == 0 {
zone.SOA_Expire = 3600000
}
if zone.SOA_Minimum == 0 {
zone.SOA_Minimum = 3600
}
if zone.TTL == 0 {
zone.TTL = 3600
}
id, err := dao.CreateDNSZone(zone)
if err != nil {
return proto.DNSZone{}, err
}
zone.ID = id
return zone, nil
}
func GetDNSZoneList(req *proto.GetDNSZoneReq, userID uint) ([]proto.DNSZone, error) {
var zones []proto.DNSZone
var err error
if req.ZoneID > 0 {
zone, err := dao.FindDNSZoneByID(req.ZoneID)
if err != nil {
return nil, err
}
server, err := dao.FindDNSServerByID(zone.ServerID)
if err != nil {
return nil, err
}
if server.UserID != userID && GetUserByIDFromUserCenter(int(userID)).Role != "admin" {
return nil, errors.New("未授权访问DNS区域")
}
zones = append(zones, zone)
} else {
if req.GetType == 0 {
if req.ServerID > 0 {
zones, err = dao.FindDNSZoneByServerID(req.ServerID)
} else {
servers, err := dao.FindDNSServerByUserID(userID)
if err != nil {
return nil, err
}
for _, server := range servers {
serverZones, err := dao.FindDNSZoneByServerID(server.ID)
if err != nil {
return nil, err
}
zones = append(zones, serverZones...)
}
}
} else if req.GetType == 1 {
user := GetUserByIDFromUserCenter(int(userID))
if user.Role != "admin" {
return nil, errors.New("未授权访问仅管理员可获取全部DNS区域")
}
if req.ServerID > 0 {
zones, err = dao.FindDNSZoneByServerID(req.ServerID)
} else {
zones, err = dao.FindAllDNSZone()
}
} else {
return nil, errors.New("无效的获取类型")
}
}
if err != nil {
return nil, err
}
return zones, nil
}
func UpdateDNSZone(req *proto.UpdateDNSZoneReq, userID int) (proto.DNSZone, error) {
zone, err := dao.FindDNSZoneByID(req.ZoneID)
if err != nil {
return proto.DNSZone{}, err
}
server, err := dao.FindDNSServerByID(zone.ServerID)
if err != nil {
return proto.DNSZone{}, err
}
if server.UserID != uint(userID) && GetUserByIDFromUserCenter(userID).Role != "admin" {
return proto.DNSZone{}, errors.New("未授权访问DNS区域")
}
zone.Domain = req.Domain
zone.SOA_MName = req.SOA_MName
zone.SOA_RName = req.SOA_RName
zone.SOA_Serial = req.SOA_Serial
zone.SOA_Refresh = req.SOA_Refresh
zone.SOA_Retry = req.SOA_Retry
zone.SOA_Expire = req.SOA_Expire
zone.SOA_Minimum = req.SOA_Minimum
zone.TTL = req.TTL
zone.Description = req.Description
err = dao.UpdateDNSZone(zone.ID, &zone)
if err != nil {
return proto.DNSZone{}, err
}
return zone, nil
}
func DeleteDNSZone(req *proto.DeleteDNSZoneReq, userID int) error {
user := GetUserByIDFromUserCenter(userID)
if req.DelType == 0 && req.ZoneID > 0 {
zone, err := dao.FindDNSZoneByID(req.ZoneID)
if err != nil {
return err
}
server, err := dao.FindDNSServerByID(zone.ServerID)
if err != nil {
return err
}
if server.UserID != uint(userID) && user.Role != "admin" {
return errors.New("未授权访问DNS区域")
}
err = dao.DeleteDNSRecordByZoneID(req.ZoneID)
if err != nil {
return err
}
err = dao.DeleteDNSZoneByID(req.ZoneID)
if err != nil {
return err
}
} else if req.DelType == 1 {
if user.Role != "admin" {
return errors.New("未授权访问仅管理员可删除所有DNS区域")
}
zones, err := dao.FindAllDNSZone()
if err != nil {
return err
}
for _, zone := range zones {
err = dao.DeleteDNSRecordByZoneID(zone.ID)
if err != nil {
return err
}
err = dao.DeleteDNSZoneByID(zone.ID)
if err != nil {
return err
}
}
} else {
return errors.New("无效的删除类型或参数")
}
return nil
}
// ==================== DNSRecord 相关操作 ====================
func CreateDNSRecord(req *proto.CreateDNSRecordReq, userID uint) (proto.DNSRecord, error) {
zone, err := dao.FindDNSZoneByID(req.ZoneID)
if err != nil {
return proto.DNSRecord{}, err
}
server, err := dao.FindDNSServerByID(zone.ServerID)
if err != nil {
return proto.DNSRecord{}, err
}
if server.UserID != userID && GetUserByIDFromUserCenter(int(userID)).Role != "admin" {
return proto.DNSRecord{}, errors.New("未授权访问DNS区域")
}
record := proto.DNSRecord{
ZoneID: req.ZoneID,
Name: req.Name,
Type: req.Type,
Value: req.Value,
TTL: req.TTL,
Priority: req.Priority,
Weight: req.Weight,
Port: req.Port,
Target: req.Target,
}
if record.TTL == 0 {
record.TTL = zone.TTL
}
id, err := dao.CreateDNSRecord(record)
if err != nil {
return proto.DNSRecord{}, err
}
record.ID = id
return record, nil
}
func GetDNSRecordList(req *proto.GetDNSRecordReq, userID uint) ([]proto.DNSRecord, error) {
var records []proto.DNSRecord
var err error
if req.RecordID > 0 {
record, err := dao.FindDNSRecordByID(req.RecordID)
if err != nil {
return nil, err
}
zone, err := dao.FindDNSZoneByID(record.ZoneID)
if err != nil {
return nil, err
}
server, err := dao.FindDNSServerByID(zone.ServerID)
if err != nil {
return nil, err
}
if server.UserID != userID && GetUserByIDFromUserCenter(int(userID)).Role != "admin" {
return nil, errors.New("未授权访问DNS记录")
}
records = append(records, record)
} else {
if req.GetType == 0 {
if req.ZoneID > 0 {
records, err = dao.FindDNSRecordByZoneID(req.ZoneID)
} else {
servers, err := dao.FindDNSServerByUserID(userID)
if err != nil {
return nil, err
}
for _, server := range servers {
zones, err := dao.FindDNSZoneByServerID(server.ID)
if err != nil {
return nil, err
}
for _, zone := range zones {
zoneRecords, err := dao.FindDNSRecordByZoneID(zone.ID)
if err != nil {
return nil, err
}
records = append(records, zoneRecords...)
}
}
}
} else if req.GetType == 1 {
user := GetUserByIDFromUserCenter(int(userID))
if user.Role != "admin" {
return nil, errors.New("未授权访问仅管理员可获取全部DNS记录")
}
if req.ZoneID > 0 {
records, err = dao.FindDNSRecordByZoneID(req.ZoneID)
} else {
records, err = dao.FindAllDNSRecord()
}
} else {
return nil, errors.New("无效的获取类型")
}
}
if err != nil {
return nil, err
}
return records, nil
}
func UpdateDNSRecord(req *proto.UpdateDNSRecordReq, userID int) (proto.DNSRecord, error) {
record, err := dao.FindDNSRecordByID(req.RecordID)
if err != nil {
return proto.DNSRecord{}, err
}
zone, err := dao.FindDNSZoneByID(record.ZoneID)
if err != nil {
return proto.DNSRecord{}, err
}
server, err := dao.FindDNSServerByID(zone.ServerID)
if err != nil {
return proto.DNSRecord{}, err
}
if server.UserID != uint(userID) && GetUserByIDFromUserCenter(userID).Role != "admin" {
return proto.DNSRecord{}, errors.New("未授权访问DNS记录")
}
record.Name = req.Name
record.Type = req.Type
record.Value = req.Value
record.TTL = req.TTL
record.Priority = req.Priority
record.Weight = req.Weight
record.Port = req.Port
record.Target = req.Target
err = dao.UpdateDNSRecord(record.ID, &record)
if err != nil {
return proto.DNSRecord{}, err
}
return record, nil
}
func DeleteDNSRecord(req *proto.DeleteDNSRecordReq, userID int) error {
user := GetUserByIDFromUserCenter(userID)
if req.DelType == 0 && req.RecordID > 0 {
record, err := dao.FindDNSRecordByID(req.RecordID)
if err != nil {
return err
}
zone, err := dao.FindDNSZoneByID(record.ZoneID)
if err != nil {
return err
}
server, err := dao.FindDNSServerByID(zone.ServerID)
if err != nil {
return err
}
if server.UserID != uint(userID) && user.Role != "admin" {
return errors.New("未授权访问DNS记录")
}
err = dao.DeleteDNSRecordByID(req.RecordID)
if err != nil {
return err
}
} else if req.DelType == 1 {
if user.Role != "admin" {
return errors.New("未授权访问仅管理员可删除所有DNS记录")
}
records, err := dao.FindAllDNSRecord()
if err != nil {
return err
}
for _, record := range records {
err = dao.DeleteDNSRecordByID(record.ID)
if err != nil {
return err
}
}
} else {
return errors.New("无效的删除类型或参数")
}
return nil
}
// ==================== DNS 服务运行管理 ====================
// handleDNSRequest 处理DNS查询请求
func (instance *DNSServiceInstance) handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
m := new(dns.Msg)
m.SetReply(r)
m.Authoritative = true
for _, q := range r.Question {
// 查找对应的Zone
zones, err := dao.FindDNSZoneByServerID(instance.ServerID)
if err != nil {
continue
}
var matchedZone *proto.DNSZone
var qName string = dns.Fqdn(q.Name)
for _, zone := range zones {
zoneFqdn := dns.Fqdn(zone.Domain)
if dns.IsSubDomain(zoneFqdn, qName) {
matchedZone = &zone
break
}
}
if matchedZone == nil {
// 递归查询
if instance.Config.EnableRecursion {
c := new(dns.Client)
upstreams := instance.Config.UpstreamDNS
if upstreams == "" {
upstreams = "8.8.8.8:53"
}
resp, _, err := c.Exchange(r, upstreams)
if err == nil {
m.Answer = append(m.Answer, resp.Answer...)
}
}
continue
}
// 查找匹配的记录
records, err := dao.FindDNSRecordByZoneID(matchedZone.ID)
if err != nil {
continue
}
for _, record := range records {
recordName := dns.Fqdn(record.Name + "." + matchedZone.Domain)
if record.Name == "@" {
recordName = dns.Fqdn(matchedZone.Domain)
}
if recordName == qName && record.Type == uint(q.Qtype) {
var rr dns.RR
var ttl uint32
if record.TTL > 0 {
ttl = uint32(record.TTL)
} else {
ttl = uint32(matchedZone.TTL)
}
switch q.Qtype {
case dns.TypeA:
rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN A %s", q.Name, ttl, record.Value))
case dns.TypeAAAA:
rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN AAAA %s", q.Name, ttl, record.Value))
case dns.TypeCNAME:
rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN CNAME %s", q.Name, ttl, record.Value))
case dns.TypeMX:
rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN MX %d %s", q.Name, ttl, record.Priority, record.Value))
case dns.TypeNS:
rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN NS %s", q.Name, ttl, record.Value))
case dns.TypeTXT:
rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN TXT \"%s\"", q.Name, ttl, record.Value))
case dns.TypeSRV:
rr, _ = dns.NewRR(fmt.Sprintf("%s %d IN SRV %d %d %d %s", q.Name, ttl, record.Priority, record.Weight, record.Port, record.Target))
}
if rr != nil {
m.Answer = append(m.Answer, rr)
}
}
}
}
w.WriteMsg(m)
}
// StartDNSServer 启动DNS服务
func StartDNSServer(serverID uint, userID int) (*DNSServiceInstance, error) {
// 检查权限
server, err := dao.FindDNSServerByID(serverID)
if err != nil {
return nil, err
}
if server.UserID != uint(userID) && GetUserByIDFromUserCenter(userID).Role != "admin" {
return nil, errors.New("未授权访问DNS服务器")
}
dnsServiceManager.rwMutex.Lock()
defer dnsServiceManager.rwMutex.Unlock()
// 检查是否已经在运行
if instance, exists := dnsServiceManager.instances[serverID]; exists && instance.Running {
return instance, nil
}
// 创建服务实例
instance := &DNSServiceInstance{
ServerID: serverID,
Config: &server,
Running: false,
}
// 创建DNS服务器
dns.HandleFunc(".", instance.handleDNSRequest)
addr := fmt.Sprintf("%s:%d", server.ListenIP, server.Port)
udpAddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
udpConn, err := net.ListenUDP("udp", udpAddr)
if err != nil {
return nil, err
}
tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
udpConn.Close()
return nil, err
}
tcpListener, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
udpConn.Close()
return nil, err
}
instance.Server = &dns.Server{
Listener: tcpListener,
PacketConn: udpConn,
}
// 启动服务
go func() {
instance.mutex.Lock()
instance.Running = true
instance.mutex.Unlock()
err := instance.Server.ActivateAndServe()
if err != nil {
instance.mutex.Lock()
instance.Running = false
instance.mutex.Unlock()
}
}()
// 更新数据库状态
server.Status = proto.DNS_STATUS_RUNNING
dao.UpdateDNSServer(serverID, &server)
dnsServiceManager.instances[serverID] = instance
return instance, nil
}
// StopDNSServer 停止DNS服务
func StopDNSServer(serverID uint, userID int) error {
server, err := dao.FindDNSServerByID(serverID)
if err != nil {
return err
}
if server.UserID != uint(userID) && GetUserByIDFromUserCenter(userID).Role != "admin" {
return errors.New("未授权访问DNS服务器")
}
dnsServiceManager.rwMutex.Lock()
defer dnsServiceManager.rwMutex.Unlock()
instance, exists := dnsServiceManager.instances[serverID]
if !exists || !instance.Running {
return nil
}
// 停止服务
err = instance.Server.Shutdown()
if err != nil {
return err
}
instance.mutex.Lock()
instance.Running = false
instance.mutex.Unlock()
// 更新数据库状态
server.Status = proto.DNS_STATUS_STOPPED
dao.UpdateDNSServer(serverID, &server)
delete(dnsServiceManager.instances, serverID)
return nil
}
// RestartDNSServer 重启DNS服务
func RestartDNSServer(serverID uint, userID int) (*DNSServiceInstance, error) {
err := StopDNSServer(serverID, userID)
if err != nil {
return nil, err
}
return StartDNSServer(serverID, userID)
}
// GetDNSServerStatus 获取DNS服务运行状态
func GetDNSServerStatus(serverID uint, userID int) (*DNSServiceInstance, error) {
server, err := dao.FindDNSServerByID(serverID)
if err != nil {
return nil, err
}
if server.UserID != uint(userID) && GetUserByIDFromUserCenter(userID).Role != "admin" {
return nil, errors.New("未授权访问DNS服务器")
}
dnsServiceManager.rwMutex.RLock()
defer dnsServiceManager.rwMutex.RUnlock()
instance, exists := dnsServiceManager.instances[serverID]
if exists {
return instance, nil
}
// 不在运行中,返回配置中的状态
return &DNSServiceInstance{
ServerID: serverID,
Config: &server,
Running: server.Status == proto.DNS_STATUS_RUNNING,
}, nil
}
// RestartDNSServerIfRunning 如果服务正在运行则重启(配置更新时调用)
func RestartDNSServerIfRunning(serverID uint, userID int) error {
dnsServiceManager.rwMutex.RLock()
instance, exists := dnsServiceManager.instances[serverID]
dnsServiceManager.rwMutex.RUnlock()
if exists && instance.Running {
// 获取最新配置
server, err := dao.FindDNSServerByID(serverID)
if err != nil {
return err
}
// 重启服务(管理员权限)
_, err = RestartDNSServer(server.ID, userID) // 假设管理员ID为1
return err
}
return nil
}

View File

@ -1,7 +1,6 @@
package service package service
import ( import (
"bytes"
"errors" "errors"
"log" "log"
"os/exec" "os/exec"