migrate.go 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214
  1. package controller
  2. import (
  3. "encoding/json"
  4. "fmt"
  5. "net"
  6. "net/http"
  7. "strconv"
  8. "time"
  9. "github.com/google/uuid"
  10. "github.com/gravitl/netmaker/database"
  11. "github.com/gravitl/netmaker/logger"
  12. "github.com/gravitl/netmaker/logic"
  13. "github.com/gravitl/netmaker/models"
  14. "github.com/gravitl/netmaker/mq"
  15. "github.com/gravitl/netmaker/servercfg"
  16. "golang.org/x/crypto/bcrypt"
  17. "golang.org/x/exp/slog"
  18. "golang.zx2c4.com/wireguard/wgctrl/wgtypes"
  19. )
  20. // swagger:route PUT /api/v1/nodes/migrate nodes migrateNode
  21. //
  22. // Used to migrate a legacy node.
  23. //
  24. // Schemes: https
  25. //
  26. // Security:
  27. // oauth
  28. //
  29. // Responses:
  30. // 200: nodeJoinResponse
  31. func migrate(w http.ResponseWriter, r *http.Request) {
  32. data := models.MigrationData{}
  33. host := models.Host{}
  34. node := models.Node{}
  35. nodes := []models.Node{}
  36. server := models.ServerConfig{}
  37. err := json.NewDecoder(r.Body).Decode(&data)
  38. if err != nil {
  39. logger.Log(0, r.Header.Get("user"), "error decoding request body: ", err.Error())
  40. logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
  41. return
  42. }
  43. for i, legacy := range data.LegacyNodes {
  44. record, err := database.FetchRecord(database.NODES_TABLE_NAME, legacy.ID)
  45. if err != nil {
  46. slog.Error("legacy node not found", "error", err)
  47. logic.ReturnErrorResponse(w, r, logic.FormatError(fmt.Errorf("legacy node not found %w", err), "badrequest"))
  48. return
  49. }
  50. var legacyNode models.LegacyNode
  51. if err = json.Unmarshal([]byte(record), &legacyNode); err != nil {
  52. slog.Error("decoding legacy node", "errror", err)
  53. logic.ReturnErrorResponse(w, r, logic.FormatError(fmt.Errorf("decode legacy node %w", err), "badrequest"))
  54. return
  55. }
  56. if err := bcrypt.CompareHashAndPassword([]byte(legacyNode.Password), []byte(legacy.Password)); err != nil {
  57. slog.Error("legacy node invalid password", "error", err)
  58. logic.ReturnErrorResponse(w, r, logic.FormatError(fmt.Errorf("invalid password %w", err), "unauthorized"))
  59. return
  60. }
  61. if i == 0 {
  62. host, node = convertLegacyHostNode(legacy)
  63. host.Name = data.HostName
  64. host.HostPass = data.Password
  65. host.OS = data.OS
  66. if err := logic.CreateHost(&host); err != nil {
  67. slog.Error("create host", "error", err)
  68. logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
  69. return
  70. }
  71. server = servercfg.GetServerInfo()
  72. if servercfg.GetBrokerType() == servercfg.EmqxBrokerType {
  73. server.MQUserName = host.ID.String()
  74. }
  75. key, keyErr := logic.RetrievePublicTrafficKey()
  76. if keyErr != nil {
  77. slog.Error("retrieving traffickey", "error", err)
  78. logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
  79. return
  80. }
  81. server.TrafficKey = key
  82. } else {
  83. node = convertLegacyNode(legacyNode, host.ID)
  84. }
  85. if err := logic.UpsertNode(&node); err != nil {
  86. slog.Error("update node", "error", err)
  87. continue
  88. }
  89. host.Nodes = append(host.Nodes, node.ID.String())
  90. nodes = append(nodes, node)
  91. }
  92. if err := logic.UpsertHost(&host); err != nil {
  93. slog.Error("save host", "error", err)
  94. }
  95. go mq.PublishPeerUpdate()
  96. response := models.HostPull{
  97. Host: host,
  98. Nodes: nodes,
  99. ServerConfig: server,
  100. }
  101. w.WriteHeader(http.StatusOK)
  102. json.NewEncoder(w).Encode(&response)
  103. slog.Info("migrated nodes")
  104. // check for gateways
  105. for _, node := range data.LegacyNodes {
  106. if node.IsEgressGateway == "yes" {
  107. egressGateway := models.EgressGatewayRequest{
  108. NodeID: node.ID,
  109. Ranges: node.EgressGatewayRanges,
  110. NatEnabled: node.EgressGatewayNatEnabled,
  111. }
  112. if _, err := logic.CreateEgressGateway(egressGateway); err != nil {
  113. logger.Log(0, "error creating egress gateway for node", node.ID, err.Error())
  114. }
  115. }
  116. if node.IsIngressGateway == "yes" {
  117. ingressGateway := models.IngressRequest{}
  118. ingressNode, err := logic.CreateIngressGateway(node.Network, node.ID, ingressGateway)
  119. if err != nil {
  120. logger.Log(0, "error creating ingress gateway for node", node.ID, err.Error())
  121. }
  122. runUpdates(&ingressNode, true)
  123. }
  124. }
  125. }
  126. func convertLegacyHostNode(legacy models.LegacyNode) (models.Host, models.Node) {
  127. //convert host
  128. host := models.Host{}
  129. host.ID = uuid.New()
  130. host.IPForwarding = models.ParseBool(legacy.IPForwarding)
  131. host.AutoUpdate = servercfg.AutoUpdateEnabled()
  132. host.Interface = "netmaker"
  133. host.ListenPort = int(legacy.ListenPort)
  134. host.MTU = int(legacy.MTU)
  135. host.PublicKey, _ = wgtypes.ParseKey(legacy.PublicKey)
  136. host.MacAddress = net.HardwareAddr(legacy.MacAddress)
  137. host.TrafficKeyPublic = legacy.TrafficKeys.Mine
  138. host.Nodes = append([]string{}, legacy.ID)
  139. host.Interfaces = legacy.Interfaces
  140. //host.DefaultInterface = legacy.Defaul
  141. host.EndpointIP = net.ParseIP(legacy.Endpoint)
  142. host.IsDocker = models.ParseBool(legacy.IsDocker)
  143. host.IsK8S = models.ParseBool(legacy.IsK8S)
  144. host.IsStatic = models.ParseBool(legacy.IsStatic)
  145. node := convertLegacyNode(legacy, host.ID)
  146. return host, node
  147. }
  148. func convertLegacyNode(legacy models.LegacyNode, hostID uuid.UUID) models.Node {
  149. //convert node
  150. node := models.Node{}
  151. node.ID, _ = uuid.Parse(legacy.ID)
  152. node.HostID = hostID
  153. node.Network = legacy.Network
  154. valid4 := true
  155. valid6 := true
  156. _, cidr4, err := net.ParseCIDR(legacy.NetworkSettings.AddressRange)
  157. if err != nil {
  158. valid4 = false
  159. slog.Warn("parsing address range", "error", err)
  160. } else {
  161. node.NetworkRange = *cidr4
  162. }
  163. _, cidr6, err := net.ParseCIDR(legacy.NetworkSettings.AddressRange6)
  164. if err != nil {
  165. valid6 = false
  166. slog.Warn("parsing address range6", "error", err)
  167. } else {
  168. node.NetworkRange6 = *cidr6
  169. }
  170. node.Server = servercfg.GetServer()
  171. node.Connected = models.ParseBool(legacy.Connected)
  172. if valid4 {
  173. node.Address = net.IPNet{
  174. IP: net.ParseIP(legacy.Address),
  175. Mask: cidr4.Mask,
  176. }
  177. }
  178. if valid6 {
  179. node.Address6 = net.IPNet{
  180. IP: net.ParseIP(legacy.Address6),
  181. Mask: cidr6.Mask,
  182. }
  183. }
  184. node.Action = models.NODE_NOOP
  185. node.LocalAddress = net.IPNet{
  186. IP: net.ParseIP(legacy.LocalAddress),
  187. }
  188. node.IsEgressGateway = models.ParseBool(legacy.IsEgressGateway)
  189. node.EgressGatewayRanges = legacy.EgressGatewayRanges
  190. node.IsIngressGateway = models.ParseBool(legacy.IsIngressGateway)
  191. node.IsRelayed = false
  192. node.IsRelay = false
  193. node.RelayedNodes = []string{}
  194. node.DNSOn = models.ParseBool(legacy.DNSOn)
  195. node.PersistentKeepalive = time.Duration(legacy.PersistentKeepalive)
  196. node.LastModified = time.Now()
  197. node.ExpirationDateTime, _ = time.Parse(strconv.Itoa(int(legacy.ExpirationDateTime)), "0")
  198. node.EgressGatewayNatEnabled = models.ParseBool(legacy.EgressGatewayNatEnabled)
  199. node.EgressGatewayRequest = legacy.EgressGatewayRequest
  200. node.IngressGatewayRange = legacy.IngressGatewayRange
  201. node.IngressGatewayRange6 = legacy.IngressGatewayRange6
  202. node.DefaultACL = legacy.DefaultACL
  203. node.OwnerID = legacy.OwnerID
  204. node.FailoverNode, _ = uuid.Parse(legacy.FailoverNode)
  205. node.Failover = models.ParseBool(legacy.Failover)
  206. return node
  207. }