Change log.Debug in goroutine for log.Info

client/internal/debug/debug.go

@@ -56,7 +56,6 @@ block.prof: Block profiling information.
 heap.prof: Heap profiling information (snapshot of memory allocations).
 allocs.prof: Allocations profiling information.
 threadcreate.prof: Thread creation profiling information.
-stack_trace.txt: Complete stack traces of all goroutines at the time of bundle creation.
 
 
 Anonymization Process
@@ -110,9 +109,6 @@ go tool pprof -http=:8088 heap.prof
 
 This will open a web browser tab with the profiling information.
 
-Stack Trace
-The stack_trace.txt file contains a complete snapshot of all goroutine stack traces at the time the debug bundle was created.
-
 Routes
 The routes.txt file contains detailed routing table information in a tabular format:
 
@@ -331,10 +327,6 @@ func (g *BundleGenerator) createArchive() error {
 		log.Errorf("failed to add profiles to debug bundle: %v", err)
 	}
 
-	if err := g.addStackTrace(); err != nil {
-		log.Errorf("failed to add stack trace to debug bundle: %v", err)
-	}
-
 	if err := g.addSyncResponse(); err != nil {
 		return fmt.Errorf("add sync response: %w", err)
 	}
@@ -530,18 +522,6 @@ func (g *BundleGenerator) addProf() (err error) {
 	return nil
 }
 
