databaseSbiStore.go

package nucleus

import (
	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/southbound"
	"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"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"

	log "github.com/sirupsen/logrus"
)

// DatabaseSbiStore is used to store SouthboundInterfaces
type DatabaseSbiStore struct {
	sbiStoreName string
}

// Add adds a SBI.
func (s *DatabaseSbiStore) Add(sbiToAdd southbound.SouthboundInterface) error {
	client, ctx, cancel := database.GetMongoConnection()
	defer cancel()
	defer client.Disconnect(ctx)

	_, err := client.Database(database.DatabaseName).
		Collection(s.sbiStoreName).
		InsertOne(ctx, sbiToAdd)
	if err != nil {
		if mongo.IsDuplicateKeyError(err) {
			return nil
		}

		return errors.ErrCouldNotCreate{Identifier: sbiToAdd.ID(), Type: sbiToAdd, Err: err}
	}

	return nil
}

// Delete deletes an SBI.
func (s *DatabaseSbiStore) Delete(sbiToDelete southbound.SouthboundInterface) error {
	client, ctx, cancel := database.GetMongoConnection()
	defer cancel()
	defer client.Disconnect(ctx)

	_, err := client.Database(database.DatabaseName).
		Collection(s.sbiStoreName).
		DeleteOne(ctx, bson.D{primitive.E{Key: "_id", Value: sbiToDelete.ID().String()}})
	if err != nil {
		return errors.ErrCouldNotDelete{Identifier: sbiToDelete.ID(), Type: sbiToDelete, Err: err}
	}

	return nil
}

// Get takes a SouthboundInterface's UUID or name and returns the SouthboundInterface. If the requested
// SouthboundInterface does not exist an error is returned.
func (s *DatabaseSbiStore) Get(query store.Query) (southbound.LoadedSbi, error) {
	var loadedSbi southbound.LoadedSbi

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

	log.Debugf("SBI-Search-ID: %+v\n", query.ID.String())

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

	err := result.Decode(&loadedSbi)
	if err != nil {
		log.Printf("Failed marshalling %v", err)

		return loadedSbi, errors.ErrCouldNotMarshall{Identifier: query.ID, Type: loadedSbi, Err: err}
	}

	return loadedSbi, nil
}

// GetAll returns all SBIs
func (s *DatabaseSbiStore) GetAll() ([]southbound.LoadedSbi, error) {
	var loadedSbis []southbound.LoadedSbi

	client, ctx, cancel := database.GetMongoConnection()
	defer cancel()
	defer client.Disconnect(ctx)
	db := client.Database(database.DatabaseName)
	collection := db.Collection(s.sbiStoreName)

	cursor, err := collection.Find(ctx, bson.D{})
	if err != nil {
		return nil, err
	}
	defer cursor.Close(ctx)

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

		return nil, errors.ErrCouldNotMarshall{Type: loadedSbis, Err: err}
	}

	return loadedSbis, nil
}