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
Branches
No related tags found
1 merge request!1258Inventory Manager with Netbox
Pipeline #279713 failed
......@@ -17,6 +17,9 @@ const (
Reset = "\033[0m"
)
// Ich habe einen go.mod eintrage gemacht:
// replace code.fbi.h-da.de/danet/gosdn/internal/netboxapi => ./internal/netboxapi
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")
......@@ -44,7 +47,66 @@ func main() {
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("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)
if err != nil {
log.Fatalf("Error creating device: %v", err)
} else {
......@@ -84,5 +146,6 @@ func main() {
} else {
log.Println("Es ist alles cool!")
}
*/
}
*/
\ No newline at end of file
NetboxAddress: "127.0.0.1:8000"
ApiToken: "863b22883c73de7ffc7dbb3c442b26d66b101c8e"
ApiToken: "4c7a48c2bbcc7661255b21fecf29b09d68507b3e"
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,
import (
netbox "code.fbi.h-da.de/danet/gosdn/internal/netboxapi"
)
// Hilfsfunktion
func Int32Ptr(i int32) *int32 {
return &i
}
func Int64Ptr(i int64) *int64 {
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
}
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
device := map[string]interface{}{
"manufacturer": manufacturerID,
"model": model,
"slug": slug,
"u_height": uHeight,
deviceType := &netbox.WritableDeviceTypeRequest{
Model: model,
Slug: slug,
UHeight: &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
device := map[string]interface{}{
"name": name,
"slug": slug,
"description": description,
manufacturer := &netbox.ManufacturerRequest{
Name: name,
Slug: slug,
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
device := map[string]interface{}{
"name": name,
"slug": slug,
"description": description,
"color": color,
"status": active,
deviceRole := &netbox.DeviceRoleRequest{
Name: name,
Slug: slug,
Description: StringPtr(description),
Color: &color,
}
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
device := map[string]interface{}{
"name": name,
"slug": slug,
"description": description,
"physicalAddress": physicalAddress,
"shippingAddress": shippingAddress,
"comments": comments,
"status": status,
site := &netbox.WritableSiteRequest{
Name: name,
Slug: slug,
Description: StringPtr(description),
PhysicalAddress: StringPtr(physicalAddress),
ShippingAddress: StringPtr(shippingAddress),
Comments: StringPtr(comments),
//Status: &status, vielleicht brauche ich es ja doch nicht?!?!
//, status netbox.LocationStatus
}
return device
return site
}
// 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,
// CreateInterface creates an interface in NetBox
func CreateInterface(name string, deviceID netbox.BriefInterfaceRequestDevice, interfaceType netbox.InterfaceTypeValue, description string, enabled bool) *netbox.WritableInterfaceRequest {
interrface := &netbox.WritableInterfaceRequest{
Name: name,
Device: deviceID,
Type: interfaceType,
Description: StringPtr(description),
Enabled: &enabled,
}
return device
return interrface
}
// createIPAddressWithParameter erstellt eine IP-Adresse und weist sie einem Interface zu
func createIPAddressWithParameter(address, interfaceID string) map[string]interface{} {
// CreateIPAddress creates an IP address in NetBox
func CreateIPAddress(address string, interfaceID int64) *netbox.WritableIPAddressRequest {
assignedType := "ipam.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,
ip := &netbox.WritableIPAddressRequest{
Address: address,
AssignedObjectType: *netbox.NewNullableString(&assignedType),
AssignedObjectId: *netbox.NewNullableInt64(&interfaceID),
}
return device
return ip
}
/*
func createTagWithParameter(name, slug, description string) map[string]interface{} {
device := map[string]interface{}{
"name": name,
"slug": slug,
"description": description,
}
return device
// 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)
}
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
device := map[string]interface{}{
"model": model,
"partNumber": partNumber,
//"weight" : "9",
//"weight_unit": "KiloGramm",
"description": description,
"comments": comments,
"manufacturer": manufacturerID,
moduleType := &models.ModuleType{
Model: model,
PartNumber: partNumber,
Description: description,
Comments: comments,
Manufacturer: &models.NestedManufacturer{ID: 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