node_grpc.go 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271
  1. package controller
  2. import (
  3. "context"
  4. "encoding/json"
  5. "errors"
  6. "strings"
  7. "time"
  8. nodepb "github.com/gravitl/netmaker/grpc"
  9. "github.com/gravitl/netmaker/logger"
  10. "github.com/gravitl/netmaker/logic"
  11. "github.com/gravitl/netmaker/models"
  12. "github.com/gravitl/netmaker/servercfg"
  13. )
  14. // NodeServiceServer - represents the service server for gRPC
  15. type NodeServiceServer struct {
  16. nodepb.UnimplementedNodeServiceServer
  17. }
  18. // NodeServiceServer.ReadNode - reads node and responds with gRPC
  19. func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
  20. var node, err = getNewOrLegacyNode(req.Data)
  21. if err != nil {
  22. return nil, err
  23. }
  24. node.NetworkSettings, err = logic.GetNetworkSettings(node.Network)
  25. if err != nil {
  26. return nil, err
  27. }
  28. node.SetLastCheckIn()
  29. // Cast to ReadNodeRes type
  30. nodeData, errN := json.Marshal(&node)
  31. if errN != nil {
  32. return nil, err
  33. }
  34. logic.UpdateNode(&node, &node)
  35. response := &nodepb.Object{
  36. Data: string(nodeData),
  37. Type: nodepb.NODE_TYPE,
  38. }
  39. return response, nil
  40. }
  41. // NodeServiceServer.CreateNode - creates a node and responds over gRPC
  42. func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
  43. var node = models.Node{}
  44. var err error
  45. data := req.GetData()
  46. if err := json.Unmarshal([]byte(data), &node); err != nil {
  47. return nil, err
  48. }
  49. validKey := logic.IsKeyValid(node.Network, node.AccessKey)
  50. node.NetworkSettings, err = logic.GetNetworkSettings(node.Network)
  51. if err != nil {
  52. return nil, err
  53. }
  54. if !validKey {
  55. if node.NetworkSettings.AllowManualSignUp == "yes" {
  56. node.IsPending = "yes"
  57. } else {
  58. return nil, errors.New("invalid key, and network does not allow no-key signups")
  59. }
  60. }
  61. getServerAddrs(&node)
  62. key, keyErr := logic.RetrievePublicTrafficKey()
  63. if keyErr != nil {
  64. logger.Log(0, "error retrieving key: ", keyErr.Error())
  65. return nil, keyErr
  66. }
  67. node.TrafficKeys = models.TrafficKeys{
  68. Mine: node.TrafficKeys.Mine,
  69. Server: key,
  70. }
  71. err = logic.CreateNode(&node)
  72. if err != nil {
  73. return nil, err
  74. }
  75. nodeData, errN := json.Marshal(&node)
  76. if errN != nil {
  77. return nil, err
  78. }
  79. response := &nodepb.Object{
  80. Data: string(nodeData),
  81. Type: nodepb.NODE_TYPE,
  82. }
  83. runUpdates(&node, false)
  84. return response, nil
  85. }
  86. // NodeServiceServer.UpdateNode updates a node and responds over gRPC
  87. func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
  88. var newnode models.Node
  89. if err := json.Unmarshal([]byte(req.GetData()), &newnode); err != nil {
  90. return nil, err
  91. }
  92. node, err := logic.GetNodeByIDorMacAddress(newnode.ID, newnode.MacAddress, newnode.Network)
  93. if err != nil {
  94. return nil, err
  95. }
  96. if !servercfg.GetRce() {
  97. newnode.PostDown = node.PostDown
  98. newnode.PostUp = node.PostUp
  99. }
  100. getServerAddrs(&node)
  101. err = logic.UpdateNode(&node, &newnode)
  102. if err != nil {
  103. return nil, err
  104. }
  105. newnode.NetworkSettings, err = logic.GetNetworkSettings(node.Network)
  106. if err != nil {
  107. return nil, err
  108. }
  109. nodeData, errN := json.Marshal(&newnode)
  110. if errN != nil {
  111. return nil, err
  112. }
  113. runUpdates(&node, false)
  114. return &nodepb.Object{
  115. Data: string(nodeData),
  116. Type: nodepb.NODE_TYPE,
  117. }, nil
  118. }
  119. func getServerAddrs(node *models.Node) {
  120. serverNode := logic.GetServerNodes(node.Network)[0]
  121. pubIP, _ := servercfg.GetPublicIP()
  122. var serverAddrs = []models.ServerAddr{
  123. {
  124. IsLeader: true,
  125. Address: pubIP,
  126. ID: serverNode.ID,
  127. },
  128. }
  129. networkSettings, _ := logic.GetParentNetwork(node.Network)
  130. // TODO consolidate functionality around files
  131. networkSettings.NodesLastModified = time.Now().Unix()
  132. networkSettings.DefaultServerAddrs = serverAddrs
  133. if err := logic.SaveNetwork(&networkSettings); err != nil {
  134. logger.Log(1, "unable to save network on serverAddr update", err.Error())
  135. }
  136. }
  137. // NodeServiceServer.DeleteNode - deletes a node and responds over gRPC
  138. func (s *NodeServiceServer) DeleteNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
  139. var node, err = getNewOrLegacyNode(req.Data)
  140. if err != nil {
  141. return nil, err
  142. }
  143. err = logic.DeleteNodeByID(&node, true)
  144. if err != nil {
  145. return nil, err
  146. }
  147. runServerPeerUpdate(&node, false)
  148. return &nodepb.Object{
  149. Data: "success",
  150. Type: nodepb.STRING_TYPE,
  151. }, nil
  152. }
  153. // NodeServiceServer.GetPeers - fetches peers over gRPC
  154. func (s *NodeServiceServer) GetPeers(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
  155. var node, err = getNewOrLegacyNode(req.Data)
  156. if err != nil {
  157. return nil, err
  158. }
  159. excludeIsRelayed := node.IsRelay != "yes"
  160. var relayedNode string
  161. if node.IsRelayed == "yes" {
  162. relayedNode = node.Address
  163. }
  164. peers, err := logic.GetPeersList(node.Network, excludeIsRelayed, relayedNode)
  165. if err != nil {
  166. return nil, err
  167. }
  168. peersData, err := json.Marshal(&peers)
  169. logger.Log(3, node.Address, "checked in successfully")
  170. return &nodepb.Object{
  171. Data: string(peersData),
  172. Type: nodepb.NODE_TYPE,
  173. }, err
  174. }
  175. // NodeServiceServer.GetExtPeers - returns ext peers for a gateway node
  176. func (s *NodeServiceServer) GetExtPeers(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
  177. var node, err = getNewOrLegacyNode(req.Data)
  178. if err != nil {
  179. return nil, err
  180. }
  181. peers, err := logic.GetExtPeersList(&node)
  182. if err != nil {
  183. return nil, err
  184. }
  185. var extPeers []models.Node
  186. for i := 0; i < len(peers); i++ {
  187. extPeers = append(extPeers, models.Node{
  188. Address: peers[i].Address,
  189. Address6: peers[i].Address6,
  190. Endpoint: peers[i].Endpoint,
  191. PublicKey: peers[i].PublicKey,
  192. PersistentKeepalive: peers[i].KeepAlive,
  193. ListenPort: peers[i].ListenPort,
  194. LocalAddress: peers[i].LocalAddress,
  195. })
  196. }
  197. extData, err := json.Marshal(&extPeers)
  198. if err != nil {
  199. return nil, err
  200. }
  201. return &nodepb.Object{
  202. Data: string(extData),
  203. Type: nodepb.EXT_PEER,
  204. }, nil
  205. }
  206. // == private methods ==
  207. func getNewOrLegacyNode(data string) (models.Node, error) {
  208. var reqNode, node models.Node
  209. var err error
  210. if err = json.Unmarshal([]byte(data), &reqNode); err != nil {
  211. oldID := strings.Split(data, "###") // handle legacy client IDs
  212. if len(oldID) == 2 {
  213. if node, err = logic.GetNodeByIDorMacAddress(reqNode.ID, oldID[0], oldID[1]); err != nil {
  214. return models.Node{}, err
  215. }
  216. } else {
  217. return models.Node{}, err
  218. }
  219. } else {
  220. node, err = logic.GetNodeByIDorMacAddress(reqNode.ID, reqNode.MacAddress, reqNode.Network)
  221. if err != nil {
  222. return models.Node{}, err
  223. }
  224. }
  225. return node, nil
  226. }
  227. func isServer(node *models.Node) bool {
  228. return node.IsServer == "yes"
  229. }