principalNetworkDomain.go

package nucleus

import (
	"context"

	"encoding/json"
	"github.com/google/uuid"
)

// PrincipalNetworkDomain provides an
// interface for PND implementations
type PrincipalNetworkDomain interface {
	Destroy() error
	AddSbi(interface{}) error
	RemoveSbi(uuid.UUID) error
	AddDevice(interface{}) error
	RemoveDevice(uuid.UUID) error
	Request(uuid.UUID, string) error
	RequestAll(string) error
	GetName() string
	GetDescription() string
	MarshalDevice(uuid.UUID) (string, error)
	ContainsDevice(uuid.UUID) bool
	GetSBIs() interface{}
	Id() uuid.UUID
}

type pndImplementation struct {
	name        string
	description string
	sbic        sbiStore
	devices     deviceStore
	id          uuid.UUID
}

// NewPND creates a Principle Network Domain
func NewPND(name, description string, sbi SouthboundInterface) (PrincipalNetworkDomain, error) {
	pnd := &pndImplementation{
		name:        name,
		description: description,
		sbic:        sbiStore{store{}},
		devices:     deviceStore{store{}},
	}
	if err := pnd.sbic.add(sbi); err != nil {
		return nil, &ErrAlreadyExists{item: sbi}
	}
	return pnd, nil
}

func NewPNDwithId(name, description string, id uuid.UUID, sbi SouthboundInterface) (PrincipalNetworkDomain, error) {
	pnd := &pndImplementation{
		name:        name,
		description: description,
		sbic:        sbiStore{store{}},
		devices:     deviceStore{store{}},
		id:          id,
	}
	if err := pnd.sbic.add(sbi); err != nil {
		return nil, &ErrAlreadyExists{item: sbi}
	}
	return pnd, nil
}

func (pnd *pndImplementation) Id() uuid.UUID {
	return pnd.id
}

// GetName returns the name of the PND
func (pnd *pndImplementation) GetName() string {
	return pnd.name
}

// ContainsDevice checks if the given device uuid is registered for this PND
func (pnd *pndImplementation) ContainsDevice(id uuid.UUID) bool {
	return pnd.devices.exists(id)
}

// GetDescription returns the current description of the PND
func (pnd *pndImplementation) GetDescription() string {
	return pnd.description
}

// GetSBIs returns the registered SBIs
func (pnd *pndImplementation) GetSBIs() interface{} {
	return &pnd.sbic
}

// Destroy destroys the PND
func (pnd *pndImplementation) Destroy() error {
	return destroy()
}

// AddSbi adds a SBI to the PND which will be supported
func (pnd *pndImplementation) AddSbi(sbi interface{}) error {
	s, ok := sbi.(SouthboundInterface)
	if !ok {
		return &ErrInvalidTypeAssertion{
			v: sbi,
			t: "Device",
		}
	}
	return pnd.addSbi(s)
}

// AddSbi removes a SBI from the PND
// TODO: this should to recursivly through
// devices and remove the devices using
// this SBI
func (pnd *pndImplementation) RemoveSbi(id uuid.UUID) error {
	return pnd.removeSbi(id)
}

//AddDevice adds a new device to the PND
func (pnd *pndImplementation) AddDevice(device interface{}) error {
	d, ok := device.(*Device)
	if !ok {
		return &ErrInvalidTypeAssertion{
			v: device,
			t: "Device",
		}
	}
	return pnd.addDevice(d)
}

// RemoveDevice removes a device from the PND
func (pnd *pndImplementation) RemoveDevice(uuid uuid.UUID) error {
	return pnd.removeDevice(uuid)
}

// Actual implementation, bind to struct if
// neccessary
func destroy() error {
	return nil
}

func (pnd *pndImplementation) addSbi(sbi SouthboundInterface) error {
	return pnd.sbic.add(sbi)
}

func (pnd *pndImplementation) removeSbi(id uuid.UUID) error {
	return pnd.sbic.delete(id)
}

func (pnd *pndImplementation) addDevice(device *Device) error {
	return pnd.devices.add(device)
}

func (pnd *pndImplementation) getDevice(id uuid.UUID) (*Device, error) {
	return pnd.devices.get(id)
}

func (pnd *pndImplementation) removeDevice(id uuid.UUID) error {
	return pnd.devices.delete(id)
}

func (pnd *pndImplementation) MarshalDevice(uuid uuid.UUID) (string, error) {
	d, err := pnd.getDevice(uuid)
	if err != nil {
		return "", err
	}
	jsonTree, err := json.MarshalIndent(d.GoStruct, "", "\t")
	if err != nil {
		return "", err
	}

	return string(jsonTree), nil
}

//Request sends a request for a specific device
func (pnd *pndImplementation) Request(uuid uuid.UUID, path string) error {
	d, err := pnd.getDevice(uuid)
	if err != nil {
		return err
	}
	ctx := context.Background()
	res, err := d.Transport.Get(ctx, path)
	if err != nil {
		return err
	}
	err = d.Transport.ProcessResponse(res, d.GoStruct, d.SBI.Schema())
	if err != nil {
		return err
	}
	return nil
}

//RequestAll sends a request for all registered devices
func (pnd *pndImplementation) RequestAll(path string) error {
	for _, k := range pnd.devices.UUIDs() {
		if err := pnd.Request(k, path); err != nil {
			return err
		}
	}
	return nil
}