inventoryManager.go

package inventoryManager

import (
	"context"
	//"flag"
	"log"
	"os"
	"time"

	//	"code.fbi.h-da.de/danet/gosdn/controller/api"

	"code.fbi.h-da.de/danet/gosdn/api/go/gosdn/networkelement"
	"code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/config"
	"code.fbi.h-da.de/danet/gosdn/controller/api"

	//inventorymanager "code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/inventoryManager"
	"github.com/sirupsen/logrus"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"gopkg.in/yaml.v3"
)

type InventoryManager struct {
	pndID             string
	controllerAddress string
	grpcClientConn    *grpc.ClientConn
	sessionContext    context.Context
	sessionToken      string
}

// createGosdnConnectionwitNetzworkElementslist creates a context with the given authorization token. And gives the list of network elements bag.
func CreateGosdnConnectionwitNetzworkElementslist(configFile *string) (*networkelement.GetAllResponse, error) {
	// Configpfad aus CLI-Flag holen
	//configFile := flag.String("configGosdn", "config/config.yaml", "Pfad zur NetBox-Konfigurationsdatei")
	//flag.Parse()

	log.Printf("Config-Pfad: %s", *configFile)

	//Reading the config file
	data, err := os.ReadFile(*configFile)
	if err != nil {
		log.Printf("Fehler beim Lesen der Konfigurationsdatei: %v", err)
		return nil, err
	}

	// YAML in Config-Struct einlesen
	gosdnConfig := &config.Config{}
	if err := yaml.Unmarshal(data, gosdnConfig); err != nil {
		log.Printf("Fehler beim Parsen der YAML-Datei: %v", err)
		return nil, err
	}
	/*
		log.Printf("gosdn Config AppName: %v", gosdnConfig.AppName)
		log.Printf("gosdn Config ControllerAddress: %v", gosdnConfig.ControllerAddress)
		log.Printf("gosdn Config PndID: %v", gosdnConfig.PndID)
		log.Printf("gosdn Config UserName: %v", gosdnConfig.UserName)
		log.Printf("Config Config UserPW: %v", gosdnConfig.UserPW)
	*/
	invManager, err := InitializeInventoryManager(gosdnConfig)
	if err != nil {
		log.Fatal(err)
	}
	//log.Print(invManager) //i dont know what this is

	//gibt die Liste mit geräte vom Controller aus.
	elements := listRunningNetworkElements(invManager)

	return elements, nil
}

// InitializeInventoryManager sets up the inventory manager and logs in to the controller.
func InitializeInventoryManager(config *config.Config) (*InventoryManager, error) {
	// Create controller client object
	newConn, err := grpc.NewClient(config.ControllerAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		logrus.Errorf("Failed to create controller client with error: %s", err.Error())
		return nil, err
	}

	var conn *grpc.ClientConn
	var sessionToken string
	logrus.Info("Connecting and logging in to controller ", config.ControllerAddress)
	for {
		sessionToken, err = Login(conn, config.ControllerAddress, config.UserName, config.UserPW)
		if err == nil {
			logrus.Info("Connected and logged in to Controller")
			conn = newConn
			break
		}
		logrus.Errorf("Failed to connect and log in to Controller with error: %s, retrying in 1 second", err.Error())
		time.Sleep(1 * time.Second)
	}

	app, err := NewInventoryManager(conn, sessionToken, config.ControllerAddress, config.PndID, config.AppName)
	if err != nil {
		return nil, err
	}

	return app, nil
}

func NewInventoryManager(grpcClientConn *grpc.ClientConn, sessionToken, controllerAddress, pndID, appName string) (*InventoryManager, error) {
	ctx := createContextWithAuthorization(sessionToken)

	return &InventoryManager{
		grpcClientConn:    grpcClientConn,
		sessionContext:    ctx,
		sessionToken:      sessionToken,
		pndID:             pndID,
		controllerAddress: controllerAddress,
	}, nil
}

// listRunningNetworkElements takes on an InventoryManager instance and retrieves the currently running network elements from the controller, returning them.
func listRunningNetworkElements(i *InventoryManager) *networkelement.GetAllResponse {

	elements, err := api.GetNetworkElements(i.sessionContext, i.controllerAddress, i.pndID)
	if err != nil {
		logrus.Errorf("Fehler beim Abrufen der Netzwerkelemente: %s", err.Error())
		return nil
	}
	/*
		// Debugging
		logrus.Info("Abrufen der laufenden Netzwerkelemente...")
		logrus.Infof("sessionContext Print %s", i.sessionContext)
		logrus.Infof("controllerAddress Print %s", i.controllerAddress)
		logrus.Infof("pndID Print %s", i.pndID)

		// Netzwerkelemente ausgeben
		logrus.Info("Gefundene Netzwerkelemente:")
		for _, element := range elements.Mne {
			logrus.Info("element.Name: ", element.Name)
			logrus.Info("element.Id: ", element.Id)
			logrus.Info("element.Plugin: ", element.Plugin)
		}
	*/
	return elements
}