From e58c2b7a262467190e7edeb0bacea5437f05b7ba Mon Sep 17 00:00:00 2001 From: alegal Date: Tue, 11 Jan 2022 11:41:29 -0800 Subject: [PATCH 01/13] remove forwarding unstructured urls --- cns/restserver/api.go | 72 +++++++++++++++++++++++++++++++++---------- 1 file changed, 56 insertions(+), 16 deletions(-) diff --git a/cns/restserver/api.go b/cns/restserver/api.go index ecbc3efa7e..84fb9a004c 100644 --- a/cns/restserver/api.go +++ b/cns/restserver/api.go @@ -10,6 +10,7 @@ import ( "net" "net/http" "net/url" + "regexp" "runtime" "strings" @@ -1072,14 +1073,32 @@ func (service *HTTPRestService) getNumberOfCPUCores(w http.ResponseWriter, r *ht logger.Response(service.Name, numOfCPUCoresResp, resp.ReturnCode, err) } -func getInterfaceIdFromCreateNetworkContainerURL( - createNetworkContainerURL string) string { - return strings.Split(strings.Split(createNetworkContainerURL, "interfaces/")[1], "/")[0] -} +func getAuthTokenAndInterfaceIdFromNcURL(networkContainerURL string) (string, string, error) { + + ncUrl, err := url.Parse(networkContainerURL) + if err != nil { + return "", "", err + } + + queryParams := ncUrl.Query() + + // current format of create network url has a path after a query parameter "type" + // doing this parsing due to this structure + typeQueryParamVal := queryParams.Get("type") + if typeQueryParamVal == "" { + return "", "", fmt.Errorf("Invalid create container url format, no type query param") + } + + // .{0,128} gets from zero to 128 characters of any kind + // ()? is optional + ncRegex := regexp.MustCompile(`NetworkManagement/interfaces/(.{0,128})/networkContainers/(.{0,128})/authenticationToken/(.{0,128})/api-version/1(/method/DELETE)?`) + matches := ncRegex.FindStringSubmatch(typeQueryParamVal) + + if len(matches) != 5 { + return "", "", fmt.Errorf("Invalid network container url format") + } -func getAuthTokenFromCreateNetworkContainerURL( - createNetworkContainerURL string) string { - return strings.Split(strings.Split(createNetworkContainerURL, "authenticationToken/")[1], "/")[0] + return matches[1], matches[3], err } func extractHostFromJoinNetworkURL(urlToParse string) string { @@ -1109,6 +1128,8 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r err = service.Listener.Decode(w, r, &req) + creteNcUrlCopy := req.CreateNetworkContainerURL + // reqCopy creates a copy of incoming request. It doesn't copy the authentication token info // to avoid logging it. reqCopy := cns.PublishNetworkContainerRequest{ @@ -1119,14 +1140,24 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r } logger.Request(service.Name, &reqCopy, err) + + // TODO - refactor this method for better error handling if err != nil { return } + var associatedInterfaceID, authToken string + associatedInterfaceID, authToken, err = getAuthTokenAndInterfaceIdFromNcURL(creteNcUrlCopy) + if err != nil { + logger.Errorf("[Azure-CNS] %+v", err) + w.WriteHeader(http.StatusBadRequest) + return + } + switch r.Method { case "POST": // Join the network - publishResponse, publishError, err = service.joinNetwork(req.NetworkID, req.JoinNetworkURL) + publishResponse, publishError, err = service.joinNetwork(req.NetworkID) if err == nil { isNetworkJoined = true } else { @@ -1138,7 +1169,8 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r // Publish Network Container publishResponse, publishError = nmagent.PublishNetworkContainer( req.NetworkContainerID, - req.CreateNetworkContainerURL, + associatedInterfaceID, + authToken, req.CreateNetworkContainerRequestBody) if publishError != nil || publishResponse.StatusCode != http.StatusOK { returnMessage = fmt.Sprintf("Failed to publish Network Container: %s", req.NetworkContainerID) @@ -1148,19 +1180,16 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r defer publishResponse.Body.Close() } - // Store ncGetVersionURL needed for calling NMAgent to check if vfp programming is completed for the NC - primaryInterfaceIdentifier := getInterfaceIdFromCreateNetworkContainerURL(req.CreateNetworkContainerURL) - authToken := getAuthTokenFromCreateNetworkContainerURL(req.CreateNetworkContainerURL) - // we attempt to extract the wireserver IP to use from the request, otherwise default to the well-known IP. hostIP := extractHostFromJoinNetworkURL(req.JoinNetworkURL) if hostIP == "" { hostIP = nmagent.WireserverIP } + // Store ncGetVersionURL needed for calling NMAgent to check if vfp programming is completed for the NC ncGetVersionURL := fmt.Sprintf(nmagent.GetNetworkContainerVersionURLFmt, hostIP, - primaryInterfaceIdentifier, + associatedInterfaceID, req.NetworkContainerID, authToken) ncVersionURLs.Store(cns.SwiftPrefix+req.NetworkContainerID, ncGetVersionURL) @@ -1219,6 +1248,8 @@ func (service *HTTPRestService) unpublishNetworkContainer(w http.ResponseWriter, err = service.Listener.Decode(w, r, &req) + deleteNcUrlCopy := req.DeleteNetworkContainerURL + // reqCopy creates a copy of incoming request. It doesn't copy the authentication token info // to avoid logging it. reqCopy := cns.UnpublishNetworkContainerRequest{ @@ -1233,12 +1264,20 @@ func (service *HTTPRestService) unpublishNetworkContainer(w http.ResponseWriter, return } + var associatedInterfaceID, authToken string + associatedInterfaceID, authToken, err = getAuthTokenAndInterfaceIdFromNcURL(deleteNcUrlCopy) + if err != nil { + logger.Errorf("[Azure-CNS] %+v", err) + w.WriteHeader(http.StatusBadRequest) + return + } + switch r.Method { case "POST": // Join Network if not joined already isNetworkJoined = service.isNetworkJoined(req.NetworkID) if !isNetworkJoined { - unpublishResponse, unpublishError, err = service.joinNetwork(req.NetworkID, req.JoinNetworkURL) + unpublishResponse, unpublishError, err = service.joinNetwork(req.NetworkID) if err == nil { isNetworkJoined = true } else { @@ -1251,7 +1290,8 @@ func (service *HTTPRestService) unpublishNetworkContainer(w http.ResponseWriter, // Unpublish Network Container unpublishResponse, unpublishError = nmagent.UnpublishNetworkContainer( req.NetworkContainerID, - req.DeleteNetworkContainerURL) + associatedInterfaceID, + authToken) if unpublishError != nil || unpublishResponse.StatusCode != http.StatusOK { returnMessage = fmt.Sprintf("Failed to unpublish Network Container: %s", req.NetworkContainerID) returnCode = types.NetworkContainerUnpublishFailed From 7ab2772f3db3df87199ca6cffeedb178eac3ed48 Mon Sep 17 00:00:00 2001 From: alegal Date: Tue, 11 Jan 2022 11:41:48 -0800 Subject: [PATCH 02/13] remove forwarding unstructured urls --- cns/nmagent/client.go | 33 +++++++++-- cns/restserver/api_test.go | 112 +++++++++++++++++++++++++++++++------ cns/restserver/util.go | 7 +-- 3 files changed, 124 insertions(+), 28 deletions(-) diff --git a/cns/nmagent/client.go b/cns/nmagent/client.go index e372dc8948..231dedbc83 100644 --- a/cns/nmagent/client.go +++ b/cns/nmagent/client.go @@ -20,6 +20,9 @@ const ( 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" GetNcVersionListWithOutTokenURLFmt = "http://%s/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/api-version/%s" + JoinNetworkURLFmt = "http://%s/machine/plugins/?comp=nmagent&type=NetworkManagement/joinedVirtualNetworks/%s/api-version/1" + PutNetworkContainerUrlFmt = "http://%s/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/%s/networkContainers/%s/authenticationToken/%s/api-version/1" + DeleteNetworkContainerURLFmt = "http://%s/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/%s/networkContainers/%s/authenticationToken/%s/api-version/1/method/DELETE" ) // WireServerIP - wire server ip @@ -65,12 +68,18 @@ func NewClient(url string) (*Client, error) { } // JoinNetwork joins the given network -func JoinNetwork(networkID, joinNetworkURL string) (*http.Response, error) { +func JoinNetwork(networkID string) (*http.Response, error) { logger.Printf("[NMAgentClient] JoinNetwork: %s", networkID) // Empty body is required as wireserver cannot handle a post without the body. var body bytes.Buffer json.NewEncoder(&body).Encode("") + + joinNetworkURL := fmt.Sprintf( + JoinNetworkURLFmt, + WireserverIP, + networkID) + response, err := common.GetHttpClient().Post(joinNetworkURL, "application/json", &body) if err == nil && response.StatusCode == http.StatusOK { @@ -84,11 +93,18 @@ func JoinNetwork(networkID, joinNetworkURL string) (*http.Response, error) { } // PublishNetworkContainer publishes given network container -func PublishNetworkContainer(networkContainerID, createNetworkContainerURL string, requestBodyData []byte) (*http.Response, error) { +func PublishNetworkContainer(networkContainerID, associatedInterfaceID, accessToken string, requestBodyData []byte) (*http.Response, error) { logger.Printf("[NMAgentClient] PublishNetworkContainer NC: %s", networkContainerID) + createNCURL := fmt.Sprintf( + PutNetworkContainerUrlFmt, + WireserverIP, + associatedInterfaceID, + networkContainerID, + accessToken) + requestBody := bytes.NewBuffer(requestBodyData) - response, err := common.GetHttpClient().Post(createNetworkContainerURL, "application/json", requestBody) + response, err := common.GetHttpClient().Post(createNCURL, "application/json", requestBody) logger.Printf("[NMAgentClient][Response] Publish NC: %s. Response: %+v. Error: %v", networkContainerID, response, err) @@ -97,13 +113,20 @@ func PublishNetworkContainer(networkContainerID, createNetworkContainerURL strin } // UnpublishNetworkContainer unpublishes given network container -func UnpublishNetworkContainer(networkContainerID, deleteNetworkContainerURL string) (*http.Response, error) { +func UnpublishNetworkContainer(networkContainerID, associatedInterfaceID, accessToken string) (*http.Response, error) { logger.Printf("[NMAgentClient] UnpublishNetworkContainer NC: %s", networkContainerID) + deleteNCURL := fmt.Sprintf( + DeleteNetworkContainerURLFmt, + WireserverIP, + associatedInterfaceID, + networkContainerID, + accessToken) + // Empty body is required as wireserver cannot handle a post without the body. var body bytes.Buffer json.NewEncoder(&body).Encode("") - response, err := common.GetHttpClient().Post(deleteNetworkContainerURL, "application/json", &body) + response, err := common.GetHttpClient().Post(deleteNCURL, "application/json", &body) logger.Printf("[NMAgentClient][Response] Unpublish NC: %s. Response: %+v. Error: %v", networkContainerID, response, err) diff --git a/cns/restserver/api_test.go b/cns/restserver/api_test.go index 34fc663f89..b7a3c6e091 100644 --- a/cns/restserver/api_test.go +++ b/cns/restserver/api_test.go @@ -515,25 +515,60 @@ func createNC( t.Fatal(err) } - publishNCViaCNS(t, params.vnetID, params.ncID) + createNetworkContainerURL := "http://" + nmagentEndpoint + + "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/dummyT/api-version/" + + err := publishNCViaCNS(t, params.vnetID, params.ncID, createNetworkContainerURL, false) + if err != nil { + t.Fatal(err) + } } func TestPublishNCViaCNS(t *testing.T) { fmt.Println("Test: publishNetworkContainer") - publishNCViaCNS(t, "vnet1", "ethWebApp") + + createNetworkContainerURL := "http://" + nmagentEndpoint + + "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/dummyT/api-version/1" + err := publishNCViaCNS(t, "vnet1", "ethWebApp", createNetworkContainerURL, false) + if err != nil { + t.Fatal(err) + } + + createNetworkContainerURL = "http://" + nmagentEndpoint + + "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/" + + "e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6" + + "/api-version/1" + + err = publishNCViaCNS(t, "vnet1", "ethWebApp", createNetworkContainerURL, true) + if err == nil { + t.Fatal(err) + } + + createNetworkContainerURL = "http://" + nmagentEndpoint + + "/machine/plugins/?comp=nmagent&NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/" + + "e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6" + + "/api-version/1" + + + err = publishNCViaCNS(t, "vnet1", "ethWebApp", createNetworkContainerURL, true) + if err == nil { + t.Fatal(err) + } + + } func publishNCViaCNS(t *testing.T, - networkID string, - networkContainerID string) { + networkID, + networkContainerID, + createNetworkContainerURL string, + expectError bool) error { var ( body bytes.Buffer resp cns.PublishNetworkContainerResponse ) joinNetworkURL := "http://" + nmagentEndpoint + "/dummyVnetURL" - createNetworkContainerURL := "http://" + nmagentEndpoint + - "/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/dummyT/api-version" publishNCRequest := &cns.PublishNetworkContainerRequest{ NetworkID: networkID, @@ -546,19 +581,22 @@ func publishNCViaCNS(t *testing.T, json.NewEncoder(&body).Encode(publishNCRequest) req, err := http.NewRequest(http.MethodPost, cns.PublishNetworkContainer, &body) if err != nil { - t.Fatal(err) + return err } w := httptest.NewRecorder() mux.ServeHTTP(w, req) err = decodeResponse(w, &resp) - if err != nil || resp.Response.ReturnCode != 0 { - t.Errorf("PublishNetworkContainer failed with response %+v Err:%+v", resp, err) - t.Fatal(err) + if err != nil || resp.Response.ReturnCode != 0 { + if(!expectError) { + t.Errorf("PublishNetworkContainer failed with response %+v Err:%+v", resp, err) + } + return err } fmt.Printf("PublishNetworkContainer succeded with response %+v, raw:%+v\n", resp, w.Body) + return nil } func TestExtractHost(t *testing.T) { @@ -587,18 +625,52 @@ func TestExtractHost(t *testing.T) { } } -func TestUnpublishNCViaCNS(t *testing.T) { - fmt.Println("Test: unpublishNetworkContainer") +func TestUnpublishNCViaCNS(t *testing.T){ + + deleteNetworkContainerURL := "http://" + nmagentEndpoint + + "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/dummyT/api-version/1/method/DELETE" + err := publishNCViaCNS(t, "vnet1", "ethWebApp", deleteNetworkContainerURL, false) + if err != nil { + t.Fatal(err) + } + + deleteNetworkContainerURL = "http://" + nmagentEndpoint + + "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/" + + "e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6" + + "/api-version/1/method/DELETE" + + err = publishNCViaCNS(t, "vnet1", "ethWebApp", deleteNetworkContainerURL, true) + if err == nil { + t.Fatal(err) + } + + deleteNetworkContainerURL = "http://" + nmagentEndpoint + + "/machine/plugins/?comp=nmagent&NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/" + + "e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6" + + "/api-version/1/method/DELETE" + + + err = testUnpublishNCViaCNS(t, "vnet1", "ethWebApp", deleteNetworkContainerURL, true) + if err == nil { + t.Fatal(err) + } + +} + +func testUnpublishNCViaCNS(t *testing.T, + networkID, + networkContainerID, + deleteNetworkContainerURL string, + expectError bool) error { var ( body bytes.Buffer resp cns.UnpublishNetworkContainerResponse ) - networkID := "vnet1" - networkContainerID := "ethWebApp" + fmt.Println("Test: unpublishNetworkContainer") + joinNetworkURL := "http://" + nmagentEndpoint + "/dummyVnetURL" - deleteNetworkContainerURL := "http://" + nmagentEndpoint + "/networkContainers/dummyNCURL" unpublishNCRequest := &cns.UnpublishNetworkContainerRequest{ NetworkID: networkID, @@ -610,7 +682,7 @@ func TestUnpublishNCViaCNS(t *testing.T) { json.NewEncoder(&body).Encode(unpublishNCRequest) req, err := http.NewRequest(http.MethodPost, cns.UnpublishNetworkContainer, &body) if err != nil { - t.Fatal(err) + return err } w := httptest.NewRecorder() @@ -618,11 +690,15 @@ func TestUnpublishNCViaCNS(t *testing.T) { err = decodeResponse(w, &resp) if err != nil || resp.Response.ReturnCode != 0 { - t.Errorf("UnpublishNetworkContainer failed with response %+v Err:%+v", resp, err) - t.Fatal(err) + if(!expectError) { + t.Errorf("UnpublishNetworkContainer failed with response %+v Err:%+v", resp, err) + } + return err } fmt.Printf("UnpublishNetworkContainer succeded with response %+v, raw:%+v\n", resp, w.Body) + + return nil } func TestNmAgentSupportedApisHandler(t *testing.T) { diff --git a/cns/restserver/util.go b/cns/restserver/util.go index fe815fccda..4383ba61aa 100644 --- a/cns/restserver/util.go +++ b/cns/restserver/util.go @@ -623,12 +623,9 @@ func (service *HTTPRestService) setNetworkStateJoined(networkID string) { // Join Network by calling nmagent func (service *HTTPRestService) joinNetwork( - networkID string, - joinNetworkURL string) (*http.Response, error, error) { + networkID string) (*http.Response, error, error) { var err error - joinResponse, joinErr := nmagent.JoinNetwork( - networkID, - joinNetworkURL) + joinResponse, joinErr := nmagent.JoinNetwork(networkID) if joinErr == nil && joinResponse.StatusCode == http.StatusOK { // Network joined successfully From 42bbf91853591349023a431f355b8849cfe2d468 Mon Sep 17 00:00:00 2001 From: alegal Date: Tue, 18 Jan 2022 17:19:11 -0800 Subject: [PATCH 03/13] addressing feedback --- cns/NetworkContainerContract.go | 6 +++ cns/nmagent/client.go | 66 +++++++++++++++++++++++------ cns/restserver/api.go | 75 ++++++++++++++++++--------------- cns/restserver/api_test.go | 48 +++++---------------- 4 files changed, 111 insertions(+), 84 deletions(-) diff --git a/cns/NetworkContainerContract.go b/cns/NetworkContainerContract.go index a724eaf5bc..db5ad38894 100644 --- a/cns/NetworkContainerContract.go +++ b/cns/NetworkContainerContract.go @@ -463,6 +463,12 @@ type PublishNetworkContainerRequest struct { CreateNetworkContainerRequestBody []byte } +// NetworkContainerParameters parameters available in network container operations +type NetworkContainerParameters struct { + AuthToken string + AssociatedInterfaceID string +} + // PublishNetworkContainerResponse specifies the response to publish network container request. type PublishNetworkContainerResponse struct { Response Response diff --git a/cns/nmagent/client.go b/cns/nmagent/client.go index 231dedbc83..d623aa41e9 100644 --- a/cns/nmagent/client.go +++ b/cns/nmagent/client.go @@ -8,6 +8,7 @@ import ( "fmt" "io" "net/http" + "net/url" "time" "github.com/Azure/azure-container-networking/cns/logger" @@ -20,14 +21,16 @@ const ( 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" GetNcVersionListWithOutTokenURLFmt = "http://%s/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/api-version/%s" - JoinNetworkURLFmt = "http://%s/machine/plugins/?comp=nmagent&type=NetworkManagement/joinedVirtualNetworks/%s/api-version/1" - PutNetworkContainerUrlFmt = "http://%s/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/%s/networkContainers/%s/authenticationToken/%s/api-version/1" - DeleteNetworkContainerURLFmt = "http://%s/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/%s/networkContainers/%s/authenticationToken/%s/api-version/1/method/DELETE" + JoinNetworkURLFmt = "NetworkManagement/joinedVirtualNetworks/%s/api-version/1" + PutNetworkValueFmt = "NetworkManagement/interfaces/%s/networkContainers/%s/authenticationToken/%s/api-version/1" + DeleteNetworkContainerURLFmt = "NetworkManagement/interfaces/%s/networkContainers/%s/authenticationToken/%s/api-version/1/method/DELETE" ) // WireServerIP - wire server ip var ( WireserverIP = "168.63.129.16" + WireServerPath = "machine/plugins" + WireServerScheme = "http" getNcVersionListWithOutTokenURLVersion = "2" ) @@ -75,12 +78,23 @@ func JoinNetwork(networkID string) (*http.Response, error) { var body bytes.Buffer json.NewEncoder(&body).Encode("") - joinNetworkURL := fmt.Sprintf( + joinNetworkTypeValue := fmt.Sprintf( JoinNetworkURLFmt, - WireserverIP, networkID) - response, err := common.GetHttpClient().Post(joinNetworkURL, "application/json", &body) + joinNetworkUrl := url.URL{ + Host: WireserverIP, + Path: WireServerPath, + Scheme: WireServerScheme, + } + + queryString := joinNetworkUrl.Query() + queryString.Set("type", joinNetworkTypeValue) + queryString.Set("comp", "nmagent") + + joinNetworkUrl.RawQuery = queryString.Encode() + + response, err := common.GetHttpClient().Post(joinNetworkUrl.String(), "application/json", &body) if err == nil && response.StatusCode == http.StatusOK { defer response.Body.Close() @@ -96,15 +110,29 @@ func JoinNetwork(networkID string) (*http.Response, error) { func PublishNetworkContainer(networkContainerID, associatedInterfaceID, accessToken string, requestBodyData []byte) (*http.Response, error) { logger.Printf("[NMAgentClient] PublishNetworkContainer NC: %s", networkContainerID) - createNCURL := fmt.Sprintf( - PutNetworkContainerUrlFmt, - WireserverIP, + createNcTypeValue := fmt.Sprintf( + PutNetworkValueFmt, associatedInterfaceID, networkContainerID, accessToken) + createUrl := url.URL{ + Host: WireserverIP, + Path: WireServerPath, + Scheme: WireServerScheme, + } + + queryString := createUrl.Query() + queryString.Set("type", createNcTypeValue) + queryString.Set("comp", "nmagent") + + createUrl.RawQuery = queryString.Encode() + requestBody := bytes.NewBuffer(requestBodyData) - response, err := common.GetHttpClient().Post(createNCURL, "application/json", requestBody) + response, err := common.GetHttpClient().Post(createUrl.String(), "application/json", requestBody) + + logger.Printf("[NMAgentClient][Response] Create NC URL: %s", + createUrl.String()) logger.Printf("[NMAgentClient][Response] Publish NC: %s. Response: %+v. Error: %v", networkContainerID, response, err) @@ -116,17 +144,29 @@ func PublishNetworkContainer(networkContainerID, associatedInterfaceID, accessTo func UnpublishNetworkContainer(networkContainerID, associatedInterfaceID, accessToken string) (*http.Response, error) { logger.Printf("[NMAgentClient] UnpublishNetworkContainer NC: %s", networkContainerID) - deleteNCURL := fmt.Sprintf( + deleteNCTypeValue := fmt.Sprintf( DeleteNetworkContainerURLFmt, - WireserverIP, associatedInterfaceID, networkContainerID, accessToken) + deleteUrl := url.URL{ + Host: WireserverIP, + Path: WireServerPath, + Scheme: WireServerScheme, + } + + queryString := deleteUrl.Query() + queryString.Set("type", deleteNCTypeValue) + queryString.Set("comp", "nmagent") + + deleteUrl.RawQuery = queryString.Encode() + + // Empty body is required as wireserver cannot handle a post without the body. var body bytes.Buffer json.NewEncoder(&body).Encode("") - response, err := common.GetHttpClient().Post(deleteNCURL, "application/json", &body) + response, err := common.GetHttpClient().Post(deleteUrl.String(), "application/json", &body) logger.Printf("[NMAgentClient][Response] Unpublish NC: %s. Response: %+v. Error: %v", networkContainerID, response, err) diff --git a/cns/restserver/api.go b/cns/restserver/api.go index 84fb9a004c..0d13fbe845 100644 --- a/cns/restserver/api.go +++ b/cns/restserver/api.go @@ -24,6 +24,8 @@ import ( "github.com/Azure/azure-container-networking/platform" ) +var ncRegex = regexp.MustCompile(`NetworkManagement/interfaces/(.{0,36})/networkContainers/(.{0,36})/authenticationToken/(.{0,36})/api-version/1(/method/DELETE)?`) + // This file contains implementation of all HTTP APIs which are exposed to external clients. // TODO: break it even further per module (network, nc, etc) like it is done for ipam @@ -1073,11 +1075,11 @@ func (service *HTTPRestService) getNumberOfCPUCores(w http.ResponseWriter, r *ht logger.Response(service.Name, numOfCPUCoresResp, resp.ReturnCode, err) } -func getAuthTokenAndInterfaceIdFromNcURL(networkContainerURL string) (string, string, error) { +func getAuthTokenAndInterfaceIdFromNcURL(networkContainerURL string) (*cns.NetworkContainerParameters, error) { ncUrl, err := url.Parse(networkContainerURL) if err != nil { - return "", "", err + return nil, err } queryParams := ncUrl.Query() @@ -1086,27 +1088,18 @@ func getAuthTokenAndInterfaceIdFromNcURL(networkContainerURL string) (string, st // doing this parsing due to this structure typeQueryParamVal := queryParams.Get("type") if typeQueryParamVal == "" { - return "", "", fmt.Errorf("Invalid create container url format, no type query param") + return nil, fmt.Errorf("Invalid create container url format, no type query param") } // .{0,128} gets from zero to 128 characters of any kind // ()? is optional - ncRegex := regexp.MustCompile(`NetworkManagement/interfaces/(.{0,128})/networkContainers/(.{0,128})/authenticationToken/(.{0,128})/api-version/1(/method/DELETE)?`) matches := ncRegex.FindStringSubmatch(typeQueryParamVal) if len(matches) != 5 { - return "", "", fmt.Errorf("Invalid network container url format") + return nil, fmt.Errorf("Invalid network container url format") } - return matches[1], matches[3], err -} - -func extractHostFromJoinNetworkURL(urlToParse string) string { - parsedURL, err := url.Parse(urlToParse) - if err != nil { - return "" - } - return parsedURL.Host + return &cns.NetworkContainerParameters{AssociatedInterfaceID: matches[1], AuthToken: matches[3]}, err } // Publish Network Container by calling nmagent @@ -1146,11 +1139,22 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r return } - var associatedInterfaceID, authToken string - associatedInterfaceID, authToken, err = getAuthTokenAndInterfaceIdFromNcURL(creteNcUrlCopy) + var ncParameters *cns.NetworkContainerParameters + ncParameters, err = getAuthTokenAndInterfaceIdFromNcURL(creteNcUrlCopy) if err != nil { - logger.Errorf("[Azure-CNS] %+v", err) + logger.Errorf("[Azure-CNS] nc parameters validation failed with %+v", err) w.WriteHeader(http.StatusBadRequest) + + badRequestResponse := &cns.PublishNetworkContainerResponse{ + Response: cns.Response{ + ReturnCode: http.StatusBadRequest, + Message: fmt.Sprintf("Request contains a unexpected create url format in request body: %v", reqCopy.CreateNetworkContainerURL), + }, + PublishErrorStr: fmt.Sprintf("Bad request: Request contains a unexpected create url format in request body: %v", reqCopy.CreateNetworkContainerURL), + PublishStatusCode: http.StatusBadRequest, + } + err = service.Listener.Encode(w, &badRequestResponse) + logger.Response(service.Name, badRequestResponse, badRequestResponse.Response.ReturnCode, err) return } @@ -1169,8 +1173,8 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r // Publish Network Container publishResponse, publishError = nmagent.PublishNetworkContainer( req.NetworkContainerID, - associatedInterfaceID, - authToken, + ncParameters.AssociatedInterfaceID, + ncParameters.AuthToken, req.CreateNetworkContainerRequestBody) if publishError != nil || publishResponse.StatusCode != http.StatusOK { returnMessage = fmt.Sprintf("Failed to publish Network Container: %s", req.NetworkContainerID) @@ -1180,18 +1184,12 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r defer publishResponse.Body.Close() } - // we attempt to extract the wireserver IP to use from the request, otherwise default to the well-known IP. - hostIP := extractHostFromJoinNetworkURL(req.JoinNetworkURL) - if hostIP == "" { - hostIP = nmagent.WireserverIP - } - // Store ncGetVersionURL needed for calling NMAgent to check if vfp programming is completed for the NC ncGetVersionURL := fmt.Sprintf(nmagent.GetNetworkContainerVersionURLFmt, - hostIP, - associatedInterfaceID, + nmagent.WireserverIP, + ncParameters.AssociatedInterfaceID, req.NetworkContainerID, - authToken) + ncParameters.AuthToken) ncVersionURLs.Store(cns.SwiftPrefix+req.NetworkContainerID, ncGetVersionURL) default: @@ -1264,11 +1262,22 @@ func (service *HTTPRestService) unpublishNetworkContainer(w http.ResponseWriter, return } - var associatedInterfaceID, authToken string - associatedInterfaceID, authToken, err = getAuthTokenAndInterfaceIdFromNcURL(deleteNcUrlCopy) + var ncParameters *cns.NetworkContainerParameters + ncParameters, err = getAuthTokenAndInterfaceIdFromNcURL(deleteNcUrlCopy) if err != nil { - logger.Errorf("[Azure-CNS] %+v", err) + logger.Errorf("[Azure-CNS] nc parameters validation failed with %+v", err) w.WriteHeader(http.StatusBadRequest) + + badRequestResponse := &cns.UnpublishNetworkContainerResponse{ + Response: cns.Response{ + ReturnCode: http.StatusBadRequest, + Message: fmt.Sprintf("Request contains a unexpected delete url format in request body: %v", reqCopy.DeleteNetworkContainerURL), + }, + UnpublishErrorStr: fmt.Sprintf("Bad request: Request contains a unexpected delete url format in request body: %v", reqCopy.DeleteNetworkContainerURL), + UnpublishStatusCode: http.StatusBadRequest, + } + err = service.Listener.Encode(w, &badRequestResponse) + logger.Response(service.Name, badRequestResponse, badRequestResponse.Response.ReturnCode, err) return } @@ -1290,8 +1299,8 @@ func (service *HTTPRestService) unpublishNetworkContainer(w http.ResponseWriter, // Unpublish Network Container unpublishResponse, unpublishError = nmagent.UnpublishNetworkContainer( req.NetworkContainerID, - associatedInterfaceID, - authToken) + ncParameters.AssociatedInterfaceID, + ncParameters.AuthToken) if unpublishError != nil || unpublishResponse.StatusCode != http.StatusOK { returnMessage = fmt.Sprintf("Failed to unpublish Network Container: %s", req.NetworkContainerID) returnCode = types.NetworkContainerUnpublishFailed diff --git a/cns/restserver/api_test.go b/cns/restserver/api_test.go index b7a3c6e091..b45aacf00e 100644 --- a/cns/restserver/api_test.go +++ b/cns/restserver/api_test.go @@ -535,27 +535,25 @@ func TestPublishNCViaCNS(t *testing.T) { } createNetworkContainerURL = "http://" + nmagentEndpoint + - "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/" + - "e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6" + + "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationTok/" + + "8636c99d-7861-401f-b0d3-7e5b7dc8183c" + "/api-version/1" err = publishNCViaCNS(t, "vnet1", "ethWebApp", createNetworkContainerURL, true) if err == nil { - t.Fatal(err) + t.Fatal("Expected a bad request error due to create network url being incorrect") } createNetworkContainerURL = "http://" + nmagentEndpoint + "/machine/plugins/?comp=nmagent&NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/" + - "e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6" + + "8636c99d-7861-401f-b0d3-7e5b7dc8183c8636c99d-7861-401f-b0d3-7e5b7dc8183c" + "/api-version/1" err = publishNCViaCNS(t, "vnet1", "ethWebApp", createNetworkContainerURL, true) if err == nil { - t.Fatal(err) + t.Fatal("Expected a bad request error due to create network url having more characters than permitted in auth token") } - - } func publishNCViaCNS(t *testing.T, @@ -599,32 +597,6 @@ func publishNCViaCNS(t *testing.T, return nil } -func TestExtractHost(t *testing.T) { - joinURL := "http://127.0.0.1:9001/machine/plugins/?comp=nmagent&type=NetworkManagement/joinedVirtualNetworks/c9b8e695-2de1-11eb-bf54-000d3af666c8/api-version/1" - - host := extractHostFromJoinNetworkURL(joinURL) - expected := "127.0.0.1:9001" - if host != expected { - t.Fatalf("expected host %q, got %q", expected, host) - } - - joinURL = "http://168.63.129.16/machine/plugins/?comp=nmagent&type=NetworkManagement/joinedVirtualNetworks/4941a21f-1a8d-4d0f-8256-cc6e73a8cd22/api-version/1" - - host = extractHostFromJoinNetworkURL(joinURL) - expected = "168.63.129.16" - if host != expected { - t.Fatalf("expected host %q, got %q", expected, host) - } - - joinURL = "http://168.63.129.16/joinedVirtualNetworks/4941a21f-1a8d-4d0f-8256-cc6e73a8cd22/api-version/1" - - host = extractHostFromJoinNetworkURL(joinURL) - expected = "168.63.129.16" - if host != expected { - t.Fatalf("expected host %q, got %q", expected, host) - } -} - func TestUnpublishNCViaCNS(t *testing.T){ deleteNetworkContainerURL := "http://" + nmagentEndpoint + @@ -635,24 +607,24 @@ func TestUnpublishNCViaCNS(t *testing.T){ } deleteNetworkContainerURL = "http://" + nmagentEndpoint + - "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/" + - "e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6" + + "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToke/" + + "8636c99d-7861-401f-b0d3-7e5b7dc8183c" + "/api-version/1/method/DELETE" err = publishNCViaCNS(t, "vnet1", "ethWebApp", deleteNetworkContainerURL, true) if err == nil { - t.Fatal(err) + t.Fatal("Expected a bad request error due to delete network url being incorrect") } deleteNetworkContainerURL = "http://" + nmagentEndpoint + "/machine/plugins/?comp=nmagent&NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/" + - "e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6e2b5c004-afbc-4a17-9cd8-6878fbee8ed6" + + "8636c99d-7861-401f-b0d3-7e5b7dc8183c8636c99d-7861-401f-b0d3-7e5b7dc8183c" + "/api-version/1/method/DELETE" err = testUnpublishNCViaCNS(t, "vnet1", "ethWebApp", deleteNetworkContainerURL, true) if err == nil { - t.Fatal(err) + t.Fatal("Expected a bad request error due to create network url having more characters than permitted in auth token") } } From 51f07edace7a4416031255a0262e5505295c6466 Mon Sep 17 00:00:00 2001 From: alegal Date: Wed, 19 Jan 2022 20:25:07 -0800 Subject: [PATCH 04/13] fix linting issues --- cns/NetworkContainerContract.go | 2 +- cns/nmagent/client.go | 32 ++++++++++++++----------------- cns/restserver/api.go | 34 ++++++++++++++++++++++----------- cns/restserver/api_test.go | 10 ++++------ 4 files changed, 42 insertions(+), 36 deletions(-) diff --git a/cns/NetworkContainerContract.go b/cns/NetworkContainerContract.go index db5ad38894..b5b9d2626f 100644 --- a/cns/NetworkContainerContract.go +++ b/cns/NetworkContainerContract.go @@ -465,7 +465,7 @@ type PublishNetworkContainerRequest struct { // NetworkContainerParameters parameters available in network container operations type NetworkContainerParameters struct { - AuthToken string + AuthToken string AssociatedInterfaceID string } diff --git a/cns/nmagent/client.go b/cns/nmagent/client.go index d623aa41e9..f246f113b6 100644 --- a/cns/nmagent/client.go +++ b/cns/nmagent/client.go @@ -29,8 +29,8 @@ const ( // WireServerIP - wire server ip var ( WireserverIP = "168.63.129.16" - WireServerPath = "machine/plugins" - WireServerScheme = "http" + WireServerPath = "machine/plugins" + WireServerScheme = "http" getNcVersionListWithOutTokenURLVersion = "2" ) @@ -82,19 +82,19 @@ func JoinNetwork(networkID string) (*http.Response, error) { JoinNetworkURLFmt, networkID) - joinNetworkUrl := url.URL{ + joinNetworkURL := url.URL{ Host: WireserverIP, Path: WireServerPath, Scheme: WireServerScheme, } - queryString := joinNetworkUrl.Query() + queryString := joinNetworkURL.Query() queryString.Set("type", joinNetworkTypeValue) queryString.Set("comp", "nmagent") - joinNetworkUrl.RawQuery = queryString.Encode() + joinNetworkURL.RawQuery = queryString.Encode() - response, err := common.GetHttpClient().Post(joinNetworkUrl.String(), "application/json", &body) + response, err := common.GetHttpClient().Post(joinNetworkURL.String(), "application/json", &body) if err == nil && response.StatusCode == http.StatusOK { defer response.Body.Close() @@ -116,23 +116,20 @@ func PublishNetworkContainer(networkContainerID, associatedInterfaceID, accessTo networkContainerID, accessToken) - createUrl := url.URL{ + createURL := url.URL{ Host: WireserverIP, Path: WireServerPath, Scheme: WireServerScheme, } - queryString := createUrl.Query() + queryString := createURL.Query() queryString.Set("type", createNcTypeValue) queryString.Set("comp", "nmagent") - createUrl.RawQuery = queryString.Encode() + createURL.RawQuery = queryString.Encode() requestBody := bytes.NewBuffer(requestBodyData) - response, err := common.GetHttpClient().Post(createUrl.String(), "application/json", requestBody) - - logger.Printf("[NMAgentClient][Response] Create NC URL: %s", - createUrl.String()) + response, err := common.GetHttpClient().Post(createURL.String(), "application/json", requestBody) logger.Printf("[NMAgentClient][Response] Publish NC: %s. Response: %+v. Error: %v", networkContainerID, response, err) @@ -150,23 +147,22 @@ func UnpublishNetworkContainer(networkContainerID, associatedInterfaceID, access networkContainerID, accessToken) - deleteUrl := url.URL{ + deleteURL := url.URL{ Host: WireserverIP, Path: WireServerPath, Scheme: WireServerScheme, } - queryString := deleteUrl.Query() + queryString := deleteURL.Query() queryString.Set("type", deleteNCTypeValue) queryString.Set("comp", "nmagent") - deleteUrl.RawQuery = queryString.Encode() - + deleteURL.RawQuery = queryString.Encode() // Empty body is required as wireserver cannot handle a post without the body. var body bytes.Buffer json.NewEncoder(&body).Encode("") - response, err := common.GetHttpClient().Post(deleteUrl.String(), "application/json", &body) + response, err := common.GetHttpClient().Post(deleteURL.String(), "application/json", &body) logger.Printf("[NMAgentClient][Response] Unpublish NC: %s. Response: %+v. Error: %v", networkContainerID, response, err) diff --git a/cns/restserver/api.go b/cns/restserver/api.go index 0d13fbe845..52ea99e20f 100644 --- a/cns/restserver/api.go +++ b/cns/restserver/api.go @@ -5,6 +5,7 @@ package restserver import ( "context" + "errors" "fmt" "io" "net" @@ -24,7 +25,18 @@ import ( "github.com/Azure/azure-container-networking/platform" ) -var ncRegex = regexp.MustCompile(`NetworkManagement/interfaces/(.{0,36})/networkContainers/(.{0,36})/authenticationToken/(.{0,36})/api-version/1(/method/DELETE)?`) +var ( + ncRegex = regexp.MustCompile(`NetworkManagement/interfaces/(.{0,36})/networkContainers/(.{0,36})/authenticationToken/(.{0,36})/api-version/1(/method/DELETE)?`) + invalidNcURLFormatErr = errors.New("Invalid network container url format") +) + +// ncURLExpectedMatches defines the size of matches expected from exercising the ncRegex +// 1) the original url (nuance related to golangs regex package) +// 2) the associated interface parameter +// 3) the ncid parameter +// 4) the authentication token parameter +// 5) the optional delete path +const ncURLExpectedMatches = 5 // This file contains implementation of all HTTP APIs which are exposed to external clients. // TODO: break it even further per module (network, nc, etc) like it is done for ipam @@ -1075,7 +1087,7 @@ func (service *HTTPRestService) getNumberOfCPUCores(w http.ResponseWriter, r *ht logger.Response(service.Name, numOfCPUCoresResp, resp.ReturnCode, err) } -func getAuthTokenAndInterfaceIdFromNcURL(networkContainerURL string) (*cns.NetworkContainerParameters, error) { +func getAuthTokenAndInterfaceIDFromNcURL(networkContainerURL string) (*cns.NetworkContainerParameters, error) { ncUrl, err := url.Parse(networkContainerURL) if err != nil { @@ -1088,15 +1100,15 @@ func getAuthTokenAndInterfaceIdFromNcURL(networkContainerURL string) (*cns.Netwo // doing this parsing due to this structure typeQueryParamVal := queryParams.Get("type") if typeQueryParamVal == "" { - return nil, fmt.Errorf("Invalid create container url format, no type query param") + return nil, fmt.Errorf("no type query param, %w", invalidNcURLFormatErr) } // .{0,128} gets from zero to 128 characters of any kind // ()? is optional matches := ncRegex.FindStringSubmatch(typeQueryParamVal) - if len(matches) != 5 { - return nil, fmt.Errorf("Invalid network container url format") + if len(matches) != ncURLExpectedMatches { + return nil, invalidNcURLFormatErr } return &cns.NetworkContainerParameters{AssociatedInterfaceID: matches[1], AuthToken: matches[3]}, err @@ -1121,7 +1133,7 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r err = service.Listener.Decode(w, r, &req) - creteNcUrlCopy := req.CreateNetworkContainerURL + creteNcURLCopy := req.CreateNetworkContainerURL // reqCopy creates a copy of incoming request. It doesn't copy the authentication token info // to avoid logging it. @@ -1140,7 +1152,7 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r } var ncParameters *cns.NetworkContainerParameters - ncParameters, err = getAuthTokenAndInterfaceIdFromNcURL(creteNcUrlCopy) + ncParameters, err = getAuthTokenAndInterfaceIDFromNcURL(creteNcURLCopy) if err != nil { logger.Errorf("[Azure-CNS] nc parameters validation failed with %+v", err) w.WriteHeader(http.StatusBadRequest) @@ -1150,7 +1162,7 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r ReturnCode: http.StatusBadRequest, Message: fmt.Sprintf("Request contains a unexpected create url format in request body: %v", reqCopy.CreateNetworkContainerURL), }, - PublishErrorStr: fmt.Sprintf("Bad request: Request contains a unexpected create url format in request body: %v", reqCopy.CreateNetworkContainerURL), + PublishErrorStr: fmt.Sprintf("Bad request: Request contains a unexpected create url format in request body: %v", reqCopy.CreateNetworkContainerURL), PublishStatusCode: http.StatusBadRequest, } err = service.Listener.Encode(w, &badRequestResponse) @@ -1246,7 +1258,7 @@ func (service *HTTPRestService) unpublishNetworkContainer(w http.ResponseWriter, err = service.Listener.Decode(w, r, &req) - deleteNcUrlCopy := req.DeleteNetworkContainerURL + deleteNcURLCopy := req.DeleteNetworkContainerURL // reqCopy creates a copy of incoming request. It doesn't copy the authentication token info // to avoid logging it. @@ -1263,7 +1275,7 @@ func (service *HTTPRestService) unpublishNetworkContainer(w http.ResponseWriter, } var ncParameters *cns.NetworkContainerParameters - ncParameters, err = getAuthTokenAndInterfaceIdFromNcURL(deleteNcUrlCopy) + ncParameters, err = getAuthTokenAndInterfaceIDFromNcURL(deleteNcURLCopy) if err != nil { logger.Errorf("[Azure-CNS] nc parameters validation failed with %+v", err) w.WriteHeader(http.StatusBadRequest) @@ -1273,7 +1285,7 @@ func (service *HTTPRestService) unpublishNetworkContainer(w http.ResponseWriter, ReturnCode: http.StatusBadRequest, Message: fmt.Sprintf("Request contains a unexpected delete url format in request body: %v", reqCopy.DeleteNetworkContainerURL), }, - UnpublishErrorStr: fmt.Sprintf("Bad request: Request contains a unexpected delete url format in request body: %v", reqCopy.DeleteNetworkContainerURL), + UnpublishErrorStr: fmt.Sprintf("Bad request: Request contains a unexpected delete url format in request body: %v", reqCopy.DeleteNetworkContainerURL), UnpublishStatusCode: http.StatusBadRequest, } err = service.Listener.Encode(w, &badRequestResponse) diff --git a/cns/restserver/api_test.go b/cns/restserver/api_test.go index b45aacf00e..00462b4ce5 100644 --- a/cns/restserver/api_test.go +++ b/cns/restserver/api_test.go @@ -549,7 +549,6 @@ func TestPublishNCViaCNS(t *testing.T) { "8636c99d-7861-401f-b0d3-7e5b7dc8183c8636c99d-7861-401f-b0d3-7e5b7dc8183c" + "/api-version/1" - err = publishNCViaCNS(t, "vnet1", "ethWebApp", createNetworkContainerURL, true) if err == nil { t.Fatal("Expected a bad request error due to create network url having more characters than permitted in auth token") @@ -586,8 +585,8 @@ func publishNCViaCNS(t *testing.T, mux.ServeHTTP(w, req) err = decodeResponse(w, &resp) - if err != nil || resp.Response.ReturnCode != 0 { - if(!expectError) { + if err != nil || resp.Response.ReturnCode != 0 { + if !expectError { t.Errorf("PublishNetworkContainer failed with response %+v Err:%+v", resp, err) } return err @@ -597,7 +596,7 @@ func publishNCViaCNS(t *testing.T, return nil } -func TestUnpublishNCViaCNS(t *testing.T){ +func TestUnpublishNCViaCNS(t *testing.T) { deleteNetworkContainerURL := "http://" + nmagentEndpoint + "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/dummyT/api-version/1/method/DELETE" @@ -621,7 +620,6 @@ func TestUnpublishNCViaCNS(t *testing.T){ "8636c99d-7861-401f-b0d3-7e5b7dc8183c8636c99d-7861-401f-b0d3-7e5b7dc8183c" + "/api-version/1/method/DELETE" - err = testUnpublishNCViaCNS(t, "vnet1", "ethWebApp", deleteNetworkContainerURL, true) if err == nil { t.Fatal("Expected a bad request error due to create network url having more characters than permitted in auth token") @@ -662,7 +660,7 @@ func testUnpublishNCViaCNS(t *testing.T, err = decodeResponse(w, &resp) if err != nil || resp.Response.ReturnCode != 0 { - if(!expectError) { + if !expectError { t.Errorf("UnpublishNetworkContainer failed with response %+v Err:%+v", resp, err) } return err From 353e314b498832bf75de1967505a4ea9e0a0a444 Mon Sep 17 00:00:00 2001 From: alegal Date: Thu, 20 Jan 2022 08:16:47 -0800 Subject: [PATCH 05/13] update getncversion test --- cns/restserver/api_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cns/restserver/api_test.go b/cns/restserver/api_test.go index 00462b4ce5..3e2579ba5f 100644 --- a/cns/restserver/api_test.go +++ b/cns/restserver/api_test.go @@ -516,7 +516,7 @@ func createNC( } createNetworkContainerURL := "http://" + nmagentEndpoint + - "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/dummyT/api-version/" + "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/dummyT/api-version/1" err := publishNCViaCNS(t, params.vnetID, params.ncID, createNetworkContainerURL, false) if err != nil { From 051ed3b62104189f927a81d5e058ff16c31ce65f Mon Sep 17 00:00:00 2001 From: alegal Date: Thu, 20 Jan 2022 09:37:11 -0800 Subject: [PATCH 06/13] fix test issue where nmagent handler returns 500 --- cns/restserver/api_test.go | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/cns/restserver/api_test.go b/cns/restserver/api_test.go index 3e2579ba5f..6504fd9086 100644 --- a/cns/restserver/api_test.go +++ b/cns/restserver/api_test.go @@ -416,7 +416,7 @@ func TestGetNetworkContainerVersionStatus(t *testing.T) { podNamespace: "testpodnamespace", } - createNC(t, params) + createNC(t, params, false) if err := getNetworkContainerByContext(t, params); err != nil { t.Errorf("TestGetNetworkContainerByOrchestratorContext failed Err:%+v", err) @@ -447,7 +447,7 @@ func TestGetNetworkContainerVersionStatus(t *testing.T) { podNamespace: "testpodnamespace", } - createNC(t, params) + createNC(t, params, false) if err := getNetworkContainerByContextExpectedError(t, params); err != nil { t.Errorf("TestGetNetworkContainerVersionStatus failed") @@ -471,7 +471,7 @@ func TestGetNetworkContainerVersionStatus(t *testing.T) { podNamespace: "testpodnamespace", } - createNC(t, params) + createNC(t, params, true) if err := getNetworkContainerByContext(t, params); err != nil { t.Errorf("TestGetNetworkContainerVersionStatus failed") @@ -494,7 +494,7 @@ func TestGetNetworkContainerVersionStatus(t *testing.T) { podNamespace: "testpodnamespace", } - createNC(t, params) + createNC(t, params, false) if err := getNetworkContainerByContextExpectedError(t, params); err != nil { t.Errorf("TestGetNetworkContainerVersionStatus failed") @@ -509,7 +509,8 @@ func TestGetNetworkContainerVersionStatus(t *testing.T) { func createNC( t *testing.T, - params createOrUpdateNetworkContainerParams) { + params createOrUpdateNetworkContainerParams, + expectError bool) { if err := createOrUpdateNetworkContainerWithParams(t, params); err != nil { t.Errorf("createOrUpdateNetworkContainerWithParams failed Err:%+v", err) t.Fatal(err) @@ -518,7 +519,7 @@ func createNC( createNetworkContainerURL := "http://" + nmagentEndpoint + "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/dummyT/api-version/1" - err := publishNCViaCNS(t, params.vnetID, params.ncID, createNetworkContainerURL, false) + err := publishNCViaCNS(t, params.vnetID, params.ncID, createNetworkContainerURL, expectError) if err != nil { t.Fatal(err) } From cb9f3b828e7a957d5b741a4b65ae6c8d81ba6f8b Mon Sep 17 00:00:00 2001 From: alegal Date: Wed, 26 Jan 2022 12:01:31 -0800 Subject: [PATCH 07/13] update for linter --- cns/restserver/api.go | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/cns/restserver/api.go b/cns/restserver/api.go index 52ea99e20f..1ddcf056f3 100644 --- a/cns/restserver/api.go +++ b/cns/restserver/api.go @@ -27,7 +27,7 @@ import ( var ( ncRegex = regexp.MustCompile(`NetworkManagement/interfaces/(.{0,36})/networkContainers/(.{0,36})/authenticationToken/(.{0,36})/api-version/1(/method/DELETE)?`) - invalidNcURLFormatErr = errors.New("Invalid network container url format") + ErrInvalidNcURLFormat = errors.New("Invalid network container url format") ) // ncURLExpectedMatches defines the size of matches expected from exercising the ncRegex @@ -1089,18 +1089,18 @@ func (service *HTTPRestService) getNumberOfCPUCores(w http.ResponseWriter, r *ht func getAuthTokenAndInterfaceIDFromNcURL(networkContainerURL string) (*cns.NetworkContainerParameters, error) { - ncUrl, err := url.Parse(networkContainerURL) + ncURL, err := url.Parse(networkContainerURL) if err != nil { - return nil, err + return nil, fmt.Errorf("failed to parse network container url, %w", err) } - queryParams := ncUrl.Query() + queryParams := ncURL.Query() // current format of create network url has a path after a query parameter "type" // doing this parsing due to this structure typeQueryParamVal := queryParams.Get("type") if typeQueryParamVal == "" { - return nil, fmt.Errorf("no type query param, %w", invalidNcURLFormatErr) + return nil, fmt.Errorf("no type query param, %w", ErrInvalidNcURLFormat) } // .{0,128} gets from zero to 128 characters of any kind @@ -1108,10 +1108,10 @@ func getAuthTokenAndInterfaceIDFromNcURL(networkContainerURL string) (*cns.Netwo matches := ncRegex.FindStringSubmatch(typeQueryParamVal) if len(matches) != ncURLExpectedMatches { - return nil, invalidNcURLFormatErr + return nil, fmt.Errorf("unexpected number of matches in url, %w", ErrInvalidNcURLFormat) } - return &cns.NetworkContainerParameters{AssociatedInterfaceID: matches[1], AuthToken: matches[3]}, err + return &cns.NetworkContainerParameters{AssociatedInterfaceID: matches[1], AuthToken: matches[3]}, nil } // Publish Network Container by calling nmagent From e433e4f7542437d429a9a238c899c2ab2c75ccf7 Mon Sep 17 00:00:00 2001 From: alegal Date: Mon, 31 Jan 2022 12:13:42 -0800 Subject: [PATCH 08/13] address comments --- cns/nmagent/client.go | 6 +++--- cns/restserver/api.go | 8 ++++++++ cns/restserver/api_test.go | 3 ++- common/utils.go | 11 +++++++++++ 4 files changed, 24 insertions(+), 4 deletions(-) diff --git a/cns/nmagent/client.go b/cns/nmagent/client.go index f246f113b6..ce0d8c5db7 100644 --- a/cns/nmagent/client.go +++ b/cns/nmagent/client.go @@ -94,7 +94,7 @@ func JoinNetwork(networkID string) (*http.Response, error) { joinNetworkURL.RawQuery = queryString.Encode() - response, err := common.GetHttpClient().Post(joinNetworkURL.String(), "application/json", &body) + response, err := common.PostCtx(context.TODO(), common.GetHttpClient(), joinNetworkURL.String(), "application/json", &body) if err == nil && response.StatusCode == http.StatusOK { defer response.Body.Close() @@ -129,7 +129,7 @@ func PublishNetworkContainer(networkContainerID, associatedInterfaceID, accessTo createURL.RawQuery = queryString.Encode() requestBody := bytes.NewBuffer(requestBodyData) - response, err := common.GetHttpClient().Post(createURL.String(), "application/json", requestBody) + response, err := common.PostCtx(context.TODO(), common.GetHttpClient(), createURL.String(), "application/json", requestBody) logger.Printf("[NMAgentClient][Response] Publish NC: %s. Response: %+v. Error: %v", networkContainerID, response, err) @@ -162,7 +162,7 @@ func UnpublishNetworkContainer(networkContainerID, associatedInterfaceID, access // Empty body is required as wireserver cannot handle a post without the body. var body bytes.Buffer json.NewEncoder(&body).Encode("") - response, err := common.GetHttpClient().Post(deleteURL.String(), "application/json", &body) + response, err := common.PostCtx(context.TODO(), common.GetHttpClient(), deleteURL.String(), "application/json", &body) logger.Printf("[NMAgentClient][Response] Unpublish NC: %s. Response: %+v. Error: %v", networkContainerID, response, err) diff --git a/cns/restserver/api.go b/cns/restserver/api.go index 1ddcf056f3..d60763043e 100644 --- a/cns/restserver/api.go +++ b/cns/restserver/api.go @@ -1173,6 +1173,10 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r switch r.Method { case "POST": // Join the network + + // nolint:bodyclose + // Please refactor this + // do not reuse the below variable between network join and publish publishResponse, publishError, err = service.joinNetwork(req.NetworkID) if err == nil { isNetworkJoined = true @@ -1296,6 +1300,10 @@ func (service *HTTPRestService) unpublishNetworkContainer(w http.ResponseWriter, switch r.Method { case "POST": // Join Network if not joined already + + // nolint:bodyclose + // Please refactor this + // do not reuse the below variable between network join and unpublish isNetworkJoined = service.isNetworkJoined(req.NetworkID) if !isNetworkJoined { unpublishResponse, unpublishError, err = service.joinNetwork(req.NetworkID) diff --git a/cns/restserver/api_test.go b/cns/restserver/api_test.go index 6504fd9086..0e1ab29dae 100644 --- a/cns/restserver/api_test.go +++ b/cns/restserver/api_test.go @@ -507,6 +507,7 @@ func TestGetNetworkContainerVersionStatus(t *testing.T) { } } +//nolint:gocritic // param is just for testing func createNC( t *testing.T, params createOrUpdateNetworkContainerParams, @@ -532,7 +533,7 @@ func TestPublishNCViaCNS(t *testing.T) { "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/dummyT/api-version/1" err := publishNCViaCNS(t, "vnet1", "ethWebApp", createNetworkContainerURL, false) if err != nil { - t.Fatal(err) + t.Fatal(fmt.Errorf("publish container failed %w ",err)) } createNetworkContainerURL = "http://" + nmagentEndpoint + diff --git a/common/utils.go b/common/utils.go index 423a9e6100..89068718cc 100644 --- a/common/utils.go +++ b/common/utils.go @@ -4,6 +4,7 @@ package common import ( + "context" "encoding/binary" "encoding/json" "encoding/xml" @@ -287,3 +288,13 @@ func GetExecutableDirectory() (string, error) { return dir, err } + +func PostCtx(ctx context.Context, cl *http.Client, url string, contentType string, body io.Reader) (*http.Response, error) { + req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, body) + if err != nil { + return nil, fmt.Errorf("could not create POST request: %w", err) + } + + req.Header.Set("Content-Type", contentType) + return cl.Do(req) +} From cc25a2d74a196627833fc3839577841fb41a65bb Mon Sep 17 00:00:00 2001 From: alegal Date: Mon, 31 Jan 2022 13:10:56 -0800 Subject: [PATCH 09/13] small liniter changes --- cns/restserver/api_test.go | 6 +++--- common/utils.go | 12 ++++++++++-- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/cns/restserver/api_test.go b/cns/restserver/api_test.go index 0e1ab29dae..e3b5bfea95 100644 --- a/cns/restserver/api_test.go +++ b/cns/restserver/api_test.go @@ -533,7 +533,7 @@ func TestPublishNCViaCNS(t *testing.T) { "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/dummyT/api-version/1" err := publishNCViaCNS(t, "vnet1", "ethWebApp", createNetworkContainerURL, false) if err != nil { - t.Fatal(fmt.Errorf("publish container failed %w ",err)) + t.Fatal(fmt.Errorf("publish container failed %w ", err)) } createNetworkContainerURL = "http://" + nmagentEndpoint + @@ -580,7 +580,7 @@ func publishNCViaCNS(t *testing.T, json.NewEncoder(&body).Encode(publishNCRequest) req, err := http.NewRequest(http.MethodPost, cns.PublishNetworkContainer, &body) if err != nil { - return err + return fmt.Errorf("Failed to create publish request %w", err) } w := httptest.NewRecorder() @@ -654,7 +654,7 @@ func testUnpublishNCViaCNS(t *testing.T, json.NewEncoder(&body).Encode(unpublishNCRequest) req, err := http.NewRequest(http.MethodPost, cns.UnpublishNetworkContainer, &body) if err != nil { - return err + return fmt.Errorf("Failed to create unpublish request %w", err) } w := httptest.NewRecorder() diff --git a/common/utils.go b/common/utils.go index 89068718cc..75cd58985b 100644 --- a/common/utils.go +++ b/common/utils.go @@ -289,12 +289,20 @@ func GetExecutableDirectory() (string, error) { return dir, err } -func PostCtx(ctx context.Context, cl *http.Client, url string, contentType string, body io.Reader) (*http.Response, error) { +func PostCtx(ctx context.Context, cl *http.Client, url, contentType string, body io.Reader) (*http.Response, error) { req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, body) if err != nil { return nil, fmt.Errorf("could not create POST request: %w", err) } req.Header.Set("Content-Type", contentType) - return cl.Do(req) + var resp *http.Response + resp, err = cl.Do(req) + if err != nil { + // returning response as well + // cause some methods seem to depend on that for error handling + return resp, fmt.Errorf("POST request recieved response %w", err) + } + + return resp, nil } From 6f0ff4445bffac324bf46a3e245f08d5a28a14cb Mon Sep 17 00:00:00 2001 From: alegal Date: Mon, 31 Jan 2022 13:39:59 -0800 Subject: [PATCH 10/13] quick linting changes --- cns/restserver/api.go | 7 ++++--- common/utils.go | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/cns/restserver/api.go b/cns/restserver/api.go index d60763043e..81bea492d5 100644 --- a/cns/restserver/api.go +++ b/cns/restserver/api.go @@ -1173,8 +1173,7 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r switch r.Method { case "POST": // Join the network - - // nolint:bodyclose + // Please refactor this // do not reuse the below variable between network join and publish publishResponse, publishError, err = service.joinNetwork(req.NetworkID) @@ -1187,6 +1186,8 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r if isNetworkJoined { // Publish Network Container + + // nolint:bodyclose // existing code needs refactoring publishResponse, publishError = nmagent.PublishNetworkContainer( req.NetworkContainerID, ncParameters.AssociatedInterfaceID, @@ -1301,11 +1302,11 @@ func (service *HTTPRestService) unpublishNetworkContainer(w http.ResponseWriter, case "POST": // Join Network if not joined already - // nolint:bodyclose // Please refactor this // do not reuse the below variable between network join and unpublish isNetworkJoined = service.isNetworkJoined(req.NetworkID) if !isNetworkJoined { + // nolint:bodyclose // existing code needs refactoring unpublishResponse, unpublishError, err = service.joinNetwork(req.NetworkID) if err == nil { isNetworkJoined = true diff --git a/common/utils.go b/common/utils.go index 75cd58985b..40c7169579 100644 --- a/common/utils.go +++ b/common/utils.go @@ -301,7 +301,7 @@ func PostCtx(ctx context.Context, cl *http.Client, url, contentType string, body if err != nil { // returning response as well // cause some methods seem to depend on that for error handling - return resp, fmt.Errorf("POST request recieved response %w", err) + return resp, fmt.Errorf("POST request received response %w", err) } return resp, nil From 2a38852e3594da0fc79d35b9d88c3e7ca9c0e128 Mon Sep 17 00:00:00 2001 From: alegal Date: Mon, 31 Jan 2022 16:10:41 -0800 Subject: [PATCH 11/13] lint --- cns/restserver/api.go | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/cns/restserver/api.go b/cns/restserver/api.go index 81bea492d5..f6c7c0c58f 100644 --- a/cns/restserver/api.go +++ b/cns/restserver/api.go @@ -1173,9 +1173,9 @@ func (service *HTTPRestService) publishNetworkContainer(w http.ResponseWriter, r switch r.Method { case "POST": // Join the network - // Please refactor this // do not reuse the below variable between network join and publish + // nolint:bodyclose // existing code needs refactoring publishResponse, publishError, err = service.joinNetwork(req.NetworkID) if err == nil { isNetworkJoined = true @@ -1301,9 +1301,6 @@ func (service *HTTPRestService) unpublishNetworkContainer(w http.ResponseWriter, switch r.Method { case "POST": // Join Network if not joined already - - // Please refactor this - // do not reuse the below variable between network join and unpublish isNetworkJoined = service.isNetworkJoined(req.NetworkID) if !isNetworkJoined { // nolint:bodyclose // existing code needs refactoring From 9a91c3bf8953096f6c6ff72627a95c7e2e5055a7 Mon Sep 17 00:00:00 2001 From: alegal Date: Tue, 1 Feb 2022 11:03:22 -0800 Subject: [PATCH 12/13] use gofumpt instead of gofmt --- cns/restserver/api.go | 1 - cns/restserver/api_test.go | 6 ++---- cns/restserver/util.go | 19 ++++++++----------- 3 files changed, 10 insertions(+), 16 deletions(-) diff --git a/cns/restserver/api.go b/cns/restserver/api.go index f6c7c0c58f..b44c98e36b 100644 --- a/cns/restserver/api.go +++ b/cns/restserver/api.go @@ -1088,7 +1088,6 @@ func (service *HTTPRestService) getNumberOfCPUCores(w http.ResponseWriter, r *ht } func getAuthTokenAndInterfaceIDFromNcURL(networkContainerURL string) (*cns.NetworkContainerParameters, error) { - ncURL, err := url.Parse(networkContainerURL) if err != nil { return nil, fmt.Errorf("failed to parse network container url, %w", err) diff --git a/cns/restserver/api_test.go b/cns/restserver/api_test.go index e3b5bfea95..844cd0d115 100644 --- a/cns/restserver/api_test.go +++ b/cns/restserver/api_test.go @@ -599,7 +599,6 @@ func publishNCViaCNS(t *testing.T, } func TestUnpublishNCViaCNS(t *testing.T) { - deleteNetworkContainerURL := "http://" + nmagentEndpoint + "/machine/plugins/?comp=nmagent&type=NetworkManagement/interfaces/dummyIntf/networkContainers/dummyNCURL/authenticationToken/dummyT/api-version/1/method/DELETE" err := publishNCViaCNS(t, "vnet1", "ethWebApp", deleteNetworkContainerURL, false) @@ -626,15 +625,14 @@ func TestUnpublishNCViaCNS(t *testing.T) { if err == nil { t.Fatal("Expected a bad request error due to create network url having more characters than permitted in auth token") } - } func testUnpublishNCViaCNS(t *testing.T, networkID, networkContainerID, deleteNetworkContainerURL string, - expectError bool) error { - + expectError bool, +) error { var ( body bytes.Buffer resp cns.UnpublishNetworkContainerResponse diff --git a/cns/restserver/util.go b/cns/restserver/util.go index 4383ba61aa..135ad39bc8 100644 --- a/cns/restserver/util.go +++ b/cns/restserver/util.go @@ -130,14 +130,13 @@ func (service *HTTPRestService) saveNetworkContainerGoalState( createNetworkContainerRequest := req createNetworkContainerRequest.AuthorizationToken = "" - service.state.ContainerStatus[req.NetworkContainerid] = - containerstatus{ - ID: req.NetworkContainerid, - VMVersion: req.Version, - CreateNetworkContainerRequest: createNetworkContainerRequest, - HostVersion: hostVersion, - VfpUpdateComplete: vfpUpdateComplete, - } + service.state.ContainerStatus[req.NetworkContainerid] = containerstatus{ + ID: req.NetworkContainerid, + VMVersion: req.Version, + CreateNetworkContainerRequest: createNetworkContainerRequest, + HostVersion: hostVersion, + VfpUpdateComplete: vfpUpdateComplete, + } switch req.NetworkContainerType { case cns.AzureContainerInstance: @@ -316,7 +315,6 @@ func validateIPSubnet(ipSubnet cns.IPSubnet) error { func (service *HTTPRestService) removeToBeDeletedIPStateUntransacted( ipID string, skipValidation bool, ) (types.ResponseCode, string) { - // this is set if caller has already done the validation if !skipValidation { ipConfigStatus, exists := service.PodIPConfigState[ipID] @@ -373,8 +371,7 @@ func (service *HTTPRestService) getNetworkContainerResponse( if exists { // If the goal state is available with CNS, check if the NC is pending VFP programming - waitingForUpdate, getNetworkContainerResponse.Response.ReturnCode, getNetworkContainerResponse.Response.Message = - service.isNCWaitingForUpdate(service.state.ContainerStatus[containerID].CreateNetworkContainerRequest.Version, containerID) + waitingForUpdate, getNetworkContainerResponse.Response.ReturnCode, getNetworkContainerResponse.Response.Message = service.isNCWaitingForUpdate(service.state.ContainerStatus[containerID].CreateNetworkContainerRequest.Version, containerID) // If the return code is not success, return the error to the caller if getNetworkContainerResponse.Response.ReturnCode == types.NetworkContainerVfpProgramPending { logger.Errorf("[Azure-CNS] isNCWaitingForUpdate failed for NC: %s with error: %s", From de61d177d576a6444b692b6a52aaecbf426ef9fe Mon Sep 17 00:00:00 2001 From: aegal Date: Tue, 1 Feb 2022 21:06:34 +0000 Subject: [PATCH 13/13] ignore line count --- cns/restserver/util.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cns/restserver/util.go b/cns/restserver/util.go index 135ad39bc8..f64999fcfe 100644 --- a/cns/restserver/util.go +++ b/cns/restserver/util.go @@ -371,7 +371,7 @@ func (service *HTTPRestService) getNetworkContainerResponse( if exists { // If the goal state is available with CNS, check if the NC is pending VFP programming - waitingForUpdate, getNetworkContainerResponse.Response.ReturnCode, getNetworkContainerResponse.Response.Message = service.isNCWaitingForUpdate(service.state.ContainerStatus[containerID].CreateNetworkContainerRequest.Version, containerID) + waitingForUpdate, getNetworkContainerResponse.Response.ReturnCode, getNetworkContainerResponse.Response.Message = service.isNCWaitingForUpdate(service.state.ContainerStatus[containerID].CreateNetworkContainerRequest.Version, containerID) //nolint:lll // bad code // If the return code is not success, return the error to the caller if getNetworkContainerResponse.Response.ReturnCode == types.NetworkContainerVfpProgramPending { logger.Errorf("[Azure-CNS] isNCWaitingForUpdate failed for NC: %s with error: %s",