began refactoring of client

controllers/nodeGrpcController.go

@@ -2,83 +2,53 @@ package controller
 
 import (
 	"context"
-	"fmt"
+	"encoding/json"
+	"errors"
+	"log"
+
 	"github.com/gravitl/netmaker/functions"
 	nodepb "github.com/gravitl/netmaker/grpc"
 	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/servercfg"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
 )
 
 type NodeServiceServer struct {
 	nodepb.UnimplementedNodeServiceServer
 }
 
-func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.ReadNodeReq) (*nodepb.ReadNodeRes, error) {
+func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
 	// convert string id (from proto) to mongoDB ObjectId
-	macaddress := req.GetMacaddress()
-	networkName := req.GetNetwork()
-	network, _ := functions.GetParentNetwork(networkName)
+	var node models.Node
+	if err := json.Unmarshal([]byte(req.Data), &node); err != nil {
+		return nil, err
+	}
+	macaddress := node.MacAddress
+	networkName := node.Network
 
 	node, err := GetNode(macaddress, networkName)
 
 	if err != nil {
-		return nil, status.Errorf(codes.InvalidArgument, fmt.Sprintf("Something went wrong: %v", err))
+		log.Println("could not get node "+macaddress+" "+networkName, err)
+		return nil, err
 	}
 	// Cast to ReadNodeRes type
-
-	response := &nodepb.ReadNodeRes{
-		Node: &nodepb.Node{
-			Macaddress:          node.MacAddress,
-			Name:                node.Name,
-			Address:             node.Address,
-			Address6:            node.Address6,
-			Endpoint:            node.Endpoint,
-			Password:            node.Password,
-			Nodenetwork:         node.Network,
-			Interface:           node.Interface,
-			Localaddress:        node.LocalAddress,
-			Postdown:            node.PostDown,
-			Postup:              node.PostUp,
-			Checkininterval:     node.CheckInInterval,
-			Dnsoff:              !servercfg.IsDNSMode(),
-			Ispending:           node.IsPending == "yes",
-			Isingressgateway:    node.IsIngressGateway == "yes",
-			Ingressgatewayrange: node.IngressGatewayRange,
-			Publickey:           node.PublicKey,
-			Listenport:          node.ListenPort,
-			Keepalive:           node.PersistentKeepalive,
-			Islocal:             network.IsLocal == "yes",
-			Isdualstack:         network.IsDualStack == "yes",
-			Localrange:          network.LocalRange,
-			Udpholepunch:        node.UDPHolePunch,
-		},
+	nodeData, err := json.Marshal(&node)
+	if err != nil {
+		return nil, err
+	}
+	response := &nodepb.Object{
+		Data: string(nodeData),
+		Type: nodepb.NODE_TYPE,
 	}
 	return response, nil
 }
 
-func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.CreateNodeReq) (*nodepb.CreateNodeRes, error) {
+func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
 	// Get the protobuf node type from the protobuf request type
 	// Essentially doing req.Node to access the struct with a nil check
-	data := req.GetNode()
-	// Now we have to convert this into a NodeItem type to convert into BSON
-	node := models.Node{
-		// ID:       primitive.NilObjectID,
-		MacAddress:          data.GetMacaddress(),
-		LocalAddress:        data.GetLocaladdress(),
-		Name:                data.GetName(),
-		Address:             data.GetAddress(),
-		Address6:            data.GetAddress6(),
-		AccessKey:           data.GetAccesskey(),
-		Endpoint:            data.GetEndpoint(),
-		PersistentKeepalive: data.GetKeepalive(),
-		Password:            data.GetPassword(),
-		Interface:           data.GetInterface(),
-		Network:             data.GetNodenetwork(),
-		PublicKey:           data.GetPublickey(),
-		ListenPort:          data.GetListenport(),
-		UDPHolePunch:        data.GetUdpholepunch(),
+	var node models.Node
+	data := req.GetData()
+	if err := json.Unmarshal([]byte(data), &node); err != nil {
+		return nil, err
 	}
 
 	//Check to see if key is valid
@@ -86,7 +56,7 @@ func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.CreateNo
 	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))
+		return nil, err
 	}
 
 	if !validKey {
@@ -95,274 +65,125 @@ func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.CreateNo
 		if network.AllowManualSignUp == "yes" {
 			node.IsPending = "yes"
 		} else {
-			return nil, status.Errorf(
-				codes.Internal,
-				fmt.Sprintf("Invalid key, and network does not allow no-key signups"),
-			)
+			return nil, errors.New("invalid key, and network does not allow no-key signups")
 		}
 	}
 
 	node, err = CreateNode(node, node.Network)
