NET-1613: TAG Mgmt APIs

auth/host_session.go

@@ -222,7 +222,7 @@ func SessionHandler(conn *websocket.Conn) {
  if err = conn.WriteMessage(messageType, reponseData); err != nil {
  logger.Log(0, "error during message writing:", err.Error())
  }
- go CheckNetRegAndHostUpdate(netsToAdd[:], &result.Host, uuid.Nil)
+ go CheckNetRegAndHostUpdate(netsToAdd[:], &result.Host, uuid.Nil, []models.TagID{})
  case <-timeout: // the read from req.answerCh has timed out
  logger.Log(0, "timeout signal recv,exiting oauth socket conn")
  break
@@ -236,7 +236,7 @@ func SessionHandler(conn *websocket.Conn) {
 }
 
 // CheckNetRegAndHostUpdate - run through networks and send a host update
-func CheckNetRegAndHostUpdate(networks []string, h *models.Host, relayNodeId uuid.UUID) {
+func CheckNetRegAndHostUpdate(networks []string, h *models.Host, relayNodeId uuid.UUID, tags []models.TagID) {
  // publish host update through MQ
  for i := range networks {
  network := networks[i]
@@ -246,6 +246,14 @@ func CheckNetRegAndHostUpdate(networks []string, h *models.Host, relayNodeId uui
  logger.Log(0, "failed to add host to network:", h.ID.String(), h.Name, network, err.Error())
  continue
  }
+ if len(tags) > 0 {
+ newNode.Tags = make(map[models.TagID]struct{})
+ for _, tagI := range tags {
+ newNode.Tags[tagI] = struct{}{}
+ }
+ logic.UpsertNode(newNode)
+ }
+
  if relayNodeId != uuid.Nil && !newNode.IsRelayed {
  // check if relay node exists and acting as relay
  relaynode, err := logic.GetNodeByID(relayNodeId.String())

controllers/controller.go

@@ -34,6 +34,7 @@ var HttpHandlers = []interface{}{
  loggerHandlers,
  hostHandlers,
  enrollmentKeyHandlers,
+ tagHandlers,
  legacyHandlers,
 }
 

controllers/enrollmentkeys.go

@@ -156,6 +156,7 @@ func createEnrollmentKey(w http.ResponseWriter, r *http.Request) {
  newTime,
  enrollmentKeyBody.Networks,
  enrollmentKeyBody.Tags,
+ enrollmentKeyBody.Groups,
  enrollmentKeyBody.Unlimited,
  relayId,
  )
@@ -206,7 +207,7 @@ func updateEnrollmentKey(w http.ResponseWriter, r *http.Request) {
  }
  }
 
- newEnrollmentKey, err := logic.UpdateEnrollmentKey(keyId, relayId)
+ newEnrollmentKey, err := logic.UpdateEnrollmentKey(keyId, relayId, enrollmentKeyBody.Groups)
  if err != nil {
  slog.Error("failed to update enrollment key", "error", err)
  logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
@@ -307,6 +308,7 @@ func handleHostRegister(w http.ResponseWriter, r *http.Request) {
  return
  }
  }
+
  if err = logic.CreateHost(&newHost); err != nil {
  logger.Log(
  0,
@@ -355,5 +357,5 @@ func handleHostRegister(w http.ResponseWriter, r *http.Request) {
  w.WriteHeader(http.StatusOK)
  json.NewEncoder(w).Encode(&response)
  // notify host of changes, peer and node updates
- go auth.CheckNetRegAndHostUpdate(enrollmentKey.Networks, &newHost, enrollmentKey.Relay)
+ go auth.CheckNetRegAndHostUpdate(enrollmentKey.Networks, &newHost, enrollmentKey.Relay, enrollmentKey.Groups)
 }

controllers/network.go

@@ -530,8 +530,9 @@ func createNetwork(w http.ResponseWriter, r *http.Request) {
  logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
  return
  }
- logic.CreateDefaultNetworkRolesAndGroups(models.NetworkID(network.NetID))
 
+ logic.CreateDefaultNetworkRolesAndGroups(models.NetworkID(network.NetID))
+ logic.CreateDefaultTags(models.NetworkID(network.NetID))
  //add new network to allocated ip map
  go logic.AddNetworkToAllocatedIpMap(network.NetID)
 

controllers/node.go

@@ -326,6 +326,7 @@ func getNetworkNodes(w http.ResponseWriter, r *http.Request) {
  if len(filteredNodes) > 0 {
  nodes = filteredNodes
  }
+ nodes = logic.AddStaticNodestoList(nodes)
 
  // returns all the nodes in JSON/API format
  apiNodes := logic.GetAllNodesAPI(nodes[:])
@@ -363,7 +364,9 @@ func getAllNodes(w http.ResponseWriter, r *http.Request) {
  if !userPlatformRole.FullAccess {
  nodes = logic.GetFilteredNodesByUserAccess(*user, nodes)
  }
+
  }
+ nodes = logic.AddStaticNodestoList(nodes)
  // return all the nodes in JSON/API format
  apiNodes := logic.GetAllNodesAPI(nodes[:])
  logger.Log(3, r.Header.Get("user"), "fetched all nodes they have access to")

controllers/tags.go

@@ -0,0 +1,199 @@
+package controller
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+
+ "github.com/gorilla/mux"
+ "github.com/gravitl/netmaker/logger"
+ "github.com/gravitl/netmaker/logic"
+ "github.com/gravitl/netmaker/models"
+)
+
+func tagHandlers(r *mux.Router) {
+ r.HandleFunc("/api/v1/tags", logic.SecurityCheck(true, http.HandlerFunc(getTags))).
+ Methods(http.MethodGet)
+ r.HandleFunc("/api/v1/tags", logic.SecurityCheck(true, http.HandlerFunc(createTag))).
+ Methods(http.MethodPost)
+ r.HandleFunc("/api/v1/tags", logic.SecurityCheck(true, http.HandlerFunc(updateTag))).
+ Methods(http.MethodPut)
+ r.HandleFunc("/api/v1/tags", logic.SecurityCheck(true, http.HandlerFunc(deleteTag))).
+ Methods(http.MethodDelete)
+
+}
+
+// @Summary List Tags in a network
+// @Router /api/v1/tags [get]
+// @Tags TAG
+// @Accept json
+// @Success 200 {array} models.SuccessResponse
+// @Failure 500 {object} models.ErrorResponse
+func getTags(w http.ResponseWriter, r *http.Request) {
+ netID, _ := url.QueryUnescape(r.URL.Query().Get("network"))
+ if netID == "" {
+ logic.ReturnErrorResponse(w, r, logic.FormatError(errors.New("network id param is missing"), "badrequest"))
+ return
+ }
+ // check if network exists
+ _, err := logic.GetNetwork(netID)
+ if err != nil {
+ logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+ return
+ }
+ tags, err := logic.ListTagsWithNodes(models.NetworkID(netID))
+ if err != nil {
+ logger.Log(0, r.Header.Get("user"), "failed to get all network tag entries: ", err.Error())
+ logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
+ return
+ }
+ logic.SortTagEntrys(tags[:])
+ logic.ReturnSuccessResponseWithJson(w, r, tags, "fetched all tags in the network "+netID)
+}
+
+// @Summary Create Tag
+// @Router /api/v1/tags [post]
+// @Tags TAG
+// @Accept json
+// @Success 200 {array} models.SuccessResponse
+// @Failure 500 {object} models.ErrorResponse
+func createTag(w http.ResponseWriter, r *http.Request) {
+ var req models.CreateTagReq
+ err := json.NewDecoder(r.Body).Decode(&req)
+ if err != nil {
+ logger.Log(0, "error decoding request body: ",
+ err.Error())
+ logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+ return
+ }
+ user, err := logic.GetUser(r.Header.Get("user"))
+ if err != nil {
+ logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+ return
+ }
+ // check if tag network exists
+ _, err = logic.GetNetwork(req.Network.String())
+ if err != nil {
+ logic.ReturnErrorResponse(w, r, logic.FormatError(errors.New("failed to get network details for "+req.Network.String()), "badrequest"))
+ return
+ }
+ // check if tag exists
+ tag := models.Tag{
+ ID: models.TagID(fmt.Sprintf("%s.%s", req.Network, req.TagName)),
+ TagName: req.TagName,
+ Network: req.Network,
+ CreatedBy: user.UserName,
+ CreatedAt: time.Now(),
+ }
+ _, err = logic.GetTag(tag.ID)
+ if err == nil {
+ logic.ReturnErrorResponse(w, r, logic.FormatError(fmt.Errorf("tag with id %s exists already", tag.TagName), "badrequest"))
+ return
+ }
+ // validate name
+ err = logic.CheckIDSyntax(tag.TagName)
+ if err != nil {
+ logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+ return
+ }
+ err = logic.InsertTag(tag)
+ if err != nil {
+ logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+ return
+ }
+ go func() {
+ 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
+ }
+ if node.Tags == nil {
+ node.Tags = make(map[models.TagID]struct{})
+ }
+ node.Tags[tag.ID] = struct{}{}
+ logic.UpsertNode(&node)
+ }
+ }()
+
+ logic.ReturnSuccessResponseWithJson(w, r, req, "created tag successfully")
+}
+
+// @Summary Update Tag
+// @Router /api/v1/tags [put]
+// @Tags TAG
+// @Accept json
+// @Success 200 {array} models.SuccessResponse
+// @Failure 500 {object} models.ErrorResponse
+func updateTag(w http.ResponseWriter, r *http.Request) {
+ var updateTag models.UpdateTagReq
+ err := json.NewDecoder(r.Body).Decode(&updateTag)
+ if err != nil {
+ logger.Log(0, "error decoding request body: ",
+ err.Error())
+ logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+ return
+ }
+
+ tag, err := logic.GetTag(updateTag.ID)
+ if err != nil {
+ logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+ return
+ }
+ updateTag.NewName = strings.TrimSpace(updateTag.NewName)
+ var newID models.TagID
+ if updateTag.NewName != "" {
+ // validate name
+ err = logic.CheckIDSyntax(updateTag.NewName)
+ if err != nil {
+ logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+ return
+ }
+ newID = models.TagID(fmt.Sprintf("%s.%s", tag.Network, updateTag.NewName))
+ tag.ID = newID
+ tag.TagName = updateTag.NewName
+ err = logic.InsertTag(tag)
+ if err != nil {
+ logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+ return
+ }
+ // delete old Tag entry
+ logic.DeleteTag(updateTag.ID)
+ }
+ go logic.UpdateTag(updateTag, newID)
+ logic.ReturnSuccessResponse(w, r, "updating tags")
+}
+
+// @Summary Delete Tag
+// @Router /api/v1/tags [delete]
+// @Tags TAG
+// @Accept json
+// @Success 200 {array} models.SuccessResponse
+// @Failure 500 {object} models.ErrorResponse
+func deleteTag(w http.ResponseWriter, r *http.Request) {
+ tagID, _ := url.QueryUnescape(r.URL.Query().Get("tag_id"))
+ if tagID == "" {
+ logic.ReturnErrorResponse(w, r, logic.FormatError(errors.New("role is required"), "badrequest"))
+ return
+ }
+ err := logic.DeleteTag(models.TagID(tagID))
+ if err != nil {
+ logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
+ return
+ }
+ logic.ReturnSuccessResponse(w, r, "deleted tag "+tagID)
+}

database/database.go

@@ -67,6 +67,8 @@ const (
  PENDING_USERS_TABLE_NAME = "pending_users"
  // USER_INVITES - table for user invites
  USER_INVITES_TABLE_NAME = "user_invites"
+ // TAG_TABLE_NAME - table for tags
+ TAG_TABLE_NAME = "tags"
  // == ERROR CONSTS ==
  // NO_RECORD - no singular result found
  NO_RECORD = "no result found"
@@ -152,6 +154,7 @@ func createTables() {
  CreateTable(PENDING_USERS_TABLE_NAME)
  CreateTable(USER_PERMISSIONS_TABLE_NAME)
  CreateTable(USER_INVITES_TABLE_NAME)
+ CreateTable(TAG_TABLE_NAME)
 }
 
 func CreateTable(tableName string) error {

logic/enrollmentkey.go

@@ -37,7 +37,7 @@ var (
 )
 
 // CreateEnrollmentKey - creates a new enrollment key in db
-func CreateEnrollmentKey(uses int, expiration time.Time, networks, tags []string, unlimited bool, relay uuid.UUID) (*models.EnrollmentKey, error) {
+func CreateEnrollmentKey(uses int, expiration time.Time, networks, tags []string, groups []models.TagID, unlimited bool, relay uuid.UUID) (*models.EnrollmentKey, error) {
  newKeyID, err := getUniqueEnrollmentID()
  if err != nil {
  return nil, err
@@ -51,6 +51,7 @@ func CreateEnrollmentKey(uses int, expiration time.Time, networks, tags []string
  Tags: []string{},
  Type: models.Undefined,
  Relay: relay,
+ Groups: groups,
  }
  if uses > 0 {
  k.UsesRemaining = uses
@@ -89,7 +90,7 @@ func CreateEnrollmentKey(uses int, expiration time.Time, networks, tags []string
 }
 
 // UpdateEnrollmentKey - updates an existing enrollment key's associated relay
-func UpdateEnrollmentKey(keyId string, relayId uuid.UUID) (*models.EnrollmentKey, error) {
+func UpdateEnrollmentKey(keyId string, relayId uuid.UUID, groups []models.TagID) (*models.EnrollmentKey, error) {
  key, err := GetEnrollmentKey(keyId)
  if err != nil {
  return nil, err
@@ -109,7 +110,7 @@ func UpdateEnrollmentKey(keyId string, relayId uuid.UUID) (*models.EnrollmentKey
  }
 
  key.Relay = relayId
-
+ key.Groups = groups
  if err = upsertEnrollmentKey(&key); err != nil {
  return nil, err
  }