Merge remote-tracking branch 'origin/revert/component-types' into revert/component-types

Signed-off-by: Dmitri Dolguikh <dmitri.external@netbird.io>

management/internals/network_map_db/pgsql/dns.go

@@ -49,6 +49,10 @@ func GetAppliedZoneCandidatesViaPgxConnection(ctx context.Context, conn *pgx.Con
 	toret := make([]networkmap.AppliedZoneCandidate, 0, len(zones))
 	currentZoneId := ""
 	for _, z := range zones {
+		if !z.RecordType.Valid {
+			continue
+		}
+
 		zone := nmdata.CustomZone{}
 		err := networkmapdb.FromSqlTypesToSharedTypes(
 			reflect.ValueOf(&z), reflect.ValueOf(&zone))
@@ -61,33 +65,28 @@ func GetAppliedZoneCandidatesViaPgxConnection(ctx context.Context, conn *pgx.Con
 			return nil, err
 		}
 
+		if z.Id != currentZoneId {
+			zone.Records = []nmdata.SimpleRecord{}
+			toret = append(toret, appliedZoneCandidateFromZone(zone, distributionGroups))
+			currentZoneId = z.Id
+		}
+
 		rtype, rdata, err := recordTypeAndRdata(z.RecordType.String, z.RecordRData.String)
 		if err != nil {
+			if errors.Is(err, DnsUnsupportedRecordTypeError) {
+				continue
+			}
 			return nil, err
 		}
-		record := nmdata.SimpleRecord{
+
+		lastZone := &toret[len(toret)-1]
+		lastZone.Zone.Records = append(lastZone.Zone.Records, nmdata.SimpleRecord{
 			Name:  z.RecordName.String,
 			Class: z.RecordClass.String,
 			TTL:   int(z.RecordTTL.Int64),
 			RData: rdata,
 			Type:  rtype,
-		}
-		zone.Records = []nmdata.SimpleRecord{record}
-
-		if len(toret) == 0 {
-			toret = append(toret, appliedZoneCandidateFromZone(zone, distributionGroups))
-			currentZoneId = z.Id
-			continue
-		}
-
-		if z.Id == currentZoneId {
-			lastZone := &toret[len(toret)-1]
-			lastZone.Zone.Records = append(lastZone.Zone.Records, record)
-			continue
-		}
-
-		toret = append(toret, appliedZoneCandidateFromZone(zone, distributionGroups))
-		currentZoneId = z.Id
+		})
 	}
 	return toret, nil
 }

management/internals/network_map_db/pgsql/network_map_data.go

