sbiFilesystemStore.go

package nucleus

import (
	"encoding/json"
	"io/ioutil"
	"sync"

	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/southbound"
	"code.fbi.h-da.de/danet/gosdn/controller/nucleus/errors"
	"code.fbi.h-da.de/danet/gosdn/controller/store"

	"github.com/google/uuid"
)

// FilesystemSbiStore is used to store SouthboundInterfaces
type FilesystemSbiStore struct {
	sbiStoreName  string
	pndUUID       uuid.UUID
	fileMutex     sync.Mutex
	pathToSbiFile string
}

// NewFilesystemSbiStore returns a filesystem implementation for a pnd store.
func NewFilesystemSbiStore(pndUUID uuid.UUID) southbound.Store {
	sbiFilenameForUUID := store.GetStoreFilenameForUUID(pndUUID, store.SbiFilenameSuffix)

	store.EnsureFilesystemStorePathExists(sbiFilenameForUUID)
	return &FilesystemSbiStore{
		pathToSbiFile: store.GetCompletePathToFileStore(sbiFilenameForUUID),
		fileMutex:     sync.Mutex{},
		pndUUID:       pndUUID,
	}
}

func (s *FilesystemSbiStore) readAllSbisFromFile() ([]southbound.LoadedSbi, error) {
	var loadedSbis []southbound.LoadedSbi

	content, err := ioutil.ReadFile(s.pathToSbiFile)
	if err != nil {
		return nil, err
	}

	err = json.Unmarshal(content, &loadedSbis)
	if err != nil {
		return nil, err
	}
	return loadedSbis, nil
}

func (s *FilesystemSbiStore) writeAllSbisToFile(sbis []southbound.LoadedSbi) error {
	serializedData, err := json.Marshal(sbis)
	if err != nil {
		return err
	}

	err = ioutil.WriteFile(s.pathToSbiFile, serializedData, 0600)
	if err != nil {
		return err
	}
	return nil
}

// Add adds a SBI.
func (s *FilesystemSbiStore) Add(sbiToAdd southbound.SouthboundInterface) error {
	s.fileMutex.Lock()
	defer s.fileMutex.Unlock()

	sbis, err := s.readAllSbisFromFile()
	if err != nil {
		return err
	}

	var loadedSbi southbound.LoadedSbi
	loadedSbi, err = store.TransformObjectToLoadedObject[southbound.SouthboundInterface, southbound.LoadedSbi](sbiToAdd)
	if err != nil {
		return err
	}

	sbis = append(sbis, loadedSbi)

	err = s.writeAllSbisToFile(sbis)
	if err != nil {
		return err
	}

	return nil
}

// Delete deletes an SBI.
func (s *FilesystemSbiStore) Delete(sbiToDelete southbound.SouthboundInterface) error {
	s.fileMutex.Lock()
	defer s.fileMutex.Unlock()

	sbis, err := s.readAllSbisFromFile()
	if err != nil {
		return err
	}

	for i, sbi := range sbis {
		if sbi.ID == sbiToDelete.ID().String() {
			//remove item from slice
			sbis[i] = sbis[len(sbis)-1]
			sbis = sbis[:len(sbis)-1]

			err = s.writeAllSbisToFile(sbis)
			if err != nil {
				return err
			}

			return nil
		}
	}
	return &errors.ErrCouldNotDelete{Identifier: sbiToDelete.ID(), Type: sbiToDelete, Err: err}
}

// 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 *FilesystemSbiStore) Get(query store.Query) (southbound.LoadedSbi, error) {
	s.fileMutex.Lock()
	defer s.fileMutex.Unlock()

	var sbi southbound.LoadedSbi

	sbis, err := s.readAllSbisFromFile()
	if err != nil {
		return sbi, err
	}

	for _, sbi := range sbis {
		if sbi.ID == query.ID.String() {
			return sbi, nil
		}
	}

	return sbi, &errors.ErrCouldNotFind{ID: query.ID, Name: query.Name}
}

// GetAll returns all SBIs
func (s *FilesystemSbiStore) GetAll() ([]southbound.LoadedSbi, error) {
	s.fileMutex.Lock()
	defer s.fileMutex.Unlock()

	sbis, err := s.readAllSbisFromFile()

	return sbis, err
}