topologyStore.go

package topology

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/store"
	"code.fbi.h-da.de/danet/gosdn/controller/topology/links"
	"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 Topology store interface
type Store interface {
	AddLink(links.Link) error
	UpdateLink(links.Link) error
	DeleteLink(links.Link) error
	Get(store.Query) (links.Link, error)
	GetAll() ([]links.Link, error)
}

// DatabaseTopologyStore is a database store for the topology
type DatabaseTopologyStore struct {
	storeName string
}

// NewDatabaseTopologyStore returns a TopologyStore
func NewDatabaseTopologyStore() Store {
	return &DatabaseTopologyStore{
		storeName: fmt.Sprintf("topology-store.json"),
	}
}

// Get takes a link's UUID or name and returns the link.
func (s *DatabaseTopologyStore) Get(query store.Query) (links.Link, error) {
	var loadedTopology links.Link

	if query.ID.String() != "" {
		loadedDevice, err := s.getByID(query.ID)
		if err != nil {
			return loadedDevice, errors.ErrCouldNotFind{StoreName: s.storeName}
		}

		return loadedDevice, nil
	}

	loadedTopology, err := s.getByName(query.Name)
	if err != nil {
		return loadedTopology, errors.ErrCouldNotFind{StoreName: s.storeName}
	}

	return loadedTopology, nil
}

func (s *DatabaseTopologyStore) getByID(idOfLink uuid.UUID) (links.Link, error) {
	var loadedTopology links.Link

	client, ctx, cancel := database.GetMongoConnection()
	defer cancel()
	defer client.Disconnect(ctx)

	db := client.Database(database.DatabaseName)
	collection := db.Collection(s.storeName)
	result := collection.FindOne(ctx, bson.D{primitive.E{Key: "_id", Value: idOfLink.String()}})
	if result == nil {
		return loadedTopology, errors.ErrCouldNotFind{StoreName: s.storeName}
	}

	err := result.Decode(&loadedTopology)
	if err != nil {
		log.Printf("Failed marshalling %v", err)
		return loadedTopology, errors.ErrCouldNotFind{StoreName: s.storeName}
	}

	return loadedTopology, nil
}

func (s *DatabaseTopologyStore) getByName(nameOfDevice string) (links.Link, error) {
	var loadedTopology links.Link

	client, ctx, cancel := database.GetMongoConnection()
	defer cancel()
	defer client.Disconnect(ctx)

	db := client.Database(database.DatabaseName)
	collection := db.Collection(s.storeName)
	result := collection.FindOne(ctx, bson.D{primitive.E{Key: "name", Value: nameOfDevice}})
	if result == nil {
		return loadedTopology, errors.ErrCouldNotFind{StoreName: s.storeName}
	}

	err := result.Decode(&loadedTopology)
	if err != nil {
		log.Printf("Failed marshalling %v", err)
		return loadedTopology, errors.ErrCouldNotFind{StoreName: s.storeName}
	}

	return loadedTopology, nil
}

// GetAll returns all stored links.
func (s *DatabaseTopologyStore) GetAll() ([]links.Link, error) {
	var loadedTopology []links.Link

	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 loadedTopology, err
	}
	defer cursor.Close(ctx)

	err = cursor.All(ctx, &loadedTopology)
	if err != nil {
		log.Printf("Failed marshalling %v", err)

		return loadedTopology, errors.ErrCouldNotMarshall{StoreName: s.storeName}
	}

	return loadedTopology, nil
}

// AddLink adds a link to the link store.
func (s *DatabaseTopologyStore) AddLink(link links.Link) error {
	client, ctx, cancel := database.GetMongoConnection()
	defer cancel()
	defer client.Disconnect(ctx)

	_, err := client.Database(database.DatabaseName).
		Collection(s.storeName).
		InsertOne(ctx, link)
	if err != nil {
		log.Printf("Could not add Link: %v", err)
		return errors.ErrCouldNotCreate{StoreName: s.storeName}
	}

	return nil
}

// UpdateLink updates a existing link.
func (s *DatabaseTopologyStore) UpdateLink(linkToUpdate links.Link) error {
	var updatedLink links.Link

	client, ctx, cancel := database.GetMongoConnection()
	defer cancel()
	defer client.Disconnect(ctx)

	update := bson.D{primitive.E{Key: "$set", Value: linkToUpdate}}

	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": linkToUpdate.ID.String()}, update, &opt).
		Decode(&updatedLink)
	if err != nil {
		log.Printf("Could not update link: %v", err)

		return errors.ErrCouldNotUpdate{StoreName: s.storeName}
	}

	return nil
}

// DeleteLink deletes a link from the link store.
func (s *DatabaseTopologyStore) DeleteLink(linkToDelete links.Link) 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: linkToDelete.ID.String()}})
	if err != nil {
		return err
	}

	return nil
}