feat: add cache invalidation support based on Cache-Control header (#10205)

* feat: add cache invalidation support based on Cache-Control header

* fix lint issues and bump golangci-lint to v2

* fix makefile

* fix unit tests

Author: floreks

.golangci.yml

@@ -11,27 +11,41 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#
+
+version: "2"
 run:
   modules-download-mode: readonly
-  allow-parallel-runners: true
-  timeout: 30m
   issues-exit-code: 1
   tests: true
+  allow-parallel-runners: true
 linters:
-  disable-all: true
+  default: none
   enable:
-    # default linters
     - errcheck
-    - gosimple
+    - errorlint
+    - gocyclo
     - govet
     - ineffassign
+    - misspell
     - staticcheck
-    - typecheck
     - unused
-    - gocyclo
-
-    # additional linters
-    - errorlint
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
+formatters:
+  enable:
     - goimports
-    - misspell
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$

modules/api/pkg/handler/apihandler.go

@@ -19,6 +19,7 @@ import (
 	"strings"
 
 	"github.com/emicklei/go-restful/v3"
+
 	metricapi "k8s.io/dashboard/api/pkg/integration/metric/api"
 	"k8s.io/dashboard/api/pkg/resource/dataselect"
 )

modules/api/pkg/handler/parser/parser.go

@@ -33,16 +33,16 @@ type Handler struct {
 //
 // By default, endpoint for checking state of the integrations is installed. It allows user
 // to check state of integration by accessing `<DASHBOARD_URL>/api/v1/integration/{name}/state`.
-func (self Handler) Install(ws *restful.WebService) {
+func (in Handler) Install(ws *restful.WebService) {
 	ws.Route(
 		ws.GET("/integration/{name}/state").
-			To(self.handleGetState).
+			To(in.handleGetState).
 			Writes(api.IntegrationState{}))
 }
 
-func (self Handler) handleGetState(request *restful.Request, response *restful.Response) {
+func (in Handler) handleGetState(request *restful.Request, response *restful.Response) {
 	integrationName := request.PathParameter("name")
-	state, err := self.manager.GetState(api.IntegrationID(integrationName))
+	state, err := in.manager.GetState(api.IntegrationID(integrationName))
 	if err != nil {
 		response.AddHeader("Content-Type", "text/plain")
 		_ = response.WriteErrorString(http.StatusInternalServerError, err.Error()+"\n")

modules/api/pkg/integration/handler.go

@@ -31,7 +31,7 @@ func areErrorsEqual(err1, err2 error) bool {
 // Removes all quote signs that might have been added to the message.
 // Might depend on dependencies version how they are constructed.
 func normalize(msg string) string {
-	return strings.Replace(msg, "\"", "", -1)
+	return strings.ReplaceAll(msg, "\"", "")
 }
 
 func TestNewIntegrationManager(t *testing.T) {
@@ -82,6 +82,6 @@ func TestIntegrationManager_GetState(t *testing.T) {
 func TestIntegrationManager_Metric(t *testing.T) {
 	metricManager := integration.NewIntegrationManager().Metric()
 	if metricManager == nil {
-		t.Error("Failed to get metric manager.")
+		t.Error("failed to get metric manager.")
 	}
 }

modules/api/pkg/integration/manager_test.go

@@ -127,15 +127,15 @@ type MetricPoint struct {
 // Label stores information about identity of resources (UIDs) described by metric.
 type Label map[types.ResourceKind][]apimachinery.UID
 
-// AddMetricLabel returns a unique combined Label of self and other resource.
+// AddMetricLabel returns a unique combined Label of in and other resource.
 // New label describes both resources.
-func (self Label) AddMetricLabel(other Label) Label {
+func (in Label) AddMetricLabel(other Label) Label {
 	if other == nil {
-		return self
+		return in
 	}
 
 	uniqueMap := map[apimachinery.UID]bool{}
-	for _, v := range self {
+	for _, v := range in {
 		for _, t := range v {
 			uniqueMap[t] = true
 		}
@@ -144,11 +144,11 @@ func (self Label) AddMetricLabel(other Label) Label {
 	for k, v := range other {
 		for _, t := range v {
 			if _, exists := uniqueMap[t]; !exists {
-				self[k] = append(self[k], t)
+				in[k] = append(in[k], t)
 			}
 		}
 	}
-	return self
+	return in
 }
 
 // Metric is a format of data used in this module. This is also the format of data that is being sent by backend client.
@@ -190,18 +190,18 @@ func (metric *SidecarMetric) AddMetricPoint(item MetricPoint) []MetricPoint {
 	return metric.MetricPoints
 }
 
-func (metric *Metric) AddMetricPoint(item MetricPoint) []MetricPoint {
-	metric.MetricPoints = append(metric.MetricPoints, item)
-	return metric.MetricPoints
+func (in *Metric) AddMetricPoint(item MetricPoint) []MetricPoint {
+	in.MetricPoints = append(in.MetricPoints, item)
+	return in.MetricPoints
 }
 
 // String implements stringer interface to allow easy printing
-func (self Metric) String() string {
-	return "{\nDataPoints: " + fmt.Sprintf("%v", self.DataPoints) +
-		"\nMetricPoints: " + fmt.Sprintf("%v", self.MetricPoints) +
-		"\nMetricName: " + self.MetricName +
-		"\nLabel: " + fmt.Sprintf("%v", self.Label) +
-		"\nAggregate: " + fmt.Sprintf("%v", self.Aggregate)
+func (in Metric) String() string {
+	return "{\nDataPoints: " + fmt.Sprintf("%v", in.DataPoints) +
+		"\nMetricPoints: " + fmt.Sprintf("%v", in.MetricPoints) +
+		"\nMetricName: " + in.MetricName +
+		"\nLabel: " + fmt.Sprintf("%v", in.Label) +
+		"\nAggregate: " + fmt.Sprintf("%v", in.Aggregate)
 }
 
 // MetricPromise is used for parallel data extraction. Contains len 1 channels for Metric and Error.
@@ -211,12 +211,12 @@ type MetricPromise struct {
 }
 
 // GetMetric returns pointer to received Metrics and forwarded error (if any)
-func (self MetricPromise) GetMetric() (*Metric, error) {
-	err := <-self.Error
+func (in MetricPromise) GetMetric() (*Metric, error) {
+	err := <-in.Error
 	if err != nil {
 		return nil, err
 	}
-	return <-self.Metric, nil
+	return <-in.Metric, nil
 }
 
 // NewMetricPromise creates a MetricPromise structure with both channels of length 1.
@@ -231,10 +231,10 @@ type MetricPromises []MetricPromise
 
 // GetMetrics returns all metrics from MetricPromises.
 // In case of no metrics were downloaded it does not initialise []Metric and returns nil.
-func (self MetricPromises) GetMetrics() ([]Metric, error) {
+func (in MetricPromises) GetMetrics() ([]Metric, error) {
 	result := make([]Metric, 0)
 
-	for _, metricPromise := range self {
+	for _, metricPromise := range in {
 		metric, err := metricPromise.GetMetric()
 		if err != nil {
 			// Do not fail when cannot resolve one of the metrics promises and return what can be resolved.
@@ -252,8 +252,8 @@ func (self MetricPromises) GetMetrics() ([]Metric, error) {
 }
 
 // PutMetrics forwards provided list of metrics to all channels. If provided err is not nil, error will be forwarded.
-func (self MetricPromises) PutMetrics(metrics []Metric, err error) {
-	for i, metricPromise := range self {
+func (in MetricPromises) PutMetrics(metrics []Metric, err error) {
+	for i, metricPromise := range in {
 		if err != nil {
 			metricPromise.Metric <- nil
 		} else {

modules/api/pkg/integration/metric/api/types.go

@@ -52,79 +52,79 @@ type metricManager struct {
 }
 
 // AddClient implements metric manager interface. See MetricManager for more information.
-func (self *metricManager) AddClient(client metricapi.MetricClient) MetricManager {
+func (in *metricManager) AddClient(client metricapi.MetricClient) MetricManager {
 	if client != nil {
-		self.clients[client.ID()] = client
+		in.clients[client.ID()] = client
 	}
 
-	return self
+	return in
 }
 
 // Client implements metric manager interface. See MetricManager for more information.
-func (self *metricManager) Client() metricapi.MetricClient {
-	return self.active
+func (in *metricManager) Client() metricapi.MetricClient {
+	return in.active
 }
 
 // Enable implements metric manager interface. See MetricManager for more information.
-func (self *metricManager) Enable(id integrationapi.IntegrationID) error {
-	metricClient, exists := self.clients[id]
+func (in *metricManager) Enable(id integrationapi.IntegrationID) error {
+	metricClient, exists := in.clients[id]
 	if !exists {
-		return fmt.Errorf("No metric client found for integration id: %s", id)
+		return fmt.Errorf("no metric client found for integration id: %s", id)
 	}
 
 	err := metricClient.HealthCheck()
 	if err != nil {
-		return fmt.Errorf("Health check failed: %s", err.Error())
+		return fmt.Errorf("health check failed: %s", err.Error())
 	}
 
-	self.active = metricClient
+	in.active = metricClient
 	return nil
 }
 
 // EnableWithRetry implements metric manager interface. See MetricManager for more information.
-func (self *metricManager) EnableWithRetry(id integrationapi.IntegrationID, period time.Duration) {
+func (in *metricManager) EnableWithRetry(id integrationapi.IntegrationID, period time.Duration) {
 	go wait.Forever(func() {
-		metricClient, exists := self.clients[id]
+		metricClient, exists := in.clients[id]
 		if !exists {
 			klog.V(5).InfoS("Metric client does not exist", "clientID", id)
 			return
 		}
 
 		err := metricClient.HealthCheck()
 		if err != nil {
-			self.active = nil
+			in.active = nil
 			klog.Errorf("Metric client health check failed: %s. Retrying in %d seconds.", err, period)
 			return
 		}
 
-		if self.active == nil {
+		if in.active == nil {
 			klog.V(1).Infof("Successful request to %s", id)
-			self.active = metricClient
+			in.active = metricClient
 		}
 	}, period*time.Second)
 }
 
 // List implements metric manager interface. See MetricManager for more information.
-func (self *metricManager) List() []integrationapi.Integration {
+func (in *metricManager) List() []integrationapi.Integration {
 	result := make([]integrationapi.Integration, 0)
-	for _, c := range self.clients {
+	for _, c := range in.clients {
 		result = append(result, c.(integrationapi.Integration))
 	}
 
 	return result
 }
 
 // ConfigureSidecar implements metric manager interface. See MetricManager for more information.
-func (self *metricManager) ConfigureSidecar(host string) MetricManager {
+func (in *metricManager) ConfigureSidecar(host string) MetricManager {
 	inClusterClient := client.InClusterClient()
 	metricClient, err := sidecar.CreateSidecarClient(host, inClusterClient)
 	if err != nil {
 		klog.Errorf("There was an error during sidecar client creation: %s", err.Error())
-		return self
+		return in
 	}
 
-	self.clients[metricClient.ID()] = metricClient
-	return self
+	in.clients[metricClient.ID()] = metricClient
+	return in
 }
 
 // NewMetricManager creates metric manager.

modules/api/pkg/integration/metric/manager.go

@@ -33,25 +33,25 @@ func (FakeMetricClient) ID() integrationapi.IntegrationID {
 	return fakeMetricClientID
 }
 
-func (self FakeMetricClient) HealthCheck() error {
-	if self.healthOk {
+func (in FakeMetricClient) HealthCheck() error {
+	if in.healthOk {
 		return nil
 	}
 
 	return errors.NewInvalid("test-error")
 }
 
-func (self FakeMetricClient) DownloadMetric(selectors []api.ResourceSelector, metricName string,
+func (in FakeMetricClient) DownloadMetric(selectors []api.ResourceSelector, metricName string,
 	cachedResources *api.CachedResources) api.MetricPromises {
 	return nil
 }
 
-func (self FakeMetricClient) DownloadMetrics(selectors []api.ResourceSelector, metricNames []string,
+func (in FakeMetricClient) DownloadMetrics(selectors []api.ResourceSelector, metricNames []string,
 	cachedResources *api.CachedResources) api.MetricPromises {
 	return nil
 }
 
-func (self FakeMetricClient) AggregateMetrics(metrics api.MetricPromises, metricName string,
+func (in FakeMetricClient) AggregateMetrics(metrics api.MetricPromises, metricName string,
 	aggregations api.AggregationModes) api.MetricPromises {
 	return nil
 }
@@ -95,7 +95,7 @@ func TestMetricManager_Enable(t *testing.T) {
 		client   api.MetricClient
 		expected error
 	}{
-		{&FakeMetricClient{healthOk: false}, errors.NewInvalid("Health check failed: test-error")},
+		{&FakeMetricClient{healthOk: false}, errors.NewInvalid("health check failed: test-error")},
 		{&FakeMetricClient{healthOk: true}, nil},
 	}