initial TODOs for CNS

Author: rjdenney

cns/kubecontroller/nodenetworkconfig/reconciler.go

@@ -124,6 +124,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (reco
 		ipAssignments += len(req.SecondaryIPConfigs)
 	}
 
+	// TODO: Here we can assign a IPFamilies along with the allocated IPs
 	// record assigned IPs metric
 	allocatedIPs.Set(float64(ipAssignments))
 

cns/middlewares/k8sSwiftV2.go

@@ -38,6 +38,7 @@ var _ cns.IPConfigsHandlerMiddleware = (*K8sSWIFTv2Middleware)(nil)
 
 // IPConfigsRequestHandlerWrapper is the middleware function for handling SWIFT v2 IP configs requests for AKS-SWIFT. This function wrapped the default SWIFT request
 // and release IP configs handlers.
+// this will need to change to also work for a delegated NIC with multiple IPs
 func (k *K8sSWIFTv2Middleware) IPConfigsRequestHandlerWrapper(defaultHandler, failureHandler cns.IPConfigsHandlerFunc) cns.IPConfigsHandlerFunc {
 	return func(ctx context.Context, req cns.IPConfigsRequest) (*cns.IPConfigsResponse, error) {
 		podInfo, respCode, message := k.validateIPConfigsRequest(ctx, &req)
@@ -52,9 +53,11 @@ func (k *K8sSWIFTv2Middleware) IPConfigsRequestHandlerWrapper(defaultHandler, fa
 		}
 		ipConfigsResp, err := defaultHandler(ctx, req)
 		// If the pod is not v2, return the response from the handler
+		// we need to add the secondary Interface. Our current POC cluster is returning here
 		if !req.SecondaryInterfacesExist {
 			return ipConfigsResp, err
 		}
+		// TODO: the pod itself won't be "V2" as we aren't using multitenancy pods
 		// If the pod is v2, get the infra IP configs from the handler first and then add the SWIFTv2 IP config
 		defer func() {
 			// Release the default IP config if there is an error
@@ -100,6 +103,8 @@ func (k *K8sSWIFTv2Middleware) IPConfigsRequestHandlerWrapper(defaultHandler, fa
 	}
 }
 
+// TODO: we will not be using multitenant pods. Need to look into what labels we are currently seeing and maybe compare to Vanilla swiftv2
+// For our purposes we would skip over this logic or need to replace it with something to check the delegated NIC
 // validateIPConfigsRequest validates if pod is multitenant by checking the pod labels, used in SWIFT V2 AKS scenario.
 // nolint
 func (k *K8sSWIFTv2Middleware) validateIPConfigsRequest(ctx context.Context, req *cns.IPConfigsRequest) (podInfo cns.PodInfo, respCode types.ResponseCode, message string) {

cns/restserver/ipam.go

@@ -280,6 +280,7 @@ func (service *HTTPRestService) RequestIPConfigsHandler(w http.ResponseWriter, r
 	}
 	var ipConfigsResp *cns.IPConfigsResponse
 
+	// TODO: Decide what middleware option we need to singetenancy swift v2
 	// Check if IPConfigsHandlerMiddleware is set
 	if service.IPConfigsHandlerMiddleware != nil {
 		// Wrap the default datapath handlers with the middleware depending on middleware type
@@ -979,8 +980,11 @@ func (service *HTTPRestService) AssignDesiredIPConfigs(podInfo cns.PodInfo, desi
 // In the case of dualstack we would expect to have one IPv6 from one NC and one IPv4 from a second NC
 func (service *HTTPRestService) AssignAvailableIPConfigs(podInfo cns.PodInfo) ([]cns.PodIpInfo, error) {
 	// Gets the number of NCs which will determine the number of IPs given to a pod
+	// TODO: If we go with the One NC route then this logic would have to be updated
+	// Instead of using numOfNCs we would have a variable added to the HTTPRestService struct that determines IPFamilies and use the length of that
 	numOfNCs := len(service.state.ContainerStatus)
 	// if there are no NCs on the NNC there will be no IPs in the pool so return error
+	// We could still keep this check
 	if numOfNCs == 0 {
 		return nil, ErrNoNCs
 	}
@@ -994,6 +998,7 @@ func (service *HTTPRestService) AssignAvailableIPConfigs(podInfo cns.PodInfo) ([
 	// Searches for available IPs in the pool
 	for _, ipState := range service.PodIPConfigState {
 		// check if an IP from this NC is already set side for assignment.
+		// TODO: Instead of using ncAlreadyMarkedForAssignment it would be IPFamilyAlreadyMarkedForAssignment
 		if _, ncAlreadyMarkedForAssignment := ipsToAssign[ipState.NCID]; ncAlreadyMarkedForAssignment {
 			continue
 		}

cns/restserver/ipusage.go

@@ -5,6 +5,9 @@ import (
 	"github.com/Azure/azure-container-networking/cns/types"
 )
 
+// TODO: add an IPFamily type with values ipv4 and ipv6
+//
+//	This should be similar to DNC's IPFamilies and will only be ipv4 only or ipv4,ipv6
 type ipState struct {
 	// allocatedIPs are all the IPs given to CNS by DNC.
 	allocatedIPs int64
@@ -16,6 +19,7 @@ type ipState struct {
 	programmingIPs int64
 	// releasingIPs are the IPs in state "PendingReleasr".
 	releasingIPs int64
+	// TODO: add and IPFamilies value to be a slice of IPFamily type
 }
 
 func (service *HTTPRestService) buildIPState() *ipState {

cns/restserver/restserver.go

@@ -53,6 +53,8 @@ type imdsClient interface {
 }
 
 // HTTPRestService represents http listener for CNS - Container Networking Service.
+// TODO: Add a new value for IPFamily
+// If we add a new type of Middleware that will be reflected in the IPConfigsHandlerMiddleware value
 type HTTPRestService struct {
 	*cns.Service
 	dockerClient             *dockerclient.Client

cns/service/main.go

@@ -1400,6 +1400,7 @@ func InitializeCRDState(ctx context.Context, httpRestService cns.HTTPService, cn
 
 	// Start building the NNC Reconciler
 
+	// TODO: We need to return the IPFamilies from the reconciler so that they can be added to the Service struct
 	// get CNS Node IP to compare NC Node IP with this Node IP to ensure NCs were created for this node
 	nodeIP := configuration.NodeIP()
 	nncReconciler := nncctrl.NewReconciler(httpRestServiceImplementation, poolMonitor, nodeIP)
@@ -1430,6 +1431,7 @@ func InitializeCRDState(ctx context.Context, httpRestService cns.HTTPService, cn
 		}
 	}
 
+	// TODO: If we need special middleware this is where we would be setting it
 	if cnsconfig.EnableSwiftV2 {
 		if err := mtpncctrl.SetupWithManager(manager); err != nil {
 			return errors.Wrapf(err, "failed to setup mtpnc reconciler with manager")