networkElement.go

package server

import (
	"context"
	"time"

	mnepb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/networkelement"
	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/networkdomain"
	"github.com/google/uuid"
	log "github.com/sirupsen/logrus"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// NetworkElementServer represents a NetworkElementServer.
type NetworkElementServer struct {
	mnepb.UnimplementedNetworkElementServiceServer
	networkDomain networkdomain.NetworkDomain
}

// NewNetworkElementServer returns a new NetWorkElementServer.
func NewNetworkElementServer(networkDomain networkdomain.NetworkDomain) *NetworkElementServer {
	return &NetworkElementServer{
		networkDomain: networkDomain,
	}
}

// Add adds a new network element.
func (s *NetworkElementServer) Add(ctx context.Context, request *mnepb.AddNetworkElementRequest) (*mnepb.AddNetworkElementResponse, error) {
	sbiID, err := uuid.Parse(request.NetworkElement.Sbi.Id)
	if err != nil {
		return nil, status.Errorf(codes.Aborted, "%v", err)
	}

	id, err := s.networkDomain.AddNetworkElement(
		request.NetworkElement.NetworkElementName,
		request.NetworkElement.TransportOption,
		nil,
		sbiID,
		uuid.Nil,
	)
	if err != nil {
		return nil, status.Errorf(codes.Aborted, "%v", err)
	}

	return &mnepb.AddNetworkElementResponse{
		Timestamp:        time.Now().UnixNano(),
		Status:           mnepb.Status_STATUS_OK,
		NetworkElementId: id.String(),
	}, nil
}

// GetAll returns all stored network elements.
func (s *NetworkElementServer) GetAll(ctx context.Context, request *mnepb.GetAllNetworkElementRequest) (*mnepb.GetAllNetworkElementResponse, error) {
	networkElements := s.networkDomain.NetworkElements()

	mnes := []*mnepb.NetworkElement{}
	for _, mne := range networkElements {
		ygotStructAsJSON, err := mne.GetModelAsString()
		if err != nil {
			log.Error(err)
			return nil, status.Errorf(codes.Aborted, "%v", err)
		}

		mnes = append(mnes, &mnepb.NetworkElement{
			Id:    mne.ID().String(),
			Name:  mne.Name(),
			Model: ygotStructAsJSON,
		})
	}

	return &mnepb.GetAllNetworkElementResponse{
		Timestamp:      time.Now().UnixNano(),
		Status:         mnepb.Status_STATUS_OK,
		NetworkElement: mnes,
	}, nil
}

// Get returns a network element.
func (s *NetworkElementServer) Get(ctx context.Context, request *mnepb.GetNetworkElementRequest) (*mnepb.GetNetworkElementResponse, error) {
	mne, err := s.networkDomain.GetNetworkElement(request.NetworkElementId)
	if err != nil {
		return nil, status.Errorf(codes.Aborted, "%v", err)
	}

	ygotStructAsJSON, err := mne.GetModelAsString()
	if err != nil {
		log.Error(err)
		return nil, status.Errorf(codes.Aborted, "%v", err)
	}

	networkElement := &mnepb.NetworkElement{
		Id:               mne.ID().String(),
		Name:             mne.Name(),
		Model:            ygotStructAsJSON,
		TransportAddress: mne.TransportAddress(),
	}

	return &mnepb.GetNetworkElementResponse{
		Timestamp:      time.Now().UnixNano(),
		Status:         mnepb.Status_STATUS_OK,
		NetworkElement: networkElement,
	}, nil
}

// Update updates a network element.
func (s *NetworkElementServer) Update(ctx context.Context, request *mnepb.UpdateNetworkElementRequest) (*mnepb.UpdateNetworkElementResponse, error) {
	mneID, err := uuid.Parse(request.NetworkElement.Id)
	if err != nil {
		return &mnepb.UpdateNetworkElementResponse{
			Timestamp: time.Now().UnixNano(),
			Status:    mnepb.Status_STATUS_OK,
		}, err
	}

	err = s.networkDomain.UpdateNetworkElement(mneID, request.NetworkElement.Model)
	if err != nil {
		return &mnepb.UpdateNetworkElementResponse{
			Timestamp: time.Now().UnixNano(),
			Status:    mnepb.Status_STATUS_OK,
		}, err
	}

	return &mnepb.UpdateNetworkElementResponse{
		Timestamp: time.Now().UnixNano(),
		Status:    mnepb.Status_STATUS_OK,
	}, nil
}