Skip to content
Snippets Groups Projects
Commit b75f99b2 authored by Fabian Herbert's avatar Fabian Herbert
Browse files

not perfect, but on a good way. The Local Netbox api is missing

parent 1f5d49da
No related branches found
No related tags found
1 merge request!1258Inventory Manager with Netbox
Pipeline #279713 failed
...@@ -17,6 +17,9 @@ const ( ...@@ -17,6 +17,9 @@ const (
Reset = "\033[0m" Reset = "\033[0m"
) )
// Ich habe einen go.mod eintrage gemacht:
// replace code.fbi.h-da.de/danet/gosdn/internal/netboxapi => ./internal/netboxapi
func main() { func main() {
var configPathGosdn = flag.String("configGosdn", "config/config.yaml", "Path to the Gosdn configuration file") 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 configPathNetbox = flag.String("configNetbox", "config/configNetbox.yaml", "Path to the NetBox configuration file")
...@@ -44,7 +47,66 @@ func main() { ...@@ -44,7 +47,66 @@ func main() {
if len(elements.Mne) != elementeFigure { if len(elements.Mne) != elementeFigure {
//log.Printf("Es wurden %d Elemente gefunden", len(elementss.Mne)) //log.Printf("Es wurden %d Elemente gefunden", len(elementss.Mne))
//take the date into Netbox //take the date into Netbox
err = netboxManager.FeedNetbox(elements, configPathNetbox)
if err != nil {
log.Fatalf("Error creating device: %v", err)
} else {
log.Println("everything is great!")
elementeFigure = len(elements.Mne)
log.Printf("there are %d elementeFigur", elementeFigure)
}
} else {
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)
}
}
/*
func main2() {
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("Error creating the controller connection: %v", err)
} else {
//log.Println("everything is great!")
}
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) err = netboxManager.FeedNetbox(elements, configPathNetbox)
if err != nil { if err != nil {
log.Fatalf("Error creating device: %v", err) log.Fatalf("Error creating device: %v", err)
} else { } else {
...@@ -84,5 +146,6 @@ func main() { ...@@ -84,5 +146,6 @@ func main() {
} else { } else {
log.Println("Es ist alles cool!") log.Println("Es ist alles cool!")
} }
*/
} }
*/
\ No newline at end of file
NetboxAddress: "127.0.0.1:8000" NetboxAddress: "127.0.0.1:8000"
ApiToken: "863b22883c73de7ffc7dbb3c442b26d66b101c8e" ApiToken: "4c7a48c2bbcc7661255b21fecf29b09d68507b3e"
package netboxManager package netboxManager
import ( import (
"bytes" "context"
"encoding/json"
"flag"
"io"
"log" "log"
"net/http"
"os" "os"
"strconv"
"code.fbi.h-da.de/danet/gosdn/api/go/gosdn/networkelement" "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/applications/inventory-manager-netbox/config"
netboxapi "code.fbi.h-da.de/danet/gosdn/internal/netboxapi"
"gopkg.in/yaml.v3" "gopkg.in/yaml.v3"
) )
func Netzworhandling(netboxURL, apiToken, api string, device map[string]interface{}) (int64, error) { func FeedNetbox(elements *networkelement.GetAllResponse, configPathNetbox *string) error {
// Ziel-URL vorbereiten var manufacturerID int32
url := "http://" + netboxURL + "/api" + api var deviceTypeID int32
//log.Printf("The URL is: %s", url) var deviceRoleID int32
var siteID int32
var deviceID int32
var ifaceID int32
var ipID int32
//ctx := context.Background()
// JSON kodieren data, err := os.ReadFile(*configPathNetbox)
body, err := json.Marshal(device)
if err != nil { if err != nil {
log.Fatalf("JSON error: %v", err) log.Printf("Error reading configuration file: %v", err)
return 0, err return err
} }
// HTTP-Request vorbereiten // YAML in Config-Struct einlesen
req, err := http.NewRequest("POST", url, bytes.NewReader(body)) netboxconfig := &config.NetboxConfig{}
if err != nil { if err := yaml.Unmarshal(data, netboxconfig); err != nil {
log.Fatalf("Request error: %v", err) log.Printf("Error parsing Netbox Config / YAML file: %v", err)
return 0, err return err
} }
log.Printf("Netbox Config Adresse: %v", netboxconfig.NetboxAddress)
log.Printf("Netbox Config Token: %v", netboxconfig.ApiToken)
req.Header.Set("Content-Type", "application/json") client := netboxapi.NewAPIClientFor("http://"+netboxconfig.NetboxAddress, netboxconfig.ApiToken)
req.Header.Set("Authorization", "Token "+apiToken)
// Request senden manufacturerID = makeManufacturer(client)
resp, err := http.DefaultClient.Do(req)
if err != nil {
log.Fatalf("Sending error: %v", err)
return 0, err
}
defer resp.Body.Close()
// Überprüfe den Statuscode deviceTypeID = makeDeviceType(client, manufacturerID)
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
bodyBytes, _ := io.ReadAll(resp.Body)
log.Printf("HTTP error: %d - %s", resp.StatusCode, string(bodyBytes))
//return 0, err
}
// Antwort dekodieren deviceRoleID = makeDeviceRole(client)
var result map[string]interface{}
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
log.Printf("Response parsing: %v", err)
//return 0, err
}
// ID extrahieren siteID = makeSite(client)
if id, ok := result["id"].(float64); ok {
return int64(id), nil
}
// Wenn ID fehlt: Fallback → über Gerätename suchen if (manufacturerID == 0) || (deviceTypeID == 0) || (deviceRoleID == 0) || (siteID == 0) {
if name, ok := device["name"].(string); ok { log.Printf("ich kann kein Gerät hinzufügen, weil ich nicht alle ID habe")
return err
} else {
if elements != nil {
for _, element := range elements.Mne {
deviceID = makeDevice(client, element.Name, deviceTypeID, deviceRoleID, siteID, element.Id, element.Plugin.String(), "active")
//log.Println("Kein Gerät mit dem Namen gefunden:", name) interfaceType := netboxapi.InterfaceTypeValue("1000base-t")
//log.Println("Keine ID erhalten – versuche bestehendes Gerät mit Namen zu finden:", name) ifaceID = makeInterface(client, "eth0", deviceID, interfaceType, "Uplink-Port", true)
ipID = int32(makeIPAddress(client, "192.168.1.10/24", int64(ifaceID)))
queryURL := "http://" + netboxURL + "/api" + api + "?name=" + name
log.Println("URL to search for name is: ", queryURL)
reqGet, err := http.NewRequest("GET", queryURL, nil) log.Printf("Gerät erstellt createdDevice: %v ", deviceID)
if err != nil { log.Printf("Interface erstellt mit der ID: %v ", ifaceID)
log.Printf("GET-Request-Fehler: %v", err) log.Printf("IP Adresse erstellt mit der ID: %v ", ipID)
return 0, err
}
reqGet.Header.Set("Authorization", "Token "+apiToken)
respGet, err := http.DefaultClient.Do(reqGet) }
if err != nil {
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 response parsing: %v", err)
return 0, err
} }
}
log.Printf("Gerät erstellt createdDevice: %v ", deviceID)
return nil
}
if results, ok := getResult["results"].([]interface{}); ok && len(results) > 0 { /* if elements != nil {
if first, ok := results[0].(map[string]interface{}); ok { for _, element := range elements.Mne {
if id, ok := first["id"].(float64); ok {
log.Printf("Bestehendes Gerät gefunden mit ID: %d", int64(id))
return int64(id), nil
}
}
}
log.Printf("No device found with the name") //log.Printf("Test Zeugs, ich will die IP: %v", element.GetMneNotification())
} else {
if model, ok := device["model"].(string); ok { log.Printf("IP Adresse, check: %v", element.TransportAddress)
//log.Println("Keine ID erhalten – versuche bestehendes Gerät mit Model zu finden:", model)
queryURL := "http://" + netboxURL + "/api" + api + "?model=" + model //log.Printf("Testen String bekommen: %v", element.String())
log.Println("URL to search for model is: ", queryURL)
reqGet, err := http.NewRequest("GET", queryURL, nil) device = createDeviceWithParameter(element.Name, strconv.FormatInt(deviceTypeID, 10), strconv.FormatInt(deviceRoleID, 10), strconv.FormatInt(siteID, 10), element.Id, element.Plugin.String(), "active")
if err != nil { id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/devices/", device)
log.Printf("GET request error: %v", err) deviceID := id
return 0, err if err != nil {
} log.Printf("Error creating a Device: %v", err)
reqGet.Header.Set("Authorization", "Token "+apiToken) return err
} else {
log.Printf("Device successfully created or found with the deviceID: %d\n", deviceID)
}
respGet, err := http.DefaultClient.Do(reqGet) 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 { if err != nil {
log.Printf("GET error: %v", err) log.Printf("Error creating a IP Address: %v", err)
return 0, err return err
} } else {
defer respGet.Body.Close() if ipAddressID == 0 {
log.Printf("No IP Address created in Netbox. IP adress: %s\n", element.TransportAddress)
var getResult map[string]interface{} } else {
if err := json.NewDecoder(respGet.Body).Decode(&getResult); err != nil { log.Printf("IP Address successfully created or found with the ipAddressID: %d\n", ipAddressID)
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("Existing device found with ID: %d", int64(id))
return int64(id), nil
}
} }
} }
log.Printf("No device found with this model")
} }
} }
} else {
log.Printf("No ID found in response and no device can be found by name or model") //log.Fatalf("The controller has no data for me. Continuing is pointless. ^^ elementss is empty.")
return 0, nil
} }
return nil
func FeedNetbox(elements *networkelement.GetAllResponse, configPathNetbox *string) error { */
var device map[string]interface{}
flag.Parse()
//log.Printf("Config path: %s", *configPathNetbox) func makeManufacturer(client *netboxapi.APIClient) int32 {
var ManufacturerID int32
ManufacturerID = 0
slug := "EindeutigerName4"
manufacturer := CreateManufacturer("Grosse Box hersteller4", slug, "Wichtig gros und ganz alleine da oben")
// Read config file //createdManufacturer, reqManufacturer, err := client.DcimAPI.DcimManufacturersCreate(context.Background()).ManufacturerRequest(*manufacturer).Execute()
data, err := os.ReadFile(*configPathNetbox) created, resp, err := client.DcimAPI.DcimManufacturersCreate(context.Background()).ManufacturerRequest(*manufacturer).Execute()
if err != nil { if err != nil {
log.Printf("Error reading configuration file: %v", err) log.Printf("Fehler beim Erstellen des Herstellers: %v", err)
return err log.Printf("Fehler beim Erstellen des Herstellers, reqManufacturer: %v", resp.Status)
//suche nach slug
manufacturerList, resp, err := client.DcimAPI.DcimManufacturersList(context.Background()).Slug([]string{slug}).Execute()
if err != nil {
log.Printf("Fehler beim Abfragen des Herstellers: %v", err)
//return err
}
if len(manufacturerList.Results) > 0 {
existingManufacturer := manufacturerList.Results[0]
ManufacturerID = existingManufacturer.Id
log.Printf("Hersteller existiert bereits mit ID: %d", ManufacturerID)
log.Printf("Hersteller existiert bereits mit der URL: %v", existingManufacturer.Url)
} else {
log.Printf("Hersteller mit Slug '%s' nicht gefunden.", slug)
log.Printf("Fehler: %v", resp.Status)
}
} else {
ManufacturerID = created.Id
log.Printf("Jippi, Herstller angelegt: %v", ManufacturerID)
log.Printf("Jippi, Die Link zu dem Gerät lautet: %v", created.Url)
} }
return ManufacturerID
}
// YAML in Config-Struct einlesen func makeDeviceType(client *netboxapi.APIClient, manufacturerID int32) int32 {
netboxconfig := &config.NetboxConfig{} var deviceTypeID int32 = 0
if err := yaml.Unmarshal(data, netboxconfig); err != nil { slug := "eindeutige-id-slug" // genau so wie du ihn in CreateDeviceType übergibst
log.Printf("Error parsing Netbox Config / YAML file: %v", err) model := "model"
return err uHeight := float64(5)
}
//log.Printf("Netbox Config Adresse: %v", netboxconfig.NetboxAddress)
//log.Printf("Netbox Config Token: %v", netboxconfig.ApiToken)
//Manufacturers Hersteller manufacturerRef := netboxapi.Int32AsBriefDeviceTypeRequestManufacturer(&manufacturerID)
device = createManufacturerWithParameter("Uni Controller", "Uni-Controller", "Die Wichtige große Box. nicht ausschalten") deviceType := CreateDeviceType(manufacturerRef, model, slug, uHeight)
id, err := Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/manufacturers/", device)
if err != nil {
log.Printf("Error creating a manufacturer: %v", err)
return err
}
manufacturerID := id
log.Printf("Manufacturer successfully created or found with the manufacturerID: %d\n", manufacturerID)
//Device Types Gerätetyp device_type created, resp, err := client.DcimAPI.DcimDeviceTypesCreate(context.Background()).
device = createdeviceTypeWithParameter(strconv.FormatInt(manufacturerID, 10), "Main Controller", "Main-Controller", "1") WritableDeviceTypeRequest(*deviceType).
id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/device-types/", device) Execute()
if err != nil {
log.Printf("Error creating a Device Type: %v", err)
return err
}
deviceTypeID := id
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 { if err != nil {
log.Printf("Error creating a Device Role: %v", err) log.Printf("Fehler beim Erstellen des Gerätetyps: %v", err)
return err log.Printf("Fehler beim Erstellen des Gerätetyps, reqDeviceType: %v", resp.Status)
}
deviceRoleID := id
log.Printf("Device Role successfully created or found with the deviceRoleID: %d\n", deviceRoleID)
//Sites Standort List // versuche über Slug zu finden
device = createSiteWithParameter("Darmstadt V1", "darmstadt-v1", "description", "physicalAddress", "shippingAddress", "comments", "active") list, resp, err := client.DcimAPI.DcimDeviceTypesList(context.Background()).Slug([]string{slug}).Execute()
id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/sites/", device) if err != nil {
if err != nil { log.Printf("Fehler beim Abfragen des Device Types: %v", err)
log.Printf("Error creating a Site: %v", err) } else if len(list.Results) > 0 {
return err existing := list.Results[0]
} deviceTypeID = existing.Id
siteID := id log.Printf("Device Type existiert bereits mit ID: %d", deviceTypeID)
log.Printf("Site successfully created or found with the siteID: %d\n", siteID) log.Printf("Device Type existiert bereits unter: %v", existing.Url)
} else {
/* log.Printf("Kein Device Type mit Slug '%s' gefunden.", slug)
for _, element := range elements.Mne { log.Printf("Fehler: %v", resp.Status)
log.Printf("element.Name: %v", element.Name)
log.Printf("element.Id: %v", element.Id)
log.Printf("element.Plugin: %v", element.Plugin)
} }
*/ } else {
log.Printf(" ") deviceTypeID = created.Id
log.Printf(" ") log.Printf("Gerätetyp erfolgreich angelegt: ID %d", deviceTypeID)
if elements != nil { log.Printf("URL zum Gerätetyp: %s", created.Url)
for _, element := range elements.Mne { }
return deviceTypeID
}
//log.Printf("Test Zeugs, ich will die IP: %v", element.GetMneNotification()) func makeDeviceRole(client *netboxapi.APIClient) int32 {
var deviceRoleID int32 = 0
slug := "grossUndWichtig" // muss slug-konform sein (keine Leerzeichen, Kleinbuchstaben)
log.Printf("IP Adresse, check: %v", element.TransportAddress) role := CreateDeviceRole("Wichtige Box", slug, "Ist WohlWichtigGenug, damit es hier ist", "ff0000")
//log.Printf("Testen String bekommen: %v", element.String()) created, resp, err := client.DcimAPI.DcimDeviceRolesCreate(context.Background()).
DeviceRoleRequest(*role).
Execute()
device = createDeviceWithParameter(element.Name, strconv.FormatInt(deviceTypeID, 10), strconv.FormatInt(deviceRoleID, 10), strconv.FormatInt(siteID, 10), element.Id, element.Plugin.String(), "active") if err != nil {
id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/devices/", device) log.Printf("Fehler beim Erstellen der Device Role: %v", err)
deviceID := id log.Printf("Fehlerhafte Antwort: %v", resp.Status)
if err != nil {
log.Printf("Error creating a Device: %v", err)
return err
} else {
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) // versuche, die Rolle über den Slug zu finden
id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/ipam/ip-addresses/", Newinterface) list, resp, err := client.DcimAPI.DcimDeviceRolesList(context.Background()).Slug([]string{slug}).Execute()
NewinterfaceID := id if err != nil {
if err != nil { log.Printf("Fehler beim Abfragen der Device Role: %v", err)
log.Printf("Error creating a Interface: %v", err) } else if len(list.Results) > 0 {
return err existing := list.Results[0]
} else { deviceRoleID = existing.Id
log.Printf("Interface successfully created or found with the interfaceID: %d\n", NewinterfaceID) log.Printf("Device Role existiert bereits mit ID: %d", deviceRoleID)
//IP hinzufügen log.Printf("Device Role URL: %s", existing.Url)
//NewIpAddress := createIPAddressWithParameter("192.168.1.10/24", strconv.FormatInt(NewinterfaceID, 10)) } else {
NewIpAddress := createIPAddressWithParameter(element.TransportAddress+"/32", strconv.FormatInt(NewinterfaceID, 10)) log.Printf("Keine Device Role mit Slug '%s' gefunden.", slug)
log.Printf("Fehler: %v", resp.Status)
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 { } else {
//log.Fatalf("The controller has no data for me. Continuing is pointless. ^^ elementss is empty.") deviceRoleID = created.Id
log.Printf("Device Role erfolgreich erstellt: ID %d", deviceRoleID)
log.Printf("Device Role URL: %s", created.Url)
} }
return nil
return deviceRoleID
} }
/* func makeSite(client *netboxapi.APIClient) int32 {
// create one Device in Netbox with JSON and HTTP var siteID int32 = 0
func Netboxmanager() error { slug := "darmstadt-der-groe" // slug muss URL-konform sein
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 site := CreateSite(
netboxconfig := &config.NetboxConfig{} "Darmstadt v2",
if err := yaml.Unmarshal(data, netboxconfig); err != nil { slug,
log.Printf("Fehler beim Parsen der YAML-Datei: %v", err) "Ort brauchen eine beschreibung",
return err "In der Uni und dann in den Keller oder ins Labor",
} "Da so und dann Links",
log.Printf("Netbox Config Adresse: %v", netboxconfig.NetboxAddress) "comments",
log.Printf("Netbox Config Token: %v", netboxconfig.ApiToken) )
//Manufacturers Hersteller created, resp, err := client.DcimAPI.DcimSitesCreate(context.Background()).
device = createManufacturerWithParameter("HerstellerName2", "slug2", "description") WritableSiteRequest(*site).
id, err := Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/manufacturers/", device) Execute()
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 { if err != nil {
log.Printf("Fehler beim erstellen des Gerätetyps: %v", err) log.Printf("Fehler beim Erstellen der Site: %v", err)
return err log.Printf("Fehlerhafte Antwort: %v", resp.Status)
// versuche, die Site über den Slug zu finden
list, resp, err := client.DcimAPI.DcimSitesList(context.Background()).Slug([]string{slug}).Execute()
if err != nil {
log.Printf("Fehler beim Abfragen der Site: %v", err)
} else if len(list.Results) > 0 {
existing := list.Results[0]
siteID = existing.Id
log.Printf("Site existiert bereits mit ID: %d", siteID)
log.Printf("Site URL: %s", existing.Url)
} else {
log.Printf("Keine Site mit Slug '%s' gefunden.", slug)
log.Printf("Fehler: %v", resp.Status)
}
} else {
siteID = created.Id
log.Printf("Site erfolgreich erstellt: ID %d", siteID)
log.Printf("Site URL: %s", created.Url)
} }
deviceTypeID := id
log.Printf("Gerätetyp erfolgreich erstellt oder gefunden mit der deviceTypeID: %d\n", deviceTypeID)
//deviceTypeID = 16 return siteID
//log.Printf("Hacki lösung DeviceRoleID manuell ändern: %d\n", deviceTypeID) //TODO }
func makeDevice(client *netboxapi.APIClient, name string, deviceTypeID, roleID, siteID int32, serial, description, status string) int32 {
var deviceID int32 = 0
// Gerät anlegen
device := CreateDevice(name, deviceTypeID, roleID, siteID, serial, description, status)
// Versuch, das Gerät zu erstellen
createdDevice, resp, err := client.DcimAPI.
DcimDevicesCreate(context.Background()).
WritableDeviceWithConfigContextRequest(*device).
Execute()
//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 { if err != nil {
log.Printf("Fehler beim erstellen der Geräterolle: %v", err) log.Printf("Fehler beim Erstellen des Geräts: %v", err)
return err if resp != nil {
log.Printf("HTTP-Status: %s", resp.Status)
}
// Fallback: Suche nach vorhandenem Gerät anhand Name
existing, resp, err := client.DcimAPI.
DcimDevicesList(context.Background()).
Name([]string{name}).
Execute()
if err != nil {
log.Printf("Fehler bei der Gerätesuche: %v", err)
} else if len(existing.Results) > 0 {
deviceID = existing.Results[0].Id
log.Printf("Gerät existiert bereits: ID %d, URL: %s", deviceID, existing.Results[0].Url)
} else {
log.Printf("Kein bestehendes Gerät mit Name '%s' gefunden.", name)
log.Printf("Status: %d", resp.StatusCode)
}
} else {
deviceID = createdDevice.Id
log.Printf("Gerät erfolgreich erstellt: ID %d, URL: %s", deviceID, createdDevice.Url)
} }
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") return deviceID
id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/sites/", device) }
func makeInterface(client *netboxapi.APIClient, name string, deviceID int32, interfaceType netboxapi.InterfaceTypeValue, description string, enabled bool) int32 {
var interfaceID int32 = 0
// NetBox erwartet ein BriefInterfaceRequestDevice
deviceRef := netboxapi.Int32AsBriefInterfaceRequestDevice(&deviceID)
iface := CreateInterface(name, deviceRef, interfaceType, description, enabled)
createdIface, resp, err := client.DcimAPI.
DcimInterfacesCreate(context.Background()).
WritableInterfaceRequest(*iface).
Execute()
if err != nil { if err != nil {
log.Printf("Fehler beim erstellen der Geräterolle: %v", err) log.Printf("Fehler beim Erstellen der Schnittstelle: %v", err)
return err if resp != nil {
log.Printf("HTTP Status: %s", resp.Status)
}
// Suche nach bestehender Schnittstelle mit Name + Device
existing, resp, err := client.DcimAPI.
DcimInterfacesList(context.Background()).
Name([]string{name}).
DeviceId([]int32{deviceID}).
Execute()
if err != nil {
log.Printf("Fehler bei Schnittstellen-Suche: %v", err)
} else if len(existing.Results) > 0 {
interfaceID = existing.Results[0].Id
log.Printf("Schnittstelle existiert bereits: ID %d, URL: %s", interfaceID, existing.Results[0].Url)
} else {
log.Printf("Keine bestehende Schnittstelle '%s' gefunden für Device-ID %d.", name, deviceID)
log.Printf("Status: %d", resp.StatusCode)
}
} else {
interfaceID = createdIface.Id
log.Printf("Schnittstelle erfolgreich erstellt: ID %d, URL: %s", interfaceID, createdIface.Url)
} }
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") return interfaceID
id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/devices/", device) }
func makeIPAddress(client *netboxapi.APIClient, address string, interfaceID int64) int64 {
var ipID int64 = 0
ip := CreateIPAddress(address, interfaceID)
createdIP, resp, err := client.IpamAPI.
IpamIpAddressesCreate(context.Background()).
WritableIPAddressRequest(*ip).
Execute()
if err != nil { if err != nil {
log.Printf("Fehler beim erstellen des Gerätes: %v", err) log.Printf("Fehler beim Erstellen der IP-Adresse: %v", err)
return err if resp != nil {
log.Printf("HTTP Status: %s", resp.Status)
}
// Suche nach bereits existierender IP-Adresse
existing, resp, err := client.IpamAPI.
IpamIpAddressesList(context.Background()).
Address([]string{address}).
Execute()
if err != nil {
log.Printf("Fehler beim Suchen nach IP-Adresse '%s': %v", address, err)
} else if len(existing.Results) > 0 {
ipID = int64(existing.Results[0].Id) // für Fehler 8
log.Printf("IP-Adresse existiert bereits: ID %d, URL: %s", ipID, existing.Results[0].Url)
} else {
log.Printf("Keine bestehende IP-Adresse gefunden: %s", address)
log.Printf("Status: %d", resp.StatusCode)
}
} else {
ipID := int64(createdIP.Id)
log.Printf("IP-Adresse erfolgreich erstellt: ID %d, URL: %s", ipID, createdIP.Url)
} }
deviceID := id
log.Printf("Gerät erfolgreich erstellt oder gefunden mit der deviceID: %d\n", deviceID)
return nil return ipID
} }
*/
package netboxManager package netboxManager
func createDeviceWithParameter(name, deviceTypeID, deviceRoleID, siteID, serial, description, status string) map[string]interface{} { import (
// /api/dcim/devices/ Gerät netbox "code.fbi.h-da.de/danet/gosdn/internal/netboxapi"
device := map[string]interface{}{ )
"name": name,
"device_type": deviceTypeID, // Hilfsfunktion
"role": deviceRoleID, func Int32Ptr(i int32) *int32 {
"site": siteID, return &i
"serial": serial, }
"description": description, func Int64Ptr(i int64) *int64 {
"status": status, return &i
}
func StringPtr(s string) *string {
return &s
}
// createDevice creates a device in NetBox
func CreateDevice(name string, deviceTypeID, roleID, siteID int32, serial, description, status string) *netbox.WritableDeviceWithConfigContextRequest {
// /dcim/device-types/ Gerätetyp
device := &netbox.WritableDeviceWithConfigContextRequest{
Name: *netbox.NewNullableString(&name),
Role: netbox.DeviceWithConfigContextRequestRole{Int32: Int32Ptr(roleID)},
Site: netbox.DeviceWithConfigContextRequestSite{Int32: Int32Ptr(siteID)},
DeviceType: netbox.DeviceBayTemplateRequestDeviceType{Int32: Int32Ptr(deviceTypeID)},
Serial: &serial,
Description: &description,
Status: (*netbox.DeviceStatusValue)(&status),
} }
return device return device
} }
func createdeviceTypeWithParameter(manufacturerID, model, slug, uHeight string) map[string]interface{} { // CreateDeviceType creates a deicetype in NetBox
func CreateDeviceType(manufacturerID netbox.BriefDeviceTypeRequestManufacturer, model, slug string, uHeight float64) *netbox.WritableDeviceTypeRequest {
// /dcim/device-types/ Gerätetyp // /dcim/device-types/ Gerätetyp
device := map[string]interface{}{ deviceType := &netbox.WritableDeviceTypeRequest{
"manufacturer": manufacturerID, Model: model,
"model": model, Slug: slug,
"slug": slug, UHeight: &uHeight,
"u_height": uHeight, Manufacturer: manufacturerID,
} }
return device return deviceType
} }
func createManufacturerWithParameter(name, slug, description string) map[string]interface{} { // CreateManufacturer creates a manufacturer in NetBox
func CreateManufacturer(name, slug, description string) *netbox.ManufacturerRequest {
// /dcim/manufacturers/ Hersteller // /dcim/manufacturers/ Hersteller
device := map[string]interface{}{ manufacturer := &netbox.ManufacturerRequest{
"name": name, Name: name,
"slug": slug, Slug: slug,
"description": description, Description: StringPtr(description),
} }
return device return manufacturer
} }
func createDeviceRoleWithParameter(name, slug, description, color, active string) map[string]interface{} { // CreateDeviceRole creates a device role in NetBox
func CreateDeviceRole(name, slug, description, color string) *netbox.DeviceRoleRequest {
// /dcim/device-roles/ Geräterolle // /dcim/device-roles/ Geräterolle
device := map[string]interface{}{ deviceRole := &netbox.DeviceRoleRequest{
"name": name, Name: name,
"slug": slug, Slug: slug,
"description": description, Description: StringPtr(description),
"color": color, Color: &color,
"status": active,
} }
return device return deviceRole
} }
func createSiteWithParameter(name, slug, description, physicalAddress, shippingAddress, comments, status string) map[string]interface{} { // CreateSite creates a site in NetBox
func CreateSite(name, slug, description, physicalAddress, shippingAddress, comments string) *netbox.WritableSiteRequest {
// /dcim/sites/ Standorts // /dcim/sites/ Standorts
device := map[string]interface{}{ site := &netbox.WritableSiteRequest{
"name": name, Name: name,
"slug": slug, Slug: slug,
"description": description, Description: StringPtr(description),
"physicalAddress": physicalAddress, PhysicalAddress: StringPtr(physicalAddress),
"shippingAddress": shippingAddress, ShippingAddress: StringPtr(shippingAddress),
"comments": comments, Comments: StringPtr(comments),
"status": status, //Status: &status, vielleicht brauche ich es ja doch nicht?!?!
//, status netbox.LocationStatus
} }
return device return site
} }
// createLocationWithParameter creates a Interface // CreateInterface creates an interface in NetBox
func createInterfaceWithParameter(name, deviceID, interfaceType, func CreateInterface(name string, deviceID netbox.BriefInterfaceRequestDevice, interfaceType netbox.InterfaceTypeValue, description string, enabled bool) *netbox.WritableInterfaceRequest {
description string, enabled bool) map[string]interface{} {
// /api/dcim/interfaces/ Schnittstelle List interrface := &netbox.WritableInterfaceRequest{
device := map[string]interface{}{ Name: name,
"device": deviceID, Device: deviceID,
"name": name, Type: interfaceType,
"type": interfaceType, // z. B. "1000base-t" Description: StringPtr(description),
"description": description, Enabled: &enabled,
"enabled": enabled,
} }
return device return interrface
} }
// createIPAddressWithParameter erstellt eine IP-Adresse und weist sie einem Interface zu // CreateIPAddress creates an IP address in NetBox
func createIPAddressWithParameter(address, interfaceID string) map[string]interface{} { func CreateIPAddress(address string, interfaceID int64) *netbox.WritableIPAddressRequest {
assignedType := "ipam.interface"
// /api/ipam/ip-addresses/ // /api/ipam/ip-addresses/
device := map[string]interface{}{
"address": address, // z. B. "192.168.0.1/24" ip := &netbox.WritableIPAddressRequest{
"assigned_object_type": "dcim.interface", Address: address,
"assigned_object_id": interfaceID, AssignedObjectType: *netbox.NewNullableString(&assignedType),
AssignedObjectId: *netbox.NewNullableInt64(&interfaceID),
} }
return device return ip
} }
/* /*
func createTagWithParameter(name, slug, description string) map[string]interface{} { // CreateTag creates a tag in NetBox
device := map[string]interface{}{ func CreateTag(client *netbox.Client, name, slug, description string) (*models.Tag, error) {
"name": name, tag := &models.Tag{
"slug": slug, Name: name,
"description": description, Slug: slug,
} Description: description,
return device }
createdTag, err := client.Extras.ExtrasTagsCreate(
extras.NewExtrasTagsCreateParams().WithData(tag).WithContext(context.Background()),
nil,
)
if err != nil {
return nil, fmt.Errorf("Fehler beim Erstellen des Tags: %w", err)
} }
func createModultypWithParameter(model, partNumber, description, comments, manufacturerID string) map[string]interface{} { return createdTag.Payload, nil
}
//createmodultyp creates a modultyp in NetBox
func CreateModuleType(client *netbox.Client, model, partNumber, description, comments, manufacturerID string) (*models.ModuleType, error) {
///api/dcim/module-types/ Modultypen ///api/dcim/module-types/ Modultypen
device := map[string]interface{}{ moduleType := &models.ModuleType{
"model": model, Model: model,
"partNumber": partNumber, PartNumber: partNumber,
//"weight" : "9", Description: description,
//"weight_unit": "KiloGramm", Comments: comments,
"description": description, Manufacturer: &models.NestedManufacturer{ID: manufacturerID},
"comments": comments,
"manufacturer": manufacturerID,
} }
return device
createdModuleType, err := client.Dcim.DcimModuleTypesCreate(
dcim.NewDcimModuleTypesCreateParams().WithData(moduleType).WithContext(context.Background()),
nil,
)
if err != nil {
return nil, fmt.Errorf("Fehler beim Erstellen des Modultyps: %w", err)
}
return createdModuleType.Payload, nil
}
/*
// createDevice creates a deicetype in NetBox
func CreateDeviceType(client *netbox.NetBoxAPI, manufacturerID int64, model, slug string, uHeight float64) (*models.DeviceType, error) {
// /dcim/device-types/ Gerätetyp
deviceType := &models.DeviceType{
Manufacturer: manufacturerID,
Model: &model,
Slug: &slug,
UHeight: &uHeight,
}
params := &dcim.DcimDeviceTypesCreateParams{
Data: deviceType,
Context: context.Background(),
}
created, err := client.Dcim.DcimDeviceTypesCreate(params, nil)
if err != nil {
return nil, err
}
return created.Payload, nil
}
// createDevice creates a manufacturer in NetBox
func CreateManufacturer(client *netbox.NetBoxAPI, name, slug, description string) (*models.Manufacturer, error) {
// /dcim/manufacturers/ Hersteller
manufacturer := &models.Manufacturer{
Name: &name,
Slug: &slug,
Description: description,
}
params := &dcim.DcimManufacturersCreateParams{
Data: manufacturer,
Context: context.Background(),
}
created, err := client.Dcim.DcimManufacturersCreate(params, nil)
if err != nil {
return nil, err
}
return created.Payload, nil
}
// createDevice creates a device role in NetBox
func CreateDeviceRole(client *netbox.NetBoxAPI, name, slug, description, color, status string) (*models.DeviceRole, error) {
// /dcim/device-roles/ Geräterolle
deviceRole := &models.DeviceRole{
Name: &name,
Slug: &slug,
Description: description,
Color: &color,
Status: &status,
}
params := &dcim.DcimDeviceRolesCreateParams{
Data: deviceRole,
Context: context.Background(),
}
created, err := client.Dcim.DcimDeviceRolesCreate(params, nil)
if err != nil {
return nil, err
}
return created.Payload, nil
}
// createDevice creates a site in NetBox
func CreateSite(client *netbox.NetBoxAPI, name, slug, description, physicalAddress, shippingAddress, comments, status string) (*models.Site, error) {
// /dcim/sites/ Standorts
site := &models.Site{
Name: &name,
Slug: &slug,
Description: description,
PhysicalAddress: physicalAddress,
ShippingAddress: shippingAddress,
Comments: comments,
Status: &status,
}
params := &dcim.DcimSitesCreateParams{
Data: site,
Context: context.Background(),
}
created, err := client.Dcim.DcimSitesCreate(params, nil)
if err != nil {
return nil, err
}
return created.Payload, nil
}
// CreateInterface creates an interface in NetBox
func CreateInterface(client *netbox.NetBoxAPI, name string, deviceID int64, interfaceType, description string, enabled bool) (*models.Interface, error) {
// /api/dcim/interfaces/ Schnittstelle Liste
interrface := &models.Interface{
Name: &name,
Device: &deviceID,
Type: &interfaceType, // z. B. "1000base-t"
Description: description,
Enabled: &enabled,
}
params := &dcim.DcimInterfacesCreateParams{
Data: interrface,
Context: context.Background(),
}
created, err := client.Dcim.DcimInterfacesCreate(params, nil)
if err != nil {
return nil, err
}
return created.Payload, nil
}
// CreateIPAddress creates an IP address in NetBox
func CreateIPAddress(client *netbox.NetBoxAPI, address string, interfaceID int64) (*models.IPAddress, error) {
assignedType := "dcim.interface"
// /api/ipam/ip-addresses/
ip := &models.IPAddress{
Address: &address,
AssignedObjectType: &assignedType,
AssignedObjectID: &interfaceID,
}
params := &ipam.IpamIPAddressesCreateParams{
Data: ip,
Context: context.Background(),
}
created, err := client.Ipam.IpamIPAddressesCreate(params, nil)
if err != nil {
return nil, err
}
return created.Payload, nil
}
/*
// CreateTag creates a tag in NetBox
func CreateTag(client *netbox.Client, name, slug, description string) (*models.Tag, error) {
tag := &models.Tag{
Name: name,
Slug: slug,
Description: description,
}
createdTag, err := client.Extras.ExtrasTagsCreate(
extras.NewExtrasTagsCreateParams().WithData(tag).WithContext(context.Background()),
nil,
)
if err != nil {
return nil, fmt.Errorf("Fehler beim Erstellen des Tags: %w", err)
}
return createdTag.Payload, nil
}
//createmodultyp creates a modultyp in NetBox
func CreateModuleType(client *netbox.Client, model, partNumber, description, comments, manufacturerID string) (*models.ModuleType, error) {
///api/dcim/module-types/ Modultypen
moduleType := &models.ModuleType{
Model: model,
PartNumber: partNumber,
Description: description,
Comments: comments,
Manufacturer: &models.NestedManufacturer{ID: manufacturerID},
}
createdModuleType, err := client.Dcim.DcimModuleTypesCreate(
dcim.NewDcimModuleTypesCreateParams().WithData(moduleType).WithContext(context.Background()),
nil,
)
if err != nil {
return nil, fmt.Errorf("Fehler beim Erstellen des Modultyps: %w", err)
}
return createdModuleType.Payload, nil
} }
*/ */
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment