feat(inventory): enable syncing of sites for vlans

internal/constants/constants.go

@@ -23,7 +23,7 @@ const OrphanTagName = "netbox-ssot-orphan"
 const OrphanTagColor = ColorGrey
 const OrphanTagDescription = "Tag used by netbox-ssot to mark orphaned objects"
 
-const DefaultVlanGroupName = "Default netbox-ssot vlan group"
+const DefaultVlanGroupName = "DefaultVlanGroup"
 const DefaultVlanGroupDescription = "Default netbox-ssot VlanGroup for all vlans that are not part of any other vlanGroup. This group is required for netbox-ssot vlan index to work."
 
 const DefaultArpTagName = "arp-entry"

internal/netbox/inventory/helpers.go

@@ -0,0 +1,37 @@
+package inventory
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/bl4ko/netbox-ssot/internal/constants"
+	"github.com/bl4ko/netbox-ssot/internal/netbox/objects"
+	"github.com/bl4ko/netbox-ssot/internal/utils"
+)
+
+// Inits default VlanGroup, which is required to group all Vlans that are not part of other
+// vlangroups into it. Each vlan is indexed by their (vlanGroup, vid).
+func (nbi *NetboxInventory) CreateDefaultVlanGroupForVlan(ctx context.Context, vlanSite *objects.Site) (*objects.VlanGroup, error) {
+	var vlanGroupName string
+	if vlanSite != nil {
+		vlanGroupName = fmt.Sprintf("%sDefaultVlanGroup", vlanSite.Name)
+	} else {
+		vlanGroupName = constants.DefaultVlanGroupName
+	}
+	vlanGroup, err := nbi.AddVlanGroup(ctx, &objects.VlanGroup{
+		NetboxObject: objects.NetboxObject{
+			Tags:        []*objects.Tag{nbi.SsotTag},
+			Description: constants.DefaultVlanGroupDescription,
+			CustomFields: map[string]interface{}{
+				constants.CustomFieldSourceName: nbi.SsotTag.Name,
+			},
+		},
+		Name:      vlanGroupName,
+		Slug:      utils.Slugify(constants.DefaultVlanGroupName),
+		VidRanges: []objects.VidRange{{constants.DefaultVID, constants.MaxVID}},
+	})
+	if err != nil {
+		return nil, fmt.Errorf("add vlan group: %s", err)
+	}
+	return vlanGroup, nil
+}

internal/netbox/inventory/init_items.go

@@ -527,27 +527,6 @@ func (nbi *NetboxInventory) initInterfaces(ctx context.Context) error {
 	return nil
 }
 
