mNAT + LB support for swift containers

.pipelines/e2e-step-template.yaml

@@ -90,6 +90,7 @@ steps:
       export REGIONS=$(AKS_ENGINE_REGION) 
       export IS_JENKINS=false 
       export DEBUG_CRASHING_PODS=true
+      export
       make test-kubernetes
     name: DeployAKSEngine
     displayName: Run AKS-Engine E2E Tests

cns/NetworkContainerContract.go

@@ -375,3 +375,9 @@ func (networkContainerRequestPolicy *NetworkContainerRequestPolicies) Validate()
 type NodeInfoResponse struct {
 	NetworkContainers []CreateNetworkContainerRequest
 }
+
+// NodeRegisterRequest - Struct to hold the node register request.
+type NodeRegisterRequest struct {
+	NumCPU               int
+	NmAgentSupportedApis []string
+}

cns/api.go

@@ -27,6 +27,7 @@ const (
 	NumberOfCPUCoresPath          = "/hostcpucores"
 	CreateHostNCApipaEndpointPath = "/network/createhostncapipaendpoint"
 	DeleteHostNCApipaEndpointPath = "/network/deletehostncapipaendpoint"
+	NmAgentSupportedApisPath      = "/network/nmagentsupportedapis"
 	V1Prefix                      = "/v0.1"
 	V2Prefix                      = "/v0.2"
 )
