UPSTREAM: <carry>: switch to apirequestcount for all resources

Author: deads2k

openshift-kube-apiserver/filters/deprecatedapirequest/apiaccess_count_controller.go

@@ -14,7 +14,7 @@ import (
 )
 
 // NewController returns a controller
-func NewController(client apiclientv1.DeprecatedAPIRequestInterface, nodeName string) *controller {
+func NewController(client apiclientv1.APIRequestCountInterface, nodeName string) *controller {
 	ret := &controller{
 		client:       client,
 		nodeName:     nodeName,
@@ -32,7 +32,7 @@ type APIRequestLogger interface {
 }
 
 type controller struct {
-	client       apiclientv1.DeprecatedAPIRequestInterface
+	client       apiclientv1.APIRequestCountInterface
 	nodeName     string
 	updatePeriod time.Duration
 

openshift-kube-apiserver/filters/deprecatedapirequest/apiaccess_count_controller_test.go

@@ -37,10 +37,21 @@ func (c *clusterRequestCounts) Node(nodeName string) *apiRequestCounts {
 	return c.nodeToRequestCount[nodeName]
 }
 
-func (c *clusterRequestCounts) IncrementRequestCount(node string, resource schema.GroupVersionResource, hour int, user, verb string, count int) {
+func (c *clusterRequestCounts) IncrementRequestCount(node string, resource schema.GroupVersionResource, hour int, user, verb string, count int64) {
 	c.Node(node).IncrementRequestCount(resource, hour, user, verb, count)
 }
 
+func (c *clusterRequestCounts) String() string {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+
+	mapStrings := []string{}
+	for _, k := range sets.StringKeySet(c.nodeToRequestCount).List() {
+		mapStrings = append(mapStrings, fmt.Sprintf("%q: %v", k, c.nodeToRequestCount[k]))
+	}
+	return fmt.Sprintf("nodeToRequestCount: {%v}", strings.Join(mapStrings, ", "))
+}
+
 type apiRequestCounts struct {
 	lock                   sync.RWMutex
 	nodeName               string
@@ -76,7 +87,7 @@ func (c *apiRequestCounts) Add(requestCounts *apiRequestCounts) {
 	}
 }
 
-func (c *apiRequestCounts) IncrementRequestCount(resource schema.GroupVersionResource, hour int, user, verb string, count int) {
+func (c *apiRequestCounts) IncrementRequestCount(resource schema.GroupVersionResource, hour int, user, verb string, count int64) {
 	c.Resource(resource).IncrementRequestCount(hour, user, verb, count)
 }
 
@@ -176,7 +187,7 @@ func (c *resourceRequestCounts) Add(requestCounts *resourceRequestCounts) {
 	}
 }
 
-func (c *resourceRequestCounts) IncrementRequestCount(hour int, user, verb string, count int) {
+func (c *resourceRequestCounts) IncrementRequestCount(hour int, user, verb string, count int64) {
 	c.Hour(hour).IncrementRequestCount(user, verb, count)
 }
 
@@ -250,7 +261,7 @@ func (c *hourlyRequestCounts) Add(requestCounts *hourlyRequestCounts) {
 	}
 }
 
-func (c *hourlyRequestCounts) IncrementRequestCount(user, verb string, count int) {
+func (c *hourlyRequestCounts) IncrementRequestCount(user, verb string, count int64) {
 	c.User(user).IncrementRequestCount(verb, count)
 }
 
@@ -322,7 +333,7 @@ func (c *userRequestCounts) Add(requestCounts *userRequestCounts) {
 	}
 }
 
-func (c *userRequestCounts) IncrementRequestCount(verb string, count int) {
+func (c *userRequestCounts) IncrementRequestCount(verb string, count int64) {
 	c.Verb(verb).IncrementRequestCount(count)
 }
 
@@ -364,19 +375,19 @@ func (c *userRequestCounts) String() string {
 }
 
 type verbRequestCount struct {
-	count uint32
+	count int64
 }
 
-func (c *verbRequestCount) Add(count uint32) {
-	atomic.AddUint32(&c.count, count)
+func (c *verbRequestCount) Add(count int64) {
+	atomic.AddInt64(&c.count, count)
 }
 
-func (c *verbRequestCount) IncrementRequestCount(count int) {
-	c.Add(uint32(count))
+func (c *verbRequestCount) IncrementRequestCount(count int64) {
+	c.Add(count)
 }
 
 func (c *verbRequestCount) Equals(rhs *verbRequestCount) bool {
-	lhsV := atomic.LoadUint32(&c.count)
-	rhsV := atomic.LoadUint32(&rhs.count)
+	lhsV := atomic.LoadInt64(&c.count)
+	rhsV := atomic.LoadInt64(&rhs.count)
 	return lhsV == rhsV
 }

openshift-kube-apiserver/filters/deprecatedapirequest/request_counts.go

@@ -28,7 +28,7 @@ func TestAPIRequestCounts_IncrementRequestCount(t *testing.T) {
 		ts       time.Time
 		user     string
 		verb     string
-		count    int
+		count    int64
 	}{
 		{gvr("test.v1.group"), testTime(0, 0), "bob", "get", 1},
 		{gvr("test.v1.group"), testTime(0, 1), "bob", "list", 2},

openshift-kube-apiserver/filters/deprecatedapirequest/request_counts_test.go

@@ -15,7 +15,7 @@ import (
 // IncrementRequestCounts add additional api request counts to the log.
 // countsToPersist must not be mutated
 func SetRequestCountsForNode(nodeName string, expiredHour int, countsToPersist *resourceRequestCounts) v1helpers.UpdateStatusFunc {
-	return func(status *apiv1.DeprecatedAPIRequestStatus) {
+	return func(status *apiv1.APIRequestCountStatus) {
 		existingLogsFromAPI := apiStatusToRequestCount(countsToPersist.resource, status)
 		existingNodeLogFromAPI := existingLogsFromAPI.Node(nodeName)
 		existingNodeLogFromAPI.ExpireOldestCounts(expiredHour)
@@ -27,108 +27,124 @@ func SetRequestCountsForNode(nodeName string, expiredHour int, countsToPersist *
 		hourlyRequestLogs := resourceRequestCountToHourlyNodeRequestLog(nodeName, updatedCounts)
 
 		newStatus := setRequestCountsForNode(status, nodeName, expiredHour, hourlyRequestLogs)
-		status.RequestsLast24h = newStatus.RequestsLast24h
-		status.RequestsLastHour = newStatus.RequestsLastHour
+		status.Last24h = newStatus.Last24h
+		status.CurrentHour = newStatus.CurrentHour
+		status.RemovedInRelease = removedRelease(countsToPersist.resource)
+		status.RequestCount = newStatus.RequestCount
 
 		// TODO remove when we start writing, but I want data tonight.
-		content, _ := json.MarshalIndent(status.RequestsLastHour, "", "  ")
+		content, _ := json.MarshalIndent(status.CurrentHour, "", "  ")
 		klog.V(2).Infof("updating top %v APIRequest counts with last hour:\n%v", countsToPersist.resource, string(content))
 	}
 }
 
-func setRequestCountsForNode(status *apiv1.DeprecatedAPIRequestStatus, nodeName string, expiredHour int, hourlyNodeRequests []apiv1.NodeRequestLog) *apiv1.DeprecatedAPIRequestStatus {
+func setRequestCountsForNode(status *apiv1.APIRequestCountStatus, nodeName string, expiredHour int, hourlyNodeRequests []apiv1.PerNodeAPIRequestLog) *apiv1.APIRequestCountStatus {
 	newStatus := status.DeepCopy()
-	newStatus.RequestsLast24h = []apiv1.RequestLog{}
-	newStatus.RequestsLastHour = apiv1.RequestLog{}
+	newStatus.Last24h = []apiv1.PerResourceAPIRequestLog{}
+	newStatus.CurrentHour = apiv1.PerResourceAPIRequestLog{}
 
 	for hour, currentNodeCount := range hourlyNodeRequests {
-		nextHourStatus := apiv1.RequestLog{}
+		totalRequestThisHour := int64(0)
+		nextHourStatus := apiv1.PerResourceAPIRequestLog{}
 		if hour == expiredHour {
-			newStatus.RequestsLast24h = append(newStatus.RequestsLast24h, nextHourStatus)
+			newStatus.Last24h = append(newStatus.Last24h, nextHourStatus)
 			continue
 		}
-		if len(status.RequestsLast24h) > hour {
-			for _, oldNodeStatus := range status.RequestsLast24h[hour].Nodes {
+		if len(status.Last24h) > hour {
+			for _, oldNodeStatus := range status.Last24h[hour].ByNode {
 				if oldNodeStatus.NodeName == nodeName {
 					continue
 				}
-				nextHourStatus.Nodes = append(nextHourStatus.Nodes, *oldNodeStatus.DeepCopy())
+				totalRequestThisHour += oldNodeStatus.RequestCount
+				nextHourStatus.ByNode = append(nextHourStatus.ByNode, *oldNodeStatus.DeepCopy())
 			}
 		}
-		nextHourStatus.Nodes = append(nextHourStatus.Nodes, currentNodeCount)
+		nextHourStatus.ByNode = append(nextHourStatus.ByNode, currentNodeCount)
+		totalRequestThisHour += currentNodeCount.RequestCount
+		nextHourStatus.RequestCount = totalRequestThisHour
 
-		newStatus.RequestsLast24h = append(newStatus.RequestsLast24h, nextHourStatus)
+		newStatus.Last24h = append(newStatus.Last24h, nextHourStatus)
 	}
 
+	totalRequestsThisDay := int64(0)
+	for _, hourCount := range newStatus.Last24h {
+		totalRequestsThisDay += hourCount.RequestCount
+	}
+	newStatus.RequestCount = totalRequestsThisDay
+
 	// get all our sorting before copying
 	canonicalizeStatus(newStatus)
 	currentHour := time.Now().Hour()
-	newStatus.RequestsLastHour = newStatus.RequestsLast24h[currentHour]
+	newStatus.CurrentHour = newStatus.Last24h[currentHour]
 
 	return newStatus
 }
 
 const numberOfUsersInAPI = 10
 
 // in this function we have exclusive access to resourceRequestCounts, so do the easy map navigation
-func resourceRequestCountToHourlyNodeRequestLog(nodeName string, resourceRequestCounts *resourceRequestCounts) []apiv1.NodeRequestLog {
-	hourlyNodeRequests := []apiv1.NodeRequestLog{}
+func resourceRequestCountToHourlyNodeRequestLog(nodeName string, resourceRequestCounts *resourceRequestCounts) []apiv1.PerNodeAPIRequestLog {
+	hourlyNodeRequests := []apiv1.PerNodeAPIRequestLog{}
 	for i := 0; i < 24; i++ {
 		hourlyNodeRequests = append(hourlyNodeRequests,
-			apiv1.NodeRequestLog{
+			apiv1.PerNodeAPIRequestLog{
 				NodeName: nodeName,
-				Users:    nil,
+				ByUser:   nil,
 			},
 		)
 	}
+
 	for hour, hourlyCount := range resourceRequestCounts.hourToRequestCount {
+		totalRequestsThisHour := int64(0)
 		for user, userCount := range hourlyCount.usersToRequestCounts {
-			apiUserStatus := apiv1.RequestUser{
-				UserName: user,
-				Count:    0,
-				Requests: nil,
+			apiUserStatus := apiv1.PerUserAPIRequestCount{
+				UserName:     user,
+				RequestCount: 0,
+				ByVerb:       nil,
 			}
-			totalCount := 0
+			totalCount := int64(0)
 			for verb, verbCount := range userCount.verbsToRequestCounts {
-				totalCount += int(verbCount.count)
-				apiUserStatus.Requests = append(apiUserStatus.Requests,
-					apiv1.RequestCount{
-						Verb:  verb,
-						Count: int(verbCount.count),
+				totalCount += verbCount.count
+				apiUserStatus.ByVerb = append(apiUserStatus.ByVerb,
+					apiv1.PerVerbAPIRequestCount{
+						Verb:         verb,
+						RequestCount: verbCount.count,
 					})
 			}
-			apiUserStatus.Count = totalCount
+			apiUserStatus.RequestCount = totalCount
+			totalRequestsThisHour += totalCount
 
 			// the api resource has an interesting property of only keeping the last few.  Having a short list makes the sort faster
-			hasMaxEntries := len(hourlyNodeRequests[hour].Users) >= numberOfUsersInAPI
+			hasMaxEntries := len(hourlyNodeRequests[hour].ByUser) >= numberOfUsersInAPI
 			if hasMaxEntries {
-				currentSmallestCount := hourlyNodeRequests[hour].Users[len(hourlyNodeRequests[hour].Users)-1].Count
-				if apiUserStatus.Count <= currentSmallestCount {
+				currentSmallestCount := hourlyNodeRequests[hour].ByUser[len(hourlyNodeRequests[hour].ByUser)-1].RequestCount
+				if apiUserStatus.RequestCount <= currentSmallestCount {
 					continue
 				}
 			}
 
-			hourlyNodeRequests[hour].Users = append(hourlyNodeRequests[hour].Users, apiUserStatus)
-			sort.Stable(byNumberOfUserRequests(hourlyNodeRequests[hour].Users))
+			hourlyNodeRequests[hour].ByUser = append(hourlyNodeRequests[hour].ByUser, apiUserStatus)
+			sort.Stable(byNumberOfUserRequests(hourlyNodeRequests[hour].ByUser))
 		}
+		hourlyNodeRequests[hour].RequestCount = totalRequestsThisHour
 	}
 
 	return hourlyNodeRequests
 }
 
-func apiStatusToRequestCount(resource schema.GroupVersionResource, status *apiv1.DeprecatedAPIRequestStatus) *clusterRequestCounts {
+func apiStatusToRequestCount(resource schema.GroupVersionResource, status *apiv1.APIRequestCountStatus) *clusterRequestCounts {
 	requestCount := newClusterRequestCounts()
-	for hour, hourlyCount := range status.RequestsLast24h {
-		for _, hourlyNodeCount := range hourlyCount.Nodes {
-			for _, hourNodeUserCount := range hourlyNodeCount.Users {
-				for _, hourlyNodeUserVerbCount := range hourNodeUserCount.Requests {
+	for hour, hourlyCount := range status.Last24h {
+		for _, hourlyNodeCount := range hourlyCount.ByNode {
+			for _, hourNodeUserCount := range hourlyNodeCount.ByUser {
+				for _, hourlyNodeUserVerbCount := range hourNodeUserCount.ByVerb {
 					requestCount.IncrementRequestCount(
 						hourlyNodeCount.NodeName,
 						resource,
 						hour,
 						hourNodeUserCount.UserName,
 						hourlyNodeUserVerbCount.Verb,
-						hourlyNodeUserVerbCount.Count,
+						hourlyNodeUserVerbCount.RequestCount,
 					)
 				}
 			}
@@ -137,23 +153,23 @@ func apiStatusToRequestCount(resource schema.GroupVersionResource, status *apiv1
 	return requestCount
 }
 
-func canonicalizeStatus(status *apiv1.DeprecatedAPIRequestStatus) {
-	for hour := range status.RequestsLast24h {
-		hourlyCount := status.RequestsLast24h[hour]
-		for j := range hourlyCount.Nodes {
-			nodeCount := hourlyCount.Nodes[j]
-			for k := range nodeCount.Users {
-				userCount := nodeCount.Users[k]
-				sort.Stable(byVerb(userCount.Requests))
+func canonicalizeStatus(status *apiv1.APIRequestCountStatus) {
+	for hour := range status.Last24h {
+		hourlyCount := status.Last24h[hour]
+		for j := range hourlyCount.ByNode {
+			nodeCount := hourlyCount.ByNode[j]
+			for k := range nodeCount.ByUser {
+				userCount := nodeCount.ByUser[k]
+				sort.Stable(byVerb(userCount.ByVerb))
 			}
-			sort.Stable(byNumberOfUserRequests(nodeCount.Users))
+			sort.Stable(byNumberOfUserRequests(nodeCount.ByUser))
 		}
-		sort.Stable(byNode(status.RequestsLast24h[hour].Nodes))
+		sort.Stable(byNode(status.Last24h[hour].ByNode))
 	}
 
 }
 
-type byVerb []apiv1.RequestCount
+type byVerb []apiv1.PerVerbAPIRequestCount
 
 func (s byVerb) Len() int {
 	return len(s)
@@ -166,7 +182,7 @@ func (s byVerb) Less(i, j int) bool {
 	return strings.Compare(s[i].Verb, s[j].Verb) < 0
 }
 
-type byNode []apiv1.NodeRequestLog
+type byNode []apiv1.PerNodeAPIRequestLog
 
 func (s byNode) Len() int {
 	return len(s)
@@ -179,7 +195,7 @@ func (s byNode) Less(i, j int) bool {
 	return strings.Compare(s[i].NodeName, s[j].NodeName) < 0
 }
 
-type byNumberOfUserRequests []apiv1.RequestUser
+type byNumberOfUserRequests []apiv1.PerUserAPIRequestCount
 
 func (s byNumberOfUserRequests) Len() int {
 	return len(s)
@@ -189,5 +205,5 @@ func (s byNumberOfUserRequests) Swap(i, j int) {
 }
 
 func (s byNumberOfUserRequests) Less(i, j int) bool {
-	return s[i].Count < s[j].Count
+	return s[i].RequestCount < s[j].RequestCount
 }

openshift-kube-apiserver/filters/deprecatedapirequest/update_func.go

@@ -12,19 +12,20 @@ import (
 	"k8s.io/client-go/util/retry"
 )
 
-type UpdateStatusFunc func(status *apiv1.DeprecatedAPIRequestStatus)
+type UpdateStatusFunc func(status *apiv1.APIRequestCountStatus)
 
-func ApplyStatus(ctx context.Context, client apiclientv1.DeprecatedAPIRequestInterface, name string, updateFuncs ...UpdateStatusFunc) (*apiv1.DeprecatedAPIRequestStatus, bool, error) {
+func ApplyStatus(ctx context.Context, client apiclientv1.APIRequestCountInterface, name string, updateFuncs ...UpdateStatusFunc) (*apiv1.APIRequestCountStatus, bool, error) {
 	updated := false
-	var updatedStatus *apiv1.DeprecatedAPIRequestStatus
+	var updatedStatus *apiv1.APIRequestCountStatus
 	err := retry.RetryOnConflict(retry.DefaultBackoff, func() error {
 		check, err := client.Get(ctx, name, metav1.GetOptions{})
 		if errors.IsNotFound(err) {
 			// on a not found, let's create this thing.
-			requestCount := &apiv1.DeprecatedAPIRequest{
+			requestCount := &apiv1.APIRequestCount{
 				ObjectMeta: metav1.ObjectMeta{Name: name},
-				// TODO fix spec here
-				Spec: apiv1.DeprecatedAPIRequestSpec{RemovedRelease: "1.1"},
+				Spec: apiv1.APIRequestCountSpec{
+					NumberOfUsersToReport: 10,
+				},
 			}
 			check, err = client.Create(ctx, requestCount, metav1.CreateOptions{})
 		}

openshift-kube-apiserver/filters/deprecatedapirequest/v1helpers/helpers.go

@@ -17,9 +17,6 @@ func WithDeprecatedApiRequestLogging(handler http.Handler, controller deprecated
 		if !ok {
 			return
 		}
-		if !controller.IsDeprecated(info.Resource, info.APIVersion, info.APIGroup) {
-			return
-		}
 		timestamp, ok := request.ReceivedTimestampFrom(req.Context())
 		if !ok {
 			return

openshift-kube-apiserver/filters/deprecatedapirequest_filter.go

@@ -81,7 +81,7 @@ func OpenShiftKubeAPIServerConfigPatch(genericConfig *genericapiserver.Config, k
 	if err != nil {
 		return err
 	}
-	deprecatedAPIRequestController := deprecatedapirequest.NewController(deprecatedAPIClient.DeprecatedAPIRequests(), nodeFor())
+	deprecatedAPIRequestController := deprecatedapirequest.NewController(deprecatedAPIClient.APIRequestCounts(), nodeFor())
 	genericConfig.AddPostStartHook("openshift.io-deprecated-api-requests-filter", func(context genericapiserver.PostStartHookContext) error {
 		go deprecatedAPIRequestController.Start(context.StopCh)
 		return nil