-
 	if err != nil {
-		// return internal gRPC error to be handled later
-		return nil, status.Errorf(
-			codes.Internal,
-			fmt.Sprintf("Internal error: %v", err),
-		)
+		log.Println("could not create node on network " + node.Network + " (gRPC controller)")
+		return nil, err
 	}
-
+	nodeData, err := json.Marshal(&node)
 	// return the node in a CreateNodeRes type
-	response := &nodepb.CreateNodeRes{
-		Node: &nodepb.Node{
-			Macaddress:   node.MacAddress,
-			Localaddress: node.LocalAddress,
-			Name:         node.Name,
-			Address:      node.Address,
-			Address6:     node.Address6,
-			Endpoint:     node.Endpoint,
-			Password:     node.Password,
-			Interface:    node.Interface,
-			Nodenetwork:  node.Network,
-			Dnsoff:       !servercfg.IsDNSMode(),
-			Ispending:    node.IsPending == "yes",
-			Publickey:    node.PublicKey,
-			Listenport:   node.ListenPort,
-			Keepalive:    node.PersistentKeepalive,
-			Islocal:      network.IsLocal == "yes",
-			Isdualstack:  network.IsDualStack == "yes",
-			Localrange:   network.LocalRange,
-			Udpholepunch: node.UDPHolePunch,
-		},
+	response := &nodepb.Object{
+		Data: string(nodeData),
+		Type: nodepb.NODE_TYPE,
 	}
 	err = SetNetworkNodesLastModified(node.Network)
 	if err != nil {
-		return nil, status.Errorf(codes.NotFound, fmt.Sprintf("Could not update network last modified date: %v", err))
+		return nil, err
 	}
 
 	return response, nil
 }
 
