pnd.go

package server

import (
	"context"
	"time"

	ppb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/pnd"
	spb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/southbound"
	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/networkdomain"
	"code.fbi.h-da.de/danet/gosdn/controller/metrics"
	"code.fbi.h-da.de/danet/gosdn/controller/nucleus"
	"code.fbi.h-da.de/danet/gosdn/controller/store"
	"github.com/google/uuid"
	"github.com/prometheus/client_golang/prometheus"
	log "github.com/sirupsen/logrus"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// PndServer implements a pnd server.
type PndServer struct {
	ppb.UnimplementedPndServiceServer
	pndService networkdomain.Service
}

// NewPndServer receives a pndStore and returns a new pndServer.
func NewPndServer(pndService networkdomain.Service) *PndServer {
	return &PndServer{
		pndService: pndService,
	}
}

// GetSbi gets a specific sbi.
func (p PndServer) GetSbi(ctx context.Context, request *ppb.GetSbiRequest) (*ppb.GetSbiResponse, error) {
	labels := prometheus.Labels{"service": "pnd", "rpc": "get"}
	start := metrics.StartHook(labels, grpcRequestsTotal)
	defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
	pid, err := uuid.Parse(request.Pid)
	if err != nil {
		return nil, handleRPCError(labels, err)
	}

	pnd, err := p.pndService.Get(store.Query{ID: pid})
	if err != nil {
		log.Error(err)
		return nil, status.Errorf(codes.Aborted, "%v", err)
	}

	sbiID, err := uuid.Parse(request.Sid)
	if err != nil {
		return nil, err
	}

	sbi, err := pnd.GetSBI(sbiID)
	if err != nil {
		log.Error(err)
		return nil, status.Errorf(codes.Aborted, "%v", err)
	}
	return &ppb.GetSbiResponse{
		Timestamp: time.Now().UnixNano(),
		Pnd: &ppb.PrincipalNetworkDomain{
			Id:          pnd.ID().String(),
			Name:        pnd.GetName(),
			Description: pnd.GetDescription(),
		},
		Sbi: &spb.SouthboundInterface{
			Id:   sbiID.String(),
			Type: sbi.Type(),
		},
	}, nil
}

// GetSbiList gets all existing sbis.
func (p PndServer) GetSbiList(ctx context.Context, request *ppb.GetSbiListRequest) (*ppb.GetSbiListResponse, error) {
	labels := prometheus.Labels{"service": "pnd", "rpc": "get"}
	start := metrics.StartHook(labels, grpcRequestsTotal)
	defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
	pid, err := uuid.Parse(request.Pid)
	if err != nil {
		return nil, handleRPCError(labels, err)
	}

	pnd, err := p.pndService.Get(store.Query{ID: pid})
	if err != nil {
		log.Error(err)
		return nil, status.Errorf(codes.Aborted, "%v", err)
	}
	sbis, err := fillSbis(pnd)
	if err != nil {
		log.Error(err)
		return nil, status.Errorf(codes.Aborted, "%v", err)
	}
	return &ppb.GetSbiListResponse{
		Timestamp: time.Now().UnixNano(),
		Pnd: &ppb.PrincipalNetworkDomain{
			Id:          pnd.ID().String(),
			Name:        pnd.GetName(),
			Description: pnd.GetDescription(),
		},
		Sbi: sbis,
	}, nil
}

func fillSbis(pnd networkdomain.NetworkDomain) ([]*spb.SouthboundInterface, error) {
	sbis, err := pnd.GetSBIs()
	if err != nil {
		return nil, err
	}

	sbisToReturn := []*spb.SouthboundInterface{}

	for _, sbi := range sbis {
		sbisToReturn = append(sbisToReturn, &spb.SouthboundInterface{
			Id: sbi.ID().String(),
		})
	}

	return sbisToReturn, nil
}

// SetSbiList sets a list of sbis.
func (p PndServer) SetSbiList(ctx context.Context, request *ppb.SetSbiListRequest) (*ppb.SetSbiListResponse, error) {
	labels := prometheus.Labels{"service": "pnd", "rpc": "set"}
	start := metrics.StartHook(labels, grpcRequestsTotal)
	defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
	pid, err := uuid.Parse(request.Pid)
	if err != nil {
		return nil, handleRPCError(labels, err)
	}

	pnd, err := p.pndService.Get(store.Query{ID: pid})
	if err != nil {
		return nil, handleRPCError(labels, err)
	}

	for _, r := range request.Sbi {
		sbiType := filterSbiType(r.SbiType)
		sbi, err := nucleus.NewSBI(sbiType)
		if err != nil {
			return nil, handleRPCError(labels, err)
		}

		err = pnd.AddSbi(sbi)
		if err != nil {
			return nil, handleRPCError(labels, err)
		}
	}

	return &ppb.SetSbiListResponse{
		Timestamp: time.Now().UnixNano(),
		Status:    ppb.Status_STATUS_OK,
		Responses: []*ppb.SetResponse{
			{
				Status: ppb.Status_STATUS_OK,
			},
		},
	}, nil
}

func filterSbiType(sbiType ppb.SbiType) spb.Type {
	var spbType spb.Type

	switch sbiType {
	case ppb.SbiType_SBI_TYPE_OPENCONFIG:
		spbType = spb.Type_TYPE_OPENCONFIG
	case ppb.SbiType_SBI_TYPE_CONTAINERISED:
		spbType = spb.Type_TYPE_CONTAINERISED
	case ppb.SbiType_SBI_TYPE_PLUGIN:
		spbType = spb.Type_TYPE_PLUGIN
	default:
		spbType = spb.Type_TYPE_UNSPECIFIED
	}

	return spbType
}