sendnrw/netbird
2
0
Fork 0
mirror of https://github.com/netbirdio/netbird.git synced 2026-08-30 11:31:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

adding network_map_data: compute Routers field

Browse Source 
Signed-off-by: Dmitri Dolguikh <dmitri.external@netbird.io>
This commit is contained in:
Dmitri Dolguikh
2026-07-31 17:56:52 +02:00
parent c2f8360b00
commit 5d6117d2c0
4 changed files with 139 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
management/internals/network_map_db/pgsql/network.go
View File

@@ -33,7 +33,7 @@ func GetNetworkViaPgxConnection(ctx context.Context, con *pgx.Conn, accountId st
return nmdata.Network{}, err
}
n, err := pgx.CollectOneRow(rows, pgx.RowToStructByName[network])
n, err := pgx.CollectOneRow(rows, pgx.RowToStructByName[accountnetwork])
if err != nil {
return nmdata.Network{}, err
}
@@ -48,7 +48,7 @@ func GetNetworkViaPgxConnection(ctx context.Context, con *pgx.Conn, accountId st
return toret, nil
}
type network struct {
type accountnetwork struct {
Identifier sql.NullString
Net json.RawMessage
NetV6 json.RawMessage

70
management/internals/network_map_db/pgsql/network_map_data.go
View File

@@ -2,8 +2,11 @@ package networkmap_pgsql
import (
"context"
"fmt"
"reflect"
"github.com/jackc/pgx/v5"
networkmapdb "github.com/netbirdio/netbird/management/internals/network_map_db"
"github.com/netbirdio/netbird/shared/management/networkmap"
"github.com/netbirdio/netbird/shared/management/networkmap/nmdata"
)
@@ -34,10 +37,11 @@ func (pg *PgStore) GetNetworkMapData(ctx context.Context, accountId string) (*ne
if err != nil {
return rollbackAndReturnError(ctx, tx, err)
}
// routers, err := GetNetworkRoutersViaPgxConnection(ctx, tx.Conn(), accountId)
// if err != nil {
// return rollbackAndReturnError(ctx, tx, err)
// }
// TODO (dmitri) this needs cleaning up -- returns an internal struct
routers, err := GetNetworkRoutersViaPgxConnection(ctx, tx.Conn(), accountId)
if err != nil {
return rollbackAndReturnError(ctx, tx, err)
}
network, err := GetNetworkViaPgxConnection(ctx, tx.Conn(), accountId)
if err != nil {
return rollbackAndReturnError(ctx, tx, err)
@@ -58,6 +62,10 @@ func (pg *PgStore) GetNetworkMapData(ctx context.Context, accountId string) (*ne
if err != nil {
return rollbackAndReturnError(ctx, tx, err)
}
networkXIDToPublicID, err := GetNetworkXIDToPublicIdMapViaPgxConnection(ctx, tx.Conn(), accountId)
if err != nil {
return rollbackAndReturnError(ctx, tx, err)
}
err = tx.Commit(ctx)
if err != nil {
@@ -65,16 +73,54 @@ func (pg *PgStore) GetNetworkMapData(ctx context.Context, accountId string) (*ne
}
toret := networkmap.NetworkMapData{
Network: &network,
Peers: toMap(peers, func(p nmdata.Peer) string { return p.ID }),
Groups: toMap(groups, func(g nmdata.Group) string { return g.PublicID }),
Policies: toSliceOfPtrs(policies),
Routes: toSliceOfPtrs(routes),
NameServerGroups: toSliceOfPtrs(nsGroups),
NetworkResources: toSliceOfPtrs(networkResources),
PostureChecks: toMap(postureChecks, func(pc nmdata.PostureChecks) string { return pc.ID }),
Network: &network,
Peers: toMap(peers, func(p nmdata.Peer) string { return p.ID }),
Groups: toMap(groups, func(g nmdata.Group) string { return g.PublicID }),
Policies: toSliceOfPtrs(policies),
Routes: toSliceOfPtrs(routes),
NameServerGroups: toSliceOfPtrs(nsGroups),
NetworkResources: toSliceOfPtrs(networkResources),
PostureChecks: toMap(postureChecks, func(pc nmdata.PostureChecks) string { return pc.ID }),
NetworkXIDToPublicID: networkXIDToPublicID, // TODO (dmitri-d) do we still need it now?
}
networktoRouters := make(map[string]map[string]*nmdata.NetworkRouter)
for _, router := range routers {
if !router.Enabled.Bool {
continue
}
if router.NetworkID.String == "" {
return nil, fmt.Errorf("router with public_id %s doesn't have network_id set", router.PublicID.String)
}
networkPublicId := networkXIDToPublicID[router.NetworkID.String]
if networkPublicId == "" {
return nil, fmt.Errorf("network with id %s has no public_id", router.NetworkID.String)
}
nmdatarouter := nmdata.NetworkRouter{}
err := networkmapdb.FromSqlTypesToSharedTypes(reflect.ValueOf(&router), reflect.ValueOf(&nmdatarouter))
if err != nil {
return nil, err
}
if networktoRouters[networkPublicId] == nil {
networktoRouters[networkPublicId] = make(map[string]*nmdata.NetworkRouter)
}
if router.Peer.String != "" {
networktoRouters[networkPublicId][router.Peer.String] = &nmdatarouter
}
for _, peerGroup := range nmdatarouter.PeerGroups {
g := toret.Groups[peerGroup]
if g != nil {
for _, peerID := range g.Peers {
networktoRouters[networkPublicId][peerID] = &nmdatarouter
}
}
}
}
toret.Routers = networktoRouters
return &toret, nil
}

55
management/internals/network_map_db/pgsql/network_router.go
View File

@@ -4,55 +4,54 @@ import (
"context"
"database/sql"
"encoding/json"
"reflect"
"github.com/jackc/pgx/v5"
networkmapdb "github.com/netbirdio/netbird/management/internals/network_map_db"
"github.com/netbirdio/netbird/shared/management/networkmap/nmdata"
)
const (
GetNetworkRouterQuery = `
select public_id, peer_groups, masquerade, metric, enabled
select public_id, peer, peer_groups, network_id, masquerade, metric, enabled,
from network_routers
where account_id=$1
`
)
func (pg *PgStore) GetNetworkRouters(ctx context.Context, accountId string) ([]nmdata.NetworkRouter, error) {
c, err := pg.Pool.Acquire(ctx)
if err != nil {
return nil, err
}
return GetNetworkRoutersViaPgxConnection(ctx, c.Conn(), accountId)
}
// func (pg *PgStore) GetNetworkRouters(ctx context.Context, accountId string) ([]nmdata.NetworkRouter, error) {
// c, err := pg.Pool.Acquire(ctx)
// if err != nil {
// return nil, err
// }
// return GetNetworkRoutersViaPgxConnection(ctx, c.Conn(), accountId)
// }
func GetNetworkRoutersViaPgxConnection(ctx context.Context, con *pgx.Conn, accountId string) ([]nmdata.NetworkRouter, error) {
func GetNetworkRoutersViaPgxConnection(ctx context.Context, con *pgx.Conn, accountId string) ([]networkrouter, error) {
rows, err := con.Query(ctx, GetNetworkRouterQuery, accountId)
if err != nil {
return nil, err
}
netrouters, err := pgx.CollectRows(rows, pgx.RowToStructByName[networkrouter])
if err != nil {
return nil, err
}
toret := make([]nmdata.NetworkRouter, 0, len(netrouters))
for _, nrt := range netrouters {
router := nmdata.NetworkRouter{}
err := networkmapdb.FromSqlTypesToSharedTypes(
reflect.ValueOf(&nrt), reflect.ValueOf(&router))
if err != nil {
return nil, err
}
toret = append(toret, router)
}
return toret, nil
return pgx.CollectRows(rows, pgx.RowToStructByName[networkrouter])
// if err != nil {
// return nil, err
// }
//
// toret := make([]nmdata.NetworkRouter, 0, len(netrouters))
// for _, nrt := range netrouters {
// router := nmdata.NetworkRouter{}
// err := networkmapdb.FromSqlTypesToSharedTypes(
// reflect.ValueOf(&nrt), reflect.ValueOf(&router))
// if err != nil {
// return nil, err
// }
// toret = append(toret, router)
// }
// return toret, nil
}
type networkrouter struct {
PublicID sql.NullString
NetworkID sql.NullString `nmap:"skip"`
Peer sql.NullString `nmap:"skip"`
PeerGroups json.RawMessage
Masquerade sql.NullBool
Metric sql.NullInt64

52
management/internals/network_map_db/pgsql/networks.go Normal file
View File

@@ -0,0 +1,52 @@
package networkmap_pgsql
import (
"context"
"database/sql"
"github.com/jackc/pgx/v5"
)
const (
GetNetworksQuery = `
select id, public_id
from networks where account_id=$1
`
)
func (pg *PgStore) GetNetworks(ctx context.Context, accountId string) ([]network, error) {
c, err := pg.Pool.Acquire(ctx)
if err != nil {
return nil, err
}
return GetNetworksViaPgxConnection(ctx, c.Conn(), accountId)
}
func GetNetworksViaPgxConnection(ctx context.Context, con *pgx.Conn, accountId string) ([]network, error) {
rows, err := con.Query(ctx, GetGroupsQuery, accountId)
if err != nil {
return nil, err
}
return pgx.CollectRows(rows, pgx.RowToStructByName[network])
}
func GetNetworkXIDToPublicIdMapViaPgxConnection(ctx context.Context, con *pgx.Conn, accountId string) (map[string]string, error) {
networks, err := GetNetworksViaPgxConnection(ctx, con, accountId)
if err != nil {
return nil, err
}
toret := make(map[string]string)
for _, n := range networks {
if n.PublicID.Valid {
toret[n.ID] = n.PublicID.String
}
}
return toret, nil
}
type network struct {
ID string
PublicID sql.NullString
}