Skip to content
Snippets Groups Projects
nodeStore.go 4.75 KiB
Newer Older
  • Learn to ignore specific revisions
  • package nodes
    
    import (
    	"fmt"
    	"log"
    
    	"code.fbi.h-da.de/danet/gosdn/controller/nucleus/database"
    	"code.fbi.h-da.de/danet/gosdn/controller/nucleus/errors"
    
    	"code.fbi.h-da.de/danet/gosdn/controller/topology/store"
    
    	"github.com/google/uuid"
    	"go.mongodb.org/mongo-driver/bson"
    	"go.mongodb.org/mongo-driver/bson/primitive"
    	"go.mongodb.org/mongo-driver/mongo/options"
    )
    
    // Store defines a NodeStore interface
    type Store interface {
    	Add(Node) error
    	Update(Node) error
    	Delete(Node) error
    	Get(store.Query) (Node, error)
    	GetAll() ([]Node, error)
    }
    
    // DatabaseNodeStore is a database store for nodes
    type DatabaseNodeStore struct {
    	storeName string
    }
    
    // NewDatabaseNodeStore returns a NodeStore
    func NewDatabaseNodeStore() Store {
    	return &DatabaseNodeStore{
    		storeName: fmt.Sprintf("node-store.json"),
    	}
    }
    
    // Get takes a nodes's UUID or name and returns the nodes.
    func (s *DatabaseNodeStore) Get(query store.Query) (Node, error) {
    	var loadedNode Node
    
    	if query.ID.String() != "" {
    		loadedNode, err := s.getByID(query.ID)
    		if err != nil {
    
    André Sterba's avatar
    André Sterba committed
    			return loadedNode, errors.ErrCouldNotFind{ID: query.ID, Name: query.Name}
    
    		}
    
    		return loadedNode, nil
    	}
    
    	loadedNode, err := s.getByName(query.Name)
    	if err != nil {
    
    André Sterba's avatar
    André Sterba committed
    		return loadedNode, errors.ErrCouldNotFind{ID: query.ID, Name: query.Name}
    
    André Sterba's avatar
    André Sterba committed
    func (s *DatabaseNodeStore) getByID(idOfNode uuid.UUID) (Node, error) {
    
    	var loadedNode Node
    
    	client, ctx, cancel := database.GetMongoConnection()
    	defer cancel()
    	defer client.Disconnect(ctx)
    
    	db := client.Database(database.DatabaseName)
    	collection := db.Collection(s.storeName)
    
    André Sterba's avatar
    André Sterba committed
    	result := collection.FindOne(ctx, bson.D{primitive.E{Key: "_id", Value: idOfNode.String()}})
    
    	if result == nil {
    
    André Sterba's avatar
    André Sterba committed
    		return loadedNode, errors.ErrCouldNotFind{ID: idOfNode}
    
    	}
    
    	err := result.Decode(&loadedNode)
    	if err != nil {
    		log.Printf("Failed marshalling %v", err)
    
    André Sterba's avatar
    André Sterba committed
    		return loadedNode, errors.ErrCouldNotFind{ID: idOfNode}
    
    André Sterba's avatar
    André Sterba committed
    func (s *DatabaseNodeStore) getByName(nameOfNode string) (Node, error) {
    
    	var loadedNode Node
    
    	client, ctx, cancel := database.GetMongoConnection()
    	defer cancel()
    	defer client.Disconnect(ctx)
    
    	db := client.Database(database.DatabaseName)
    	collection := db.Collection(s.storeName)
    
    André Sterba's avatar
    André Sterba committed
    	result := collection.FindOne(ctx, bson.D{primitive.E{Key: "name", Value: nameOfNode}})
    
    	if result == nil {
    
    André Sterba's avatar
    André Sterba committed
    		return loadedNode, errors.ErrCouldNotFind{Name: nameOfNode}
    
    	}
    
    	err := result.Decode(&loadedNode)
    	if err != nil {
    		log.Printf("Failed marshalling %v", err)
    
    André Sterba's avatar
    André Sterba committed
    		return loadedNode, errors.ErrCouldNotFind{Name: nameOfNode}
    
    	}
    
    	return loadedNode, nil
    }
    
    // GetAll returns all stored nodes.
    func (s *DatabaseNodeStore) GetAll() ([]Node, error) {
    	var loadedNode []Node
    
    	client, ctx, cancel := database.GetMongoConnection()
    	defer cancel()
    	defer client.Disconnect(ctx)
    	db := client.Database(database.DatabaseName)
    	collection := db.Collection(s.storeName)
    
    	cursor, err := collection.Find(ctx, bson.D{})
    	if err != nil {
    		return []Node{}, err
    	}
    	defer cursor.Close(ctx)
    
    	err = cursor.All(ctx, &loadedNode)
    	if err != nil {
    		log.Printf("Failed marshalling %v", err)
    
    
    		return loadedNode, errors.ErrCouldNotMarshall{Type: loadedNode, Err: err}
    
    	}
    
    	return loadedNode, nil
    }
    
    // Add adds a node to the node store.
    func (s *DatabaseNodeStore) Add(node Node) error {
    	client, ctx, cancel := database.GetMongoConnection()
    	defer cancel()
    	defer client.Disconnect(ctx)
    
    	_, err := client.Database(database.DatabaseName).
    		Collection(s.storeName).
    		InsertOne(ctx, node)
    	if err != nil {
    		log.Printf("Could not add Node: %v", err)
    
    		return errors.ErrCouldNotCreate{Identifier: node.ID, Type: node, Err: err}
    
    	}
    
    	return nil
    }
    
    // Update updates a existing node.
    func (s *DatabaseNodeStore) Update(node Node) error {
    	var updatedLoadedNodes Node
    
    	client, ctx, cancel := database.GetMongoConnection()
    	defer cancel()
    	defer client.Disconnect(ctx)
    
    	update := bson.D{primitive.E{Key: "$set", Value: node}}
    
    	upsert := false
    	after := options.After
    	opt := options.FindOneAndUpdateOptions{
    		Upsert:         &upsert,
    		ReturnDocument: &after,
    	}
    
    	err := client.Database(database.DatabaseName).
    		Collection(s.storeName).
    		FindOneAndUpdate(
    			ctx, bson.M{"_id": node.ID.String()}, update, &opt).
    		Decode(&updatedLoadedNodes)
    	if err != nil {
    		log.Printf("Could not update Node: %v", err)
    
    
    		return errors.ErrCouldNotUpdate{Identifier: node.ID, Type: node, Err: err}
    
    	}
    
    	return nil
    }
    
    // Delete deletes a node from the node store.
    func (s *DatabaseNodeStore) Delete(node Node) error {
    	client, ctx, cancel := database.GetMongoConnection()
    	defer cancel()
    	defer client.Disconnect(ctx)
    
    	db := client.Database(database.DatabaseName)
    	collection := db.Collection(s.storeName)
    	_, err := collection.DeleteOne(ctx, bson.D{primitive.E{Key: node.ID.String()}})
    	if err != nil {
    		return err
    	}
    
    	return nil
    }