Initial commit: Create rtdt-manager struct, implement functions to fetch pnd...

Initial commit: Create rtdt-manager struct, implement functions to fetch pnd structure, mne-list and topology information and execute clab, start work on subscription mechanism

applications/rtdt-manager/main.go

+package main
+
+import (
+	"flag"
+	"fmt"
+
+	reg "code.fbi.h-da.de/danet/gosdn/applications/rtdt-manager/registration"
+	RtdtMan "code.fbi.h-da.de/danet/gosdn/applications/rtdt-manager/rtdt-manager"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+func main() {
+
+	var url string
+	var pass string
+	var user string
+	flag.StringVar(&url, "url", "172.100.0.5:55055", "Address of the gosdn controller")
+	flag.StringVar(&pass, "p", "TestPassword", "Password for admin user")
+	flag.StringVar(&user, "u", "admin", "Username")
+	flag.Parse()
+	fmt.Println("Trying to connect to gosdn controller at ", url)
+
+	dialOption := grpc.WithTransportCredentials(insecure.NewCredentials())
+	conn, err := grpc.NewClient(url, dialOption, grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(100*1024*1024)))
+	if err != nil {
+		fmt.Println("Failed to create connection")
+		return
+	}
+	defer conn.Close()
+
+	sessionToken, err := reg.Login(conn, url, "admin", pass)
+	if err != nil {
+		_ = fmt.Errorf("Failed to log in: %w", err)
+		return
+	} else {
+		fmt.Println("Successfully logged in to gosdn controller at ", url, " as user ", user)
+	}
+
+	rtdtMan := RtdtMan.NewRtdtManager(conn, sessionToken)
+	_ = rtdtMan
+}

applications/rtdt-manager/registration/registration.go

+package registration
+
+import (
+	"context"
+
+	"code.fbi.h-da.de/danet/gosdn/controller/api"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
+)
+
+// Source: documentation on https://code.fbi.h-da.de/danet/gosdn
+
+// Login logs in to the controller.
+func Login(conn *grpc.ClientConn, address, user, pw string) (string, error) {
+	loginResp, err := api.Login(context.Background(), address, user, pw)
+	if err != nil {
+		return "", err
+	}
+	return loginResp.GetToken(), nil
+}
+
+// createContextWithAuthorization creates a context with the token received after login.
+func CreateContextWithAuthorization(sessionToken string) context.Context {
+	md := metadata.Pairs("authorize", sessionToken)
+	return metadata.NewOutgoingContext(context.Background(), md)
+}

applications/rtdt-manager/rtdt-manager/rtdt-manager.go

