try and encapsulate a little more

Author: paulgmiller

cns/restserver/helper_for_nodesubnet_test.go

@@ -79,8 +79,8 @@ func GetRestServiceObjectForNodeSubnetTest(t *testing.T, generator CNIConflistGe
 				return interfaces, nil
 			},
 		},
-		wscli:    &fakes.WireserverClientFake{},
-		ncSynced: make(chan struct{}),
+		wscli:       &fakes.WireserverClientFake{},
+		ncSyncState: &NetworkContainerSyncState{},
 	}
 }
 

cns/restserver/nodesubnet.go

@@ -59,8 +59,8 @@ func (service *HTTPRestService) InitializeNodeSubnet(ctx context.Context, podInf
 // StartNodeSubnet starts the IP fetcher for NodeSubnet. This will cause secondary IPs to be fetched periodically.
 // After the first successful fetch, conflist will be generated to indicate CNS is ready.
 func (service *HTTPRestService) StartNodeSubnet(ctx context.Context) error {
-	if !service.ncSyncLoop.CompareAndSwap(false, true) {
-		return errors.New("SyncHostNCVersion loop already started")
+	if err := service.ncSyncState.Start(); err != nil {
+		return err
 	}
 	service.nodesubnetIPFetcher.Start(ctx)
 	return nil

cns/restserver/restserver.go

@@ -6,7 +6,6 @@ import (
 	"net/http"
 	"net/http/pprof"
 	"sync"
-	"sync/atomic"
 	"time"
 
 	"github.com/Azure/azure-container-networking/cns"
@@ -103,9 +102,7 @@ type HTTPRestService struct {
 	PnpIDByMacAddress          map[string]string
 	imdsClient                 imdsClient
 	nodesubnetIPFetcher        *nodesubnet.IPFetcher
-	//put in ncstate struct?
-	ncSynced   chan struct{}
-	ncSyncLoop atomic.Bool
+	ncSyncState                *NetworkContainerSyncState
 }
 
 type CNIConflistGenerator interface {
@@ -256,7 +253,7 @@ func NewHTTPRestService(config *common.ServiceConfig, wscli interfaceGetter, wsp
 		homeAzMonitor:            homeAzMonitor,
 		cniConflistGenerator:     gen,
 		imdsClient:               imdsClient,
-		ncSynced:                 make(chan struct{}),
+		ncSyncState:              &NetworkContainerSyncState{},
 	}, nil
 }
 
@@ -390,3 +387,8 @@ func (service *HTTPRestService) Stop() {
 func (service *HTTPRestService) AttachIPConfigsHandlerMiddleware(middleware cns.IPConfigsHandlerMiddleware) {
 	service.IPConfigsHandlerMiddleware = middleware
 }
+
+// GetNetworkContainerSyncState returns the NetworkContainerSyncState for external use.
+func (service *HTTPRestService) Wait(ctx context.Context) {
+	service.ncSyncState.WaitForConfList(ctx)
+}

cns/restserver/synchostnc.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"strconv"
 	"strings"
+	"sync/atomic"
 	"time"
 
 	"github.com/Azure/azure-container-networking/cns"
@@ -17,9 +18,54 @@ import (
 
 // TODO: make this file a sub pacakge?
 
+// NetworkContainerSyncState manages the synchronization state for network container operations.
+type NetworkContainerSyncState struct {
+	ncSynced   chan struct{}
+	ncSyncLoop atomic.Bool
+}
+
+// Start attempts to start the sync loop. Returns an error if already started.
+func (n *NetworkContainerSyncState) Start() error {
+	if n == nil {
+		return errors.New("NetworkContainerSyncState is nil")
+	}
+	if !n.ncSyncLoop.CompareAndSwap(false, true) {
+		return errors.New("sync loop already started")
+	}
+	n.ncSynced = make(chan struct{})
+	return nil
+}
+
+// NotifyReady closes the ncSynced channel to signal readiness.
+func (n *NetworkContainerSyncState) NotifyReady() {
+	if n == nil || !n.ncSyncLoop.Load() {
+		return //nobody ever set this up just move on.
+	}
+	close(n.ncSynced)
+}
+
+// WaitForConfList waits for the CNI conflist to be ready or for the context to be done.
+func (n *NetworkContainerSyncState) WaitForConfList(ctx context.Context) {
+	if n == nil {
+		return //do nothing if we never got intiialized.
+	}
+
+	// Sync loop never set up, get out of here.
+	if n.ncSyncLoop.Load() {
+		return
+	}
+
+	select {
+	case <-n.ncSynced:
+		return
+	case <-ctx.Done():
+		return
+	}
+}
+
 func (service *HTTPRestService) StartSyncHostNCVersionLoop(ctx context.Context, cnsconfig configuration.CNSConfig) error {
-	if !service.ncSyncLoop.CompareAndSwap(false, true) {
-		return errors.New("SyncHostNCVersion loop already started")
+	if err := service.ncSyncState.Start(); err != nil {
+		return err
 	}
 	go func() {
 		logger.Printf("Starting SyncHostNCVersion loop.")
@@ -194,29 +240,14 @@ func (service *HTTPRestService) syncHostNCVersion(ctx context.Context, channelMo
 // a conflist generator. If not, this is a no-op.
 func (service *HTTPRestService) mustGenerateCNIConflistOnce() {
 	service.generateCNIConflistOnce.Do(func() {
-		if service.ncSyncLoop.Load() {
-			close(service.ncSynced)
-		}
+
 		if err := service.cniConflistGenerator.Generate(); err != nil {
 			panic("unable to generate cni conflist with error: " + err.Error())
 		}
 
 		if err := service.cniConflistGenerator.Close(); err != nil {
 			panic("unable to close the cni conflist output stream: " + err.Error())
 		}
+		service.ncSyncState.NotifyReady()
 	})
 }
-
-func (service *HTTPRestService) WaitForConfList(ctx context.Context) {
-	// Sync loop never set up, get out of here.
-	if !service.ncSyncLoop.Load() {
-		return
-	}
-
-	select {
-	case <-service.ncSynced:
-		return
-	case <-ctx.Done():
-		return
-	}
-}

cns/service/main.go

@@ -1122,7 +1122,7 @@ func main() {
 	}
 
 	// Wait for NC sync to complete before marking service as ready.
-	httpRemoteRestService.WaitForConfList(rootCtx)
+	httpRemoteRestService.Wait(rootCtx)
 	// mark the service as "ready"
 	close(readyCh)
 	// block until process exiting