Skip to content
Snippets Groups Projects
inventoryManager.go 4.74 KiB
Newer Older
  • Learn to ignore specific revisions
  • package inventoryManager
    
    
    import (
    	"context"
    
    	//"code.fbi.h-da.de/danet/gosdn/api/go/github.com/openconfig/gnmi/proto/gnmi"
    
    	"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"
    
    	//"github.com/openconfig/ygot/ytypes"
    
    	"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
    }
    
    
    
    
    /*func GetModelAsStruct(gnmiNotifications []*gnmi.Notification) (*temp.Device, error) {
    	modelAsSchema := ytypes.Schema{
    		Root:       &temp.Device{},
    		SchemaTree: temp.SchemaTree,
    	}
    
    	err := ytypes.UnmarshalNotifications(&modelAsSchema, gnmiNotifications, &ytypes.IgnoreExtraFields{})
    	if err != nil {
    		return nil, err
    	}
    
    	modelAsStruct, ok := modelAsSchema.Root.(*temp.Device)
    	if !ok {
    		return nil, errors.New("dynamic cast fail")
    	}
    
    	return modelAsStruct, nil
    }*/
    
    
    // createGosdnConnectionwitNetzworkElementslist creates a context with the given authorization token. And gives the list of network elements bag.
    
    func CreateGosdnConnectionwitNetzworkElementslist(configFile *string) (*networkelement.GetAllResponse, error) {
    
    	//Reading the config file
    	data, err := os.ReadFile(*configFile)
    	if err != nil {
    
    		log.Printf("Error reading configuration file:  %v", err)
    
    		return nil, err
    	}
    
    	// YAML in Config-Struct einlesen
    	gosdnConfig := &config.Config{}
    	if err := yaml.Unmarshal(data, gosdnConfig); err != nil {
    
    		log.Printf("Error parsing YAML file: %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)
    	}
    
    	//Returning the list of devices from the controller.
    
    	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("Error retrieving network elements: %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