update match domain to list

controllers/dns.go

@@ -95,17 +95,21 @@ func createNs(w http.ResponseWriter, r *http.Request) {
 			"*": struct{}{},
 		}
 	}
+	if req.MatchAll {
+		req.MatchDomains = []string{"."}
+	}
 	ns := schema.Nameserver{
-		ID:          uuid.New().String(),
-		Name:        req.Name,
-		NetworkID:   req.NetworkID,
-		Description: req.Description,
-		MatchDomain: req.MatchDomain,
-		Servers:     req.Servers,
-		Tags:        req.Tags,
-		Status:      true,
-		CreatedBy:   r.Header.Get("user"),
-		CreatedAt:   time.Now().UTC(),
+		ID:           uuid.New().String(),
+		Name:         req.Name,
+		NetworkID:    req.NetworkID,
+		Description:  req.Description,
+		MatchAll:     req.MatchAll,
+		MatchDomains: req.MatchDomains,
+		Servers:      req.Servers,
+		Tags:         req.Tags,
+		Status:       true,
+		CreatedBy:    r.Header.Get("user"),
+		CreatedAt:    time.Now().UTC(),
 	}
 
 	err = ns.Create(db.WithContext(r.Context()))
@@ -187,7 +191,7 @@ func updateNs(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if err := logic.ValidateUpdateNameserverReq(updateNs); err != nil {
+	if err := logic.ValidateNameserverReq(updateNs); err != nil {
 		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
 		return
 	}
@@ -202,9 +206,13 @@ func updateNs(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	var updateStatus bool
+	var updateMatchAll bool
 	if updateNs.Status != ns.Status {
 		updateStatus = true
 	}
+	if updateNs.MatchAll != ns.MatchAll {
+		updateMatchAll = true
+	}
 	event := &models.Event{
 		Action: models.Update,
 		Source: models.Subject{
@@ -227,7 +235,8 @@ func updateNs(w http.ResponseWriter, r *http.Request) {
 	}
 	ns.Servers = updateNs.Servers
 	ns.Tags = updateNs.Tags
-	ns.MatchDomain = updateNs.MatchDomain
+	ns.MatchDomains = updateNs.MatchDomains
+	ns.MatchAll = updateNs.MatchAll
 	ns.Description = updateNs.Description
 	ns.Name = updateNs.Name
 	ns.Status = updateNs.Status
@@ -245,6 +254,9 @@ func updateNs(w http.ResponseWriter, r *http.Request) {
 	if updateStatus {
 		ns.UpdateStatus(db.WithContext(context.TODO()))
 	}
+	if updateMatchAll {
+		ns.UpdateMatchAll(db.WithContext(context.TODO()))
+	}
 	logic.LogEvent(event)
 	go mq.PublishPeerUpdate(false)
 	logic.ReturnSuccessResponseWithJson(w, r, ns, "updated nameserver")

logic/dns.go

@@ -375,22 +375,17 @@ func ValidateNameserverReq(ns schema.Nameserver) error {
 	if len(ns.Servers) == 0 {
 		return errors.New("atleast one nameserver should be specified")
 	}
-	if !IsValidMatchDomain(ns.MatchDomain) {
-		return errors.New("invalid match domain")
+	if !ns.MatchAll && len(ns.MatchDomains) == 0 {
+		return errors.New("atleast one match domain is required")
 	}
-	return nil
-}
-
-func ValidateUpdateNameserverReq(updateNs schema.Nameserver) error {
-	if updateNs.Name == "" {
-		return errors.New("name is required")
-	}
-	if len(updateNs.Servers) == 0 {
-		return errors.New("atleast one nameserver should be specified")
-	}
-	if !IsValidMatchDomain(updateNs.MatchDomain) {
-		return errors.New("invalid match domain")
+	if !ns.MatchAll {
+		for _, matchDomain := range ns.MatchDomains {
+			if !IsValidMatchDomain(matchDomain) {
+				return errors.New("invalid match domain")
+			}
+		}
 	}
+
 	return nil
 }
 
@@ -405,18 +400,22 @@ func GetNameserversForNode(node *models.Node) (returnNsLi []models.Nameserver) {
 		}
 		_, all := nsI.Tags["*"]
 		if all {
-			returnNsLi = append(returnNsLi, models.Nameserver{
-				IPs:         nsI.Servers,
-				MatchDomain: nsI.MatchDomain,
-			})
+			for _, matchDomain := range nsI.MatchDomains {
+				returnNsLi = append(returnNsLi, models.Nameserver{
+					IPs:         nsI.Servers,
+					MatchDomain: matchDomain,
+				})
+			}
 			continue
 		}
 		for tagI := range node.Tags {
 			if _, ok := nsI.Tags[tagI.String()]; ok {
-				returnNsLi = append(returnNsLi, models.Nameserver{
-					IPs:         nsI.Servers,
-					MatchDomain: nsI.MatchDomain,
-				})
+				for _, matchDomain := range nsI.MatchDomains {
+					returnNsLi = append(returnNsLi, models.Nameserver{
+						IPs:         nsI.Servers,
+						MatchDomain: matchDomain,
+					})
+				}
 			}
 		}
 	}
@@ -451,18 +450,23 @@ func GetNameserversForHost(h *models.Host) (returnNsLi []models.Nameserver) {
 			}
 			_, all := nsI.Tags["*"]
 			if all {
-				returnNsLi = append(returnNsLi, models.Nameserver{
-					IPs:         nsI.Servers,
-					MatchDomain: nsI.MatchDomain,
-				})
+				for _, matchDomain := range nsI.MatchDomains {
+					returnNsLi = append(returnNsLi, models.Nameserver{
+						IPs:         nsI.Servers,
+						MatchDomain: matchDomain,
+					})
+				}
 				continue
 			}
 			for tagI := range node.Tags {
 				if _, ok := nsI.Tags[tagI.String()]; ok {
-					returnNsLi = append(returnNsLi, models.Nameserver{
-						IPs:         nsI.Servers,
-						MatchDomain: nsI.MatchDomain,
-					})
+					for _, matchDomain := range nsI.MatchDomains {
+						returnNsLi = append(returnNsLi, models.Nameserver{
+							IPs:         nsI.Servers,
+							MatchDomain: matchDomain,
+						})
+					}
+
 				}
 			}
 		}

migrate/migrate.go

@@ -37,9 +37,35 @@ func Run() {
 	updateAcls()
 	logic.MigrateToGws()
 	migrateToEgressV1()
+	migrateNameservers()
 	resync()
 }
 
+func migrateNameservers() {
+	nets, _ := logic.GetNetworks()
+	for _, netI := range nets {
+		if len(netI.NameServers) > 0 {
+			ns := schema.Nameserver{
+				ID:           uuid.NewString(),
+				Name:         "upstream nameservers",
+				NetworkID:    netI.NetID,
+				Servers:      []string{},
+				MatchAll:     true,
+				MatchDomains: []string{"."},
+				Tags: datatypes.JSONMap{
+					"*": struct{}{},
+				},
+				Status:    true,
+				CreatedBy: "auto",
+			}
+			for _, ip := range netI.NameServers {
+				ns.Servers = append(ns.Servers, ip)
+			}
+			ns.Create(db.WithContext(context.TODO()))
+		}
+	}
+}
+
 // removes if any stale configurations from previous run.
 func resync() {
 

pro/logic/dns.go

@@ -18,8 +18,15 @@ func ValidateNameserverReq(ns schema.Nameserver) error {
 	if len(ns.Servers) == 0 {
 		return errors.New("atleast one nameserver should be specified")
 	}
-	if !logic.IsValidMatchDomain(ns.MatchDomain) {
-		return errors.New("invalid match domain")
+	if !ns.MatchAll && len(ns.MatchDomains) == 0 {
+		return errors.New("atleast one match domain is required")
+	}
+	if !ns.MatchAll {
+		for _, matchDomain := range ns.MatchDomains {
+			if !logic.IsValidMatchDomain(matchDomain) {
+				return errors.New("invalid match domain")
+			}
+		}
 	}
 	if len(ns.Tags) > 0 {
 		for tagI := range ns.Tags {

schema/dns.go

@@ -9,17 +9,18 @@ import (
 )
 
 type Nameserver struct {
-	ID          string                      `gorm:"primaryKey" json:"id"`
-	Name        string                      `gorm:"name" json:"name"`
-	NetworkID   string                      `gorm:"network_id" json:"network_id"`
-	Description string                      `gorm:"description" json:"description"`
-	Servers     datatypes.JSONSlice[string] `gorm:"servers" json:"servers"`
-	MatchDomain string                      `gorm:"match_domain" json:"match_domain"`
-	Tags        datatypes.JSONMap           `gorm:"tags" json:"tags"`
-	Status      bool                        `gorm:"status" json:"status"`
-	CreatedBy   string                      `gorm:"created_by" json:"created_by"`
-	CreatedAt   time.Time                   `gorm:"created_at" json:"created_at"`
-	UpdatedAt   time.Time                   `gorm:"updated_at" json:"updated_at"`
+	ID           string                      `gorm:"primaryKey" json:"id"`
+	Name         string                      `gorm:"name" json:"name"`
+	NetworkID    string                      `gorm:"network_id" json:"network_id"`
+	Description  string                      `gorm:"description" json:"description"`
+	Servers      datatypes.JSONSlice[string] `gorm:"servers" json:"servers"`
+	MatchAll     bool                        `gorm:"match_all" json:"match_all"`
+	MatchDomains datatypes.JSONSlice[string] `gorm:"match_domains" json:"match_domains"`
+	Tags         datatypes.JSONMap           `gorm:"tags" json:"tags"`
+	Status       bool                        `gorm:"status" json:"status"`
+	CreatedBy    string                      `gorm:"created_by" json:"created_by"`
+	CreatedAt    time.Time                   `gorm:"created_at" json:"created_at"`
+	UpdatedAt    time.Time                   `gorm:"updated_at" json:"updated_at"`
 }
 
 func (ns *Nameserver) Get(ctx context.Context) error {
@@ -48,3 +49,9 @@ func (ns *Nameserver) UpdateStatus(ctx context.Context) error {
 		"status": ns.Status,
 	}).Error
 }
+
+func (ns *Nameserver) UpdateMatchAll(ctx context.Context) error {
+	return db.FromContext(ctx).Model(&Nameserver{}).Where("id = ?", ns.ID).Updates(map[string]any{
+		"match_all": ns.MatchAll,
+	}).Error
+}