From 948efdd2f99fba3e173779692d019774810b79c7 Mon Sep 17 00:00:00 2001 From: Mugesh SP Date: Tue, 12 Aug 2025 13:43:29 +0100 Subject: [PATCH 1/8] feat: Implement DeleteEndpointState API and integrate with network manager --- cns/client/client.go | 33 ++++++++++++++++++++ cns/restserver/ipam.go | 71 ++++++++++++++++++++++++++++++++++++++++++ network/manager.go | 9 +++++- 3 files changed, 112 insertions(+), 1 deletion(-) diff --git a/cns/client/client.go b/cns/client/client.go index 1021d6f412..bd1aaa045b 100644 --- a/cns/client/client.go +++ b/cns/client/client.go @@ -1100,3 +1100,36 @@ func (c *Client) UpdateEndpoint(ctx context.Context, endpointID string, ipInfo m return &response, nil } + +func (c *Client) DeleteEndpointState(ctx context.Context, endpointId string) (*cns.Response, error) { + // build the request + u := c.routes[cns.EndpointAPI] + uString := u.String() + endpointId + req, err := http.NewRequestWithContext(ctx, http.MethodDelete, uString, http.NoBody) + if err != nil { + return nil, errors.Wrap(err, "failed to build request") + } + req.Header.Set(headerContentType, contentTypeJSON) + res, err := c.client.Do(req) + if err != nil { + return nil, &ConnectionFailureErr{cause: err} + } + + defer res.Body.Close() + if res.StatusCode != http.StatusOK { + return nil, errors.Errorf("http response %d", res.StatusCode) + } + + var response cns.Response + err = json.NewDecoder(res.Body).Decode(&response) + + if err != nil { + return nil, errors.Wrap(err, "failed to decode CNS Response") + } + + if response.ReturnCode != 0 { + return nil, errors.New(response.Message) + } + + return &response, nil +} diff --git a/cns/restserver/ipam.go b/cns/restserver/ipam.go index 7c1366149d..6583845572 100644 --- a/cns/restserver/ipam.go +++ b/cns/restserver/ipam.go @@ -1151,6 +1151,8 @@ func (service *HTTPRestService) EndpointHandlerAPI(w http.ResponseWriter, r *htt service.GetEndpointHandler(w, r) case http.MethodPatch: service.UpdateEndpointHandler(w, r) + case http.MethodDelete: + service.DeleteEndpointStateHandler(w, r) default: logger.Errorf("[EndpointHandlerAPI] EndpointHandler API expect http Get or Patch method") } @@ -1356,6 +1358,7 @@ func verifyUpdateEndpointStateRequest(req map[string]*IPInfo) error { return nil } +<<<<<<< HEAD // getIPFamiliesMap returns a map of IP families present across all NC's func (service *HTTPRestService) getIPFamiliesMap() map[cns.IPFamily]struct{} { ncIPFamilies := map[cns.IPFamily]struct{}{} @@ -1392,4 +1395,72 @@ func (service *HTTPRestService) getIPFamiliesMap() map[cns.IPFamily]struct{} { // - In dual-stack: 2 IPs per pod (one IPv4, one IPv6) func (service *HTTPRestService) GetIPFamilyCount() int { return len(service.getIPFamiliesMap()) +======= +func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter, r *http.Request) { + opName := "DeleteEndpointStateHandler" + logger.Printf("[DeleteEndpointStateHandler] DeleteEndpointState for %s", r.URL.Path) + endpointID := strings.TrimPrefix(r.URL.Path, cns.EndpointPath) + service.Lock() + defer service.Unlock() + + if service.EndpointStateStore == nil { + response := cns.Response{ + ReturnCode: types.UnexpectedError, + Message: fmt.Sprintf("[DeleteEndpointStateHandler] EndpointStateStore is not initialized"), + } + err := common.Encode(w, &response) + logger.Response(opName, response, response.ReturnCode, err) + return + } + + // Decode the request body to get ipInfo if needed + var req map[string]*IPInfo + err := common.Decode(w, r, &req) + if err != nil { + logger.Printf("[DeleteEndpointStateHandler] Failed to decode request body: %v", err) + // Continue with deletion even if decode fails, as ipInfo might not be needed + } + + // Delete the endpoint from state + err = service.DeleteEndpointStateHelper(endpointID) + if err != nil { + response := cns.Response{ + ReturnCode: types.UnexpectedError, + Message: fmt.Sprintf("[DeleteEndpointStateHandler] Failed to delete endpoint state for %s with error: %s", endpointID, err.Error()), + } + err = common.Encode(w, &response) + logger.Response(opName, response, response.ReturnCode, err) + return + } + + response := cns.Response{ + ReturnCode: types.Success, + Message: "[DeleteEndpointStateHandler] Endpoint state deleted successfully", + } + err = common.Encode(w, &response) + logger.Response(opName, response, response.ReturnCode, err) +} + +func (service *HTTPRestService) DeleteEndpointStateHelper(endpointID string) error { + if service.EndpointStateStore == nil { + return ErrStoreEmpty + } + logger.Printf("[deleteEndpointState] Deleting Endpoint state from state file %s", endpointID) + _, endpointExist := service.EndpointState[endpointID] + if !endpointExist { + logger.Printf("[deleteEndpointState] endpoint could not be found in the statefile %s", endpointID) + return fmt.Errorf("[deleteEndpointState] endpoint %s does not exist in the statefile", endpointID) + } + + // Delete the endpoint from the state + delete(service.EndpointState, endpointID) + + // Write the updated state back to the store + err := service.EndpointStateStore.Write(EndpointStoreKey, service.EndpointState) + if err != nil { + return fmt.Errorf("[deleteEndpointState] failed to write endpoint state to store: %w", err) + } + logger.Printf("[deleteEndpointState] successfully deleted endpoint %s from state file", endpointID) + return nil +>>>>>>> 79f3d9a0d (feat: Implement DeleteEndpointState API and integrate with network manager) } diff --git a/network/manager.go b/network/manager.go index 7bc1441fea..54fe240c97 100644 --- a/network/manager.go +++ b/network/manager.go @@ -761,7 +761,7 @@ func (nm *networkManager) SaveState(eps []*endpoint) error { return nm.save() } -func (nm *networkManager) DeleteState(_ []*EndpointInfo) error { +func (nm *networkManager) DeleteState(epInfos []*EndpointInfo) error { nm.Lock() defer nm.Unlock() @@ -771,6 +771,13 @@ func (nm *networkManager) DeleteState(_ []*EndpointInfo) error { // For stateless cni, plugin.ipamInvoker.Delete takes care of removing the state in the main Delete function if nm.IsStatelessCNIMode() { + for _, epInfo := range epInfos { + response, err := nm.CnsClient.DeleteEndpointState(context.TODO(), epInfo.ContainerID) + if err != nil { + return errors.Wrapf(err, "Delete endpoint API returned with error for endpoint %s", epInfo.ContainerID) + } + logger.Info("Delete endpoint API returned", zap.String("endpointID", epInfo.ContainerID), zap.String("returnCode", response.ReturnCode.String())) + } return nil } From e1522cc5033274653f0bfbf023a55fbefd00078e Mon Sep 17 00:00:00 2001 From: mushiboy Date: Tue, 12 Aug 2025 17:17:13 +0100 Subject: [PATCH 2/8] refactor: Remove unnecessary locking in DeleteEndpointStateHandler --- cns/restserver/ipam.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/cns/restserver/ipam.go b/cns/restserver/ipam.go index 6583845572..a44d682979 100644 --- a/cns/restserver/ipam.go +++ b/cns/restserver/ipam.go @@ -1400,8 +1400,6 @@ func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter opName := "DeleteEndpointStateHandler" logger.Printf("[DeleteEndpointStateHandler] DeleteEndpointState for %s", r.URL.Path) endpointID := strings.TrimPrefix(r.URL.Path, cns.EndpointPath) - service.Lock() - defer service.Unlock() if service.EndpointStateStore == nil { response := cns.Response{ From d1477c8ee02d3e14ff80a26432de8719b1b742a5 Mon Sep 17 00:00:00 2001 From: mushiboy Date: Wed, 13 Aug 2025 09:17:04 +0100 Subject: [PATCH 3/8] feat: Add conditional check for NIC type (FrontendNic) in DeleteState method to enhance endpoint deletion logic --- network/manager.go | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/network/manager.go b/network/manager.go index 54fe240c97..8848e17424 100644 --- a/network/manager.go +++ b/network/manager.go @@ -772,11 +772,13 @@ func (nm *networkManager) DeleteState(epInfos []*EndpointInfo) error { if nm.IsStatelessCNIMode() { for _, epInfo := range epInfos { - response, err := nm.CnsClient.DeleteEndpointState(context.TODO(), epInfo.ContainerID) - if err != nil { - return errors.Wrapf(err, "Delete endpoint API returned with error for endpoint %s", epInfo.ContainerID) + if epInfo.NICType == cns.NodeNetworkInterfaceFrontendNIC { + response, err := nm.CnsClient.DeleteEndpointState(context.TODO(), epInfo.ContainerID) + if err != nil { + return errors.Wrapf(err, "Delete endpoint API returned with error for endpoint %s", epInfo.ContainerID) + } + logger.Info("Delete endpoint API returned", zap.String("endpointID", epInfo.ContainerID), zap.String("returnCode", response.ReturnCode.String())) } - logger.Info("Delete endpoint API returned", zap.String("endpointID", epInfo.ContainerID), zap.String("returnCode", response.ReturnCode.String())) } return nil } From 4c23cceb03268126327178bec0c2bb15ebedac09 Mon Sep 17 00:00:00 2001 From: Mugesh SP Date: Fri, 15 Aug 2025 13:48:32 +0100 Subject: [PATCH 4/8] fix: lint errors --- cns/client/client.go | 4 ++-- cns/restserver/ipam.go | 4 ++-- network/manager.go | 6 +++--- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/cns/client/client.go b/cns/client/client.go index bd1aaa045b..18f2e96fd2 100644 --- a/cns/client/client.go +++ b/cns/client/client.go @@ -1101,10 +1101,10 @@ func (c *Client) UpdateEndpoint(ctx context.Context, endpointID string, ipInfo m return &response, nil } -func (c *Client) DeleteEndpointState(ctx context.Context, endpointId string) (*cns.Response, error) { +func (c *Client) DeleteEndpointState(ctx context.Context, endpointID string) (*cns.Response, error) { // build the request u := c.routes[cns.EndpointAPI] - uString := u.String() + endpointId + uString := u.String() + endpointID req, err := http.NewRequestWithContext(ctx, http.MethodDelete, uString, http.NoBody) if err != nil { return nil, errors.Wrap(err, "failed to build request") diff --git a/cns/restserver/ipam.go b/cns/restserver/ipam.go index a44d682979..f7749d6897 100644 --- a/cns/restserver/ipam.go +++ b/cns/restserver/ipam.go @@ -1404,7 +1404,7 @@ func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter if service.EndpointStateStore == nil { response := cns.Response{ ReturnCode: types.UnexpectedError, - Message: fmt.Sprintf("[DeleteEndpointStateHandler] EndpointStateStore is not initialized"), + Message: "[DeleteEndpointStateHandler] EndpointStateStore is not initialized", } err := common.Encode(w, &response) logger.Response(opName, response, response.ReturnCode, err) @@ -1447,7 +1447,7 @@ func (service *HTTPRestService) DeleteEndpointStateHelper(endpointID string) err _, endpointExist := service.EndpointState[endpointID] if !endpointExist { logger.Printf("[deleteEndpointState] endpoint could not be found in the statefile %s", endpointID) - return fmt.Errorf("[deleteEndpointState] endpoint %s does not exist in the statefile", endpointID) + return fmt.Errorf("[deleteEndpointState] endpoint %s: %w", endpointID, ErrEndpointStateNotFound) } // Delete the endpoint from the state diff --git a/network/manager.go b/network/manager.go index 8848e17424..90bc5fcc78 100644 --- a/network/manager.go +++ b/network/manager.go @@ -773,11 +773,11 @@ func (nm *networkManager) DeleteState(epInfos []*EndpointInfo) error { if nm.IsStatelessCNIMode() { for _, epInfo := range epInfos { if epInfo.NICType == cns.NodeNetworkInterfaceFrontendNIC { - response, err := nm.CnsClient.DeleteEndpointState(context.TODO(), epInfo.ContainerID) + response, err := nm.CnsClient.DeleteEndpointState(context.TODO(), epInfo.EndpointID) if err != nil { - return errors.Wrapf(err, "Delete endpoint API returned with error for endpoint %s", epInfo.ContainerID) + return errors.Wrapf(err, "Delete endpoint API returned with error for endpoint %s", epInfo.EndpointID) } - logger.Info("Delete endpoint API returned", zap.String("endpointID", epInfo.ContainerID), zap.String("returnCode", response.ReturnCode.String())) + logger.Info("Delete endpoint API returned", zap.String("endpointID", epInfo.EndpointID), zap.String("returnCode", response.ReturnCode.String())) } } return nil From 330feee6237f9d7de8eba6d543e80ca7df61bfe7 Mon Sep 17 00:00:00 2001 From: mushiboy Date: Thu, 21 Aug 2025 12:40:10 +0100 Subject: [PATCH 5/8] fix: lint errors --- cns/restserver/ipam.go | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/cns/restserver/ipam.go b/cns/restserver/ipam.go index f7749d6897..570f5e7cff 100644 --- a/cns/restserver/ipam.go +++ b/cns/restserver/ipam.go @@ -1398,7 +1398,7 @@ func (service *HTTPRestService) GetIPFamilyCount() int { ======= func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter, r *http.Request) { opName := "DeleteEndpointStateHandler" - logger.Printf("[DeleteEndpointStateHandler] DeleteEndpointState for %s", r.URL.Path) + logger.Printf("[DeleteEndpointStateHandler] DeleteEndpointState for %s", r.URL.Path) //nolint:staticcheck endpointID := strings.TrimPrefix(r.URL.Path, cns.EndpointPath) if service.EndpointStateStore == nil { @@ -1407,7 +1407,7 @@ func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter Message: "[DeleteEndpointStateHandler] EndpointStateStore is not initialized", } err := common.Encode(w, &response) - logger.Response(opName, response, response.ReturnCode, err) + logger.Response(opName, response, response.ReturnCode, err) //nolint:staticcheck return } @@ -1415,7 +1415,7 @@ func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter var req map[string]*IPInfo err := common.Decode(w, r, &req) if err != nil { - logger.Printf("[DeleteEndpointStateHandler] Failed to decode request body: %v", err) + logger.Printf("[DeleteEndpointStateHandler] Failed to decode request body: %v", err) //nolint:staticcheck // Continue with deletion even if decode fails, as ipInfo might not be needed } @@ -1427,7 +1427,7 @@ func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter Message: fmt.Sprintf("[DeleteEndpointStateHandler] Failed to delete endpoint state for %s with error: %s", endpointID, err.Error()), } err = common.Encode(w, &response) - logger.Response(opName, response, response.ReturnCode, err) + logger.Response(opName, response, response.ReturnCode, err) //nolint:staticcheck return } @@ -1436,17 +1436,17 @@ func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter Message: "[DeleteEndpointStateHandler] Endpoint state deleted successfully", } err = common.Encode(w, &response) - logger.Response(opName, response, response.ReturnCode, err) + logger.Response(opName, response, response.ReturnCode, err) //nolint:staticcheck } func (service *HTTPRestService) DeleteEndpointStateHelper(endpointID string) error { if service.EndpointStateStore == nil { return ErrStoreEmpty } - logger.Printf("[deleteEndpointState] Deleting Endpoint state from state file %s", endpointID) + logger.Printf("[deleteEndpointState] Deleting Endpoint state from state file %s", endpointID) //nolint:staticcheck _, endpointExist := service.EndpointState[endpointID] if !endpointExist { - logger.Printf("[deleteEndpointState] endpoint could not be found in the statefile %s", endpointID) + logger.Printf("[deleteEndpointState] endpoint could not be found in the statefile %s", endpointID) //nolint:staticcheck return fmt.Errorf("[deleteEndpointState] endpoint %s: %w", endpointID, ErrEndpointStateNotFound) } @@ -1458,7 +1458,7 @@ func (service *HTTPRestService) DeleteEndpointStateHelper(endpointID string) err if err != nil { return fmt.Errorf("[deleteEndpointState] failed to write endpoint state to store: %w", err) } - logger.Printf("[deleteEndpointState] successfully deleted endpoint %s from state file", endpointID) + logger.Printf("[deleteEndpointState] successfully deleted endpoint %s from state file", endpointID) //nolint:staticcheck return nil >>>>>>> 79f3d9a0d (feat: Implement DeleteEndpointState API and integrate with network manager) } From e7869148183bdad4e6b805b617b2c1ef1ed6555f Mon Sep 17 00:00:00 2001 From: mushiboy Date: Mon, 25 Aug 2025 08:57:28 +0100 Subject: [PATCH 6/8] fix: Add reason for using deprecated logger calls in DeleteEndpointStateHandler and DeleteEndpointStateHelper --- cns/restserver/ipam.go | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/cns/restserver/ipam.go b/cns/restserver/ipam.go index 570f5e7cff..32d2a3a64e 100644 --- a/cns/restserver/ipam.go +++ b/cns/restserver/ipam.go @@ -1398,7 +1398,7 @@ func (service *HTTPRestService) GetIPFamilyCount() int { ======= func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter, r *http.Request) { opName := "DeleteEndpointStateHandler" - logger.Printf("[DeleteEndpointStateHandler] DeleteEndpointState for %s", r.URL.Path) //nolint:staticcheck + logger.Printf("[DeleteEndpointStateHandler] DeleteEndpointState for %s", r.URL.Path) //nolint:staticcheck // reason: using deprecated call until migration to new API endpointID := strings.TrimPrefix(r.URL.Path, cns.EndpointPath) if service.EndpointStateStore == nil { @@ -1407,7 +1407,7 @@ func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter Message: "[DeleteEndpointStateHandler] EndpointStateStore is not initialized", } err := common.Encode(w, &response) - logger.Response(opName, response, response.ReturnCode, err) //nolint:staticcheck + logger.Response(opName, response, response.ReturnCode, err) //nolint:staticcheck // reason: using deprecated call until migration to new API return } @@ -1415,7 +1415,7 @@ func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter var req map[string]*IPInfo err := common.Decode(w, r, &req) if err != nil { - logger.Printf("[DeleteEndpointStateHandler] Failed to decode request body: %v", err) //nolint:staticcheck + logger.Printf("[DeleteEndpointStateHandler] Failed to decode request body: %v", err) //nolint:staticcheck // reason: using deprecated call until migration to new API // Continue with deletion even if decode fails, as ipInfo might not be needed } @@ -1427,7 +1427,7 @@ func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter Message: fmt.Sprintf("[DeleteEndpointStateHandler] Failed to delete endpoint state for %s with error: %s", endpointID, err.Error()), } err = common.Encode(w, &response) - logger.Response(opName, response, response.ReturnCode, err) //nolint:staticcheck + logger.Response(opName, response, response.ReturnCode, err) //nolint:staticcheck // reason: using deprecated call until migration to new API return } @@ -1436,17 +1436,17 @@ func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter Message: "[DeleteEndpointStateHandler] Endpoint state deleted successfully", } err = common.Encode(w, &response) - logger.Response(opName, response, response.ReturnCode, err) //nolint:staticcheck + logger.Response(opName, response, response.ReturnCode, err) //nolint:staticcheck // reason: using deprecated call until migration to new API } func (service *HTTPRestService) DeleteEndpointStateHelper(endpointID string) error { if service.EndpointStateStore == nil { return ErrStoreEmpty } - logger.Printf("[deleteEndpointState] Deleting Endpoint state from state file %s", endpointID) //nolint:staticcheck + logger.Printf("[deleteEndpointState] Deleting Endpoint state from state file %s", endpointID) //nolint:staticcheck // reason: using deprecated call until migration to new API _, endpointExist := service.EndpointState[endpointID] if !endpointExist { - logger.Printf("[deleteEndpointState] endpoint could not be found in the statefile %s", endpointID) //nolint:staticcheck + logger.Printf("[deleteEndpointState] endpoint could not be found in the statefile %s", endpointID) //nolint:staticcheck // reason: using deprecated call until migration to new API return fmt.Errorf("[deleteEndpointState] endpoint %s: %w", endpointID, ErrEndpointStateNotFound) } @@ -1458,7 +1458,7 @@ func (service *HTTPRestService) DeleteEndpointStateHelper(endpointID string) err if err != nil { return fmt.Errorf("[deleteEndpointState] failed to write endpoint state to store: %w", err) } - logger.Printf("[deleteEndpointState] successfully deleted endpoint %s from state file", endpointID) //nolint:staticcheck + logger.Printf("[deleteEndpointState] successfully deleted endpoint %s from state file", endpointID) //nolint:staticcheck // reason: using deprecated call until migration to new API return nil >>>>>>> 79f3d9a0d (feat: Implement DeleteEndpointState API and integrate with network manager) } From 928e6a21beaecd27b8d118967fb210798b68b7da Mon Sep 17 00:00:00 2001 From: mushiboy Date: Mon, 25 Aug 2025 09:20:17 +0100 Subject: [PATCH 7/8] fix: Remove unnecessary blank lines in UpdateEndpoint and DeleteEndpointState methods --- cns/client/client.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/cns/client/client.go b/cns/client/client.go index 18f2e96fd2..38bf19d23f 100644 --- a/cns/client/client.go +++ b/cns/client/client.go @@ -1089,7 +1089,6 @@ func (c *Client) UpdateEndpoint(ctx context.Context, endpointID string, ipInfo m var response cns.Response err = json.NewDecoder(res.Body).Decode(&response) - if err != nil { return nil, errors.Wrap(err, "failed to decode CNS Response") } @@ -1122,7 +1121,6 @@ func (c *Client) DeleteEndpointState(ctx context.Context, endpointID string) (*c var response cns.Response err = json.NewDecoder(res.Body).Decode(&response) - if err != nil { return nil, errors.Wrap(err, "failed to decode CNS Response") } From 626eab90939f719eb32a0bc64ca6187b8a20e748 Mon Sep 17 00:00:00 2001 From: Mugesh SP Date: Tue, 14 Oct 2025 01:52:07 +0100 Subject: [PATCH 8/8] fix: clean up code --- cns/restserver/ipam.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/cns/restserver/ipam.go b/cns/restserver/ipam.go index 32d2a3a64e..3e87d8a714 100644 --- a/cns/restserver/ipam.go +++ b/cns/restserver/ipam.go @@ -1358,7 +1358,6 @@ func verifyUpdateEndpointStateRequest(req map[string]*IPInfo) error { return nil } -<<<<<<< HEAD // getIPFamiliesMap returns a map of IP families present across all NC's func (service *HTTPRestService) getIPFamiliesMap() map[cns.IPFamily]struct{} { ncIPFamilies := map[cns.IPFamily]struct{}{} @@ -1395,7 +1394,8 @@ func (service *HTTPRestService) getIPFamiliesMap() map[cns.IPFamily]struct{} { // - In dual-stack: 2 IPs per pod (one IPv4, one IPv6) func (service *HTTPRestService) GetIPFamilyCount() int { return len(service.getIPFamiliesMap()) -======= +} + func (service *HTTPRestService) DeleteEndpointStateHandler(w http.ResponseWriter, r *http.Request) { opName := "DeleteEndpointStateHandler" logger.Printf("[DeleteEndpointStateHandler] DeleteEndpointState for %s", r.URL.Path) //nolint:staticcheck // reason: using deprecated call until migration to new API @@ -1460,5 +1460,4 @@ func (service *HTTPRestService) DeleteEndpointStateHelper(endpointID string) err } logger.Printf("[deleteEndpointState] successfully deleted endpoint %s from state file", endpointID) //nolint:staticcheck // reason: using deprecated call until migration to new API return nil ->>>>>>> 79f3d9a0d (feat: Implement DeleteEndpointState API and integrate with network manager) }