@@ -213,3 +214,12 @@ type DeleteHostNCApipaEndpointRequest struct {
 type DeleteHostNCApipaEndpointResponse struct {
 	Response Response
 }
+
+type NmAgentSupportedApisRequest struct {
+	GetNmAgentSupportedApisURL string
+}
+
+type NmAgentSupportedApisResponse struct {
+	Response      Response
+	SupportedApis []string
+}

cns/nmagentclient/nmagentclient.go

@@ -3,16 +3,21 @@ package nmagentclient
 import (
 	"bytes"
 	"encoding/json"
+	"encoding/xml"
+	"fmt"
 	"net/http"
 
 	"github.com/Azure/azure-container-networking/cns/logger"
 	"github.com/Azure/azure-container-networking/common"
 )
 
 const (
+	//GetNmAgentSupportedApiURLFmt Api endpoint to get supported Apis of NMAgent
+	GetNmAgentSupportedApiURLFmt     = "http://%s/machine/plugins/?comp=nmagent&type=GetSupportedApis"
 	GetNetworkContainerVersionURLFmt = "http://%s/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/%s/networkContainers/%s/version/authenticationToken/%s/api-version/1"
 )
 
+//WireServerIP - wire server ip
 var WireserverIP = "168.63.129.16"
 
 // NMANetworkContainerResponse - NMAgent response.
@@ -22,6 +27,10 @@ type NMANetworkContainerResponse struct {
 	Version            string `json:"version"`
 }
 
+type NMAgentSupportedApisResponseXML struct {
+	SupportedApis []string `xml:"type"`
+}
+
 // JoinNetwork joins the given network
 func JoinNetwork(
 	networkID string,
@@ -88,3 +97,55 @@ func GetNetworkContainerVersion(
 		networkContainerID, response, err)
 	return response, err
 }
+
+// GetNmAgentSupportedApis :- Retrieves Supported Apis from NMAgent
+func GetNmAgentSupportedApis(
+	httpc *http.Client,
+	getNmAgentSupportedApisURL string) ([]string, error) {
+	var (
+		returnErr error
+	)
+
+	if getNmAgentSupportedApisURL == "" {
+		getNmAgentSupportedApisURL = fmt.Sprintf(
+			GetNmAgentSupportedApiURLFmt, WireserverIP)
+	}
+
+	response, err := httpc.Get(getNmAgentSupportedApisURL)
+	if err != nil {
+		returnErr = fmt.Errorf(
+			"Failed to retrieve Supported Apis from NMAgent with error %v",
+			err.Error())
+		logger.Errorf("[Azure-CNS] %s", returnErr)
+		return nil, returnErr
+	}
+	if response == nil {
+		returnErr = fmt.Errorf(
+			"Response from getNmAgentSupportedApis call is <nil>")
+		logger.Errorf("[Azure-CNS] %s", returnErr)
+		return nil, returnErr
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		returnErr = fmt.Errorf(
+			"Failed to retrieve Supported Apis from NMAgent with StatusCode: %d",
+			response.StatusCode)
+		logger.Errorf("[Azure-CNS] %s", returnErr)
+		return nil, returnErr
+	}
+
+	var xmlDoc NMAgentSupportedApisResponseXML
+	decoder := xml.NewDecoder(response.Body)
+	err = decoder.Decode(&xmlDoc)
+	if err != nil {
+		returnErr = fmt.Errorf(
+			"Failed to decode XML response of Supported Apis from NMAgent with error %v",
+			err.Error())
+		logger.Errorf("[Azure-CNS] %s", returnErr)
+		return nil, returnErr
+	}
+
+	logger.Printf("[NMAgentClient][Response] GetNmAgentSupportedApis. Response: %+v.", response)
+	return xmlDoc.SupportedApis, nil
+}

cns/restserver/api.go

@@ -15,6 +15,7 @@ import (
 	"github.com/Azure/azure-container-networking/cns/hnsclient"
 	"github.com/Azure/azure-container-networking/cns/logger"
 	"github.com/Azure/azure-container-networking/cns/nmagentclient"
+	"github.com/Azure/azure-container-networking/common"
 	"github.com/Azure/azure-container-networking/platform"
 )
 
@@ -1439,3 +1440,47 @@ func (service *HTTPRestService) deleteHostNCApipaEndpoint(w http.ResponseWriter,
 	err = service.Listener.Encode(w, &response)
 	logger.Response(service.Name, response, response.Response.ReturnCode, ReturnCodeToString(response.Response.ReturnCode), err)
 }
+
+// This function is used to query NMagents's supported APIs list
+func (service *HTTPRestService) nmAgentSupportedApisHandler(w http.ResponseWriter, r *http.Request) {
+	logger.Request(service.Name, "nmAgentSupportedApisHandler", nil)
+	var (
+		err, retErr   error
+		req           cns.NmAgentSupportedApisRequest
+		returnCode    int
+		returnMessage string
+		supportedApis []string
+	)
+
+	err = service.Listener.Decode(w, r, &req)
+	logger.Request(service.Name, &req, err)
+	if err != nil {
+		return
+	}
+
+	switch r.Method {
+	case http.MethodPost:
+		supportedApis, retErr = nmagentclient.GetNmAgentSupportedApis(common.GetHttpClient(),
+			req.GetNmAgentSupportedApisURL)
+		if retErr != nil {
+			returnCode = NmAgentSupportedApisError
+			returnMessage = fmt.Sprintf("[Azure-CNS] %s", retErr.Error())
+		}
+		if supportedApis == nil {
+			supportedApis = []string{}
+		}
+
+	default:
+		returnMessage = "[Azure-CNS] NmAgentSupported API list expects a POST method."
+	}
+
+	resp := cns.Response{ReturnCode: returnCode, Message: returnMessage}
+	nmAgentSupportedApisResponse := &cns.NmAgentSupportedApisResponse{
+		Response:      resp,
+		SupportedApis: supportedApis,
+	}
+
+	serviceErr := service.Listener.Encode(w, &nmAgentSupportedApisResponse)
+
+	logger.Response(service.Name, nmAgentSupportedApisResponse, resp.ReturnCode, ReturnCodeToString(resp.ReturnCode), serviceErr)
+}

cns/restserver/api_test.go

@@ -591,6 +591,68 @@ func TestUnpublishNCViaCNS(t *testing.T) {
 	fmt.Printf("UnpublishNetworkContainer succeded with response %+v, raw:%+v\n", resp, w.Body)
 }
 
+func TestNmAgentSupportedApisHandler(t *testing.T) {
+	fmt.Println("Test: nmAgentSupportedApisHandler")
+
+	var (
+		err        error
+		req        *http.Request
+		nmAgentReq cns.NmAgentSupportedApisRequest
+		body       bytes.Buffer
+	)
+
+	json.NewEncoder(&body).Encode(nmAgentReq)
+	req, err = http.NewRequest(http.MethodGet, cns.NmAgentSupportedApisPath, &body)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var w *httptest.ResponseRecorder
+	w = httptest.NewRecorder()
+	mux.ServeHTTP(w, req)
+	var nmAgentSupportedApisResponse cns.NmAgentSupportedApisResponse
+
+	err = decodeResponse(w, &nmAgentSupportedApisResponse)
+	if err != nil || nmAgentSupportedApisResponse.Response.ReturnCode != 0 {
+		t.Errorf("nmAgentSupportedApisHandler failed with response %+v", nmAgentSupportedApisResponse)
+	}
+
+	// Since we are testing the NMAgent API in internalapi_test, we will skip POST call
+	// and test other paths
+	fmt.Printf("nmAgentSupportedApisHandler Responded with %+v\n", nmAgentSupportedApisResponse)
+
+}
+
+func TestCreateHostNCApipaEndpoint(t *testing.T) {
+	fmt.Println("Test: createHostNCApipaEndpoint")
+
+	var (
+		err           error
+		req           *http.Request
+		createHostReq cns.CreateHostNCApipaEndpointRequest
+		body          bytes.Buffer
+	)
+
+	json.NewEncoder(&body).Encode(createHostReq)
+	req, err = http.NewRequest(http.MethodPost, cns.CreateHostNCApipaEndpointPath, &body)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var w *httptest.ResponseRecorder
+	w = httptest.NewRecorder()
+	mux.ServeHTTP(w, req)
+	var createHostNCApipaEndpointResponse cns.CreateHostNCApipaEndpointResponse
+
+	err = decodeResponse(w, &createHostNCApipaEndpointResponse)
+	if err != nil || createHostNCApipaEndpointResponse.Response.ReturnCode != UnknownContainerID {
+		t.Errorf("createHostNCApipaEndpoint failed with response %+v", createHostNCApipaEndpointResponse)
+	}
+
+	fmt.Printf("createHostNCApipaEndpoint Responded with %+v\n", createHostNCApipaEndpointResponse)
+
+}
+
 func setOrchestratorType(t *testing.T, orchestratorType string) error {
 	var body bytes.Buffer
 

cns/restserver/const.go

@@ -37,6 +37,7 @@ const (
 	UnsupportedOrchestratorContext         = 34
 	NetworkContainerVfpProgramComplete     = 35
 	NetworkContainerVfpProgramCheckSkipped = 36
+	NmAgentSupportedApisError              = 37
 	UnexpectedError                        = 99
 )
 

cns/restserver/internalapi_test.go

@@ -27,7 +27,16 @@ const (
 )
 
 var (
-	dnsservers = []string{"8.8.8.8", "8.8.4.4"}
+	dnsservers        = []string{"8.8.8.8", "8.8.4.4"}
+	hostSupportedApis = `<SupportedRequestTypes>
+							<type>GetSupportedApis</type>
+							<type>GetIpRangesV1</type>
+							<type>GetIpRangesV2</type>
+							<type>GetInterfaceInfoV1</type>
+							<type>PortContainerIOVInformationV1</type>
+							<type>NetworkManagement</type>
+							<type>NetworkManagementDNSSupport</type>
+						</SupportedRequestTypes>`
 )
 
 func TestCreateOrUpdateNetworkContainerInternal(t *testing.T) {

cns/restserver/restserver.go

@@ -176,6 +176,7 @@ func (service *HTTPRestService) Start(config *common.ServiceConfig) error {
 	listener.AddHandler(cns.UnpublishNetworkContainer, service.unpublishNetworkContainer)
 	listener.AddHandler(cns.RequestIPConfig, service.requestIPConfigHandler)
 	listener.AddHandler(cns.ReleaseIPConfig, service.releaseIPConfigHandler)
+	listener.AddHandler(cns.NmAgentSupportedApisPath, service.nmAgentSupportedApisHandler)
 	listener.AddHandler(cns.GetIPAddresses, service.getIPAddressesHandler)
 
 	// handlers for v0.2
@@ -200,6 +201,7 @@ func (service *HTTPRestService) Start(config *common.ServiceConfig) error {
 	listener.AddHandler(cns.V2Prefix+cns.NumberOfCPUCoresPath, service.getNumberOfCPUCores)
 	listener.AddHandler(cns.V2Prefix+cns.CreateHostNCApipaEndpointPath, service.createHostNCApipaEndpoint)
 	listener.AddHandler(cns.V2Prefix+cns.DeleteHostNCApipaEndpointPath, service.deleteHostNCApipaEndpoint)
+	listener.AddHandler(cns.V2Prefix+cns.NmAgentSupportedApisPath, service.nmAgentSupportedApisHandler)
 
 	// Initialize HTTP client to be reused in CNS
 	connectionTimeout, _ := service.GetOption(acn.OptHttpConnectionTimeout).(int)