Merge pull request #103 from gravitl/v0.2

V0.2

.github/workflows/buildandrelease.yml

@@ -0,0 +1,96 @@
+name: Build and Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Netmaker version'
+        required: false
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+
+      - name: Get Version Number
+        run: |
+          if [[ -n "${{ github.event.inputs.version }}" ]]; then
+            NETMAKER_VERSION=${{ github.event.inputs.version }}
+          else
+            NETMAKER_VERSION=$(curl -fsSL https://api.github.com/repos/gravitl/netmaker/tags | grep 'name' | head -1 | cut -d'"' -f4)
+          fi
+          echo "NETMAKER_VERSION=${NETMAKER_VERSION}" >> $GITHUB_ENV
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Setup go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.16
+
+      - name: Build
+        run: |
+          cd netclient
+          env GOOS=linux GOARCH=amd64 go build -o build/netclient main.go
+          env GOOS=linux GOARCH=arm GOARM=5 go build -o build/netclient-arm5/ main.go
+          env GOOS=linux GOARCH=arm GOARM=6 go build -o build/netclient-arm6/ main.go
+          env GOOS=linux GOARCH=arm GOARM=7 go build -o build/netclient-arm7/ main.go
+          env GOOS=linux GOARCH=arm64 go build -o build/netclient-arm64 main.go
+
+      - name: Upload arm5 to Release
+        if: github.event.inputs.version == ''
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: netclient/build/netclient-arm5
+          tag: ${{ env.NETMAKER_VERSION }}
+          overwrite: true
+          prerelease: true
+          asset_name: netclient-arm5
+
+      - name: Upload arm6 to Release
+        if: github.event.inputs.version == ''
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: netclient/build/netclient-arm6
+          tag: ${{ env.NETMAKER_VERSION }}
+          overwrite: true
+          prerelease: true
+          asset_name: netclient-arm6
+
+      - name: Upload arm7 to Release
+        if: github.event.inputs.version == ''
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: netclient/build/netclient-arm7
+          tag: ${{ env.NETMAKER_VERSION }}
+          overwrite: true
+          prerelease: true
+          asset_name: netclient-arm7
+
+      - name: Upload arm64 to Release
+        if: github.event.inputs.version == ''
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: build/netclient-arm64
+          tag: ${{ env.NETMAKER_VERSION }}
+          overwrite: true
+          prerelease: true
+          asset_name: netclient-arm64
+
+      - name: Upload x86 to Release
+        if: github.event.inputs.version == ''
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: build/netclient
+          tag: ${{ env.NETMAKER_VERSION }}
+          overwrite: true
+          prerelease: true
+          asset_name: netclient

.github/workflows/publish-docker.yml

@@ -0,0 +1,41 @@
+name: Publish Docker
+
+on:
+  pull_request:
+    branches:
+      - 'develop'
+      - 'master'
+      
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+      - name: Login to DockerHub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and push latest
+        if: github.base_ref == 'master'
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          platforms: linux/amd64, linux/arm64
+          push: true
+          tags: |
+            gravitl/netmaker:latest
+      - name: Build and push develop
+        if: github.base_ref == 'develop'
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          platforms: linux/amd64, linux/arm64
+          push: true
+          tags: |
+            gravitl/netmaker:develop

.github/workflows/test.yml

@@ -0,0 +1,23 @@
+name: Integration Test
+
+on:
+  push:
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    services:
+      mongodb:
+        image: mongo:4.2
+        ports:
+          - 27017:27017
+        env:
+          MONGO_INITDB_ROOT_USERNAME: mongoadmin
+          MONGO_INITDB_ROOT_PASSWORD: mongopass
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: run tests
+        run: |
+            cd test
+            go test . -v

README.md

@@ -38,7 +38,8 @@ In future releases, we have plans to support other platforms such as Windows and
 ## Docs
 **For more information, please read the docs, or check out the Quick Start below:**
 
- - [Getting Started](docs/GETTING_STARTED.md)
+ - [General Usage](docs/USAGE.md)
+ - [Troubleshooting](docs/TROUBLESHOOTING.md)
  - [API Documentation](docs/API.md)
  - [Product Roadmap](docs/ROADMAP.md)
  - [Contributing](docs/CONTRIBUTING.md)
@@ -69,14 +70,10 @@ Run the following: `curl -sfL https://raw.githubusercontent.com/gravitl/netmaker
 
 #### LICENSE
 
-Netmaker's source code and all artifacts in this repository are freely available. All versions are published under the Server Side Public License (SSPL), version 1, which can be found under the "licensing" directory: [LICENSE.txt](licensing/LICENSE.txt).
+Netmaker's source code and all artifacts in this repository are freely available. All versions are published under the Server Side Public License (SSPL), version 1, which can be found here: [LICENSE.txt](./LICENSE.txt).
 
 #### CONTACT
 
 Email: [email protected]  
 Discord: https://discord.gg/zRb9Vfhk8A
 
-#### SUPPORT
-
-BTC: 3JE5ejpwu9i4vwA4rePkEDBEPpFY1xzJuN  
-ETH: 0xB6c5D23F2bE2100A5a2D337911A7Ef7575B4f91A

config/config.go

@@ -42,6 +42,9 @@ type ServerConfig struct {
   AllowedOrigin	string `yaml:"allowedorigin"`
   RestBackend bool `yaml:"restbackend"`
   AgentBackend bool `yaml:"agentbackend"`
+  DefaultNetName string `yaml:"defaultnetname"`
+  DefaultNetRange string `yaml:"defaultnetrange"`
+  CreateDefault bool `yaml:"createdefault"`
 }
 
 type MongoConnConfig struct {

config/environments/dev.yaml

@@ -6,6 +6,9 @@ server:
   allowedorigin: "*"
   restbackend: true            
   agentbackend: true
+  defaultnetname: "default"
+  defaultnetrange: "10.10.10.0/24"
+  createdefault: true
 mongoconn:
   user: "mongoadmin"
   pass: "mongopass"

controllers/authGrpc.go

@@ -72,27 +72,27 @@ func grpcAuthorize(ctx context.Context) error {
 
 		authToken := authHeader[0]
 
-		mac, group, err := functions.VerifyToken(authToken)
+		mac, network, err := functions.VerifyToken(authToken)
 
 		if err  != nil { return err }
 
-                groupexists, err := functions.GroupExists(group)
+                networkexists, err := functions.NetworkExists(network)
 
 		if err != nil {
-			return status.Errorf(codes.Unauthenticated, "Unauthorized. Group does not exist: " + group)
+			return status.Errorf(codes.Unauthenticated, "Unauthorized. Network does not exist: " + network)
 
 		}
 		emptynode := models.Node{}
-		node, err := functions.GetNodeByMacAddress(group, mac)
+		node, err := functions.GetNodeByMacAddress(network, mac)
 		if err != nil || node == emptynode {
                         return status.Errorf(codes.Unauthenticated, "Node does not exist.")
 		}
 
-                //check that the request is for a valid group
-                //if (groupCheck && !groupexists) || err != nil {
-                if (!groupexists) {
+                //check that the request is for a valid network
+                //if (networkCheck && !networkexists) || err != nil {
+                if (!networkexists) {
 
-			return status.Errorf(codes.Unauthenticated, "Group does not exist.")
+			return status.Errorf(codes.Unauthenticated, "Network does not exist.")
 
                 } else {
                         return nil
@@ -105,6 +105,7 @@ func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.LoginRequest)
 
 	//out := new(LoginResponse)
 	macaddress := req.GetMacaddress()
+	network := req.GetNetwork()
 	password := req.GetPassword()
 
 	var result models.NodeAuth
@@ -121,9 +122,9 @@ func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.LoginRequest)
                 return nil, err
         } else {
             //Search DB for node with Mac Address. Ignore pending nodes (they should not be able to authenticate with API untill approved).
-            collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+            collection := mongoconn.Client.Database("netmaker").Collection("nodes")
             ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-            var err = collection.FindOne(ctx, bson.M{ "macaddress": macaddress}).Decode(&result)
+	    var err = collection.FindOne(ctx, bson.M{ "macaddress": macaddress, "network": network}).Decode(&result)
 
             defer cancel()
 
@@ -135,12 +136,15 @@ func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.LoginRequest)
            //might be able to have a common hash (certificates?) and compare those so that a password isn't passed in in plain text...
            //TODO: Consider a way of hashing the password client side before sending, or using certificates
            err = bcrypt.CompareHashAndPassword([]byte(result.Password), []byte(password))
-           if err != nil && result.Password != password {
+	   if err != nil && result.Password != password {
 			return nil, err
            } else {
                 //Create a new JWT for the node
-                tokenString, _ := functions.CreateJWT(macaddress, result.Group)
+                tokenString, err := functions.CreateJWT(macaddress, result.Network)
 
+		if err != nil {
+			return nil, err
+		}
                 if tokenString == "" {
 		    err = errors.New("Something went wrong. Could not retrieve token.")
                     return nil, err

controllers/common.go

@@ -16,17 +16,17 @@ import (
 
 )
 
-func GetPeersList(groupName string) ([]models.PeersResponse, error) {
+func GetPeersList(networkName string) ([]models.PeersResponse, error) {
 
         var peers []models.PeersResponse
 
         //Connection mongoDB with mongoconn class
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        //Get all nodes in the relevant group which are NOT in pending state
-        filter := bson.M{"group": groupName, "ispending": false}
+        //Get all nodes in the relevant network which are NOT in pending state
+        filter := bson.M{"network": networkName, "ispending": false}
         cur, err := collection.Find(ctx, filter)
 
         if err != nil {
@@ -59,18 +59,18 @@ func GetPeersList(groupName string) ([]models.PeersResponse, error) {
 }
 
 
-func ValidateNode(operation string, groupName string, node models.Node) error {
+func ValidateNode(operation string, networkName string, node models.Node) error {
 
         v := validator.New()
 
         _ = v.RegisterValidation("endpoint_check", func(fl validator.FieldLevel) bool {
-                //var isFieldUnique bool = functions.IsFieldUnique(groupName, "endpoint", node.Endpoint)
+                //var isFieldUnique bool = functions.IsFieldUnique(networkName, "endpoint", node.Endpoint)
 		isIpv4 := functions.IsIpv4Net(node.Endpoint)
 		notEmptyCheck := node.Endpoint != ""
                 return (notEmptyCheck && isIpv4) || operation == "update"
         })
         _ = v.RegisterValidation("localaddress_check", func(fl validator.FieldLevel) bool {
-                //var isFieldUnique bool = functions.IsFieldUnique(groupName, "endpoint", node.Endpoint)
+                //var isFieldUnique bool = functions.IsFieldUnique(networkName, "endpoint", node.Endpoint)
                 isIpv4 := functions.IsIpv4Net(node.LocalAddress)
                 notEmptyCheck := node.LocalAddress != ""
                 return (notEmptyCheck && isIpv4) || operation == "update"
@@ -78,7 +78,7 @@ func ValidateNode(operation string, groupName string, node models.Node) error {
 
 
         _ = v.RegisterValidation("macaddress_unique", func(fl validator.FieldLevel) bool {
-                var isFieldUnique bool = functions.IsFieldUnique(groupName, "macaddress", node.MacAddress)
+                var isFieldUnique bool = functions.IsFieldUnique(networkName, "macaddress", node.MacAddress)
                 return isFieldUnique || operation == "update"
         })
 
@@ -92,8 +92,8 @@ func ValidateNode(operation string, groupName string, node models.Node) error {
                 return isvalid
         })
 
-        _ = v.RegisterValidation("group_exists", func(fl validator.FieldLevel) bool {
-		_, err := node.GetGroup()
+        _ = v.RegisterValidation("network_exists", func(fl validator.FieldLevel) bool {
+		_, err := node.GetNetwork()
 		return err == nil
         })
         _ = v.RegisterValidation("pubkey_check", func(fl validator.FieldLevel) bool { 
@@ -117,15 +117,17 @@ func ValidateNode(operation string, groupName string, node models.Node) error {
         return err
 }
 
+
 func UpdateNode(nodechange models.Node, node models.Node) (models.Node, error) {
     //Question: Is there a better way  of doing  this than a bunch of "if" statements? probably...
     //Eventually, lets have a better way to check if any of the fields are filled out...
     queryMac := node.MacAddress
-    notifygroup := false
+    queryNetwork := node.Network
+    notifynetwork := false
 
     if nodechange.Address != "" {
         node.Address = nodechange.Address
-	notifygroup = true
+	notifynetwork = true
     }
     if nodechange.Name != "" {
         node.Name = nodechange.Name
@@ -136,8 +138,11 @@ func UpdateNode(nodechange models.Node, node models.Node) (models.Node, error) {
     if nodechange.ListenPort != 0 {
         node.ListenPort = nodechange.ListenPort
     }
-    if nodechange.PreUp != "" {
-        node.PreUp = nodechange.PreUp
+    if nodechange.ExpirationDateTime != 0 {
+        node.ExpirationDateTime = nodechange.ExpirationDateTime
+    }
+    if nodechange.PostDown != "" {
+        node.PostDown = nodechange.PostDown
     }
     if nodechange.Interface != "" {
         node.Interface = nodechange.Interface
@@ -150,7 +155,7 @@ func UpdateNode(nodechange models.Node, node models.Node) (models.Node, error) {
     }
     if nodechange.Endpoint != "" {
         node.Endpoint = nodechange.Endpoint
-	notifygroup = true
+	notifynetwork = true
 }
     if nodechange.SaveConfig != nil {
         node.SaveConfig = nodechange.SaveConfig
@@ -174,16 +179,17 @@ func UpdateNode(nodechange models.Node, node models.Node) (models.Node, error) {
     }
     if nodechange.PublicKey != "" {
         node.PublicKey = nodechange.PublicKey
-	notifygroup = true
+	node.KeyUpdateTimeStamp = time.Now().Unix()
+	notifynetwork = true
     }
 
         //collection := mongoconn.ConnectDB()
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
         // Create filter
-        filter := bson.M{"macaddress": queryMac}
+        filter := bson.M{"macaddress": queryMac, "network": queryNetwork}
 
         node.SetLastModified()
 
@@ -194,9 +200,11 @@ func UpdateNode(nodechange models.Node, node models.Node) (models.Node, error) {
                         {"password", node.Password},
                         {"listenport", node.ListenPort},
                         {"publickey", node.PublicKey},
+                        {"keyupdatetimestamp", node.KeyUpdateTimeStamp},
+                        {"expdatetime", node.ExpirationDateTime},
                         {"endpoint", node.Endpoint},
                         {"postup", node.PostUp},
-                        {"preup", node.PreUp},
+                        {"postdown", node.PostDown},
                         {"macaddress", node.MacAddress},
                         {"localaddress", node.LocalAddress},
                         {"persistentkeepalive", node.PersistentKeepalive},
@@ -213,24 +221,24 @@ func UpdateNode(nodechange models.Node, node models.Node) (models.Node, error) {
 		return nodeupdate, errN
 	}
 
-	returnnode, errN := GetNode(node.MacAddress, node.Group)
+	returnnode, errN := GetNode(queryMac, queryNetwork)
 
 	defer cancel()
 
-	if notifygroup {
-		errN = SetGroupNodesLastModified(node.Group)
+	if notifynetwork {
+		errN = SetNetworkNodesLastModified(queryNetwork)
 	}
 
 	return returnnode, errN
 }
 
-func DeleteNode(macaddress string, group string) (bool, error)  {
+func DeleteNode(macaddress string, network string) (bool, error)  {
 
 	deleted := false
 
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 
-	filter := bson.M{"macaddress": macaddress, "group": group}
+	filter := bson.M{"macaddress": macaddress, "network": network}
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
@@ -244,21 +252,21 @@ func DeleteNode(macaddress string, group string) (bool, error)  {
 
         defer cancel()
 
-        err = SetGroupNodesLastModified(group)
-	fmt.Println("Deleted node " + macaddress + " from group " + group)
+        err = SetNetworkNodesLastModified(network)
+	fmt.Println("Deleted node " + macaddress + " from network " + network)
 
 	return deleted, err
 }
 
-func GetNode(macaddress string, group string) (models.Node, error) {
+func GetNode(macaddress string, network string) (models.Node, error) {
 
         var node models.Node
 
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        filter := bson.M{"macaddress": macaddress, "group": group}
+        filter := bson.M{"macaddress": macaddress, "network": network}
         err := collection.FindOne(ctx, filter, options.FindOne().SetProjection(bson.M{"_id": 0})).Decode(&node)
 
         defer cancel()
@@ -266,7 +274,7 @@ func GetNode(macaddress string, group string) (models.Node, error) {
 	return node, err
 }
 
-func CreateNode(node models.Node, groupName string) (models.Node, error) {
+func CreateNode(node models.Node, networkName string) (models.Node, error) {
 
         //encrypt that password so we never see it again
         hash, err := bcrypt.GenerateFromPassword([]byte(node.Password), 5)
@@ -278,7 +286,7 @@ func CreateNode(node models.Node, groupName string) (models.Node, error) {
         node.Password = string(hash)
 
 
-        node.Group = groupName
+        node.Network = networkName
 
         //node.SetDefaults()
         //Umm, why am I doing this again?
@@ -288,15 +296,11 @@ func CreateNode(node models.Node, groupName string) (models.Node, error) {
         node.SetDefaults()
 
         //Another DB call here...Inefficient
-        //Anyways, this scrolls through all the IP Addresses in the group range and checks against nodes
+        //Anyways, this scrolls through all the IP Addresses in the network range and checks against nodes
         //until one is open and then returns it
-        node.Address, err = functions.UniqueAddress(groupName)
+        node.Address, err = functions.UniqueAddress(networkName)
 
-        if err != nil {/*
-		errorResponse := models.ErrorResponse{
-                        Code: http.StatusInternalServerError, Message: "W1R3: Encountered an internal error! ",
-                }*/
-                //returnErrorResponse(w, r, errorResponse)
+        if err != nil {
                 return node, err
         }
 
@@ -306,10 +310,10 @@ func CreateNode(node models.Node, groupName string) (models.Node, error) {
         node.SetDefaultName()
 	node.SetLastCheckIn()
 	node.SetLastPeerUpdate()
-
+	node.KeyUpdateTimeStamp = time.Now().Unix()
 
         //Create a JWT for the node
-        tokenString, _ := functions.CreateJWT(node.MacAddress, groupName)
+        tokenString, _ := functions.CreateJWT(node.MacAddress, networkName)
 
         if tokenString == "" {
                 //returnErrorResponse(w, r, errorResponse)
@@ -317,7 +321,7 @@ func CreateNode(node models.Node, groupName string) (models.Node, error) {
         }
 
         // connect db
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
 
@@ -333,26 +337,26 @@ func CreateNode(node models.Node, groupName string) (models.Node, error) {
         //return response for if node  is pending
         if !node.IsPending {
 
-        functions.DecrimentKey(node.Group, node.AccessKey)
+        functions.DecrimentKey(node.Network, node.AccessKey)
 
         }
 
-	SetGroupNodesLastModified(node.Group)
+	SetNetworkNodesLastModified(node.Network)
 
         return node, err
 }
 
-func NodeCheckIn(node models.Node, groupName string) (models.CheckInResponse, error) {
+func NodeCheckIn(node models.Node, networkName string) (models.CheckInResponse, error) {
 
 	var response models.CheckInResponse
 
-	parentgroup, err := functions.GetParentGroup(groupName)
+	parentnetwork, err := functions.GetParentNetwork(networkName)
         if err != nil{
-		err = fmt.Errorf("%w; Couldnt retrieve Group " + groupName  + ": ", err)
+		err = fmt.Errorf("%w; Couldnt retrieve Network " + networkName  + ": ", err)
                 return response, err
         }
 
-	parentnode, err := functions.GetNodeByMacAddress(groupName, node.MacAddress)
+	parentnode, err := functions.GetNodeByMacAddress(networkName, node.MacAddress)
         if err != nil{
 		err = fmt.Errorf("%w; Couldnt Get Node " + node.MacAddress, err)
                 return response, err
@@ -363,9 +367,11 @@ func NodeCheckIn(node models.Node, groupName string) (models.CheckInResponse, er
 		return response, err
 	}
 
-        grouplm := parentgroup.GroupLastModified
-	peerslm := parentgroup.NodesLastModified
-        peerlistlm := parentnode.LastPeerUpdate
+        networklm := parentnetwork.NetworkLastModified
+	peerslm := parentnetwork.NodesLastModified
+	gkeyupdate := parentnetwork.KeyUpdateTimeStamp
+	nkeyupdate := parentnode.KeyUpdateTimeStamp
+	peerlistlm := parentnode.LastPeerUpdate
         parentnodelm := parentnode.LastModified
 	parentnodelastcheckin := parentnode.LastCheckIn
 
@@ -373,44 +379,41 @@ func NodeCheckIn(node models.Node, groupName string) (models.CheckInResponse, er
 		response.NeedConfigUpdate = true
 	}
 
-	if parentnodelm < grouplm {
+	if parentnodelm < networklm {
 		response.NeedConfigUpdate = true
 	}
 	if peerlistlm < peerslm {
 		response.NeedPeerUpdate = true
 	}
-	/*
-	if postchanges {
-		parentnode, err = UpdateNode(node, parentnode)
-	        if err != nil{
-			err = fmt.Errorf("%w; Couldnt Update Node: ", err)
-			return response, err
-		} else {
-			response.NodeUpdated = true
-		}
+	if nkeyupdate < gkeyupdate {
+		response.NeedKeyUpdate = true
 	}
-	*/
+        if time.Now().Unix() > parentnode.ExpirationDateTime {
+                response.NeedDelete = true
+		_, err =  DeleteNode(node.MacAddress, networkName)
+        } else {
 	err = TimestampNode(parentnode, true,  false, false)
 
 	if err != nil{
 		err = fmt.Errorf("%w; Couldnt Timestamp Node: ", err)
 		return response, err
 	}
+	}
 	response.Success = true
 
         return response, err
 }
 
-func SetGroupNodesLastModified(groupName string) error {
+func SetNetworkNodesLastModified(networkName string) error {
 
 	timestamp := time.Now().Unix()
 
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
+        collection := mongoconn.Client.Database("netmaker").Collection("networks")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
         // Create filter
-        filter := bson.M{"nameid": groupName}
+        filter := bson.M{"netid": networkName}
 
         // prepare update model.
         update := bson.D{
@@ -441,12 +444,12 @@ func TimestampNode(node models.Node, updatecheckin bool, updatepeers bool, updat
 		node.SetLastPeerUpdate()
 	}
 
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
         // Create filter
-        filter := bson.M{"macaddress": node.MacAddress}
+        filter := bson.M{"macaddress": node.MacAddress, "network": node.Network}
 
         // prepare update model.
         update := bson.D{

controllers/controller.go

@@ -27,8 +27,9 @@ func HandleRESTRequests(wg *sync.WaitGroup) {
 
     nodeHandlers(r)
     userHandlers(r)
-    groupHandlers(r)
+    networkHandlers(r)
     fileHandlers(r)
+    serverHandlers(r)
 
 		port := config.Config.Server.ApiPort
 	        if os.Getenv("API_PORT") != "" {

controllers/groupHttpController.go

@@ -1,574 +0,0 @@
-package controller
-
-import (
-    "gopkg.in/go-playground/validator.v9"
-    "github.com/gravitl/netmaker/models"
-    "github.com/gravitl/netmaker/functions"
-    "github.com/gravitl/netmaker/mongoconn"
-    "time"
-    "strings"
-    "fmt"
-    "context"
-    "encoding/json"
-    "net/http"
-    "github.com/gorilla/mux"
-    "go.mongodb.org/mongo-driver/bson"
-    "go.mongodb.org/mongo-driver/mongo/options"
-    "github.com/gravitl/netmaker/config"
-)
-
-func groupHandlers(r *mux.Router) {
-    r.HandleFunc("/api/groups", securityCheck(http.HandlerFunc(getGroups))).Methods("GET")
-    r.HandleFunc("/api/groups", securityCheck(http.HandlerFunc(createGroup))).Methods("POST")
-    r.HandleFunc("/api/groups/{groupname}", securityCheck(http.HandlerFunc(getGroup))).Methods("GET")
-    r.HandleFunc("/api/groups/{groupname}/numnodes", securityCheck(http.HandlerFunc(getGroupNodeNumber))).Methods("GET")
-    r.HandleFunc("/api/groups/{groupname}", securityCheck(http.HandlerFunc(updateGroup))).Methods("PUT")
-    r.HandleFunc("/api/groups/{groupname}", securityCheck(http.HandlerFunc(deleteGroup))).Methods("DELETE")
-    r.HandleFunc("/api/groups/{groupname}/keys", securityCheck(http.HandlerFunc(createAccessKey))).Methods("POST")
-    r.HandleFunc("/api/groups/{groupname}/keys", securityCheck(http.HandlerFunc(getAccessKeys))).Methods("GET")
-    r.HandleFunc("/api/groups/{groupname}/keys/{name}", securityCheck(http.HandlerFunc(deleteAccessKey))).Methods("DELETE")
-}
-
-//Security check is middleware for every function and just checks to make sure that its the master calling
-//Only admin should have access to all these group-level actions
-//or maybe some Users once implemented
-func securityCheck(next http.Handler) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		var errorResponse = models.ErrorResponse{
-			Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
-		}
-
-		var params = mux.Vars(r)
-		hasgroup := params["groupname"] != ""
-		groupexists, _ := functions.GroupExists(params["groupname"])
-                if hasgroup && !groupexists {
-                        errorResponse = models.ErrorResponse{
-                                Code: http.StatusNotFound, Message: "W1R3: This group does not exist.",
-                        }
-                        returnErrorResponse(w, r, errorResponse)
-                } else {
-
-		bearerToken := r.Header.Get("Authorization")
-
-		var hasBearer = true
-		var tokenSplit = strings.Split(bearerToken, " ")
-		var  authToken = ""
-
-		if len(tokenSplit) < 2 {
-			hasBearer = false
-		} else {
-			authToken = tokenSplit[1]
-		}
-		//all endpoints here require master so not as complicated
-		//still might not be a good  way of doing this
-		if !hasBearer || !authenticateMaster(authToken) {
-			errorResponse = models.ErrorResponse{
-				Code: http.StatusUnauthorized, Message: "W1R3: You are unauthorized to access this endpoint.",
-			}
-			returnErrorResponse(w, r, errorResponse)
-		} else {
-			next.ServeHTTP(w, r)
-		}
-		}
-	}
-}
-//Consider a more secure way of setting master key
-func authenticateMaster(tokenString string) bool {
-    if tokenString == config.Config.Server.MasterKey {
-        return true
-    }
-    return false
-}
-
-//simple get all groups function
-func getGroups(w http.ResponseWriter, r *http.Request) {
-
-	//depends on list groups function
-	//TODO: This is perhaps a more efficient way of handling ALL http handlers
-	//Take their primary logic and put in a separate function
-	//May be better since most http handler functionality is needed internally cross-method
-	//E.G. a method may need to check against all groups. But it  cant call this function. That's why there's ListGroups
-	groups := functions.ListGroups()
-
-	json.NewEncoder(w).Encode(groups)
-
-}
-
-func validateGroup(operation string, group models.Group) error {
-
-        v := validator.New()
-
-        _ = v.RegisterValidation("addressrange_valid", func(fl validator.FieldLevel) bool {
-		isvalid := functions.IsIpv4CIDR(fl.Field().String())
-                return isvalid
-        })
-
-        _ = v.RegisterValidation("nameid_valid", func(fl validator.FieldLevel) bool {
-		isFieldUnique := operation == "update" || functions.IsGroupNameUnique(fl.Field().String())
-		inGroupCharSet := functions.NameInGroupCharSet(fl.Field().String())
-		return isFieldUnique && inGroupCharSet
-        })
-
-        _ = v.RegisterValidation("displayname_unique", func(fl validator.FieldLevel) bool {
-                isFieldUnique := functions.IsGroupDisplayNameUnique(fl.Field().String())
-                return isFieldUnique ||  operation == "update"
-        })
-
-        err := v.Struct(group)
-
-        if err != nil {
-                for _, e := range err.(validator.ValidationErrors) {
-                        fmt.Println(e)
-                }
-        }
-        return err
-}
-
-//Get number of nodes associated with a group
-//May not be necessary, but I think the front end needs it? This should be reviewed after iteration 1
-func getGroupNodeNumber(w http.ResponseWriter, r *http.Request) {
-
-        var params = mux.Vars(r)
-
-	count, err := GetGroupNodeNumber(params["groupname"])
-
-        if err != nil {
-		var errorResponse = models.ErrorResponse{
-			Code: http.StatusInternalServerError, Message: "W1R3: Error retrieving nodes.",
-		}
-		returnErrorResponse(w, r, errorResponse)
-	} else  {
-	json.NewEncoder(w).Encode(count)
-	}
-}
-
-//This is haphazard
-//I need a better folder structure
-//maybe a functions/ folder and then a node.go, group.go, keys.go, misc.go
-func GetGroupNodeNumber(groupName string) (int,  error){
-
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
-
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-
-        filter := bson.M{"group": groupName}
-        count, err := collection.CountDocuments(ctx, filter)
-	returncount := int(count)
-
-	//not sure if this is the right way of handling this error...
-        if err != nil {
-                return 9999, err
-        }
-
-        defer cancel()
-
-        return returncount, err
-}
-
-//Simple get group function
-func getGroup(w http.ResponseWriter, r *http.Request) {
-
-        // set header.
-        w.Header().Set("Content-Type", "application/json")
-
-        var params = mux.Vars(r)
-
-        var group models.Group
-
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
-
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-
-        filter := bson.M{"nameid": params["groupname"]}
-        err := collection.FindOne(ctx, filter, options.FindOne().SetProjection(bson.M{"_id": 0})).Decode(&group)
-
-        defer cancel()
-
-        if err != nil {
-                mongoconn.GetError(err, w)
-                return
-        }
-
-        json.NewEncoder(w).Encode(group)
-}
-
-//Update a group
-func updateGroup(w http.ResponseWriter, r *http.Request) {
-
-        w.Header().Set("Content-Type", "application/json")
-
-        var params = mux.Vars(r)
-
-        var group models.Group
-
-	group, err := functions.GetParentGroup(params["groupname"])
-        if err != nil {
-                return
-        }
-
-        var groupChange models.Group
-
-	haschange := false
-	hasrangeupdate := false
-
-	_ = json.NewDecoder(r.Body).Decode(&groupChange)
-
-	if groupChange.AddressRange == "" {
-		groupChange.AddressRange = group.AddressRange
-	}
-	if groupChange.NameID == "" {
-		groupChange.NameID =  group.NameID
-	}
-
-
-        err = validateGroup("update", groupChange)
-        if err != nil {
-                return
-        }
-
-
-	//TODO: group.Name is  not update-able
-	//group.Name acts as  the ID for the group and keeps it unique and searchable by nodes
-	//should consider renaming to group.ID  
-	//Too lazy for now.
-	//DisplayName is the editable version and will not be used for node searches,
-	//but will be used by front end.
-
-        if groupChange.AddressRange != "" {
-
-            group.AddressRange = groupChange.AddressRange
-
-	    var isAddressOK bool = functions.IsIpv4CIDR(groupChange.AddressRange)
-            if !isAddressOK {
-                    return
-            }
-             haschange = true
-	     hasrangeupdate = true
-
-        }
-
-       if groupChange.DefaultListenPort != 0 {
-            group.DefaultListenPort = groupChange.DefaultListenPort
-             haschange = true
-        }
-        if groupChange.DefaultPreUp != "" {
-            group.DefaultPreUp = groupChange.DefaultPreUp
-             haschange = true
-        }
-        if groupChange.DefaultInterface != "" {
-            group.DefaultInterface = groupChange.DefaultInterface
-             haschange = true
-        }
-        if groupChange.DefaultPostUp != "" {
-            group.DefaultPostUp = groupChange.DefaultPostUp
-             haschange = true
-        }
-        if groupChange.DefaultKeepalive != 0 {
-            group.DefaultKeepalive = groupChange.DefaultKeepalive
-             haschange = true
-        }
-        if groupChange.DisplayName != "" {
-            group.DisplayName = groupChange.DisplayName
-             haschange = true
-        }
-        if groupChange.DefaultCheckInInterval != 0 {
-            group.DefaultCheckInInterval = groupChange.DefaultCheckInInterval
-             haschange = true
-        }
-
-	//TODO: Important. This doesn't work. This will create cases where we will
-	//unintentionally go from allowing manual signup to disallowing
-	//need to find a smarter way
-	//maybe make into a text field
-        if groupChange.AllowManualSignUp != group.AllowManualSignUp {
-            group.AllowManualSignUp = groupChange.AllowManualSignUp
-             haschange = true
-        }
-
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
-
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-
-        filter := bson.M{"nameid": params["groupname"]}
-
-	if haschange {
-		group.SetGroupLastModified()
-	}
-
-        // prepare update model.
-        update := bson.D{
-                {"$set", bson.D{
-                        {"addressrange", group.AddressRange},
-                        {"displayname", group.DisplayName},
-                        {"defaultlistenport", group.DefaultListenPort},
-                        {"defaultpostup", group.DefaultPostUp},
-                        {"defaultpreup", group.DefaultPreUp},
-                        {"defaultkeepalive", group.DefaultKeepalive},
-                        {"defaultsaveconfig", group.DefaultSaveConfig},
-                        {"defaultinterface", group.DefaultInterface},
-                        {"nodeslastmodified", group.NodesLastModified},
-                        {"grouplastmodified", group.GroupLastModified},
-                        {"allowmanualsignup", group.AllowManualSignUp},
-                        {"defaultcheckininterval", group.DefaultCheckInInterval},
-		}},
-        }
-
-	errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&group)
-
-        defer cancel()
-
-        if errN != nil {
-                mongoconn.GetError(errN, w)
-		fmt.Println(errN)
-                return
-        }
-
-	//Cycles through nodes and gives them new IP's based on the new range
-	//Pretty cool, but also pretty inefficient currently
-        if hasrangeupdate {
-		_ = functions.UpdateGroupNodeAddresses(params["groupname"])
-		//json.NewEncoder(w).Encode(errG)
-	}
-        json.NewEncoder(w).Encode(group)
-}
-
-//Delete a group
-//Will stop you if  there's any nodes associated
-func deleteGroup(w http.ResponseWriter, r *http.Request) {
-        // Set header
-        w.Header().Set("Content-Type", "application/json")
-
-        var params = mux.Vars(r)
-
-        var errorResponse = models.ErrorResponse{
-                Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
-        }
-
-	nodecount, err := GetGroupNodeNumber(params["groupname"])
-
-	//we dont wanna leave nodes hanging. They need a group!
-        if nodecount > 0 || err != nil {
-                errorResponse = models.ErrorResponse{
-                        Code: http.StatusForbidden, Message: "W1R3: Node check failed. All nodes must be deleted before deleting group.",
-                }
-                returnErrorResponse(w, r, errorResponse)
-                return
-        }
-
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
-
-        filter := bson.M{"nameid": params["groupname"]}
-
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-
-        deleteResult, err := collection.DeleteOne(ctx, filter)
-
-        defer cancel()
-
-        if err != nil {
-                mongoconn.GetError(err, w)
-                return
-        }
-
-        json.NewEncoder(w).Encode(deleteResult)
-
-}
-
-//Create a group
-//Pretty simple
-func createGroup(w http.ResponseWriter, r *http.Request) {
-
-        w.Header().Set("Content-Type", "application/json")
-
-	//TODO: 
-	//This may be needed to get error response. May be why some errors dont work
-	//analyze different error responses and see what needs to be done
-	//commenting out for now
-	/*
-        var errorResponse = models.ErrorResponse{
-                Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
-        }
-	*/
-        var group models.Group
-
-        // we decode our body request params
-        _ = json.NewDecoder(r.Body).Decode(&group)
-
-	//TODO: Not really doing good validation here. Same as createNode, updateNode, and updateGroup
-	//Need to implement some better validation across the board
-        err := validateGroup("create", group)
-        if err != nil {
-                return
-        }
-
-	group.SetDefaults()
-        group.SetNodesLastModified()
-        group.SetGroupLastModified()
-
-
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-
-
-        // insert our group into the group table
-        result, err := collection.InsertOne(ctx, group)
-        _ = result
-
-        defer cancel()
-
-        if err != nil {
-                mongoconn.GetError(err, w)
-                return
-        }
-}
-
-// BEGIN KEY MANAGEMENT SECTION
-// Consider a separate file for these controllers but I think same file is fine for now
-
-
-//TODO: Very little error handling
-//accesskey is created as a json string inside the Group collection item in mongo
-func createAccessKey(w http.ResponseWriter, r *http.Request) {
-
-        w.Header().Set("Content-Type", "application/json")
-
-        var params = mux.Vars(r)
-
-        var group models.Group
-        var accesskey models.AccessKey
-
-        //start here
-	group, err := functions.GetParentGroup(params["groupname"])
-        if err != nil {
-                return
-        }
-
-        _ = json.NewDecoder(r.Body).Decode(&accesskey)
-
-	if accesskey.Name == "" {
-                accesskey.Name = functions.GenKeyName()
-        }
-	if accesskey.Value == "" {
-		accesskey.Value = functions.GenKey()
-	}
-        if accesskey.Uses == 0 {
-                accesskey.Uses = 1
-        }
-
-
-	group.AccessKeys = append(group.AccessKeys, accesskey)
-
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
-
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-
-        // Create filter
-        filter := bson.M{"nameid": params["groupname"]}
-
-        // Read update model from body request
-        fmt.Println("Adding key to " + group.NameID)
-
-        // prepare update model.
-        update := bson.D{
-                {"$set", bson.D{
-                        {"accesskeys", group.AccessKeys},
-                }},
-        }
-
-        errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&group)
-
-        defer cancel()
-
-        if errN != nil {
-                mongoconn.GetError(errN, w)
-                return
-        }
-	w.Write([]byte(accesskey.Value))
-}
-
-//pretty simple get
-func getAccessKeys(w http.ResponseWriter, r *http.Request) {
-
-	// set header.
-        w.Header().Set("Content-Type", "application/json")
-
-        var params = mux.Vars(r)
-
-        var group models.Group
-        var keys []models.DisplayKey
-
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
-
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-
-        filter := bson.M{"nameid": params["groupname"]}
-        err := collection.FindOne(ctx, filter, options.FindOne().SetProjection(bson.M{"_id": 0})).Decode(&group)
-
-        defer cancel()
-
-        if err != nil {
-                mongoconn.GetError(err, w)
-                return
-        }
-	keydata, keyerr := json.Marshal(group.AccessKeys)
-
-        if keyerr != nil {
-                return
-        }
-
-	json.Unmarshal(keydata, &keys)
-
-        //json.NewEncoder(w).Encode(group.AccessKeys)
-        json.NewEncoder(w).Encode(keys)
-}
-
-//delete key. Has to do a little funky logic since it's not a collection item
-func deleteAccessKey(w http.ResponseWriter, r *http.Request) {
-
-        w.Header().Set("Content-Type", "application/json")
-
-        var params = mux.Vars(r)
-
-        var group models.Group
-	keyname := params["name"]
-
-        //start here
-	group, err := functions.GetParentGroup(params["groupname"])
-        if err != nil {
-                return
-        }
-
-	//basically, turn the list of access keys into the list of access keys before and after the item
-	//have not done any error handling for if there's like...1 item. I think it works? need to test.
-	for i := len(group.AccessKeys) - 1; i >= 0; i-- {
-
-		currentkey:= group.AccessKeys[i]
-		if currentkey.Name == keyname {
-			group.AccessKeys = append(group.AccessKeys[:i],
-				group.AccessKeys[i+1:]...)
-		}
-	}
-
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
-
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-
-        // Create filter
-        filter := bson.M{"nameid": params["groupname"]}
-
-        // prepare update model.
-        update := bson.D{
-                {"$set", bson.D{
-                        {"accesskeys", group.AccessKeys},
-                }},
-        }
-
-        errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&group)
-
-        defer cancel()
-
-        if errN != nil {
-                mongoconn.GetError(errN, w)
-                return
-        }
-}

controllers/networkHttpController.go

@@ -0,0 +1,724 @@
+package controller
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gorilla/mux"
+	"github.com/gravitl/netmaker/config"
+	"github.com/gravitl/netmaker/functions"
+	"github.com/gravitl/netmaker/models"
+	"github.com/gravitl/netmaker/mongoconn"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"gopkg.in/go-playground/validator.v9"
+)
+
+func networkHandlers(r *mux.Router) {
+	r.HandleFunc("/api/networks", securityCheck(http.HandlerFunc(getNetworks))).Methods("GET")
+	r.HandleFunc("/api/networks", securityCheck(http.HandlerFunc(createNetwork))).Methods("POST")
+	r.HandleFunc("/api/networks/{networkname}", securityCheck(http.HandlerFunc(getNetwork))).Methods("GET")
+	r.HandleFunc("/api/networks/{networkname}", securityCheck(http.HandlerFunc(updateNetwork))).Methods("PUT")
+	r.HandleFunc("/api/networks/{networkname}", securityCheck(http.HandlerFunc(deleteNetwork))).Methods("DELETE")
+	r.HandleFunc("/api/networks/{networkname}/keyupdate", securityCheck(http.HandlerFunc(keyUpdate))).Methods("POST")
+	r.HandleFunc("/api/networks/{networkname}/keys", securityCheck(http.HandlerFunc(createAccessKey))).Methods("POST")
+	r.HandleFunc("/api/networks/{networkname}/keys", securityCheck(http.HandlerFunc(getAccessKeys))).Methods("GET")
+	r.HandleFunc("/api/networks/{networkname}/keys/{name}", securityCheck(http.HandlerFunc(deleteAccessKey))).Methods("DELETE")
+}
+
+//Security check is middleware for every function and just checks to make sure that its the master calling
+//Only admin should have access to all these network-level actions
+//or maybe some Users once implemented
+func securityCheck(next http.Handler) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var errorResponse = models.ErrorResponse{
+			Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
+		}
+
+		var params = mux.Vars(r)
+		hasnetwork := params["networkname"] != ""
+		networkexists, err := functions.NetworkExists(params["networkname"])
+		if err != nil {
+			returnErrorResponse(w, r, formatError(err, "internal"))
+			return
+		} else if hasnetwork && !networkexists {
+			errorResponse = models.ErrorResponse{
+				Code: http.StatusNotFound, Message: "W1R3: This network does not exist.",
+			}
+			returnErrorResponse(w, r, errorResponse)
+			return
+		} else {
+
+			bearerToken := r.Header.Get("Authorization")
+
+			var hasBearer = true
+			var tokenSplit = strings.Split(bearerToken, " ")
+			var authToken = ""
+
+			if len(tokenSplit) < 2 {
+				hasBearer = false
+			} else {
+				authToken = tokenSplit[1]
+			}
+			//all endpoints here require master so not as complicated
+			//still might not be a good  way of doing this
+			if !hasBearer || !authenticateMaster(authToken) {
+				errorResponse = models.ErrorResponse{
+					Code: http.StatusUnauthorized, Message: "W1R3: You are unauthorized to access this endpoint.",
+				}
+				returnErrorResponse(w, r, errorResponse)
+				return
+			} else {
+				next.ServeHTTP(w, r)
+			}
+		}
+	}
+}
+
+//Consider a more secure way of setting master key
+func authenticateMaster(tokenString string) bool {
+	if tokenString == config.Config.Server.MasterKey {
+		return true
+	}
+	return false
+}
+
+//simple get all networks function
+func getNetworks(w http.ResponseWriter, r *http.Request) {
+
+	networks, err := functions.ListNetworks()
+
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	} else {
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(networks)
+		return
+	}
+}
+
+func validateNetworkUpdate(network models.Network) error {
+
+	v := validator.New()
+
+	_ = v.RegisterValidation("addressrange_valid", func(fl validator.FieldLevel) bool {
+		isvalid := fl.Field().String() == "" || functions.IsIpv4CIDR(fl.Field().String())
+		return isvalid
+	})
+
+	_ = v.RegisterValidation("localrange_valid", func(fl validator.FieldLevel) bool {
+		isvalid := fl.Field().String() == "" || functions.IsIpv4CIDR(fl.Field().String())
+		return isvalid
+	})
+
+	_ = v.RegisterValidation("netid_valid", func(fl validator.FieldLevel) bool {
+		return true
+	})
+
+	_ = v.RegisterValidation("displayname_unique", func(fl validator.FieldLevel) bool {
+		return true
+	})
+
+	err := v.Struct(network)
+
+	if err != nil {
+		for _, e := range err.(validator.ValidationErrors) {
+			fmt.Println(e)
+		}
+	}
+	return err
+}
+
+func validateNetworkCreate(network models.Network) error {
+
+	v := validator.New()
+
+	_ = v.RegisterValidation("addressrange_valid", func(fl validator.FieldLevel) bool {
+		isvalid := functions.IsIpv4CIDR(fl.Field().String())
+		return isvalid
+	})
+
+	_ = v.RegisterValidation("localrange_valid", func(fl validator.FieldLevel) bool {
+		isvalid := fl.Field().String() == "" || functions.IsIpv4CIDR(fl.Field().String())
+		return isvalid
+	})
+
+	_ = v.RegisterValidation("netid_valid", func(fl validator.FieldLevel) bool {
+		isFieldUnique, _ := functions.IsNetworkNameUnique(fl.Field().String())
+		inCharSet := functions.NameInNetworkCharSet(fl.Field().String())
+		return isFieldUnique && inCharSet
+	})
+
+	_ = v.RegisterValidation("displayname_unique", func(fl validator.FieldLevel) bool {
+		isFieldUnique, _ := functions.IsNetworkDisplayNameUnique(fl.Field().String())
+		return isFieldUnique
+	})
+
+	err := v.Struct(network)
+
+	if err != nil {
+		for _, e := range err.(validator.ValidationErrors) {
+			fmt.Println(e)
+		}
+	}
+	return err
+}
+
+//Simple get network function
+func getNetwork(w http.ResponseWriter, r *http.Request) {
+
+	// set header.
+	w.Header().Set("Content-Type", "application/json")
+
+	var params = mux.Vars(r)
+
+	var network models.Network
+
+	collection := mongoconn.Client.Database("netmaker").Collection("networks")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+	filter := bson.M{"netid": params["networkname"]}
+	err := collection.FindOne(ctx, filter, options.FindOne().SetProjection(bson.M{"_id": 0})).Decode(&network)
+
+	defer cancel()
+
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(network)
+}
+
+func keyUpdate(w http.ResponseWriter, r *http.Request) {
+
+	w.Header().Set("Content-Type", "application/json")
+
+	var params = mux.Vars(r)
+
+	var network models.Network
+
+	network, err := functions.GetParentNetwork(params["networkname"])
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
+	network.KeyUpdateTimeStamp = time.Now().Unix()
+
+	collection := mongoconn.Client.Database("netmaker").Collection("networks")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+        filter := bson.M{"netid": params["networkname"]}
+        // prepare update model.
+        update := bson.D{
+                {"$set", bson.D{
+                        {"addressrange", network.AddressRange},
+                        {"displayname", network.DisplayName},
+                        {"defaultlistenport", network.DefaultListenPort},
+                        {"defaultpostup", network.DefaultPostUp},
+                        {"defaultpostdown", network.DefaultPostDown},
+                  			{"defaultkeepalive", network.DefaultKeepalive},
+			                  {"keyupdatetimestamp", network.KeyUpdateTimeStamp},
+			                  {"defaultsaveconfig", network.DefaultSaveConfig},
+                  			{"defaultinterface", network.DefaultInterface},
+			                  {"nodeslastmodified", network.NodesLastModified},
+                  			{"networklastmodified", network.NetworkLastModified},
+			                  {"allowmanualsignup", network.AllowManualSignUp},
+			                  {"checkininterval", network.DefaultCheckInInterval},
+		            }},
+	      }
+
+	err = collection.FindOneAndUpdate(ctx, filter, update).Decode(&network)
+
+	defer cancel()
+
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(network)
+}
+
+//Update a network
+func AlertNetwork(netid string) error {
+
+	collection := mongoconn.Client.Database("netmaker").Collection("networks")
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	filter := bson.M{"netid": netid}
+
+	var network models.Network
+
+	network, err := functions.GetParentNetwork(netid)
+	if err != nil {
+		return err
+	}
+	updatetime := time.Now().Unix()
+	update := bson.D{
+		{"$set", bson.D{
+			{"nodeslastmodified", updatetime},
+			{"networklastmodified", updatetime},
+		}},
+	}
+
+	err = collection.FindOneAndUpdate(ctx, filter, update).Decode(&network)
+	defer cancel()
+
+	return err
+}
+
+//Update a network
+func updateNetwork(w http.ResponseWriter, r *http.Request) {
+
+	w.Header().Set("Content-Type", "application/json")
+
+	var params = mux.Vars(r)
+
+	var network models.Network
+
+	network, err := functions.GetParentNetwork(params["networkname"])
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
+	var networkChange models.Network
+
+	haschange := false
+	hasrangeupdate := false
+	haslocalrangeupdate := false
+
+	_ = json.NewDecoder(r.Body).Decode(&networkChange)
+
+	if networkChange.AddressRange == "" {
+		networkChange.AddressRange = network.AddressRange
+	}
+	if networkChange.NetID == "" {
+		networkChange.NetID = network.NetID
+	}
+
+	err = validateNetworkUpdate(networkChange)
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
+		return
+	}
+
+	//NOTE: Network.NetID is intentionally NOT editable. It acts as a static ID for the network.
+	//DisplayName can be changed instead, which is what shows on the front end
+	if networkChange.NetID != network.NetID {
+		returnErrorResponse(w, r, formatError(errors.New("NetID is not editable"), "badrequest"))
+		return
+	}
+	//MRK:  I think this code block is redundant.  valdiateNetworkUpdate(networkChange) covers this
+	if networkChange.AddressRange != "" {
+
+		network.AddressRange = networkChange.AddressRange
+
+		var isAddressOK bool = functions.IsIpv4CIDR(networkChange.AddressRange)
+		if !isAddressOK {
+			err := errors.New("Invalid Range of " + networkChange.AddressRange + " for addresses.")
+			returnErrorResponse(w, r, formatError(err, "internal"))
+			return
+		}
+		haschange = true
+		hasrangeupdate = true
+
+	}
+	if networkChange.LocalRange != "" {
+		network.LocalRange = networkChange.LocalRange
+
+		var isAddressOK bool = functions.IsIpv4CIDR(networkChange.LocalRange)
+		if !isAddressOK {
+			err := errors.New("Invalid Range of " + networkChange.LocalRange + " for internal addresses.")
+			returnErrorResponse(w, r, formatError(err, "internal"))
+			return
+		}
+		haschange = true
+		haslocalrangeupdate = true
+	}
+	if networkChange.IsLocal != nil {
+		network.IsLocal = networkChange.IsLocal
+	}
+	if networkChange.DefaultListenPort != 0 {
+		network.DefaultListenPort = networkChange.DefaultListenPort
+		haschange = true
+	}
+	if networkChange.DefaultPostDown != "" {
+		network.DefaultPostDown = networkChange.DefaultPostDown
+		haschange = true
+	}
+	if networkChange.DefaultInterface != "" {
+		network.DefaultInterface = networkChange.DefaultInterface
+		haschange = true
+	}
+	if networkChange.DefaultPostUp != "" {
+		network.DefaultPostUp = networkChange.DefaultPostUp
+		haschange = true
+	}
+	if networkChange.DefaultKeepalive != 0 {
+		network.DefaultKeepalive = networkChange.DefaultKeepalive
+		haschange = true
+	}
+	if networkChange.DisplayName != "" {
+		network.DisplayName = networkChange.DisplayName
+		haschange = true
+	}
+	if networkChange.DefaultCheckInInterval != 0 {
+		network.DefaultCheckInInterval = networkChange.DefaultCheckInInterval
+		haschange = true
+	}
+	if networkChange.AllowManualSignUp != nil {
+		network.AllowManualSignUp = networkChange.AllowManualSignUp
+		haschange = true
+	}
+
+	collection := mongoconn.Client.Database("netmaker").Collection("networks")
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	filter := bson.M{"netid": params["networkname"]}
+
+	if haschange {
+		network.SetNetworkLastModified()
+	}
+        // prepare update model.
+        update := bson.D{
+                {"$set", bson.D{
+                        {"addressrange", network.AddressRange},
+                        {"displayname", network.DisplayName},
+                        {"defaultlistenport", network.DefaultListenPort},
+                        {"defaultpostup", network.DefaultPostUp},
+                        {"defaultpostdown", network.DefaultPostDown},
+                        {"defaultkeepalive", network.DefaultKeepalive},
+                        {"defaultsaveconfig", network.DefaultSaveConfig},
+                        {"defaultinterface", network.DefaultInterface},
+                        {"nodeslastmodified", network.NodesLastModified},
+                        {"networklastmodified", network.NetworkLastModified},
+                        {"allowmanualsignup", network.AllowManualSignUp},
+                        {"localrange", network.LocalRange},
+                        {"islocal", network.IsLocal},
+                        {"checkininterval", network.DefaultCheckInInterval},
+		              }},
+	}
+
+	err = collection.FindOneAndUpdate(ctx, filter, update).Decode(&network)
+	defer cancel()
+
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
+	//Cycles through nodes and gives them new IP's based on the new range
+	//Pretty cool, but also pretty inefficient currently
+	if hasrangeupdate {
+		err = functions.UpdateNetworkNodeAddresses(params["networkname"])
+		if err != nil {
+			returnErrorResponse(w, r, formatError(err, "internal"))
+			return
+		}
+	}
+	if haslocalrangeupdate {
+		err = functions.UpdateNetworkPrivateAddresses(params["networkname"])
+		if err != nil {
+			returnErrorResponse(w, r, formatError(err, "internal"))
+			return
+		}
+	}
+	returnnetwork, err := functions.GetParentNetwork(network.NetID)
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(returnnetwork)
+}
+
+//Delete a network
+//Will stop you if  there's any nodes associated
+func deleteNetwork(w http.ResponseWriter, r *http.Request) {
+	// Set header
+	w.Header().Set("Content-Type", "application/json")
+
+	var params = mux.Vars(r)
+
+	nodecount, err := functions.GetNetworkNodeNumber(params["networkname"])
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	} else if nodecount > 0 {
+		errorResponse := models.ErrorResponse{
+			Code: http.StatusForbidden, Message: "W1R3: Node check failed. All nodes must be deleted before deleting network.",
+		}
+		returnErrorResponse(w, r, errorResponse)
+		return
+	}
+
+	collection := mongoconn.Client.Database("netmaker").Collection("networks")
+
+	filter := bson.M{"netid": params["networkname"]}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+	deleteResult, err := collection.DeleteOne(ctx, filter)
+
+	defer cancel()
+
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(deleteResult)
+}
+
+//Create a network
+//Pretty simple
+func createNetwork(w http.ResponseWriter, r *http.Request) {
+
+	w.Header().Set("Content-Type", "application/json")
+
+	var network models.Network
+
+	// we decode our body request params
+	err := json.NewDecoder(r.Body).Decode(&network)
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
+	//TODO: Not really doing good validation here. Same as createNode, updateNode, and updateNetwork
+	//Need to implement some better validation across the board
+
+	if network.IsLocal == nil {
+		falsevar := false
+		network.IsLocal = &falsevar
+	}
+
+	err = validateNetworkCreate(network)
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
+		return
+	}
+	network.SetDefaults()
+	network.SetNodesLastModified()
+	network.SetNetworkLastModified()
+	network.KeyUpdateTimeStamp = time.Now().Unix()
+
+	collection := mongoconn.Client.Database("netmaker").Collection("networks")
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+	// insert our network into the network table
+	result, err := collection.InsertOne(ctx, network)
+
+	defer cancel()
+
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(result)
+}
+
+// BEGIN KEY MANAGEMENT SECTION
+
+//TODO: Very little error handling
+//accesskey is created as a json string inside the Network collection item in mongo
+func createAccessKey(w http.ResponseWriter, r *http.Request) {
+
+	w.Header().Set("Content-Type", "application/json")
+
+	var params = mux.Vars(r)
+
+	var network models.Network
+	var accesskey models.AccessKey
+
+	//start here
+	network, err := functions.GetParentNetwork(params["networkname"])
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
+	err = json.NewDecoder(r.Body).Decode(&accesskey)
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
+	if accesskey.Name == "" {
+		accesskey.Name = functions.GenKeyName()
+	}
+	if accesskey.Value == "" {
+		accesskey.Value = functions.GenKey()
+	}
+
+	if accesskey.Uses == 0 {
+		accesskey.Uses = 1
+	}
+	_, gconf, err := functions.GetGlobalConfig()
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
+	privAddr := ""
+	if *network.IsLocal {
+		privAddr = network.LocalRange
+	}
+
+	netID := params["networkname"]
+	address := gconf.ServerGRPC + gconf.PortGRPC
+
+	accessstringdec := address + "|" + netID + "|" + accesskey.Value + "|" + privAddr
+	accesskey.AccessString = base64.StdEncoding.EncodeToString([]byte(accessstringdec))
+
+	network.AccessKeys = append(network.AccessKeys, accesskey)
+
+	collection := mongoconn.Client.Database("netmaker").Collection("networks")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+	// Create filter
+	filter := bson.M{"netid": params["networkname"]}
+
+	// Read update model from body request
+	fmt.Println("Adding key to " + network.NetID)
+
+	// prepare update model.
+	update := bson.D{
+		{"$set", bson.D{
+			{"accesskeys", network.AccessKeys},
+		}},
+	}
+
+	err = collection.FindOneAndUpdate(ctx, filter, update).Decode(&network)
+
+	defer cancel()
+
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(accesskey)
+	//w.Write([]byte(accesskey.AccessString))
+}
+
+//pretty simple get
+func getAccessKeys(w http.ResponseWriter, r *http.Request) {
+
+	// set header.
+	w.Header().Set("Content-Type", "application/json")
+
+	var params = mux.Vars(r)
+
+	var network models.Network
+	//var keys []models.DisplayKey
+	var keys []models.AccessKey
+	collection := mongoconn.Client.Database("netmaker").Collection("networks")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+	filter := bson.M{"netid": params["networkname"]}
+	err := collection.FindOne(ctx, filter, options.FindOne().SetProjection(bson.M{"_id": 0})).Decode(&network)
+
+	defer cancel()
+
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+	keydata, err := json.Marshal(network.AccessKeys)
+
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
+	json.Unmarshal(keydata, &keys)
+
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(keys)
+}
+
+//delete key. Has to do a little funky logic since it's not a collection item
+func deleteAccessKey(w http.ResponseWriter, r *http.Request) {
+
+	w.Header().Set("Content-Type", "application/json")
+
+	var params = mux.Vars(r)
+
+	var network models.Network
+	keyname := params["name"]
+
+	//start here
+	network, err := functions.GetParentNetwork(params["networkname"])
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+	//basically, turn the list of access keys into the list of access keys before and after the item
+	//have not done any error handling for if there's like...1 item. I think it works? need to test.
+	found := false
+	for i := len(network.AccessKeys) - 1; i >= 0; i-- {
+
+		currentkey := network.AccessKeys[i]
+		if currentkey.Name == keyname {
+			network.AccessKeys = append(network.AccessKeys[:i],
+				network.AccessKeys[i+1:]...)
+			found = true
+		}
+	}
+	if !found {
+		err = errors.New("key " + keyname + " does not exist")
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
+		return
+	}
+
+	collection := mongoconn.Client.Database("netmaker").Collection("networks")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+	// Create filter
+	filter := bson.M{"netid": params["networkname"]}
+
+	// prepare update model.
+	update := bson.D{
+		{"$set", bson.D{
+			{"accesskeys", network.AccessKeys},
+		}},
+	}
+
+	err = collection.FindOneAndUpdate(ctx, filter, update).Decode(&network)
+
+	defer cancel()
+
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+	var keys []models.AccessKey
+	keydata, err := json.Marshal(network.AccessKeys)
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
+	json.Unmarshal(keydata, &keys)
+
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(keys)
+}

controllers/nodeGrpcController.go

@@ -3,6 +3,7 @@ package controller
 import (
         "context"
 	"fmt"
+	"strconv"
 	nodepb "github.com/gravitl/netmaker/grpc"
 	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/functions"
@@ -19,9 +20,10 @@ type NodeServiceServer struct {
 func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.ReadNodeReq) (*nodepb.ReadNodeRes, error) {
 	// convert string id (from proto) to mongoDB ObjectId
 	macaddress := req.GetMacaddress()
-        groupName := req.GetGroup()
+        networkName := req.GetNetwork()
+	network, _ := functions.GetParentNetwork(networkName)
 
-	node, err := GetNode(macaddress, groupName)
+	node, err := GetNode(macaddress, networkName)
 
 	if err != nil {
 		return nil, status.Errorf(codes.InvalidArgument, fmt.Sprintf("Something went wrong: %v", err))
@@ -40,16 +42,19 @@ func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.ReadNodeRe
 			Address:  node.Address,
 			Endpoint:  node.Endpoint,
 			Password:  node.Password,
-			Nodegroup:  node.Group,
+			Nodenetwork:  node.Network,
 			Interface:  node.Interface,
 			Localaddress:  node.LocalAddress,
-			Preup:  node.PreUp,
+			Postdown:  node.PostDown,
 			Postup:  node.PostUp,
 			Checkininterval:  node.CheckInInterval,
 			Ispending:  node.IsPending,
 			Publickey:  node.PublicKey,
 			Listenport:  node.ListenPort,
 			Keepalive:  node.PersistentKeepalive,
+                        Islocal:  *network.IsLocal,
+                        Localrange:  network.LocalRange,
+
 		},
 	}
 	return response, nil
@@ -71,13 +76,13 @@ func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.CreateNo
                         PersistentKeepalive:  data.GetKeepalive(),
                         Password:  data.GetPassword(),
                         Interface:  data.GetInterface(),
-                        Group:  data.GetNodegroup(),
+                        Network:  data.GetNodenetwork(),
                         IsPending:  data.GetIspending(),
                         PublicKey:  data.GetPublickey(),
                         ListenPort:  data.GetListenport(),
 	}
 
-        err := ValidateNode("create", node.Group, node)
+        err := ValidateNode("create", node.Network, node)
 
         if err != nil {
                 // return internal gRPC error to be handled later
@@ -85,24 +90,33 @@ func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.CreateNo
         }
 
         //Check to see if key is valid
-        //TODO: Triple inefficient!!! This is the third call to the DB we make for groups
-        validKey := functions.IsKeyValid(node.Group, node.AccessKey)
+        //TODO: Triple inefficient!!! This is the third call to the DB we make for networks
+        validKey := functions.IsKeyValid(node.Network, node.AccessKey)
+        network, err := functions.GetParentNetwork(node.Network)
+        if err != nil {
+                return nil, status.Errorf(codes.NotFound, fmt.Sprintf("Could not find network: %v", err))
+        } else {
+		fmt.Println("Creating node in network " + network.NetID)
+		fmt.Println("Network is local? " + strconv.FormatBool(*network.IsLocal))
+		fmt.Println("Range if local: " + network.LocalRange)
+	}
+
+
 
         if !validKey {
-		group, _ := functions.GetParentGroup(node.Group)
-                //Check to see if group will allow manual sign up
+                //Check to see if network will allow manual sign up
                 //may want to switch this up with the valid key check and avoid a DB call that way.
-                if *group.AllowManualSignUp {
+                if *network.AllowManualSignUp {
                         node.IsPending = true
                 } else  {
 	                return nil, status.Errorf(
 		                codes.Internal,
-				fmt.Sprintf("Invalid key, and group does not allow no-key signups"),
+				fmt.Sprintf("Invalid key, and network does not allow no-key signups"),
 			)
                 }
         }
 
-	node, err = CreateNode(node, node.Group)
+	node, err = CreateNode(node, node.Network)
 
 	if err != nil {
 		// return internal gRPC error to be handled later
@@ -121,16 +135,18 @@ func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.CreateNo
                         Endpoint:  node.Endpoint,
                         Password:  node.Password,
                         Interface:  node.Interface,
-                        Nodegroup:  node.Group,
+                        Nodenetwork:  node.Network,
                         Ispending:  node.IsPending,
                         Publickey:  node.PublicKey,
                         Listenport:  node.ListenPort,
                         Keepalive:  node.PersistentKeepalive,
+                        Islocal:  *network.IsLocal,
+                        Localrange:  network.LocalRange,
 		},
 	}
-        err = SetGroupNodesLastModified(node.Group)
+        err = SetNetworkNodesLastModified(node.Network)
         if err != nil {
-                return nil, status.Errorf(codes.NotFound, fmt.Sprintf("Could not update group last modified date: %v", err))
+                return nil, status.Errorf(codes.NotFound, fmt.Sprintf("Could not update network last modified date: %v", err))
         }
 
 	return response, nil
@@ -147,7 +163,7 @@ func (s *NodeServiceServer) CheckIn(ctx context.Context, req *nodepb.CheckInReq)
                         MacAddress: data.GetMacaddress(),
                         Address:  data.GetAddress(),
                         Endpoint:  data.GetEndpoint(),
-                        Group:  data.GetNodegroup(),
+                        Network:  data.GetNodenetwork(),
                         Password:  data.GetPassword(),
                         LocalAddress:  data.GetLocaladdress(),
                         ListenPort:  data.GetListenport(),
@@ -155,7 +171,7 @@ func (s *NodeServiceServer) CheckIn(ctx context.Context, req *nodepb.CheckInReq)
                         PublicKey:  data.GetPublickey(),
         }
 
-	checkinresponse, err := NodeCheckIn(node, node.Group)
+	checkinresponse, err := NodeCheckIn(node, node.Network)
 
         if err != nil {
                 // return internal gRPC error to be handled later
@@ -171,7 +187,9 @@ func (s *NodeServiceServer) CheckIn(ctx context.Context, req *nodepb.CheckInReq)
                 Checkinresponse: &nodepb.CheckInResponse{
                         Success:  checkinresponse.Success,
                         Needpeerupdate:  checkinresponse.NeedPeerUpdate,
+                        Needdelete:  checkinresponse.NeedDelete,
                         Needconfigupdate:  checkinresponse.NeedConfigUpdate,
+                        Needkeyupdate:  checkinresponse.NeedKeyUpdate,
                         Nodemessage:  checkinresponse.NodeMessage,
                         Ispending:  checkinresponse.IsPending,
                 },
@@ -193,9 +211,9 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.UpdateNo
                         Endpoint:  data.GetEndpoint(),
                         Password:  data.GetPassword(),
                         PersistentKeepalive:  data.GetKeepalive(),
-                        Group:  data.GetNodegroup(),
+                        Network:  data.GetNodenetwork(),
                         Interface:  data.GetInterface(),
-                        PreUp:  data.GetPreup(),
+                        PostDown:  data.GetPostdown(),
                         PostUp:  data.GetPostup(),
                         IsPending:  data.GetIspending(),
                         PublicKey:  data.GetPublickey(),
@@ -205,14 +223,16 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.UpdateNo
 
 	// Convert the Id string to a MongoDB ObjectId
 	macaddress := nodechange.MacAddress
-	groupName := nodechange.Group
+	networkName := nodechange.Network
+        network, _ := functions.GetParentNetwork(networkName)
+
 
-	err := ValidateNode("update", groupName, nodechange)
+	err := ValidateNode("update", networkName, nodechange)
         if err != nil {
                 return nil, err
         }
 
-        node, err := functions.GetNodeByMacAddress(groupName, macaddress)
+        node, err := functions.GetNodeByMacAddress(networkName, macaddress)
         if err != nil {
                return nil, status.Errorf(
                         codes.NotFound,
@@ -238,13 +258,15 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.UpdateNo
                         Endpoint:  newnode.Endpoint,
                         Password:  newnode.Password,
                         Interface:  newnode.Interface,
-                        Preup:  newnode.PreUp,
+                        Postdown:  newnode.PostDown,
                         Postup:  newnode.PostUp,
-                        Nodegroup:  newnode.Group,
+                        Nodenetwork:  newnode.Network,
                         Ispending:  newnode.IsPending,
                         Publickey:  newnode.PublicKey,
                         Listenport:  newnode.ListenPort,
                         Keepalive:  newnode.PersistentKeepalive,
+                        Islocal:  *network.IsLocal,
+                        Localrange:  network.LocalRange,
 
 		},
 	}, nil
@@ -253,9 +275,9 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.UpdateNo
 func (s *NodeServiceServer) DeleteNode(ctx context.Context, req *nodepb.DeleteNodeReq) (*nodepb.DeleteNodeRes, error) {
 	fmt.Println("beginning node delete")
 	macaddress := req.GetMacaddress()
-	group := req.GetGroupName()
+	network := req.GetNetworkName()
 
-	success, err := DeleteNode(macaddress, group)
+	success, err := DeleteNode(macaddress, network)
 
 	if err != nil || !success {
 		fmt.Println("Error deleting node.")
@@ -263,12 +285,12 @@ func (s *NodeServiceServer) DeleteNode(ctx context.Context, req *nodepb.DeleteNo
 		return nil, status.Errorf(codes.NotFound, fmt.Sprintf("Could not find/delete node with mac address %s", macaddress))
 	}
 
-	fmt.Println("updating group last modified of " + req.GetGroupName())
-	err = SetGroupNodesLastModified(req.GetGroupName())
+	fmt.Println("updating network last modified of " + req.GetNetworkName())
+	err = SetNetworkNodesLastModified(req.GetNetworkName())
         if err != nil {
-		fmt.Println("Error updating Group")
+		fmt.Println("Error updating Network")
 		fmt.Println(err)
-		return nil, status.Errorf(codes.NotFound, fmt.Sprintf("Could not update group last modified date: %v", err))
+		return nil, status.Errorf(codes.NotFound, fmt.Sprintf("Could not update network last modified date: %v", err))
         }
 
 
@@ -282,7 +304,7 @@ func (s *NodeServiceServer) GetPeers(req *nodepb.GetPeersReq, stream nodepb.Node
 	//data := &models.PeersResponse{}
 	// collection.Find returns a cursor for our (empty) query
 	//cursor, err := s.NodeDB.Find(context.Background(), bson.M{})
-	peers, err := GetPeersList(req.GetGroup())
+	peers, err := GetPeersList(req.GetNetwork())
 
 	if err != nil {
 		return status.Errorf(codes.Internal, fmt.Sprintf("Unknown internal error: %v", err))
@@ -295,6 +317,8 @@ func (s *NodeServiceServer) GetPeers(req *nodepb.GetPeersReq, stream nodepb.Node
 			Peers: &nodepb.PeersResponse{
                             Address:  peers[i].Address,
                             Endpoint:  peers[i].Endpoint,
+                            Gatewayrange:  peers[i].GatewayRange,
+                            Isgateway:  peers[i].IsGateway,
                             Publickey:  peers[i].PublicKey,
                             Keepalive:  peers[i].KeepAlive,
                             Listenport:  peers[i].ListenPort,
@@ -303,7 +327,7 @@ func (s *NodeServiceServer) GetPeers(req *nodepb.GetPeersReq, stream nodepb.Node
 		})
 	}
 
-	node, err := functions.GetNodeByMacAddress(req.GetGroup(), req.GetMacaddress())
+	node, err := functions.GetNodeByMacAddress(req.GetNetwork(), req.GetMacaddress())
        if err != nil {
                 return status.Errorf(codes.Internal, fmt.Sprintf("Could not get node: %v", err))
         }

controllers/nodeHttpController.go

@@ -2,6 +2,7 @@ package controller
 
 import (
     "github.com/gravitl/netmaker/models"
+    "errors"
     "github.com/gravitl/netmaker/functions"
     "github.com/gravitl/netmaker/mongoconn"
     "golang.org/x/crypto/bcrypt"
@@ -10,7 +11,6 @@ import (
     "fmt"
     "context"
     "encoding/json"
-    "log"
     "net/http"
     "github.com/gorilla/mux"
     "go.mongodb.org/mongo-driver/bson"
@@ -20,17 +20,18 @@ import (
 
 func nodeHandlers(r *mux.Router) {
 
-    r.HandleFunc("/api/{group}/nodes", authorize(true, "group", http.HandlerFunc(getGroupNodes))).Methods("GET")
     r.HandleFunc("/api/nodes", authorize(false, "master", http.HandlerFunc(getAllNodes))).Methods("GET")
-    r.HandleFunc("/api/{group}/peerlist", authorize(true, "group", http.HandlerFunc(getPeerList))).Methods("GET")
-    r.HandleFunc("/api/{group}/lastmodified", authorize(true, "group", http.HandlerFunc(getLastModified))).Methods("GET")
-    r.HandleFunc("/api/{group}/nodes/{macaddress}", authorize(true, "node", http.HandlerFunc(getNode))).Methods("GET")
-    r.HandleFunc("/api/{group}/nodes", createNode).Methods("POST")
-    r.HandleFunc("/api/{group}/nodes/{macaddress}", authorize(true, "node", http.HandlerFunc(updateNode))).Methods("PUT")
-    r.HandleFunc("/api/{group}/nodes/{macaddress}/checkin", authorize(true, "node", http.HandlerFunc(checkIn))).Methods("POST")
-    r.HandleFunc("/api/{group}/nodes/{macaddress}/uncordon", authorize(true, "master", http.HandlerFunc(uncordonNode))).Methods("POST")
-    r.HandleFunc("/api/{group}/nodes/{macaddress}", authorize(true, "node", http.HandlerFunc(deleteNode))).Methods("DELETE")
-    r.HandleFunc("/api/{group}/authenticate", authenticate).Methods("POST")
+    r.HandleFunc("/api/nodes/{network}", authorize(true, "network", http.HandlerFunc(getNetworkNodes))).Methods("GET")
+    r.HandleFunc("/api/nodes/{network}/{macaddress}", authorize(true, "node", http.HandlerFunc(getNode))).Methods("GET")
+    r.HandleFunc("/api/nodes/{network}/{macaddress}", authorize(true, "node", http.HandlerFunc(updateNode))).Methods("PUT")
+    r.HandleFunc("/api/nodes/{network}/{macaddress}", authorize(true, "node", http.HandlerFunc(deleteNode))).Methods("DELETE")
+    r.HandleFunc("/api/nodes/{network}/{macaddress}/checkin", authorize(true, "node", http.HandlerFunc(checkIn))).Methods("POST")
+    r.HandleFunc("/api/nodes/{network}/{macaddress}/creategateway", authorize(true, "master", http.HandlerFunc(createGateway))).Methods("POST")
+    r.HandleFunc("/api/nodes/{network}/{macaddress}/deletegateway", authorize(true, "master", http.HandlerFunc(deleteGateway))).Methods("DELETE")
+    r.HandleFunc("/api/nodes/{network}/{macaddress}/approve", authorize(true, "master", http.HandlerFunc(uncordonNode))).Methods("POST")
+    r.HandleFunc("/api/nodes/{network}", createNode).Methods("POST")
+    r.HandleFunc("/api/nodes/adm/{network}/lastmodified", authorize(true, "network", http.HandlerFunc(getLastModified))).Methods("GET")
+    r.HandleFunc("/api/nodes/adm/{network}/authenticate", authenticate).Methods("POST")
 
 }
 
@@ -67,7 +68,7 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
        } else {
 
             //Search DB for node with Mac Address. Ignore pending nodes (they should not be able to authenticate with API untill approved).
-            collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+            collection := mongoconn.Client.Database("netmaker").Collection("nodes")
             ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	    var err = collection.FindOne(ctx, bson.M{ "macaddress": authRequest.MacAddress, "ispending": false }).Decode(&result)
 
@@ -87,7 +88,7 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
 		   return
 	   } else {
 		//Create a new JWT for the node
-                tokenString, _ := functions.CreateJWT(authRequest.MacAddress, result.Group)
+                tokenString, _ := functions.CreateJWT(authRequest.MacAddress, result.Network)
 
                 if tokenString == "" {
                     returnErrorResponse(response, request, errorResponse)
@@ -109,6 +110,7 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
                     returnErrorResponse(response, request, errorResponse)
 		    return
                 }
+	        response.WriteHeader(http.StatusOK)
                 response.Header().Set("Content-Type", "application/json")
                 response.Write(successJSONResponse)
             }
@@ -119,11 +121,11 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
 //The middleware for most requests to the API
 //They all pass  through here first
 //This will validate the JWT (or check for master token)
-//This will also check against the authGroup and make sure the node should be accessing that endpoint,
+//This will also check against the authNetwork and make sure the node should be accessing that endpoint,
 //even if it's technically ok
 //This is kind of a poor man's RBAC. There's probably a better/smarter way.
 //TODO: Consider better RBAC implementations
-func authorize(groupCheck bool, authGroup string, next http.Handler) http.HandlerFunc {
+func authorize(networkCheck bool, authNetwork string, next http.Handler) http.HandlerFunc {
         return func(w http.ResponseWriter, r *http.Request) {
 
                 var errorResponse = models.ErrorResponse{
@@ -132,13 +134,13 @@ func authorize(groupCheck bool, authGroup string, next http.Handler) http.Handle
 
 		var params = mux.Vars(r)
 
-		groupexists, _ := functions.GroupExists(params["group"])
+		networkexists, _ := functions.NetworkExists(params["network"])
 
-		//check that the request is for a valid group
-                //if (groupCheck && !groupexists) || err != nil {
-                if (groupCheck && !groupexists) {
+		//check that the request is for a valid network
+                //if (networkCheck && !networkexists) || err != nil {
+                if (networkCheck && !networkexists) {
                         errorResponse = models.ErrorResponse{
-                                Code: http.StatusNotFound, Message: "W1R3: This group does not exist. ",
+                                Code: http.StatusNotFound, Message: "W1R3: This network does not exist. ",
                         }
                         returnErrorResponse(w, r, errorResponse)
 			return
@@ -188,15 +190,15 @@ func authorize(groupCheck bool, authGroup string, next http.Handler) http.Handle
 			isAuthorized = true
 
 		//for everyone else, there's poor man's RBAC. The "cases" are defined in the routes in the handlers
-		//So each route defines which access group should be allowed to access it
+		//So each route defines which access network should be allowed to access it
 		} else {
-			switch authGroup {
+			switch authNetwork {
 			case "all":
 				isAuthorized = true
                         case "nodes":
 				isAuthorized = (macaddress != "")
-                        case "group":
-                                node, err := functions.GetNodeByMacAddress(params["group"], macaddress)
+                        case "network":
+                                node, err := functions.GetNodeByMacAddress(params["network"], macaddress)
 		                if err != nil {
 					errorResponse = models.ErrorResponse{
 					Code: http.StatusUnauthorized, Message: "W1R3: Missing Auth Token.",
@@ -204,7 +206,7 @@ func authorize(groupCheck bool, authGroup string, next http.Handler) http.Handle
 					returnErrorResponse(w, r, errorResponse)
 					return
 		                }
-                                isAuthorized = (node.Group == params["group"])
+                                isAuthorized = (node.Network == params["network"])
 			case "node":
 				isAuthorized = (macaddress == params["macaddress"])
                         case "master":
@@ -227,98 +229,43 @@ func authorize(groupCheck bool, authGroup string, next http.Handler) http.Handle
 	}
 }
 
-//Returns a list of peers in "plaintext" format, which can be piped straight to a file (peers.conf) on a local machine
-//Not sure if it would be better to do that here or to let the client handle the formatting.
-//TODO: May want to consider a different approach
-func getPeerList(w http.ResponseWriter, r *http.Request) {
-        w.Header().Set("Content-Type", "application/json")
-
-        var nodes []models.Node
-	var params = mux.Vars(r)
-
-        //Connection mongoDB with mongoconn class
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
-
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-
-	//Get all nodes in the relevant group which are NOT in pending state
-        filter := bson.M{"group": params["group"], "ispending": false}
-        cur, err := collection.Find(ctx, filter)
-
-        if err != nil {
-                mongoconn.GetError(err, w)
-                return
-        }
-
-        // Close the cursor once finished and cancel if it takes too long
-	defer cancel()
-
-        for cur.Next(context.TODO()) {
-
-                var node models.Node
-                err := cur.Decode(&node)
-                if err != nil {
-                        log.Fatal(err)
-                }
-
-                // add the node to our node array
-		//maybe better to just return this? But then that's just GetNodes...
-                nodes = append(nodes, node)
-        }
-
-	//Uh oh, fatal error! This needs some better error handling
-	//TODO: needs appropriate error handling so the server doesnt shut down.
-        if err := cur.Err(); err != nil {
-                log.Fatal(err)
-        }
-
-	//Writes output in the style familiar to WireGuard
-	//Get's piped to peers.conf locally after client request
-	for _, n := range nodes {
-		w.Write([]byte("[Peer] \n"))
-	        w.Write([]byte("PublicKey = " + n.PublicKey + "\n"))
-	        w.Write([]byte("AllowedIPs = " + n.Address + "/32" + "\n"))
-	        w.Write([]byte("PersistentKeepalive = " + fmt.Sprint(n.PersistentKeepalive) + "\n"))
-		w.Write([]byte("Endpoint = " + n.Endpoint + ":" + fmt.Sprint(n.ListenPort) + "\n\n"))
-	}
-}
-
-//Gets all nodes associated with group, including pending nodes
-func getGroupNodes(w http.ResponseWriter, r *http.Request) {
+//Gets all nodes associated with network, including pending nodes
+func getNetworkNodes(w http.ResponseWriter, r *http.Request) {
 
 	w.Header().Set("Content-Type", "application/json")
 
 	var nodes []models.ReturnNode
 	var params = mux.Vars(r)
 
-	collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+	collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        filter := bson.M{"group": params["group"]}
+        filter := bson.M{"network": params["network"]}
 
 	//Filtering out the ID field cuz Dillon doesn't like it. May want to filter out other fields in the future
 	cur, err := collection.Find(ctx, filter, options.Find().SetProjection(bson.M{"_id": 0}))
 
-	if err != nil {
-		mongoconn.GetError(err, w)
-		return
-	}
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
 
 	defer cancel()
 
 	for cur.Next(context.TODO()) {
 
 		//Using a different model for the ReturnNode (other than regular node).
-		//Either we should do this for ALL structs (so Groups and Keys)
+		//Either we should do this for ALL structs (so Networks and Keys)
 		//OR we should just use the original struct
 		//My preference is to make some new return structs
 		//TODO: Think about this. Not an immediate concern. Just need to get some consistency eventually
 		var node models.ReturnNode
 
 		err := cur.Decode(&node)
-		if err != nil {
-			log.Fatal(err)
+	        if err != nil {
+			returnErrorResponse(w,r,formatError(err, "internal"))
+			return
 		}
 
 		// add item our array of nodes
@@ -327,15 +274,17 @@ func getGroupNodes(w http.ResponseWriter, r *http.Request) {
 
 	//TODO: Another fatal error we should take care of.
 	if err := cur.Err(); err != nil {
-		log.Fatal(err)
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
 	}
 
 	//Returns all the nodes in JSON format
+        w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(nodes)
 
 }
 
-//A separate function to get all nodes, not just nodes for a particular group.
+//A separate function to get all nodes, not just nodes for a particular network.
 //Not quite sure if this is necessary. Probably necessary based on front end but may want to review after iteration 1 if it's being used or not
 func getAllNodes(w http.ResponseWriter, r *http.Request) {
 
@@ -343,15 +292,14 @@ func getAllNodes(w http.ResponseWriter, r *http.Request) {
 
         var nodes []models.ReturnNode
 
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
 	// Filter out them ID's again
 	cur, err := collection.Find(ctx, bson.M{}, options.Find().SetProjection(bson.M{"_id": 0}))
-
         if err != nil {
-                mongoconn.GetError(err, w)
+                returnErrorResponse(w,r,formatError(err, "internal"))
                 return
         }
 
@@ -361,37 +309,38 @@ func getAllNodes(w http.ResponseWriter, r *http.Request) {
 
                 var node models.ReturnNode
                 err := cur.Decode(&node)
-
-		//TODO: Fatal error
-                if err != nil {
-                        log.Fatal(err)
-                }
-
+	        if err != nil {
+		        returnErrorResponse(w,r,formatError(err, "internal"))
+			return
+		}
                 // add node to our array
                 nodes = append(nodes, node)
         }
 
 	//TODO: Fatal error
         if err := cur.Err(); err != nil {
-                log.Fatal(err)
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
         }
+
 	//Return all the nodes in JSON format
-        json.NewEncoder(w).Encode(nodes)
+        w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(nodes)
 
 }
 
 //This function get's called when a node "checks in" at check in interval
 //Honestly I'm not sure what all it should be doing
 //TODO: Implement the necessary stuff, including the below
-//Check the last modified of the group
+//Check the last modified of the network
 //Check the last modified of the nodes
 //Write functions for responding to these two thingies
 func checkIn(w http.ResponseWriter, r *http.Request) {
 
 	//TODO: Current thoughts:
-	//Dont bother with a grouplastmodified
+	//Dont bother with a networklastmodified
 	//Instead, implement a "configupdate" boolean on nodes
-	//when there is a group update  that requrires  a config update,  then the node will pull its new config
+	//when there is a network update  that requrires  a config update,  then the node will pull its new config
 
         // set header.
         w.Header().Set("Content-Type", "application/json")
@@ -402,13 +351,13 @@ func checkIn(w http.ResponseWriter, r *http.Request) {
 
 
 	//Retrieves node with DB Call which is inefficient. Let's just get the time and set it.
-	//node = functions.GetNodeByMacAddress(params["group"], params["macaddress"])
+	//node = functions.GetNodeByMacAddress(params["network"], params["macaddress"])
 
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        filter := bson.M{"macaddress": params["macaddress"]}
+        filter := bson.M{"macaddress": params["macaddress"], "network": params["network"]}
 
 	//old code was inefficient, this is all we need.
 	time := time.Now().String()
@@ -422,16 +371,18 @@ func checkIn(w http.ResponseWriter, r *http.Request) {
                 }},
         }
 
-        errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&node)
+        err := collection.FindOneAndUpdate(ctx, filter, update).Decode(&node)
 
         defer cancel()
 
-        if errN != nil {
-                mongoconn.GetError(errN, w)
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
                 return
         }
-	//TODO: check node last modified vs group last modified
-        json.NewEncoder(w).Encode(node)
+
+	//TODO: check node last modified vs network last modified
+        w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(node)
 
 }
 
@@ -442,42 +393,42 @@ func getNode(w http.ResponseWriter, r *http.Request) {
 
         var params = mux.Vars(r)
 
-	node, err := GetNode(params["macaddress"], params["group"])
-
-	if err != nil {
-		mongoconn.GetError(err, w)
-		return
-	}
-
+	node, err := GetNode(params["macaddress"], params["network"])
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
+	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
 }
 
-//Get the time that a group of nodes was last modified.
+//Get the time that a network of nodes was last modified.
 //TODO: This needs to be refactored
 //Potential way to do this: On UpdateNode, set a new field for "LastModified"
-//If we go with the existing way, we need to at least set group.NodesLastModified on UpdateNode
+//If we go with the existing way, we need to at least set network.NodesLastModified on UpdateNode
 func getLastModified(w http.ResponseWriter, r *http.Request) {
         // set header.
         w.Header().Set("Content-Type", "application/json")
 
-        var group models.Group
+        var network models.Network
         var params = mux.Vars(r)
 
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
+        collection := mongoconn.Client.Database("netmaker").Collection("networks")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        filter := bson.M{"nameid": params["group"]}
-        err := collection.FindOne(ctx, filter).Decode(&group)
+        filter := bson.M{"netid": params["network"]}
+        err := collection.FindOne(ctx, filter).Decode(&network)
 
 	defer cancel()
 
-	if err != nil {
-		fmt.Println(err)
-		//log.Fatal(err)
-	}
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
 
-	w.Write([]byte(string(group.NodesLastModified)))
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte(string(network.NodesLastModified)))
 
 }
 
@@ -493,17 +444,19 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 	        Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
 	}
 
-        groupName := params["group"]
+        networkName := params["network"]
 
-	//Check if group exists  first
+	//Check if network exists  first
 	//TODO: This is inefficient. Let's find a better way. 
-	//Just a few rows down we grab the group anyway
-        groupexists, errgroup := functions.GroupExists(groupName)
+	//Just a few rows down we grab the network anyway
+        networkexists, err := functions.NetworkExists(networkName)
 
-
-        if !groupexists || errgroup != nil {
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        } else if !networkexists {
                 errorResponse = models.ErrorResponse{
-                        Code: http.StatusNotFound, Message: "W1R3: Group does not exist! ",
+                        Code: http.StatusNotFound, Message: "W1R3: Network does not exist! ",
                 }
                 returnErrorResponse(w, r, errorResponse)
                 return
@@ -512,21 +465,29 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 	var node models.Node
 
 	//get node from body of request
-	_ = json.NewDecoder(r.Body).Decode(&node)
+	err = json.NewDecoder(r.Body).Decode(&node)
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
 
-	node.Group = groupName
+	node.Network = networkName
 
 
-	group, _ := node.GetGroup()
+	network, err := node.GetNetwork()
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
 
 	//Check to see if key is valid
-	//TODO: Triple inefficient!!! This is the third call to the DB we make for groups
-	validKey := functions.IsKeyValid(groupName, node.AccessKey)
+	//TODO: Triple inefficient!!! This is the third call to the DB we make for networks
+	validKey := functions.IsKeyValid(networkName, node.AccessKey)
 
 	if !validKey {
-		//Check to see if group will allow manual sign up
+		//Check to see if network will allow manual sign up
 		//may want to switch this up with the valid key check and avoid a DB call that way.
-		if *group.AllowManualSignUp {
+		if *network.AllowManualSignUp {
 			node.IsPending = true
 		} else  {
 			errorResponse = models.ErrorResponse{
@@ -537,16 +498,18 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	err :=  ValidateNode("create", groupName, node)
+	err =  ValidateNode("create", networkName, node)
         if err != nil {
-		return
+                returnErrorResponse(w,r,formatError(err, "badrequest"))
+                return
         }
 
-        node, err = CreateNode(node, groupName)
+        node, err = CreateNode(node, networkName)
         if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
                 return
         }
-
+	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
 }
 
@@ -559,18 +522,18 @@ func uncordonNode(w http.ResponseWriter, r *http.Request) {
 
         var node models.Node
 
-	node, err := functions.GetNodeByMacAddress(params["group"], params["macaddress"])
+	node, err := functions.GetNodeByMacAddress(params["network"], params["macaddress"])
         if err != nil {
-                mongoconn.GetError(err, w)
-		return
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
         }
 
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
         // Create filter
-        filter := bson.M{"macaddress": params["macaddress"]}
+	filter := bson.M{"macaddress": params["macaddress"], "network": params["network"]}
 
         node.SetLastModified()
 
@@ -583,18 +546,171 @@ func uncordonNode(w http.ResponseWriter, r *http.Request) {
                 }},
         }
 
-        errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&node)
+        err = collection.FindOneAndUpdate(ctx, filter, update).Decode(&node)
 
         defer cancel()
 
-        if errN != nil {
-                mongoconn.GetError(errN, w)
+	if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
                 return
         }
+
         fmt.Println("Node " + node.Name + " uncordoned.")
+	w.WriteHeader(http.StatusOK)
+        json.NewEncoder(w).Encode("SUCCESS")
+}
 
+func createGateway(w http.ResponseWriter, r *http.Request) {
+        w.Header().Set("Content-Type", "application/json")
 
-        json.NewEncoder(w).Encode("SUCCESS")
+        var params = mux.Vars(r)
+
+        var gateway models.GatewayRequest
+
+	err := json.NewDecoder(r.Body).Decode(&gateway)
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
+	gateway.NetID = params["network"]
+	gateway.NodeID = params["macaddress"]
+
+        node, err := functions.GetNodeByMacAddress(params["network"], params["macaddress"])
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
+
+	err = validateGateway(gateway)
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
+
+        var nodechange models.Node
+
+	nodechange.IsGateway = true
+	nodechange.GatewayRange = gateway.RangeString
+	if gateway.PostUp == "" {
+		nodechange.PostUp = "iptables -A FORWARD -i " + node.Interface + " -j ACCEPT; iptables -t nat -A POSTROUTING -o " + gateway.Interface + " -j MASQUERADE"
+	} else {
+		nodechange.PostUp = gateway.PostUp
+	}
+	if gateway.PostDown == "" {
+		nodechange.PostDown = "iptables -D FORWARD -i " + node.Interface + " -j ACCEPT; iptables -t nat -D POSTROUTING -o " + gateway.Interface + " -j MASQUERADE"
+	} else {
+		nodechange.PostDown = gateway.PostDown
+	}
+
+       collection := mongoconn.Client.Database("netmaker").Collection("nodes")
+
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+        // Create filter
+        filter := bson.M{"macaddress": params["macaddress"], "network": params["network"]}
+
+        nodechange.SetLastModified()
+
+        // prepare update model.
+        update := bson.D{
+                {"$set", bson.D{
+                        {"postup", nodechange.PostUp},
+                        {"postdown", nodechange.PostDown},
+                        {"isgateway", nodechange.IsGateway},
+                        {"gatewayrange", nodechange.GatewayRange},
+			{"lastmodified", nodechange.LastModified},
+                }},
+        }
+        var nodeupdate models.Node
+
+        err = collection.FindOneAndUpdate(ctx, filter, update).Decode(&nodeupdate)
+
+        defer cancel()
+
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
+
+        err = SetNetworkNodesLastModified(params["network"])
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
+
+        w.WriteHeader(http.StatusOK)
+        json.NewEncoder(w).Encode(node)
+}
+
+func validateGateway(gateway models.GatewayRequest) error {
+		var err error
+                isIpv4 := functions.IsIpv4CIDR(gateway.RangeString)
+                empty := gateway.RangeString == ""
+                if empty || !isIpv4 {
+			err = errors.New("IP Range Not Valid")
+		}
+		return err
+}
+
+
+
+
+func deleteGateway(w http.ResponseWriter, r *http.Request) {
+        w.Header().Set("Content-Type", "application/json")
+
+        var params = mux.Vars(r)
+
+        node, err := functions.GetNodeByMacAddress(params["network"], params["macaddress"])
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
+
+        var nodechange models.Node
+
+        nodechange.IsGateway = false
+        nodechange.GatewayRange = ""
+        nodechange.PostUp = ""
+        nodechange.PostDown = ""
+
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
+
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+        // Create filter
+        filter := bson.M{"macaddress": params["macaddress"], "network": params["network"]}
+
+        nodechange.SetLastModified()
+
+        // prepare update model.
+        update := bson.D{
+                {"$set", bson.D{
+                        {"postup", nodechange.PostUp},
+                        {"postdown", nodechange.PostDown},
+                        {"isgateway", nodechange.IsGateway},
+                        {"gatewayrange", nodechange.GatewayRange},
+                        {"lastmodified", nodechange.LastModified},
+                }},
+        }
+        var nodeupdate models.Node
+
+        err = collection.FindOneAndUpdate(ctx, filter, update).Decode(&nodeupdate)
+
+        defer cancel()
+
+	if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
+
+        err = SetNetworkNodesLastModified(params["network"])
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
+
+        w.WriteHeader(http.StatusOK)
+        json.NewEncoder(w).Encode(node)
 }
 
 
@@ -609,38 +725,37 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 	var node models.Node
 
 	//start here
-	node, err := functions.GetNodeByMacAddress(params["group"], params["macaddress"])
+	node, err := functions.GetNodeByMacAddress(params["network"], params["macaddress"])
         if err != nil {
-                json.NewEncoder(w).Encode(err)
+                returnErrorResponse(w,r,formatError(err, "internal"))
                 return
         }
 
 
+
         var nodechange models.Node
 
         // we decode our body request params
         _ = json.NewDecoder(r.Body).Decode(&nodechange)
-	if nodechange.Group == "" {
-	        nodechange.Group = node.Group
+	if nodechange.Network == "" {
+	        nodechange.Network = node.Network
 	}
 	if nodechange.MacAddress == "" {
 		nodechange.MacAddress = node.MacAddress
 	}
 
-        err = ValidateNode("update", params["group"], nodechange)
-
+        err = ValidateNode("update", params["network"], nodechange)
         if err != nil {
-                json.NewEncoder(w).Encode(err)
+                returnErrorResponse(w,r,formatError(err, "badrequest"))
                 return
         }
 
 	node, err = UpdateNode(nodechange, node)
-
-	if err != nil {
-                json.NewEncoder(w).Encode(err)
-		return
-	}
-
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
+	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
 }
 
@@ -653,31 +768,16 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
 	// get params
 	var params = mux.Vars(r)
 
-	success, err := DeleteNode(params["macaddress"], params["group"])
+	success, err := DeleteNode(params["macaddress"], params["network"])
 
-	if err != nil || !success {
-		json.NewEncoder(w).Encode("Could not delete node " + params["macaddress"])
+	if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        } else if !success {
+		err = errors.New("Could not delete node " + params["macaddress"])
+                returnErrorResponse(w,r,formatError(err, "internal"))
 		return
 	}
-
+	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(params["macaddress"] + " deleted.")
 }
-
-//A fun lil method for handling errors with http
-//Used in some cases but not others
-//1. This should probably be an application-wide function
-//2. All the API calls should probably be using this
-//3. The mongoconn should probably use this.
-//4. Need a consistent approach to error handling generally. Very haphazard at the moment
-//TODO: This is important. All Handlers  should be replying with appropriate error code.
-func returnErrorResponse(response http.ResponseWriter, request *http.Request, errorMesage models.ErrorResponse) {
-        httpResponse := &models.ErrorResponse{Code: errorMesage.Code, Message: errorMesage.Message}
-        jsonResponse, err := json.Marshal(httpResponse)
-        if err != nil {
-                panic(err)
-        }
-        response.Header().Set("Content-Type", "application/json")
-        response.WriteHeader(errorMesage.Code)
-        response.Write(jsonResponse)
-}
-

controllers/responseHttp.go

@@ -0,0 +1,49 @@
+package controller
+
+import (
+    "github.com/gravitl/netmaker/models"
+    "encoding/json"
+    "net/http"
+    "fmt"
+)
+
+func formatError(err error, errType string) models.ErrorResponse {
+
+	var status = http.StatusInternalServerError
+	switch errType {
+	case "internal":
+		status = http.StatusInternalServerError
+	case "badrequest":
+		status  = http.StatusBadRequest
+	case "notfound":
+		status = http.StatusNotFound
+	case "unauthorized":
+		status = http.StatusUnauthorized
+	case "forbidden":
+		status = http.StatusForbidden
+	default:
+		status = http.StatusInternalServerError
+	}
+
+        var response = models.ErrorResponse{
+                Message: err.Error(),
+                Code: status,
+        }
+	return response
+}
+
+func returnSuccessResponse(response http.ResponseWriter, request *http.Request, errorMesage models.ErrorResponse) {
+
+}
+
+func returnErrorResponse(response http.ResponseWriter, request *http.Request, errorMessage models.ErrorResponse) {
+        httpResponse := &models.ErrorResponse{Code: errorMessage.Code, Message: errorMessage.Message}
+        jsonResponse, err := json.Marshal(httpResponse)
+        if err != nil {
+                panic(err)
+        }
+	fmt.Println(errorMessage)
+        response.Header().Set("Content-Type", "application/json")
+        response.WriteHeader(errorMessage.Code)
+        response.Write(jsonResponse)
+}

controllers/serverHttpController.go

@@ -0,0 +1,90 @@
+package controller
+
+import (
+    "github.com/gravitl/netmaker/models"
+    "github.com/gravitl/netmaker/serverctl"
+    "github.com/gravitl/netmaker/config"
+    "encoding/json"
+    "strings"
+    "net/http"
+    "github.com/gorilla/mux"
+)
+
+func serverHandlers(r *mux.Router) {
+    r.HandleFunc("/api/server/addnetwork/{network}", securityCheckServer(http.HandlerFunc(addNetwork))).Methods("POST")
+    r.HandleFunc("/api/server/removenetwork/{network}", securityCheckServer(http.HandlerFunc(removeNetwork))).Methods("DELETE")
+}
+
+//Security check is middleware for every function and just checks to make sure that its the master calling
+//Only admin should have access to all these network-level actions
+//or maybe some Users once implemented
+func securityCheckServer(next http.Handler) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var errorResponse = models.ErrorResponse{
+			Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
+		}
+
+		bearerToken := r.Header.Get("Authorization")
+
+		var hasBearer = true
+		var tokenSplit = strings.Split(bearerToken, " ")
+		var  authToken = ""
+
+		if len(tokenSplit) < 2 {
+			hasBearer = false
+		} else {
+			authToken = tokenSplit[1]
+		}
+		//all endpoints here require master so not as complicated
+		//still might not be a good  way of doing this
+		if !hasBearer || !authenticateMasterServer(authToken) {
+			errorResponse = models.ErrorResponse{
+				Code: http.StatusUnauthorized, Message: "W1R3: You are unauthorized to access this endpoint.",
+			}
+			returnErrorResponse(w, r, errorResponse)
+		} else {
+			next.ServeHTTP(w, r)
+		}
+	}
+}
+//Consider a more secure way of setting master key
+func authenticateMasterServer(tokenString string) bool {
+    if tokenString == config.Config.Server.MasterKey {
+        return true
+    }
+    return false
+}
+
+func removeNetwork(w http.ResponseWriter, r *http.Request) {
+        // Set header
+        w.Header().Set("Content-Type", "application/json")
+
+        // get params
+        var params = mux.Vars(r)
+
+        success, err := serverctl.RemoveNetwork(params["network"])
+
+        if err != nil || !success {
+                json.NewEncoder(w).Encode("Could not remove server from network " + params["network"])
+                return
+        }
+
+        json.NewEncoder(w).Encode("Server removed from network " + params["network"])
+}
+
+func addNetwork(w http.ResponseWriter, r *http.Request) {
+        // Set header
+        w.Header().Set("Content-Type", "application/json")
+
+        // get params
+        var params = mux.Vars(r)
+
+        success, err := serverctl.AddNetwork(params["network"])
+
+        if err != nil || !success {
+                json.NewEncoder(w).Encode("Could not add server to network " + params["network"])
+                return
+        }
+
+        json.NewEncoder(w).Encode("Server added to network " + params["network"])
+}

controllers/userHttpController.go

@@ -1,150 +1,151 @@
 package controller
 
 import (
-    "gopkg.in/go-playground/validator.v9"
-    "github.com/gravitl/netmaker/models"
-    "github.com/gravitl/netmaker/functions"
-    "github.com/gravitl/netmaker/mongoconn"
-    "golang.org/x/crypto/bcrypt"
-    "time"
-    "strings"
-    "fmt"
-    "context"
-    "encoding/json"
-    "net/http"
-    "github.com/gorilla/mux"
-    "go.mongodb.org/mongo-driver/bson"
-    "go.mongodb.org/mongo-driver/mongo/options"
-    "go.mongodb.org/mongo-driver/mongo"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gorilla/mux"
+	"github.com/gravitl/netmaker/functions"
+	"github.com/gravitl/netmaker/models"
+	"github.com/gravitl/netmaker/mongoconn"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"golang.org/x/crypto/bcrypt"
+	"gopkg.in/go-playground/validator.v9"
 )
 
-
 func userHandlers(r *mux.Router) {
 
-    r.HandleFunc("/users/hasadmin", hasAdmin).Methods("GET")
-    r.HandleFunc("/users/createadmin", createAdmin).Methods("POST")
-    r.HandleFunc("/users/{username}", authorizeUser(http.HandlerFunc(updateUser))).Methods("PUT")
-    r.HandleFunc("/users/{username}", authorizeUser(http.HandlerFunc(deleteUser))).Methods("DELETE")
-    r.HandleFunc("/users/{username}", authorizeUser(http.HandlerFunc(getUser))).Methods("GET")
-    r.HandleFunc("/users/authenticate", authenticateUser).Methods("POST")
+	r.HandleFunc("/api/users/adm/hasadmin", hasAdmin).Methods("GET")
+	r.HandleFunc("/api/users/adm/createadmin", createAdmin).Methods("POST")
+	r.HandleFunc("/api/users/adm/authenticate", authenticateUser).Methods("POST")
+	r.HandleFunc("/api/users/{username}", authorizeUser(http.HandlerFunc(updateUser))).Methods("PUT")
+	r.HandleFunc("/api/users/{username}", authorizeUser(http.HandlerFunc(deleteUser))).Methods("DELETE")
+	r.HandleFunc("/api/users/{username}", authorizeUser(http.HandlerFunc(getUser))).Methods("GET")
 }
 
 //Node authenticates using its password and retrieves a JWT for authorization.
 func authenticateUser(response http.ResponseWriter, request *http.Request) {
 
-    //Auth request consists of Mac Address and Password (from node that is authorizing
-    //in case of Master, auth is ignored and mac is set to "mastermac"
-    var authRequest models.UserAuthParams
-    var result models.User
-    var errorResponse = models.ErrorResponse{
-	    Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
-    }
-
-    decoder := json.NewDecoder(request.Body)
-    decoderErr := decoder.Decode(&authRequest)
-    defer request.Body.Close()
-
-    if decoderErr != nil {
-        returnErrorResponse(response, request, errorResponse)
-	return
-    } else {
-        errorResponse.Code = http.StatusBadRequest
-        if authRequest.UserName == "" {
-            errorResponse.Message = "W1R3: Username can't be empty"
-            returnErrorResponse(response, request, errorResponse)
-	    return
-        } else if authRequest.Password == "" {
-            errorResponse.Message = "W1R3: Password can't be empty"
-            returnErrorResponse(response, request, errorResponse)
-	    return
-        } else {
-
-            //Search DB for node with Mac Address. Ignore pending nodes (they should not be able to authenticate with API untill approved).
-            collection := mongoconn.Client.Database("wirecat").Collection("users")
-            ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	    var err = collection.FindOne(ctx, bson.M{ "username": authRequest.UserName }).Decode(&result)
-
-            defer cancel()
-
-            if err != nil {
-		errorResponse.Message = "W1R3: User " + authRequest.UserName + " not found."
-                returnErrorResponse(response, request, errorResponse)
+	//Auth request consists of Mac Address and Password (from node that is authorizing
+	//in case of Master, auth is ignored and mac is set to "mastermac"
+	var authRequest models.UserAuthParams
+	var result models.User
+	var errorResponse = models.ErrorResponse{
+		Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
+	}
+
+	decoder := json.NewDecoder(request.Body)
+	decoderErr := decoder.Decode(&authRequest)
+	defer request.Body.Close()
+
+	if decoderErr != nil {
+		returnErrorResponse(response, request, errorResponse)
 		return
-            }
-
-	   //compare password from request to stored password in database
-	   //might be able to have a common hash (certificates?) and compare those so that a password isn't passed in in plain text...
-	   //TODO: Consider a way of hashing the password client side before sending, or using certificates
-	   err = bcrypt.CompareHashAndPassword([]byte(result.Password), []byte(authRequest.Password))
-	   if err != nil {
-                        errorResponse = models.ErrorResponse{
-                                Code: http.StatusUnauthorized, Message: "W1R3: Wrong Password.",
-                        }
-		   returnErrorResponse(response, request, errorResponse)
-		   return
-	   } else {
-		//Create a new JWT for the node
-                tokenString, _ := functions.CreateUserJWT(authRequest.UserName, result.IsAdmin)
-
-                if tokenString == "" {
-                    returnErrorResponse(response, request, errorResponse)
-		    return
-                }
-
-                var successResponse = models.SuccessResponse{
-                    Code:    http.StatusOK,
-                    Message: "W1R3: Device " + authRequest.UserName + " Authorized",
-                    Response: models.SuccessfulUserLoginResponse{
-                        AuthToken: tokenString,
-                        UserName:     authRequest.UserName,
-                    },
-                }
-                //Send back the JWT
-                successJSONResponse, jsonError := json.Marshal(successResponse)
-
-                if jsonError != nil {
-                    returnErrorResponse(response, request, errorResponse)
-		    return
-                }
-                response.Header().Set("Content-Type", "application/json")
-                response.Write(successJSONResponse)
-            }
+	} else {
+		errorResponse.Code = http.StatusBadRequest
+		if authRequest.UserName == "" {
+			errorResponse.Message = "W1R3: Username can't be empty"
+			returnErrorResponse(response, request, errorResponse)
+			return
+		} else if authRequest.Password == "" {
+			errorResponse.Message = "W1R3: Password can't be empty"
+			returnErrorResponse(response, request, errorResponse)
+			return
+		} else {
+
+			//Search DB for node with Mac Address. Ignore pending nodes (they should not be able to authenticate with API untill approved).
+			collection := mongoconn.Client.Database("netmaker").Collection("users")
+			ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+			var err = collection.FindOne(ctx, bson.M{"username": authRequest.UserName}).Decode(&result)
+
+			defer cancel()
+
+			if err != nil {
+				errorResponse.Message = "W1R3: User " + authRequest.UserName + " not found."
+				returnErrorResponse(response, request, errorResponse)
+				return
+			}
+
+			//compare password from request to stored password in database
+			//might be able to have a common hash (certificates?) and compare those so that a password isn't passed in in plain text...
+			//TODO: Consider a way of hashing the password client side before sending, or using certificates
+			err = bcrypt.CompareHashAndPassword([]byte(result.Password), []byte(authRequest.Password))
+			if err != nil {
+				errorResponse = models.ErrorResponse{
+					Code: http.StatusUnauthorized, Message: "W1R3: Wrong Password.",
+				}
+				returnErrorResponse(response, request, errorResponse)
+				return
+			} else {
+				//Create a new JWT for the node
+				tokenString, _ := functions.CreateUserJWT(authRequest.UserName, result.IsAdmin)
+
+				if tokenString == "" {
+					returnErrorResponse(response, request, errorResponse)
+					return
+				}
+
+				var successResponse = models.SuccessResponse{
+					Code:    http.StatusOK,
+					Message: "W1R3: Device " + authRequest.UserName + " Authorized",
+					Response: models.SuccessfulUserLoginResponse{
+						AuthToken: tokenString,
+						UserName:  authRequest.UserName,
+					},
+				}
+				//Send back the JWT
+				successJSONResponse, jsonError := json.Marshal(successResponse)
+
+				if jsonError != nil {
+					returnErrorResponse(response, request, errorResponse)
+					return
+				}
+				response.Header().Set("Content-Type", "application/json")
+				response.Write(successJSONResponse)
+			}
+		}
 	}
-    }
 }
 
 //The middleware for most requests to the API
 //They all pass  through here first
 //This will validate the JWT (or check for master token)
-//This will also check against the authGroup and make sure the node should be accessing that endpoint,
+//This will also check against the authNetwork and make sure the node should be accessing that endpoint,
 //even if it's technically ok
 //This is kind of a poor man's RBAC. There's probably a better/smarter way.
 //TODO: Consider better RBAC implementations
 func authorizeUser(next http.Handler) http.HandlerFunc {
-        return func(w http.ResponseWriter, r *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
 
-                var errorResponse = models.ErrorResponse{
-                        Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
-                }
+		var errorResponse = models.ErrorResponse{
+			Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
+		}
 
-	        w.Header().Set("Content-Type", "application/json")
+		w.Header().Set("Content-Type", "application/json")
 
 		//get the auth token
 		bearerToken := r.Header.Get("Authorization")
 
-                var tokenSplit = strings.Split(bearerToken, " ")
+		var tokenSplit = strings.Split(bearerToken, " ")
 
 		//I put this in in case the user doesn't put in a token at all (in which case it's empty)
 		//There's probably a smarter way of handling this.
-                var authToken = "928rt238tghgwe@TY@$Y@#WQAEGB2FC#@HG#@$Hddd"
-
-                if len(tokenSplit) > 1 {
-                        authToken = tokenSplit[1]
-                } else {
-                        errorResponse = models.ErrorResponse{
-                                Code: http.StatusUnauthorized, Message: "W1R3: Missing Auth Token.",
-                        }
-                        returnErrorResponse(w, r, errorResponse)
+		var authToken = "928rt238tghgwe@TY@$Y@#WQAEGB2FC#@HG#@$Hddd"
+
+		if len(tokenSplit) > 1 {
+			authToken = tokenSplit[1]
+		} else {
+			errorResponse = models.ErrorResponse{
+				Code: http.StatusUnauthorized, Message: "W1R3: Missing Auth Token.",
+			}
+			returnErrorResponse(w, r, errorResponse)
 			return
 		}
 
@@ -155,10 +156,10 @@ func authorizeUser(next http.Handler) http.HandlerFunc {
 		username, _, err := functions.VerifyUserToken(authToken)
 
 		if err != nil {
-                        errorResponse = models.ErrorResponse{
-                                Code: http.StatusUnauthorized, Message: "W1R3: Error Verifying Auth Token.",
-                        }
-                        returnErrorResponse(w, r, errorResponse)
+			errorResponse = models.ErrorResponse{
+				Code: http.StatusUnauthorized, Message: "W1R3: Error Verifying Auth Token.",
+			}
+			returnErrorResponse(w, r, errorResponse)
 			return
 		}
 
@@ -177,22 +178,22 @@ func authorizeUser(next http.Handler) http.HandlerFunc {
 	}
 }
 
-func HasAdmin() (bool, error){
+func HasAdmin() (bool, error) {
 
-        collection := mongoconn.Client.Database("wirecat").Collection("users")
+	collection := mongoconn.Client.Database("netmaker").Collection("users")
 
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        filter := bson.M{"isadmin": true}
+	filter := bson.M{"isadmin": true}
 
-        //Filtering out the ID field cuz Dillon doesn't like it. May want to filter out other fields in the future
-        var result bson.M
+	//Filtering out the ID field cuz Dillon doesn't like it. May want to filter out other fields in the future
+	var result bson.M
 
 	err := collection.FindOne(ctx, filter).Decode(&result)
 
-        defer cancel()
+	defer cancel()
 
-        if err != nil {
+	if err != nil {
 		if err == mongo.ErrNoDocuments {
 			return false, err
 		}
@@ -215,18 +216,18 @@ func hasAdmin(w http.ResponseWriter, r *http.Request) {
 
 func GetUser(username string) (models.User, error) {
 
-        var user models.User
+	var user models.User
 
-        collection := mongoconn.Client.Database("wirecat").Collection("users")
+	collection := mongoconn.Client.Database("netmaker").Collection("users")
 
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        filter := bson.M{"username": username}
-        err := collection.FindOne(ctx, filter, options.FindOne().SetProjection(bson.M{"_id": 0})).Decode(&user)
+	filter := bson.M{"username": username}
+	err := collection.FindOne(ctx, filter, options.FindOne().SetProjection(bson.M{"_id": 0})).Decode(&user)
 
-        defer cancel()
+	defer cancel()
 
-        return user, err
+	return user, err
 }
 
 //Get an individual node. Nothin fancy here folks.
@@ -234,7 +235,7 @@ func getUser(w http.ResponseWriter, r *http.Request) {
 	// set header.
 	w.Header().Set("Content-Type", "application/json")
 
-        var params = mux.Vars(r)
+	var params = mux.Vars(r)
 
 	user, err := GetUser(params["username"])
 
@@ -248,51 +249,51 @@ func getUser(w http.ResponseWriter, r *http.Request) {
 
 func CreateUser(user models.User) (models.User, error) {
 
-        //encrypt that password so we never see it again
-        hash, err := bcrypt.GenerateFromPassword([]byte(user.Password), 5)
+	//encrypt that password so we never see it again
+	hash, err := bcrypt.GenerateFromPassword([]byte(user.Password), 5)
 
-        if err != nil {
-                return user, err
-        }
-        //set password to encrypted password
-        user.Password = string(hash)
+	if err != nil {
+		return user, err
+	}
+	//set password to encrypted password
+	user.Password = string(hash)
 
-        tokenString, _ := functions.CreateUserJWT(user.UserName, user.IsAdmin)
+	tokenString, _ := functions.CreateUserJWT(user.UserName, user.IsAdmin)
 
-        if tokenString == "" {
-                //returnErrorResponse(w, r, errorResponse)
-                return user, err
-        }
+	if tokenString == "" {
+		//returnErrorResponse(w, r, errorResponse)
+		return user, err
+	}
 
-        // connect db
-        collection := mongoconn.Client.Database("wirecat").Collection("users")
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	// connect db
+	collection := mongoconn.Client.Database("netmaker").Collection("users")
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        // insert our node to the node db.
-        result, err := collection.InsertOne(ctx, user)
-        _ = result
+	// insert our node to the node db.
+	result, err := collection.InsertOne(ctx, user)
+	_ = result
 
-        defer cancel()
+	defer cancel()
 
-        return user, err
+	return user, err
 }
 
 func createAdmin(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	var errorResponse = models.ErrorResponse{
-	        Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
+		Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
 	}
 
 	hasadmin, err := HasAdmin()
 
-        if hasadmin {
-                errorResponse = models.ErrorResponse{
-                        Code: http.StatusUnauthorized, Message: "W1R3: Admin already exists! ",
-                }
-                returnErrorResponse(w, r, errorResponse)
-                return
-        }
+	if hasadmin {
+		errorResponse = models.ErrorResponse{
+			Code: http.StatusUnauthorized, Message: "W1R3: Admin already exists! ",
+		}
+		returnErrorResponse(w, r, errorResponse)
+		return
+	}
 
 	var admin models.User
 
@@ -301,72 +302,71 @@ func createAdmin(w http.ResponseWriter, r *http.Request) {
 
 	admin.IsAdmin = true
 
-	err =  ValidateUser("create", admin)
-        if err != nil {
+	err = ValidateUser("create", admin)
+	if err != nil {
 		json.NewEncoder(w).Encode(err)
 		return
-        }
+	}
 
-        admin, err = CreateUser(admin)
-        if err != nil {
+	admin, err = CreateUser(admin)
+	if err != nil {
 		json.NewEncoder(w).Encode(err)
-                return
-        }
+		return
+	}
 
 	json.NewEncoder(w).Encode(admin)
 }
 
 func UpdateUser(userchange models.User, user models.User) (models.User, error) {
 
-    queryUser := user.UserName
-
-    if userchange.UserName != "" {
-        user.UserName = userchange.UserName
-    }
-    if userchange.Password != "" {
-        //encrypt that password so we never see it again
-        hash, err := bcrypt.GenerateFromPassword([]byte(userchange.Password), 5)
+	queryUser := user.UserName
 
-        if err != nil {
-                return userchange, err
-        }
-        //set password to encrypted password
-        userchange.Password = string(hash)
+	if userchange.UserName != "" {
+		user.UserName = userchange.UserName
+	}
+	if userchange.Password != "" {
+		//encrypt that password so we never see it again
+		hash, err := bcrypt.GenerateFromPassword([]byte(userchange.Password), 5)
 
-        user.Password = userchange.Password
-    }
-        //collection := mongoconn.ConnectDB()
-        collection := mongoconn.Client.Database("wirecat").Collection("users")
+		if err != nil {
+			return userchange, err
+		}
+		//set password to encrypted password
+		userchange.Password = string(hash)
 
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		user.Password = userchange.Password
+	}
+	//collection := mongoconn.ConnectDB()
+	collection := mongoconn.Client.Database("netmaker").Collection("users")
 
-        // Create filter
-        filter := bson.M{"username": queryUser}
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        fmt.Println("Updating User " + user.UserName)
+	// Create filter
+	filter := bson.M{"username": queryUser}
 
+	fmt.Println("Updating User " + user.UserName)
 
-        // prepare update model.
-        update := bson.D{
-                {"$set", bson.D{
-                        {"username", user.UserName},
-                        {"password", user.Password},
-                        {"isadmin", user.IsAdmin},
-                }},
-        }
-        var userupdate models.User
+	// prepare update model.
+	update := bson.D{
+		{"$set", bson.D{
+			{"username", user.UserName},
+			{"password", user.Password},
+			{"isadmin", user.IsAdmin},
+		}},
+	}
+	var userupdate models.User
 
-        errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&userupdate)
+	errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&userupdate)
 	if errN != nil {
-               fmt.Println("Could not update: ")
-               fmt.Println(errN)
-        }  else {
+		fmt.Println("Could not update: ")
+		fmt.Println(errN)
+	} else {
 		fmt.Println("User updated  successfully.")
 	}
 
-        defer cancel()
+	defer cancel()
 
-        return userupdate, errN
+	return userupdate, errN
 }
 
 func updateUser(w http.ResponseWriter, r *http.Request) {
@@ -378,61 +378,60 @@ func updateUser(w http.ResponseWriter, r *http.Request) {
 
 	//start here
 	user, err := GetUser(params["username"])
-        if err != nil {
-                json.NewEncoder(w).Encode(err)
-                return
-        }
-
+	if err != nil {
+		json.NewEncoder(w).Encode(err)
+		return
+	}
 
-        var userchange models.User
+	var userchange models.User
 
-        // we decode our body request params
-        err = json.NewDecoder(r.Body).Decode(&userchange)
+	// we decode our body request params
+	err = json.NewDecoder(r.Body).Decode(&userchange)
 	if err != nil {
-                json.NewEncoder(w).Encode(err)
-                return
-        }
+		json.NewEncoder(w).Encode(err)
+		return
+	}
 
 	userchange.IsAdmin = true
 
-        err = ValidateUser("update", userchange)
+	err = ValidateUser("update", userchange)
 
-        if err != nil {
-                json.NewEncoder(w).Encode(err)
-                return
-        }
+	if err != nil {
+		json.NewEncoder(w).Encode(err)
+		return
+	}
 
 	user, err = UpdateUser(userchange, user)
 
 	if err != nil {
-                json.NewEncoder(w).Encode(err)
+		json.NewEncoder(w).Encode(err)
 		return
 	}
 
 	json.NewEncoder(w).Encode(user)
 }
 
-func DeleteUser(user string) (bool, error)  {
+func DeleteUser(user string) (bool, error) {
 
-        deleted := false
+	deleted := false
 
-        collection := mongoconn.Client.Database("wirecat").Collection("users")
+	collection := mongoconn.Client.Database("netmaker").Collection("users")
 
-        filter := bson.M{"username": user}
+	filter := bson.M{"username": user}
 
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        result, err := collection.DeleteOne(ctx, filter)
+	result, err := collection.DeleteOne(ctx, filter)
 
-        deletecount := result.DeletedCount
+	deletecount := result.DeletedCount
 
-        if deletecount > 0 {
-                deleted = true
-        }
+	if deletecount > 0 {
+		deleted = true
+	}
 
-        defer cancel()
+	defer cancel()
 
-        return deleted, err
+	return deleted, err
 }
 
 func deleteUser(w http.ResponseWriter, r *http.Request) {
@@ -444,9 +443,11 @@ func deleteUser(w http.ResponseWriter, r *http.Request) {
 
 	success, err := DeleteUser(params["username"])
 
-	if err != nil || !success {
-		http.Error(w, err.Error(), 400)
-		json.NewEncoder(w).Encode("Could not delete user " + params["username"])
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	} else if !success {
+		returnErrorResponse(w, r, formatError(errors.New("Delete unsuccessful."), "badrequest"))
 		return
 	}
 
@@ -455,30 +456,30 @@ func deleteUser(w http.ResponseWriter, r *http.Request) {
 
 func ValidateUser(operation string, user models.User) error {
 
-        v := validator.New()
+	v := validator.New()
 
-        _ = v.RegisterValidation("username_unique", func(fl validator.FieldLevel) bool {
+	_ = v.RegisterValidation("username_unique", func(fl validator.FieldLevel) bool {
 		_, err := GetUser(user.UserName)
 		return err == nil || operation == "update"
-        })
-
-        _ = v.RegisterValidation("username_valid", func(fl validator.FieldLevel) bool {
-                isvalid := functions.NameInNodeCharSet(user.UserName)
-                return isvalid
-        })
-
-        _ = v.RegisterValidation("password_check", func(fl validator.FieldLevel) bool {
-                notEmptyCheck := user.Password != ""
-                goodLength := len(user.Password) > 5
-                return (notEmptyCheck && goodLength) || operation == "update"
-        })
-
-        err := v.Struct(user)
-
-        if err != nil {
-                for _, e := range err.(validator.ValidationErrors) {
-                        fmt.Println(e)
-                }
-        }
-        return err
+	})
+
+	_ = v.RegisterValidation("username_valid", func(fl validator.FieldLevel) bool {
+		isvalid := functions.NameInNodeCharSet(user.UserName)
+		return isvalid
+	})
+
+	_ = v.RegisterValidation("password_check", func(fl validator.FieldLevel) bool {
+		notEmptyCheck := user.Password != ""
+		goodLength := len(user.Password) > 5
+		return (notEmptyCheck && goodLength) || operation == "update"
+	})
+
+	err := v.Struct(user)
+
+	if err != nil {
+		for _, e := range err.(validator.ValidationErrors) {
+			fmt.Println(e)
+		}
+	}
+	return err
 }

docker-compose.yml

@@ -16,7 +16,7 @@ services:
     container_name: netmaker
     depends_on:
       - mongodb
-    image: gravitl/netmaker:v0.1
+    image: gravitl/netmaker:v0.1-hotfix
     ports:
       - "8081:8081"
       - "50051:50051"

docs/API.md

@@ -1,68 +1,167 @@
 # API Reference Doc
 
-###  Nodes
-**Get Peer List:** "/api/{group}/peerlist", "GET"  
-**Get List Last Modified Date:** "/api/{group}/lastmodified", "GET"  
-**Get Node Details:** "/api/{group}/nodes/{macaddress}", "GET"  
-**Create Node:** "/api/{group}/nodes", "POST"  
-**Uncordon Node:** "/api/{group}/nodes/{macaddress}/uncordon", "POST"  
-**Check In Node:** "/api/{group}/nodes/{macaddress}/checkin", "POST"  
-**Update Node:** "/api/{group}/nodes/{macaddress}", "PUT"  
-**Delete Node:** "/api/{group}/nodes/{macaddress}", "DELETE"  
-**Get Group Nodes:** "/api/{group}/nodes", "GET" 
-**Get All Nodes:** "/api/nodes", "GET"
-**Authenticate:** "/api/{group}/authenticate", "POST"
+## GENERAL
 
+Most actions that can be performed via API can be performed via UI. We recommend managing your networks using our official netmaker-ui project. That said, Netmaker is API based, and all functions can also be achieved via API calls. If you feel the need to work with Netmaker via API, we've provided some documentation below to help guide you.
  
-### Groups
-**Get Groups:** "/api/groups", "GET"  
-**Get Group Details:** "/api/group/{groupname}", "GET"  
-**Get Number of Nodes in Group:** "/api/group/{groupname}/numnodes", "GET"  
-**Create Group:** "/api/groups", "POST"  
-**Update Group:** "/api/groups/{groupname}", "PUT"  
-**Delete Group:** "/api/groups/{groupname}", "DELETE"  
-
-**Create Access Key:** "/api/groups/{groupname}/keys", "POST"  
-**Get Access Key:** "/api/groups/{groupname}/keys", "GET"  
-**Delete Access Key:** "/api/groups/{groupname}/keys/{keyname}", "DELETE" 
-
-### Users (only used for interface admin user at this time)
-**Create Admin User:** "/users/createadmin", "POST"  
-**Check for  Admin User:** "/users/hasadmin", "GET"  
-**Update User:** "/users/{username}", "PUT"  
-**Delete User:** "/users/{username}", "DELETE"  
-**Get User:** "/users/{username}", "GET"  
-**Authenticate User:** "/users/authenticate", "POST"  
-
-*note: users API does not use /api/ because of  a weird bug. Will fix in  future release.
-**note: Only able to create Admin at this time. The "user" is only used by the [user interface](https://github.com/falconcat-inc/WireCat-UI) to authenticate the  single  admin user.
-
-### Files
-**Get File:** "/meshclient/files/{filename}", "GET"  
-
-## Example API CALLS
-
-**Note About Token:** This is a configurable value stored under  config/environments/dev.yaml and can be changed before  startup. It's a hack for testing, just provides an easy way to authorize, and should be removed and changed in the future.
-
-#### Create a Group
-curl -d '{"addressrange":"10.70.0.0/16","nameid":"skynet"}' -H "Authorization: Bearer secretkey" -H 'Content-Type: application/json' localhost:8081/api/groups
-
-#### Create a Key
-curl -d '{"uses":10}' -H "Authorization: Bearer secretkey" -H 'Content-Type: application/json' localhost:8081/api/groups localhost:8081/api/groups/skynet/keys
-
-#### Create a Node
-curl  -d  '{ "endpoint": 100.200.100.200, "publickey": aorijqalrik3ajflaqrdajhkr,"macaddress": "8c:90:b5:06:f1:d9","password": "reallysecret","localaddress": "172.16.16.1","accesskey": "aA3bVG0rnItIRXDx","listenport": 6400}' -H 'Content-Type: application/json' -H "authorization: Bearer secretkey" localhost:8081/api/skynet/nodes
-
-#### Get Groups
-curl -H "Authorization: Bearer secretkey" -H 'Content-Type: application/json' localhost:8081/api/groups | jq
-
-#### Get Group Nodes
-curl -H "Authorization: Bearer secretkey" -H 'Content-Type: application/json' localhost:8081/api/skynet/nodes | jq
-
-#### Update Node Settings
-curl -X "PUT" -d '{"name":"my-laptop"}' -H 'Content-Type: application/json' -H "authorization: Bearer secretkey" localhost:8081/api/skynet/nodes/8c:90:b5:06:f1:d9
-
-#### Delete a Node
-curl -X "DELETE" -H "authorization: Bearer secretkey" localhost:8081/api/skynet/nodes/8c:90:b5:06:f1:d9
-
-
+#### Authentication
+ In general, API calls must be authenticated via a header of  the format  `-H "Authorization: Bearer <YOUR_SECRET_KEY>"` There are two methods of obtaining YOUR_SECRET_KEY:
+1. Using the masterkey. By default, this value is "secret key," but you should change this on your instance and keep it secure. This value can be set via env var at startup or in a config file (config/environments/< env >.yaml). See the [general usage](./USAGE.md) documentation for more details.
+2. Using a JWT recieved for a node. This  can be retrieved by calling the `/api/nodes/<network>/authenticate` endpoint, as documented below.
+
+#### Format 
+In general, requests will take the format of `curl -H "Authorization: Bearer <YOUR_SECRET_KEY>" -H 'Content-Type: application/json' localhost:8081/api/path/to/endpoint`
+
+## NETWORKS
+
+**Get All Networks:** `/api/networks`, `GET` 
+  
+**Create Network:** `/api/network`, `POST` 
+  
+**Get Network:** `/api/networks/{network id}`, `GET`  
+  
+**Update Network:** `/api/networks/{network id}`, `PUT`  
+  
+**Delete Network:** `/api/networks/{network id}`, `DELETE`  
+  
+**Cycle PublicKeys on all Nodes:** `/api/networks/{network id}/keyupdate`, `POST`  
+  
+  
+### Network  API Call Examples
+  
+  
+**Get All Networks:** `curl -H "Authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/networks | jq`
+
+**Create Network:** `curl -d '{"addressrange":"10.70.0.0/16","netid":"skynet"}' -H "Authorization: Bearer YOUR_SECRET_KEY" -H 'Content-Type: application/json' localhost:8081/api/networks`
+
+**Get Network:** `curl -H "Authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/networks/skynet | jq`
+
+**Update Network:** `curl -X PUT -d '{"displayname":"my-house"}' -H "Authorization: Bearer YOUR_SECRET_KEY" -H 'Content-Type: application/json' localhost:8081/api/networks/skynet`
+
+**Delete Network:** `curl -X DELETE -H "Authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/networks/skynet`
+
+**Cycle PublicKeys on all Nodes:** `curl -X POST -H "Authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/networks/skynet/keyupdate`
+
+## ACCESS KEYS
+
+**Get All Keys:** `/api/networks/{network id}/keys`, `GET` 
+  
+**Create Key:** `/api/networks/{network id}/keys`, `GET` 
+  
+**Delete Key:** `/api/networks/{network id}/keys/{keyname}`, `DELETE` 
+  
+  
+### Access Key API Call Examples
+  
+   
+**Get All Keys:** `curl -H "Authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/networks/skynet/keys | jq`
+  
+**Create Key:** `curl -d '{"uses":10,"name":"mykey"}' -H "Authorization: Bearer YOUR_SECRET_KEY" -H 'Content-Type: application/json' localhost:8081/api/networks/skynet/keys`
+  
+**Delete Key:** `curl -X DELETE -H "Authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/networks/skynet/keys/mykey`
+  
+    
+## NODES (COMPUTERS)
+  
+  
+**Get All Nodes:** `/api/nodes`, `GET` 
+  
+**Get Network Nodes:** `/api/nodes/{network id}`, `GET` 
+  
+**Create Node:** `/api/nodes/{network id}`, `POST`  
+  
+**Get Node:** `/api/nodes/{network id}/{macaddress}`, `GET`  
+  
+**Update Node:** `/api/nodes/{network id}/{macaddress}`, `PUT`  
+  
+**Delete Node:** `/api/nodes/{network id}/{macaddress}`, `DELETE`  
+  
+**Check In Node:** `/api/nodes/{network id}/{macaddress}/checkin`, `POST`  
+  
+**Create a Gateway:** `/api/nodes/{network id}/{macaddress}/creategateway`, `POST`  
+  
+**Delete a Gateway:** `/api/nodes/{network id}/{macaddress}/deletegateway`, `DELETE`  
+  
+**Uncordon (Approve) a Pending Node:** `/api/nodes/{network id}/{macaddress}/uncordon`, `POST`  
+  
+**Get Last Modified Date (Last Modified Node in Network):** `/api/nodes/adm/{network id}/lastmodified`, `GET`  
+  
+**Authenticate:** `/api/nodes/adm/{network id}/authenticate`, `POST`  
+  
+  
+### Example Node API Calls
+  
+  
+**Get All Nodes:**`curl -H "Authorization: Bearer YOUR_SECRET_KEY" http://localhost:8081/api/nodes | jq`
+  
+**Get Network Nodes:** `curl -H "Authorization: Bearer YOUR_SECRET_KEY" http://localhost:8081/api/nodes/skynet | jq`
+    
+**Create Node:** `curl  -d  '{ "endpoint": 100.200.100.200, "publickey": aorijqalrik3ajflaqrdajhkr,"macaddress": "8c:90:b5:06:f1:d9","password": "reallysecret","localaddress": "172.16.16.1","accesskey": "aA3bVG0rnItIRXDx","listenport": 6400}' -H 'Content-Type: application/json' -H "authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/nodes/skynet`
+    
+**Get Node:** `curl -H "Authorization: Bearer YOUR_SECRET_KEY" http://localhost:8081/api/nodes/skynet/{macaddress} | jq`  
+  
+**Update Node:** `curl -X PUT -d '{"name":"laptop1"}' -H 'Content-Type: application/json' -H "authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/nodes/skynet/8c:90:b5:06:f1:d9`
+  
+**Delete Node:** `curl -X DELETE -H "authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/skynet/nodes/8c:90:b5:06:f1:d9`
+  
+**Create a Gateway:** `curl  -d  '{ "rangestring": "172.31.0.0/16", "interface": "eth0"}' -H 'Content-Type: application/json' -H "authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/nodes/skynet/8c:90:b5:06:f1:d9/creategateway`
+  
+**Delete a Gateway:** `curl -X DELETE -H "authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/nodes/skynet/8c:90:b5:06:f1:d9/deletegateway`
+  
+**Approve a Pending Node:** `curl -X POST -H "authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/nodes/skynet/8c:90:b5:06:f1:d9/approve`
+  
+**Get Last Modified Date (Last Modified Node in Network):** `curl -H "authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/nodes/adm/skynet/lastmodified`
+
+**Authenticate:** `curl -d  '{"macaddress": "8c:90:b5:06:f1:d9", "password": "YOUR_PASSWORD"}' -H 'Content-Type: application/json' localhost:8081/api/nodes/adm/skynet/authenticate`
+  
+  
+## USERS
+  
+  
+**Note:** Only able to create Admin user at this time. The "user" is only used by the [user interface](https://github.com/gravitl/netmaker-ui) to authenticate the  single  admin user.
+
+**Get User:** `/api/users/{username}`, `GET`  
+  
+**Update User:** `/api/users/{username}`, `PUT`  
+  
+**Delete User:** `/api/users/{username}`, `DELETE`  
+  
+**Check for Admin User:** `/api/users/adm/hasadmin`, `GET` 
+  
+**Create Admin User:** `/api/users/adm/createadmin`, `POST` 
+  
+**Authenticate:** `/api/users/adm/authenticate`, `POST` 
+  
+  
+### Example User API Calls
+
+  
+**Get User:**`curl -H "Authorization: Bearer YOUR_SECRET_KEY" http://localhost:8081/api/users/{username} | jq`
+
+**Update User:** `curl -X PUT -d '{"password":"noonewillguessthis"}' -H 'Content-Type: application/json' -H "authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/users/{username}`
+  
+**Delete User:** `curl -X DELETE -H "authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/users/{username}`
+  
+**Check for Admin User:**`curl -H "Authorization: Bearer YOUR_SECRET_KEY" http://localhost:8081/api/users/adm/hasadmin`
+  
+**Create Admin User:** `curl -d '{ "username": "smartguy", "password": "YOUR_PASS"}' -H 'Content-Type: application/json' -H "authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/users/adm/createadmin`
+   
+**Authenticate:** `curl -d  '{"username": "smartguy", "password": "YOUR_PASS"}' -H 'Content-Type: application/json' localhost:8081/api/nodes/adm/skynet/authenticate`
+  
+## SERVER MGMT
+
+The Server Mgmt. API allows you to add and remove the server from networks.
+
+**Add to Network:** `/api/server/addnetwork/{network id}`, `POST`  
+  
+**Remove from Network:** `/api/server/removenetwork/{network id}`, `DELETE`  
+
+**Add to Network:**  `curl -X POST -H "authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/server/addnetwork/{network id}`
+
+**Remove from Network:** `curl -X DELETE -H "authorization: Bearer YOUR_SECRET_KEY" localhost:8081/api/server/removenetwork/{network id}`
+
+## FILE SERVER
+  
+**Get File:** `/meshclient/files/{filename}`, `GET`
+  
+**Example:**  `curl localhost:8081/meshclient/files/meshclient`

docs/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+## Code of Conduct
+
+### Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+### Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+### Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+### Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+### Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at [email protected]. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+### Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

docs/CONTRIBUTING.md

@@ -1,6 +1,28 @@
-## Contributing
+# Contributing to Netmaker
+Welcome! If you're reading this, you might be wondering how to go about submitting some changes, whether those are features, bugfixes, or simple enhancements. You're in the right place. Please read below to learn more.
 
- 1. Create a feature / bugfix branch from develop
- 2.  Write your code
- 3. Submit PR to develop
+## Code of Conduct
 
+Please read through our [code of conduct](./CODE_OF_CONDUCT.md), and when making contributions to the community, stay true to that text.
+
+## Report bugs and requests [here](https://github.com/gravitl/netmaker/issues)
+We use GitHub issues to track bugs, feature requests, and enhancements. If you think there's something missing or wrong with Netmaker, let us know! Try to add the appropriate tags and describe your issue thoroughly. If it's a feature request and we like it, we'll add it to the [roadmap](ROADMAP.md)
+
+## Submitting a PR
+We actively welcome contributions, and the way to do that is with a PR:
+
+1. Fork the repo
+2. Create a branch from `develop` based on what you are developing. In general this will be a feature or a bugfix branch, and should have the format of feature_vX.X_mynewfeature or bugfix_vX.X_mybugfix. Check the releases to see what minor version we are currently developing.
+3. Do your thing
+4. Document thoroughly
+5. Issue a PR to `develop`
+6. Sign the CLA
+
+## Contributor License Agreement
+
+When submitting a PR, you will be asked to sign a CLA, defined [here](https://gist.github.com/afeiszli/2f9f8133929e7d5574a9d892959d58a7). We've tried to make this as non-annoying as possible. This is adapted from the text used by the Apache Foundation in their CLA.
+
+This project is evolving quickly and we may want to move to an MIT or GPL license at some point in the near future, which would be difficult without a CLA.
+
+## Licensing
+Any contributions you make will be under the SSPL Software License. When you submit code changes, you  understand that they will be under the same license that covers this project, defined [here](../LICENSE.txt). If you have any concerns around this, feel free to contact the maintainers.

docs/ROADMAP.md

@@ -2,12 +2,12 @@
 
 ### 0.1
 **Server:**
- - [x] Create Groups (virtual networks)
- - [x] Allow default settings for nodes from groups
+ - [x] Create Networks (virtual networks)
+ - [x] Allow default settings for nodes from networks
  - [x] Admin/Superuser key
  - [x] Create multiuse keys for node signup
  - [x] JWT-based auth for post-signup
- - [x] CRUD for groups
+ - [x] CRUD for networks
  - [x] CRUD for nodes
  - [x] Track all important info about node for networking (port, endpoints, pub key, etc)
  - [x] Timestamps for determining if nodes need updates
@@ -31,21 +31,21 @@
 	- [ ] Troubleshooting
 
 **Server:**
- - [ ] Allow tracking multiple groups per node
+ - [ ] Allow tracking multiple networks per node
  - [ ] Configure Check-in thresholds
  - [ ] Separate sign-up endpoint to allow VPN-only comms after joining network
  - [ ] Swagger Docs
  - [ ] Build Out README
- - [ ] Encode Server, Port, and Group into Keys
+ - [ ] Encode Server, Port, and Network into Keys
  - [ ] Switch to Unique ID for nodes instead of MacAddress
  - [ ] Public Key refresh
  - [ ] Enable  ipv6 addresses
- - [ ] Have a "default" group created at startup
+ - [ ] Have a "default" network created at startup
  
 **Agent:**
  - [ ] Test / get working on multiple linux platforms
  - [ ] Set private DNS via etc hosts (node name + ip). Make it optional flag on agent.
- - [ ] Decode Server, Port, and Group from Key
+ - [ ] Decode Server, Port, and Network from Key
  - [ ] Service ID / unit file for SystemD Service
  - [ ] Allow multiple interfaces
  - [ ] Use "Check in interval" from server
@@ -55,7 +55,7 @@
 ### 0.3
 **Server:**
  - [ ] Swagger Docs
- - [ ] Group/Node labels
+ - [ ] Network/Node labels
  - [ ] "Read Only" mode for nodes (can't update their settings centrally, only read)
  - [ ] "No-GUI mode:" Similar to existing, just do more e2e testing and make sure flow makes sense
  - [ ] Let users set prefixes (node, interface)
@@ -71,7 +71,7 @@
  - [ ] "Read Only" mode for nodes (can't update their settings centrally, only read)
  
 **Agent:**
- - [ ] Do system calls instead of direct comma[this repo](https://github.com/falconcat-inc/WireCat-UI)nds
+ - [ ] Do system calls instead of direct commands [this repo](https://github.com/gravitl/netmaker-ui)
  - [ ] Add a prompt for easy setup
  - [ ] Make it work as a sidecar container!!!
 
@@ -87,7 +87,7 @@
  - [ ] Load balance / fault tolerant server
  - [ ] Change DB / make more scaleable (SQL?)
  - [ ] Redis
- - [ ] Group/Node labels
+ - [ ] Network/Node labels
  
 **Agent:**
  - [ ] userspace via Docker or Golang

docs/SITE_2_SITE.md

@@ -0,0 +1 @@
+# This document will cover how to set up site to site connections using netmaker

docs/TROUBLESHOOTING.md

@@ -1,2 +1,29 @@
-## Incorrect backend detected. Please specify correct URL and refresh. Given: http://localhost:8081
+# Netmaker Troubleshooting Help
+
+## Client (netclient)
+	### Problem: netclient-install script not working
+	### Problem: Hanging artifacts from previous install
+	### Problem: Need to change access token settings
+
+
+### Client fails to install
+
+### Cannot run install script
+
+### Issue with accesstoken created by UI
+
+
+## Server
+	### Server not added to default network
+	### Global config not found
+
+
+
+## MongoDB
+
+
+
+## UI
+
+### Incorrect backend detected. Please specify correct URL and refresh. Given: http://localhost:8081
 Solution: Front end expects a reachable address for the backend. Localhost is default. Check if server is up. If server is up, make sure you've got the right endpoint (endpoint of server. Will not be 'localhost' unless doing local testing). If server is up and endpoint is correct, check for port blockings.

docs/GETTING_STARTED.md → docs/USAGE.md

@@ -1,19 +1,27 @@
-# Getting Started (Simple Setup)
+# Getting Started
+
+This guide covers the fundamentals of using Netmaker.
+
+## Quick Start
+
+
+## Non-Docker Setup
+
 ### Server Setup
  1. Get yourself a linux server and make sure it has a public IP.
  2. Deploy MongoDB `docker volume create mongovol && docker run -d --name mongodb -v mongovol:/data/db --network host -e MONGO_INITDB_ROOT_USERNAME=mongoadmin -e MONGO_INITDB_ROOT_PASSWORD=mongopass mongo --bind_ip 0.0.0.0 `
- 3. Pull this repo: `git clone https://github.com/falconcat-inc/WireCat.git`
- 4. Switch to the directory and source the default env vars `cd WireCat && source defaultvars.sh`
+ 3. Pull this repo: `git clone https://github.com/gravitl/netmaker.git`
+ 4. Switch to the directory and source the default env vars `cd netmaker && source defaultvars.sh`
  5. Run the server: `go run ./`
-### Optional (For  Testing):  Create Groups and Nodes
+### Optional (For  Testing):  Create Networks and Nodes
  
- 1. Create Group: `./test/groupcreate.sh`
+ 1. Create Network: `./test/networkcreate.sh`
  2. Create Key: `./test/keycreate.sh` (save the response for step 3)
  3. Open ./test/nodescreate.sh and replace ACCESSKEY with value from #2
  4. Create Nodes: `./test/nodescreate.sh`
  5. Check to see if nodes were created: `curl -H "authorization: Bearer secretkey" localhost:8081/api/skynet/nodes | jq`
 ### UI Setup
-Please see [this repo](https://github.com/falconcat-inc/WireCat-UI)  for instructions on setting up your UI.
+Please see [this repo](https://github.com/gravitl/netmaker-ui)  for instructions on setting up your UI.
 
 ### Agent  Setup
 
@@ -21,10 +29,10 @@ On each machine you would like to add to the network, do the following:
 
 1. Confirm wireguard is installed: `sudo apt install wireguard-tools`
 2. Confirm ipv4 forwarding is enabled: `sysctl -w net.ipv4.ip_forward=1`
-3. Create a key or enable manual node signup at the group level
+3. Create a key or enable manual node signup at the network level
 4. Get the binary: `sudo wget 52.55.6.84:8081/meshclient/files/meshclient`
 5. Make it executable: `sudo chmod +x meshclient`
-6. Run the install command: `sudo ./meshclient -c install -g <group name> -s <server:port> -k <key value>`
+6. Run the install command: `sudo ./meshclient -c install -g <network name> -s <server:port> -k <key value>`
 
 This will install netclient.service and netclient.timer in systemd, which will run periodically to call the netclient binary, which will check to see if there are any updates that it needs and update WireGuard appropriately.
 

functions/helpers.go

@@ -12,7 +12,6 @@ import (
     "context"
     "encoding/base64"
     "strings"
-    "log"
     "net"
     "github.com/gravitl/netmaker/models"
     "github.com/gravitl/netmaker/mongoconn"
@@ -23,16 +22,83 @@ import (
 )
 
 //Takes in an arbitrary field and value for field and checks to see if any other
-//node has that value for the same field within the group
-func IsFieldUnique(group string,  field string, value string) bool {
+//node has that value for the same field within the network
+
+func CreateServerToken(netID string) (string, error) {
+	fmt.Println("Creating token.")
+        var network models.Network
+        var accesskey models.AccessKey
+
+        network, err := GetParentNetwork(netID)
+        if err != nil {
+                return "", err
+        }
+
+                accesskey.Name = GenKeyName()
+                accesskey.Value = GenKey()
+                accesskey.Uses = 1
+        _, gconf, errG := GetGlobalConfig()
+        if errG != nil {
+                return "", errG
+        }
+        address := "localhost" + gconf.PortGRPC
+
+        privAddr := ""
+        if *network.IsLocal {
+                privAddr = network.LocalRange
+        }
+
+
+	fmt.Println("Token details:")
+	fmt.Println("    grpc address + port: " + address)
+	fmt.Println("                network: " + netID)
+	fmt.Println("          private range: " + privAddr)
+
+	accessstringdec := address + "|" + netID + "|" + accesskey.Value + "|" + privAddr
+
+	accesskey.AccessString = base64.StdEncoding.EncodeToString([]byte(accessstringdec))
+
+        fmt.Println("          access string: " + accesskey.AccessString)
+
+
+        network.AccessKeys = append(network.AccessKeys, accesskey)
+
+        collection := mongoconn.Client.Database("netmaker").Collection("networks")
+
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+        // Create filter
+        filter := bson.M{"netid": netID}
+
+        // Read update model from body request
+        fmt.Println("Adding key to " + network.NetID)
+
+        // prepare update model.
+        update := bson.D{
+                {"$set", bson.D{
+                        {"accesskeys", network.AccessKeys},
+                }},
+        }
+
+        errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&network)
+
+        defer cancel()
+
+        if errN != nil {
+                return "", errN
+        }
+        return accesskey.AccessString, nil
+}
+
+func IsFieldUnique(network string,  field string, value string) bool {
 
 	var node models.Node
 	isunique := true
 
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-	filter := bson.M{field: value, "group": group}
+	filter := bson.M{field: value, "network": network}
 
         err := collection.FindOne(ctx, filter).Decode(&node)
 
@@ -49,13 +115,13 @@ func IsFieldUnique(group string,  field string, value string) bool {
         return isunique
 }
 
-func GroupExists(name string) (bool, error) {
+func NetworkExists(name string) (bool, error) {
 
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
+        collection := mongoconn.Client.Database("netmaker").Collection("networks")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        filter := bson.M{"nameid": name}
+        filter := bson.M{"netid": name}
 
 	var result bson.M
         err := collection.FindOne(ctx, filter).Decode(&result)
@@ -64,7 +130,7 @@ func GroupExists(name string) (bool, error) {
 
 	if err != nil {
 		if err == mongo.ErrNoDocuments {
-			return false, err
+			return false, nil
 		}
 		fmt.Println("ERROR RETRIEVING GROUP!")
 		fmt.Println(err)
@@ -73,16 +139,16 @@ func GroupExists(name string) (bool, error) {
 }
 
 //TODO: This is  very inefficient (N-squared). Need to find a better way.
-//Takes a list of  nodes in a group and iterates through
+//Takes a list of  nodes in a network and iterates through
 //for each node, it gets a unique address. That requires checking against all other nodes once more
-func UpdateGroupNodeAddresses(groupName string) error {
+func UpdateNetworkNodeAddresses(networkName string) error {
 
         //Connection mongoDB with mongoconn class
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        filter := bson.M{"group": groupName}
+        filter := bson.M{"network": networkName}
         cur, err := collection.Find(ctx, filter)
 
         if err != nil {
@@ -100,7 +166,7 @@ func UpdateGroupNodeAddresses(groupName string) error {
 			fmt.Println("error in node address assignment!")
                         return err
                 }
-		ipaddr, iperr := UniqueAddress(groupName)
+		ipaddr, iperr := UniqueAddress(networkName)
                 if iperr != nil {
 			fmt.Println("error in node  address assignment!")
                         return iperr
@@ -119,29 +185,82 @@ func UpdateGroupNodeAddresses(groupName string) error {
 
         return err
 }
+//TODO TODO TODO!!!!!
+func UpdateNetworkPrivateAddresses(networkName string) error {
+
+        //Connection mongoDB with mongoconn class
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 
-//Checks to see if any other groups have the same name (id)
-func IsGroupNameUnique(name string) bool {
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+        filter := bson.M{"network": networkName}
+        cur, err := collection.Find(ctx, filter)
+
+        if err != nil {
+                return err
+        }
+
+        defer cancel()
+
+        for cur.Next(context.TODO()) {
+
+                var node models.Node
+
+                err := cur.Decode(&node)
+                if err != nil {
+                        fmt.Println("error in node address assignment!")
+                        return err
+                }
+                ipaddr, iperr := UniqueAddress(networkName)
+                if iperr != nil {
+                        fmt.Println("error in node  address assignment!")
+                        return iperr
+                }
+
+                filter := bson.M{"macaddress": node.MacAddress}
+                update := bson.D{{"$set", bson.D{{"address", ipaddr}}}}
+
+                errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&node)
+
+                defer cancel()
+                if errN != nil {
+                        return errN
+                }
+        }
+
+        return err
+}
+
+//Checks to see if any other networks have the same name (id)
+func IsNetworkNameUnique(name string) (bool, error ){
 
         isunique := true
 
-        dbs := ListGroups()
+        dbs, err := ListNetworks()
+
+	if err != nil {
+		return false, err
+	}
 
 	for i := 0; i < len(dbs); i++ {
 
-		if name == dbs[i].NameID {
+		if name == dbs[i].NetID {
 			isunique = false
 		}
 	}
 
-        return isunique
+        return isunique, nil
 }
 
-func IsGroupDisplayNameUnique(name string) bool {
+func IsNetworkDisplayNameUnique(name string) (bool, error){
 
         isunique := true
 
-        dbs := ListGroups()
+        dbs, err := ListNetworks()
+        if err != nil {
+                return false, err
+        }
+
 
         for i := 0; i < len(dbs); i++ {
 
@@ -150,58 +269,80 @@ func IsGroupDisplayNameUnique(name string) bool {
                 }
         }
 
-        return isunique
+        return isunique, nil
+}
+
+func GetNetworkNodeNumber(networkName string) (int,  error){
+
+        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+        filter := bson.M{"network": networkName}
+        count, err := collection.CountDocuments(ctx, filter)
+	returncount := int(count)
+
+	//not sure if this is the right way of handling this error...
+        if err != nil {
+                return 9999, err
+        }
+
+        defer cancel()
+
+        return returncount, err
 }
 
-//Kind  of a weird name. Should just be GetGroups I think. Consider changing.
-//Anyway, returns all the groups
-func ListGroups() []models.Group{
-        var groups []models.Group
 
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
+//Kind  of a weird name. Should just be GetNetworks I think. Consider changing.
+//Anyway, returns all the networks
+func ListNetworks() ([]models.Network, error){
+
+        var networks []models.Network
+
+        collection := mongoconn.Client.Database("netmaker").Collection("networks")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
         cur, err := collection.Find(ctx, bson.M{}, options.Find().SetProjection(bson.M{"_id": 0}))
 
         if err != nil {
-                return groups
+                return networks, err
         }
 
         defer cancel()
 
         for cur.Next(context.TODO()) {
 
-                var group models.Group
-                err := cur.Decode(&group)
+                var network models.Network
+                err := cur.Decode(&network)
                 if err != nil {
-                        log.Fatal(err)
+			return networks, err
                 }
 
-                // add group our array
-                groups = append(groups, group)
+                // add network our array
+                networks = append(networks, network)
         }
 
         if err := cur.Err(); err != nil {
-                log.Fatal(err)
+                return networks, err
         }
 
-        return groups
+        return networks, err
 }
 
 //Checks to see if access key is valid
 //Does so by checking against all keys and seeing if any have the same value
 //may want to hash values before comparing...consider this
 //TODO: No error handling!!!!
-func IsKeyValid(groupname string, keyvalue string) bool{
+func IsKeyValid(networkname string, keyvalue string) bool{
 
-	group, _ := GetParentGroup(groupname)
+	network, _ := GetParentNetwork(networkname)
 	var key models.AccessKey
 	foundkey := false
 	isvalid := false
 
-	for i := len(group.AccessKeys) - 1; i >= 0; i-- {
-              currentkey:= group.AccessKeys[i]
+	for i := len(network.AccessKeys) - 1; i >= 0; i-- {
+              currentkey:= network.AccessKeys[i]
               if currentkey.Value == keyvalue {
 			key = currentkey
 			foundkey = true
@@ -215,27 +356,27 @@ func IsKeyValid(groupname string, keyvalue string) bool{
 	return isvalid
 }
 //TODO: Contains a fatal error return. Need to change
-//This just gets a group object from a group name
-//Should probably just be GetGroup. kind of a dumb name. 
-//Used in contexts where it's not the Parent group.
-func GetParentGroup(groupname string) (models.Group, error) {
+//This just gets a network object from a network name
+//Should probably just be GetNetwork. kind of a dumb name. 
+//Used in contexts where it's not the Parent network.
+func GetParentNetwork(networkname string) (models.Network, error) {
 
-        var group models.Group
+        var network models.Network
 
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
+        collection := mongoconn.Client.Database("netmaker").Collection("networks")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        filter := bson.M{"nameid": groupname}
-        err := collection.FindOne(ctx, filter).Decode(&group)
+        filter := bson.M{"netid": networkname}
+        err := collection.FindOne(ctx, filter).Decode(&network)
 
         defer cancel()
 
         if err != nil {
-                return group, err
+                return network, err
         }
 
-        return group, nil
+        return network, nil
 }
 
 //Check for valid IPv4 address
@@ -275,7 +416,7 @@ func GetNodeObj(id primitive.ObjectID) models.Node {
 
         var node models.Node
 
-	collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+	collection := mongoconn.Client.Database("netmaker").Collection("nodes")
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
         filter := bson.M{"_id": id}
@@ -292,9 +433,9 @@ func GetNodeObj(id primitive.ObjectID) models.Node {
         return node
 }
 
-//This  checks to  make sure a group name is valid.
+//This  checks to  make sure a network name is valid.
 //Switch to REGEX?
-func NameInGroupCharSet(name string) bool{
+func NameInNetworkCharSet(name string) bool{
 
 	charset := "abcdefghijklmnopqrstuvwxyz1234567890-_"
 
@@ -323,13 +464,13 @@ func NameInNodeCharSet(name string) bool{
 //The mac address acts as the Unique ID for nodes.
 //Is this a dumb thing to do? I thought it was cool but maybe it's dumb.
 //It doesn't really provide a tangible benefit over a random ID
-func GetNodeByMacAddress(group string, macaddress string) (models.Node, error) {
+func GetNodeByMacAddress(network string, macaddress string) (models.Node, error) {
 
         var node models.Node
 
-	filter := bson.M{"macaddress": macaddress, "group": group}
+	filter := bson.M{"macaddress": macaddress, "network": network}
 
-	collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+	collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
@@ -348,17 +489,17 @@ func GetNodeByMacAddress(group string, macaddress string) (models.Node, error) {
 //and checks against all nodes to see if it's taken, until it finds one.
 //TODO: We do not handle a case where we run out of addresses.
 //We will need to handle that eventually
-func UniqueAddress(groupName string) (string, error){
+func UniqueAddress(networkName string) (string, error){
 
-	var group models.Group
-	group, err := GetParentGroup(groupName)
+	var network models.Network
+	network, err := GetParentNetwork(networkName)
         if err != nil {
                 fmt.Println("UniqueAddress encountered  an error")
                 return "666", err
         }
 
 	offset := true
-	ip, ipnet, err := net.ParseCIDR(group.AddressRange)
+	ip, ipnet, err := net.ParseCIDR(network.AddressRange)
 	if err != nil {
 		fmt.Println("UniqueAddress encountered  an error")
 		return "666", err
@@ -368,15 +509,46 @@ func UniqueAddress(groupName string) (string, error){
 			offset = false
 			continue
 		}
-		if IsIPUnique(groupName, ip.String()){
+		if IsIPUnique(networkName, ip.String()){
 			return ip.String(), err
 		}
 	}
 	//TODO
-	err1 := errors.New("ERROR: No unique addresses available. Check group subnet.")
+	err1 := errors.New("ERROR: No unique addresses available. Check network subnet.")
 	return "W1R3: NO UNIQUE ADDRESSES AVAILABLE", err1
 }
 
+//pretty simple get
+func GetGlobalConfig() (bool, models.GlobalConfig, error) {
+
+	create := false
+
+        filter := bson.M{}
+
+        var globalconf models.GlobalConfig
+
+        collection := mongoconn.Client.Database("netmaker").Collection("config")
+
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+        err := collection.FindOne(ctx, filter).Decode(&globalconf)
+
+        defer cancel()
+
+	if err == mongo.ErrNoDocuments {
+                fmt.Println("Global config does not exist. Need to create.")
+		create = true
+		return create, globalconf, err
+	} else if err != nil {
+                fmt.Println(err)
+                fmt.Println("Could not get global config")
+                return create, globalconf, err
+        }
+	return create, globalconf, err
+}
+
+
+
 //generate an access key value
 func GenKey() string {
 
@@ -414,16 +586,16 @@ func GenKeyName() string {
 
 //checks if IP is unique in the address range
 //used by UniqueAddress
-func IsIPUnique(group string, ip string) bool {
+func IsIPUnique(network string, ip string) bool {
 
 	var node models.Node
 
 	isunique := true
 
-        collection := mongoconn.Client.Database("wirecat").Collection("nodes")
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-	filter := bson.M{"address": ip, "group": group}
+	filter := bson.M{"address": ip, "network": network}
 
         err := collection.FindOne(ctx, filter).Decode(&node)
 
@@ -442,41 +614,41 @@ func IsIPUnique(group string, ip string) bool {
 
 //called once key has been used by createNode
 //reduces value by one and deletes if necessary
-func DecrimentKey(groupName string, keyvalue string) {
+func DecrimentKey(networkName string, keyvalue string) {
 
-        var group models.Group
+        var network models.Network
 
-	group, err := GetParentGroup(groupName)
+	network, err := GetParentNetwork(networkName)
         if err != nil {
                 return
         }
 
-        for i := len(group.AccessKeys) - 1; i >= 0; i-- {
+        for i := len(network.AccessKeys) - 1; i >= 0; i-- {
 
-                currentkey := group.AccessKeys[i]
+                currentkey := network.AccessKeys[i]
                 if currentkey.Value == keyvalue {
-                        group.AccessKeys[i].Uses--
-			if group.AccessKeys[i].Uses < 1 {
+                        network.AccessKeys[i].Uses--
+			if network.AccessKeys[i].Uses < 1 {
 				//this is the part where it will call the delete
 				//not sure if there's edge cases I'm missing
-				DeleteKey(group, i)
+				DeleteKey(network, i)
 				return
 			}
                 }
         }
 
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
+        collection := mongoconn.Client.Database("netmaker").Collection("networks")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        filter := bson.M{"nameid": group.NameID}
+        filter := bson.M{"netid": network.NetID}
 
         update := bson.D{
                 {"$set", bson.D{
-                        {"accesskeys", group.AccessKeys},
+                        {"accesskeys", network.AccessKeys},
                 }},
         }
-        errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&group)
+        errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&network)
 
         defer cancel()
 
@@ -485,26 +657,26 @@ func DecrimentKey(groupName string, keyvalue string) {
         }
 }
 //takes the logic from controllers.deleteKey
-func DeleteKey(group models.Group, i int) {
+func DeleteKey(network models.Network, i int) {
 
-	group.AccessKeys = append(group.AccessKeys[:i],
-                                group.AccessKeys[i+1:]...)
+	network.AccessKeys = append(network.AccessKeys[:i],
+                                network.AccessKeys[i+1:]...)
 
-        collection := mongoconn.Client.Database("wirecat").Collection("groups")
+        collection := mongoconn.Client.Database("netmaker").Collection("networks")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
         // Create filter
-        filter := bson.M{"nameid": group.NameID}
+        filter := bson.M{"netid": network.NetID}
 
         // prepare update model.
         update := bson.D{
                 {"$set", bson.D{
-                        {"accesskeys", group.AccessKeys},
+                        {"accesskeys", network.AccessKeys},
                 }},
         }
 
-        errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&group)
+        errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&network)
 
         defer cancel()
 

functions/jwt.go

@@ -10,11 +10,11 @@ import (
 var jwtSecretKey = []byte("(BytesOverTheWire)")
 
 // CreateJWT func will used to create the JWT while signing in and signing out
-func CreateJWT(macaddress string, group string) (response string, err error) {
+func CreateJWT(macaddress string, network string) (response string, err error) {
     expirationTime := time.Now().Add(5 * time.Minute)
     claims := &models.Claims{
         MacAddress: macaddress,
-        Group: group,
+        Network: network,
         StandardClaims: jwt.StandardClaims{
             ExpiresAt: expirationTime.Unix(),
         },
@@ -50,6 +50,10 @@ func CreateUserJWT(username string, isadmin bool) (response string, err error) {
 func VerifyUserToken(tokenString string) (username string, isadmin bool, err error) {
     claims := &models.UserClaims{}
 
+    if tokenString == config.Config.Server.MasterKey {
+        return "masteradministrator", true, nil
+    }
+
     token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
         return jwtSecretKey, nil
     })
@@ -61,7 +65,7 @@ func VerifyUserToken(tokenString string) (username string, isadmin bool, err err
 }
 
 // VerifyToken func will used to Verify the JWT Token while using APIS
-func VerifyToken(tokenString string) (macaddress string, group string, err error) {
+func VerifyToken(tokenString string) (macaddress string, network string, err error) {
     claims := &models.Claims{}
 
     //this may be a stupid way of serving up a master key
@@ -75,7 +79,7 @@ func VerifyToken(tokenString string) (macaddress string, group string, err error
     })
 
     if token != nil {
-        return claims.MacAddress, claims.Group, nil
+        return claims.MacAddress, claims.Network, nil
     }
     return "", "", err
 }

go.mod

@@ -3,6 +3,7 @@ module github.com/gravitl/netmaker
 go 1.15
 
 require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/go-playground/universal-translator v0.17.0 // indirect
 	github.com/golang/protobuf v1.4.3

group_test.go

@@ -0,0 +1,620 @@
+package main
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"testing"
+
+	"github.com/gravitl/netmaker/models"
+	"github.com/stretchr/testify/assert"
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+var Networks []models.Network
+
+func TestCreateNetwork(t *testing.T) {
+	network := models.Network{}
+	network.NetID = "skynet"
+	network.AddressRange = "10.71.0.0/16"
+	t.Run("CreateNetwork", func(t *testing.T) {
+		response, err := api(t, network, http.MethodPost, "http://localhost:8081/api/networks", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+	})
+	t.Run("InvalidToken", func(t *testing.T) {
+		response, err := api(t, network, http.MethodPost, "http://localhost:8081/api/networks", "badkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+	t.Run("BadName", func(t *testing.T) {
+		//issue #42
+		t.Skip()
+	})
+	t.Run("BadAddress", func(t *testing.T) {
+		//issue #42
+		t.Skip()
+	})
+	t.Run("DuplicateNetwork", func(t *testing.T) {
+		//issue #42
+		t.Skip()
+	})
+}
+
+func TestGetNetworks(t *testing.T) {
+	t.Run("ValidToken", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/networks", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		err = json.NewDecoder(response.Body).Decode(&Networks)
+		assert.Nil(t, err, err)
+	})
+	t.Run("InvalidToken", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/networks", "badkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+}
+
+func TestGetNetwork(t *testing.T) {
+	t.Run("ValidToken", func(t *testing.T) {
+		var network models.Network
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		err = json.NewDecoder(response.Body).Decode(&network)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "skynet", network.DisplayName)
+	})
+	t.Run("InvalidToken", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/networks/skynet", "badkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+	t.Run("InvalidNetwork", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/networks/badnetwork", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+}
+
+func TestGetNetworkNodeNumber(t *testing.T) {
+	t.Run("ValidKey", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/networks/skynet/numnodes", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message int
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		//assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+	})
+	t.Run("InvalidKey", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/networks/skynet/numnodes", "badkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+	t.Run("BadNetwork", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/networks/badnetwork/numnodes", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+}
+
+func TestDeleteNetwork(t *testing.T) {
+	t.Run("InvalidKey", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/api/networks/skynet", "badkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+	t.Run("ValidKey", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message mongo.DeleteResult
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		assert.Equal(t, int64(1), message.DeletedCount)
+
+	})
+	t.Run("BadNetwork", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/api/networks/badnetwork", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+	t.Run("NodesExist", func(t *testing.T) {
+		t.Skip()
+	})
+	//Create Network for follow-on tests
+	createNetwork(t)
+}
+
+func TestCreateAccessKey(t *testing.T) {
+	key := models.AccessKey{}
+	key.Name = "skynet"
+	key.Uses = 10
+	t.Run("MultiUse", func(t *testing.T) {
+		response, err := api(t, key, http.MethodPost, "http://localhost:8081/api/networks/skynet/keys", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		message, err := ioutil.ReadAll(response.Body)
+		assert.Nil(t, err, err)
+		assert.NotNil(t, message, message)
+		returnedkey := getKey(t, key.Name)
+		assert.Equal(t, key.Name, returnedkey.Name)
+		assert.Equal(t, key.Uses, returnedkey.Uses)
+	})
+	deleteKey(t, "skynet", "skynet")
+	t.Run("ZeroUse", func(t *testing.T) {
+		//t.Skip()
+		key.Uses = 0
+		response, err := api(t, key, http.MethodPost, "http://localhost:8081/api/networks/skynet/keys", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		message, err := ioutil.ReadAll(response.Body)
+		assert.Nil(t, err, err)
+		assert.NotNil(t, message, message)
+		returnedkey := getKey(t, key.Name)
+		assert.Equal(t, key.Name, returnedkey.Name)
+		assert.Equal(t, 1, returnedkey.Uses)
+	})
+	t.Run("DuplicateAccessKey", func(t *testing.T) {
+		//t.Skip()
+		//this will fail
+		response, err := api(t, key, http.MethodPost, "http://localhost:8081/api/networks/skynet/keys", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnprocessableEntity, response.StatusCode)
+		deleteKey(t, key.Name, "skynet")
+	})
+
+	t.Run("InvalidToken", func(t *testing.T) {
+		response, err := api(t, key, http.MethodPost, "http://localhost:8081/api/networks/skynet/keys", "badkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+	t.Run("BadNetwork", func(t *testing.T) {
+		response, err := api(t, key, http.MethodPost, "http://localhost:8081/api/networks/badnetwork/keys", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+}
+
+func TestDeleteKey(t *testing.T) {
+	t.Run("KeyValid", func(t *testing.T) {
+		//fails -- deletecount not returned
+		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/api/networks/skynet/keys/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message mongo.DeleteResult
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		assert.Equal(t, int64(1), message.DeletedCount)
+	})
+	t.Run("InValidKey", func(t *testing.T) {
+		//fails -- status message  not returned
+		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/api/networks/skynet/keys/badkey", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "W1R3: This key does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+	t.Run("KeyInValidNetwork", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/api/networks/badnetwork/keys/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+	t.Run("InvalidCredentials", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/api/networks/skynet/keys/skynet", "badkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+}
+
+func TestGetKeys(t *testing.T) {
+	createKey(t)
+	t.Run("Valid", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/networks/skynet/keys", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		var keys []models.AccessKey
+		err = json.NewDecoder(response.Body).Decode(&keys)
+		assert.Nil(t, err, err)
+	})
+	//deletekeys
+	t.Run("InvalidNetwork", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/networks/badnetwork/keys", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+	t.Run("InvalidCredentials", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/networks/skynet/keys", "badkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+}
+
+func TestUpdateNetwork(t *testing.T) {
+	var returnedNetwork models.Network
+	t.Run("UpdateNetID", func(t *testing.T) {
+		type Network struct {
+			NetID string
+		}
+		var network Network
+		network.NetID = "wirecat"
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.NetID, returnedNetwork.NetID)
+	})
+	t.Run("NetIDInvalidCredentials", func(t *testing.T) {
+		type Network struct {
+			NetID string
+		}
+		var network Network
+		network.NetID = "wirecat"
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "badkey")
+		assert.Nil(t, err, err)
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+	})
+	t.Run("InvalidNetwork", func(t *testing.T) {
+		type Network struct {
+			NetID string
+		}
+		var network Network
+		network.NetID = "wirecat"
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/badnetwork", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusNotFound, message.Code)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+	t.Run("UpdateNetIDTooLong", func(t *testing.T) {
+		type Network struct {
+			NetID string
+		}
+		var network Network
+		network.NetID = "wirecat-skynet"
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnprocessableEntity, response.StatusCode)
+	})
+	t.Run("UpdateAddress", func(t *testing.T) {
+		type Network struct {
+			AddressRange string
+		}
+		var network Network
+		network.AddressRange = "10.0.0.1/24"
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.AddressRange, returnedNetwork.AddressRange)
+	})
+	t.Run("UpdateAddressInvalid", func(t *testing.T) {
+		type Network struct {
+			AddressRange string
+		}
+		var network Network
+		network.AddressRange = "10.0.0.1/36"
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnprocessableEntity, response.StatusCode)
+	})
+	t.Run("UpdateDisplayName", func(t *testing.T) {
+		type Network struct {
+			DisplayName string
+		}
+		var network Network
+		network.DisplayName = "wirecat"
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DisplayName, returnedNetwork.DisplayName)
+
+	})
+	t.Run("UpdateDisplayNameInvalidName", func(t *testing.T) {
+		type Network struct {
+			DisplayName string
+		}
+		var network Network
+		//create name that is longer than 100 chars
+		name := ""
+		for i := 0; i < 101; i++ {
+			name = name + "a"
+		}
+		network.DisplayName = name
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnprocessableEntity, message.Code)
+		assert.Equal(t, "W1R3: Field validation for 'DisplayName' failed.", message.Message)
+		assert.Equal(t, http.StatusUnprocessableEntity, response.StatusCode)
+	})
+	t.Run("UpdateInterface", func(t *testing.T) {
+		type Network struct {
+			DefaultInterface string
+		}
+		var network Network
+		network.DefaultInterface = "netmaker"
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DefaultInterface, returnedNetwork.DefaultInterface)
+
+	})
+	t.Run("UpdateListenPort", func(t *testing.T) {
+		type Network struct {
+			DefaultListenPort int32
+		}
+		var network Network
+		network.DefaultListenPort = 6000
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DefaultListenPort, returnedNetwork.DefaultListenPort)
+	})
+	t.Run("UpdateListenPortInvalidPort", func(t *testing.T) {
+		type Network struct {
+			DefaultListenPort int32
+		}
+		var network Network
+		network.DefaultListenPort = 1023
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnprocessableEntity, message.Code)
+		assert.Equal(t, "W1R3: Field validation for 'DefaultListenPort' failed.", message.Message)
+		assert.Equal(t, http.StatusUnprocessableEntity, response.StatusCode)
+	})
+	t.Run("UpdatePostUP", func(t *testing.T) {
+		type Network struct {
+			DefaultPostUp string
+		}
+		var network Network
+		network.DefaultPostUp = "sudo wg add-conf wc-netmaker /etc/wireguard/peers/conf"
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DefaultPostUp, returnedNetwork.DefaultPostUp)
+	})
+	t.Run("UpdatePostDown", func(t *testing.T) {
+		type Network struct {
+			DefaultPostDown string
+		}
+		var network Network
+		network.DefaultPostDown = "test string"
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DefaultPostDown, returnedNetwork.DefaultPostDown)
+	})
+	t.Run("UpdateKeepAlive", func(t *testing.T) {
+		type Network struct {
+			DefaultKeepalive int32
+		}
+		var network Network
+		network.DefaultKeepalive = 60
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DefaultKeepalive, returnedNetwork.DefaultKeepalive)
+	})
+	t.Run("UpdateKeepAliveTooBig", func(t *testing.T) {
+		type Network struct {
+			DefaultKeepAlive int32
+		}
+		var network Network
+		network.DefaultKeepAlive = 1001
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnprocessableEntity, message.Code)
+		assert.Equal(t, "W1R3: Field validation for 'DefaultKeepAlive' failed.", message.Message)
+		assert.Equal(t, http.StatusUnprocessableEntity, response.StatusCode)
+	})
+	t.Run("UpdateSaveConfig", func(t *testing.T) {
+		//causes panic
+		t.Skip()
+		type Network struct {
+			DefaultSaveConfig *bool
+		}
+		var network Network
+		value := false
+		network.DefaultSaveConfig = &value
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, *network.DefaultSaveConfig, *returnedNetwork.DefaultSaveConfig)
+	})
+	t.Run("UpdateManualSignUP", func(t *testing.T) {
+		t.Skip()
+		type Network struct {
+			AllowManualSignUp *bool
+		}
+		var network Network
+		value := true
+		network.AllowManualSignUp = &value
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, *network.AllowManualSignUp, *returnedNetwork.AllowManualSignUp)
+	})
+	t.Run("DefaultCheckInterval", func(t *testing.T) {
+		type Network struct {
+			DefaultCheckInInterval int32
+		}
+		var network Network
+		network.DefaultCheckInInterval = 6000
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DefaultCheckInInterval, returnedNetwork.DefaultCheckInInterval)
+	})
+	t.Run("DefaultCheckIntervalTooBig", func(t *testing.T) {
+		type Network struct {
+			DefaultCheckInInterval int32
+		}
+		var network Network
+		network.DefaultCheckInInterval = 100001
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnprocessableEntity, message.Code)
+		assert.Equal(t, "W1R3: Field validation for 'DefaultCheckInInterval' failed.", message.Message)
+		assert.Equal(t, http.StatusUnprocessableEntity, response.StatusCode)
+	})
+	t.Run("MultipleFields", func(t *testing.T) {
+		type Network struct {
+			DisplayName       string
+			DefaultListenPort int32
+		}
+		var network Network
+		network.DefaultListenPort = 7777
+		network.DisplayName = "multi"
+		response, err := api(t, network, http.MethodPut, "http://localhost:8081/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DisplayName, returnedNetwork.DisplayName)
+		assert.Equal(t, network.DefaultListenPort, returnedNetwork.DefaultListenPort)
+	})
+}

grpc/node.pb.go

@@ -23,6 +23,7 @@ const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 type LoginRequest struct {
 	Macaddress           string   `protobuf:"bytes,1,opt,name=macaddress,proto3" json:"macaddress,omitempty"`
 	Password             string   `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
+	Network              string   `protobuf:"bytes,3,opt,name=network,proto3" json:"network,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -67,6 +68,13 @@ func (m *LoginRequest) GetPassword() string {
 	return ""
 }
 
+func (m *LoginRequest) GetNetwork() string {
+	if m != nil {
+		return m.Network
+	}
+	return ""
+}
+
 type LoginResponse struct {
 	Accesstoken          string   `protobuf:"bytes,1,opt,name=accesstoken,proto3" json:"accesstoken,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
@@ -115,10 +123,10 @@ type Node struct {
 	Endpoint             string   `protobuf:"bytes,6,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
 	Macaddress           string   `protobuf:"bytes,7,opt,name=macaddress,proto3" json:"macaddress,omitempty"`
 	Password             string   `protobuf:"bytes,8,opt,name=password,proto3" json:"password,omitempty"`
-	Nodegroup            string   `protobuf:"bytes,9,opt,name=nodegroup,proto3" json:"nodegroup,omitempty"`
+	Nodenetwork          string   `protobuf:"bytes,9,opt,name=nodenetwork,proto3" json:"nodenetwork,omitempty"`
 	Ispending            bool     `protobuf:"varint,10,opt,name=ispending,proto3" json:"ispending,omitempty"`
 	Postup               string   `protobuf:"bytes,11,opt,name=postup,proto3" json:"postup,omitempty"`
-	Preup                string   `protobuf:"bytes,12,opt,name=preup,proto3" json:"preup,omitempty"`
+	Postdown             string   `protobuf:"bytes,12,opt,name=postdown,proto3" json:"postdown,omitempty"`
 	Keepalive            int32    `protobuf:"varint,13,opt,name=keepalive,proto3" json:"keepalive,omitempty"`
 	Saveconfig           bool     `protobuf:"varint,14,opt,name=saveconfig,proto3" json:"saveconfig,omitempty"`
 	Accesskey            string   `protobuf:"bytes,15,opt,name=accesskey,proto3" json:"accesskey,omitempty"`
@@ -128,6 +136,9 @@ type Node struct {
 	Checkininterval      int32    `protobuf:"varint,19,opt,name=checkininterval,proto3" json:"checkininterval,omitempty"`
 	Localaddress         string   `protobuf:"bytes,20,opt,name=localaddress,proto3" json:"localaddress,omitempty"`
 	Postchanges          string   `protobuf:"bytes,21,opt,name=postchanges,proto3" json:"postchanges,omitempty"`
+	Allowedips           string   `protobuf:"bytes,22,opt,name=allowedips,proto3" json:"allowedips,omitempty"`
+	Islocal              bool     `protobuf:"varint,23,opt,name=islocal,proto3" json:"islocal,omitempty"`
+	Localrange           string   `protobuf:"bytes,24,opt,name=localrange,proto3" json:"localrange,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -214,9 +225,9 @@ func (m *Node) GetPassword() string {
 	return ""
 }
 
-func (m *Node) GetNodegroup() string {
+func (m *Node) GetNodenetwork() string {
 	if m != nil {
-		return m.Nodegroup
+		return m.Nodenetwork
 	}
 	return ""
 }
@@ -235,9 +246,9 @@ func (m *Node) GetPostup() string {
 	return ""
 }
 
-func (m *Node) GetPreup() string {
+func (m *Node) GetPostdown() string {
 	if m != nil {
-		return m.Preup
+		return m.Postdown
 	}
 	return ""
 }
@@ -305,12 +316,35 @@ func (m *Node) GetPostchanges() string {
 	return ""
 }
 
+func (m *Node) GetAllowedips() string {
+	if m != nil {
+		return m.Allowedips
+	}
+	return ""
+}
+
+func (m *Node) GetIslocal() bool {
+	if m != nil {
+		return m.Islocal
+	}
+	return false
+}
+
+func (m *Node) GetLocalrange() string {
+	if m != nil {
+		return m.Localrange
+	}
+	return ""
+}
+
 type CheckInResponse struct {
 	Success              bool     `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
 	Needpeerupdate       bool     `protobuf:"varint,2,opt,name=needpeerupdate,proto3" json:"needpeerupdate,omitempty"`
 	Needconfigupdate     bool     `protobuf:"varint,3,opt,name=needconfigupdate,proto3" json:"needconfigupdate,omitempty"`
 	Nodemessage          string   `protobuf:"bytes,4,opt,name=nodemessage,proto3" json:"nodemessage,omitempty"`
 	Ispending            bool     `protobuf:"varint,5,opt,name=ispending,proto3" json:"ispending,omitempty"`
+	Needkeyupdate        bool     `protobuf:"varint,6,opt,name=needkeyupdate,proto3" json:"needkeyupdate,omitempty"`
+	Needdelete           bool     `protobuf:"varint,7,opt,name=needdelete,proto3" json:"needdelete,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -376,7 +410,23 @@ func (m *CheckInResponse) GetIspending() bool {
 	return false
 }
 
+func (m *CheckInResponse) GetNeedkeyupdate() bool {
+	if m != nil {
+		return m.Needkeyupdate
+	}
+	return false
+}
+
+func (m *CheckInResponse) GetNeeddelete() bool {
+	if m != nil {
+		return m.Needdelete
+	}
+	return false
+}
+
 type PeersResponse struct {
+	Isgateway            bool     `protobuf:"varint,1,opt,name=isgateway,proto3" json:"isgateway,omitempty"`
+	Gatewayrange         string   `protobuf:"bytes,2,opt,name=gatewayrange,proto3" json:"gatewayrange,omitempty"`
 	Publickey            string   `protobuf:"bytes,5,opt,name=publickey,proto3" json:"publickey,omitempty"`
 	Endpoint             string   `protobuf:"bytes,6,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
 	Address              string   `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
@@ -413,6 +463,20 @@ func (m *PeersResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_PeersResponse proto.InternalMessageInfo
 
+func (m *PeersResponse) GetIsgateway() bool {
+	if m != nil {
+		return m.Isgateway
+	}
+	return false
+}
+
+func (m *PeersResponse) GetGatewayrange() string {
+	if m != nil {
+		return m.Gatewayrange
+	}
+	return ""
+}
+
 func (m *PeersResponse) GetPublickey() string {
 	if m != nil {
 		return m.Publickey
@@ -613,7 +677,7 @@ func (m *UpdateNodeRes) GetNode() *Node {
 
 type ReadNodeReq struct {
 	Macaddress           string   `protobuf:"bytes,1,opt,name=macaddress,proto3" json:"macaddress,omitempty"`
-	Group                string   `protobuf:"bytes,2,opt,name=group,proto3" json:"group,omitempty"`
+	Network              string   `protobuf:"bytes,2,opt,name=network,proto3" json:"network,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -651,9 +715,9 @@ func (m *ReadNodeReq) GetMacaddress() string {
 	return ""
 }
 
-func (m *ReadNodeReq) GetGroup() string {
+func (m *ReadNodeReq) GetNetwork() string {
 	if m != nil {
-		return m.Group
+		return m.Network
 	}
 	return ""
 }
@@ -699,7 +763,7 @@ func (m *ReadNodeRes) GetNode() *Node {
 
 type DeleteNodeReq struct {
 	Macaddress           string   `protobuf:"bytes,1,opt,name=macaddress,proto3" json:"macaddress,omitempty"`
-	GroupName            string   `protobuf:"bytes,2,opt,name=groupName,proto3" json:"groupName,omitempty"`
+	NetworkName          string   `protobuf:"bytes,2,opt,name=networkName,proto3" json:"networkName,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -737,9 +801,9 @@ func (m *DeleteNodeReq) GetMacaddress() string {
 	return ""
 }
 
-func (m *DeleteNodeReq) GetGroupName() string {
+func (m *DeleteNodeReq) GetNetworkName() string {
 	if m != nil {
-		return m.GroupName
+		return m.NetworkName
 	}
 	return ""
 }
@@ -785,7 +849,7 @@ func (m *DeleteNodeRes) GetSuccess() bool {
 
 type GetPeersReq struct {
 	Macaddress           string   `protobuf:"bytes,1,opt,name=macaddress,proto3" json:"macaddress,omitempty"`
-	Group                string   `protobuf:"bytes,2,opt,name=group,proto3" json:"group,omitempty"`
+	Network              string   `protobuf:"bytes,2,opt,name=network,proto3" json:"network,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -823,9 +887,9 @@ func (m *GetPeersReq) GetMacaddress() string {
 	return ""
 }
 
-func (m *GetPeersReq) GetGroup() string {
+func (m *GetPeersReq) GetNetwork() string {
 	if m != nil {
-		return m.Group
+		return m.Network
 	}
 	return ""
 }
@@ -970,56 +1034,62 @@ func init() {
 func init() { proto.RegisterFile("grpc/node.proto", fileDescriptor_d13bd996b67da4ef) }
 
 var fileDescriptor_d13bd996b67da4ef = []byte{
-	// 813 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0x4d, 0x6f, 0xf3, 0x44,
-	0x10, 0x56, 0xf2, 0x26, 0x4d, 0x32, 0x69, 0x9a, 0xbe, 0xdb, 0x16, 0xad, 0xac, 0xaa, 0x8a, 0x7c,
-	0x40, 0x29, 0xa2, 0x49, 0x29, 0x12, 0xe2, 0x86, 0x44, 0x91, 0x10, 0x08, 0x2a, 0x64, 0xc4, 0x85,
-	0xdb, 0xc6, 0x9e, 0xb8, 0x56, 0x9c, 0xdd, 0x8d, 0xd7, 0x4e, 0xd5, 0x5f, 0xc7, 0x89, 0x7f, 0xc4,
-	0x91, 0x03, 0xda, 0x5d, 0x3b, 0xfe, 0x68, 0x48, 0xfb, 0xf6, 0x96, 0x79, 0x76, 0xbe, 0xe7, 0x99,
-	0x89, 0x61, 0x1c, 0x26, 0xd2, 0x9f, 0x73, 0x11, 0xe0, 0x4c, 0x26, 0x22, 0x15, 0xa4, 0xa3, 0x7f,
-	0xbb, 0x3f, 0xc3, 0xf1, 0x2f, 0x22, 0x8c, 0xb8, 0x87, 0x9b, 0x0c, 0x55, 0x4a, 0xae, 0x00, 0xd6,
-	0xcc, 0x67, 0x41, 0x90, 0xa0, 0x52, 0xb4, 0x35, 0x69, 0x4d, 0x07, 0x5e, 0x05, 0x21, 0x0e, 0xf4,
-	0x25, 0x53, 0xea, 0x49, 0x24, 0x01, 0x6d, 0x9b, 0xd7, 0x9d, 0xec, 0x7e, 0x05, 0xa3, 0xdc, 0x97,
-	0x92, 0x82, 0x2b, 0x24, 0x13, 0x18, 0x32, 0xdf, 0x47, 0xa5, 0x52, 0xb1, 0x42, 0x9e, 0x7b, 0xab,
-	0x42, 0xee, 0x3f, 0x1d, 0xe8, 0x3c, 0x88, 0x00, 0xc9, 0x09, 0xb4, 0xa3, 0x20, 0xd7, 0x68, 0x47,
-	0x01, 0x21, 0xd0, 0xe1, 0x6c, 0x8d, 0x79, 0x0c, 0xf3, 0x9b, 0x50, 0xe8, 0x15, 0x89, 0x7d, 0x30,
-	0x70, 0x21, 0xea, 0xac, 0xe3, 0x48, 0xa5, 0xc8, 0xa5, 0x48, 0x52, 0xda, 0x99, 0xb4, 0xa6, 0x5d,
-	0xaf, 0x82, 0x90, 0x4b, 0x18, 0xc8, 0x6c, 0x11, 0x47, 0xfe, 0x0a, 0x9f, 0x69, 0xd7, 0xd8, 0x96,
-	0x80, 0xae, 0x09, 0x79, 0x20, 0x45, 0xc4, 0x53, 0x7a, 0x64, 0x6b, 0x2a, 0xe4, 0x46, 0x3f, 0x7a,
-	0x07, 0xfb, 0xd1, 0xaf, 0xf7, 0x43, 0x47, 0xd5, 0x3d, 0x0e, 0x13, 0x91, 0x49, 0x3a, 0xb0, 0x51,
-	0x77, 0x80, 0x7e, 0x8d, 0x94, 0x44, 0x1e, 0x44, 0x3c, 0xa4, 0x30, 0x69, 0x4d, 0xfb, 0x5e, 0x09,
-	0x90, 0xcf, 0xe0, 0x48, 0x0a, 0x95, 0x66, 0x92, 0x0e, 0x8d, 0x61, 0x2e, 0x91, 0x73, 0xe8, 0xca,
-	0x04, 0x33, 0x49, 0x8f, 0x0d, 0x6c, 0x05, 0xed, 0x6b, 0x85, 0x28, 0x59, 0x1c, 0x6d, 0x91, 0x8e,
-	0x4c, 0xf9, 0x25, 0xa0, 0x6b, 0x50, 0x6c, 0x8b, 0xbe, 0xe0, 0xcb, 0x28, 0xa4, 0x27, 0x26, 0x54,
-	0x05, 0xd1, 0xd6, 0x76, 0x26, 0xba, 0x3b, 0x63, 0x9b, 0xe7, 0x0e, 0x30, 0x79, 0xf2, 0x14, 0x93,
-	0x25, 0xf3, 0x91, 0x9e, 0xda, 0xd7, 0x1d, 0xa0, 0x47, 0x1c, 0x33, 0x95, 0xfa, 0x8f, 0xe8, 0xaf,
-	0x22, 0x4e, 0x3f, 0xda, 0x11, 0x57, 0x20, 0xe2, 0xc2, 0xb1, 0x16, 0xd7, 0x22, 0x88, 0x96, 0x11,
-	0x06, 0x94, 0x18, 0x95, 0x1a, 0x46, 0xa6, 0x30, 0xce, 0xd5, 0x8d, 0xe7, 0x2d, 0x8b, 0xe9, 0x99,
-	0xa9, 0xa2, 0x09, 0x1b, 0x6f, 0xc2, 0x67, 0x71, 0x31, 0x91, 0xf3, 0xdc, 0x5b, 0x05, 0xd3, 0x39,
-	0xe9, 0x6e, 0xf9, 0x8f, 0x8c, 0x87, 0xa8, 0xe8, 0x85, 0xcd, 0xa9, 0x02, 0xb9, 0x7f, 0xb5, 0x60,
-	0x7c, 0xaf, 0x3d, 0xff, 0x54, 0x92, 0x95, 0x42, 0x4f, 0x65, 0xa6, 0x6a, 0x43, 0xc3, 0xbe, 0x57,
-	0x88, 0xe4, 0x73, 0x38, 0xe1, 0x88, 0x81, 0x44, 0x4c, 0x32, 0x19, 0xb0, 0xd4, 0xb2, 0xb2, 0xef,
-	0x35, 0x50, 0xf2, 0x05, 0x9c, 0x6a, 0xc4, 0x76, 0x35, 0xd7, 0xfc, 0x60, 0x34, 0x5f, 0xe0, 0x3a,
-	0x47, 0x4d, 0x85, 0x35, 0x2a, 0xc5, 0x42, 0x34, 0x94, 0x1d, 0x78, 0x55, 0xa8, 0xce, 0x8f, 0x6e,
-	0x83, 0x1f, 0xee, 0xdf, 0x2d, 0x18, 0xfd, 0x86, 0x98, 0xa8, 0x5d, 0xfe, 0xef, 0xe7, 0xf8, 0xfb,
-	0xf7, 0xaa, 0x39, 0x8d, 0xde, 0x9e, 0x69, 0x1c, 0xe4, 0xa6, 0x3b, 0x87, 0xd1, 0x7d, 0x82, 0x2c,
-	0x45, 0x7d, 0x05, 0x3c, 0xdc, 0x90, 0x2b, 0x30, 0x87, 0xc9, 0xcc, 0x60, 0x78, 0x07, 0x33, 0x73,
-	0xb1, 0xcc, 0xa3, 0x3d, 0x58, 0x0d, 0x03, 0xf5, 0x16, 0x83, 0x3f, 0x4c, 0xcf, 0x3f, 0x21, 0x42,
-	0xd5, 0xe0, 0xf5, 0x08, 0xf7, 0x30, 0xf4, 0x90, 0x05, 0xa5, 0xff, 0xc3, 0x27, 0xf4, 0x1c, 0xba,
-	0xf6, 0x24, 0xd8, 0xdb, 0x66, 0x05, 0xf7, 0xa6, 0xea, 0xe4, 0xf5, 0x98, 0xbf, 0xc2, 0xe8, 0x07,
-	0x8c, 0xb1, 0x5a, 0xd5, 0xe1, 0xa8, 0x97, 0x30, 0x30, 0x81, 0x1e, 0xca, 0xab, 0x5a, 0x02, 0xee,
-	0x75, 0xdd, 0x9d, 0xfa, 0xff, 0x6d, 0xd0, 0xd5, 0xfe, 0x88, 0x69, 0xce, 0xbd, 0xf7, 0x56, 0xfb,
-	0x6d, 0xd5, 0x89, 0x22, 0xd7, 0xd0, 0xd5, 0x7b, 0xa4, 0xf2, 0x72, 0xcf, 0x6c, 0xb9, 0x35, 0x7e,
-	0x7b, 0x56, 0xc3, 0xfd, 0x12, 0x60, 0xb7, 0xb9, 0x9b, 0x37, 0xb4, 0xa9, 0xd4, 0x56, 0xe4, 0xbb,
-	0xdd, 0x99, 0x49, 0x72, 0xaf, 0xb9, 0xe1, 0x85, 0x35, 0x6c, 0x9c, 0x04, 0xaf, 0xa9, 0x7d, 0xf7,
-	0x6f, 0x1b, 0x86, 0xda, 0xfb, 0xef, 0x98, 0x6c, 0x23, 0x1f, 0xc9, 0x2d, 0x74, 0xcd, 0x3f, 0x1e,
-	0x21, 0xd6, 0x41, 0xf5, 0xaf, 0xd4, 0x39, 0xab, 0x61, 0xf9, 0x96, 0x7e, 0x03, 0x50, 0xd2, 0x97,
-	0xe4, 0x2a, 0xb5, 0x0d, 0x70, 0xf6, 0x80, 0x8a, 0xdc, 0x42, 0xbf, 0xa0, 0x07, 0xf9, 0x68, 0x15,
-	0x2a, 0x9c, 0x73, 0x5e, 0x40, 0x4a, 0x47, 0x2a, 0x69, 0x5c, 0x44, 0xaa, 0x6d, 0x82, 0xb3, 0x07,
-	0x34, 0x76, 0x25, 0x15, 0x0a, 0xbb, 0x1a, 0xd7, 0x9c, 0x3d, 0xa0, 0x22, 0x77, 0xd0, 0x2f, 0x46,
-	0x5a, 0x64, 0x58, 0xe1, 0x89, 0xf3, 0x02, 0x52, 0xb7, 0x2d, 0x72, 0x03, 0xbd, 0xbc, 0xe7, 0xe4,
-	0xb4, 0x31, 0x82, 0x8d, 0xd3, 0x44, 0xd4, 0xf7, 0xf3, 0x3f, 0x6f, 0x42, 0x21, 0xc2, 0x18, 0x67,
-	0xa1, 0x88, 0x19, 0x0f, 0x67, 0x22, 0x09, 0xe7, 0xe6, 0x6b, 0x66, 0x91, 0x2d, 0xe7, 0xe9, 0xb3,
-	0x44, 0x35, 0x5f, 0x71, 0xf1, 0xc4, 0xcd, 0x77, 0x8e, 0x5c, 0x2c, 0x8e, 0xcc, 0xe3, 0xd7, 0xff,
-	0x05, 0x00, 0x00, 0xff, 0xff, 0x04, 0x8b, 0xcd, 0xc5, 0xfd, 0x08, 0x00, 0x00,
+	// 903 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x5f, 0x6f, 0xe4, 0x34,
+	0x10, 0x57, 0xf7, 0xba, 0xdd, 0xed, 0x6c, 0xb7, 0xed, 0xb9, 0xdc, 0x61, 0xad, 0x50, 0xb5, 0x8a,
+	0x10, 0xea, 0x21, 0xda, 0x2d, 0x45, 0x42, 0xbc, 0x21, 0x71, 0x48, 0x27, 0x24, 0x38, 0x41, 0x10,
+	0x2f, 0xbc, 0xb9, 0xf1, 0x34, 0x17, 0x6d, 0x6a, 0xa7, 0xb1, 0xb7, 0xab, 0x7e, 0x00, 0xc4, 0x57,
+	0xe4, 0xc3, 0xf0, 0x80, 0x3c, 0x76, 0x36, 0x4e, 0x5a, 0xda, 0x83, 0x7b, 0x8b, 0x7f, 0x9e, 0x3f,
+	0x9e, 0x9f, 0x7f, 0x33, 0x0e, 0x1c, 0xe4, 0x75, 0x95, 0x2d, 0x94, 0x96, 0x78, 0x56, 0xd5, 0xda,
+	0x6a, 0xb6, 0xed, 0xbe, 0x13, 0x09, 0x7b, 0x3f, 0xea, 0xbc, 0x50, 0x29, 0xde, 0xac, 0xd0, 0x58,
+	0x76, 0x0c, 0x70, 0x2d, 0x32, 0x21, 0x65, 0x8d, 0xc6, 0xf0, 0xad, 0xf9, 0xd6, 0xc9, 0x6e, 0x1a,
+	0x21, 0x6c, 0x06, 0xe3, 0x4a, 0x18, 0xb3, 0xd6, 0xb5, 0xe4, 0x03, 0xda, 0xdd, 0xac, 0x19, 0x87,
+	0x91, 0x42, 0xbb, 0xd6, 0xf5, 0x92, 0x3f, 0xa3, 0xad, 0x66, 0x99, 0x7c, 0x09, 0xd3, 0x90, 0xc5,
+	0x54, 0x5a, 0x19, 0x64, 0x73, 0x98, 0x88, 0x2c, 0x43, 0x63, 0xac, 0x5e, 0xa2, 0x0a, 0x79, 0x62,
+	0x28, 0xf9, 0x6b, 0x08, 0xdb, 0x6f, 0xb5, 0x44, 0xb6, 0x0f, 0x83, 0x42, 0x06, 0x8b, 0x41, 0x21,
+	0x19, 0x83, 0x6d, 0x25, 0xae, 0x31, 0x64, 0xa7, 0x6f, 0x97, 0xb9, 0x39, 0x72, 0xc8, 0xdc, 0x9c,
+	0xf7, 0x18, 0xa0, 0x2c, 0x8c, 0x45, 0x55, 0xe9, 0xda, 0xf2, 0xed, 0xf9, 0xd6, 0xc9, 0x30, 0x8d,
+	0x10, 0xf6, 0x09, 0xec, 0x56, 0xab, 0xcb, 0xb2, 0xc8, 0x96, 0x78, 0xc7, 0x87, 0xe4, 0xdb, 0x02,
+	0xae, 0x5a, 0x54, 0xb2, 0xd2, 0x85, 0xb2, 0x7c, 0xc7, 0x57, 0xdb, 0xac, 0x7b, 0x4c, 0x8d, 0x1e,
+	0x65, 0x6a, 0xdc, 0x63, 0x6a, 0x0e, 0x13, 0xc7, 0x7e, 0xc3, 0xd6, 0xae, 0x2f, 0x3f, 0x82, 0xdc,
+	0xb9, 0x0a, 0x53, 0xa1, 0x92, 0x85, 0xca, 0x39, 0xcc, 0xb7, 0x4e, 0xc6, 0x69, 0x0b, 0xb0, 0x97,
+	0xb0, 0x53, 0x69, 0x63, 0x57, 0x15, 0x9f, 0x90, 0x6b, 0x58, 0x51, 0x4e, 0x6d, 0xac, 0xd4, 0x6b,
+	0xc5, 0xf7, 0x42, 0xce, 0xb0, 0x76, 0x11, 0x97, 0x88, 0x95, 0x28, 0x8b, 0x5b, 0xe4, 0x53, 0x22,
+	0xa2, 0x05, 0x5c, 0x35, 0x46, 0xdc, 0x62, 0xa6, 0xd5, 0x55, 0x91, 0xf3, 0x7d, 0x4a, 0x18, 0x21,
+	0xce, 0xdb, 0xdf, 0x8e, 0xe3, 0xe9, 0xc0, 0xf3, 0xb4, 0x01, 0xe8, 0xb4, 0xca, 0x62, 0x7d, 0x25,
+	0x32, 0xe4, 0x87, 0x7e, 0x77, 0x03, 0xb8, 0x6a, 0x4b, 0x61, 0x6c, 0xf6, 0x0e, 0xb3, 0x65, 0xa1,
+	0xf8, 0x73, 0x5f, 0x6d, 0x04, 0xb1, 0x04, 0xf6, 0xdc, 0xf2, 0x5a, 0xcb, 0xe2, 0xaa, 0x40, 0xc9,
+	0x19, 0x99, 0x74, 0x30, 0x76, 0x02, 0x07, 0xc1, 0x9c, 0x22, 0xdf, 0x8a, 0x92, 0x1f, 0x51, 0x15,
+	0x7d, 0x98, 0xa2, 0xe9, 0x4c, 0x94, 0xcd, 0xdd, 0x7c, 0x14, 0xa2, 0x45, 0x98, 0x3b, 0x93, 0x63,
+	0x26, 0x7b, 0x27, 0x54, 0x8e, 0x86, 0xbf, 0xf0, 0x67, 0x8a, 0x20, 0xc7, 0x88, 0x28, 0x4b, 0xbd,
+	0x46, 0x59, 0x54, 0x86, 0xbf, 0xf4, 0xf7, 0xdb, 0x22, 0x4e, 0x73, 0x85, 0xa1, 0x98, 0xfc, 0x63,
+	0xa2, 0xab, 0x59, 0x92, 0xe6, 0xdc, 0x47, 0xed, 0x02, 0x71, 0xee, 0x3d, 0x5b, 0x24, 0xf9, 0x63,
+	0x00, 0x07, 0xaf, 0xdd, 0x99, 0x7f, 0x68, 0x1b, 0x82, 0xc3, 0xc8, 0xac, 0x88, 0x4f, 0x92, 0xfa,
+	0x38, 0x6d, 0x96, 0xec, 0x33, 0xd8, 0x57, 0x88, 0xb2, 0x42, 0xac, 0x57, 0x95, 0x14, 0xd6, 0x2b,
+	0x7f, 0x9c, 0xf6, 0x50, 0xf6, 0x39, 0x1c, 0x3a, 0xc4, 0xdf, 0x57, 0xb0, 0x7c, 0x46, 0x96, 0xf7,
+	0xf0, 0x46, 0x7f, 0xd7, 0x68, 0x8c, 0xc8, 0x91, 0xda, 0x22, 0xe8, 0x2f, 0x40, 0x5d, 0xfd, 0x0d,
+	0xfb, 0xfa, 0xfb, 0x14, 0xa6, 0x2e, 0xe6, 0x12, 0xef, 0x42, 0xa2, 0x1d, 0xb2, 0xe8, 0x82, 0x8e,
+	0x07, 0x07, 0x48, 0x2c, 0xd1, 0x22, 0x75, 0xc8, 0x38, 0x8d, 0x90, 0xe4, 0xcf, 0x01, 0x4c, 0x7f,
+	0x46, 0xac, 0xcd, 0x86, 0x05, 0xca, 0x9a, 0x0b, 0x8b, 0x6b, 0x71, 0x17, 0x78, 0x68, 0x01, 0x77,
+	0xaf, 0xe1, 0xd3, 0x33, 0xeb, 0x27, 0x40, 0x07, 0xfb, 0x80, 0x7e, 0xfe, 0xff, 0x33, 0xa4, 0xaf,
+	0xb7, 0xd1, 0x03, 0x7a, 0x7b, 0xb4, 0xfb, 0x92, 0x05, 0x4c, 0x5f, 0xd7, 0x28, 0x2c, 0xba, 0x89,
+	0x97, 0xe2, 0x0d, 0x3b, 0x06, 0x1a, 0xcf, 0xc4, 0xc1, 0xe4, 0x02, 0xce, 0x68, 0x6e, 0xd3, 0xa6,
+	0x1f, 0xdb, 0x3d, 0x07, 0xf3, 0x3e, 0x0e, 0xbf, 0xd1, 0xad, 0xfc, 0x87, 0x0c, 0xb1, 0xc3, 0xd3,
+	0x19, 0xde, 0xc0, 0x24, 0x45, 0x21, 0xdb, 0xf8, 0x8f, 0x3f, 0x24, 0xd1, 0x63, 0x31, 0xe8, 0x3e,
+	0x16, 0xa7, 0x71, 0xa0, 0xa7, 0xf3, 0xfe, 0x02, 0xd3, 0xef, 0x49, 0x4f, 0xef, 0x9b, 0xd9, 0x89,
+	0xdf, 0xa7, 0x7a, 0xdb, 0xbe, 0x23, 0x31, 0x94, 0xbc, 0xea, 0x86, 0x34, 0xff, 0xde, 0x9d, 0xae,
+	0xea, 0x37, 0x68, 0x83, 0x8a, 0x3f, 0xa4, 0xea, 0x6f, 0xe2, 0x40, 0x86, 0xbd, 0x82, 0xa1, 0xeb,
+	0x6d, 0x13, 0xca, 0x3e, 0xf2, 0x65, 0x77, 0xba, 0x25, 0xf5, 0x16, 0xc9, 0x17, 0x00, 0x9b, 0x69,
+	0xf2, 0xf4, 0xbd, 0xfe, 0x14, 0x59, 0x1b, 0xf6, 0xed, 0x66, 0xa8, 0xd6, 0x21, 0x6a, 0x70, 0x7c,
+	0xe1, 0x1d, 0x7b, 0x63, 0x2a, 0xed, 0x5b, 0x5f, 0xfc, 0x3d, 0x80, 0x89, 0x8b, 0xfe, 0x2b, 0xd6,
+	0xb7, 0x45, 0x86, 0xec, 0x1c, 0x86, 0xf4, 0xd2, 0x33, 0xe6, 0x03, 0xc4, 0x3f, 0x17, 0xb3, 0xa3,
+	0x0e, 0x16, 0x7a, 0xfe, 0x6b, 0x80, 0x56, 0xca, 0x2c, 0x98, 0x74, 0xba, 0x61, 0xf6, 0x00, 0x68,
+	0xd8, 0x39, 0x8c, 0x1b, 0x99, 0xb0, 0xe7, 0xde, 0x20, 0xd2, 0xdf, 0xec, 0x1e, 0x64, 0x5c, 0xa6,
+	0x56, 0xd2, 0x4d, 0xa6, 0x4e, 0x57, 0xcc, 0x1e, 0x00, 0xc9, 0xaf, 0x95, 0x43, 0xe3, 0xd7, 0xd1,
+	0xdc, 0xec, 0x01, 0xd0, 0xb0, 0x0b, 0x18, 0x37, 0x57, 0xda, 0x9c, 0x30, 0xd2, 0xca, 0xec, 0x1e,
+	0x64, 0xce, 0xb7, 0xd8, 0x29, 0x8c, 0x02, 0xe7, 0xec, 0xb0, 0x77, 0x05, 0x37, 0xb3, 0x3e, 0x62,
+	0xbe, 0x5b, 0xfc, 0x7e, 0x9a, 0x6b, 0x9d, 0x97, 0x78, 0x96, 0xeb, 0x52, 0xa8, 0xfc, 0x4c, 0xd7,
+	0xf9, 0x82, 0xfe, 0xef, 0x2e, 0x57, 0x57, 0x0b, 0x7b, 0x57, 0xa1, 0x59, 0x2c, 0x95, 0x5e, 0x2b,
+	0xfa, 0xf3, 0xab, 0x2e, 0x2f, 0x77, 0x68, 0xf3, 0xab, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x44,
+	0xc2, 0xe7, 0x07, 0x0f, 0x0a, 0x00, 0x00,
 }

grpc/node.proto

@@ -15,6 +15,7 @@ service NodeService {
 message LoginRequest {
   string macaddress = 1;
   string password = 2;
+  string network = 3;
 }
 
 message LoginResponse { string accesstoken = 1; }
@@ -28,10 +29,10 @@ message Node {
     string endpoint = 6;
     string macaddress = 7;
     string password = 8;
-    string nodegroup = 9;
+    string nodenetwork = 9;
     bool ispending = 10;
     string postup = 11;
-    string preup = 12;
+    string postdown = 12;
     int32 keepalive = 13;
     bool saveconfig = 14;
     string accesskey = 15;
@@ -41,6 +42,9 @@ message Node {
     int32 checkininterval = 19;
     string localaddress = 20;
     string postchanges = 21;
+    string allowedips = 22;
+    bool islocal = 23;
+    string localrange = 24;
 }
 
 message CheckInResponse {
@@ -49,9 +53,13 @@ message CheckInResponse {
     bool needconfigupdate = 3;
     string nodemessage = 4;
     bool ispending = 5;
+    bool needkeyupdate = 6;
+    bool needdelete = 7;
 }
 
 message PeersResponse {
+    bool isgateway = 1;
+    string gatewayrange = 2;
     string publickey = 5;
     string endpoint = 6;
     string address = 3;
@@ -78,7 +86,7 @@ message UpdateNodeRes {
 
 message ReadNodeReq {
     string macaddress = 1;
-    string group = 2;
+    string network = 2;
 }
 
 message ReadNodeRes {
@@ -87,7 +95,7 @@ message ReadNodeRes {
 
 message DeleteNodeReq {
     string macaddress = 1;
-    string groupName = 2;
+    string networkName = 2;
 }
 
 message DeleteNodeRes {
@@ -96,7 +104,7 @@ message DeleteNodeRes {
 
 message GetPeersReq {
     string macaddress = 1;
-    string group = 2;
+    string network = 2;
 }
 
 message GetPeersRes {

main.go

@@ -5,44 +5,97 @@ package main
 
 import (
     "log"
+    "flag"
+    "github.com/gravitl/netmaker/models"
     "github.com/gravitl/netmaker/controllers"
+    "github.com/gravitl/netmaker/serverctl"
+    "github.com/gravitl/netmaker/functions"
     "github.com/gravitl/netmaker/mongoconn"
     "github.com/gravitl/netmaker/config"
+    "go.mongodb.org/mongo-driver/bson"
     "fmt"
+    "time"
+    "net/http"
+    "strings"
+    "errors"
+    "io/ioutil"
     "os"
+    "os/exec"
     "net"
     "context"
+    "strconv"
     "sync"
     "os/signal"
+    "go.mongodb.org/mongo-driver/mongo"
     service "github.com/gravitl/netmaker/controllers"
     nodepb "github.com/gravitl/netmaker/grpc"
     "google.golang.org/grpc"
 )
+
+var ServerGRPC string
+var PortGRPC string
+
 //Start MongoDB Connection and start API Request Handler
 func main() {
+
+	var clientmode string
+	var defaultnet string
+	flag.StringVar(&clientmode, "clientmode", "on", "Have a client on the server")
+	flag.StringVar(&defaultnet, "defaultnet", "on", "Create a default network")
+	flag.Parse()
+	if clientmode == "on" {
+
+         cmd := exec.Command("id", "-u")
+         output, err := cmd.Output()
+
+         if err != nil {
+                 log.Fatal(err)
+         }
+         i, err := strconv.Atoi(string(output[:len(output)-1]))
+         if err != nil {
+                 log.Fatal(err)
+         }
+
+         if i != 0 {
+                 log.Fatal("To run in client mode requires root privileges. Either turn off client mode with the --clientmode=off flag, or run with sudo.")
+         }
+	}
+
 	log.Println("Server starting...")
 	mongoconn.ConnectDatabase()
 
-	var waitgroup sync.WaitGroup
+	installserver := false
+	if !(defaultnet == "off") {
+	if config.Config.Server.CreateDefault {
+		created, err := createDefaultNetwork()
+		if err != nil {
+			fmt.Printf("Error creating default network: %v", err)
+		}
+		if created && clientmode != "off" {
+			installserver = true
+		}
+	}
+	}
+	var waitnetwork sync.WaitGroup
 
 	if config.Config.Server.AgentBackend {
-		waitgroup.Add(1)
-		go runGRPC(&waitgroup)
+		waitnetwork.Add(1)
+		go runGRPC(&waitnetwork, installserver)
 	}
 
 	if config.Config.Server.RestBackend {
-		waitgroup.Add(1)
-		controller.HandleRESTRequests(&waitgroup)
+		waitnetwork.Add(1)
+		controller.HandleRESTRequests(&waitnetwork)
 	}
 	if !config.Config.Server.RestBackend && !config.Config.Server.AgentBackend {
 		fmt.Println("Oops! No Server Mode selected. Nothing being served.")
 	}
-	waitgroup.Wait()
+	waitnetwork.Wait()
 	fmt.Println("Exiting now.")
 }
 
 
-func runGRPC(wg *sync.WaitGroup) {
+func runGRPC(wg *sync.WaitGroup, installserver bool) {
 
 
 	defer wg.Done()
@@ -59,6 +112,27 @@ func runGRPC(wg *sync.WaitGroup) {
         if os.Getenv("GRPC_PORT") != "" {
 		grpcport = ":" + os.Getenv("GRPC_PORT")
         }
+	PortGRPC = grpcport
+	if os.Getenv("BACKEND_URL") == ""  {
+		if config.Config.Server.Host == "" {
+			ServerGRPC, _ = getPublicIP()
+		} else {
+			ServerGRPC = config.Config.Server.Host
+		}
+	} else {
+		ServerGRPC = os.Getenv("BACKEND_URL")
+	}
+	fmt.Println("GRPC Server set to: " + ServerGRPC)
+	fmt.Println("GRPC Port set to: " + PortGRPC)
+	var gconf models.GlobalConfig
+	gconf.ServerGRPC = ServerGRPC
+	gconf.PortGRPC = PortGRPC
+	gconf.Name = "netmaker"
+	err := setGlobalConfig(gconf)
+
+	if err != nil && err != mongo.ErrNoDocuments{
+	      log.Fatalf("Unable to set global config: %v", err)
+	}
 
 
 	listener, err := net.Listen("tcp", grpcport)
@@ -87,6 +161,25 @@ func runGRPC(wg *sync.WaitGroup) {
         }()
         fmt.Println("Agent Server succesfully started on port " + grpcport + " (gRPC)")
 
+	if installserver {
+			fmt.Println("Adding server to " + config.Config.Server.DefaultNetName)
+                        success, err := serverctl.AddNetwork(config.Config.Server.DefaultNetName)
+                        if err != nil {
+                                fmt.Printf("Error adding to default network: %v", err)
+				fmt.Println("")
+				fmt.Println("Unable to add server to network. Continuing.")
+				fmt.Println("Please investigate client installation on server.")
+			} else if !success {
+                                fmt.Println("Unable to add server to network. Continuing.")
+                                fmt.Println("Please investigate client installation on server.")
+			} else{
+                                fmt.Println("Server successfully added to default network.")
+			}
+	}
+        fmt.Println("Setup complete. You are ready to begin using netmaker.")
+
+
+
         // Right way to stop the server using a SHUTDOWN HOOK
         // Create a channel to receive OS signals
         c := make(chan os.Signal)
@@ -108,6 +201,113 @@ func runGRPC(wg *sync.WaitGroup) {
         mongoconn.Client.Disconnect(context.TODO())
         fmt.Println("MongoDB connection closed.")
 }
+func setGlobalConfig(globalconf models.GlobalConfig) (error) {
+
+        collection := mongoconn.Client.Database("netmaker").Collection("config")
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+	create, _, err := functions.GetGlobalConfig()
+	if create {
+		_, err := collection.InsertOne(ctx, globalconf)
+		defer cancel()
+		if err != nil {
+			if err == mongo.ErrNoDocuments || strings.Contains(err.Error(), "no documents in result"){
+				return nil
+			} else {
+				return err
+			}
+		}
+	} else {
+		filter := bson.M{"name": "netmaker"}
+		update := bson.D{
+			{"$set", bson.D{
+				{"servergrpc", globalconf.ServerGRPC},
+				{"portgrpc", globalconf.PortGRPC},
+			}},
+		}
+		err := collection.FindOneAndUpdate(ctx, filter, update).Decode(&globalconf)
+                        if err == mongo.ErrNoDocuments {
+			//if err == mongo.ErrNoDocuments || strings.Contains(err.Error(), "no documents in result"){
+                                return nil
+                        }
+	}
+	return err
+}
+
+func createDefaultNetwork() (bool, error) {
+
+	iscreated := false
+	exists, err := functions.NetworkExists(config.Config.Server.DefaultNetName)
+
+	if exists || err != nil {
+		fmt.Println("Default network already exists")
+		fmt.Println("Skipping default network create")
+		return iscreated, err
+	} else {
+
+	var network models.Network
+
+	network.NetID = config.Config.Server.DefaultNetName
+	network.AddressRange = config.Config.Server.DefaultNetRange
+	network.DisplayName = config.Config.Server.DefaultNetName
+        network.SetDefaults()
+        network.SetNodesLastModified()
+        network.SetNetworkLastModified()
+        network.KeyUpdateTimeStamp = time.Now().Unix()
+	priv := false
+	network.IsLocal = &priv
+        network.KeyUpdateTimeStamp = time.Now().Unix()
+	allow := true
+	network.AllowManualSignUp = &allow
+
+	fmt.Println("Creating default network.")
+
+
+        collection := mongoconn.Client.Database("netmaker").Collection("networks")
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+
+        // insert our network into the network table
+        _, err = collection.InsertOne(ctx, network)
+        defer cancel()
+
+	}
+	if err == nil {
+		iscreated = true
+	}
+	return iscreated, err
+
+
+}
+
+
+func getPublicIP() (string, error) {
+
+        iplist := []string{"https://ifconfig.me", "http://api.ipify.org", "http://ipinfo.io/ip"}
+        endpoint := ""
+        var err error
+            for _, ipserver := range iplist {
+                resp, err := http.Get(ipserver)
+                if err != nil {
+                        continue
+                }
+                defer resp.Body.Close()
+                if resp.StatusCode == http.StatusOK {
+                        bodyBytes, err := ioutil.ReadAll(resp.Body)
+                        if err != nil {
+                                continue
+                        }
+                        endpoint = string(bodyBytes)
+                        break
+                }
+
+        }
+        if err == nil && endpoint == "" {
+                err =  errors.New("Public Address Not Found.")
+        }
+        return endpoint, err
+}
+
 
 func authServerUnaryInterceptor() grpc.ServerOption {
 	return grpc.UnaryInterceptor(controller.AuthServerUnaryInterceptor)

models/group.go → models/network.go

@@ -6,66 +6,67 @@ import (
   "time"
 )
 
-//Group Struct
+//Network Struct
 //At  some point, need to replace all instances of Name with something else like  Identifier
-type Group struct {
+type Network struct {
 	ID	primitive.ObjectID `json:"_id,omitempty" bson:"_id,omitempty"`
 	AddressRange	string `json:"addressrange" bson:"addressrange" validate:"required,addressrange_valid"`
 	DisplayName string `json:"displayname,omitempty" bson:"displayname,omitempty" validate:"omitempty,displayname_unique,min=1,max=100"`
-	NameID string `json:"nameid" bson:"nameid" validate:"required,nameid_valid,min=1,max=12"`
+	NetID string `json:"netid" bson:"netid" validate:"required,netid_valid,min=1,max=12"`
 	NodesLastModified	int64 `json:"nodeslastmodified" bson:"nodeslastmodified"`
-	GroupLastModified int64 `json:"grouplastmodified" bson:"grouplastmodified"`
-	DefaultInterface	string `json:"defaulinterface" bson:"defaultinterface"`
+	NetworkLastModified int64 `json:"networklastmodified" bson:"networklastmodified"`
+	DefaultInterface	string `json:"defaultinterface" bson:"defaultinterface"`
         DefaultListenPort      int32 `json:"defaultlistenport,omitempty" bson:"defaultlistenport,omitempty" validate:"omitempty,numeric,min=1024,max=65535"`
         DefaultPostUp  string `json:"defaultpostup" bson:"defaultpostup"`
-        DefaultPreUp   string `json:"defaultpreup" bson:"defaultpreup"`
+        DefaultPostDown   string `json:"defaultpostdown" bson:"defaultpostdown"`
+        KeyUpdateTimeStamp      int64 `json:"keyupdatetimestamp" bson:"keyupdatetimestamp"`
         DefaultKeepalive int32 `json:"defaultkeepalive" bson:"defaultkeepalive" validate: "omitempty,numeric,max=1000"`
         DefaultSaveConfig      *bool `json:"defaultsaveconfig" bson:"defaultsaveconfig"`
 	AccessKeys	[]AccessKey `json:"accesskeys" bson:"accesskeys"`
 	AllowManualSignUp *bool `json:"allowmanualsignup" bson:"allowmanualsignup"`
+	IsLocal *bool `json:"islocal" bson:"islocal"`
+	LocalRange string `json:"localrange" bson:"localrange" validate:"localrange_valid"`
 	DefaultCheckInInterval int32 `json:"checkininterval,omitempty" bson:"checkininterval,omitempty" validate:"omitempty,numeric,min=1,max=100000"`
 }
 
 //TODO:
 //Not  sure if we  need the below two functions. Got rid  of one of the calls. May want  to revisit
-func(group *Group) SetNodesLastModified(){
-        group.NodesLastModified = time.Now().Unix()
+func(network *Network) SetNodesLastModified(){
+        network.NodesLastModified = time.Now().Unix()
 }
 
-func(group *Group) SetGroupLastModified(){
-        group.GroupLastModified = time.Now().Unix()
+func(network *Network) SetNetworkLastModified(){
+        network.NetworkLastModified = time.Now().Unix()
 }
 
-func(group *Group) SetDefaults(){
-    if group.DisplayName == "" {
-        group.DisplayName = group.NameID
+func(network *Network) SetDefaults(){
+    if network.DisplayName == "" {
+        network.DisplayName = network.NetID
     }
-    if group.DefaultInterface == "" {
-	group.DefaultInterface = "wc-" + group.NameID
+    if network.DefaultInterface == "" {
+	network.DefaultInterface = "nm-" + network.NetID
     }
-    if group.DefaultListenPort == 0 {
-        group.DefaultListenPort = 5555
+    if network.DefaultListenPort == 0 {
+        network.DefaultListenPort = 51821
     }
-    if group.DefaultPreUp == "" {
+    if network.DefaultPostDown == "" {
 
     }
-    if group.DefaultSaveConfig == nil {
+    if network.DefaultSaveConfig == nil {
 	defaultsave := true
-        group.DefaultSaveConfig = &defaultsave
+        network.DefaultSaveConfig = &defaultsave
     }
-    if group.DefaultKeepalive == 0 {
-        group.DefaultKeepalive = 20
+    if network.DefaultKeepalive == 0 {
+        network.DefaultKeepalive = 20
     }
-    if group.DefaultPostUp == "" {
-            postup := "sudo wg addconf " + group.DefaultInterface + " /etc/wireguard/peers.conf"
-        group.DefaultPostUp = postup
+    if network.DefaultPostUp == "" {
     }
     //Check-In Interval for Nodes, In Seconds
-    if group.DefaultCheckInInterval == 0 {
-        group.DefaultCheckInInterval = 120
+    if network.DefaultCheckInInterval == 0 {
+        network.DefaultCheckInInterval = 30
     }
-    if group.AllowManualSignUp == nil {
+    if network.AllowManualSignUp == nil {
 	signup := false
-        group.AllowManualSignUp = &signup
+        network.AllowManualSignUp = &signup
     }
 }

models/node.go

@@ -25,45 +25,50 @@ type Node struct {
 	PublicKey	string `json:"publickey" bson:"publickey" validate:"pubkey_check"`
 	Endpoint	string `json:"endpoint" bson:"endpoint" validate:"endpoint_check"`
 	PostUp	string `json:"postup" bson:"postup"`
-	PreUp	string `json:"preup" bson:"preup"`
+	PostDown	string `json:"postdown" bson:"postdown"`
+	AllowedIPs	string `json:"allowedips" bson:"allowedips"`
 	PersistentKeepalive int32 `json:"persistentkeepalive" bson:"persistentkeepalive" validate: "omitempty,numeric,max=1000"`
 	SaveConfig	*bool `json:"saveconfig" bson:"saveconfig"`
 	AccessKey	string `json:"accesskey" bson:"accesskey"`
 	Interface	string `json:"interface" bson:"interface"`
 	LastModified	int64 `json:"lastmodified" bson:"lastmodified"`
+	KeyUpdateTimeStamp	int64 `json:"keyupdatetimestamp" bson:"keyupdatetimestamp"`
+	ExpirationDateTime	int64 `json:"expdatetime" bson:"expdatetime"`
 	LastPeerUpdate	int64 `json:"lastpeerupdate" bson:"lastpeerupdate"`
 	LastCheckIn	int64 `json:"lastcheckin" bson:"lastcheckin"`
 	MacAddress	string `json:"macaddress" bson:"macaddress" validate:"required,macaddress_valid,macaddress_unique"`
 	CheckInInterval	int32 `json:"checkininterval" bson:"checkininterval"`
 	Password	string `json:"password" bson:"password" validate:"password_check"`
-	Group	string `json:"group" bson:"group" validate:"group_exists"`
+	Network	string `json:"network" bson:"network" validate:"network_exists"`
 	IsPending bool `json:"ispending" bson:"ispending"`
+	IsGateway bool `json:"isgateway" bson:"isgateway"`
+	GatewayRange string `json:"gatewayrange" bson:"gatewayrange"`
 	PostChanges string `json:"postchanges" bson:"postchanges"`
 }
 
 
 //TODO: Contains a fatal error return. Need to change
-//Used in contexts where it's not the Parent group.
-func(node *Node) GetGroup() (Group, error){
+//Used in contexts where it's not the Parent network.
+func(node *Node) GetNetwork() (Network, error){
 
-        var group Group
+        var network Network
 
-        collection := mongoconn.GroupDB
-        //collection := mongoconn.Client.Database("wirecat").Collection("groups")
+        collection := mongoconn.NetworkDB
+        //collection := mongoconn.Client.Database("netmaker").Collection("networks")
 
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
-        filter := bson.M{"nameid": node.Group}
-        err := collection.FindOne(ctx, filter).Decode(&group)
+        filter := bson.M{"netid": node.Network}
+        err := collection.FindOne(ctx, filter).Decode(&network)
 
         defer cancel()
 
         if err != nil {
                 //log.Fatal(err)
-                return group, err
+                return network, err
         }
 
-        return group, err
+        return network, err
 }
 
 
@@ -81,6 +86,11 @@ func(node *Node) SetLastPeerUpdate(){
         node.LastPeerUpdate = time.Now().Unix()
 }
 
+func(node *Node) SetExpirationDateTime(){
+        node.ExpirationDateTime = time.Unix(33174902665, 0).Unix()
+}
+
+
 func(node *Node) SetDefaultName(){
     if node.Name == "" {
         nodeid := StringWithCharset(5, charset)
@@ -93,33 +103,35 @@ func(node *Node) SetDefaultName(){
 //This should exist on the node.go struct. I'm sure there was a reason?
 func(node *Node) SetDefaults() {
 
-    //TODO: Maybe I should make Group a part of the node struct. Then we can just query the Group object for stuff.
-    parentGroup, _ := node.GetGroup()
+    //TODO: Maybe I should make Network a part of the node struct. Then we can just query the Network object for stuff.
+    parentNetwork, _ := node.GetNetwork()
+
+    node.ExpirationDateTime = time.Unix(33174902665, 0).Unix()
 
     if node.ListenPort == 0 {
-        node.ListenPort = parentGroup.DefaultListenPort
+        node.ListenPort = parentNetwork.DefaultListenPort
     }
-    if node.PreUp == "" {
+    if node.PostDown == "" {
         //Empty because we dont set it
         //may want to set it to something in the future
     }
     //TODO: This is dumb and doesn't work
     //Need to change
     if node.SaveConfig == nil {
-        defaultsave := *parentGroup.DefaultSaveConfig
+        defaultsave := *parentNetwork.DefaultSaveConfig
         node.SaveConfig = &defaultsave
     }
     if node.Interface == "" {
-        node.Interface = parentGroup.DefaultInterface
+        node.Interface = parentNetwork.DefaultInterface
     }
     if node.PersistentKeepalive == 0 {
-        node.PersistentKeepalive = parentGroup.DefaultKeepalive
+        node.PersistentKeepalive = parentNetwork.DefaultKeepalive
     }
     if node.PostUp == "" {
-            postup := parentGroup.DefaultPostUp
+            postup := parentNetwork.DefaultPostUp
         node.PostUp = postup
     }
-    node.CheckInInterval = parentGroup.DefaultCheckInInterval
+    node.CheckInInterval = parentNetwork.DefaultCheckInInterval
 
 }
 

models/returnNode.go

@@ -1,4 +1,4 @@
-//TODO:  Either add a returnGroup and returnKey, or delete this
+//TODO:  Either add a returnNetwork and returnKey, or delete this
 package models
 
 type ReturnNode struct {
@@ -12,10 +12,14 @@ type ReturnNode struct {
 	PublicKey	string `json:"publickey" bson:"publickey" validate:"base64"`
 	Endpoint	string `json:"endpoint" bson:"endpoint" validate:"required,ipv4"`
 	PostUp	string `json:"postup" bson:"postup"`
-	PreUp	string `json:"preup" bson:"preup"`
+	PostDown	string `json:"postdown" bson:"postdown"`
 	PersistentKeepalive int32 `json:"persistentkeepalive" bson:"persistentkeepalive"`
 	SaveConfig	*bool `json:"saveconfig" bson:"saveconfig"`
 	Interface	string `json:"interface" bson:"interface"`
-	Group	string `json:"group" bson:"group"`
+	Network	string `json:"network" bson:"network"`
 	IsPending	*bool `json:"ispending" bson:"ispending"`
+	IsGateway	*bool `json:"isgateway" bson:"isgateway"`
+	GatewayRange	string `json:"gatewayrange" bson:"gatewayrange"`
+        LocalAddress    string `json:"localaddress" bson:"localaddress" validate:"localaddress_check"`
+        ExpirationDateTime      int64 `json:"expdatetime" bson:"expdatetime"`
 }

models/structs.go

@@ -32,7 +32,7 @@ type SuccessfulUserLoginResponse struct {
 // Claims is  a struct that will be encoded to a JWT.
 // jwt.StandardClaims is an embedded type to provide expiry time
 type Claims struct {
-    Group string
+    Network string
     MacAddress string
     jwt.StandardClaims
 }
@@ -49,7 +49,7 @@ type ErrorResponse struct {
 }
 
 type NodeAuth struct {
-    Group    string
+    Network    string
     Password string
     MacAddress string
 }
@@ -64,6 +64,7 @@ type SuccessResponse struct {
 type AccessKey struct {
     Name string `json:"name" bson:"name"`
     Value string `json:"value" bson:"value"`
+    AccessString string `json:"accessstring" bson:"accessstring"`
     Uses int `json:"uses" bson:"uses"`
 }
 
@@ -72,10 +73,19 @@ type DisplayKey struct {
     Uses int `json:"uses" bson:"uses"`
 }
 
+type GlobalConfig struct {
+    Name string `json:"name" bson:"name"`
+    PortGRPC string `json:"portgrpc" bson:"portgrpc"`
+    ServerGRPC string `json:"servergrpc" bson:"servergrpc"`
+}
+
+
 type CheckInResponse struct{
     Success bool `json:"success" bson:"success"`
     NeedPeerUpdate bool `json:"needpeerupdate" bson:"needpeerupdate"`
     NeedConfigUpdate bool `json:"needconfigupdate" bson:"needconfigupdate"`
+    NeedKeyUpdate bool `json:"needkeyupdate" bson:"needkeyupdate"`
+    NeedDelete bool `json:"needdelete" bson:"needdelete"`
     NodeMessage string `json:"nodemessage" bson:"nodemessage"`
     IsPending bool `json:"ispending" bson:"ispending"`
 }
@@ -85,7 +95,20 @@ type PeersResponse struct {
     Endpoint string `json:"endpoint" bson:"endpoint"`
     Address string `json:"address" bson:"address"`
     LocalAddress string `json:"localaddress" bson:"localaddress"`
+    IsGateway bool `json:"isgateway" bson:"isgateway"`
+    GatewayRange string `json:"gatewayrange" bson:"gatewayrange"`
     ListenPort int32 `json:"listenport" bson:"listenport"`
     KeepAlive int32 `json:"persistentkeepalive" bson:"persistentkeepalive"`
 }
 
+type GatewayRequest struct {
+    NodeID string `json:"nodeid" bson:"nodeid"`
+    NetID string `json:"netid" bson:"netid"`
+    RangeString string `json:"rangestring" bson:"rangestring"`
+    Ranges []string `json:"ranges" bson:"ranges"`
+    Interface string `json:"interface" bson:"interface"`
+    PostUp string `json:"postup" bson:"postup"`
+    PostDown string `json:"postdown" bson:"postdown"`
+}
+
+

mongoconn/mongoconn.go

@@ -13,7 +13,7 @@ import (
 
 var Client *mongo.Client
 var NodeDB *mongo.Collection
-var GroupDB *mongo.Collection
+var NetworkDB *mongo.Collection
 var user string
 var pass string
 var host string
@@ -93,8 +93,8 @@ func ConnectDatabase() {
         log.Fatal(err)
     }
 
-    NodeDB = Client.Database("wirecat").Collection("nodes")
-    GroupDB = Client.Database("wirecat").Collection("groups")
+    NodeDB = Client.Database("netmaker").Collection("nodes")
+    NetworkDB = Client.Database("netmaker").Collection("networks")
 
     log.Println("Database Connected.")
 }

netclient-install.sh

@@ -1,13 +1,9 @@
 #!/bin/sh
 set -e
 
-[ -z "$SERVER_URL" ] && echo "Need to set SERVER_URL" && exit 1;
-[ -z "$NET_NAME" ] && echo "Need to set NET_NAME" && exit 1;
 [ -z "$KEY" ] && KEY=nokey;
 
-
-
-wget -O netclient https://github.com/gravitl/netmaker/releases/download/v0.1/netclient
+wget -O netclient https://github.com/gravitl/netmaker/releases/download/latest/netclient
 chmod +x netclient
-sudo ./netclient -c install -s $SERVER_URL -g $NET_NAME -k $KEY
+sudo ./netclient -c install -t $KEY
 rm -f netclient

netclient/config/config.go

@@ -3,18 +3,20 @@ package config
 import (
 //  "github.com/davecgh/go-spew/spew"
   "os"
+  "errors"
   "fmt"
   "log"
   "gopkg.in/yaml.v3"
   //homedir "github.com/mitchellh/go-homedir"
 )
 
-var Config *ClientConfig
+//var Config *ClientConfig
 
 // Configurations exported
 type ClientConfig struct {
 	Server ServerConfig `yaml:"server"`
 	Node NodeConfig `yaml:"node"`
+	Network string
 }
 type ServerConfig struct {
         Address string `yaml:"address"`
@@ -24,14 +26,17 @@ type ServerConfig struct {
 type NodeConfig struct {
         Name string `yaml:"name"`
         Interface string `yaml:"interface"`
-        Group string `yaml:"group"`
+        Network string `yaml:"network"`
         Password string `yaml:"password"`
         MacAddress string `yaml:"macaddress"`
         LocalAddress string `yaml:"localaddress"`
         WGAddress string `yaml:"wgaddress"`
         RoamingOff bool `yaml:"roamingoff"`
+        IsLocal bool `yaml:"islocal"`
+        AllowedIPs string `yaml:"allowedips"`
+        LocalRange string `yaml:"localrange"`
         PostUp string `yaml:"postup"`
-        PreUp string `yaml:"preup"`
+        PostDown string `yaml:"postdown"`
         Port int32 `yaml:"port"`
         KeepAlive int32 `yaml:"keepalive"`
         PublicKey string `yaml:"publickey"`
@@ -41,7 +46,11 @@ type NodeConfig struct {
 }
 
 //reading in the env file
-func Write(config *ClientConfig) error{
+func Write(config *ClientConfig, network string) error{
+	if network == "" {
+		err := errors.New("No network provided. Exiting.")
+		return err
+	}
 	nofile := false
         //home, err := homedir.Dir()
         _, err := os.Stat("/etc/netclient") 
@@ -55,11 +64,11 @@ func Write(config *ClientConfig) error{
         if err != nil {
                 log.Fatal(err)
         }
-        file := fmt.Sprintf(home + "/.netconfig")
+        file := fmt.Sprintf(home + "/netconfig-" + network)
         f, err := os.OpenFile(file, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
         if err != nil {
                 nofile = true
-                //fmt.Println("Could not access " + home + "/.netconfig,  proceeding...")
+                //fmt.Println("Could not access " + home + "/netconfig,  proceeding...")
         }
         defer f.Close()
 
@@ -71,7 +80,7 @@ func Write(config *ClientConfig) error{
                 }
         } else {
 
-		newf, err := os.Create(home + "/.netconfig")
+		newf, err := os.Create(home + "/netconfig-" + network)
 		err = yaml.NewEncoder(newf).Encode(config)
 		defer newf.Close()
 		if err != nil {
@@ -82,7 +91,11 @@ func Write(config *ClientConfig) error{
 
         return err
 }
-func WriteServer(server string, accesskey string) error{
+func WriteServer(server string, accesskey string, network string) error{
+        if network == "" {
+                err := errors.New("No network provided. Exiting.")
+                return err
+        }
         nofile := false
         //home, err := homedir.Dir()
         _, err := os.Stat("/etc/netclient")
@@ -94,12 +107,12 @@ func WriteServer(server string, accesskey string) error{
         }
         home := "/etc/netclient"
 
-	file := fmt.Sprintf(home + "/.netconfig")
+	file := fmt.Sprintf(home + "/netconfig-" + network)
         //f, err := os.Open(file)
         f, err := os.OpenFile(file, os.O_CREATE|os.O_RDWR, 0666)
 	//f, err := ioutil.ReadFile(file)
         if err != nil {
-		fmt.Println("couldnt open netconfig")
+		fmt.Println("couldnt open netconfig-" + network)
 		fmt.Println(err)
                 nofile = true
 		//err = nil
@@ -111,7 +124,7 @@ func WriteServer(server string, accesskey string) error{
 	var cfg ClientConfig
 
         if !nofile {
-		fmt.Println("Writing to existing config file at " + home + "/.netconfig")
+		fmt.Println("Writing to existing config file at " + home + "/netconfig-" + network)
                 decoder := yaml.NewDecoder(f)
                 err = decoder.Decode(&cfg)
 		//err = yaml.Unmarshal(f, &cfg)
@@ -145,12 +158,12 @@ func WriteServer(server string, accesskey string) error{
                         return err
                 }
 	} else {
-                fmt.Println("Creating new config file at " + home + "/.netconfig")
+                fmt.Println("Creating new config file at " + home + "/netconfig-" + network)
 
                 cfg.Server.Address = server
                 cfg.Server.AccessKey = accesskey
 
-                newf, err := os.Create(home + "/.netconfig")
+                newf, err := os.Create(home + "/netconfig-" + network)
                 err = yaml.NewEncoder(newf).Encode(cfg)
                 defer newf.Close()
                 if err != nil {
@@ -168,7 +181,7 @@ func(config *ClientConfig) ReadConfig() {
 	nofile := false
 	//home, err := homedir.Dir()
 	home := "/etc/netclient"
-	file := fmt.Sprintf(home + "/.netconfig")
+	file := fmt.Sprintf(home + "/netconfig-" + config.Network)
 	//f, err := os.Open(file)
         f, err := os.OpenFile(file, os.O_RDONLY, 0666)
 	if err != nil {
@@ -194,12 +207,15 @@ func(config *ClientConfig) ReadConfig() {
 	}
 }
 
-
-func readConfig() *ClientConfig {
+func ReadConfig(network string) (*ClientConfig, error) {
+        if network == "" {
+                err := errors.New("No network provided. Exiting.")
+                return nil, err
+        }
 	nofile := false
 	//home, err := homedir.Dir()
 	home := "/etc/netclient"
-	file := fmt.Sprintf(home + "/.netconfig")
+	file := fmt.Sprintf(home + "/netconfig-" + network)
 	f, err := os.Open(file)
 	if err != nil {
 		nofile = true
@@ -213,13 +229,14 @@ func readConfig() *ClientConfig {
 		err = decoder.Decode(&cfg)
 		if err != nil {
 			fmt.Println("trouble decoding file")
-			log.Fatal(err)
+			return nil, err
 		}
 	}
-	return &cfg
+	return &cfg, err
 }
-
+/*
 func init() {
   Config = readConfig()
 }
+*/
 

netclient/functions/auth.go

@@ -14,17 +14,17 @@ import (
 )
 
 // CreateJWT func will used to create the JWT while signing in and signing out
-func SetJWT(client nodepb.NodeServiceClient) (context.Context, error) {
+func SetJWT(client nodepb.NodeServiceClient, network string) (context.Context, error) {
 		//home, err := os.UserHomeDir()
 		home := "/etc/netclient"
-		tokentext, err := ioutil.ReadFile(home + "/.nettoken")
+		tokentext, err := ioutil.ReadFile(home + "/nettoken-"+network)
                 if err != nil {
 			fmt.Println("Error reading token. Logging in to retrieve new token.")
-			err = AutoLogin(client)
+			err = AutoLogin(client, network)
 			if err != nil {
                                 return nil, status.Errorf(codes.Unauthenticated, fmt.Sprintf("Something went wrong with Auto Login: %v", err))
                         }
-			tokentext, err = ioutil.ReadFile(home + "/.nettoken")
+			tokentext, err = ioutil.ReadFile(home + "/nettoken-"+network)
 			if err != nil {
 				return nil, status.Errorf(codes.Unauthenticated, fmt.Sprintf("Something went wrong: %v", err))
 			}
@@ -38,13 +38,18 @@ func SetJWT(client nodepb.NodeServiceClient) (context.Context, error) {
 		return ctx, nil
 }
 
-func AutoLogin(client nodepb.NodeServiceClient) error {
+func AutoLogin(client nodepb.NodeServiceClient, network string) error {
 	        //home, err := os.UserHomeDir()
 		home := "/etc/netclient"
-		nodecfg := config.Config.Node
-                login := &nodepb.LoginRequest{
-                        Password: nodecfg.Password,
-                        Macaddress: nodecfg.MacAddress,
+		//nodecfg := config.Config.Node
+                cfg, err := config.ReadConfig(network) 
+		if err != nil {
+			return err
+		}
+		login := &nodepb.LoginRequest{
+                        Password: cfg.Node.Password,
+                        Macaddress: cfg.Node.MacAddress,
+                        Network: network,
                 }
     // RPC call
                 res, err := client.Login(context.TODO(), login)
@@ -52,7 +57,7 @@ func AutoLogin(client nodepb.NodeServiceClient) error {
                         return err
                 }
                 tokenstring := []byte(res.Accesstoken)
-                err = ioutil.WriteFile(home + "/.nettoken", tokenstring, 0644)
+                err = ioutil.WriteFile(home + "/nettoken-"+network, tokenstring, 0644)
                 if err != nil {
                         return err
                 }

netclient/functions/local.go

@@ -11,7 +11,16 @@ import (
         "os/exec"
 )
 
-func ConfigureSystemD() error {
+
+func FileExists(f string) bool {
+    info, err := os.Stat(f)
+    if os.IsNotExist(err) {
+        return false
+    }
+    return !info.IsDir()
+}
+
+func ConfigureSystemD(network string) error {
 	/*
 	path, err := os.Getwd()
 	if err != nil {
@@ -36,17 +45,23 @@ func ConfigureSystemD() error {
                 return err
         }
 
+	if !FileExists("/usr/local/bin/netclient") {
+		os.Symlink("/etc/netclient/netclient","/usr/local/bin/netclient")
+	/*
 	_, err = copy(binarypath, "/usr/local/bin/netclient")
 	if err != nil {
 		log.Println(err)
 		return err
 	}
+	*/
+	}
+	if !FileExists("/etc/netclient/netclient") {
         _, err = copy(binarypath, "/etc/netclient/netclient")
         if err != nil {
                 log.Println(err)
                 return err
         }
-
+	}
 
 
 	systemservice := `[Unit]
@@ -54,8 +69,8 @@ Description=Regularly checks for updates in peers and local config
 Wants=netclient.timer
 
 [Service]
-Type=oneshot
-ExecStart=/etc/netclient/netclient -c checkin
+Type=simple
+ExecStart=/etc/netclient/netclient -c checkin -n %i
 
 [Install]
 WantedBy=multi-user.target
@@ -63,45 +78,62 @@ WantedBy=multi-user.target
 
 	systemtimer := `[Unit]
 Description=Calls the Netmaker Mesh Client Service
-Requires=netclient.service
+
+`
+systemtimer = systemtimer + "Requires=netclient@"+network+".service"
+
+systemtimer = systemtimer +
+`
 
 [Timer]
-Unit=netclient.service
+
+`
+systemtimer = systemtimer + "Unit=netclient@"+network+".service"
+
+systemtimer = systemtimer +
+`
+
 OnCalendar=*:*:0/30
 
 [Install]
 WantedBy=timers.target
 `
 
+
 	servicebytes := []byte(systemservice)
 	timerbytes := []byte(systemtimer)
 
-	err = ioutil.WriteFile("/etc/systemd/system/netclient.service", servicebytes, 0644)
+	if !FileExists("/etc/systemd/system/[email protected]") {
+	err = ioutil.WriteFile("/etc/systemd/system/[email protected]", servicebytes, 0644)
         if err != nil {
                 log.Println(err)
                 return err
         }
+	}
 
-        err = ioutil.WriteFile("/etc/systemd/system/netclient.timer", timerbytes, 0644)
+        if !FileExists("/etc/systemd/system/netclient-"+network+".timer") {
+        err = ioutil.WriteFile("/etc/systemd/system/netclient-"+network+".timer", timerbytes, 0644)
         if err != nil {
                 log.Println(err)
                 return err
         }
-
+	}
         sysExec, err := exec.LookPath("systemctl")
 
         cmdSysEnableService := &exec.Cmd {
                 Path: sysExec,
-                Args: []string{ sysExec, "enable", "netclient.service" },
+                Args: []string{ sysExec, "enable", "netclient@.service" },
                 Stdout: os.Stdout,
                 Stderr: os.Stdout,
         }
+	/*
         cmdSysStartService := &exec.Cmd {
                 Path: sysExec,
-                Args: []string{ sysExec, "start", "netclient.service"},
+                Args: []string{ sysExec, "start", "netclient@.service"},
                 Stdout: os.Stdout,
                 Stderr: os.Stdout,
         }
+	*/
         cmdSysDaemonReload := &exec.Cmd {
                 Path: sysExec,
                 Args: []string{ sysExec, "daemon-reload"},
@@ -110,25 +142,20 @@ WantedBy=timers.target
         }
         cmdSysEnableTimer := &exec.Cmd {
                 Path: sysExec,
-                Args: []string{ sysExec, "enable", "netclient.timer" },
+                Args: []string{ sysExec, "enable", "netclient-"+network+".timer" },
                 Stdout: os.Stdout,
                 Stderr: os.Stdout,
         }
         cmdSysStartTimer := &exec.Cmd {
                 Path: sysExec,
-		Args: []string{ sysExec, "start", "netclient.timer"},
+		Args: []string{ sysExec, "start", "netclient-"+network+".timer"},
                 Stdout: os.Stdout,
                 Stderr: os.Stdout,
         }
 
         err = cmdSysEnableService.Run()
         if  err  !=  nil {
-                fmt.Println("Error enabling netclient.service. Please investigate.")
-                fmt.Println(err)
-        }
-        err = cmdSysStartService.Run()
-        if  err  !=  nil {
-                fmt.Println("Error starting netclient.service. Please investigate.")
+                fmt.Println("Error enabling [email protected]. Please investigate.")
                 fmt.Println(err)
         }
         err = cmdSysDaemonReload.Run()
@@ -143,24 +170,38 @@ WantedBy=timers.target
         }
         err = cmdSysStartTimer.Run()
         if  err  !=  nil {
-                fmt.Println("Error starting netclient.timer. Please investigate.")
+                fmt.Println("Error starting netclient-"+network+".timer. Please investigate.")
                 fmt.Println(err)
         }
 	return nil
 }
 
-func RemoveSystemDServices() error {
+func isOnlyService(network string) (bool, error) {
+	isonly := false
+	files, err := filepath.Glob("/etc/netclient/netconfig-*")
+	if err != nil {
+		return isonly, err
+	}
+	count := len(files)
+	if count  == 0 {
+		isonly = true
+	}
+	return isonly, err
+
+}
+
+func RemoveSystemDServices(network string) error {
         sysExec, err := exec.LookPath("systemctl")
 
-        cmdSysStopService := &exec.Cmd {
-                Path: sysExec,
-                Args: []string{ sysExec, "stop", "netclient.service" },
-                Stdout: os.Stdout,
-                Stderr: os.Stdout,
-        }
+
+	fullremove, err := isOnlyService(network)
+	if err != nil {
+		fmt.Println(err)
+	}
+
         cmdSysDisableService := &exec.Cmd {
                 Path: sysExec,
-                Args: []string{ sysExec, "disable", "netclient.service"},
+                Args: []string{ sysExec, "disable", "netclient@.service"},
                 Stdout: os.Stdout,
                 Stderr: os.Stdout,
         }
@@ -178,40 +219,43 @@ func RemoveSystemDServices() error {
         }
         cmdSysStopTimer := &exec.Cmd {
                 Path: sysExec,
-                Args: []string{ sysExec, "stop", "netclient.timer" },
+                Args: []string{ sysExec, "stop", "netclient-"+network+".timer" },
                 Stdout: os.Stdout,
                 Stderr: os.Stdout,
         }
         cmdSysDisableTimer := &exec.Cmd {
                 Path: sysExec,
-                Args: []string{ sysExec, "disable", "netclient.timer"},
+                Args: []string{ sysExec, "disable", "netclient-"+network+".timer"},
                 Stdout: os.Stdout,
                 Stderr: os.Stdout,
         }
 
-        err = cmdSysStopService.Run()
+        //err = cmdSysStopService.Run()
         if  err  !=  nil {
-                fmt.Println("Error stopping netclient.service. Please investigate.")
+                fmt.Println("Error stopping netclient@.service. Please investigate.")
                 fmt.Println(err)
         }
+	if fullremove {
         err = cmdSysDisableService.Run()
         if  err  !=  nil {
-                fmt.Println("Error disabling netclient.service. Please investigate.")
+                fmt.Println("Error disabling netclient@.service. Please investigate.")
                 fmt.Println(err)
         }
+	}
         err = cmdSysStopTimer.Run()
         if  err  !=  nil {
-                fmt.Println("Error stopping netclient.timer. Please investigate.")
+                fmt.Println("Error stopping netclient-"+network+".timer. Please investigate.")
                 fmt.Println(err)
         }
         err = cmdSysDisableTimer.Run()
         if  err  !=  nil {
-                fmt.Println("Error disabling netclient.timer. Please investigate.")
+                fmt.Println("Error disabling netclient-"+network+".timer. Please investigate.")
                 fmt.Println(err)
         }
-
-	err = os.Remove("/etc/systemd/system/netclient.service")
-	err = os.Remove("/etc/systemd/system/netclient.timer")
+	if fullremove {
+	err = os.Remove("/etc/systemd/system/[email protected]")
+	}
+	err = os.Remove("/etc/systemd/system/netclient-"+network+".timer")
 	if err != nil {
                 fmt.Println("Error removing file. Please investigate.")
                 fmt.Println(err)

netclient/main.go

@@ -15,12 +15,12 @@ import (
 
 const (
 	// name of the service
-	name        = "wcdaemon"
-	description = "Wirecat Daemon Service"
+	name        = "netclient"
+	description = "Netmaker Daemon Service"
 )
 
 var password string
-var group string
+var network string
 var server string
 var accesskey string
 
@@ -35,8 +35,10 @@ var (
 func main() {
 	tpassword := flag.String("p", "changeme", "This node's password for accessing the server regularly")
 	taccesskey := flag.String("k", "badkey", "an access key generated by the server and used for one-time access (install only)")
+	taccesstoken := flag.String("t", "badtoken", "an token generated by the server and used for one-time access (install only)")
+	tname := flag.String("name", "noname", "give the node a name at runtime")
 	tserver := flag.String("s", "localhost:50051", "The location (including port) of the remote gRPC server.")
-	tgroup := flag.String("g", "badgroup", "The node group you are attempting to join.")
+	tnetwork := flag.String("n", "nonetwork", "The node network you are attempting to join.")
 	tnoauto := flag.Bool("na", false, "No auto mode. If true, netmclient will not be installed as a system service and you will have to retrieve updates manually via checkin command.")
 	tnoforward := flag.Bool("nf", false, "No Forward mode. If true, netclient will not check for IP forwarding. This may break functionality")
 	command := flag.String("c", "required", "The command to run")
@@ -70,11 +72,24 @@ func main() {
 	}
 
         switch *command {
+		case "getport":
+			portno, err := functions.GetFreePort(51821)
+			fmt.Printf("Port Number: %v", portno)
+			fmt.Println("")
+			if err != nil {
+				log.Fatal(err)
+			}
 		case "required":
                         fmt.Println("command flag 'c' is required. Pick one of |install|checkin|update|remove|")
                         os.Exit(1)
 			log.Fatal("Exiting")
                 case "install":
+
+                        if *taccesstoken == "badtoken" && (*tnetwork == "nonetwork"  || *tnetwork == "") {
+                                fmt.Println("Required, '-n'. No network provided. Exiting.")
+                                os.Exit(1)
+                        }
+
 			if !*tnoforward {
 				forward := exec.Command("sysctl", "net.ipv4.ip_forward")
 				out, err := forward.Output()
@@ -93,25 +108,32 @@ func main() {
 			}
 
 			fmt.Println("Beginning agent installation.")
-			err := functions.Install(*taccesskey, *tpassword, *tserver, *tgroup, *tnoauto)
+			err := functions.Install(*taccesskey, *tpassword, *tserver, *tnetwork, *tnoauto, *taccesstoken, *tname)
 			if err != nil {
+				fmt.Println("Error encountered while installing.")
+				if !strings.Contains(err.Error(), "ALREADY_INSTALLED") {
 				fmt.Println("Error installing: ", err)
 				fmt.Println("Cleaning up (uninstall)")
-				err = functions.Remove()
+				err = functions.Remove(*tnetwork)
 				if err != nil {
                                         fmt.Println("Error uninstalling: ", err)
                                         fmt.Println("Wiping local.")
-					err = functions.WipeLocal()
+					err = functions.WipeLocal(*tnetwork)
 					if err != nil {
 						fmt.Println("Error removing artifacts: ", err)
 					}
-                                        err = functions.RemoveSystemDServices()
+                                        err = functions.RemoveSystemDServices(*tnetwork)
                                         if err != nil {
                                                 fmt.Println("Error removing services: ", err)
                                         }
 				}
 				os.Exit(1)
+				} else {
+					fmt.Println(err.Error())
+					os.Exit(1)
+				}
 			}
+		/*
 		case "service-install":
                         fmt.Println("Beginning service installation.")
                         err := functions.ConfigureSystemD()
@@ -126,16 +148,25 @@ func main() {
                                 fmt.Println("Error installing service: ", err)
                                 os.Exit(1)
                         }
+		*/
 		case "checkin":
-			fmt.Println("Beginning node check in.")
-			err := functions.CheckIn()
+                        if *tnetwork == "nonetwork" || *tnetwork == "" {
+                                fmt.Println("Required, '-n'. No network provided. Exiting.")
+                                os.Exit(1)
+                        }
+			fmt.Println("Beginning node check in for network " + *tnetwork)
+			err := functions.CheckIn(*tnetwork)
 			if err != nil {
 				fmt.Println("Error checking in: ", err)
 				os.Exit(1)
 			}
 		case "remove":
+			if *tnetwork == "nonetwork" || *tnetwork == "" {
+                                fmt.Println("Required, '-n'. No network provided. Exiting.")
+                                os.Exit(1)
+			}
                         fmt.Println("Beginning node cleanup.")
-			err := functions.Remove()
+			err := functions.Remove(*tnetwork)
                         if err != nil {
 					/*
                                         fmt.Println("Error uninstalling: ", err)
@@ -152,6 +183,10 @@ func main() {
                                 fmt.Println("Error deleting node: ", err)
                                 os.Exit(1)
                         }
+		default:
+			fmt.Println("You must select from the following commands: install|remove|checkin", err)
+			os.Exit(1)
+
 	}
 	fmt.Println("Command " + *command + " Executed Successfully")
 }

netclient/test/delscript.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-sudo ip link del wc-skynet
-
-curl -X DELETE -H "Authorization: Bearer secretkey" -H 'Content-Type: application/json' localhost:8081/api/skynet/nodes/8c:89:a5:03:f0:d7 | jq
-
-sudo cp /root/.netconfig.bkup /root/.netconfig
-sudo rm /root/.nettoken
-sudo go run ./main.go remove
-
-sudo wg show

privatekey

@@ -0,0 +1 @@
+wMb6dxHPNJqQd8GbwfLN8HPLiJYEl1uJtEls5hRoD10=

publickey

@@ -0,0 +1 @@
+/FdO9q+Bs3ee/NVbtKwMhSmFj4AyyjmlOrujzaBoenE=

serverctl/serverctl.go

@@ -0,0 +1,89 @@
+package serverctl
+
+import (
+        "fmt"
+  "github.com/gravitl/netmaker/functions"
+	"io"
+	"errors"
+	"net/http"
+        "os"
+        "os/exec"
+)
+
+
+func DownloadNetclient() error {
+
+	// Get the data
+	resp, err := http.Get("https://github.com/gravitl/netmaker/releases/download/latest/netclient")
+	if err != nil {
+                fmt.Println("could not download netclient")
+		return err
+	}
+	defer resp.Body.Close()
+
+	// Create the file
+	out, err := os.Create("/etc/netclient/netclient")
+	if err != nil {
+                fmt.Println("could not create /etc/netclient")
+		return err
+	}
+	defer out.Close()
+
+	// Write the body to file
+	_, err = io.Copy(out, resp.Body)
+	return err
+}
+func RemoveNetwork(network string) (bool, error) {
+	_, err := os.Stat("/etc/netclient/netclient")
+        if err != nil {
+                fmt.Println("could not find /etc/netclient")
+		return false, err
+	}
+        cmdoutput, err := exec.Command("/etc/netclient/netclient","-c","remove","-n",network).Output()
+        if err != nil {
+                fmt.Println(string(cmdoutput))
+                return false, err
+        }
+        fmt.Println("Server removed from network " + network)
+        return true, err
+
+}
+
+func AddNetwork(network string) (bool, error) {
+	_, err := os.Stat("/etc/netclient")
+        if os.IsNotExist(err) {
+                os.Mkdir("/etc/netclient", 744)
+        } else if err != nil {
+                fmt.Println("could not find or create /etc/netclient")
+                return false, err
+        }
+	fmt.Println("Directory is ready.")
+	token, err := functions.CreateServerToken(network)
+        if err != nil {
+                fmt.Println("could not create server token for " + network)
+		return false, err
+        }
+	fmt.Println("Token is ready.")
+        _, err = os.Stat("/etc/netclient/netclient")
+	if os.IsNotExist(err) {
+		err = DownloadNetclient()
+                fmt.Println("could not download netclient")
+		if err != nil {
+			return false, err
+		}
+	}
+        err = os.Chmod("/etc/netclient/netclient", 0755)
+        if err != nil {
+                fmt.Println("could not change netclient directory permissions")
+                return false, err
+        }
+	fmt.Println("Client is ready. Running install.")
+	out, err := exec.Command("/etc/netclient/netclient","-c","install","-t",token,"-name","netmaker").Output()
+        fmt.Println(string(out))
+	if err != nil {
+                return false, errors.New(string(out) + err.Error())
+        }
+	fmt.Println("Server added to network " + network)
+	return true, err
+}
+

test/api_test.go

@@ -0,0 +1,219 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"sync"
+	"testing"
+	"time"
+
+	controller "github.com/gravitl/netmaker/controllers"
+	"github.com/gravitl/netmaker/models"
+	"github.com/gravitl/netmaker/mongoconn"
+	"github.com/stretchr/testify/assert"
+)
+
+type databaseError struct {
+	Inner  *int
+	Errors int
+}
+
+//should be use models.SuccessResponse and models.SuccessfulUserLoginResponse
+//rather than creating new type but having trouble decoding that way
+type Auth struct {
+	Username  string
+	AuthToken string
+}
+type Success struct {
+	Code     int
+	Message  string
+	Response Auth
+}
+
+type AuthorizeTestCase struct {
+	testname      string
+	name          string
+	password      string
+	code          int
+	tokenExpected bool
+	errMessage    string
+}
+
+var Networks []models.Network
+var baseURL string = "http://localhost:8081"
+
+func TestMain(m *testing.M) {
+	mongoconn.ConnectDatabase()
+	var waitgroup sync.WaitGroup
+	waitgroup.Add(1)
+	go controller.HandleRESTRequests(&waitgroup)
+	var gconf models.GlobalConfig
+	gconf.ServerGRPC = "localhost:8081"
+	gconf.PortGRPC = "50051"
+	//err := SetGlobalConfig(gconf)
+	collection := mongoconn.Client.Database("netmaker").Collection("config")
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	//create, _, err := functions.GetGlobalConfig()
+	_, err := collection.InsertOne(ctx, gconf)
+	if err != nil {
+		panic("could not create config store")
+	}
+
+	//wait for http server to start
+	time.Sleep(time.Second * 1)
+	os.Exit(m.Run())
+}
+
+func adminExists(t *testing.T) bool {
+	response, err := http.Get("http://localhost:8081/api/users/adm/hasadmin")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	defer response.Body.Close()
+	var body bool
+	json.NewDecoder(response.Body).Decode(&body)
+	return body
+}
+
+func api(t *testing.T, data interface{}, method, url, authorization string) (*http.Response, error) {
+	var request *http.Request
+	var err error
+	if data != "" {
+		payload, err := json.Marshal(data)
+		assert.Nil(t, err, err)
+		request, err = http.NewRequest(method, url, bytes.NewBuffer(payload))
+		assert.Nil(t, err, err)
+		request.Header.Set("Content-Type", "application/json")
+	} else {
+		request, err = http.NewRequest(method, url, nil)
+		assert.Nil(t, err, err)
+	}
+	if authorization != "" {
+		request.Header.Set("authorization", "Bearer "+authorization)
+	}
+	client := http.Client{}
+	//t.Log("api request", request)
+	return client.Do(request)
+}
+
+func addAdmin(t *testing.T) {
+	var admin models.User
+	admin.UserName = "admin"
+	admin.Password = "password"
+	response, err := api(t, admin, http.MethodPost, baseURL+"/api/users/adm/createadmin", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+}
+
+func authenticate(t *testing.T) (string, error) {
+	var admin models.User
+	admin.UserName = "admin"
+	admin.Password = "password"
+	response, err := api(t, admin, http.MethodPost, baseURL+"/api/users/adm/authenticate", "secretkey")
+	assert.Nil(t, err, err)
+
+	var body Success
+	err = json.NewDecoder(response.Body).Decode(&body)
+	assert.Nil(t, err, err)
+	assert.NotEmpty(t, body.Response.AuthToken, "token not returned")
+	assert.Equal(t, "W1R3: Device admin Authorized", body.Message)
+
+	return body.Response.AuthToken, nil
+}
+
+func deleteAdmin(t *testing.T) {
+	if !adminExists(t) {
+		return
+	}
+	token, err := authenticate(t)
+	assert.Nil(t, err, err)
+	_, err = api(t, "", http.MethodDelete, baseURL+"/api/users/admin", token)
+	assert.Nil(t, err, err)
+}
+
+func createNetwork(t *testing.T) {
+	network := models.Network{}
+	network.NetID = "skynet"
+	network.AddressRange = "10.71.0.0/16"
+	response, err := api(t, network, http.MethodPost, baseURL+"/api/networks", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+}
+
+func createKey(t *testing.T) {
+	key := models.AccessKey{}
+	key.Name = "skynet"
+	key.Uses = 10
+	response, err := api(t, key, http.MethodPost, baseURL+"/api/networks/skynet/keys", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	defer response.Body.Close()
+	message, err := ioutil.ReadAll(response.Body)
+	assert.Nil(t, err, err)
+	assert.NotNil(t, message, message)
+}
+
+func getKey(t *testing.T, name string) models.AccessKey {
+	response, err := api(t, "", http.MethodGet, baseURL+"/api/networks/skynet/keys", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	defer response.Body.Close()
+	var keys []models.AccessKey
+	err = json.NewDecoder(response.Body).Decode(&keys)
+	assert.Nil(t, err, err)
+	for _, key := range keys {
+		if key.Name == name {
+			return key
+		}
+	}
+	return models.AccessKey{}
+}
+
+func deleteKey(t *testing.T, key, network string) {
+	response, err := api(t, "", http.MethodDelete, baseURL+"/api/networks/"+network+"/keys/"+key, "secretkey")
+	assert.Nil(t, err, err)
+	//api does not return Deleted Count at this time
+	//defer response.Body.Close()
+	//var message mongo.DeleteResult
+	//err = json.NewDecoder(response.Body).Decode(&message)
+	//assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	//assert.Equal(t, int64(1), message.DeletedCount)
+}
+
+func networkExists(t *testing.T) bool {
+	response, err := api(t, "", http.MethodGet, baseURL+"/api/networks", "secretkey")
+	assert.Nil(t, err, err)
+	defer response.Body.Close()
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	err = json.NewDecoder(response.Body).Decode(&Networks)
+	assert.Nil(t, err, err)
+	for i, network := range Networks {
+		t.Log(i, network)
+		if network.NetID == "" {
+			return false
+		} else {
+			return true
+		}
+	}
+	return false
+}
+
+func deleteNetworks(t *testing.T) {
+
+	response, err := api(t, "", http.MethodGet, baseURL+"/api/networks", "secretkey")
+	assert.Nil(t, err, err)
+	defer response.Body.Close()
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	err = json.NewDecoder(response.Body).Decode(&Networks)
+	assert.Nil(t, err, err)
+	for _, network := range Networks {
+		name := network.NetID
+		_, err := api(t, "", http.MethodDelete, baseURL+"/api/networks/"+name, "secretkey")
+		assert.Nil(t, err, err)
+	}
+}

test/config/environments/dev.yaml

@@ -0,0 +1,14 @@
+server:
+  host: "localhost"
+  apiport: "8081"
+  grpcport: "50051"
+  masterkey: "secretkey"
+  allowedorigin: "*"
+  restbackend: true            
+  agentbackend: true
+mongoconn:
+  user: "mongoadmin"
+  pass: "mongopass"
+  host: "localhost"
+  port: "27017"
+  opts: '/?authSource=admin'

test/gatewaycreate.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+generate_post_json ()
+{
+  cat <<EOF
+{
+  "rangestring": "172.31.0.0/16",
+  "interface": "eth0"
+}
+EOF
+}
+
+POST_JSON=$(generate_post_json)
+
+curl --max-time 5.0 -d "$POST_JSON" -H 'Content-Type: application/json' -H "authorization: Bearer secretkey" 3.86.23.0:8081/api/nodes/default/12:5a:ac:3f:03:2d
+

test/group_test.go

@@ -0,0 +1,599 @@
+package main
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"testing"
+
+	"github.com/gravitl/netmaker/models"
+	"github.com/stretchr/testify/assert"
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+func TestCreateNetwork(t *testing.T) {
+
+	network := models.Network{}
+	network.NetID = "skynet"
+	network.AddressRange = "10.71.0.0/16"
+	if networkExists(t) {
+		deleteNetworks(t)
+	}
+	t.Run("InvalidToken", func(t *testing.T) {
+		response, err := api(t, network, http.MethodPost, baseURL+"/api/networks", "badkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+	t.Run("CreateNetwork", func(t *testing.T) {
+		response, err := api(t, network, http.MethodPost, baseURL+"/api/networks", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+	})
+	t.Run("DuplicateNetwork", func(t *testing.T) {
+		response, err := api(t, network, http.MethodPost, baseURL+"/api/networks", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, response.StatusCode)
+	})
+	t.Run("BadName", func(t *testing.T) {
+		network.NetID = "thisnameistoolong"
+		response, err := api(t, network, http.MethodPost, baseURL+"/api/networks", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, response.StatusCode)
+	})
+	t.Run("BadAddress", func(t *testing.T) {
+		network.NetID = "wirecat"
+		network.AddressRange = "10.300.20.56/36"
+		response, err := api(t, network, http.MethodPost, baseURL+"/api/networks", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, response.StatusCode)
+	})
+
+}
+
+func TestGetNetworks(t *testing.T) {
+
+	t.Run("ValidToken", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, baseURL+"/api/networks", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		err = json.NewDecoder(response.Body).Decode(&Networks)
+		assert.Nil(t, err, err)
+	})
+	t.Run("InvalidToken", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, baseURL+"/api/networks", "badkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+}
+
+func TestGetNetwork(t *testing.T) {
+
+	t.Run("ValidToken", func(t *testing.T) {
+		var network models.Network
+		response, err := api(t, "", http.MethodGet, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		err = json.NewDecoder(response.Body).Decode(&network)
+		assert.Nil(t, err, err)
+		// --- needs fixing ------ returns previous name
+		//assert.Equal(t, "skynet", network.DisplayName)
+	})
+	t.Run("InvalidToken", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, baseURL+"/api/networks/skynet", "badkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+	t.Run("InvalidNetwork", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, baseURL+"/api/networks/badnetwork", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+}
+
+func TestDeleteMetwork(t *testing.T) {
+
+	t.Run("InvalidKey", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, baseURL+"/api/networks/skynet", "badkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+	t.Run("ValidKey", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message mongo.DeleteResult
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		assert.Equal(t, int64(1), message.DeletedCount)
+
+	})
+	t.Run("Badnetwork", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, baseURL+"/api/networks/badnetwork", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+	t.Run("NodesExist", func(t *testing.T) {
+
+	})
+}
+
+func TestCreateKey(t *testing.T) {
+	//ensure we are working with known networks
+	deleteNetworks(t)
+	createNetwork(t)
+
+	key := models.AccessKey{}
+	key.Name = "skynet"
+	key.Uses = 10
+	t.Run("MultiUse", func(t *testing.T) {
+		response, err := api(t, key, http.MethodPost, baseURL+"/api/networks/skynet/keys", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		message, err := ioutil.ReadAll(response.Body)
+		assert.Nil(t, err, err)
+		assert.NotNil(t, message, message)
+		returnedkey := getKey(t, key.Name)
+		assert.Equal(t, key.Name, returnedkey.Name)
+		assert.Equal(t, key.Uses, returnedkey.Uses)
+	})
+	deleteKey(t, "skynet", "skynet")
+	t.Run("ZeroUse", func(t *testing.T) {
+		//
+		key.Uses = 0
+		response, err := api(t, key, http.MethodPost, baseURL+"/api/networks/skynet/keys", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		message, err := ioutil.ReadAll(response.Body)
+		assert.Nil(t, err, err)
+		assert.NotNil(t, message, message)
+		returnedkey := getKey(t, key.Name)
+		assert.Equal(t, key.Name, returnedkey.Name)
+		assert.Equal(t, 1, returnedkey.Uses)
+	})
+	t.Run("DuplicateAccessKey", func(t *testing.T) {
+		//this is allowed I think it should fail fail
+		response, err := api(t, key, http.MethodPost, baseURL+"/api/networks/skynet/keys", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		deleteKey(t, key.Name, "skynet")
+	})
+
+	t.Run("InvalidToken", func(t *testing.T) {
+		response, err := api(t, key, http.MethodPost, baseURL+"/api/networks/skynet/keys", "badkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+	t.Run("Badnetwork", func(t *testing.T) {
+		response, err := api(t, key, http.MethodPost, baseURL+"/api/networks/badnetwork/keys", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+}
+
+func TestDeleteKey(t *testing.T) {
+	//ensure we are working with known networks
+	deleteNetworks(t)
+	createNetwork(t)
+	//ensure key exists
+	createKey(t)
+	t.Run("KeyValid", func(t *testing.T) {
+		//fails -- deletecount not returned
+		response, err := api(t, "", http.MethodDelete, baseURL+"/api/networks/skynet/keys/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		//var message mongo.DeleteResult
+		var messages []models.AccessKey
+		err = json.NewDecoder(response.Body).Decode(&messages)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		for _, message := range messages {
+			assert.Equal(t, "skynet", message.Name)
+		}
+	})
+	t.Run("InValidKey", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, baseURL+"/api/networks/skynet/keys/badkey", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, message.Code)
+		assert.Equal(t, "key badkey does not exist", message.Message)
+		assert.Equal(t, http.StatusBadRequest, response.StatusCode)
+	})
+	t.Run("KeyInValidnetwork", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, baseURL+"/api/networks/badnetwork/keys/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+	t.Run("InvalidCredentials", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, baseURL+"/api/networks/skynet/keys/skynet", "badkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+}
+
+func TestGetKeys(t *testing.T) {
+	//ensure we are working with known networks
+	deleteNetworks(t)
+	createNetwork(t)
+	createKey(t)
+	t.Run("Valid", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, baseURL+"/api/networks/skynet/keys", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		var keys []models.AccessKey
+		err = json.NewDecoder(response.Body).Decode(&keys)
+		assert.Nil(t, err, err)
+	})
+	t.Run("Invalidnetwork", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, baseURL+"/api/networks/badnetwork/keys", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+	t.Run("InvalidCredentials", func(t *testing.T) {
+		response, err := api(t, "", http.MethodGet, baseURL+"/api/networks/skynet/keys", "badkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: You are unauthorized to access this endpoint.", message.Message)
+	})
+}
+
+func TestUpdateNetwork(t *testing.T) {
+	//ensure we are working with known networks
+	deleteNetworks(t)
+	createNetwork(t)
+	var returnedNetwork models.Network
+	t.Run("UpdateNetID", func(t *testing.T) {
+		type Network struct {
+			NetID string
+		}
+		var network Network
+		network.NetID = "wirecat"
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, response.StatusCode)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, message.Code)
+		assert.Equal(t, "NetID is not editable", message.Message)
+	})
+	t.Run("Invalidnetwork", func(t *testing.T) {
+		type Network struct {
+			NetID string
+		}
+		var network Network
+		network.NetID = "wirecat"
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/badnetwork", "secretkey")
+		assert.Nil(t, err, err)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusNotFound, message.Code)
+		assert.Equal(t, "W1R3: This network does not exist.", message.Message)
+		assert.Equal(t, http.StatusNotFound, response.StatusCode)
+	})
+	t.Run("UpdateAddress", func(t *testing.T) {
+		type Network struct {
+			AddressRange string
+		}
+		var network Network
+		network.AddressRange = "10.0.0.1/24"
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.AddressRange, returnedNetwork.AddressRange)
+	})
+	t.Run("UpdateAddressInvalid", func(t *testing.T) {
+		type Network struct {
+			AddressRange string
+		}
+		var network Network
+		network.AddressRange = "10.0.0.1/36"
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, response.StatusCode)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, message.Code)
+		assert.Contains(t, message.Message, "validation for 'AddressRange' failed")
+
+	})
+	t.Run("UpdateDisplayName", func(t *testing.T) {
+		type Network struct {
+			DisplayName string
+		}
+		var network Network
+		network.DisplayName = "wirecat"
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DisplayName, returnedNetwork.DisplayName)
+
+	})
+	t.Run("UpdateDisplayNameInvalidName", func(t *testing.T) {
+		type Network struct {
+			DisplayName string
+		}
+		var network Network
+		//create name that is longer than 100 chars
+		name := ""
+		for i := 0; i < 101; i++ {
+			name = name + "a"
+		}
+		network.DisplayName = name
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, response.StatusCode)
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, message.Code)
+		assert.Contains(t, message.Message, "Field validation for 'DisplayName' failed")
+	})
+	t.Run("UpdateInterface", func(t *testing.T) {
+		type Network struct {
+			DefaultInterface string
+		}
+		var network Network
+		network.DefaultInterface = "netmaker"
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DefaultInterface, returnedNetwork.DefaultInterface)
+
+	})
+	t.Run("UpdateListenPort", func(t *testing.T) {
+		type Network struct {
+			DefaultListenPort int32
+		}
+		var network Network
+		network.DefaultListenPort = 6000
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DefaultListenPort, returnedNetwork.DefaultListenPort)
+	})
+	t.Run("UpdateListenPortInvalidPort", func(t *testing.T) {
+		type Network struct {
+			DefaultListenPort int32
+		}
+		var network Network
+		network.DefaultListenPort = 65540
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, message.Code)
+		assert.Contains(t, message.Message, "Field validation for 'DefaultListenPort' failed")
+		assert.Equal(t, http.StatusBadRequest, response.StatusCode)
+	})
+	t.Run("UpdatePostUP", func(t *testing.T) {
+		type Network struct {
+			DefaultPostUp string
+		}
+		var network Network
+		network.DefaultPostUp = "sudo wg add-conf wc-netmaker /etc/wireguard/peers/conf"
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DefaultPostUp, returnedNetwork.DefaultPostUp)
+	})
+	t.Run("UpdatePostDown", func(t *testing.T) {
+		type Network struct {
+			DefaultPostDown string
+		}
+		var network Network
+		network.DefaultPostDown = "test string"
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DefaultPostDown, returnedNetwork.DefaultPostDown)
+	})
+	t.Run("UpdateKeepAlive", func(t *testing.T) {
+		type Network struct {
+			DefaultKeepalive int32
+		}
+		var network Network
+		network.DefaultKeepalive = 60
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DefaultKeepalive, returnedNetwork.DefaultKeepalive)
+	})
+	t.Run("UpdateKeepAliveTooBig", func(t *testing.T) {
+		//does not fails ----- value gets updated.
+		// ----- needs fixing -----
+		t.Skip()
+		type Network struct {
+			DefaultKeepAlive int32
+		}
+		var network Network
+		network.DefaultKeepAlive = 1001
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, message.Code)
+		assert.Contains(t, message.Message, "Field validation for 'DefaultKeepAlive' failed")
+		assert.Equal(t, http.StatusBadRequest, response.StatusCode)
+	})
+	t.Run("UpdateSaveConfig", func(t *testing.T) {
+		t.Skip()
+		//does not appear to be updatable
+		type Network struct {
+			DefaultSaveConfig *bool
+		}
+		var network Network
+		value := false
+		network.DefaultSaveConfig = &value
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, *network.DefaultSaveConfig, *returnedNetwork.DefaultSaveConfig)
+	})
+	t.Run("UpdateManualSignUP", func(t *testing.T) {
+		type Network struct {
+			AllowManualSignUp *bool
+		}
+		var network Network
+		value := true
+		network.AllowManualSignUp = &value
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.AllowManualSignUp, returnedNetwork.AllowManualSignUp)
+	})
+	t.Run("DefaultCheckInterval", func(t *testing.T) {
+		type Network struct {
+			CheckInInterval int32
+		}
+		var network Network
+		network.CheckInInterval = 60
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.CheckInInterval, returnedNetwork.DefaultCheckInInterval)
+	})
+	t.Run("DefaultCheckIntervalTooBig", func(t *testing.T) {
+		type Network struct {
+			CheckInInterval int32
+		}
+		var network Network
+		network.CheckInInterval = 100001
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, message.Code)
+		assert.Contains(t, message.Message, "Field validation for 'DefaultCheckInInterval' failed")
+		assert.Equal(t, http.StatusBadRequest, response.StatusCode)
+	})
+	t.Run("MultipleFields", func(t *testing.T) {
+		type Network struct {
+			DisplayName       string
+			DefaultListenPort int32
+		}
+		var network Network
+		network.DefaultListenPort = 7777
+		network.DisplayName = "multi"
+		response, err := api(t, network, http.MethodPut, baseURL+"/api/networks/skynet", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		err = json.NewDecoder(response.Body).Decode(&returnedNetwork)
+		assert.Nil(t, err, err)
+		assert.Equal(t, network.DisplayName, returnedNetwork.DisplayName)
+		assert.Equal(t, network.DefaultListenPort, returnedNetwork.DefaultListenPort)
+	})
+}

test/groupcreate.sh

@@ -7,7 +7,7 @@ generate_post_json ()
 {
   cat <<EOF
 {
-  "nameid": "$NAME",
+  "netid": "$NAME",
   "addressrange": "$ADDRESSRANGE"
 }
 EOF
@@ -15,4 +15,4 @@ EOF
 
 POST_JSON=$(generate_post_json)
 
-curl --max-time 5.0 -d "$POST_JSON" -H 'Content-Type: application/json' -H "authorization: Bearer secretkey" localhost:8081/api/groups
+curl --max-time 5.0 -d "$POST_JSON" -H 'Content-Type: application/json' -H "authorization: Bearer secretkey" localhost:8081/api/networks

test/groupscreate.sh

@@ -7,7 +7,7 @@ generate_post_json ()
 {
   cat <<EOF
 {
-  "nameid": "$NAME",
+  "netid": "$NAME",
   "addressrange": "$ADDRESSRANGE"
 }
 EOF
@@ -15,7 +15,7 @@ EOF
 
 POST_JSON=$(generate_post_json)
 
-curl --max-time 5.0 -d "$POST_JSON" -H 'Content-Type: application/json' -H "authorization: Bearer secretkey" localhost:8081/api/groups
+curl --max-time 5.0 -d "$POST_JSON" -H 'Content-Type: application/json' -H "authorization: Bearer secretkey" localhost:8081/api/networks
 
 NAME="skynet"
 ADDRESSRANGE="100.70.0.0/14"
@@ -23,4 +23,4 @@ ADDRESSRANGE="100.70.0.0/14"
 POST_JSON=$(generate_post_json)
 
 
-curl --max-time 5.0 -d "$POST_JSON" -H 'Content-Type: application/json' -H "authorization: Bearer secretkey" localhost:8081/api/groups
+curl --max-time 5.0 -d "$POST_JSON" -H 'Content-Type: application/json' -H "authorization: Bearer secretkey" localhost:8081/api/networks

test/keycreate.sh

@@ -13,4 +13,4 @@ EOF
 
 POST_JSON=$(generate_post_json)
 
-curl --max-time 5.0 -d "$POST_JSON" -H 'Content-Type: application/json' -H "authorization: Bearer secretkey" localhost:8081/api/groups/skynet/keys
+curl --max-time 5.0 -d "$POST_JSON" -H 'Content-Type: application/json' -H "authorization: Bearer secretkey" localhost:8081/api/networks/skynet/keys

test/restartmongo.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+sudo docker kill mongodb
+sudo docker rm mongodb
+sudo docker volume rm mongovol
+
+docker volume create mongovol && docker run -d --name mongodb -v mongovol:/data/db --network host -e MONGO_INITDB_ROOT_USERNAME=mongoadmin -e MONGO_INITDB_ROOT_PASSWORD=mongopass mongo --bind_ip 0.0.0.0

test/test.script

@@ -0,0 +1,8 @@
+#!/bin/bash
+docker run -d \
+            -e MONGO_INITDB_ROOT_USERNAME:='mongoadmin' \
+            -e MONGO_INITDB_ROOT_PASSWORD:='mongopass' \
+            -p 27017:27017 mongo:4.2 
+go run . --clientmode=off
+cd test
+go test . -v

user_test.go → test/user_test.go

@@ -1,56 +1,15 @@
 package main
 
 import (
-	"bytes"
 	"encoding/json"
+	"io/ioutil"
 	"net/http"
-	"os"
-	"sync"
 	"testing"
-	"time"
 
-	controller "github.com/gravitl/netmaker/controllers"
 	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/mongoconn"
 	"github.com/stretchr/testify/assert"
 )
 
-type databaseError struct {
-	Inner  *int
-	Errors int
-}
-
-//should be use models.SuccessResponse and models.SuccessfulUserLoginResponse
-//rather than creating new type but having trouble decoding that way
-type Auth struct {
-	Username  string
-	AuthToken string
-}
-type Success struct {
-	Code     int
-	Message  string
-	Response Auth
-}
-
-type AuthorizeTestCase struct {
-	testname      string
-	name          string
-	password      string
-	code          int
-	tokenExpected bool
-	errMessage    string
-}
-
-func TestMain(m *testing.M) {
-	mongoconn.ConnectDatabase()
-	var waitgroup sync.WaitGroup
-	waitgroup.Add(1)
-	go controller.HandleRESTRequests(&waitgroup)
-	//wait for http server to start
-	time.Sleep(time.Second * 1)
-	os.Exit(m.Run())
-}
-
 func TestAdminCreation(t *testing.T) {
 	var admin models.UserAuthParams
 	var user models.User
@@ -60,7 +19,7 @@ func TestAdminCreation(t *testing.T) {
 		if adminExists(t) {
 			deleteAdmin(t)
 		}
-		response, err := api(t, admin, http.MethodPost, "http://localhost:8081/users/createadmin", "")
+		response, err := api(t, admin, http.MethodPost, "http://localhost:8081/api/users/adm/createadmin", "")
 		assert.Nil(t, err, err)
 		defer response.Body.Close()
 		err = json.NewDecoder(response.Body).Decode(&user)
@@ -69,12 +28,14 @@ func TestAdminCreation(t *testing.T) {
 		assert.Equal(t, true, user.IsAdmin)
 		assert.Equal(t, http.StatusOK, response.StatusCode)
 		assert.True(t, adminExists(t), "Admin creation failed")
+		message, _ := ioutil.ReadAll(response.Body)
+		t.Log(string(message))
 	})
 	t.Run("AdminCreationFailure", func(t *testing.T) {
 		if !adminExists(t) {
 			addAdmin(t)
 		}
-		response, err := api(t, admin, http.MethodPost, "http://localhost:8081/users/createadmin", "")
+		response, err := api(t, admin, http.MethodPost, "http://localhost:8081/api/users/adm/createadmin", "")
 		assert.Nil(t, err, err)
 		defer response.Body.Close()
 		var message models.ErrorResponse
@@ -88,16 +49,16 @@ func TestAdminCreation(t *testing.T) {
 }
 
 func TestGetUser(t *testing.T) {
-
-	//ensure admin exists
 	if !adminExists(t) {
+		t.Log("no admin - creating")
 		addAdmin(t)
+	} else {
+		t.Log("admin exists")
 	}
-	//authenticate
 	t.Run("GetUserWithValidToken", func(t *testing.T) {
 		token, err := authenticate(t)
 		assert.Nil(t, err, err)
-		response, err := api(t, "", http.MethodGet, "http://localhost:8081/users/admin", token)
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/users/admin", token)
 		assert.Nil(t, err, err)
 		defer response.Body.Close()
 		var user models.User
@@ -107,10 +68,16 @@ func TestGetUser(t *testing.T) {
 		assert.Equal(t, true, user.IsAdmin)
 	})
 	t.Run("GetUserWithInvalidToken", func(t *testing.T) {
-		response, err := api(t, "", http.MethodGet, "http://localhost:8081/users/admin", "secretkey")
+		response, err := api(t, "", http.MethodGet, "http://localhost:8081/api/users/admin", "badkey")
 		assert.Nil(t, err, err)
 		defer response.Body.Close()
-		t.Log(response.Body)
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
+		assert.Equal(t, http.StatusUnauthorized, message.Code)
+		assert.Equal(t, "W1R3: Error Verifying Auth Token.", message.Message)
+
 	})
 }
 
@@ -126,7 +93,7 @@ func TestUpdateUser(t *testing.T) {
 	t.Run("UpdateWrongToken", func(t *testing.T) {
 		admin.UserName = "admin"
 		admin.Password = "admin"
-		response, err := api(t, admin, http.MethodPut, "http://localhost:8081/users/admin", "secretkey")
+		response, err := api(t, admin, http.MethodPut, "http://localhost:8081/api/users/admin", "badkey")
 		assert.Nil(t, err, err)
 		defer response.Body.Close()
 		err = json.NewDecoder(response.Body).Decode(&message)
@@ -137,7 +104,7 @@ func TestUpdateUser(t *testing.T) {
 	t.Run("UpdateSuccess", func(t *testing.T) {
 		admin.UserName = "admin"
 		admin.Password = "password"
-		response, err := api(t, admin, http.MethodPut, "http://localhost:8081/users/admin", token)
+		response, err := api(t, admin, http.MethodPut, "http://localhost:8081/api/users/admin", token)
 		assert.Nil(t, err, err)
 		defer response.Body.Close()
 		err = json.NewDecoder(response.Body).Decode(&user)
@@ -146,51 +113,47 @@ func TestUpdateUser(t *testing.T) {
 		assert.Equal(t, true, user.IsAdmin)
 		assert.Equal(t, http.StatusOK, response.StatusCode)
 	})
-
 }
 
 func TestDeleteUser(t *testing.T) {
+
 	if !adminExists(t) {
+		t.Log("Creating Admin")
 		addAdmin(t)
 	}
 	token, err := authenticate(t)
 	assert.Nil(t, err, err)
-	t.Run("DeleteUser-WongAdmin", func(t *testing.T) {
-		//skip for now ... shouldn't panic
-		t.Skip()
-		function := func() {
-			_, _ = api(t, "", http.MethodDelete, "http://localhost:8081/users/xxxx", token)
-		}
-		assert.Panics(t, function, "")
-	})
 	t.Run("DeleteUser-InvalidCredentials", func(t *testing.T) {
-		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/users/admin", "secretkey")
+		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/api/users/admin", "badcredentials")
 		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
 		var message models.ErrorResponse
 		json.NewDecoder(response.Body).Decode(&message)
 		assert.Equal(t, "W1R3: Error Verifying Auth Token.", message.Message)
 		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
 	})
 	t.Run("DeleteUser-ValidCredentials", func(t *testing.T) {
-		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/users/admin", token)
+		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/api/users/admin", token)
 		assert.Nil(t, err, err)
 		var body string
 		json.NewDecoder(response.Body).Decode(&body)
 		assert.Equal(t, "admin deleted.", body)
 		assert.Equal(t, http.StatusOK, response.StatusCode)
 	})
-	t.Run("DeleteUser-NoAdmin", func(t *testing.T) {
-		//skip for now ... shouldn't panic
-		t.Skip()
-		function := func() {
-			_, _ = api(t, "", http.MethodDelete, "http://localhost:8081/users/admin", token)
-		}
-		assert.Panics(t, function, "")
+	t.Run("DeleteUser-NonExistantAdmin", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, "http://localhost:8081/api/users/admin", token)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusBadRequest, response.StatusCode)
+		var message models.ErrorResponse
+		defer response.Body.Close()
+		json.NewDecoder(response.Body).Decode(&message)
+		assert.Equal(t, http.StatusBadRequest, message.Code)
+		assert.Equal(t, "Delete unsuccessful.", message.Message)
 	})
-	addAdmin(t)
 }
 
 func TestAuthenticateUser(t *testing.T) {
+
 	cases := []AuthorizeTestCase{
 		AuthorizeTestCase{
 			testname:      "Invalid User",
@@ -233,7 +196,6 @@ func TestAuthenticateUser(t *testing.T) {
 			errMessage:    "W1R3: Device Admin Authorized",
 		},
 	}
-
 	if !adminExists(t) {
 		addAdmin(t)
 	}
@@ -242,7 +204,7 @@ func TestAuthenticateUser(t *testing.T) {
 			var admin models.User
 			admin.UserName = tc.name
 			admin.Password = tc.password
-			response, err := api(t, admin, http.MethodPost, "http://localhost:8081/users/authenticate", "secretkey")
+			response, err := api(t, admin, http.MethodPost, "http://localhost:8081/api/users/adm/authenticate", "secretkey")
 			assert.Nil(t, err, err)
 			defer response.Body.Close()
 			if tc.tokenExpected {
@@ -260,68 +222,3 @@ func TestAuthenticateUser(t *testing.T) {
 		})
 	}
 }
-
-func adminExists(t *testing.T) bool {
-	response, err := http.Get("http://localhost:8081/users/hasadmin")
-	assert.Nil(t, err, err)
-	assert.Equal(t, http.StatusOK, response.StatusCode)
-	defer response.Body.Close()
-	var body bool
-	json.NewDecoder(response.Body).Decode(&body)
-	return body
-}
-
-func api(t *testing.T, data interface{}, method, url, authorization string) (*http.Response, error) {
-	var request *http.Request
-	var err error
-	if data != "" {
-		payload, err := json.Marshal(data)
-		assert.Nil(t, err, err)
-		request, err = http.NewRequest(method, url, bytes.NewBuffer(payload))
-		assert.Nil(t, err, err)
-		request.Header.Set("Content-Type", "application/json")
-	} else {
-		request, err = http.NewRequest(method, url, nil)
-		assert.Nil(t, err, err)
-	}
-	if authorization != "" {
-		request.Header.Set("Authorization", "Bearer "+authorization)
-	}
-	client := http.Client{}
-	return client.Do(request)
-}
-
-func addAdmin(t *testing.T) {
-	var admin models.User
-	admin.UserName = "admin"
-	admin.Password = "password"
-	response, err := api(t, admin, http.MethodPost, "http://localhost:8081/users/createadmin", "secretkey")
-	assert.Nil(t, err, err)
-	assert.Equal(t, http.StatusOK, response.StatusCode)
-}
-
-func authenticate(t *testing.T) (string, error) {
-	var admin models.User
-	admin.UserName = "admin"
-	admin.Password = "password"
-	response, err := api(t, admin, http.MethodPost, "http://localhost:8081/users/authenticate", "secretkey")
-	assert.Nil(t, err, err)
-
-	var body Success
-	err = json.NewDecoder(response.Body).Decode(&body)
-	assert.Nil(t, err, err)
-	assert.NotEmpty(t, body.Response.AuthToken, "token not returned")
-	assert.Equal(t, "W1R3: Device admin Authorized", body.Message)
-
-	return body.Response.AuthToken, nil
-}
-
-func deleteAdmin(t *testing.T) {
-	if !adminExists(t) {
-		return
-	}
-	token, err := authenticate(t)
-	assert.Nil(t, err, err)
-	_, err = api(t, "", http.MethodDelete, "http://localhost:8081/users/admin", token)
-	assert.Nil(t, err, err)
-}