memoryDeviceStore.go

package nucleus

import (
	"encoding/json"

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

// MemoryDeviceStore provides a in-memory implementation for devices.
type MemoryDeviceStore struct {
	Store           map[string]device.LoadedDevice
	nameLookupTable map[string]string
}

// NewMemoryDeviceStore returns a specific in-memory store for devices.
func NewMemoryDeviceStore() device.Store {
	return &MemoryDeviceStore{
		Store:           make(map[string]device.LoadedDevice),
		nameLookupTable: make(map[string]string),
	}
}

// Add adds a item to the store.
func (t *MemoryDeviceStore) Add(item device.Device) error {
	var device device.LoadedDevice

	b, err := json.Marshal(item)
	if err != nil {
		return err
	}
	err = json.Unmarshal(b, &device)
	if err != nil {
		return err
	}

	_, ok := t.Store[device.DeviceID]
	if ok {
		return nil
	}

	t.Store[device.DeviceID] = device
	t.nameLookupTable[item.Name()] = device.DeviceID

	return nil
}

// Update updates a existing device.
func (t *MemoryDeviceStore) Update(item device.Device) error {
	_, ok := t.Store[item.ID().String()]
	if !ok {
		return errors.ErrCouldNotFind{StoreName: deviceStoreName}
	}

	var device device.LoadedDevice

	b, err := json.Marshal(item)
	if err != nil {
		return err
	}
	err = json.Unmarshal(b, &device)
	if err != nil {
		return err
	}

	t.Store[item.ID().String()] = device
	t.nameLookupTable[item.Name()] = item.ID().String()

	return nil
}

// Delete deletes a device from the device store.
func (t *MemoryDeviceStore) Delete(item device.Device) error {
	delete(t.Store, item.ID().String())

	return nil
}

// Get takes a Device's UUID or name and returns the Device.
func (t *MemoryDeviceStore) Get(query store.Query) (device.LoadedDevice, error) {
	// First search for direct hit on UUID.
	item, ok := t.Store[query.ID.String()]
	if !ok {
		// Second search for name
		id, ok := t.nameLookupTable[query.Name]
		if !ok {
			return item, errors.ErrCouldNotFind{StoreName: deviceStoreName}
		}

		item, ok := t.Store[id]
		if !ok {
			return item, errors.ErrCouldNotFind{StoreName: deviceStoreName}
		}

		return item, nil
	}

	return item, nil
}

// GetAll returns all stored devices.
func (t *MemoryDeviceStore) GetAll() ([]device.LoadedDevice, error) {
	var allItems []device.LoadedDevice

	for _, item := range t.Store {
		allItems = append(allItems, item)
	}

	return allItems, nil
}