controller.go

package gosdn

import (
	"context"
	"net/http"
	"os"
	"os/signal"
	"sync"
	"time"

	"code.fbi.h-da.de/cocsn/gosdn/nucleus/types"

	"code.fbi.h-da.de/cocsn/gosdn/database"
	"code.fbi.h-da.de/cocsn/gosdn/nucleus"
	"github.com/google/uuid"
	log "github.com/sirupsen/logrus"
)

var coreLock sync.RWMutex
var coreOnce sync.Once

// Core is the representation of the controllers core
type Core struct {
	// deprecated
	database database.Database

	pndc       *nucleus.PndStore
	sbic       *nucleus.SbiStore
	httpServer *http.Server
	stopChan   chan os.Signal
}

var c *Core

func init() {
	c = &Core{
		database: database.Database{},
		pndc:     nucleus.NewPndStore(),
		sbic:     nucleus.NewSbiStore(),
		stopChan: make(chan os.Signal, 1),
	}

	// Setting up signal capturing
	signal.Notify(c.stopChan, os.Interrupt)
}

// initialize does start-up housekeeping like reading controller config files
func initialize() error {
	if err := createSouthboundInterfaces(); err != nil {
		return err
	}

	// TODO: Start grpc listener here
	coreLock.Lock()
	defer coreLock.Unlock()
	startHttpServer()
	return nil
}

// createSouthboundInterfaces initializes the controller with its supported SBIs
func createSouthboundInterfaces() error {
	sbi := nucleus.NewSBI(types.Openconfig)
	if err := c.sbic.Add(sbi); err != nil {
		return err
	}
	return createPrincipalNetworkDomain(sbi)
}

// createPrincipalNetworkDomain initializes the controller with an initial PND
func createPrincipalNetworkDomain(s nucleus.SouthboundInterface) error {
	pnd, err := nucleus.NewPND("base", "gosdn base pnd", uuid.New(), s)
	if err != nil {
		return err
	}
	err = c.pndc.Add(pnd)
	if err != nil {
		return err
	}
	return nil
}

// Run calls initialize to start the controller
func Run(ctx context.Context) error {
	var initError error
	coreOnce.Do(func() {
		initError = initialize()
	})
	if initError != nil {
		log.WithFields(log.Fields{}).Error(initError)
		return initError
	}
	log.WithFields(log.Fields{}).Info("initialisation finished")
	for {
		select {
		case <-c.stopChan:
			return shutdown()
		case <-ctx.Done():
			return shutdown()
		case <-time.Tick(time.Minute):
			log.Debug("up and running")
		}
	}
}

func shutdown() error {
	log.Info("shutting down controller")
	coreLock.Lock()
	defer coreLock.Unlock()
	return stopHttpServer()
}