+package rtdtmanager
+
+import (
+	"fmt"
+	"os/exec"
+	"time"
+
+	confManPb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/configurationmanagement"
+	pnd "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/pnd"
+	subMgmt "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/subscriptionmanagement"
+	topoPb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/topology"
+	reg "code.fbi.h-da.de/danet/gosdn/applications/rtdt-manager/registration"
+	"google.golang.org/grpc"
+)
+
+type RtdtManager struct {
+	conn         *grpc.ClientConn
+	sessionToken string
+	Pnd          *pnd.PrincipalNetworkDomain
+	topo         *topoPb.Topology
+	sdnConfig    string
+}
+
+func NewRtdtManager(conn *grpc.ClientConn, sessionToken string) *RtdtManager {
+	rMan := RtdtManager{
+		conn:         conn,
+		sessionToken: sessionToken,
+	}
+	if err := rMan.fetchPndUUID(); err != nil {
+		fmt.Println("RtdtManager could not be created, didn't receive pnd's UUID")
+	}
+	if err := rMan.fetchTopology(); err != nil {
+		_ = fmt.Errorf("RtdtManager could not fetch topology: %w", err)
+	}
+	if err := rMan.manageConfig("import"); err != nil {
+		fmt.Println("Successfully retrieved goSDN configuration file: ", rMan.sdnConfig)
+	}
+	return &rMan
+}
+
+func (rMan *RtdtManager) fetchPndUUID() error {
+	pndService := pnd.NewPndServiceClient(rMan.conn)
+	ctx := reg.CreateContextWithAuthorization(rMan.sessionToken)
+	pndResponse, err := pndService.GetPndList(ctx, &pnd.GetPndListRequest{Timestamp: int64(time.Now().Nanosecond())})
+	if err != nil {
+		return fmt.Errorf("Failed to retrieve PND information: %w", err)
+	}
+	if pndList := pndResponse.GetPnd(); pndList != nil {
+		fmt.Println("pndUUID is now: ", pndList[0].Id) // TODO If more than 1, let user choose
+		rMan.Pnd = pndList[0]
+		return nil
+	} else {
+		return fmt.Errorf("Failed to retrieve PND from Pnd List: %w", err)
+	}
+}
+
+func (rMan *RtdtManager) fetchTopology() error {
+	topoService := topoPb.NewTopologyServiceClient(rMan.conn)
+	ctx := reg.CreateContextWithAuthorization(rMan.sessionToken)
+	topoResponse, err := topoService.GetTopology(ctx, &topoPb.GetTopologyRequest{Timestamp: int64(time.Now().Nanosecond())})
+	if err != nil {
+		return fmt.Errorf("Failed to retrieve Topology: %w", err)
+	}
+	fmt.Println("Successfully read topology: ", topoResponse.Toplogy)
+	rMan.topo = topoResponse.Toplogy
+	return nil
+}
+
+func (rMan *RtdtManager) clabExec(configFile string) error {
+	cmd := exec.Command("sudo", "containerlab", "deploy", configFile)
+	output, err := cmd.Output()
+	if err != nil {
+		return fmt.Errorf("Failed to execute containerlab: %w", err)
+	}
+	fmt.Print(output)
+	return nil
+
+}
+
+func (rMan *RtdtManager) manageConfig(op string) error {
+
+	switch op {
+	// Import the configuration into rtdt-manager (by exporting from gosdn)
+	case "import":
+		fmt.Println("Now importing sdnConfig into rtdt-manager")
+		confManService := confManPb.NewConfigurationManagementServiceClient(rMan.conn)
+		ctx := reg.CreateContextWithAuthorization(rMan.sessionToken)
+		exportSdnConfigResponse, err := confManService.ExportSDNConfig(ctx, &confManPb.ExportSDNConfigRequest{Timestamp: int64(time.Now().Nanosecond())})
+		if err != nil {
+			return fmt.Errorf("Failed to retrieve goSDN config file: %w", err)
+		}
+		rMan.sdnConfig = exportSdnConfigResponse.SdnConfigData
+		return nil
+	// Export from rtdt-manager into gosdn controller
+	case "export":
+		fmt.Println("Now exporting sdnConfig into gosdn controller")
+		// Implement me some day
+		return nil
+	default:
+		return fmt.Errorf("Unknown config operation")
+	}
+}
+
+func (rMan *RtdtManager) initEventSystem() error {
+	subMgmtService := subMgmt.NewSubscriptionManagementServiceClient(rMan.conn)
+	ctx := reg.CreateContextWithAuthorization(rMan.sessionToken)
+	subservice, err := subMgmtService.GetAll(ctx, &subMgmt.GetAllRequest{})
+	if err != nil {
+		return fmt.Errorf("Failed to create subscription service: %w", err)
+	}
+
+	return nil
+}

applications/venv-manager/venv-manager/venv-manager.go

@@ -54,7 +54,6 @@ func (v *VenvManager) createConnection() (*grpc.ClientConn, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	return conn, nil
 }
 
@@ -118,7 +117,6 @@ func (v *VenvManager) sendSDNConfigData(sdnConfigData *string) error {
 	if err != nil {
 		return err
 	}
-
 	return nil
 }
 

makefiles/build/Makefile

@@ -38,3 +38,6 @@ build-ws-events-app: pre
 
 build-inventory-manager: pre
 	$(GOBUILD) -trimpath -o $(BUILD_ARTIFACTS_PATH)/inventory-manager ./applications/inventory-manager
+
+build-rtdt-manager: pre
+	$(GOBUILD) -trimpath -o $(BUILD_ARTIFACTS_PATH)/rtdt-manager ./applications/rtdt-manager

makefiles/clab/Makefile

@@ -13,7 +13,7 @@ containerlab-stop: create-clab-dir
 
 containerlab-slim-start: create-clab-dir containerize-all generate-all-certs
 	cd $(CLAB_DIR) &&\
-	sudo containerlab deploy --topo $(MAKEFILE_DIR)dev_env_data/clab/gosdn_slim.clab.yaml
+	sudo containerlab deploy --topo $(MAKEFILE_DIR)dev_env_data/clab/gosdn_slim.clab.yaml --reconfigure
 
 containerlab-slim-start-reconfigure: create-clab-dir containerize-all generate-all-certs
 	cd $(CLAB_DIR) &&\