diff --git a/applications/inventory-manager-netbox/inventoryManager/inventoryManager.go b/applications/inventory-manager-netbox/inventoryManager/inventoryManager.go index 4816e95bf1fe4d55bd873e935c82be67f96e469b..7c27be411c999d5fee3971ac3c36309581ac55c9 100644 --- a/applications/inventory-manager-netbox/inventoryManager/inventoryManager.go +++ b/applications/inventory-manager-netbox/inventoryManager/inventoryManager.go @@ -1,21 +1,23 @@ -package inventorymanager +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" - "github.com/netbox-community/go-netbox/netbox" - "github.com/netbox-community/go-netbox/netbox/client" - "github.com/netbox-community/go-netbox/netbox/client/extras" - "github.com/netbox-community/go-netbox/netbox/models" + "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" - //"github.com/smutel/go-netbox/netbox/client" - //"github.com/smutel/go-netbox/netbox/client/extras" - //"github.com/smutel/go-netbox/netbox/models" + "gopkg.in/yaml.v3" ) type InventoryManager struct { @@ -26,18 +28,44 @@ type InventoryManager struct { sessionToken string } -type NetboxManager struct { - NetboxConfig *config.NetboxConfig -} +// createGosdnConnectionwitNetzworkElementslist creates a context with the given authorization token. And gives the list of network elements bag. +func CreateGosdnConnectionwitNetzworkElementslist() (*networkelement.GetAllResponse, error) { + // Configpfad aus CLI-Flag holen + configFile := flag.String("configGosdn", "config/config.yaml", "Pfad zur NetBox-Konfigurationsdatei") + flag.Parse() -// Hilfsfunktion -func Int64Ptr(i int64) *int64 { - return &i -} + 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) -// String in einen *string zu konvertieren -func StringPtrr(s string) *string { - return &s + return elements, nil } // InitializeInventoryManager sets up the inventory manager and logs in to the controller. @@ -74,125 +102,37 @@ func InitializeInventoryManager(config *config.Config) (*InventoryManager, error func NewInventoryManager(grpcClientConn *grpc.ClientConn, sessionToken, controllerAddress, pndID, appName string) (*InventoryManager, error) { ctx := createContextWithAuthorization(sessionToken) - // Not needed now, but later when lifecycle is implemented - //queueCredentials, err := getQueueCredentials(ctx, controllerAddress, appName, registrationToken) - //if err != nil { - // return nil, err - //} - // - //eventService, err := event.NewEventService( - // queueCredentials, - // []event.Topic{event.ManagedNetworkElement}, - //) - //if err != nil { - // return nil, err - //} - return &InventoryManager{ - grpcClientConn: grpcClientConn, - sessionContext: ctx, - sessionToken: sessionToken, - //eventService: eventService, + grpcClientConn: grpcClientConn, + sessionContext: ctx, + sessionToken: sessionToken, pndID: pndID, controllerAddress: controllerAddress, }, nil } -// Run starts the InventoryManager. This will elad to it trying to create every network element from the config file. -// It will try to create it indefinitely. -// TODO: After creating a network element, it will ensure that the element exists in the controller. -func (i *InventoryManager) Run() error { - //i.createNetworkelements() - - return nil -} - -func (i *InventoryManager) createNetworkelements() { - - //Hier einmal alles rausgeworfen. Nutze ich dan nauch wieder. bloß gerade nicht^^ - - //err = api.AddNetworkElement(i.sessionContext, i.controllerAddress, networkElement.Name, networkElement.UUID, &transportOptions, pluginUUID, pndUUID, []string{}) - // err = api.AddNetworkElement("test", "test", "test", "test", "test", "test", "test", []string{}) - -} - -// Funktion zur Initialisierung des NetBox Clients -/* -func (i *NetboxManager) initializeNetboxClient() *client.NetBoxAPI { - return netbox.NewNetboxWithAPIKey(i.NetboxConfig.NetboxAddress, i.NetboxConfig.ApiToken) -} +// listRunningNetworkElements takes on an InventoryManager instance and retrieves the currently running network elements from the controller, returning them. +func listRunningNetworkElements(i *InventoryManager) *networkelement.GetAllResponse { -func (i *NetboxManager) initializeNetboxClient() *netbox.NetBox { - return netbox.NewNetboxWithAPIKey(i.NetboxConfig.NetboxAddress, i.NetboxConfig.ApiToken) -} -*/ - -// Funktion zur Erstellung eines neuen WirelessLAN Modells -/* -func createNewWirelessLAN(ssid, status, comments, description string, vlanID int64) *models.WritableWirelessLAN { - return &models.WritableWirelessLAN{ - Ssid: StringPtrr(ssid), - Status: status, - Comments: comments, - Description: description, - Vlan: Int64Ptr(vlanID), - } -} -*/ - -func createNewWirelessLAN(ssid, status, comments, description string, vlanID int64) *models.WritableWirelessLAN { - return &models.WritableWirelessLAN{ - Ssid: StringPtrr(ssid), - Status: status, - Comments: comments, - Description: description, - Vlan: Int64Ptr(vlanID), - } -} - -// Funktion zur Erstellung eines neuen Tags (mit einer korrekten Methode) -func CreateNewTag() *models.Tag { - return &models.Tag{ - Name: StringPtrr("Guter Tag aus dem richtigen Programm"), - Slug: StringPtrr("guter-tag6"), - Description: "Das ist ein gutes Gerät, aus dem richtigen Programm", - } -} - -// Funktion zur Durchführung des API-Requests für Tags (mit richtiger Methode) -func CreateTag(c *client.NetBoxAPI, newTag *models.Tag, ctx context.Context) (*models.Tag, error) { - req := extras.NewExtrasTagsCreateParamsWithContext(ctx) // Tags-API unter extras - req.SetData(newTag) - - res, err := c.Extras.ExtrasTagsCreate(req, nil) // Verwende die korrekte Methode + elements, err := api.GetNetworkElements(i.sessionContext, i.controllerAddress, i.pndID) if err != nil { - return nil, err + logrus.Errorf("Fehler beim Abrufen der Netzwerkelemente: %s", err.Error()) + return nil } - - return res.Payload, nil -} - -func (i *NetboxManager) Run() error { - i.createNetboxConnection() - - //logrus.Info("Netbox-Verbindung aufbauen mit Adresse:", i.NetboxConfig.NetboxAddress) - //logrus.Info("Connecting and logging in to controller ", i.NetboxConfig.ApiToken) - return nil -} - -func (i *NetboxManager) createNetboxConnection() { - ctx := context.Background() - client := netbox.NewNetboxWithAPIKey(i.NetboxConfig.NetboxAddress, i.NetboxConfig.ApiToken) - - //client := i.initializeNetboxClient() - //logrus.Info("Netbox-Verbindung aufbauen mit Adresse:", i.NetboxConfig.NetboxAddress) - //logrus.Info("Connecting and logging in to controller ", i.NetboxConfig.ApiToken) - - newTag := CreateNewTag() - createdTag, err := CreateTag(client, newTag, ctx) - if err != nil { - log.Fatalf("Fehler beim Erstellen des Tags: %v", err) - } - log.Printf("Neues Tag erstellt: %v", createdTag) - + /* + // 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 } diff --git a/applications/inventory-manager-netbox/inventoryManager/netboxManager.go b/applications/inventory-manager-netbox/inventoryManager/netboxManager.go deleted file mode 100644 index 87cb040bf5b6112281f043a92cd617ca4d66bc12..0000000000000000000000000000000000000000 --- a/applications/inventory-manager-netbox/inventoryManager/netboxManager.go +++ /dev/null @@ -1 +0,0 @@ -package inventorymanager diff --git a/applications/inventory-manager-netbox/main.go b/applications/inventory-manager-netbox/main.go index 961c1a0a611c20d0644bf2d6b23aa9a2a5931544..6d8ee5fca8cf720723ceb0119ba000a5e073a7af 100644 --- a/applications/inventory-manager-netbox/main.go +++ b/applications/inventory-manager-netbox/main.go @@ -1,112 +1,67 @@ package main import ( - "flag" "log" - "os" + "time" - "code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/config" - inventorymanager "code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/inventoryManager" - "github.com/sirupsen/logrus" - "google.golang.org/grpc/resolver" - "gopkg.in/yaml.v3" + "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/networkelement" + "code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/netboxManager" ) func main() { - configFileController := flag.String("config", "config/config.yaml", "app config file") - configFileNetbox := flag.String("configNetbox", "config/configNetbox.yaml", "app config file") - logLevel := flag.String("log", "info", "logrus lof level (debug, info, warn, error, fatal, panic)") - noGRPCPassthrough := flag.Bool("noGRPCPassthrough", false, "set the default resolve scheme for grpc to not use passthrough, default is false") - flag.Parse() + for { + var elementeFigure int + var elements *networkelement.GetAllResponse + var err error - if *noGRPCPassthrough { - logrus.Info("gRPC default resolver scheme is not set to passthrough. This might cause issues with the gRPC connection when no real DNS server is available as each gRPC requests requires a DNS request.") - } else { - logrus.Info("Setting gRPC default resolver scheme to passthrough. No DNS queries are being made when doing a gRPC request.") - resolver.SetDefaultScheme("passthrough") - } - - // parse string, this is built-in feature of logrus - ll, err := logrus.ParseLevel(*logLevel) - if err != nil { - ll = logrus.InfoLevel - logrus.Warn("invalid log level, using default: ", ll) - } - - // set global log level - logrus.Info("setting log level to ", ll) - logrus.SetLevel(ll) - - logrus.Debugf("current config path: %s", *configFileController) - file, err := os.ReadFile(*configFileController) - if err != nil { - currentFolder, _ := os.Getwd() - log.Fatalf("error reading config file: %s, current folder: %s", *configFileController, currentFolder) - } - - appConfig := &config.Config{} - if err = yaml.Unmarshal(file, appConfig); err != nil { - logrus.Fatal(err) - } - - // Just for printing the config - configBytes, err := yaml.Marshal(appConfig) - if err != nil { - logrus.Fatal("error marshaling config to YAML: ", err) - } - logrus.Debugf("config:\n%s", string(configBytes)) - - inventoryManager, err := inventorymanager.InitializeInventoryManager(appConfig) - if err != nil { - logrus.Fatal(err) - } - - //Netbox Config File - logrus.Debugf("current config path: %s", *configFileNetbox) - filee, err := os.ReadFile(*configFileNetbox) - if err != nil { - currentFolder, _ := os.Getwd() - log.Fatalf("error reading config filee: %s, current folder: %s", *configFileNetbox, currentFolder) - } + //getting date from the controller. + elements, err = inventoryManager.CreateGosdnConnectionwitNetzworkElementslist() + if err != nil { + log.Fatalf("Fehler beim Erstellen der Controller Conenction: %v", err) + } else { + log.Println("Es ist alles cool!") + } - netboxconfig := &config.NetboxConfig{} - if err = yaml.Unmarshal(filee, netboxconfig); err != nil { - logrus.Fatal(err) - } - // Just for printing the config - configBytesNetbox, err := yaml.Marshal(netboxconfig) - if err != nil { - logrus.Fatal("error marshaling config to YAML: ", err) + //if elements != nil { + if len(elements.Mne) != elementeFigure { + //log.Printf("Es wurden %d Elemente gefunden", len(elementss.Mne)) + //take the date into Netbox + err = netboxManager.FeedNetbox(elements) + if err != nil { + log.Fatalf("Fehler beim Erstellen des Geräts: %v", err) + } else { + log.Println("Es ist alles cool!") + elementeFigure = len(elements.Mne) + log.Printf("Es sind %d elementeFigur", elementeFigure) + } + + } else { + log.Printf("Der Controller hat keine Daten für mich. Weiter machen Sinnlos^^ elements ist leer") + time.Sleep(1 * time.Second) + } } - logrus.Debugf("config:\n%s", string(configBytesNetbox)) - - //logrus.Infof("Netbox Adresse: %s", netboxconfig.NetboxAddress) - //logrus.Infof("Controller Adresse: %s", appConfig.ControllerAddress) /* - NetboxManager, err := inventorymanager.InitializeInventoryManager(netboxconfig) + elements, err := inventoryManager.CreateGosdnConnectionwitNetzworkElementslist() if err != nil { - logrus.Fatal(err) + log.Fatalf("Fehler beim Erstellen der Controller Conenction: %v", err) + } else { + log.Println("Es ist alles cool!") } - err = NetboxManager.Run(netboxconfig) + + err = netboxManager.Netboxmanager() if err != nil { - logrus.Fatal(err) + log.Fatalf("Fehler beim Erstellen des Geräts: %v", err) + } else { + log.Println("Es ist alles cool!") } - */ - //############## - - err = inventoryManager.Run() - if err != nil { - logrus.Fatal(err) - } - - netboxManager := &inventorymanager.NetboxManager{ - NetboxConfig: netboxconfig, - } - err = netboxManager.Run() - if err != nil { - logrus.Fatal(err) - } + err = netboxManager.FeedNetbox(elementss) + if err != nil { + log.Fatalf("Fehler beim Erstellen des Geräts: %v", err) + } else { + log.Println("Es ist alles cool!") + } + */ } diff --git a/applications/inventory-manager-netbox/netboxManager/netboxDinge.go b/applications/inventory-manager-netbox/netboxManager/netboxDinge.go new file mode 100644 index 0000000000000000000000000000000000000000..f81ec9e2fe646a5d792a9ba9fa2898053f1b816f --- /dev/null +++ b/applications/inventory-manager-netbox/netboxManager/netboxDinge.go @@ -0,0 +1,161 @@ +package netboxManager + +func createDevice() map[string]interface{} { + device := map[string]interface{}{ + "name": "Modulares-Gerät", + "device_type": 1, + "role": 1, + "site": 1, + "serial": "SN123456999", + "description": "Kompaktes Beispielgerät", + "status": "active", + } + return device +} +func createDeviceWithParameter(name, deviceTypeID, deviceRoleID, siteID, serial, description, status string) map[string]interface{} { + // /api/dcim/devices/ Gerät + device := map[string]interface{}{ + "name": name, + "device_type": deviceTypeID, + "role": deviceRoleID, + "site": siteID, + "serial": serial, + "description": description, + "status": status, + } + return device +} + +func createTag() map[string]interface{} { + device := map[string]interface{}{ + "name": "Guter Tag aus dem richtigen Programm18", + "slug": "guter-tag18", + "description": "Das ist ein gutes Gerät, aus dem richtigen Programm", + } + return device +} +func createTagWithParameter(name, slug, description string) map[string]interface{} { + device := map[string]interface{}{ + "name": name, + "slug": slug, + "description": description, + } + return device +} + +func createModultyp(manufacturerID string) map[string]interface{} { + ///api/dcim/module-types/ Modultypen + device := map[string]interface{}{ + "model": "Großes Model18", + "partNumber": "Ich bin eine Part Number", + //"weight" : "9", + //"weight_unit": "KiloGramm", + "description": "Ich bin eine Beschreibung von einem Großen Model", + "comments": "Und ich bin ein Kommentar", + "manufacturer": manufacturerID, + } + return device +} +func createModultypWithParameter(model, partNumber, description, comments, manufacturerID string) map[string]interface{} { + ///api/dcim/module-types/ Modultypen + device := map[string]interface{}{ + "model": model, + "partNumber": partNumber, + //"weight" : "9", + //"weight_unit": "KiloGramm", + "description": description, + "comments": comments, + "manufacturer": manufacturerID, + } + return device +} + +func createdeviceType(manufacturerID string) map[string]interface{} { + // /dcim/device-types/ Gerätetyp + device := map[string]interface{}{ + + "manufacturer": manufacturerID, + "model": "Mein-Gerätetyp", + "slug": "mein-geraetetyp", + "u_height": "1", + } + return device +} +func createdeviceTypeWithParameter(manufacturerID, model, slug, uHeight string) map[string]interface{} { + // /dcim/device-types/ Gerätetyp + device := map[string]interface{}{ + "manufacturer": manufacturerID, + "model": model, + "slug": slug, + "u_height": uHeight, + } + return device +} + +func createManufacturer() map[string]interface{} { + // /dcim/manufacturers/ Hersteller + device := map[string]interface{}{ + "name": "Großer Hersteller18", + "slug": "grosser-hersteller18", + "description": "Hersteller für große Modelle", + } + return device +} +func createManufacturerWithParameter(name, slug, description string) map[string]interface{} { + // /dcim/manufacturers/ Hersteller + device := map[string]interface{}{ + "name": name, + "slug": slug, + "description": description, + } + return device +} + +func createDeviceRole() map[string]interface{} { + // /dcim/device-roles/ Geräterolle + device := map[string]interface{}{ + "name": "Wichtige Rolle18", + "slug": "wichtige-rolle18", + "description": "Eine wichtige Rolle für Geräte", + "color": "ff0000", // Rote Farbe als Hex-Code + } + return device +} +func createDeviceRoleWithParameter(name, slug, description, color, active string) map[string]interface{} { + // /dcim/device-roles/ Geräterolle + device := map[string]interface{}{ + "name": name, + "slug": slug, + "description": description, + "color": color, + "status": active, + } + return device +} + +func createSite() map[string]interface{} { + // /dcim/sites/ Standorts + device := map[string]interface{}{ + "name": "GoHauptstandort18", + "slug": "Gohauptstandort18", + "description": "Hauptsitz des Unternehmens", + "physicalAddress": "Musterstraße 1, 12345 Musterstadt", + "shippingAddress": "Postfach 1001, 12345 Musterstadt", + "comments": "Dies ist der Hauptstandort.", + "status": "active", + } + return device +} +func createSiteWithParameter(name, slug, description, physicalAddress, shippingAddress, comments, status string) map[string]interface{} { + // /dcim/sites/ Standorts + device := map[string]interface{}{ + "name": name, + "slug": slug, + "description": description, + "physicalAddress": physicalAddress, + "shippingAddress": shippingAddress, + "comments": comments, + "status": status, + } + return device +} diff --git a/applications/inventory-manager-netbox/netboxManager/netboxManager.go b/applications/inventory-manager-netbox/netboxManager/netboxManager.go new file mode 100644 index 0000000000000000000000000000000000000000..6db84e17211294549ea14e920add6edc591e494e --- /dev/null +++ b/applications/inventory-manager-netbox/netboxManager/netboxManager.go @@ -0,0 +1,320 @@ +package netboxManager + +import ( + "bytes" + "encoding/json" + "flag" + "io" + "log" + "net/http" + "os" + "strconv" + + "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/networkelement" + "code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/config" + "gopkg.in/yaml.v3" +) + +func gehMirNichtAufdenSack() { + var device map[string]interface{} + device = createDevice() + log.Printf("Irgendwas: %v", device) + device = createDeviceWithParameter("name", "deviceTypeID", "deviceRoleID", "siteID", "serial", "description", "active") + log.Printf("Irgendwas: %v", device) + device = createTag() + log.Printf("Irgendwas: %v", device) + device = createTagWithParameter("name", "slug", "description") + log.Printf("Irgendwas: %v", device) + device = createModultyp("10") + log.Printf("Irgendwas: %v", device) + device = createModultypWithParameter("model", "partNumber", "description", "comments", "manufacturerID") + log.Printf("Irgendwas: %v", device) + device = createdeviceType("10") + log.Printf("Irgendwas: %v", device) + device = createdeviceTypeWithParameter("manufacturerID", "model", "slug", "1") + log.Printf("Irgendwas: %v", device) + device = createManufacturer() + log.Printf("Irgendwas: %v", device) + device = createManufacturerWithParameter("name", "slug", "description") + log.Printf("Irgendwas: %v", device) + device = createDeviceRole() + log.Printf("Irgendwas: %v", device) + device = createDeviceRoleWithParameter("name", "slug", "description", "ff0000", "offline") + log.Printf("Irgendwas: %v", device) + device = createSite() + log.Printf("Irgendwas: %v", device) + device = createSiteWithParameter("name", "slug", "description", "physicalAddress", "shippingAddress", "comments", "status") + log.Printf("%v", device) + +} + +// create one Device in Netbox with JSON and HTTP +func Netboxmanager() error { + var device map[string]interface{} + //gehMirNichtAufdenSack() + // Configpfad aus CLI-Flag holen + configFileNetbox := flag.String("configNetbox", "config/configNetbox.yaml", "Pfad zur NetBox-Konfigurationsdatei") + flag.Parse() + log.Printf("Config-Pfad: %s", *configFileNetbox) + + // Datei lesen + data, err := os.ReadFile(*configFileNetbox) + if err != nil { + log.Printf("Fehler beim Lesen der Konfigurationsdatei: %v", err) + return err + } + + // YAML in Config-Struct einlesen + netboxconfig := &config.NetboxConfig{} + if err := yaml.Unmarshal(data, netboxconfig); err != nil { + log.Printf("Fehler beim Parsen der YAML-Datei: %v", err) + return err + } + log.Printf("Netbox Config Adresse: %v", netboxconfig.NetboxAddress) + log.Printf("Netbox Config Token: %v", netboxconfig.ApiToken) + + //Manufacturers Hersteller + device = createManufacturerWithParameter("HerstellerName2", "slug2", "description") + id, err := Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/manufacturers/", device) + if err != nil { + log.Printf("Fehler beim erstellen eines Herstellers: %v", err) + return err + } + manufacturerID := id + log.Printf("Hersteller erfolgreich erstellt oder gefunden mit der manufacturerID: %d\n", manufacturerID) + + //Device Types Gerätetyp device_type + device = createdeviceTypeWithParameter(strconv.FormatInt(manufacturerID, 10), "model5", "slug5", "1") + id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/device-types/", device) + if err != nil { + log.Printf("Fehler beim erstellen des Gerätetyps: %v", err) + return err + } + deviceTypeID := id + log.Printf("Gerätetyp erfolgreich erstellt oder gefunden mit der deviceTypeID: %d\n", deviceTypeID) + + deviceTypeID = 16 + log.Printf("Hacki lösung DeviceRoleID manuell ändern: %d\n", deviceTypeID) //TODO + + //device-roles Geräterolle + device = createDeviceRoleWithParameter("name2", "slug5", "description", "ff0000", "offline") + id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/device-roles/", device) + if err != nil { + log.Printf("Fehler beim erstellen der Geräterolle: %v", err) + return err + } + deviceRoleID := id + log.Printf("Geräterolle erfolgreich erstellt oder gefunden mit der deviceRoleID: %d\n", deviceRoleID) + + device = createSiteWithParameter("Darmstadt", "darmstadt", "description", "physicalAddress", "shippingAddress", "comments", "active") + id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/sites/", device) + if err != nil { + log.Printf("Fehler beim erstellen der Geräterolle: %v", err) + return err + } + siteID := id + log.Printf("Geräterolle erfolgreich erstellt oder gefunden mit der siteID: %d\n", siteID) + + device = createDeviceWithParameter("name", strconv.FormatInt(deviceTypeID, 10), strconv.FormatInt(deviceRoleID, 10), strconv.FormatInt(siteID, 10), "serial", "description", "active") + id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/devices/", device) + if err != nil { + log.Printf("Fehler beim erstellen des Gerätes: %v", err) + return err + } + deviceID := id + log.Printf("Gerät erfolgreich erstellt oder gefunden mit der deviceID: %d\n", deviceID) + + return nil +} + +func Netzworhandling(netboxURL, apiToken, api string, device map[string]interface{}) (int64, error) { + // Ziel-URL vorbereiten + url := "http://" + netboxURL + "/api" + api + log.Printf("Die URL lautet: %s", url) + + // JSON kodieren + body, err := json.Marshal(device) + if err != nil { + log.Printf("JSON-Fehler: %v", err) + return 0, err + } + + // HTTP-Request vorbereiten + req, err := http.NewRequest("POST", url, bytes.NewReader(body)) + if err != nil { + log.Printf("Request-Fehler: %v", err) + return 0, err + } + + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Authorization", "Token "+apiToken) + + // Request senden + resp, err := http.DefaultClient.Do(req) + if err != nil { + log.Printf("Sende-Fehler: %v", err) + return 0, err + } + defer resp.Body.Close() + + // Überprüfe den Statuscode + if resp.StatusCode < 200 || resp.StatusCode >= 300 { + bodyBytes, _ := io.ReadAll(resp.Body) + log.Printf("HTTP Fehler: %d - %s", resp.StatusCode, string(bodyBytes)) + //return 0, err + } + + // Antwort dekodieren + var result map[string]interface{} + if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { + log.Printf("Antwort-Parsing: %v", err) + //return 0, err + } + + // ID extrahieren + if id, ok := result["id"].(float64); ok { + return int64(id), nil + } + + // Wenn ID fehlt: Fallback → über Gerätename suchen + if name, ok := device["name"].(string); ok { + log.Println("Keine ID erhalten – versuche bestehendes Gerät mit Namen zu finden:", name) + + queryURL := "http://" + netboxURL + "/api" + api + "?name=" + name + log.Println("url zum namen suchen lautet: ", queryURL) + + reqGet, err := http.NewRequest("GET", queryURL, nil) + if err != nil { + log.Printf("GET-Request-Fehler: %v", err) + return 0, err + } + reqGet.Header.Set("Authorization", "Token "+apiToken) + + respGet, err := http.DefaultClient.Do(reqGet) + if err != nil { + log.Printf("GET-Fehler: %v", err) + return 0, err + } + defer respGet.Body.Close() + + var getResult map[string]interface{} + if err := json.NewDecoder(respGet.Body).Decode(&getResult); err != nil { + log.Printf("GET-Antwort-Parsing: %v", err) + return 0, err + } + + if results, ok := getResult["results"].([]interface{}); ok && len(results) > 0 { + if first, ok := results[0].(map[string]interface{}); ok { + if id, ok := first["id"].(float64); ok { + log.Printf("Bestehendes Gerät gefunden mit ID: %d", int64(id)) + return int64(id), nil + } + } + } + + log.Printf("Kein existierendes Gerät mit dem Namen gefunden.") + } + + log.Printf("keine ID in Antwort gefunden und kein Gerät per Namen auffindbar") + return 0, nil +} + +func FeedNetbox(elements *networkelement.GetAllResponse) error { + var device map[string]interface{} + + if elements != nil { + log.Printf("Es wurden %d Elemente gefunden", len(elements.Mne)) + } + //gehMirNichtAufdenSack() + configFileNetboxV2 := flag.String("configNetbox", "config/configNetbox.yaml", "Pfad zur NetBox-Konfigurationsdatei") + flag.Parse() + + log.Printf("Config-Pfad: %s", *configFileNetboxV2) + + // Config Datei lesen + data, err := os.ReadFile(*configFileNetboxV2) + if err != nil { + log.Printf("Fehler beim Lesen der Konfigurationsdatei: %v", err) + return err + } + + // YAML in Config-Struct einlesen + netboxconfig := &config.NetboxConfig{} + if err := yaml.Unmarshal(data, netboxconfig); err != nil { + log.Printf("Fehler beim Parsen der YAML-Datei: %v", err) + return err + } + //log.Printf("Netbox Config Adresse: %v", netboxconfig.NetboxAddress) + //log.Printf("Netbox Config Token: %v", netboxconfig.ApiToken) + + //Manufacturers Hersteller + device = createManufacturerWithParameter("UniController", "UniController", "Die Wichtige große Box. nicht ausschalten") + id, err := Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/manufacturers/", device) + if err != nil { + log.Printf("Fehler beim erstellen eines Herstellers: %v", err) + return err + } + manufacturerID := id + log.Printf("Hersteller erfolgreich erstellt oder gefunden mit der manufacturerID: %d\n", manufacturerID) + + //Device Types Gerätetyp device_type + device = createdeviceTypeWithParameter(strconv.FormatInt(manufacturerID, 10), "MainController", "MainController", "1") + id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/device-types/", device) + if err != nil { + log.Printf("Fehler beim erstellen des Gerätetyps: %v", err) + return err + } + deviceTypeID := id + log.Printf("Gerätetyp erfolgreich erstellt oder gefunden mit der deviceTypeID: %d\n", deviceTypeID) + + //deviceTypeID = 16 + //log.Printf("Hacki lösung DeviceRoleID manuell ändern: %d\n", deviceTypeID) //TODO + + //device-roles Geräterolle + device = createDeviceRoleWithParameter("HauptController", "HauptController", "Ganz wichtig Kiste", "ff0000", "offline") + id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/device-roles/", device) + if err != nil { + log.Printf("Fehler beim erstellen der Geräterolle: %v", err) + return err + } + deviceRoleID := id + log.Printf("Geräterolle erfolgreich erstellt oder gefunden mit der deviceRoleID: %d\n", deviceRoleID) + + device = createSiteWithParameter("Darmstadt", "darmstadt", "description", "physicalAddress", "shippingAddress", "comments", "active") + id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/sites/", device) + if err != nil { + log.Printf("Fehler beim erstellen der Geräterolle: %v", err) + return err + } + siteID := id + log.Printf("Geräterolle erfolgreich erstellt oder gefunden mit der siteID: %d\n", siteID) + + /* + for _, element := range elements.Mne { + log.Printf("element.Name: %v", element.Name) + log.Printf("element.Id: %v", element.Id) + log.Printf("element.Plugin: %v", element.Plugin) + } + */ + log.Printf(" ") + log.Printf(" ") + if elements != nil { + for _, element := range elements.Mne { + + deviceTypeID = 3 + device = createDeviceWithParameter(element.Name, strconv.FormatInt(deviceTypeID, 10), strconv.FormatInt(deviceRoleID, 10), strconv.FormatInt(siteID, 10), element.Id, element.Plugin.String(), "active") + id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/devices/", device) + if err != nil { + log.Printf("Fehler beim erstellen des Gerätes: %v", err) + return err + } else { + + log.Printf("Gerät erfolgreich erstellt oder gefunden mit der deviceID: %d\n", id) + } + + } + } else { + log.Fatalf("Der Controller hat keine Daten für mich. Weiter machen Sinnlos^^ elementss ist leer") + } + return nil +}