helpers.go 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438
  1. package functions
  2. import (
  3. "encoding/json"
  4. "fmt"
  5. "log"
  6. "math/rand"
  7. "strings"
  8. "time"
  9. "github.com/gravitl/netmaker/database"
  10. "github.com/gravitl/netmaker/logic"
  11. "github.com/gravitl/netmaker/models"
  12. )
  13. // ParseNetwork - parses a network into a model
  14. func ParseNetwork(value string) (models.Network, error) {
  15. var network models.Network
  16. err := json.Unmarshal([]byte(value), &network)
  17. return network, err
  18. }
  19. // ParseNode - parses a node into a model
  20. func ParseNode(value string) (models.Node, error) {
  21. var node models.Node
  22. err := json.Unmarshal([]byte(value), &node)
  23. return node, err
  24. }
  25. // ParseExtClient - parses an extclient into a model
  26. func ParseExtClient(value string) (models.ExtClient, error) {
  27. var extClient models.ExtClient
  28. err := json.Unmarshal([]byte(value), &extClient)
  29. return extClient, err
  30. }
  31. // ParseIntClient - parses int client
  32. func ParseIntClient(value string) (models.IntClient, error) {
  33. var intClient models.IntClient
  34. err := json.Unmarshal([]byte(value), &intClient)
  35. return intClient, err
  36. }
  37. //Takes in an arbitrary field and value for field and checks to see if any other
  38. //node has that value for the same field within the network
  39. // SliceContains - sees if a slice contains something
  40. func SliceContains(slice []string, item string) bool {
  41. set := make(map[string]struct{}, len(slice))
  42. for _, s := range slice {
  43. set[s] = struct{}{}
  44. }
  45. _, ok := set[item]
  46. return ok
  47. }
  48. // GetPeersList - gets peers for given network
  49. func GetPeersList(networkName string) ([]models.PeersResponse, error) {
  50. var peers []models.PeersResponse
  51. collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
  52. if err != nil {
  53. return peers, err
  54. }
  55. for _, value := range collection {
  56. var peer models.PeersResponse
  57. err := json.Unmarshal([]byte(value), &peer)
  58. if err != nil {
  59. continue // try the rest
  60. }
  61. peers = append(peers, peer)
  62. }
  63. return peers, err
  64. }
  65. // GetIntPeersList - get int peers list
  66. func GetIntPeersList() ([]models.PeersResponse, error) {
  67. var peers []models.PeersResponse
  68. records, err := database.FetchRecords(database.INT_CLIENTS_TABLE_NAME)
  69. if err != nil {
  70. return peers, err
  71. }
  72. // parse the peers
  73. for _, value := range records {
  74. var peer models.PeersResponse
  75. err := json.Unmarshal([]byte(value), &peer)
  76. if err != nil {
  77. log.Fatal(err)
  78. }
  79. // add the node to our node array
  80. //maybe better to just return this? But then that's just GetNodes...
  81. peers = append(peers, peer)
  82. }
  83. return peers, err
  84. }
  85. // GetServerIntClient - get server int client
  86. func GetServerIntClient() (*models.IntClient, error) {
  87. intClients, err := database.FetchRecords(database.INT_CLIENTS_TABLE_NAME)
  88. for _, value := range intClients {
  89. var intClient models.IntClient
  90. err = json.Unmarshal([]byte(value), &intClient)
  91. if err != nil {
  92. return nil, err
  93. }
  94. if intClient.IsServer == "yes" && intClient.Network == "comms" {
  95. return &intClient, nil
  96. }
  97. }
  98. return nil, err
  99. }
  100. // NetworkExists - check if network exists
  101. func NetworkExists(name string) (bool, error) {
  102. var network string
  103. var err error
  104. if network, err = database.FetchRecord(database.NETWORKS_TABLE_NAME, name); err != nil {
  105. return false, err
  106. }
  107. return len(network) > 0, nil
  108. }
  109. // NetworkNodesUpdateAction - updates action of network nodes
  110. func NetworkNodesUpdateAction(networkName string, action string) error {
  111. collections, err := database.FetchRecords(database.NODES_TABLE_NAME)
  112. if err != nil {
  113. if database.IsEmptyRecord(err) {
  114. return nil
  115. }
  116. return err
  117. }
  118. for _, value := range collections {
  119. var node models.Node
  120. err := json.Unmarshal([]byte(value), &node)
  121. if err != nil {
  122. fmt.Println("error in node address assignment!")
  123. return err
  124. }
  125. if action == models.NODE_UPDATE_KEY && node.IsStatic == "yes" {
  126. continue
  127. }
  128. if node.Network == networkName {
  129. node.Action = action
  130. data, err := json.Marshal(&node)
  131. if err != nil {
  132. return err
  133. }
  134. node.SetID()
  135. database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
  136. }
  137. }
  138. return nil
  139. }
  140. // NetworkNodesUpdatePullChanges - tells nodes on network to pull
  141. func NetworkNodesUpdatePullChanges(networkName string) error {
  142. collections, err := database.FetchRecords(database.NODES_TABLE_NAME)
  143. if err != nil {
  144. if database.IsEmptyRecord(err) {
  145. return nil
  146. }
  147. return err
  148. }
  149. for _, value := range collections {
  150. var node models.Node
  151. err := json.Unmarshal([]byte(value), &node)
  152. if err != nil {
  153. fmt.Println("error in node address assignment!")
  154. return err
  155. }
  156. if node.Network == networkName {
  157. node.PullChanges = "yes"
  158. data, err := json.Marshal(&node)
  159. if err != nil {
  160. return err
  161. }
  162. node.SetID()
  163. database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
  164. }
  165. }
  166. return nil
  167. }
  168. // IsNetworkDisplayNameUnique - checks if network display name unique
  169. func IsNetworkDisplayNameUnique(name string) (bool, error) {
  170. isunique := true
  171. dbs, err := logic.GetNetworks()
  172. if err != nil {
  173. return database.IsEmptyRecord(err), err
  174. }
  175. for i := 0; i < len(dbs); i++ {
  176. if name == dbs[i].DisplayName {
  177. isunique = false
  178. }
  179. }
  180. return isunique, nil
  181. }
  182. // IsMacAddressUnique - checks if mac is unique
  183. func IsMacAddressUnique(macaddress string, networkName string) (bool, error) {
  184. _, err := database.FetchRecord(database.NODES_TABLE_NAME, macaddress+"###"+networkName)
  185. if err != nil {
  186. return database.IsEmptyRecord(err), err
  187. }
  188. return true, nil
  189. }
  190. // GetNetworkNonServerNodeCount - get number of network non server nodes
  191. func GetNetworkNonServerNodeCount(networkName string) (int, error) {
  192. collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
  193. count := 0
  194. if err != nil && !database.IsEmptyRecord(err) {
  195. return count, err
  196. }
  197. for _, value := range collection {
  198. var node models.Node
  199. if err = json.Unmarshal([]byte(value), &node); err != nil {
  200. return count, err
  201. } else {
  202. if node.Network == networkName && node.IsServer != "yes" {
  203. count++
  204. }
  205. }
  206. }
  207. return count, nil
  208. }
  209. // IsKeyValidGlobal - checks if a key is valid globally
  210. func IsKeyValidGlobal(keyvalue string) bool {
  211. networks, _ := logic.GetNetworks()
  212. var key models.AccessKey
  213. foundkey := false
  214. isvalid := false
  215. for _, network := range networks {
  216. for i := len(network.AccessKeys) - 1; i >= 0; i-- {
  217. currentkey := network.AccessKeys[i]
  218. if currentkey.Value == keyvalue {
  219. key = currentkey
  220. foundkey = true
  221. break
  222. }
  223. }
  224. if foundkey {
  225. break
  226. }
  227. }
  228. if foundkey {
  229. if key.Uses > 0 {
  230. isvalid = true
  231. }
  232. }
  233. return isvalid
  234. }
  235. //TODO: Contains a fatal error return. Need to change
  236. //This just gets a network object from a network name
  237. //Should probably just be GetNetwork. kind of a dumb name.
  238. //Used in contexts where it's not the Parent network.
  239. //Similar to above but checks if Cidr range is valid
  240. //At least this guy's got some print statements
  241. //still not good error handling
  242. //This checks to make sure a network name is valid.
  243. //Switch to REGEX?
  244. // NameInNetworkCharSet - see if name is in charset for networks
  245. func NameInNetworkCharSet(name string) bool {
  246. charset := "abcdefghijklmnopqrstuvwxyz1234567890-_."
  247. for _, char := range name {
  248. if !strings.Contains(charset, strings.ToLower(string(char))) {
  249. return false
  250. }
  251. }
  252. return true
  253. }
  254. // NameInDNSCharSet - name in dns char set
  255. func NameInDNSCharSet(name string) bool {
  256. charset := "abcdefghijklmnopqrstuvwxyz1234567890-."
  257. for _, char := range name {
  258. if !strings.Contains(charset, strings.ToLower(string(char))) {
  259. return false
  260. }
  261. }
  262. return true
  263. }
  264. // NameInNodeCharSet - name in node char set
  265. func NameInNodeCharSet(name string) bool {
  266. charset := "abcdefghijklmnopqrstuvwxyz1234567890-"
  267. for _, char := range name {
  268. if !strings.Contains(charset, strings.ToLower(string(char))) {
  269. return false
  270. }
  271. }
  272. return true
  273. }
  274. // RemoveDeletedNode - remove deleted node
  275. func RemoveDeletedNode(nodeid string) bool {
  276. return database.DeleteRecord(database.DELETED_NODES_TABLE_NAME, nodeid) == nil
  277. }
  278. // DeleteAllIntClients - delete all int clients
  279. func DeleteAllIntClients() error {
  280. err := database.DeleteAllRecords(database.INT_CLIENTS_TABLE_NAME)
  281. if err != nil {
  282. return err
  283. }
  284. return nil
  285. }
  286. // GetAllIntClients - get all int clients
  287. func GetAllIntClients() ([]models.IntClient, error) {
  288. var clients []models.IntClient
  289. collection, err := database.FetchRecords(database.INT_CLIENTS_TABLE_NAME)
  290. if err != nil {
  291. return clients, err
  292. }
  293. for _, value := range collection {
  294. var client models.IntClient
  295. err := json.Unmarshal([]byte(value), &client)
  296. if err != nil {
  297. return []models.IntClient{}, err
  298. }
  299. // add node to our array
  300. clients = append(clients, client)
  301. }
  302. return clients, nil
  303. }
  304. // GetAllExtClients - get all ext clients
  305. func GetAllExtClients() ([]models.ExtClient, error) {
  306. var extclients []models.ExtClient
  307. collection, err := database.FetchRecords(database.EXT_CLIENT_TABLE_NAME)
  308. if err != nil {
  309. return extclients, err
  310. }
  311. for _, value := range collection {
  312. var extclient models.ExtClient
  313. err := json.Unmarshal([]byte(value), &extclient)
  314. if err != nil {
  315. return []models.ExtClient{}, err
  316. }
  317. // add node to our array
  318. extclients = append(extclients, extclient)
  319. }
  320. return extclients, nil
  321. }
  322. // GenKey - generates access key
  323. func GenKey() string {
  324. var seededRand *rand.Rand = rand.New(
  325. rand.NewSource(time.Now().UnixNano()))
  326. length := 16
  327. charset := "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
  328. b := make([]byte, length)
  329. for i := range b {
  330. b[i] = charset[seededRand.Intn(len(charset))]
  331. }
  332. return string(b)
  333. }
  334. //generate a key value
  335. //we should probably just have 1 random string generator
  336. //that can be used across all functions
  337. //have a "base string" a "length" and a "charset"
  338. // GenKeyName - generates a key name
  339. func GenKeyName() string {
  340. var seededRand *rand.Rand = rand.New(
  341. rand.NewSource(time.Now().UnixNano()))
  342. length := 5
  343. charset := "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
  344. b := make([]byte, length)
  345. for i := range b {
  346. b[i] = charset[seededRand.Intn(len(charset))]
  347. }
  348. return "key" + string(b)
  349. }
  350. // DeleteKey - deletes a key
  351. func DeleteKey(network models.Network, i int) {
  352. network.AccessKeys = append(network.AccessKeys[:i],
  353. network.AccessKeys[i+1:]...)
  354. if networkData, err := json.Marshal(&network); err != nil {
  355. return
  356. } else {
  357. database.Insert(network.NetID, string(networkData), database.NETWORKS_TABLE_NAME)
  358. }
  359. }