-// Inits default VlanGroup, which is required to group all Vlans that are not part of other
-// vlangroups into it. Each vlan is indexed by their (vlanGroup, vid).
-func (nbi *NetboxInventory) initDefaultVlanGroup(ctx context.Context) error {
-	_, err := nbi.AddVlanGroup(ctx, &objects.VlanGroup{
-		NetboxObject: objects.NetboxObject{
-			Tags:        []*objects.Tag{nbi.SsotTag},
-			Description: constants.DefaultVlanGroupDescription,
-			CustomFields: map[string]interface{}{
-				constants.CustomFieldSourceName: nbi.SsotTag.Name,
-			},
-		},
-		Name:      constants.DefaultVlanGroupName,
-		Slug:      utils.Slugify(constants.DefaultVlanGroupName),
-		VidRanges: []objects.VidRange{{constants.DefaultVID, constants.MaxVID}},
-	})
-	if err != nil {
-		return fmt.Errorf("init default vlan group: %s", err)
-	}
-	return nil
-}
-
 // Collects all vlans from Netbox API and stores them to local inventory.
 func (nbi *NetboxInventory) initVlanGroups(ctx context.Context) error {
 	nbVlanGroups, err := service.GetAll[objects.VlanGroup](ctx, nbi.NetboxAPI, "")
@@ -582,8 +561,12 @@ func (nbi *NetboxInventory) initVlans(ctx context.Context) error {
 		vlan := &nbVlans[i]
 		if vlan.Group == nil {
 			// Update all existing vlans with default vlanGroup. This only happens
-			// when there are predefined vlans in netbox.
-			vlan.Group = nbi.vlanGroupsIndexByName[constants.DefaultVlanGroupName] // This should not fail, because InitDefaultVlanGroup executes before InitVlans
+			// when there are predefined vlans in netbox. This is required because
+			// vlans are indexed by vlan group.
+			vlan.Group, err = nbi.CreateDefaultVlanGroupForVlan(nbi.Ctx, vlan.Site)
+			if err != nil {
+				return fmt.Errorf("create default vlan group for vlan: %s", err)
+			}
 			vlan, err = nbi.AddVlan(ctx, vlan)
 			if err != nil {
 				return err

internal/netbox/inventory/init_items_test.go

@@ -404,27 +404,6 @@ func TestNetboxInventory_InitInterfaces(t *testing.T) {
 	}
 }
 
-func TestNetboxInventory_InitDefaultVlanGroup(t *testing.T) {
-	type args struct {
-		ctx context.Context
-	}
-	tests := []struct {
-		name    string
-		nbi     *NetboxInventory
-		args    args
-		wantErr bool
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := tt.nbi.initDefaultVlanGroup(tt.args.ctx); (err != nil) != tt.wantErr {
-				t.Errorf("NetboxInventory.InitDefaultVlanGroup() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
 func TestNetboxInventory_InitVlanGroups(t *testing.T) {
 	type args struct {
 		ctx context.Context
@@ -992,27 +971,6 @@ func TestNetboxInventory_initInterfaces(t *testing.T) {
 	}
 }
 
-func TestNetboxInventory_initDefaultVlanGroup(t *testing.T) {
-	type args struct {
-		ctx context.Context
-	}
-	tests := []struct {
-		name    string
-		nbi     *NetboxInventory
-		args    args
-		wantErr bool
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := tt.nbi.initDefaultVlanGroup(tt.args.ctx); (err != nil) != tt.wantErr {
-				t.Errorf("NetboxInventory.initDefaultVlanGroup() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
 func TestNetboxInventory_initVlanGroups(t *testing.T) {
 	type args struct {
 		ctx context.Context

internal/netbox/inventory/inventory.go

@@ -223,7 +223,6 @@ func (nbi *NetboxInventory) Init() error {
 		nbi.initInterfaces,
 		nbi.initIPAddresses,
 		nbi.initVlanGroups,
-		nbi.initDefaultVlanGroup,
 		nbi.initPrefixes,
 		nbi.initVlans,
 		nbi.initDeviceRoles,

internal/source/common/utils.go

@@ -69,9 +69,9 @@ func MatchClusterToSite(ctx context.Context, nbi *inventory.NetboxInventory, clu
 // Function that matches vlanName to vlanGroupName using regexRelationsMap.
 //
 // In case there is no match or regexRelations is nil, it will return default VlanGroup.
-func MatchVlanToGroup(ctx context.Context, nbi *inventory.NetboxInventory, vlanName string, vlanGroupRelations map[string]string, vlanGroupSiteRelations map[string]string) (*objects.VlanGroup, error) {
+func MatchVlanToGroup(ctx context.Context, nbi *inventory.NetboxInventory, vlanName string, vlanSite *objects.Site, vlanGroupRelations map[string]string, vlanGroupSiteRelations map[string]string) (*objects.VlanGroup, error) {
 	if vlanGroupRelations == nil {
-		vlanGroup, _ := nbi.GetVlanGroup(constants.DefaultVlanGroupName)
+		vlanGroup, _ := nbi.CreateDefaultVlanGroupForVlan(ctx, vlanSite)
 		return vlanGroup, nil
 	}
 	vlanGroupName, err := utils.MatchStringToValue(vlanName, vlanGroupRelations)

internal/source/dnac/dnac_sync.go

@@ -52,7 +52,11 @@ func (ds *DnacSource) syncSites(nbi *inventory.NetboxInventory) error {
 // Syncs dnac vlans to netbox inventory.
 func (ds *DnacSource) syncVlans(nbi *inventory.NetboxInventory) error {
 	for vid, vlan := range ds.Vlans {
-		vlanGroup, err := common.MatchVlanToGroup(ds.Ctx, nbi, vlan.InterfaceName, ds.SourceConfig.VlanGroupRelations, ds.SourceConfig.VlanGroupSiteRelations)
+		vlanSite, err := common.MatchVlanToSite(ds.Ctx, nbi, vlan.InterfaceName, ds.SourceConfig.VlanSiteRelations)
+		if err != nil {
+			return fmt.Errorf("match vlan to site: %s", err)
+		}
+		vlanGroup, err := common.MatchVlanToGroup(ds.Ctx, nbi, vlan.InterfaceName, vlanSite, ds.SourceConfig.VlanGroupRelations, ds.SourceConfig.VlanGroupSiteRelations)
 		if err != nil {
 			return fmt.Errorf("vlanGroup: %s", err)
 		}
@@ -71,6 +75,7 @@ func (ds *DnacSource) syncVlans(nbi *inventory.NetboxInventory) error {
 			Name:   vlan.InterfaceName,
 			Group:  vlanGroup,
 			Vid:    vid,
+			Site:   vlanSite,
 			Tenant: vlanTenant,
 		})
 		if err != nil {
@@ -537,7 +542,11 @@ func (ds *DnacSource) syncWirelessLANs(nbi *inventory.NetboxInventory) error {
 		if err != nil {
 			return fmt.Errorf("add wirelessLANGroup %s: %s", wlanGroup, err)
 		}
-		vlanGroup, err := common.MatchVlanToGroup(ds.Ctx, nbi, wlanWirelessProfile.InterfaceName, ds.SourceConfig.VlanGroupRelations, ds.SourceConfig.VlanGroupSiteRelations)
+		vlanSite, err := common.MatchVlanToSite(ds.Ctx, nbi, wlanWirelessProfile.InterfaceName, ds.SourceConfig.VlanSiteRelations)
+		if err != nil {
+			return fmt.Errorf("match vlan to site: %s", err)
+		}
+		vlanGroup, err := common.MatchVlanToGroup(ds.Ctx, nbi, wlanWirelessProfile.InterfaceName, vlanSite, ds.SourceConfig.VlanGroupRelations, ds.SourceConfig.VlanGroupSiteRelations)
 		if err != nil {
 			return err
 		}

internal/source/fmc/fmc_sync.go

@@ -116,7 +116,13 @@ func (fmcs *FMCSource) syncVlanInterfaces(nbi *inventory.NetboxInventory, nbDevi
 			// Add vlan
 			ifaceTaggedVlans := []*objects.Vlan{}
 			if vlanIface.VID != 0 {
-				vlanGroup, err := common.MatchVlanToGroup(fmcs.Ctx, nbi, vlanIface.Name, fmcs.SourceConfig.VlanGroupRelations, fmcs.SourceConfig.VlanGroupSiteRelations)
+				// Match vlan to site
+				vlanSite, err := common.MatchVlanToSite(fmcs.Ctx, nbi, vlanIface.Name, fmcs.SourceConfig.VlanSiteRelations)
+				if err != nil {
+					return fmt.Errorf("match vlan to site: %s", err)
+				}
+				// Match vlan to group
+				vlanGroup, err := common.MatchVlanToGroup(fmcs.Ctx, nbi, vlanIface.Name, vlanSite, fmcs.SourceConfig.VlanGroupRelations, fmcs.SourceConfig.VlanGroupSiteRelations)
 				if err != nil {
 					return fmt.Errorf("match vlan to group: %s", err)
 				}
@@ -131,6 +137,7 @@ func (fmcs *FMCSource) syncVlanInterfaces(nbi *inventory.NetboxInventory, nbDevi
 					},
 					Status: &objects.VlanStatusActive,
 					Name:   vlanIface.Name,
+					Site:   vlanSite,
 					Vid:    vlanIface.VID,
 					Tenant: vlanTenent,
 					Group:  vlanGroup,

internal/source/fortigate/fortigate_sync.go

@@ -167,18 +167,18 @@ func (fs *FortigateSource) syncInterfaces(nbi *inventory.NetboxInventory) error
 			// Add Vlan for interface
 			vlanID := iface.VlanID
 			vlanName := fmt.Sprintf("Vlan%d", vlanID)
-			vlanGroup, err := common.MatchVlanToGroup(fs.Ctx, nbi, vlanName, fs.SourceConfig.VlanGroupRelations, fs.SourceConfig.VlanGroupSiteRelations)
+			vlanSite, err := common.MatchVlanToSite(fs.Ctx, nbi, vlanName, fs.SourceConfig.VlanSiteRelations)
+			if err != nil {
+				return fmt.Errorf("match vlan to site: %s", err)
+			}
+			vlanGroup, err := common.MatchVlanToGroup(fs.Ctx, nbi, vlanName, vlanSite, fs.SourceConfig.VlanGroupRelations, fs.SourceConfig.VlanGroupSiteRelations)
 			if err != nil {
 				return fmt.Errorf("match vlan to group: %s", err)
 			}
 			vlanTenant, err := common.MatchVlanToTenant(fs.Ctx, nbi, vlanName, fs.SourceConfig.VlanTenantRelations)
 			if err != nil {
 				return fmt.Errorf("match vlan to tenant: %s", err)
 			}
-			vlanSite, err := common.MatchVlanToSite(fs.Ctx, nbi, vlanName, fs.SourceConfig.VlanSiteRelations)
-			if err != nil {
-				return fmt.Errorf("match vlan to site: %s", err)
-			}
 			NBVlan, err := nbi.AddVlan(fs.Ctx, &objects.Vlan{
 				NetboxObject: objects.NetboxObject{
 					Tags: fs.SourceTags,

internal/source/ovirt/ovirt_sync.go

@@ -24,8 +24,13 @@ func (o *OVirtSource) syncNetworks(nbi *inventory.NetboxInventory) error {
 		description, _ := network.Description()
 		// TODO: handle other networks
 		if networkVlan, exists := network.Vlan(); exists {
+			// Get vlanSite from relation
+			vlanSite, err := common.MatchVlanToSite(o.Ctx, nbi, name, o.SourceConfig.VlanSiteRelations)
+			if err != nil {
+				return fmt.Errorf("match vlan to site: %s", err)
+			}
 			// Get vlanGroup from relation
-			vlanGroup, err := common.MatchVlanToGroup(o.Ctx, nbi, name, o.SourceConfig.VlanGroupRelations, o.SourceConfig.VlanGroupSiteRelations)
+			vlanGroup, err := common.MatchVlanToGroup(o.Ctx, nbi, name, vlanSite, o.SourceConfig.VlanGroupRelations, o.SourceConfig.VlanGroupSiteRelations)
 			if err != nil {
 				return err
 			}
@@ -43,6 +48,7 @@ func (o *OVirtSource) syncNetworks(nbi *inventory.NetboxInventory) error {
 					Name:     name,
 					Group:    vlanGroup,
 					Vid:      int(networkVlanID),
+					Site:     vlanSite,
 					Status:   &objects.VlanStatusActive,
 					Tenant:   vlanTenant,
 					Comments: network.MustComment(),
@@ -624,8 +630,13 @@ func (o *OVirtSource) collectHostNicsData(nbHost *objects.Device, nbi *inventory
 			vlanID, exists := vlan.Id()
 			if exists {
 				vlanName := o.Networks.Vid2Name[int(vlanID)]
+				// Get vlanSite from relation
+				vlanSite, err := common.MatchVlanToSite(o.Ctx, nbi, vlanName, o.SourceConfig.VlanSiteRelations)
+				if err != nil {
+					return fmt.Errorf("match vlan to site: %s", err)
+				}
 				// Get vlanGroup from relation
-				vlanGroup, err := common.MatchVlanToGroup(o.Ctx, nbi, vlanName, o.SourceConfig.VlanGroupRelations, o.SourceConfig.VlanGroupSiteRelations)
+				vlanGroup, err := common.MatchVlanToGroup(o.Ctx, nbi, vlanName, vlanSite, o.SourceConfig.VlanGroupRelations, o.SourceConfig.VlanGroupSiteRelations)
 				if err != nil {
 					return err
 				}
@@ -1089,7 +1100,11 @@ func (o *OVirtSource) syncVMNics(nbi *inventory.NetboxInventory, ovirtVM *ovirts
 					if vnicNetworkVlan, ok := vnicNetwork.Vlan(); ok {
 						if vlanID, ok := vnicNetworkVlan.Id(); ok {
 							vlanName := o.Networks.Vid2Name[int(vlanID)]
-							vlanGroup, err := common.MatchVlanToGroup(o.Ctx, nbi, vlanName, o.SourceConfig.VlanGroupRelations, o.SourceConfig.VlanGroupSiteRelations)
+							vlanSite, err := common.MatchVlanToSite(o.Ctx, nbi, vlanName, o.SourceConfig.VlanSiteRelations)
+							if err != nil {
+								return fmt.Errorf("match vlan to site: %s", err)
+							}
+							vlanGroup, err := common.MatchVlanToGroup(o.Ctx, nbi, vlanName, vlanSite, o.SourceConfig.VlanGroupRelations, o.SourceConfig.VlanGroupSiteRelations)
 							if err != nil {
 								o.Logger.Warningf(o.Ctx, "match vlan to group: %s", err)
 								continue

internal/source/paloalto/paloalto_sync.go

@@ -169,7 +169,11 @@ func (pas *PaloAltoSource) syncInterfaces(nbi *inventory.NetboxInventory) error
 			if subIface.Tag != 0 {
 				// Extract Vlan
 				vlanName := fmt.Sprintf("Vlan%d", subIface.Tag)
-				vlanGroup, err := common.MatchVlanToGroup(pas.Ctx, nbi, vlanName, pas.SourceConfig.VlanGroupRelations, pas.SourceConfig.VlanGroupSiteRelations)
+				vlanSite, err := common.MatchVlanToSite(pas.Ctx, nbi, vlanName, pas.SourceConfig.VlanSiteRelations)
+				if err != nil {
+					return fmt.Errorf("match vlan to site: %s", err)
+				}
+				vlanGroup, err := common.MatchVlanToGroup(pas.Ctx, nbi, vlanName, vlanSite, pas.SourceConfig.VlanGroupRelations, pas.SourceConfig.VlanGroupSiteRelations)
 				if err != nil {
 					return fmt.Errorf("match vlan to group: %s", err)
 				}
@@ -185,6 +189,7 @@ func (pas *PaloAltoSource) syncInterfaces(nbi *inventory.NetboxInventory) error
 					Status: &objects.VlanStatusActive,
 					Name:   fmt.Sprintf("Vlan%d", subIface.Tag),
 					Vid:    subIface.Tag,
+					Site:   vlanSite,
 					Tenant: vlanTenant,
 					Group:  vlanGroup,
 				}