support tags system on ext clients

controllers/tags.go

@@ -106,8 +106,19 @@ func createTag(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	go func() {
-		for _, nodeID := range req.TaggedNodes {
-			node, err := logic.GetNodeByID(nodeID)
+		for _, node := range req.TaggedNodes {
+			if node.IsStatic {
+				extclient, err := logic.GetExtClient(node.StaticNode.ClientID, node.StaticNode.Network)
+				if err == nil && extclient.RemoteAccessClientID == "" {
+					if extclient.Tags == nil {
+						extclient.Tags = make(map[models.TagID]struct{})
+					}
+					extclient.Tags[tag.ID] = struct{}{}
+					logic.SaveExtClient(&extclient)
+				}
+				continue
+			}
+			node, err := logic.GetNodeByID(node.ID)
 			if err != nil {
 				continue
 			}

logic/nodes.go

@@ -727,11 +727,31 @@ func GetTagMapWithNodes(netID models.NetworkID) (tagNodesMap map[models.TagID][]
 			tagNodesMap[nodeTagID] = append(tagNodesMap[nodeTagID], nodeI)
 		}
 	}
-	return
+	return AddTagMapWithStaticNodes(netID, tagNodesMap)
+}
+
+func AddTagMapWithStaticNodes(netID models.NetworkID,
+	tagNodesMap map[models.TagID][]models.Node) map[models.TagID][]models.Node {
+	extclients, err := GetNetworkExtClients(netID.String())
+	if err != nil {
+		return tagNodesMap
+	}
+	for _, extclient := range extclients {
+		if extclient.Tags == nil || extclient.RemoteAccessClientID != "" {
+			continue
+		}
+		for tagID := range extclient.Tags {
+			tagNodesMap[tagID] = append(tagNodesMap[tagID], models.Node{
+				IsStatic:   true,
+				StaticNode: extclient,
+			})
+		}
+
+	}
+	return tagNodesMap
 }
 
 func GetNodesWithTag(tagID models.TagID) map[string]models.Node {
-
 	nMap := make(map[string]models.Node)
 	tag, err := GetTag(tagID)
 	if err != nil {
@@ -746,5 +766,41 @@ func GetNodesWithTag(tagID models.TagID) map[string]models.Node {
 			nMap[nodeI.ID.String()] = nodeI
 		}
 	}
+	return AddStaticNodesWithTag(tag, nMap)
+}
+
+func AddStaticNodesWithTag(tag models.Tag, nMap map[string]models.Node) map[string]models.Node {
+	extclients, err := GetNetworkExtClients(tag.Network.String())
+	if err != nil {
+		return nMap
+	}
+	for _, extclient := range extclients {
+		if extclient.RemoteAccessClientID != "" {
+			continue
+		}
+		nMap[extclient.ClientID] = models.Node{
+			IsStatic:   true,
+			StaticNode: extclient,
+		}
+	}
+	return nMap
+}
+
+func GetStaticNodeWithTag(tagID models.TagID) map[string]models.Node {
+	nMap := make(map[string]models.Node)
+	tag, err := GetTag(tagID)
+	if err != nil {
+		return nMap
+	}
+	extclients, err := GetNetworkExtClients(tag.Network.String())
+	if err != nil {
+		return nMap
+	}
+	for _, extclient := range extclients {
+		nMap[extclient.ClientID] = models.Node{
+			IsStatic:   true,
+			StaticNode: extclient,
+		}
+	}
 	return nMap
 }

logic/tags.go

@@ -80,7 +80,7 @@ func ListTagsWithNodes(netID models.NetworkID) ([]models.TagListResp, error) {
 		tagRespI := models.TagListResp{
 			Tag:         tagI,
 			UsedByCnt:   len(tagsNodeMap[tagI.ID]),
-			TaggedNodes: tagsNodeMap[tagI.ID],
+			TaggedNodes: GetAllNodesAPI(tagsNodeMap[tagI.ID]),
 		}
 		resp = append(resp, tagRespI)
 	}
@@ -134,48 +134,93 @@ func ListNetworkTags(netID models.NetworkID) ([]models.Tag, error) {
 func UpdateTag(req models.UpdateTagReq, newID models.TagID) {
 	tagMutex.Lock()
 	defer tagMutex.Unlock()
+	var err error
 	tagNodesMap := GetNodesWithTag(req.ID)
-	for _, nodeID := range req.TaggedNodes {
-		node, err := GetNodeByID(nodeID)
+	for _, apiNode := range req.TaggedNodes {
+		node := models.Node{}
+		if apiNode.IsStatic {
+			if apiNode.StaticNode.RemoteAccessClientID != "" {
+				continue
+			}
+			extclient, err := GetExtClient(apiNode.StaticNode.ClientID, apiNode.StaticNode.Network)
 			if err != nil {
 				continue
 			}
+			node.IsStatic = true
+			node.StaticNode = extclient
+		} else {
+			node, err = GetNodeByID(apiNode.ID)
+			if err != nil {
+				continue
+			}
+		}
 
 		if _, ok := tagNodesMap[node.ID.String()]; !ok {
+			if node.StaticNode.Tags == nil {
+				node.StaticNode.Tags = make(map[models.TagID]struct{})
+			}
 			if node.Tags == nil {
 				node.Tags = make(map[models.TagID]struct{})
 			}
 			if newID != "" {
 				node.Tags[newID] = struct{}{}
+				node.StaticNode.Tags[newID] = struct{}{}
 			} else {
 				node.Tags[req.ID] = struct{}{}
+				node.StaticNode.Tags[req.ID] = struct{}{}
 			}
+			if node.IsStatic {
+				SaveExtClient(&node.StaticNode)
+			} else {
 				UpsertNode(&node)
+			}
 		} else {
 			if newID != "" {
 				delete(node.Tags, req.ID)
+				delete(node.StaticNode.Tags, req.ID)
+				node.StaticNode.Tags[newID] = struct{}{}
 				node.Tags[newID] = struct{}{}
+				if node.IsStatic {
+					SaveExtClient(&node.StaticNode)
+				} else {
 					UpsertNode(&node)
 				}
+			}
 			delete(tagNodesMap, node.ID.String())
 		}
 
 	}
 	for _, deletedTaggedNode := range tagNodesMap {
-		deletedTaggedHost := deletedTaggedNode
-		delete(deletedTaggedHost.Tags, req.ID)
-		UpsertNode(&deletedTaggedHost)
+		delete(deletedTaggedNode.Tags, req.ID)
+		delete(deletedTaggedNode.StaticNode.Tags, req.ID)
+		if deletedTaggedNode.IsStatic {
+			SaveExtClient(&deletedTaggedNode.StaticNode)
+		} else {
+			UpsertNode(&deletedTaggedNode)
+		}
 	}
 	go func(req models.UpdateTagReq) {
 		if newID != "" {
 			tagNodesMap = GetNodesWithTag(req.ID)
 			for _, nodeI := range tagNodesMap {
 				nodeI := nodeI
+				if nodeI.StaticNode.Tags == nil {
+					nodeI.StaticNode.Tags = make(map[models.TagID]struct{})
+				}
+				if nodeI.Tags == nil {
+					nodeI.Tags = make(map[models.TagID]struct{})
+				}
 				delete(nodeI.Tags, req.ID)
+				delete(nodeI.StaticNode.Tags, req.ID)
 				nodeI.Tags[newID] = struct{}{}
+				nodeI.StaticNode.Tags[newID] = struct{}{}
+				if nodeI.IsStatic {
+					SaveExtClient(&nodeI.StaticNode)
+				} else {
 					UpsertNode(&nodeI)
 				}
 			}
+		}
 	}(req)
 
 }

models/tags.go

@@ -30,23 +30,23 @@ type Tag struct {
 type CreateTagReq struct {
 	TagName     string    `json:"tag_name"`
 	Network     NetworkID `json:"network"`
-	TaggedNodes []string  `json:"tagged_nodes"`
+	TaggedNodes []ApiNode `json:"tagged_nodes"`
 }
 
 type TagListResp struct {
 	Tag
 	UsedByCnt   int       `json:"used_by_count"`
-	TaggedNodes []Node `json:"tagged_nodes"`
+	TaggedNodes []ApiNode `json:"tagged_nodes"`
 }
 
 type TagListRespNodes struct {
 	Tag
 	UsedByCnt   int       `json:"used_by_count"`
-	TaggedNodes []Node `json:"tagged_nodes"`
+	TaggedNodes []ApiNode `json:"tagged_nodes"`
 }
 
 type UpdateTagReq struct {
 	Tag
 	NewName     string    `json:"new_name"`
-	TaggedNodes []string `json:"tagged_nodes"`
+	TaggedNodes []ApiNode `json:"tagged_nodes"`
 }