Mid way through adopting rqlite

This commit is contained in:
afeiszli
2021-07-21 18:55:19 -04:00
parent d22ad13cfe
commit 93b0b94788
26 changed files with 946 additions and 1587 deletions

View File

@@ -1,21 +1,16 @@
package controller
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"time"
"github.com/go-playground/validator/v10"
"github.com/gorilla/mux"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/functions"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/mongoconn"
"github.com/txn2/txeh"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo/options"
)
func dnsHandlers(r *mux.Router) {
@@ -82,39 +77,23 @@ func GetNodeDNS(network string) ([]models.DNSEntry, error) {
var dns []models.DNSEntry
collection := mongoconn.Client.Database("netmaker").Collection("nodes")
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
filter := bson.M{"network": network}
cur, err := collection.Find(ctx, filter, options.Find().SetProjection(bson.M{"_id": 0}))
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
return dns, err
}
defer cancel()
for cur.Next(context.TODO()) {
for _, value := range collection {
var entry models.DNSEntry
err := cur.Decode(&entry)
if err != nil {
return dns, err
var node models.Node
if err = json.Unmarshal([]byte(value), &node); err != nil {
continue
}
if err = json.Unmarshal([]byte(value), &entry); node.Network == network && err == nil {
dns = append(dns, entry)
}
// add item our array of nodes
dns = append(dns, entry)
}
//TODO: Another fatal error we should take care of.
if err := cur.Err(); err != nil {
return dns, err
}
return dns, err
return dns, nil
}
//Gets all nodes associated with network, including pending nodes
@@ -140,36 +119,20 @@ func GetCustomDNS(network string) ([]models.DNSEntry, error) {
var dns []models.DNSEntry
collection := mongoconn.Client.Database("netmaker").Collection("dns")
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
filter := bson.M{"network": network}
cur, err := collection.Find(ctx, filter, options.Find().SetProjection(bson.M{"_id": 0}))
collection, err := database.FetchRecords(database.DNS_TABLE_NAME)
if err != nil {
return dns, err
}
defer cancel()
for cur.Next(context.TODO()) {
for _, value := range collection { // filter for entries based on network
var entry models.DNSEntry
err := cur.Decode(&entry)
if err != nil {
return dns, err
if err := json.Unmarshal([]byte(value), entry); err != nil {
continue
}
// add item our array of nodes
dns = append(dns, entry)
}
//TODO: Another fatal error we should take care of.
if err := cur.Err(); err != nil {
return dns, err
if entry.Network == network {
dns = append(dns, entry)
}
}
return dns, err
@@ -343,109 +306,78 @@ func deleteDNS(w http.ResponseWriter, r *http.Request) {
// get params
var params = mux.Vars(r)
success, err := DeleteDNS(params["domain"], params["network"])
err := DeleteDNS(params["domain"], params["network"])
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
} else if !success {
returnErrorResponse(w, r, formatError(errors.New("Delete unsuccessful."), "badrequest"))
return
}
json.NewEncoder(w).Encode(params["domain"] + " deleted.")
entrytext := params["domain"] + "." + params["network"]
functions.PrintUserLog("netmaker", "deleted dns entry: "+entrytext, 1)
json.NewEncoder(w).Encode(entrytext + " deleted.")
}
func CreateDNS(entry models.DNSEntry) (models.DNSEntry, error) {
// connect db
collection := mongoconn.Client.Database("netmaker").Collection("dns")
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
// insert our node to the node db.
_, err := collection.InsertOne(ctx, entry)
defer cancel()
data, err := json.Marshal(&entry)
if err != nil {
return models.DNSEntry{}, err
}
key, err := functions.GetRecordKey(entry.Name, entry.Network)
if err != nil {
return models.DNSEntry{}, err
}
err = database.Insert(key, string(data), database.DNS_TABLE_NAME)
return entry, err
}
func GetDNSEntry(domain string, network string) (models.DNSEntry, error) {
var entry models.DNSEntry
collection := mongoconn.Client.Database("netmaker").Collection("dns")
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
filter := bson.M{"name": domain, "network": network}
err := collection.FindOne(ctx, filter, options.FindOne().SetProjection(bson.M{"_id": 0})).Decode(&entry)
defer cancel()
key, err := functions.GetRecordKey(domain, network)
if err != nil {
return entry, err
}
record, err := database.FetchRecord(database.DNS_TABLE_NAME, key)
if err != nil {
return entry, err
}
err = json.Unmarshal([]byte(record), &entry)
return entry, err
}
func UpdateDNS(dnschange models.DNSEntry, entry models.DNSEntry) (models.DNSEntry, error) {
queryDNS := entry.Name
key, err := functions.GetRecordKey(entry.Name, entry.Network)
if err != nil {
return entry, err
}
if dnschange.Name != "" {
entry.Name = dnschange.Name
}
if dnschange.Address != "" {
entry.Address = dnschange.Address
}
//collection := mongoconn.ConnectDB()
collection := mongoconn.Client.Database("netmaker").Collection("dns")
newkey, err := functions.GetRecordKey(entry.Name, entry.Network)
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
// Create filter
filter := bson.M{"name": queryDNS}
// prepare update model.
update := bson.D{
{"$set", bson.D{
{"name", entry.Name},
{"address", entry.Address},
}},
}
var dnsupdate models.DNSEntry
errN := collection.FindOneAndUpdate(ctx, filter, update).Decode(&dnsupdate)
if errN != nil {
fmt.Println("Could not update: ")
fmt.Println(errN)
} else {
fmt.Println("DNS Entry updated successfully.")
err = database.DeleteRecord(database.DNS_TABLE_NAME, key)
if err != nil {
return entry, err
}
defer cancel()
data, err := json.Marshal(&entry)
err = database.Insert(newkey, string(data), database.DNS_TABLE_NAME)
return entry, err
return dnsupdate, errN
}
func DeleteDNS(domain string, network string) (bool, error) {
fmt.Println("delete dns entry ", domain, network)
deleted := false
collection := mongoconn.Client.Database("netmaker").Collection("dns")
filter := bson.M{"name": domain, "network": network}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
result, err := collection.DeleteOne(ctx, filter)
deletecount := result.DeletedCount
if deletecount > 0 {
deleted = true
func DeleteDNS(domain string, network string) error {
key, err := functions.GetRecordKey(domain, network)
if err != nil {
return err
}
defer cancel()
return deleted, err
err = database.DeleteRecord(database.DNS_TABLE_NAME, key)
return err
}
func pushDNS(w http.ResponseWriter, r *http.Request) {