Newer
Older
//"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"
)
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)
}
log.Print(invManager)
//Returning the list of devices from the controller.
elements := listRunningNetworkElements(invManager)
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
}
// 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)
logrus.Errorf("Error retrieving network elements: %s", err.Error())
/*
// 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