diff --git a/applications/inventory-manager-netbox/Main.go b/applications/inventory-manager-netbox/Main.go
index 452010a2815a519f0d80a6318b556bcc3c60b7cc..d5742ef9ae8a280e1abb74943fb14a918f7e3b70 100644
--- a/applications/inventory-manager-netbox/Main.go
+++ b/applications/inventory-manager-netbox/Main.go
@@ -9,41 +9,58 @@ import (
"code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/netboxManager"
)
-var configPathGosdn = flag.String("configGosdn", "config/config.yaml", "Pfad zur NetBox-Konfigurationsdatei")
-var configPathNetbox = flag.String("configNetbox", "config/configNetbox.yaml", "Pfad zur NetBox-Konfigurationsdatei")
+const (
+ Red = "\033[31m"
+ Green = "\033[32m"
+ Yellow = "\033[33m"
+ Blue = "\033[34m"
+ Reset = "\033[0m"
+)
func main() {
+ var configPathGosdn = flag.String("configGosdn", "config/config.yaml", "Path to the Gosdn configuration file")
+ var configPathNetbox = flag.String("configNetbox", "config/configNetbox.yaml", "Path to the NetBox configuration file")
var elementeFigure int
flag.Parse()
for {
+ start := time.Now() // Startzeit merken
//getting date from the controller.
elements, err := inventoryManager.CreateGosdnConnectionwitNetzworkElementslist(configPathGosdn)
if err != nil {
- log.Fatalf("Fehler beim Erstellen der Controller Conenction: %v", err)
+ log.Fatalf("Error creating the controller connection: %v", err)
} else {
- log.Println("Es ist alles cool!")
+ //log.Println("everything is great!")
}
- log.Println("länge von element.men: ", len(elements.Mne))
+ duration := time.Since(start) // Dauer berechnen
+ //log.Printf("Gosdn Dauer: %s\n", duration)
+ log.Println(string(Yellow), duration, Reset)
+ start = time.Now() // Startzeit merken
+
+ log.Println("length of element.men: ", len(elements.Mne))
//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, configPathNetbox)
if err != nil {
- log.Fatalf("Fehler beim Erstellen des Geräts: %v", err)
+ log.Fatalf("Error creating device: %v", err)
} else {
- log.Println("Es ist alles cool!")
+ log.Println("everything is great!")
elementeFigure = len(elements.Mne)
- log.Printf("Es sind %d elementeFigur", elementeFigure)
+ log.Printf("there are %d elementeFigur", elementeFigure)
}
} else {
- log.Printf("Der Controller hat keine Daten für mich. Weiter machen Sinnlos^^ elements ist leer")
+ log.Printf("The controller has no new data for me. Continuing is pointless^^ elements is empty")
time.Sleep(1 * time.Second)
}
+ duration = time.Since(start) // Dauer berechnen
+ //log.Printf("Netbox Dauer: %s\n", duration)
+ log.Println(string(Yellow), duration, Reset)
+
}
/*
diff --git a/applications/inventory-manager-netbox/inventoryManager/inventoryManager.go b/applications/inventory-manager-netbox/inventoryManager/inventoryManager.go
index 654355e0b5805eb730d8626a18612f9f821b5534..82ca8a3b8a0c47b3b4360ea09cdae44ab29b57ae 100644
--- a/applications/inventory-manager-netbox/inventoryManager/inventoryManager.go
+++ b/applications/inventory-manager-netbox/inventoryManager/inventoryManager.go
@@ -2,18 +2,13 @@ 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"
@@ -31,22 +26,21 @@ type InventoryManager struct {
// 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")
+ //configPathNetbox = flag.String("configNetbox", "config/configNetbox.yaml", "Path to the NetBox configuration file")
//flag.Parse()
-
- log.Printf("Config-Pfad: %s", *configFile)
+ //log.Printf("Config path: %s", *configFile)
//Reading the config file
data, err := os.ReadFile(*configFile)
if err != nil {
- log.Printf("Fehler beim Lesen der Konfigurationsdatei: %v", err)
+ 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("Fehler beim Parsen der YAML-Datei: %v", err)
+ log.Printf("Error parsing YAML file: %v", err)
return nil, err
}
/*
@@ -60,9 +54,9 @@ func CreateGosdnConnectionwitNetzworkElementslist(configFile *string) (*networke
if err != nil {
log.Fatal(err)
}
- //log.Print(invManager) //i dont know what this is
+ //log.Print(invManager)
- //gibt die Liste mit geräte vom Controller aus.
+ //Returning the list of devices from the controller.
elements := listRunningNetworkElements(invManager)
return elements, nil
@@ -116,7 +110,7 @@ func listRunningNetworkElements(i *InventoryManager) *networkelement.GetAllRespo
elements, err := api.GetNetworkElements(i.sessionContext, i.controllerAddress, i.pndID)
if err != nil {
- logrus.Errorf("Fehler beim Abrufen der Netzwerkelemente: %s", err.Error())
+ logrus.Errorf("Error retrieving network elements: %s", err.Error())
return nil
}
/*
diff --git a/applications/inventory-manager-netbox/netboxManager/netboxDinge.go b/applications/inventory-manager-netbox/netboxManager/netboxDinge.go
deleted file mode 100644
index 8290e61414f93f3e21106a92df557c6d798a0519..0000000000000000000000000000000000000000
--- a/applications/inventory-manager-netbox/netboxManager/netboxDinge.go
+++ /dev/null
@@ -1,162 +0,0 @@
-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
index c60d608b5666582f40d1074534614c5e8a421e26..67d22bcd85798e0d2b6772e7566e8dffaa61eb5c 100644
--- a/applications/inventory-manager-netbox/netboxManager/netboxManager.go
+++ b/applications/inventory-manager-netbox/netboxManager/netboxManager.go
@@ -15,134 +15,22 @@ import (
"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)
+ //log.Printf("The URL is: %s", url)
// JSON kodieren
body, err := json.Marshal(device)
if err != nil {
- log.Fatalf("JSON-Fehler: %v", err)
+ log.Fatalf("JSON error: %v", err)
return 0, err
}
// HTTP-Request vorbereiten
req, err := http.NewRequest("POST", url, bytes.NewReader(body))
if err != nil {
- log.Fatalf("Request-Fehler: %v", err)
+ log.Fatalf("Request error: %v", err)
return 0, err
}
@@ -152,7 +40,7 @@ func Netzworhandling(netboxURL, apiToken, api string, device map[string]interfac
// Request senden
resp, err := http.DefaultClient.Do(req)
if err != nil {
- log.Fatalf("Sende-Fehler: %v", err)
+ log.Fatalf("Sending error: %v", err)
return 0, err
}
defer resp.Body.Close()
@@ -160,14 +48,14 @@ func Netzworhandling(netboxURL, apiToken, api string, device map[string]interfac
// Ü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))
+ log.Printf("HTTP error: %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)
+ log.Printf("Response parsing: %v", err)
//return 0, err
}
@@ -183,7 +71,7 @@ func Netzworhandling(netboxURL, apiToken, api string, device map[string]interfac
//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)
+ log.Println("URL to search for name is: ", queryURL)
reqGet, err := http.NewRequest("GET", queryURL, nil)
if err != nil {
@@ -194,14 +82,14 @@ func Netzworhandling(netboxURL, apiToken, api string, device map[string]interfac
respGet, err := http.DefaultClient.Do(reqGet)
if err != nil {
- log.Printf("GET-Fehler: %v", err)
+ log.Printf("GET error: %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)
+ log.Printf("GET response parsing: %v", err)
return 0, err
}
@@ -214,49 +102,48 @@ func Netzworhandling(netboxURL, apiToken, api string, device map[string]interfac
}
}
- log.Printf("Kein Gerät mit dem Namen gefunden.")
+ log.Printf("No device found with the name")
} else {
if model, ok := device["model"].(string); ok {
- //log.Println("Kein Gerät mit dem Model gefunden:", model)
//log.Println("Keine ID erhalten – versuche bestehendes Gerät mit Model zu finden:", model)
queryURL := "http://" + netboxURL + "/api" + api + "?model=" + model
- log.Println("url zum model suchen lautet: ", queryURL)
+ log.Println("URL to search for model is: ", queryURL)
reqGet, err := http.NewRequest("GET", queryURL, nil)
if err != nil {
- log.Printf("GET-Request-Fehler: %v", err)
+ log.Printf("GET request error: %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)
+ log.Printf("GET error: %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)
+ log.Printf("GET response 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))
+ log.Printf("Existing device found with ID: %d", int64(id))
return int64(id), nil
}
}
}
- log.Printf("Kein Gerät mit dem Model gefunden.")
+ log.Printf("No device found with this model")
}
}
- log.Printf("keine ID in Antwort gefunden und kein Gerät per Namen auffindbar")
+ log.Printf("No ID found in response and no device can be found by name or model")
return 0, nil
}
@@ -265,62 +152,63 @@ func FeedNetbox(elements *networkelement.GetAllResponse, configPathNetbox *strin
flag.Parse()
- log.Printf("Config-Pfad: %s", *configPathNetbox)
+ //log.Printf("Config path: %s", *configPathNetbox)
- // Config Datei lesen
+ // Read config file
data, err := os.ReadFile(*configPathNetbox)
if err != nil {
- log.Printf("Fehler beim Lesen der Konfigurationsdatei: %v", err)
+ log.Printf("Error reading configuration file: %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)
+ log.Printf("Error parsing Netbox Config / YAML file: %v", err)
return err
}
- log.Printf("Netbox Config Adresse: %v", netboxconfig.NetboxAddress)
- log.Printf("Netbox Config Token: %v", netboxconfig.ApiToken)
+ //log.Printf("Netbox Config Adresse: %v", netboxconfig.NetboxAddress)
+ //log.Printf("Netbox Config Token: %v", netboxconfig.ApiToken)
//Manufacturers Hersteller
device = createManufacturerWithParameter("Uni Controller", "Uni-Controller", "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)
+ log.Printf("Error creating a manufacturer: %v", err)
return err
}
manufacturerID := id
- log.Printf("Hersteller erfolgreich erstellt oder gefunden mit der manufacturerID: %d\n", manufacturerID)
+ log.Printf("Manufacturer successfully created or found with the manufacturerID: %d\n", manufacturerID)
//Device Types Gerätetyp device_type
device = createdeviceTypeWithParameter(strconv.FormatInt(manufacturerID, 10), "Main Controller", "Main-Controller", "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)
+ log.Printf("Error creating a Device Type: %v", err)
return err
}
deviceTypeID := id
- log.Printf("Gerätetyp erfolgreich erstellt oder gefunden mit der deviceTypeID: %d\n", deviceTypeID)
+ log.Printf("Device Types successfully created or found with the deviceTypeID: %d\n", deviceTypeID)
//device-roles Geräterolle
device = createDeviceRoleWithParameter("Haupt Controller", "Haupt-Controller", "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)
+ log.Printf("Error creating a Device Role: %v", err)
return err
}
deviceRoleID := id
- log.Printf("Geräterolle erfolgreich erstellt oder gefunden mit der deviceRoleID: %d\n", deviceRoleID)
+ log.Printf("Device Role successfully created or found with the deviceRoleID: %d\n", deviceRoleID)
+ //Sites Standort List
device = createSiteWithParameter("Darmstadt V1", "darmstadt-v1", "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)
+ log.Printf("Error creating a Site: %v", err)
return err
}
siteID := id
- log.Printf("Geräterolle erfolgreich erstellt oder gefunden mit der siteID: %d\n", siteID)
+ log.Printf("Site successfully created or found with the siteID: %d\n", siteID)
/*
for _, element := range elements.Mne {
@@ -334,20 +222,131 @@ func FeedNetbox(elements *networkelement.GetAllResponse, configPathNetbox *strin
if elements != nil {
for _, element := range elements.Mne {
- //deviceTypeID = 3
+ //log.Printf("Test Zeugs, ich will die IP: %v", element.GetMneNotification())
+
+ log.Printf("IP Adresse, check: %v", element.TransportAddress)
+
+ //log.Printf("Testen String bekommen: %v", element.String())
+
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)
+ deviceID := id
if err != nil {
- log.Printf("Fehler beim erstellen des Gerätes: %v", err)
+ log.Printf("Error creating a Device: %v", err)
return err
} else {
-
- log.Printf("Gerät erfolgreich erstellt oder gefunden mit der deviceID: %d\n", id)
+ log.Printf("Device successfully created or found with the deviceID: %d\n", deviceID)
}
+ Newinterface := createInterfaceWithParameter("Name-eth0", strconv.FormatInt(deviceID, 10), "1000base-t", "Main uplink", true)
+ id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/ipam/ip-addresses/", Newinterface)
+ NewinterfaceID := id
+ if err != nil {
+ log.Printf("Error creating a Interface: %v", err)
+ return err
+ } else {
+ log.Printf("Interface successfully created or found with the interfaceID: %d\n", NewinterfaceID)
+ //IP hinzufügen
+ //NewIpAddress := createIPAddressWithParameter("192.168.1.10/24", strconv.FormatInt(NewinterfaceID, 10))
+ NewIpAddress := createIPAddressWithParameter(element.TransportAddress+"/32", strconv.FormatInt(NewinterfaceID, 10))
+
+ id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/devices/", NewIpAddress)
+ ipAddressID := id
+ if err != nil {
+ log.Printf("Error creating a IP Address: %v", err)
+ return err
+ } else {
+ if ipAddressID == 0 {
+ log.Printf("No IP Address created in Netbox. IP Address: %s\n", element.TransportAddress)
+ } else {
+ log.Printf("IP Address successfully created or found with the ipAddressID: %d\n", ipAddressID)
+ }
+ }
+ }
}
} else {
- log.Fatalf("Der Controller hat keine Daten für mich. Weiter machen Sinnlos^^ elementss ist leer")
+ //log.Fatalf("The controller has no data for me. Continuing is pointless. ^^ elementss is empty.")
+ }
+ return nil
+}
+
+/*
+// 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
}
+*/
diff --git a/applications/inventory-manager-netbox/netboxManager/netboxUtility.go b/applications/inventory-manager-netbox/netboxManager/netboxUtility.go
new file mode 100644
index 0000000000000000000000000000000000000000..01361246241354ee3980016a09b9b3b72219fdc3
--- /dev/null
+++ b/applications/inventory-manager-netbox/netboxManager/netboxUtility.go
@@ -0,0 +1,112 @@
+package netboxManager
+
+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 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 createManufacturerWithParameter(name, slug, description string) map[string]interface{} {
+ // /dcim/manufacturers/ Hersteller
+ device := map[string]interface{}{
+ "name": name,
+ "slug": slug,
+ "description": description,
+ }
+ 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 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
+}
+
+// createLocationWithParameter creates a Interface
+func createInterfaceWithParameter(name, deviceID, interfaceType,
+ description string, enabled bool) map[string]interface{} {
+ // /api/dcim/interfaces/ Schnittstelle List
+ device := map[string]interface{}{
+ "device": deviceID,
+ "name": name,
+ "type": interfaceType, // z. B. "1000base-t"
+ "description": description,
+ "enabled": enabled,
+ }
+ return device
+}
+
+// createIPAddressWithParameter erstellt eine IP-Adresse und weist sie einem Interface zu
+func createIPAddressWithParameter(address, interfaceID string) map[string]interface{} {
+ // /api/ipam/ip-addresses/
+ device := map[string]interface{}{
+ "address": address, // z. B. "192.168.0.1/24"
+ "assigned_object_type": "dcim.interface",
+ "assigned_object_id": interfaceID,
+ }
+ return device
+}
+
+/*
+ func createTagWithParameter(name, slug, description string) map[string]interface{} {
+ device := map[string]interface{}{
+ "name": name,
+ "slug": slug,
+ "description": description,
+ }
+ 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
+}
+*/