@@ -81,11 +81,10 @@ func (pg *PgStore) GetNetworkMapData(ctx context.Context, accountId string) (*ne
 	if err != nil {
 		return rollbackAndReturnError(ctx, tx, err)
 	}
-	extraSettings, err := pg.settingsManager.GetExtraSettings(ctx, accountId)
+	proxyTargetedDomainResourceIDs, err := GetProxyTargetedDomainResourceIDsViaPgxConnection(ctx, tx.Conn(), accountId)
 	if err != nil {
-		return rollbackAndReturnError(ctx, tx, err)
+		return rollbackAndReturnError(ctx, tx, fmt.Errorf("failed to get proxy targeted domain resources: %w", err))
 	}
-	validatedPeers, err := pg.integratedPeerValidator.GetValidatedPeers(ctx, accountId, toSliceOfPtrs(groups), toSliceOfPtrs(peers), extraSettings)
 
 	resourcePolicies := make(map[string][]*nmdata.Policy)
 	for _, resource := range networkResources {
@@ -99,7 +98,7 @@ func (pg *PgStore) GetNetworkMapData(ctx context.Context, accountId string) (*ne
 			}
 			if _, ok := policyToDestinationResourceIdx[policy.ID][resource.ID]; ok {
 				resourcePolicies[resource.ID] = append(resourcePolicies[resource.ID], &policy) // TODO (dmitri) maybe use public id?
-				break
+				continue
 			}
 			if groupIds, ok := policyToDestinationGroupIdx[policy.ID]; ok {
 				for networkResourceGroup := range networkResourceGroups {
@@ -118,25 +117,25 @@ func (pg *PgStore) GetNetworkMapData(ctx context.Context, accountId string) (*ne
 	}
 
 	toret := networkmap.NetworkMapData{
-		AccountSettings:           &acctSettings,
-		DNSSettings:               &dnsSettings,
-		Network:                   &network,
-		Peers:                     toMap(peers, func(p nmdata.Peer) string { return p.ID }),
-		ValidatedPeers:            validatedPeers,
-		Groups:                    toMap(groups, func(g nmdata.Group) string { return g.PublicID }),
-		Policies:                  toSliceOfPtrs(policies),
-		ResourcePolicies:          resourcePolicies,
-		Routes:                    toSliceOfPtrs(routes),
-		Routers:                   routers,
-		NameServerGroups:          toSliceOfPtrs(nsGroups),
-		NetworkResources:          toSliceOfPtrs(networkResources),
-		PostureChecks:             toMap(postureChecks, func(pc nmdata.PostureChecks) string { return pc.ID }),
-		AllowedUserIDs:            allowedUserIds,
-		GroupIDToUserIDs:          groupsToUserIds,
-		NetworkXIDToPublicID:      networkXIDToPublicID, // TODO (dmitri) maybe we can switch to public ids everywhere?
-		AppliedZoneCandidates:     dnsZones,
-		PrivateServiceCandidates:  buildPrivateServiceCandidates(services, domains, proxyPeers),
-		PostureCheckXIDToPublicID: postureCheckXIDToPublicID,
+		AccountSettings:                &acctSettings,
+		DNSSettings:                    &dnsSettings,
+		Network:                        &network,
+		Peers:                          toMap(peers, func(p nmdata.Peer) string { return p.ID }),
+		Groups:                         toMap(groups, func(g nmdata.Group) string { return g.ID }),
+		Policies:                       toSliceOfPtrs(policies),
+		ResourcePolicies:               resourcePolicies,
+		Routes:                         toSliceOfPtrs(routes),
+		Routers:                        routers,
+		NameServerGroups:               toSliceOfPtrs(nsGroups),
+		NetworkResources:               toSliceOfPtrs(networkResources),
+		PostureChecks:                  toMap(postureChecks, func(pc nmdata.PostureChecks) string { return pc.ID }),
+		AllowedUserIDs:                 allowedUserIds,
+		GroupIDToUserIDs:               groupsToUserIds,
+		NetworkXIDToPublicID:           networkXIDToPublicID, // TODO (dmitri) maybe we can switch to public ids everywhere?
+		AppliedZoneCandidates:          dnsZones,
+		PrivateServiceCandidates:       buildPrivateServiceCandidates(services, domains, proxyPeers),
+		PostureCheckXIDToPublicID:      postureCheckXIDToPublicID,
+		ProxyTargetedDomainResourceIDs: proxyTargetedDomainResourceIDs,
 	}
 
 	return &toret, nil
@@ -158,7 +157,7 @@ func toMap[T any](all []T, id func(t T) string) map[string]*T {
 }
 
 func toSliceOfPtrs[T any](all []T) []*T {
-	toret := make([]*T, len(all))
+	toret := make([]*T, 0, len(all))
 	for _, t := range all {
 		toret = append(toret, &t)
 	}
@@ -198,6 +197,9 @@ func buildPrivateServiceCandidates(svcs []service, domains []domain, proxyPeersB
 	}
 
 	for _, svc := range svcs {
+		if !svc.Enabled.Bool || !svc.Private.Bool {
+			continue
+		}
 		if len(svc.AccessGroups) == 0 {
 			continue
 		}

management/internals/network_map_db/pgsql/network_router.go

@@ -65,6 +65,7 @@ func GetNetworkRoutersViaPgxConnection(ctx context.Context, con *pgx.Conn, accou
 		}
 		if router.Peer.String != "" {
 			toret[networkId][router.Peer.String] = &nmdatarouter
+			continue
 		}
 		for _, peerId := range router.PeersViaGroups {
 			toret[networkId][peerId] = &nmdatarouter

management/internals/network_map_db/pgsql/pg_store.go

@@ -7,8 +7,6 @@ import (
 
 	"github.com/jackc/pgx/v5/pgxpool"
 	networkmapdb "github.com/netbirdio/netbird/management/internals/network_map_db"
-	"github.com/netbirdio/netbird/management/server/integrations/integrated_validator"
-	"github.com/netbirdio/netbird/management/server/settings"
 )
 
 const (
@@ -21,9 +19,7 @@ const (
 var _ networkmapdb.NetworkMapDBStore = &PgStore{}
 
 type PgStore struct {
-	Pool                    *pgxpool.Pool
-	integratedPeerValidator integrated_validator.IntegratedValidator
-	settingsManager         settings.Manager
+	Pool *pgxpool.Pool
 }
 
 func NewPostgresqlStore(ctx context.Context, dsn string) (*PgStore, error) {

management/internals/network_map_db/pgsql/policy.go

@@ -86,11 +86,13 @@ func GetPoliciesViaPgxConnection(ctx context.Context, con *pgx.Conn, accountId s
 				return toret, nil, nil, err
 			}
 
-			for _, dst := range pr().Destinations {
-				if _, ok := policyToDestinationGroupIdx[p.ID]; !ok {
-					policyToDestinationGroupIdx[p.ID] = make(map[string]any)
+			if p.RuleEnabled.Valid && p.RuleEnabled.Bool {
+				for _, dst := range pr().Destinations {
+					if _, ok := policyToDestinationGroupIdx[p.ID]; !ok {
+						policyToDestinationGroupIdx[p.ID] = make(map[string]any)
+					}
+					policyToDestinationGroupIdx[p.ID][dst] = struct{}{}
 				}
-				policyToDestinationGroupIdx[p.ID][dst] = struct{}{}
 			}
 		}
 		if len(p.SourceResource) > 0 {
@@ -105,10 +107,12 @@ func GetPoliciesViaPgxConnection(ctx context.Context, con *pgx.Conn, accountId s
 				return toret, nil, nil, err
 			}
 
-			if _, ok := policyToDestinationResourceIdx[p.ID]; !ok {
-				policyToDestinationResourceIdx[p.ID] = make(map[string]any)
+			if p.RuleEnabled.Valid && p.RuleEnabled.Bool {
+				if _, ok := policyToDestinationResourceIdx[p.ID]; !ok {
+					policyToDestinationResourceIdx[p.ID] = make(map[string]any)
+				}
+				policyToDestinationResourceIdx[p.ID][pr().DestinationResource.ID] = struct{}{}
 			}
-			policyToDestinationResourceIdx[p.ID][pr().DestinationResource.ID] = struct{}{}
 		}
 		if len(p.Ports) > 0 {
 			err := json.Unmarshal([]byte(p.Ports), &pr().Ports)

management/internals/network_map_db/pgsql/service.go

@@ -13,6 +13,14 @@ const (
 	from services
 	where account_id=$1
 	`
+
+	GetProxyTargetedDomainResourcesQuery = `
+	select t.target_id
+	from targets as t
+	join services as s on s.id = t.service_id
+	where s.account_id=$1 and s.enabled and not coalesce(s.terminated, false)
+	and t.enabled and t.target_type='domain' and t.target_id is not null
+	`
 )
 
 func (pg *PgStore) GetPrivateServices(ctx context.Context, accountId string) ([]service, error) {
@@ -32,6 +40,24 @@ func GetPrivateServicesViaPgxConnection(ctx context.Context, conn *pgx.Conn, acc
 	return pgx.CollectRows(rows, pgx.RowToStructByName[service])
 }
 
+func GetProxyTargetedDomainResourceIDsViaPgxConnection(ctx context.Context, conn *pgx.Conn, accountId string) (map[string]struct{}, error) {
+	rows, err := conn.Query(ctx, GetProxyTargetedDomainResourcesQuery, accountId)
+	if err != nil {
+		return nil, err
+	}
+
+	ids, err := pgx.CollectRows(rows, pgx.RowTo[string])
+	if err != nil {
+		return nil, err
+	}
+
+	toret := make(map[string]struct{}, len(ids))
+	for _, id := range ids {
+		toret[id] = struct{}{}
+	}
+	return toret, nil
+}
+
 type service struct {
 	Enabled      sql.NullBool
 	Private      sql.NullBool

management/internals/network_map_db/pgsql/user.go

@@ -8,10 +8,15 @@ import (
 
 const (
 	GetAllowedUserIdsQuery = `
-	select id, array (select json_array_elements_text(auto_groups::json)) as auto_groups 
+	select id, array (select json_array_elements_text(auto_groups::json)) as auto_groups
 	from users
 	where account_id=$1 and not blocked and not is_service_user
 	`
+
+	GetAllGroupIdQuery = `
+	select id from groups
+	where account_id=$1 and name='All'
+	`
 )
 
 func (pg *PgStore) GetAllowedUsers(ctx context.Context, accountId string) (map[string]struct{}, map[string][]string, error) {
@@ -33,6 +38,19 @@ func GetAllowedUsersViaPgxConnection(ctx context.Context, con *pgx.Conn, account
 		return nil, nil, err
 	}
 
+	rows, err = con.Query(ctx, GetAllGroupIdQuery, accountId)
+	if err != nil {
+		return nil, nil, err
+	}
+	allGroupIds, err := pgx.CollectRows(rows, pgx.RowTo[string])
+	if err != nil {
+		return nil, nil, err
+	}
+	allGroupId := ""
+	if len(allGroupIds) > 0 {
+		allGroupId = allGroupIds[0]
+	}
+
 	userIdIdx := make(map[string]struct{})
 	groupIdToUserIds := make(map[string][]string)
 	for _, user := range users {
@@ -40,6 +58,9 @@ func GetAllowedUsersViaPgxConnection(ctx context.Context, con *pgx.Conn, account
 		for _, groupId := range user.AutoGroups {
 			groupIdToUserIds[groupId] = append(groupIdToUserIds[groupId], user.ID)
 		}
+		if allGroupId != "" {
+			groupIdToUserIds[allGroupId] = append(groupIdToUserIds[allGroupId], user.ID)
+		}
 	}
 
 	return userIdIdx, groupIdToUserIds, nil