2021-03-26 00:17:52 +08:00
|
|
|
package controller
|
|
|
|
|
|
|
|
import (
|
2021-04-16 02:48:10 +08:00
|
|
|
"encoding/json"
|
|
|
|
"errors"
|
2022-04-23 04:01:58 +08:00
|
|
|
"fmt"
|
2021-04-16 02:48:10 +08:00
|
|
|
"net/http"
|
|
|
|
"strings"
|
2021-08-10 03:32:04 +08:00
|
|
|
|
2021-04-16 02:48:10 +08:00
|
|
|
"github.com/gorilla/mux"
|
2022-12-07 12:11:20 +08:00
|
|
|
|
2021-07-22 06:55:19 +08:00
|
|
|
"github.com/gravitl/netmaker/database"
|
2021-12-07 04:31:08 +08:00
|
|
|
"github.com/gravitl/netmaker/logger"
|
2021-10-06 03:02:09 +08:00
|
|
|
"github.com/gravitl/netmaker/logic"
|
2022-02-26 05:28:58 +08:00
|
|
|
"github.com/gravitl/netmaker/logic/acls"
|
2021-04-16 02:48:10 +08:00
|
|
|
"github.com/gravitl/netmaker/models"
|
2022-02-21 00:12:51 +08:00
|
|
|
"github.com/gravitl/netmaker/mq"
|
2021-05-09 22:52:42 +08:00
|
|
|
"github.com/gravitl/netmaker/servercfg"
|
2021-03-26 00:17:52 +08:00
|
|
|
)
|
|
|
|
|
2021-04-13 12:42:35 +08:00
|
|
|
func networkHandlers(r *mux.Router) {
|
2022-12-23 22:49:08 +08:00
|
|
|
r.HandleFunc("/api/networks", logic.SecurityCheck(false, http.HandlerFunc(getNetworks))).Methods(http.MethodGet)
|
|
|
|
r.HandleFunc("/api/networks", logic.SecurityCheck(true, checkFreeTierLimits(networks_l, http.HandlerFunc(createNetwork)))).Methods(http.MethodPost)
|
|
|
|
r.HandleFunc("/api/networks/{networkname}", logic.SecurityCheck(false, http.HandlerFunc(getNetwork))).Methods(http.MethodGet)
|
|
|
|
r.HandleFunc("/api/networks/{networkname}", logic.SecurityCheck(false, http.HandlerFunc(updateNetwork))).Methods(http.MethodPut)
|
|
|
|
r.HandleFunc("/api/networks/{networkname}", logic.SecurityCheck(true, http.HandlerFunc(deleteNetwork))).Methods(http.MethodDelete)
|
|
|
|
r.HandleFunc("/api/networks/{networkname}/keyupdate", logic.SecurityCheck(true, http.HandlerFunc(keyUpdate))).Methods(http.MethodPost)
|
|
|
|
r.HandleFunc("/api/networks/{networkname}/keys", logic.SecurityCheck(false, http.HandlerFunc(createAccessKey))).Methods(http.MethodPost)
|
|
|
|
r.HandleFunc("/api/networks/{networkname}/keys", logic.SecurityCheck(false, http.HandlerFunc(getAccessKeys))).Methods(http.MethodGet)
|
|
|
|
r.HandleFunc("/api/networks/{networkname}/keys/{name}", logic.SecurityCheck(false, http.HandlerFunc(deleteAccessKey))).Methods(http.MethodDelete)
|
2022-03-04 23:46:46 +08:00
|
|
|
// ACLs
|
2022-12-23 22:49:08 +08:00
|
|
|
r.HandleFunc("/api/networks/{networkname}/acls", logic.SecurityCheck(true, http.HandlerFunc(updateNetworkACL))).Methods(http.MethodPut)
|
|
|
|
r.HandleFunc("/api/networks/{networkname}/acls", logic.SecurityCheck(true, http.HandlerFunc(getNetworkACL))).Methods(http.MethodGet)
|
2021-03-26 00:17:52 +08:00
|
|
|
}
|
|
|
|
|
2022-09-03 04:42:51 +08:00
|
|
|
// swagger:route GET /api/networks networks getNetworks
|
|
|
|
//
|
2022-09-11 12:51:59 +08:00
|
|
|
// Lists all networks.
|
2022-09-03 04:42:51 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Schemes: https
|
2022-09-03 04:42:51 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Security:
|
|
|
|
// oauth
|
2022-09-11 12:51:59 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Responses:
|
|
|
|
// 200: getNetworksSliceResponse
|
2021-04-13 12:42:35 +08:00
|
|
|
func getNetworks(w http.ResponseWriter, r *http.Request) {
|
2021-03-26 00:17:52 +08:00
|
|
|
|
2021-07-15 04:47:05 +08:00
|
|
|
headerNetworks := r.Header.Get("networks")
|
|
|
|
networksSlice := []string{}
|
|
|
|
marshalErr := json.Unmarshal([]byte(headerNetworks), &networksSlice)
|
|
|
|
if marshalErr != nil {
|
2022-07-13 14:01:25 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), "error unmarshalling networks: ",
|
2022-07-12 22:50:32 +08:00
|
|
|
marshalErr.Error())
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(marshalErr, "badrequest"))
|
2021-04-13 11:19:01 +08:00
|
|
|
return
|
|
|
|
}
|
2021-07-15 04:47:05 +08:00
|
|
|
allnetworks := []models.Network{}
|
2022-02-19 07:26:20 +08:00
|
|
|
var err error
|
2022-11-11 03:54:53 +08:00
|
|
|
if len(networksSlice) > 0 && networksSlice[0] == logic.ALL_NETWORK_ACCESS {
|
2021-10-27 00:27:29 +08:00
|
|
|
allnetworks, err = logic.GetNetworks()
|
2021-09-28 05:51:20 +08:00
|
|
|
if err != nil && !database.IsEmptyRecord(err) {
|
2022-07-13 14:01:25 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), "failed to fetch networks: ", err.Error())
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
2021-07-15 04:47:05 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for _, network := range networksSlice {
|
2021-10-27 00:27:29 +08:00
|
|
|
netObject, parentErr := logic.GetParentNetwork(network)
|
2021-07-15 04:47:05 +08:00
|
|
|
if parentErr == nil {
|
2022-02-19 08:47:20 +08:00
|
|
|
allnetworks = append(allnetworks, netObject)
|
2021-07-15 04:47:05 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-11-17 01:20:48 +08:00
|
|
|
if !servercfg.IsDisplayKeys() {
|
|
|
|
for i, net := range allnetworks {
|
|
|
|
net.AccessKeys = logic.RemoveKeySensitiveInfo(net.AccessKeys)
|
|
|
|
allnetworks[i] = net
|
|
|
|
}
|
|
|
|
}
|
2022-02-21 22:05:41 +08:00
|
|
|
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(2, r.Header.Get("user"), "fetched networks.")
|
2021-05-30 23:26:10 +08:00
|
|
|
w.WriteHeader(http.StatusOK)
|
2022-02-21 22:05:41 +08:00
|
|
|
json.NewEncoder(w).Encode(allnetworks)
|
2021-05-30 23:26:10 +08:00
|
|
|
}
|
|
|
|
|
2022-09-11 12:51:59 +08:00
|
|
|
// swagger:route GET /api/networks/{networkname} networks getNetwork
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-09-11 12:51:59 +08:00
|
|
|
// Get a network.
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Schemes: https
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Security:
|
|
|
|
// oauth
|
2022-09-11 12:51:59 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Responses:
|
|
|
|
// 200: networkBodyResponse
|
2021-04-13 12:42:35 +08:00
|
|
|
func getNetwork(w http.ResponseWriter, r *http.Request) {
|
2021-04-16 02:48:10 +08:00
|
|
|
// set header.
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
var params = mux.Vars(r)
|
2021-05-01 19:57:49 +08:00
|
|
|
netname := params["networkname"]
|
2021-12-08 01:46:55 +08:00
|
|
|
network, err := logic.GetNetwork(netname)
|
2021-05-01 19:57:49 +08:00
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), fmt.Sprintf("failed to fetch network [%s] info: %v",
|
|
|
|
netname, err))
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
2021-05-01 19:57:49 +08:00
|
|
|
return
|
|
|
|
}
|
2021-11-17 01:20:48 +08:00
|
|
|
if !servercfg.IsDisplayKeys() {
|
|
|
|
network.AccessKeys = logic.RemoveKeySensitiveInfo(network.AccessKeys)
|
|
|
|
}
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(2, r.Header.Get("user"), "fetched network", netname)
|
2021-05-01 19:57:49 +08:00
|
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
json.NewEncoder(w).Encode(network)
|
|
|
|
}
|
2021-03-26 00:17:52 +08:00
|
|
|
|
2022-09-06 20:20:24 +08:00
|
|
|
// swagger:route POST /api/networks/{networkname}/keyupdate networks keyUpdate
|
|
|
|
//
|
|
|
|
// Update keys for a network.
|
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Schemes: https
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Security:
|
|
|
|
// oauth
|
2022-09-11 12:51:59 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Responses:
|
|
|
|
// 200: networkBodyResponse
|
2021-04-06 06:09:21 +08:00
|
|
|
func keyUpdate(w http.ResponseWriter, r *http.Request) {
|
2021-04-16 02:48:10 +08:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
var params = mux.Vars(r)
|
2021-05-01 19:57:49 +08:00
|
|
|
netname := params["networkname"]
|
2021-12-08 01:46:55 +08:00
|
|
|
network, err := logic.KeyUpdate(netname)
|
2021-04-16 02:48:10 +08:00
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), fmt.Sprintf("failed to update keys for network [%s]: %v",
|
|
|
|
netname, err))
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
2021-04-16 02:48:10 +08:00
|
|
|
return
|
2021-04-13 11:19:01 +08:00
|
|
|
}
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(2, r.Header.Get("user"), "updated key on network", netname)
|
2021-05-01 19:57:49 +08:00
|
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
json.NewEncoder(w).Encode(network)
|
2022-02-05 00:40:29 +08:00
|
|
|
nodes, err := logic.GetNetworkNodes(netname)
|
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, "failed to retrieve network nodes for network", netname, err.Error())
|
2022-02-05 00:40:29 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
for _, node := range nodes {
|
2022-12-21 04:29:09 +08:00
|
|
|
logger.Log(2, "updating node ", node.ID.String(), " for a key update")
|
|
|
|
if err = mq.NodeUpdate(&node); err != nil {
|
|
|
|
logger.Log(1, "failed to send update to node during a network wide key update", node.ID.String(), err.Error())
|
2022-02-21 00:12:51 +08:00
|
|
|
}
|
2022-02-05 00:40:29 +08:00
|
|
|
}
|
2021-05-01 19:57:49 +08:00
|
|
|
}
|
2021-04-13 11:19:01 +08:00
|
|
|
|
2022-09-06 20:20:24 +08:00
|
|
|
// swagger:route PUT /api/networks/{networkname} networks updateNetwork
|
|
|
|
//
|
2022-09-11 12:51:59 +08:00
|
|
|
// Update a network.
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Schemes: https
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Security:
|
|
|
|
// oauth
|
2022-09-11 12:51:59 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Responses:
|
|
|
|
// 200: networkBodyResponse
|
2021-04-13 12:42:35 +08:00
|
|
|
func updateNetwork(w http.ResponseWriter, r *http.Request) {
|
2021-04-16 02:48:10 +08:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
var params = mux.Vars(r)
|
|
|
|
var network models.Network
|
2021-07-15 04:47:05 +08:00
|
|
|
netname := params["networkname"]
|
2022-02-19 07:26:20 +08:00
|
|
|
|
2021-10-27 00:27:29 +08:00
|
|
|
network, err := logic.GetParentNetwork(netname)
|
2021-04-16 02:48:10 +08:00
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), "failed to get network info: ",
|
|
|
|
err.Error())
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
2021-04-16 02:48:10 +08:00
|
|
|
return
|
|
|
|
}
|
2021-07-24 06:24:34 +08:00
|
|
|
var newNetwork models.Network
|
|
|
|
err = json.NewDecoder(r.Body).Decode(&newNetwork)
|
2021-04-16 20:02:12 +08:00
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), "error decoding request body: ",
|
|
|
|
err.Error())
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
2021-04-16 20:02:12 +08:00
|
|
|
return
|
|
|
|
}
|
2023-01-19 05:27:44 +08:00
|
|
|
rangeupdate4, rangeupdate6, holepunchupdate, groupsDelta, userDelta, err := logic.UpdateNetwork(&network, &newNetwork)
|
2021-05-04 05:51:38 +08:00
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), "failed to update network: ",
|
|
|
|
err.Error())
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
2021-05-04 05:51:38 +08:00
|
|
|
return
|
|
|
|
}
|
2021-03-26 00:17:52 +08:00
|
|
|
|
2022-09-14 03:25:56 +08:00
|
|
|
if len(groupsDelta) > 0 {
|
|
|
|
for _, g := range groupsDelta {
|
|
|
|
users, err := logic.GetGroupUsers(g)
|
|
|
|
if err == nil {
|
|
|
|
for _, user := range users {
|
|
|
|
logic.AdjustNetworkUserPermissions(&user, &newNetwork)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(userDelta) > 0 {
|
|
|
|
for _, uname := range userDelta {
|
|
|
|
user, err := logic.GetReturnUser(uname)
|
|
|
|
if err == nil {
|
|
|
|
logic.AdjustNetworkUserPermissions(&user, &newNetwork)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-05-13 07:35:46 +08:00
|
|
|
if rangeupdate4 {
|
2021-10-27 00:27:29 +08:00
|
|
|
err = logic.UpdateNetworkNodeAddresses(network.NetID)
|
2021-07-24 06:24:34 +08:00
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"),
|
|
|
|
fmt.Sprintf("failed to update network [%s] ipv4 addresses: %v",
|
|
|
|
network.NetID, err.Error()))
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
2021-07-24 06:24:34 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
2022-05-13 07:35:46 +08:00
|
|
|
if rangeupdate6 {
|
|
|
|
err = logic.UpdateNetworkNodeAddresses6(network.NetID)
|
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"),
|
|
|
|
fmt.Sprintf("failed to update network [%s] ipv6 addresses: %v",
|
|
|
|
network.NetID, err.Error()))
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
2022-05-13 07:35:46 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
2023-01-19 05:27:44 +08:00
|
|
|
if rangeupdate4 || rangeupdate6 || holepunchupdate {
|
2022-02-03 12:38:57 +08:00
|
|
|
nodes, err := logic.GetNetworkNodes(network.NetID)
|
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"),
|
|
|
|
fmt.Sprintf("failed to get network [%s] nodes: %v",
|
|
|
|
network.NetID, err.Error()))
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
2022-02-03 12:38:57 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
for _, node := range nodes {
|
2022-08-19 23:25:39 +08:00
|
|
|
runUpdates(&node, true)
|
2022-02-03 12:38:57 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(1, r.Header.Get("user"), "updated network", netname)
|
2021-05-04 05:51:38 +08:00
|
|
|
w.WriteHeader(http.StatusOK)
|
2021-07-24 06:24:34 +08:00
|
|
|
json.NewEncoder(w).Encode(newNetwork)
|
2021-05-04 05:51:38 +08:00
|
|
|
}
|
|
|
|
|
2022-09-06 20:20:24 +08:00
|
|
|
// swagger:route PUT /api/networks/{networkname}/acls networks updateNetworkACL
|
|
|
|
//
|
|
|
|
// Update a network ACL (Access Control List).
|
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Schemes: https
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Security:
|
|
|
|
// oauth
|
2022-09-11 12:51:59 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Responses:
|
|
|
|
// 200: aclContainerResponse
|
2022-02-26 05:28:58 +08:00
|
|
|
func updateNetworkACL(w http.ResponseWriter, r *http.Request) {
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
var params = mux.Vars(r)
|
|
|
|
netname := params["networkname"]
|
|
|
|
var networkACLChange acls.ACLContainer
|
|
|
|
networkACLChange, err := networkACLChange.Get(acls.ContainerID(netname))
|
|
|
|
if err != nil {
|
2022-07-13 18:53:37 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"),
|
|
|
|
fmt.Sprintf("failed to fetch ACLs for network [%s]: %v", netname, err))
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
2022-02-26 05:28:58 +08:00
|
|
|
return
|
|
|
|
}
|
2022-07-13 18:53:37 +08:00
|
|
|
err = json.NewDecoder(r.Body).Decode(&networkACLChange)
|
|
|
|
if err != nil {
|
|
|
|
logger.Log(0, r.Header.Get("user"), "error decoding request body: ",
|
|
|
|
err.Error())
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
2022-07-13 18:53:37 +08:00
|
|
|
return
|
|
|
|
}
|
2022-02-26 05:28:58 +08:00
|
|
|
newNetACL, err := networkACLChange.Save(acls.ContainerID(netname))
|
|
|
|
if err != nil {
|
2022-07-13 18:53:37 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"),
|
|
|
|
fmt.Sprintf("failed to update ACLs for network [%s]: %v", netname, err))
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
2022-02-26 05:28:58 +08:00
|
|
|
return
|
|
|
|
}
|
2022-03-11 01:37:52 +08:00
|
|
|
logger.Log(1, r.Header.Get("user"), "updated ACLs for network", netname)
|
|
|
|
|
|
|
|
// send peer updates
|
|
|
|
if servercfg.IsMessageQueueBackend() {
|
2023-01-10 13:19:15 +08:00
|
|
|
if err = mq.PublishPeerUpdate(); err != nil {
|
2022-12-21 04:29:09 +08:00
|
|
|
logger.Log(0, "failed to publish peer update after ACL update on", netname)
|
2022-03-11 01:37:52 +08:00
|
|
|
}
|
|
|
|
}
|
2022-02-26 05:28:58 +08:00
|
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
json.NewEncoder(w).Encode(newNetACL)
|
|
|
|
}
|
|
|
|
|
2022-09-06 20:20:24 +08:00
|
|
|
// swagger:route GET /api/networks/{networkname}/acls networks getNetworkACL
|
|
|
|
//
|
|
|
|
// Get a network ACL (Access Control List).
|
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Schemes: https
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Security:
|
|
|
|
// oauth
|
2022-09-11 12:51:59 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Responses:
|
|
|
|
// 200: aclContainerResponse
|
2022-02-26 05:28:58 +08:00
|
|
|
func getNetworkACL(w http.ResponseWriter, r *http.Request) {
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
var params = mux.Vars(r)
|
|
|
|
netname := params["networkname"]
|
|
|
|
var networkACL acls.ACLContainer
|
|
|
|
networkACL, err := networkACL.Get(acls.ContainerID(netname))
|
|
|
|
if err != nil {
|
2022-07-13 18:53:37 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"),
|
|
|
|
fmt.Sprintf("failed to fetch ACLs for network [%s]: %v", netname, err))
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
2022-02-26 05:28:58 +08:00
|
|
|
return
|
|
|
|
}
|
2022-03-11 01:37:52 +08:00
|
|
|
logger.Log(2, r.Header.Get("user"), "fetched acl for network", netname)
|
2022-02-26 05:28:58 +08:00
|
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
json.NewEncoder(w).Encode(networkACL)
|
|
|
|
}
|
|
|
|
|
2022-09-06 20:20:24 +08:00
|
|
|
// swagger:route DELETE /api/networks/{networkname} networks deleteNetwork
|
|
|
|
//
|
|
|
|
// Delete a network. Will not delete if there are any nodes that belong to the network.
|
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Schemes: https
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Security:
|
|
|
|
// oauth
|
2022-09-11 12:51:59 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Responses:
|
|
|
|
// 200: stringJSONResponse
|
2021-04-13 12:42:35 +08:00
|
|
|
func deleteNetwork(w http.ResponseWriter, r *http.Request) {
|
2021-04-16 02:48:10 +08:00
|
|
|
// Set header
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2021-03-26 00:17:52 +08:00
|
|
|
|
2021-04-16 02:48:10 +08:00
|
|
|
var params = mux.Vars(r)
|
2021-05-01 11:07:25 +08:00
|
|
|
network := params["networkname"]
|
2022-02-19 07:26:20 +08:00
|
|
|
err := logic.DeleteNetwork(network)
|
2021-04-13 11:19:01 +08:00
|
|
|
if err != nil {
|
2021-05-28 22:04:07 +08:00
|
|
|
errtype := "badrequest"
|
2021-07-15 04:47:05 +08:00
|
|
|
if strings.Contains(err.Error(), "Node check failed") {
|
2021-05-28 22:04:07 +08:00
|
|
|
errtype = "forbidden"
|
|
|
|
}
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"),
|
|
|
|
fmt.Sprintf("failed to delete network [%s]: %v", network, err))
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, errtype))
|
2021-04-16 02:48:10 +08:00
|
|
|
return
|
|
|
|
}
|
2022-09-30 02:29:18 +08:00
|
|
|
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(1, r.Header.Get("user"), "deleted network", network)
|
2021-05-01 11:07:25 +08:00
|
|
|
w.WriteHeader(http.StatusOK)
|
2021-07-22 06:55:19 +08:00
|
|
|
json.NewEncoder(w).Encode("success")
|
2021-05-01 11:07:25 +08:00
|
|
|
}
|
2021-03-26 00:17:52 +08:00
|
|
|
|
2022-09-06 20:20:24 +08:00
|
|
|
// swagger:route POST /api/networks networks createNetwork
|
|
|
|
//
|
2022-09-11 12:51:59 +08:00
|
|
|
// Create a network.
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Schemes: https
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Security:
|
|
|
|
// oauth
|
2022-09-11 12:51:59 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Responses:
|
|
|
|
// 200: networkBodyResponse
|
2021-04-13 12:42:35 +08:00
|
|
|
func createNetwork(w http.ResponseWriter, r *http.Request) {
|
2021-03-26 00:17:52 +08:00
|
|
|
|
2021-04-16 02:48:10 +08:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2021-03-26 00:17:52 +08:00
|
|
|
|
2021-04-16 02:48:10 +08:00
|
|
|
var network models.Network
|
2021-03-26 00:17:52 +08:00
|
|
|
|
2021-04-16 02:48:10 +08:00
|
|
|
// we decode our body request params
|
2021-04-13 12:42:35 +08:00
|
|
|
err := json.NewDecoder(r.Body).Decode(&network)
|
2021-04-16 02:48:10 +08:00
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), "error decoding request body: ",
|
|
|
|
err.Error())
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
2021-04-16 02:48:10 +08:00
|
|
|
return
|
|
|
|
}
|
2021-03-26 00:17:52 +08:00
|
|
|
|
2022-04-21 03:15:29 +08:00
|
|
|
if network.AddressRange == "" && network.AddressRange6 == "" {
|
2022-07-12 22:50:32 +08:00
|
|
|
err := errors.New("IPv4 or IPv6 CIDR required")
|
|
|
|
logger.Log(0, r.Header.Get("user"), "failed to create network: ",
|
|
|
|
err.Error())
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
2022-04-21 03:15:29 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-03-17 22:08:28 +08:00
|
|
|
network, err = logic.CreateNetwork(network)
|
2021-05-01 11:07:25 +08:00
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), "failed to create network: ",
|
|
|
|
err.Error())
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
2021-05-01 11:07:25 +08:00
|
|
|
return
|
|
|
|
}
|
2022-09-30 02:29:18 +08:00
|
|
|
|
2023-02-11 02:45:57 +08:00
|
|
|
defaultHosts := logic.GetDefaultHosts()
|
|
|
|
for i := range defaultHosts {
|
|
|
|
currHost := &defaultHosts[i]
|
|
|
|
newNode, err := logic.UpdateHostNetwork(currHost, network.NetID, true)
|
|
|
|
if err != nil {
|
|
|
|
logger.Log(0, r.Header.Get("user"), "failed to add host to network:", currHost.ID.String(), network.NetID, err.Error())
|
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
logger.Log(1, "added new node", newNode.ID.String(), "to host", currHost.Name)
|
|
|
|
if err = mq.HostUpdate(&models.HostUpdate{
|
|
|
|
Action: models.JoinHostToNetwork,
|
|
|
|
Host: *currHost,
|
|
|
|
Node: *newNode,
|
|
|
|
}); err != nil {
|
|
|
|
logger.Log(0, r.Header.Get("user"), "failed to add host to network:", currHost.ID.String(), network.NetID, err.Error())
|
|
|
|
}
|
|
|
|
}
|
2022-12-24 05:14:45 +08:00
|
|
|
|
2021-12-08 01:46:55 +08:00
|
|
|
logger.Log(1, r.Header.Get("user"), "created network", network.NetID)
|
|
|
|
w.WriteHeader(http.StatusOK)
|
2022-03-17 22:08:28 +08:00
|
|
|
json.NewEncoder(w).Encode(network)
|
2021-03-26 00:17:52 +08:00
|
|
|
}
|
|
|
|
|
2022-09-06 20:20:24 +08:00
|
|
|
// swagger:route POST /api/networks/{networkname}/keys networks createAccessKey
|
|
|
|
//
|
|
|
|
// Create a network access key.
|
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Schemes: https
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Security:
|
|
|
|
// oauth
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Responses:
|
|
|
|
// 200: accessKeyBodyResponse
|
2022-09-11 12:51:59 +08:00
|
|
|
//
|
2021-03-26 00:17:52 +08:00
|
|
|
// BEGIN KEY MANAGEMENT SECTION
|
|
|
|
func createAccessKey(w http.ResponseWriter, r *http.Request) {
|
2021-04-16 02:48:10 +08:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
var params = mux.Vars(r)
|
|
|
|
var accesskey models.AccessKey
|
2022-12-07 12:11:20 +08:00
|
|
|
// start here
|
2021-07-15 04:47:05 +08:00
|
|
|
netname := params["networkname"]
|
2021-10-27 00:27:29 +08:00
|
|
|
network, err := logic.GetParentNetwork(netname)
|
2021-04-16 02:48:10 +08:00
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), "failed to get network info: ",
|
|
|
|
err.Error())
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
2021-04-16 02:48:10 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
err = json.NewDecoder(r.Body).Decode(&accesskey)
|
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), "error decoding request body: ",
|
|
|
|
err.Error())
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
2021-04-16 02:48:10 +08:00
|
|
|
return
|
|
|
|
}
|
2021-12-08 01:46:55 +08:00
|
|
|
key, err := logic.CreateAccessKey(accesskey, network)
|
2021-05-01 19:57:49 +08:00
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), "failed to create access key: ",
|
|
|
|
err.Error())
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
2021-05-01 19:57:49 +08:00
|
|
|
return
|
|
|
|
}
|
2022-09-14 03:25:56 +08:00
|
|
|
|
|
|
|
// do not allow access key creations view API with user names
|
|
|
|
if _, err = logic.GetUser(key.Name); err == nil {
|
|
|
|
logger.Log(0, "access key creation with invalid name attempted by", r.Header.Get("user"))
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(fmt.Errorf("cannot create access key with user name"), "badrequest"))
|
2022-09-14 03:25:56 +08:00
|
|
|
logic.DeleteKey(key.Name, network.NetID)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(1, r.Header.Get("user"), "created access key", accesskey.Name, "on", netname)
|
2021-05-01 19:57:49 +08:00
|
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
json.NewEncoder(w).Encode(key)
|
2021-05-26 00:48:04 +08:00
|
|
|
}
|
|
|
|
|
2022-09-06 20:20:24 +08:00
|
|
|
// swagger:route GET /api/networks/{networkname}/keys networks getAccessKeys
|
|
|
|
//
|
|
|
|
// Get network access keys for a network.
|
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Schemes: https
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Security:
|
|
|
|
// oauth
|
2022-09-11 12:51:59 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Responses:
|
|
|
|
// 200: accessKeySliceBodyResponse
|
2021-03-26 00:17:52 +08:00
|
|
|
func getAccessKeys(w http.ResponseWriter, r *http.Request) {
|
2021-04-16 02:48:10 +08:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
var params = mux.Vars(r)
|
2021-05-01 19:57:49 +08:00
|
|
|
network := params["networkname"]
|
2021-12-08 01:46:55 +08:00
|
|
|
keys, err := logic.GetKeys(network)
|
2021-05-01 19:57:49 +08:00
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), fmt.Sprintf("failed to get keys for network [%s]: %v",
|
|
|
|
network, err))
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
|
2021-05-01 19:57:49 +08:00
|
|
|
return
|
|
|
|
}
|
2021-11-15 05:50:20 +08:00
|
|
|
if !servercfg.IsDisplayKeys() {
|
2021-11-17 01:20:48 +08:00
|
|
|
keys = logic.RemoveKeySensitiveInfo(keys)
|
2021-11-15 05:50:20 +08:00
|
|
|
}
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(2, r.Header.Get("user"), "fetched access keys on network", network)
|
2021-05-01 19:57:49 +08:00
|
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
json.NewEncoder(w).Encode(keys)
|
|
|
|
}
|
2021-03-26 00:17:52 +08:00
|
|
|
|
2022-09-11 12:51:59 +08:00
|
|
|
// swagger:route DELETE /api/networks/{networkname}/keys/{name} networks deleteAccessKey
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
|
|
|
// Delete a network access key.
|
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Schemes: https
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Security:
|
|
|
|
// oauth
|
2022-09-06 20:20:24 +08:00
|
|
|
//
|
2022-12-21 04:29:09 +08:00
|
|
|
// Responses:
|
|
|
|
// 200:
|
|
|
|
// *: stringJSONResponse
|
2022-09-11 12:51:59 +08:00
|
|
|
//
|
2021-12-08 01:46:55 +08:00
|
|
|
// delete key. Has to do a little funky logic since it's not a collection item
|
2021-03-26 00:17:52 +08:00
|
|
|
func deleteAccessKey(w http.ResponseWriter, r *http.Request) {
|
2021-04-16 02:48:10 +08:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
var params = mux.Vars(r)
|
2021-03-26 00:17:52 +08:00
|
|
|
keyname := params["name"]
|
2021-05-01 19:57:49 +08:00
|
|
|
netname := params["networkname"]
|
2021-12-08 01:46:55 +08:00
|
|
|
err := logic.DeleteKey(keyname, netname)
|
2021-04-16 02:48:10 +08:00
|
|
|
if err != nil {
|
2022-07-12 22:50:32 +08:00
|
|
|
logger.Log(0, r.Header.Get("user"), fmt.Sprintf("failed to delete key [%s] for network [%s]: %v",
|
|
|
|
keyname, netname, err))
|
2022-09-15 01:26:31 +08:00
|
|
|
logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
|
2021-04-16 02:48:10 +08:00
|
|
|
return
|
|
|
|
}
|
2021-12-07 04:31:08 +08:00
|
|
|
logger.Log(1, r.Header.Get("user"), "deleted access key", keyname, "on network,", netname)
|
2021-05-01 19:57:49 +08:00
|
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
}
|