Port DeleteNetworkContainer and SetOrchestratorType from DNC (Azure#1454)

* Add DeleteNetworkContainer method to CNS Client DNC needs to delete network containers using CNS, and it currently does so through raw HTTP requests. This instead makes this an official operation within the CNS client so that it can be used there instead. * Remove return value from DeleteNetworkContainer The return value from DeleteNetworkContainer was basically unused in DeleteNetworkContainer, since it only contains a CNSResponse type which can only ever be a successful response. Given this, it's sufficient to just return no error as a signifier of success. * Add SetOrchestratorType endpoint to cns client DNC uses SetOrchestratorType currently by making straight HTTP requests to the CNS backend. Since we should have one client only, this moves these endpoints into the CNS client so that it can be consumed in DNC. * Fix two linter issues In one instance the linter had a false positive on an error that doesn't really need to be wrapped. The other was a good suggestion since it helps readers of the test understand what is going on. * Add CreateNetworkContainer endpoint to client Turns out DNC uses a few more endpoints than it would seem. This adds a CreateNetworkContainer method to encapsulate the /network/createorupdatenetworkcontainer endpoint. * Add a PublishNetworkContainer to CNS client Publishing network containers via CNS is something that DNC does directly through an HTTP client. Given how common this is, it makes sense to adopt this into the CNS client so that DNC can use the client instead. * Fix placeholder error message This was just used in testing and was forgotten. * Add context to DeleteNetworkContainer Everything involving the network should take a context parameter. * Fix PublishNetworkContainer return type The PublishNetworkContainer endpoint returns a wrapping type around the cns.Response. This updates the tests and the endpoint to reflect that. * Add UnpublishNC to CNS Client Unpublishing NCs is accomplished by DNC currently by directly making HTTP calls. This adds that functionality to the client so the client can be used instead.

Author: timraymond

cns/client/client.go

@@ -411,3 +411,247 @@ func (c *Client) GetHTTPServiceData(ctx context.Context) (*restserver.GetHTTPSer
 
 return &resp, nil
 }
+
+// DeleteNetworkContainer destroys the requested network container matching the
+// provided ID.
+func (c *Client) DeleteNetworkContainer(ctx context.Context, ncID string) error {
+// the network container ID is required by the API, so ensure that we have
+// one before we even make the request
+if ncID == "" {
+return errors.New("no network container ID provided")
+}
+
+// build the request
+dncr := cns.DeleteNetworkContainerRequest{
+NetworkContainerid: ncID,
+}
+body, err := json.Marshal(dncr)
+if err != nil {
+return errors.Wrap(err, "encoding request body")
+}
+u := c.routes[cns.DeleteNetworkContainer]
+req, err := http.NewRequest(http.MethodPost, u.String(), bytes.NewReader(body))
+if err != nil {
+return errors.Wrap(err, "building HTTP request")
+}
+
+// submit the request
+resp, err := c.client.Do(req)
+if err != nil {
+return errors.Wrap(err, "sending HTTP request")
+}
+defer resp.Body.Close()
+
+// decode the response
+var out cns.DeleteNetworkContainerResponse
+err = json.NewDecoder(resp.Body).Decode(&out)
+if err != nil {
+return errors.Wrap(err, "decoding response as JSON")
+}
+
+// if a non-zero response code was received from CNS, it means something went
+// wrong and it should be surfaced to the caller as an error
+if out.Response.ReturnCode != 0 {
+return errors.New(out.Response.Message)
+}
+
+// otherwise the response isn't terribly useful in a successful case, so it
+// doesn't make sense to provide it to callers. The absence of an error is
+// sufficient to communicate success.
+return nil
+}
+
+// SetOrchestratorType sets the orchestrator type for a given node
+func (c *Client) SetOrchestratorType(ctx context.Context, sotr cns.SetOrchestratorTypeRequest) error {
+// validate that the request has all of the required fields before we waste a
+// round trip
+if sotr.OrchestratorType == "" {
+return errors.New("request missing field OrchestratorType")
+}
+
+if sotr.DncPartitionKey == "" {
+return errors.New("request missing field DncPartitionKey")
+}
+
+if sotr.NodeID == "" {
+return errors.New("request missing field NodeID")
+}
+
+// build the HTTP request using the supplied request body
+// submit the request
+body, err := json.Marshal(sotr)
+if err != nil {
+return errors.Wrap(err, "encoding request body")
+}
+u := c.routes[cns.SetOrchestratorType]
+req, err := http.NewRequest(http.MethodPost, u.String(), bytes.NewReader(body))
+if err != nil {
+return errors.Wrap(err, "building HTTP request")
+}
+
+// send the request
+resp, err := c.client.Do(req)
+if err != nil {
+return errors.Wrap(err, "sending HTTP request")
+}
+defer resp.Body.Close()
+
+// decode the response
+var out cns.Response
+err = json.NewDecoder(resp.Body).Decode(&out)
+if err != nil {
+return errors.Wrap(err, "decoding JSON response")
+}
+
+// if there was a non-zero response code, this is an error that
+// should be communicated back to the caller...
+if out.ReturnCode != 0 {
+return errors.New(out.Message)
+}
+
+// ...otherwise it's a success and returning nil is sufficient to
+// communicate that
+return nil
+}
+
+// CreateNetworkContainer will create the provided network container, or update
+// an existing one if one already exists.
+func (c *Client) CreateNetworkContainer(ctx context.Context, cncr cns.CreateNetworkContainerRequest) error {
+// CreateNetworkContainerRequest is a deep and complicated struct, so
+// validating fields before we send it off is difficult and likely redundant
+// since the backend will have similar checks. However, we can be pretty
+// certain that if the NetworkContainerid is missing, it's likely an invalid
+// request (since that parameter is mandatory).
+if cncr.NetworkContainerid == "" {
+return errors.New("empty request provided")
+}
+
+// build the request using the supplied struct and the client's internal
+// routes
+body, err := json.Marshal(cncr)
+if err != nil {
+return errors.Wrap(err, "encoding request as JSON")
+}
+u := c.routes[cns.CreateOrUpdateNetworkContainer]
+req, err := http.NewRequest(http.MethodPost, u.String(), bytes.NewReader(body))
+if err != nil {
+return errors.Wrap(err, "building HTTP request")
+}
+
+// send the request
+resp, err := c.client.Do(req)
+if err != nil {
+return errors.Wrap(err, "sending HTTP request")
+}
+defer resp.Body.Close()
+
+// decode the response
+var out cns.Response
+err = json.NewDecoder(resp.Body).Decode(&out)
+if err != nil {
+return errors.Wrap(err, "decoding JSON response")
+}
+
+// if there was a non-zero response code, this is an error that
+// should be communicated back to the caller...
+if out.ReturnCode != 0 {
+return errors.New(out.Message)
+}
+
+// ...otherwise the request was successful so
+return nil
+}
+
+// PublishNetworkContainer publishes the provided network container via the
+// NMAgent resident on the node where CNS is running. This effectively proxies
+// the publication through CNS which can be useful for avoiding throttling
+// issues from Wireserver.
+func (c *Client) PublishNetworkContainer(ctx context.Context, pncr cns.PublishNetworkContainerRequest) error {
+// Given that the PublishNetworkContainer endpoint is intended to publish
+// network containers, it's reasonable to assume that the request is invalid
+// if it's missing a NetworkContainerID. Check for its presence and
+// pre-emptively fail if that ID is missing:
+if pncr.NetworkContainerID == "" {
+return errors.New("network container id missing from request")
+}
+
+// Now that the request is valid it can be packaged as an HTTP request:
+body, err := json.Marshal(pncr)
+if err != nil {
+return errors.Wrap(err, "encoding request body as json")
+}
+u := c.routes[cns.PublishNetworkContainer]
+req, err := http.NewRequest(http.MethodPost, u.String(), bytes.NewReader(body))
+if err != nil {
+return errors.Wrap(err, "building HTTP request")
+}
+
+// send the HTTP request
+resp, err := c.client.Do(req)
+if err != nil {
+return errors.Wrap(err, "sending HTTP request")
+}
+defer resp.Body.Close()
+
+// decode the response to see if it was successful
+var out cns.PublishNetworkContainerResponse
+err = json.NewDecoder(resp.Body).Decode(&out)
+if err != nil {
+return errors.Wrap(err, "decoding JSON response")
+}
+
+// if there was a non-zero response code, this is an error that
+// should be communicated back to the caller...
+if out.Response.ReturnCode != 0 {
+return errors.New(out.Response.Message)
+}
+
+// ...otherwise the request was successful so
+return nil
+}
+
+// UnpublishNC unpublishes the network container via the NMAgent running
+// alongside the CNS service. This is useful to avoid throttling issues imposed
+// by Wireserver.
+func (c *Client) UnpublishNC(ctx context.Context, uncr cns.UnpublishNetworkContainerRequest) error {
+// In order to unpublish a Network Container, we need its ID. If the ID is
+// missing, we can assume that the request is invalid and immediately return
+// an error
+if uncr.NetworkContainerID == "" {
+return errors.New("request missing network container id")
+}
+
+// Now that the request is valid it can be packaged as an HTTP request:
+body, err := json.Marshal(uncr)
+if err != nil {
+return errors.Wrap(err, "encoding request body as json")
+}
+u := c.routes[cns.UnpublishNetworkContainer]
+req, err := http.NewRequest(http.MethodPost, u.String(), bytes.NewReader(body))
+if err != nil {
+return errors.Wrap(err, "building HTTP request")
+}
+
+// send the HTTP request
+resp, err := c.client.Do(req)
+if err != nil {
+return errors.Wrap(err, "sending HTTP request")
+}
+defer resp.Body.Close()
+
+// decode the response to see if it was successful
+var out cns.UnpublishNetworkContainerResponse
+err = json.NewDecoder(resp.Body).Decode(&out)
+if err != nil {
+return errors.Wrap(err, "decoding JSON response")
+}
+
+// if there was a non-zero response code, this is an error that
+// should be communicated back to the caller...
+if out.Response.ReturnCode != 0 {
+return errors.New(out.Response.Message)
+}
+
+// ...otherwise the request was successful so
+return nil
+}