Skip to content
Snippets Groups Projects
pnd.go 13.6 KiB
Newer Older
  • Learn to ignore specific revisions
  • Manuel Kieweg's avatar
    Manuel Kieweg committed
    package server
    
    import (
    	"context"
    	"time"
    
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	ppb "code.fbi.h-da.de/danet/api/go/gosdn/pnd"
    	spb "code.fbi.h-da.de/danet/api/go/gosdn/southbound"
    	"code.fbi.h-da.de/danet/gosdn/interfaces/networkdomain"
    
    Malte Bauch's avatar
    Malte Bauch committed
    	"code.fbi.h-da.de/danet/gosdn/metrics"
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	"code.fbi.h-da.de/danet/gosdn/nucleus/errors"
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	"github.com/google/uuid"
    	"github.com/openconfig/ygot/ygot"
    
    Malte Bauch's avatar
    Malte Bauch committed
    	"github.com/prometheus/client_golang/prometheus"
    
    	log "github.com/sirupsen/logrus"
    
    	"google.golang.org/grpc/codes"
    	"google.golang.org/grpc/status"
    
    type pndServer struct {
    
    func (p pndServer) GetOnd(ctx context.Context, request *ppb.GetOndRequest) (*ppb.GetOndResponse, error) {
    
    Malte Bauch's avatar
    Malte Bauch committed
    	labels := prometheus.Labels{"service": "pnd", "rpc": "get"}
    	start := metrics.StartHook(labels, grpcRequestsTotal)
    	defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	pid, err := uuid.Parse(request.Pid)
    	if err != nil {
    
    Malte Bauch's avatar
    Malte Bauch committed
    		return nil, handleRPCError(labels, err)
    
    	pnd, err := pndc.GetPND(pid)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	if err != nil {
    
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	}
    
    	onds, err := fillOnds(pnd, false, request.Did...)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	if err != nil {
    
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	}
    
    	return &ppb.GetOndResponse{
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		Timestamp: time.Now().UnixNano(),
    
    		Ond:       onds,
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	}, nil
    }
    
    
    func (p pndServer) GetOndList(ctx context.Context, request *ppb.GetOndListRequest) (*ppb.GetOndListResponse, 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 := pndc.GetPND(pid)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	if err != nil {
    
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	}
    
    	onds, err := fillOnds(pnd, true, "")
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	if err != nil {
    
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	}
    
    	return &ppb.GetOndListResponse{
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		Timestamp: time.Now().UnixNano(),
    
    		Ond:       onds,
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	}, nil
    }
    
    
    func fillOnds(pnd networkdomain.NetworkDomain, all bool, did ...string) ([]*ppb.OrchestratedNetworkingDevice, error) {
    	var ondList []uuid.UUID
    	var onds []*ppb.OrchestratedNetworkingDevice
    
    	// all indicates if a client wants all devices or only a single one
    	switch all {
    	case true:
    		ondList = pnd.Devices()
    		onds = make([]*ppb.OrchestratedNetworkingDevice, len(ondList))
    		for _, id := range ondList {
    			did = append(did, id.String())
    		}
    	default:
    		if len(did) == 0 {
    			err := &errors.ErrInvalidParameters{
    				Func:  fillOnds,
    				Param: "length of 'did' cannot be '0' when 'all' is set to 'false'",
    			}
    			log.Error(err)
    
    			return nil, err
    		}
    
    		onds = make([]*ppb.OrchestratedNetworkingDevice, 1)
    	}
    
    	for i, id := range did {
    		d, err := pnd.GetDevice(id)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		if err != nil {
    
    			log.Error(err)
    			return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		}
    
    		cfg := ygot.GNMINotificationsConfig{}
    		dev, err := ygot.TogNMINotifications(d.Model(), time.Now().UnixNano(), cfg)
    		if err != nil {
    			log.Error(err)
    			return nil, status.Errorf(codes.Aborted, "%v", err)
    		}
    		onds[i] = &ppb.OrchestratedNetworkingDevice{
    			Id:     id,
    			Name:   d.Name(),
    			Device: dev,
    		}
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	}
    
    
    	return onds, nil
    
    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)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	if err != nil {
    
    		return nil, handleRPCError(labels, err)
    
    	pnd, err := pndc.GetPND(pid)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	if err != nil {
    
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	}
    
    	sbis, err := fillSbis(pnd, false, request.Sid...)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	if err != nil {
    
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	}
    
    	return &ppb.GetSbiResponse{
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		Timestamp: time.Now().UnixNano(),
    
    		Sbi:       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 := pndc.GetPND(pid)
    
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    
    	sbis, err := fillSbis(pnd, true, "")
    
    	if err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    
    	return &ppb.GetSbiListResponse{
    
    		Timestamp: time.Now().UnixNano(),
    
    		Sbi:       sbis,
    
    	}, nil
    
    func fillSbis(pnd networkdomain.NetworkDomain, all bool, sid ...string) ([]*spb.SouthboundInterface, error) {
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	var sbiList []uuid.UUID
    
    
    	sbiStore := pnd.GetSBIs()
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	switch all {
    	case true:
    		sbiList = sbiStore.UUIDs()
    	default:
    		var err error
    		if len(sid) == 0 {
    			return nil, &errors.ErrInvalidParameters{
    				Func:  fillSbis,
    				Param: "length of 'sid' cannot be '0' when 'all' is set to 'false'",
    			}
    		}
    		sbiList, err = stringToUUID(sid)
    		if err != nil {
    
    			log.Error(err)
    			return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		}
    	}
    	sbis := make([]*spb.SouthboundInterface, len(sbiList))
    	for i, id := range sbiList {
    
    		_, err := sbiStore.Get(id)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		if err != nil {
    
    			log.Error(err)
    			return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		}
    		sbis[i] = &spb.SouthboundInterface{
    
    			Id: id.String(),
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		}
    	}
    	return sbis, nil
    }
    
    
    func stringToUUID(sid []string) ([]uuid.UUID, error) {
    	UUIDs := make([]uuid.UUID, len(sid))
    	for i, id := range sid {
    		parsed, err := uuid.Parse(id)
    		if err != nil {
    
    			log.Error(err)
    
    			return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		}
    
    		UUIDs[i] = parsed
    	}
    	return UUIDs, nil
    }
    
    func (p pndServer) GetPath(ctx context.Context, request *ppb.GetPathRequest) (*ppb.GetPathResponse, 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 := pndc.GetPND(pid)
    	if err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    	duid, err := uuid.Parse(request.Did)
    	if err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	}
    
    	_, err = pnd.Request(duid, request.Path)
    	if err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    	ond, err := fillOnds(pnd, false, request.Did)
    	if err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    	return &ppb.GetPathResponse{
    		Timestamp: time.Now().UnixNano(),
    		Device:    ond[0].Device,
    	}, nil
    
    }
    
    func (p pndServer) GetChange(ctx context.Context, request *ppb.GetChangeRequest) (*ppb.GetChangeResponse, 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 := pndc.GetPND(pid)
    	if err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    	changes, err := fillChanges(pnd, false, request.Cuid)
    	if err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    	return &ppb.GetChangeResponse{
    		Timestamp: time.Now().UnixNano(),
    		Change:    changes,
    	}, nil
    }
    
    func (p pndServer) GetChangeList(ctx context.Context, request *ppb.GetChangeListRequest) (*ppb.GetChangeListResponse, 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 := pndc.GetPND(pid)
    	if err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    	changes, err := fillChanges(pnd, true, "")
    	if err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    	return &ppb.GetChangeListResponse{
    		Timestamp: time.Now().UnixNano(),
    		Change:    changes,
    	}, nil
    
    func fillChanges(pnd networkdomain.NetworkDomain, all bool, cuid ...string) ([]*ppb.Change, error) {
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	var changeList []uuid.UUID
    
    	switch all {
    	case true:
    		changeList = pnd.PendingChanges()
    		changeList = append(changeList, pnd.CommittedChanges()...)
    	default:
    		var err error
    		if len(cuid) == 0 {
    			return nil, &errors.ErrInvalidParameters{
    				Func:  fillOnds,
    				Param: "length of 'did' cannot be '0' when 'all' is set to 'false'",
    			}
    		}
    		changeList, err = stringToUUID(cuid)
    		if err != nil {
    
    			log.Error(err)
    			return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		}
    	}
    
    	changes := make([]*ppb.Change, len(changeList))
    	for i, ch := range changeList {
    		c, err := pnd.GetChange(ch)
    		if err != nil {
    
    			log.Error(err)
    			return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		}
    
    		changes[i] = &ppb.Change{
    			Id:    ch.String(),
    
    			Age:   c.Age().Microseconds(),
    			State: c.State(),
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		}
    	}
    	return changes, nil
    }
    
    
    func (p pndServer) SetOndList(ctx context.Context, request *ppb.SetOndListRequest) (*ppb.SetOndListResponse, error) {
    
    Malte Bauch's avatar
    Malte Bauch committed
    	labels := prometheus.Labels{"service": "pnd", "rpc": "set"}
    	start := metrics.StartHook(labels, grpcRequestsTotal)
    	defer metrics.FinishHook(labels, start, grpcRequestDurationSecondsTotal, grpcRequestDurationSeconds)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	pid, err := uuid.Parse(request.Pid)
    	if err != nil {
    
    Malte Bauch's avatar
    Malte Bauch committed
    		return nil, handleRPCError(labels, err)
    
    	pnd, err := pndc.GetPND(pid)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	if err != nil {
    
    Malte Bauch's avatar
    Malte Bauch committed
    		return nil, handleRPCError(labels, err)
    
    	for _, r := range request.Ond {
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		sid, err := uuid.Parse(r.Sbi.Id)
    		if err != nil {
    
    			log.Error(err)
    			return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		}
    		if err := pnd.AddDevice(r.DeviceName, r.TransportOption, sid); err != nil {
    
    			log.Error(err)
    			return nil, status.Errorf(codes.Aborted, "%v", err)
    
    	return &ppb.SetOndListResponse{
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		Timestamp: time.Now().UnixNano(),
    
    		Status:    ppb.Status_STATUS_OK,
    		Responses: []*ppb.SetResponse{
    			&ppb.SetResponse{
    				Status: ppb.Status_STATUS_OK,
    			},
    		},
    
    func (p pndServer) SetChangeList(ctx context.Context, request *ppb.SetChangeListRequest) (*ppb.SetChangeListResponse, 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 := pndc.GetPND(pid)
    	if err != nil {
    		return nil, handleRPCError(labels, err)
    	}
    
    	for _, r := range request.Change {
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		cuid, err := uuid.Parse(r.Cuid)
    		if err != nil {
    
    			log.Error(err)
    			return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		}
    		switch r.Op {
    
    		case ppb.Operation_OPERATION_COMMIT:
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    			if err := pnd.Commit(cuid); err != nil {
    
    				log.Error(err)
    				return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    			}
    
    		case ppb.Operation_OPERATION_CONFIRM:
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    			if err := pnd.Confirm(cuid); err != nil {
    
    				log.Error(err)
    				return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    			}
    		default:
    			return nil, &errors.ErrInvalidParameters{
    				Param: r.Op,
    			}
    		}
    	}
    
    	return &ppb.SetChangeListResponse{
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		Timestamp: time.Now().UnixNano(),
    
    		Status:    ppb.Status_STATUS_OK,
    		Responses: []*ppb.SetResponse{
    			&ppb.SetResponse{
    				Status: ppb.Status_STATUS_OK,
    			},
    		},
    
    func (p pndServer) SetPathList(ctx context.Context, request *ppb.SetPathListRequest) (*ppb.SetPathListResponse, 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 := pndc.GetPND(pid)
    	if err != nil {
    		return nil, handleRPCError(labels, err)
    	}
    
    	for _, r := range request.ChangeRequest {
    		did, err := uuid.Parse(r.Did)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		if err != nil {
    
    			log.Error(err)
    			return nil, status.Errorf(codes.Aborted, "%v", err)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		}
    
    		// TODO: Return CUID in API
    		_, err = pnd.ChangeOND(did, r.ApiOp, r.Path, r.Value)
    		if err != nil {
    
    			log.Error(err)
    			return nil, status.Errorf(codes.Aborted, "%v", err)
    
    	return &ppb.SetPathListResponse{
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		Timestamp: time.Now().UnixNano(),
    
    		Status:    ppb.Status_STATUS_OK,
    		Responses: []*ppb.SetResponse{
    			&ppb.SetResponse{
    				Status: ppb.Status_STATUS_OK,
    			},
    		},
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	}, nil
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    }
    
    func (p pndServer) DeleteOnd(ctx context.Context, request *ppb.DeleteOndRequest) (*ppb.DeleteOndResponse, error) {
    	pid, err := uuid.Parse(request.Pid)
    
    	if err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    	pnd, err := pndc.GetPND(pid)
    	if err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    
    
    	did, err := uuid.Parse(request.Did)
    
    	if err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    	if err := pnd.RemoveDevice(did); err != nil {
    		log.Error(err)
    		return nil, status.Errorf(codes.Aborted, "%v", err)
    	}
    
    	return &ppb.DeleteOndResponse{
    
    		Timestamp: time.Now().UnixNano(),
    
    		Status:    ppb.Status_STATUS_OK,
    
    	}, nil