-func (g *BundleGenerator) addStackTrace() error {
-	buf := make([]byte, 5242880) // 5 MB buffer
-	n := runtime.Stack(buf, true)
-
-	stackTrace := bytes.NewReader(buf[:n])
-	if err := g.addFileToZip(stackTrace, "stack_trace.txt"); err != nil {
-		return fmt.Errorf("add stack trace file to zip: %w", err)
-	}
-
-	return nil
-}
-
 func (g *BundleGenerator) addInterfaces() error {
 	interfaces, err := net.Interfaces()
 	if err != nil {

client/internal/dns/mgmt/mgmt.go

@@ -96,10 +96,15 @@ func (m *Resolver) continueToNext(w dns.ResponseWriter, r *dns.Msg) {
 func (m *Resolver) AddDomain(ctx context.Context, d domain.Domain) error {
 	dnsName := strings.ToLower(dns.Fqdn(d.PunycodeString()))
 
+	log.Infof("AddDomain: starting DNS lookup for %s", d.SafeString())
+
 	ctx, cancel := context.WithTimeout(ctx, dnsTimeout)
 	defer cancel()
 
 	ips, err := net.DefaultResolver.LookupNetIP(ctx, "ip", d.PunycodeString())
+
+	log.Infof("AddDomain: DNS lookup completed for %s, err=%v, ips=%d", d.SafeString(), err, len(ips))
+
 	if err != nil {
 		return fmt.Errorf("resolve domain %s: %w", d.SafeString(), err)
 	}

client/internal/engine.go

@@ -420,10 +420,14 @@ func (e *Engine) Start(netbirdConfig *mgmProto.NetbirdConfig, mgmtURL *url.URL)
 	e.wgInterface = wgIface
 	e.statusRecorder.SetWgIface(wgIface)
 
+	log.Info("set wg interface to statusRecorder")
+
 	// start flow manager right after interface creation
 	publicKey := e.config.WgPrivateKey.PublicKey()
 	e.flowManager = netflow.NewManager(e.wgInterface, publicKey[:], e.statusRecorder)
 
+	log.Info("created flow manager")
+
 	if e.config.RosenpassEnabled {
 		log.Infof("rosenpass is enabled")
 		if e.config.RosenpassPermissive {
@@ -441,6 +445,8 @@ func (e *Engine) Start(netbirdConfig *mgmProto.NetbirdConfig, mgmtURL *url.URL)
 	}
 	e.stateManager.Start()
 
+	log.Info("started state manager")
+
 	initialRoutes, dnsConfig, dnsFeatureFlag, err := e.readInitialSettings()
 	if err != nil {
 		e.close()
@@ -454,10 +460,40 @@ func (e *Engine) Start(netbirdConfig *mgmProto.NetbirdConfig, mgmtURL *url.URL)
 	}
 	e.dnsServer = dnsServer
 
+	log.Info("created dns server")
+
 	// Populate DNS cache with NetbirdConfig and management URL for early resolution
-	if err := e.PopulateNetbirdConfig(netbirdConfig, mgmtURL); err != nil {
-		log.Warnf("failed to populate DNS cache: %v", err)
-	}
+	e.shutdownWg.Add(1)
+	go func() {
+		defer e.shutdownWg.Done()
+		backoff := time.Second
+		var lastErr error
+		const populateAttempts = 5
+
+		for attempts := 0; attempts < populateAttempts; attempts++ {
+			if pErr := e.PopulateNetbirdConfig(netbirdConfig, mgmtURL); pErr == nil {
+				log.Info("populated DNS cache successfully")
+				return
+			} else {
+				lastErr = pErr
+				log.Infof("populate DNS cache attempt %d failed: %v", attempts+1, pErr)
+			}
+
+			d := backoff + time.Duration(rand.Intn(500))*time.Millisecond
+			log.WithFields(log.Fields{"attempt": attempts + 1, "sleep": d}).Info("populate DNS cache retrying")
+
+			select {
+			case <-time.After(d):
+			case <-e.ctx.Done():
+				return
+			}
+
+			if backoff < 10*time.Second {
+				backoff *= 2
+			}
+		}
+		log.Errorf("failed to populate DNS cache after %d attempts: %v", populateAttempts, lastErr)
+	}()
 
 	e.routeManager = routemanager.NewManager(routemanager.ManagerConfig{
 		Context:             e.ctx,
@@ -478,19 +514,27 @@ func (e *Engine) Start(netbirdConfig *mgmProto.NetbirdConfig, mgmtURL *url.URL)
 		log.Errorf("Failed to initialize route manager: %s", err)
 	}
 
+	log.Info("set route manager")
+
 	e.routeManager.SetRouteChangeListener(e.mobileDep.NetworkChangeListener)
 
+	log.Info("set route change listener to route manager")
+
 	if err = e.wgInterfaceCreate(); err != nil {
 		log.Errorf("failed creating tunnel interface %s: [%s]", e.config.WgIfaceName, err.Error())
 		e.close()
 		return fmt.Errorf("create wg interface: %w", err)
 	}
 
+	log.Info("created tunnel interface")
+
 	if err := e.createFirewall(); err != nil {
 		e.close()
 		return err
 	}
 
+	log.Info("created firewall")
+
 	e.udpMux, err = e.wgInterface.Up()
 	if err != nil {
 		log.Errorf("failed to pull up wgInterface [%s]: %s", e.wgInterface.Name(), err.Error())
@@ -498,6 +542,8 @@ func (e *Engine) Start(netbirdConfig *mgmProto.NetbirdConfig, mgmtURL *url.URL)
 		return fmt.Errorf("up wg interface: %w", err)
 	}
 
+	log.Info("pulled up tunnel interface")
+
 	// if inbound conns are blocked there is no need to create the ACL manager
 	if e.firewall != nil && !e.config.BlockInbound {
 		e.acl = acl.NewDefaultManager(e.firewall)
@@ -509,24 +555,38 @@ func (e *Engine) Start(netbirdConfig *mgmProto.NetbirdConfig, mgmtURL *url.URL)
 		return fmt.Errorf("initialize dns server: %w", err)
 	}
 
+	log.Info("initialized dns server")
+
 	iceCfg := e.createICEConfig()
 
+	log.Infof("created ICE config: %v", iceCfg)
+
 	e.connMgr = NewConnMgr(e.config, e.statusRecorder, e.peerStore, wgIface)
 	e.connMgr.Start(e.ctx)
 
+	log.Info("started connection manager")
+
 	e.srWatcher = guard.NewSRWatcher(e.signal, e.relayManager, e.mobileDep.IFaceDiscover, iceCfg)
 	e.srWatcher.Start()
 
+	log.Info("started SR watcher")
+
 	e.receiveSignalEvents()
 	e.receiveManagementEvents()
 
+	log.Info("started receiving events from Signal and Management services")
+
 	// starting network monitor at the very last to avoid disruptions
 	e.startNetworkMonitor()
 
+	log.Info("started network monitor")
+
 	// monitor WireGuard interface lifecycle and restart engine on changes
 	e.wgIfaceMonitor = NewWGIfaceMonitor()
 	e.shutdownWg.Add(1)
 
+	log.Infof("starting WireGuard interface monitor")
+
 	go func() {
 		defer e.shutdownWg.Done()
 
@@ -538,6 +598,8 @@ func (e *Engine) Start(netbirdConfig *mgmProto.NetbirdConfig, mgmtURL *url.URL)
 		}
 	}()
 
+	log.Info("engine started successfully")
+
 	return nil
 }
 
@@ -731,21 +793,28 @@ func (e *Engine) PopulateNetbirdConfig(netbirdConfig *mgmProto.NetbirdConfig, mg
 		return nil
 	}
 
+	log.Info("PopulateNetbirdConfig: starting")
+
 	// Populate management URL if provided
 	if mgmtURL != nil {
+		log.Infof("PopulateNetbirdConfig: calling PopulateManagementDomain for %s", mgmtURL.Host)
 		if err := e.dnsServer.PopulateManagementDomain(mgmtURL); err != nil {
 			log.Warnf("failed to populate DNS cache with management URL: %v", err)
 		}
+		log.Info("PopulateNetbirdConfig: PopulateManagementDomain completed")
 	}
 
 	// Populate NetbirdConfig domains if provided
 	if netbirdConfig != nil {
+		log.Info("PopulateNetbirdConfig: calling UpdateServerConfig")
 		serverDomains := dnsconfig.ExtractFromNetbirdConfig(netbirdConfig)
 		if err := e.dnsServer.UpdateServerConfig(serverDomains); err != nil {
 			return fmt.Errorf("update DNS server config from NetbirdConfig: %w", err)
 		}
+		log.Info("PopulateNetbirdConfig: UpdateServerConfig completed")
 	}
 
+	log.Info("PopulateNetbirdConfig: done")
 	return nil
 }
 

client/internal/peer/endpoint.go

@@ -20,7 +20,7 @@ type EndpointUpdater struct {
 	wgConfig  WgConfig
 	initiator bool
 
-	// mu protects cancelFunc
+	// mu protects updateWireGuardPeer and cancelFunc
 	mu         sync.Mutex
 	cancelFunc func()
 	updateWg   sync.WaitGroup
@@ -86,9 +86,11 @@ func (e *EndpointUpdater) scheduleDelayedUpdate(ctx context.Context, addr *net.U
 	case <-ctx.Done():
 		return
 	case <-t.C:
+		e.mu.Lock()
 		if err := e.updateWireGuardPeer(addr, presharedKey); err != nil {
 			e.log.Errorf("failed to update WireGuard peer, address: %s, error: %v", addr, err)
 		}
+		e.mu.Unlock()
 	}
 }
 

management/internals/controllers/network_map/controller/controller.go

@@ -144,7 +144,7 @@ func (c *Controller) sendUpdateAccountPeers(ctx context.Context, accountID strin
 	if c.experimentalNetworkMap(accountID) {
 		account = c.getAccountFromHolderOrInit(accountID)
 	} else {
-		account, err = c.requestBuffer.GetAccountLightWithBackpressure(ctx, accountID)
+		account, err = c.requestBuffer.GetAccountWithBackpressure(ctx, accountID)
 		if err != nil {
 			return fmt.Errorf("failed to get account: %v", err)
 		}
@@ -300,7 +300,7 @@ func (c *Controller) UpdateAccountPeer(ctx context.Context, accountId string, pe
 		return fmt.Errorf("peer %s doesn't have a channel, skipping network map update", peerId)
 	}
 
-	account, err := c.requestBuffer.GetAccountLightWithBackpressure(ctx, accountId)
+	account, err := c.requestBuffer.GetAccountWithBackpressure(ctx, accountId)
 	if err != nil {
 		return fmt.Errorf("failed to send out updates to peer %s: %v", peerId, err)
 	}
@@ -414,7 +414,7 @@ func (c *Controller) GetValidatedPeerWithMap(ctx context.Context, isRequiresAppr
 	if c.experimentalNetworkMap(accountID) {
 		account = c.getAccountFromHolderOrInit(accountID)
 	} else {
-		account, err = c.requestBuffer.GetAccountLightWithBackpressure(ctx, accountID)
+		account, err = c.requestBuffer.GetAccountWithBackpressure(ctx, accountID)
 		if err != nil {
 			return nil, nil, nil, 0, err
 		}
@@ -506,7 +506,7 @@ func (c *Controller) recalculateNetworkMapCache(account *types.Account, validate
 
 func (c *Controller) RecalculateNetworkMapCache(ctx context.Context, accountId string) error {
 	if c.experimentalNetworkMap(accountId) {
-		account, err := c.requestBuffer.GetAccountLightWithBackpressure(ctx, accountId)
+		account, err := c.requestBuffer.GetAccountWithBackpressure(ctx, accountId)
 		if err != nil {
 			return err
 		}
@@ -548,7 +548,7 @@ func (c *Controller) getAccountFromHolderOrInit(accountID string) *types.Account
 	if a != nil {
 		return a
 	}
-	account, err := c.holder.LoadOrStoreFunc(accountID, c.requestBuffer.GetAccountLightWithBackpressure)
+	account, err := c.holder.LoadOrStoreFunc(accountID, c.requestBuffer.GetAccountWithBackpressure)
 	if err != nil {
 		return nil
 	}
@@ -715,7 +715,7 @@ func (c *Controller) OnPeersUpdated(ctx context.Context, accountID string, peerI
 func (c *Controller) OnPeersAdded(ctx context.Context, accountID string, peerIDs []string) error {
 	for _, peerID := range peerIDs {
 		if c.experimentalNetworkMap(accountID) {
-			account, err := c.requestBuffer.GetAccountLightWithBackpressure(ctx, accountID)
+			account, err := c.requestBuffer.GetAccountWithBackpressure(ctx, accountID)
 			if err != nil {
 				return err
 			}
@@ -761,7 +761,7 @@ func (c *Controller) OnPeersDeleted(ctx context.Context, accountID string, peerI
 		c.peersUpdateManager.CloseChannel(ctx, peerID)
 
 		if c.experimentalNetworkMap(accountID) {
-			account, err := c.requestBuffer.GetAccountLightWithBackpressure(ctx, accountID)
+			account, err := c.requestBuffer.GetAccountWithBackpressure(ctx, accountID)
 			if err != nil {
 				log.WithContext(ctx).Errorf("failed to get account %s: %v", accountID, err)
 				continue

management/server/account/request_buffer.go

@@ -7,6 +7,5 @@ import (
 )
 
 type RequestBuffer interface {
-	// GetAccountLightWithBackpressure returns account without users, setup keys, and onboarding data with request buffering
-	GetAccountLightWithBackpressure(ctx context.Context, accountID string) (*types.Account, error)
+	GetAccountWithBackpressure(ctx context.Context, accountID string) (*types.Account, error)
 }

management/server/account_request_buffer.go

@@ -25,13 +25,11 @@ type AccountResult struct {
 }
 
 type AccountRequestBuffer struct {
-	store                     store.Store
-	getAccountRequests        map[string][]*AccountRequest
-	getAccountLightRequests   map[string][]*AccountRequest
-	mu                        sync.Mutex
-	getAccountRequestCh       chan *AccountRequest
-	getAccountLightRequestCh  chan *AccountRequest
-	bufferInterval            time.Duration
+	store               store.Store
+	getAccountRequests  map[string][]*AccountRequest
+	mu                  sync.Mutex
+	getAccountRequestCh chan *AccountRequest
+	bufferInterval      time.Duration
 }
 
 func NewAccountRequestBuffer(ctx context.Context, store store.Store) *AccountRequestBuffer {
@@ -47,16 +45,13 @@ func NewAccountRequestBuffer(ctx context.Context, store store.Store) *AccountReq
 	log.WithContext(ctx).Infof("set account request buffer interval to %s", bufferInterval)
 
 	ac := AccountRequestBuffer{
-		store:                    store,
-		getAccountRequests:       make(map[string][]*AccountRequest),
-		getAccountLightRequests:  make(map[string][]*AccountRequest),
-		getAccountRequestCh:      make(chan *AccountRequest),
-		getAccountLightRequestCh: make(chan *AccountRequest),
-		bufferInterval:           bufferInterval,
+		store:               store,
+		getAccountRequests:  make(map[string][]*AccountRequest),
+		getAccountRequestCh: make(chan *AccountRequest),
+		bufferInterval:      bufferInterval,
 	}
 
 	go ac.processGetAccountRequests(ctx)
-	go ac.processGetAccountLightRequests(ctx)
 
 	return &ac
 }
@@ -75,22 +70,6 @@ func (ac *AccountRequestBuffer) GetAccountWithBackpressure(ctx context.Context,
 	return result.Account, result.Err
 }
 
-// GetAccountLightWithBackpressure returns account without users, setup keys, and onboarding data with request buffering
-func (ac *AccountRequestBuffer) GetAccountLightWithBackpressure(ctx context.Context, accountID string) (*types.Account, error) {
-	req := &AccountRequest{
-		AccountID:  accountID,
-		ResultChan: make(chan *AccountResult, 1),
-	}
-
-	log.WithContext(ctx).Tracef("requesting account light %s with backpressure", accountID)
-	startTime := time.Now()
-	ac.getAccountLightRequestCh <- req
-
-	result := <-req.ResultChan
-	log.WithContext(ctx).Tracef("got account light with backpressure after %s", time.Since(startTime))
-	return result.Account, result.Err
-}
-
 func (ac *AccountRequestBuffer) processGetAccountBatch(ctx context.Context, accountID string) {
 	ac.mu.Lock()
 	requests := ac.getAccountRequests[accountID]
@@ -130,43 +109,3 @@ func (ac *AccountRequestBuffer) processGetAccountRequests(ctx context.Context) {
 		}
 	}
 }
-
-func (ac *AccountRequestBuffer) processGetAccountLightBatch(ctx context.Context, accountID string) {
-	ac.mu.Lock()
-	requests := ac.getAccountLightRequests[accountID]
-	delete(ac.getAccountLightRequests, accountID)
-	ac.mu.Unlock()
-
-	if len(requests) == 0 {
-		return
-	}
-
-	startTime := time.Now()
-	account, err := ac.store.GetAccountLight(ctx, accountID)
-	log.WithContext(ctx).Tracef("getting account light %s in batch took %s", accountID, time.Since(startTime))
-	result := &AccountResult{Account: account, Err: err}
-
-	for _, req := range requests {
-		req.ResultChan <- result
-		close(req.ResultChan)
-	}
-}
-
-func (ac *AccountRequestBuffer) processGetAccountLightRequests(ctx context.Context) {
-	for {
-		select {
-		case req := <-ac.getAccountLightRequestCh:
-			ac.mu.Lock()
-			ac.getAccountLightRequests[req.AccountID] = append(ac.getAccountLightRequests[req.AccountID], req)
-			if len(ac.getAccountLightRequests[req.AccountID]) == 1 {
-				go func(ctx context.Context, accountID string) {
-					time.Sleep(ac.bufferInterval)
-					ac.processGetAccountLightBatch(ctx, accountID)
-				}(ctx, req.AccountID)
-			}
-			ac.mu.Unlock()
-		case <-ctx.Done():
-			return
-		}
-	}
-}

management/server/store/sql_store.go

@@ -796,14 +796,6 @@ func (s *SqlStore) GetAccount(ctx context.Context, accountID string) (*types.Acc
 	return s.getAccountGorm(ctx, accountID)
 }
 
-// GetAccountLight returns account without users, setup keys, and onboarding data
-func (s *SqlStore) GetAccountLight(ctx context.Context, accountID string) (*types.Account, error) {
-	if s.pool != nil {
-		return s.getAccountLightPgx(ctx, accountID)
-	}
-	return s.getAccountLightGorm(ctx, accountID)
-}
-
 func (s *SqlStore) getAccountGorm(ctx context.Context, accountID string) (*types.Account, error) {
 	start := time.Now()
 	defer func() {
@@ -905,82 +897,6 @@ func (s *SqlStore) getAccountGorm(ctx context.Context, accountID string) (*types
 	return &account, nil
 }
 
-func (s *SqlStore) getAccountLightGorm(ctx context.Context, accountID string) (*types.Account, error) {
-	start := time.Now()
-	defer func() {
-		elapsed := time.Since(start)
-		if elapsed > 1*time.Second {
-			log.WithContext(ctx).Tracef("GetAccountLight for account %s exceeded 1s, took: %v", accountID, elapsed)
-		}
-	}()
-
-	var account types.Account
-	result := s.db.Model(&account).
-		Preload("Policies.Rules").
-		Preload("PeersG").
-		Preload("GroupsG.GroupPeers").
-		Preload("RoutesG").
-		Preload("NameServerGroupsG").
-		Preload("PostureChecks").
-		Preload("Networks").
-		Preload("NetworkRouters").
-		Preload("NetworkResources").
-		Take(&account, idQueryCondition, accountID)
-	if result.Error != nil {
-		log.WithContext(ctx).Errorf("error when getting account %s from the store: %s", accountID, result.Error)
-		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
-			return nil, status.NewAccountNotFoundError(accountID)
-		}
-		return nil, status.NewGetAccountFromStoreError(result.Error)
-	}
-
-	account.SetupKeys = make(map[string]*types.SetupKey)
-
-	account.Peers = make(map[string]*nbpeer.Peer, len(account.PeersG))
-	for _, peer := range account.PeersG {
-		account.Peers[peer.ID] = &peer
-	}
-	account.PeersG = nil
-
-	account.Users = make(map[string]*types.User)
-
-	account.Groups = make(map[string]*types.Group, len(account.GroupsG))
-	for _, group := range account.GroupsG {
-		group.Peers = make([]string, len(group.GroupPeers))
-		for i, gp := range group.GroupPeers {
-			group.Peers[i] = gp.PeerID
-		}
-		if group.Resources == nil {
-			group.Resources = []types.Resource{}
-		}
-		account.Groups[group.ID] = group
-	}
-	account.GroupsG = nil
-
-	account.Routes = make(map[route.ID]*route.Route, len(account.RoutesG))
-	for _, route := range account.RoutesG {
-		account.Routes[route.ID] = &route
-	}
-	account.RoutesG = nil
-	account.NameServerGroups = make(map[string]*nbdns.NameServerGroup, len(account.NameServerGroupsG))
-	for _, ns := range account.NameServerGroupsG {
-		ns.AccountID = ""
-		if ns.NameServers == nil {
-			ns.NameServers = []nbdns.NameServer{}
-		}
-		if ns.Groups == nil {
-			ns.Groups = []string{}
-		}
-		if ns.Domains == nil {
-			ns.Domains = []string{}
-		}
-		account.NameServerGroups[ns.ID] = &ns
-	}
-	account.NameServerGroupsG = nil
-	account.InitOnce()
-	return &account, nil
-}
-
 func (s *SqlStore) getAccountPgx(ctx context.Context, accountID string) (*types.Account, error) {
 	account, err := s.getAccount(ctx, accountID)
 	if err != nil {
@@ -1264,221 +1180,6 @@ func (s *SqlStore) getAccountPgx(ctx context.Context, accountID string) (*types.
 	return account, nil
 }
 
-func (s *SqlStore) getAccountLightPgx(ctx context.Context, accountID string) (*types.Account, error) {
-	account, err := s.getAccount(ctx, accountID)
-	if err != nil {
-		return nil, err
-	}
-
-	var wg sync.WaitGroup
-	errChan := make(chan error, 9)
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		peers, err := s.getPeers(ctx, accountID)
-		if err != nil {
-			errChan <- err
-			return
-		}
-		account.PeersG = peers
-	}()
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		groups, err := s.getGroups(ctx, accountID)
-		if err != nil {
-			errChan <- err
-			return
-		}
-		account.GroupsG = groups
-	}()
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		policies, err := s.getPolicies(ctx, accountID)
-		if err != nil {
-			errChan <- err
-			return
-		}
-		account.Policies = policies
-	}()
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		routes, err := s.getRoutes(ctx, accountID)
-		if err != nil {
-			errChan <- err
-			return
-		}
-		account.RoutesG = routes
-	}()
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		nsgs, err := s.getNameServerGroups(ctx, accountID)
-		if err != nil {
-			errChan <- err
-			return
-		}
-		account.NameServerGroupsG = nsgs
-	}()
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		checks, err := s.getPostureChecks(ctx, accountID)
-		if err != nil {
-			errChan <- err
-			return
-		}
-		account.PostureChecks = checks
-	}()
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		networks, err := s.getNetworks(ctx, accountID)
-		if err != nil {
-			errChan <- err
-			return
-		}
-		account.Networks = networks
-	}()
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		routers, err := s.getNetworkRouters(ctx, accountID)
-		if err != nil {
-			errChan <- err
-			return
-		}
-		account.NetworkRouters = routers
-	}()
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		resources, err := s.getNetworkResources(ctx, accountID)
-		if err != nil {
-			errChan <- err
-			return
-		}
-		account.NetworkResources = resources
-	}()
-
-	wg.Wait()
-	close(errChan)
-	for e := range errChan {
-		if e != nil {
-			return nil, e
-		}
-	}
-
-	var policyIDs []string
-	for _, p := range account.Policies {
-		policyIDs = append(policyIDs, p.ID)
-	}
-	var groupIDs []string
-	for _, g := range account.GroupsG {
-		groupIDs = append(groupIDs, g.ID)
-	}
-
-	wg.Add(2)
-	errChan = make(chan error, 2)
-
-	var rules []*types.PolicyRule
-	go func() {
-		defer wg.Done()
-		var err error
-		rules, err = s.getPolicyRules(ctx, policyIDs)
-		if err != nil {
-			errChan <- err
-		}
-	}()
-
-	var groupPeers []types.GroupPeer
-	go func() {
-		defer wg.Done()
-		var err error
-		groupPeers, err = s.getGroupPeers(ctx, groupIDs)
-		if err != nil {
-			errChan <- err
-		}
-	}()
-
-	wg.Wait()
-	close(errChan)
-	for e := range errChan {
-		if e != nil {
-			return nil, e
-		}
-	}
-
-	rulesByPolicyID := make(map[string][]*types.PolicyRule)
-	for _, rule := range rules {
-		rulesByPolicyID[rule.PolicyID] = append(rulesByPolicyID[rule.PolicyID], rule)
-	}
-
-	peersByGroupID := make(map[string][]string)
-	for _, gp := range groupPeers {
-		peersByGroupID[gp.GroupID] = append(peersByGroupID[gp.GroupID], gp.PeerID)
-	}
-
-	account.SetupKeys = make(map[string]*types.SetupKey)
-
-	account.Peers = make(map[string]*nbpeer.Peer, len(account.PeersG))
-	for i := range account.PeersG {
-		peer := &account.PeersG[i]
-		account.Peers[peer.ID] = peer
-	}
-
-	account.Users = make(map[string]*types.User)
-
-	for i := range account.Policies {
-		policy := account.Policies[i]
-		if policyRules, ok := rulesByPolicyID[policy.ID]; ok {
-			policy.Rules = policyRules
-		}
-	}
-
-	account.Groups = make(map[string]*types.Group, len(account.GroupsG))
-	for i := range account.GroupsG {
-		group := account.GroupsG[i]
-		if peerIDs, ok := peersByGroupID[group.ID]; ok {
-			group.Peers = peerIDs
-		}
-		account.Groups[group.ID] = group
-	}
-
-	account.Routes = make(map[route.ID]*route.Route, len(account.RoutesG))
-	for i := range account.RoutesG {
-		route := &account.RoutesG[i]
-		account.Routes[route.ID] = route
-	}
-
-	account.NameServerGroups = make(map[string]*nbdns.NameServerGroup, len(account.NameServerGroupsG))
-	for i := range account.NameServerGroupsG {
-		nsg := &account.NameServerGroupsG[i]
-		nsg.AccountID = ""
-		account.NameServerGroups[nsg.ID] = nsg
-	}
-
-	account.SetupKeysG = nil
-	account.PeersG = nil
-	account.UsersG = nil
-	account.GroupsG = nil
-	account.RoutesG = nil
-	account.NameServerGroupsG = nil
-
-	return account, nil
-}
-
 func (s *SqlStore) getAccount(ctx context.Context, accountID string) (*types.Account, error) {
 	var account types.Account
 	account.Network = &types.Network{}

management/server/store/store.go

@@ -51,8 +51,6 @@ type Store interface {
 	GetAccountsCounter(ctx context.Context) (int64, error)
 	GetAllAccounts(ctx context.Context) []*types.Account
 	GetAccount(ctx context.Context, accountID string) (*types.Account, error)
-	// GetAccountLight returns account without users, setup keys, and onboarding data
-	GetAccountLight(ctx context.Context, accountID string) (*types.Account, error)
 	GetAccountMeta(ctx context.Context, lockStrength LockingStrength, accountID string) (*types.AccountMeta, error)
 	GetAccountOnboarding(ctx context.Context, accountID string) (*types.AccountOnboarding, error)
 	AccountExists(ctx context.Context, lockStrength LockingStrength, id string) (bool, error)