CNS_Fixing debug API

 The GetIPAddressesMatchingStates now returns IPConfigurationStatus
 type, which also includes PodInfo along with IP address and state

Author: kmurudi

cns/NetworkContainerContract.go

@@ -233,8 +233,8 @@ type GetIPAddressesRequest struct {
 
 // GetIPAddressStateResponse is used in CNS IPAM mode as a response to get IP address state
 type GetIPAddressStateResponse struct {
-	IPAddresses []IPAddressState
-	Response    Response
+	IPConfigurationStatus[] IPConfigurationStatus
+	Response Response
 }
 
 // IPAddressState Only used in the GetIPConfig API to return IP's that match a filter

cns/api.go

@@ -46,7 +46,7 @@ type HTTPService interface {
 	MarkIPAsPendingRelease(numberToMark int) (map[string]IPConfigurationStatus, error)
 }
 
-// This is used for KubernetesCRD orchastrator Type where NC has multiple ips.
+// This is used for KubernetesCRD orchestrator Type where NC has multiple ips.
 // This struct captures the state for SecondaryIPs associated to a given NC
 type IPConfigurationStatus struct {
 	NCID                string

cns/cnsclient/cli.go

@@ -68,10 +68,14 @@ func getCmd(client *CNSClient, arg string) error {
 	case cns.PendingRelease:
 		states = append(states, cns.PendingRelease)
 
+	case cns.PendingProgramming:
+		states = append(states, cns.PendingProgramming)
+
 	default:
 		states = append(states, cns.Allocated)
 		states = append(states, cns.Available)
 		states = append(states, cns.PendingRelease)
+		states = append(states, cns.PendingProgramming)
 	}
 
 	addr, err := client.GetIPAddressesMatchingStates(states...)
@@ -84,7 +88,7 @@ func getCmd(client *CNSClient, arg string) error {
 }
 
 // Sort the addresses based on IP, then write to stdout
-func printIPAddresses(addrSlice []cns.IPAddressState) {
+func printIPAddresses(addrSlice []cns.IPConfigurationStatus) {
 	sort.Slice(addrSlice, func(i, j int) bool {
 		return addrSlice[i].IPAddress < addrSlice[j].IPAddress
 	})

cns/cnsclient/cnsclient.go

@@ -319,7 +319,7 @@ func (cnsClient *CNSClient) ReleaseIPAddress(orchestratorContext []byte) error {
 
 // GetIPAddressesWithStates takes a variadic number of string parameters, to get all IP Addresses matching a number of states
 // usage GetIPAddressesWithStates(cns.Available, cns.Allocated)
-func (cnsClient *CNSClient) GetIPAddressesMatchingStates(StateFilter ...string) ([]cns.IPAddressState, error) {
+func (cnsClient *CNSClient) GetIPAddressesMatchingStates(StateFilter ...string) ([]cns.IPConfigurationStatus, error) {
 	var (
 		resp cns.GetIPAddressStateResponse
 		err  error
@@ -328,7 +328,7 @@ func (cnsClient *CNSClient) GetIPAddressesMatchingStates(StateFilter ...string)
 	)
 
 	if len(StateFilter) == 0 {
-		return []cns.IPAddressState{}, nil
+		return resp.IPConfigurationStatus, nil
 	}
 
 	url := cnsClient.connectionURL + cns.GetIPAddresses
@@ -341,33 +341,33 @@ func (cnsClient *CNSClient) GetIPAddressesMatchingStates(StateFilter ...string)
 	err = json.NewEncoder(&body).Encode(payload)
 	if err != nil {
 		log.Errorf("encoding json failed with %v", err)
-		return resp.IPAddresses, err
+		return resp.IPConfigurationStatus, err
 	}
 
 	res, err = http.Post(url, contentTypeJSON, &body)
 	if err != nil {
 		log.Errorf("[Azure CNSClient] HTTP Post returned error %v", err.Error())
-		return resp.IPAddresses, err
+		return resp.IPConfigurationStatus, err
 	}
 
 	defer res.Body.Close()
 
 	if res.StatusCode != http.StatusOK {
 		errMsg := fmt.Sprintf("[Azure CNSClient] GetIPAddressesMatchingStates invalid http status code: %v", res.StatusCode)
 		log.Errorf(errMsg)
-		return resp.IPAddresses, fmt.Errorf(errMsg)
+		return resp.IPConfigurationStatus, fmt.Errorf(errMsg)
 	}
 
 	err = json.NewDecoder(res.Body).Decode(&resp)
 	if err != nil {
 		log.Errorf("[Azure CNSClient] Error received while parsing GetIPAddressesMatchingStates response resp:%v err:%v", res.Body, err.Error())
-		return resp.IPAddresses, err
+		return resp.IPConfigurationStatus, err
 	}
 
 	if resp.Response.ReturnCode != 0 {
 		log.Errorf("[Azure CNSClient] GetIPAddressesMatchingStates received error response :%v", resp.Response.Message)
-		return resp.IPAddresses, fmt.Errorf(resp.Response.Message)
+		return resp.IPConfigurationStatus, fmt.Errorf(resp.Response.Message)
 	}
 
-	return resp.IPAddresses, err
+	return resp.IPConfigurationStatus, err
 }

cns/cnsclient/cnsclient_test.go

@@ -227,7 +227,8 @@ func TestCNSClientRequestAndRelease(t *testing.T) {
 		t.Fatalf("Expected to not fail when releasing IP reservation found with context: %+v", err)
 	}
 
-	ipaddresses, err := cnsClient.GetIPAddressesMatchingStates(cns.Available)
+	ipaddresses, err := cnsClient.GetIPAddressesMatchingStates("Available")
+	fmt.Println(ipaddresses)
 	if err != nil {
 		t.Fatalf("Get allocated IP addresses failed %+v", err)
 	}

cns/restserver/ipam.go

@@ -207,21 +207,24 @@ func (service *HTTPRestService) getIPAddressesHandler(w http.ResponseWriter, r *
 	}
 
 	// Get all IPConfigs matching a state, and append to a slice of IPAddressState
-	resp.IPAddresses = filterIPConfigsMatchingState(service.PodIPConfigState, req.IPConfigStateFilter, filterFunc)
+	resp.IPConfigurationStatus = filterIPConfigsMatchingState(service.PodIPConfigState, req.IPConfigStateFilter, filterFunc)
 
 	return
 }
 
 // filter the ipconfigs in CNS matching a state (Available, Allocated, etc.) and return in a slice
-func filterIPConfigsMatchingState(toBeAdded map[string]cns.IPConfigurationStatus, states []string, f func(cns.IPConfigurationStatus, []string) bool) []cns.IPAddressState {
-	vsf := make([]cns.IPAddressState, 0)
+func filterIPConfigsMatchingState(toBeAdded map[string]cns.IPConfigurationStatus, states []string, f func(cns.IPConfigurationStatus, []string) bool) []cns.IPConfigurationStatus {
+	vsf := make([]cns.IPConfigurationStatus, 0)
 	for _, v := range toBeAdded {
 		if f(v, states) {
-			ip := cns.IPAddressState{
-				IPAddress: v.IPAddress,
-				State:     v.State,
+			ipconfigstate := cns.IPConfigurationStatus{
+				IPAddress: 			 v.IPAddress,
+				State:               v.State,
+				OrchestratorContext: v.OrchestratorContext,
+				NCID:                v.NCID,
+				ID:                  v.ID,
 			}
-			vsf = append(vsf, ip)
+			vsf = append(vsf, ipconfigstate)
 		}
 	}
 	return vsf