-func (s *NodeServiceServer) CheckIn(ctx context.Context, req *nodepb.CheckInReq) (*nodepb.CheckInRes, error) {
-	// Get the protobuf node type from the protobuf request type
-	// Essentially doing req.Node to access the struct with a nil check
-	data := req.GetNode()
-	//postchanges := req.GetPostchanges()
-	// Now we have to convert this into a NodeItem type to convert into BSON
-	node := models.Node{
-		// ID:       primitive.NilObjectID,
-		MacAddress:          data.GetMacaddress(),
-		Address:             data.GetAddress(),
-		Address6:            data.GetAddress6(),
-		Endpoint:            data.GetEndpoint(),
-		Network:             data.GetNodenetwork(),
-		Password:            data.GetPassword(),
-		LocalAddress:        data.GetLocaladdress(),
-		ListenPort:          data.GetListenport(),
-		PersistentKeepalive: data.GetKeepalive(),
-		PublicKey:           data.GetPublickey(),
-		UDPHolePunch:        data.GetUdpholepunch(),
-		SaveConfig:          data.GetSaveconfig(),
-	}
-
-	checkinresponse, err := NodeCheckIn(node, node.Network)
-
-	if err != nil {
-		// return internal gRPC error to be handled later
-		if checkinresponse == (models.CheckInResponse{}) || !checkinresponse.IsPending {
-			return nil, status.Errorf(
-				codes.Internal,
-				fmt.Sprintf("Internal error: %v", err),
-			)
-		}
-	}
-	// return the node in a CreateNodeRes type
-	response := &nodepb.CheckInRes{
-		Checkinresponse: &nodepb.CheckInResponse{
-			Success:          checkinresponse.Success,
-			Needpeerupdate:   checkinresponse.NeedPeerUpdate,
-			Needdelete:       checkinresponse.NeedDelete,
-			Needconfigupdate: checkinresponse.NeedConfigUpdate,
-			Needkeyupdate:    checkinresponse.NeedKeyUpdate,
-			Nodemessage:      checkinresponse.NodeMessage,
-			Ispending:        checkinresponse.IsPending,
-		},
-	}
-	return response, nil
-}
-
-func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.UpdateNodeReq) (*nodepb.UpdateNodeRes, error) {
+func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
 	// Get the node data from the request
-	data := req.GetNode()
-	// Now we have to convert this into a NodeItem type to convert into BSON
-	newnode := models.Node{
-		// ID:       primitive.NilObjectID,
-		MacAddress:          data.GetMacaddress(),
-		Name:                data.GetName(),
-		Address:             data.GetAddress(),
-		Address6:            data.GetAddress6(),
-		LocalAddress:        data.GetLocaladdress(),
-		Endpoint:            data.GetEndpoint(),
-		Password:            data.GetPassword(),
-		PersistentKeepalive: data.GetKeepalive(),
-		Network:             data.GetNodenetwork(),
-		Interface:           data.GetInterface(),
-		PostDown:            data.GetPostdown(),
-		PostUp:              data.GetPostup(),
-		PublicKey:           data.GetPublickey(),
-		ListenPort:          data.GetListenport(),
-		UDPHolePunch:        data.GetUdpholepunch(),
-		SaveConfig:          data.GetSaveconfig(),
+	var newnode models.Node
+	if err := json.Unmarshal([]byte(req.GetData()), &newnode); err != nil {
+		return nil, err
 	}
-
-	// Convert the Id string to a MongoDB ObjectId
 	macaddress := newnode.MacAddress
 	networkName := newnode.Network
-	network, _ := functions.GetParentNetwork(networkName)
 
 	node, err := functions.GetNodeByMacAddress(networkName, macaddress)
 	if err != nil {
-		return nil, status.Errorf(
-			codes.NotFound,
-			fmt.Sprintf("Could not find node with supplied Mac Address: %v", err),
-		)
+		return nil, err
 	}
 
 	err = node.Update(&newnode)
-
 	if err != nil {
-		return nil, status.Errorf(
-			codes.NotFound,
-			fmt.Sprintf("Could not update node: %v", err),
-		)
+		return nil, err
 	}
-	return &nodepb.UpdateNodeRes{
-		Node: &nodepb.Node{
-			Macaddress:   newnode.MacAddress,
-			Localaddress: newnode.LocalAddress,
-			Name:         newnode.Name,
-			Address:      newnode.Address,
-			Address6:     newnode.Address6,
-			Endpoint:     newnode.Endpoint,
-			Password:     newnode.Password,
-			Interface:    newnode.Interface,
-			Postdown:     newnode.PostDown,
-			Postup:       newnode.PostUp,
-			Nodenetwork:  newnode.Network,
-			Ispending:    newnode.IsPending == "yes",
-			Publickey:    newnode.PublicKey,
-			Dnsoff:       !servercfg.IsDNSMode(),
-			Listenport:   newnode.ListenPort,
-			Keepalive:    newnode.PersistentKeepalive,
-			Islocal:      network.IsLocal == "yes",
-			Isdualstack:  network.IsDualStack == "yes",
-			Localrange:   network.LocalRange,
-			Udpholepunch: newnode.UDPHolePunch,
-		},
+	nodeData, err := json.Marshal(&node)
+
+	return &nodepb.Object{
+		Data: string(nodeData),
+		Type: nodepb.NODE_TYPE,
 	}, nil
 }
 
-func (s *NodeServiceServer) DeleteNode(ctx context.Context, req *nodepb.DeleteNodeReq) (*nodepb.DeleteNodeRes, error) {
-	macaddress := req.GetMacaddress()
-	network := req.GetNetworkName()
-
-	err := DeleteNode(macaddress, network)
+func (s *NodeServiceServer) DeleteNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
+	nodeID := req.GetData()
 
+	err := DeleteNode(nodeID, true)
 	if err != nil {
-		fmt.Println("Error deleting node.")
-		fmt.Println(err)
-		return nil, status.Errorf(codes.NotFound, fmt.Sprintf("Could not find/delete node with mac address %s", macaddress))
+		log.Println("Error deleting node (gRPC controller).")
+		return nil, err
 	}
 
-	fmt.Println("updating network last modified of " + req.GetNetworkName())
-	err = SetNetworkNodesLastModified(req.GetNetworkName())
-	if err != nil {
-		fmt.Println("Error updating Network")
-		fmt.Println(err)
-		return nil, status.Errorf(codes.NotFound, fmt.Sprintf("Could not update network last modified date: %v", err))
-	}
-
-	return &nodepb.DeleteNodeRes{
-		Success: true,
+	return &nodepb.Object{
+		Data: "success",
+		Type: nodepb.STRING_TYPE,
 	}, nil
 }
 
-func (s *NodeServiceServer) GetPeers(req *nodepb.GetPeersReq, stream nodepb.NodeService_GetPeersServer) error {
+func (s *NodeServiceServer) GetPeers(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
+	var node models.Node
+	if err := json.Unmarshal([]byte(req.GetData()), &node); err != nil {
+		return nil, err
+	}
+
+	peers, err := GetPeersList(node.Network)
+	if err != nil {
+		return nil, err
+	}
+
+	peersData, err := json.Marshal(&peers)
+	return &nodepb.Object{
+		Data: string(peersData),
+		Type: nodepb.NODE_TYPE,
+	}, nil
+}
+
+/**
+ * Return Ext Peers (clients).NodeCheckIn
+ * When a gateway node checks in, it pulls these peers to add to peers list in addition to normal network peers.
+ */
+func (s *NodeServiceServer) GetExtPeers(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
 	// Initiate a NodeItem type to write decoded data to
 	//data := &models.PeersResponse{}
 	// collection.Find returns a cursor for our (empty) query
-	peers, err := GetPeersList(req.GetNetwork())
-
+	var reqNode models.Node
+	if err := json.Unmarshal([]byte(req.Data), &reqNode); err != nil {
+		return nil, err
+	}
+	peers, err := GetExtPeersList(reqNode.Network, reqNode.MacAddress)
 	if err != nil {
-		return status.Errorf(codes.Internal, fmt.Sprintf("Unknown internal error: %v", err))
+		return nil, err
 	}
 	// cursor.Next() returns a boolean, if false there are no more items and loop will break
+	var extPeers []models.Node
 	for i := 0; i < len(peers); i++ {
-
-		// If no error is found send node over stream
-		stream.Send(&nodepb.GetPeersRes{
-			Peers: &nodepb.PeersResponse{
-				Address:            peers[i].Address,
-				Address6:           peers[i].Address6,
-				Endpoint:           peers[i].Endpoint,
-				Egressgatewayranges: peers[i].EgressGatewayRanges,
-				Isegressgateway:    peers[i].IsEgressGateway == "yes",
-				Publickey:          peers[i].PublicKey,
-				Keepalive:          peers[i].KeepAlive,
-				Listenport:         peers[i].ListenPort,
-				Localaddress:       peers[i].LocalAddress,
-			},
+		extPeers = append(extPeers, models.Node{
+			Address:             peers[i].Address,
+			Address6:            peers[i].Address6,
+			Endpoint:            peers[i].Endpoint,
+			PublicKey:           peers[i].PublicKey,
+			PersistentKeepalive: peers[i].KeepAlive,
+			ListenPort:          peers[i].ListenPort,
+			LocalAddress:        peers[i].LocalAddress,
 		})
 	}
 
-	node, err := functions.GetNodeByMacAddress(req.GetNetwork(), req.GetMacaddress())
+	extData, err := json.Marshal(&extPeers)
 	if err != nil {
-		return status.Errorf(codes.Internal, fmt.Sprintf("Could not get node: %v", err))
+		return nil, err
 	}
 
-	err = TimestampNode(node, false, true, false)
-	if err != nil {
-		return status.Errorf(codes.Internal, fmt.Sprintf("Internal error occurred: %v", err))
-	}
-
-	return nil
-}
-
-func (s *NodeServiceServer) GetExtPeers(req *nodepb.GetExtPeersReq, stream nodepb.NodeService_GetExtPeersServer) error {
-	// Initiate a NodeItem type to write decoded data to
-	//data := &models.PeersResponse{}
-	// collection.Find returns a cursor for our (empty) query
-	peers, err := GetExtPeersList(req.GetNetwork(), req.GetMacaddress())
-
-	if err != nil {
-		return status.Errorf(codes.Internal, fmt.Sprintf("Unknown internal error: %v", err))
-	}
-	// cursor.Next() returns a boolean, if false there are no more items and loop will break
-	for i := 0; i < len(peers); i++ {
-
-		// If no error is found send node over stream
-		stream.Send(&nodepb.GetExtPeersRes{
-			Extpeers: &nodepb.ExtPeersResponse{
-				Address:      peers[i].Address,
-				Address6:     peers[i].Address6,
-				Endpoint:     peers[i].Endpoint,
-				Publickey:    peers[i].PublicKey,
-				Keepalive:    peers[i].KeepAlive,
-				Listenport:   peers[i].ListenPort,
-				Localaddress: peers[i].LocalAddress,
-			},
-		})
-	}
-
-	node, err := functions.GetNodeByMacAddress(req.GetNetwork(), req.GetMacaddress())
-	if err != nil {
-		return status.Errorf(codes.Internal, fmt.Sprintf("Could not get node: %v", err))
-	}
-
-	err = TimestampNode(node, false, true, false)
-	if err != nil {
-		return status.Errorf(codes.Internal, fmt.Sprintf("Internal error occurred: %v", err))
-	}
-
-	return nil
+	return &nodepb.Object{
+		Data: string(extData),
+		Type: nodepb.EXT_PEER,
+	}, nil
 }