client-go: event support label

Signed-off-by: acejilam <[email protected]>

Author: ls-2018

pkg/controller/statefulset/stateful_set_utils_test.go

@@ -51,6 +51,8 @@ func (r *noopRecorder) Eventf(object runtime.Object, eventtype, reason, messageF
 }
 func (r *noopRecorder) AnnotatedEventf(object runtime.Object, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
 }
+func (r *noopRecorder) LabeledAnnotatedEventf(object runtime.Object, labels, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
+}
 
 // getClaimPodName gets the name of the Pod associated with the Claim, or an empty string if this doesn't look matching.
 func getClaimPodName(set *apps.StatefulSet, claim *v1.PersistentVolumeClaim) string {

pkg/controller/testutil/test_utils.go

@@ -417,6 +417,11 @@ func (f *FakeRecorder) AnnotatedEventf(obj runtime.Object, annotations map[strin
 	f.Eventf(obj, eventtype, reason, messageFmt, args...)
 }
 
+// LabeledAnnotatedEventf emits a fake formatted event to the fake recorder
+func (f *FakeRecorder) LabeledAnnotatedEventf(obj runtime.Object, labels, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
+	f.Eventf(obj, eventtype, reason, messageFmt, args...)
+}
+
 func (f *FakeRecorder) generateEvent(obj runtime.Object, timestamp metav1.Time, eventtype, reason, message string) {
 	f.Lock()
 	defer f.Unlock()

pkg/kubelet/container/helpers.go

@@ -243,7 +243,12 @@ func (irecorder *innerEventRecorder) AnnotatedEventf(object runtime.Object, anno
 	if ref, ok := irecorder.shouldRecordEvent(object); ok {
 		irecorder.recorder.AnnotatedEventf(ref, annotations, eventtype, reason, messageFmt, args...)
 	}
+}
 
+func (irecorder *innerEventRecorder) LabeledAnnotatedEventf(object runtime.Object, labels, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
+	if ref, ok := irecorder.shouldRecordEvent(object); ok {
+		irecorder.recorder.LabeledAnnotatedEventf(ref, labels, annotations, eventtype, reason, messageFmt, args...)
+	}
 }
 
 // IsHostNetworkPod returns whether the host networking requested for the given Pod.

pkg/kubelet/container/helpers_test.go

@@ -1187,6 +1187,10 @@ func (f *fakeRecorder) AnnotatedEventf(object runtime.Object, annotations map[st
 	f.aEvents = append(f.aEvents, eventtype+":"+reason+":"+messageFmt)
 }
 
+func (f *fakeRecorder) LabeledAnnotatedEventf(object runtime.Object, labels, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
+	f.aEvents = append(f.aEvents, eventtype+":"+reason+":"+messageFmt)
+}
+
 func TestFilterEventRecorder(t *testing.T) {
 	recorder := &fakeRecorder{}
 	filtered := FilterEventRecorder(recorder)

staging/src/k8s.io/client-go/tools/leaderelection/resourcelock/leaselock_test.go

@@ -46,6 +46,10 @@ func (r *mockRecorder) AnnotatedEventf(object runtime.Object, annotations map[st
 	r.events = append(r.events, fmt.Sprintf(messageFmt, args...))
 }
 
+func (r *mockRecorder) LabeledAnnotatedEventf(object runtime.Object, labels, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
+	r.events = append(r.events, fmt.Sprintf(messageFmt, args...))
+}
+
 const (
 	testNamespace = "test-namespace"
 	testName      = "test-name"

staging/src/k8s.io/client-go/tools/record/event.go

@@ -109,6 +109,9 @@ type EventRecorder interface {
 
 	// AnnotatedEventf is just like eventf, but with annotations attached
 	AnnotatedEventf(object runtime.Object, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{})
+
+	// LabeledAnnotatedEventf is just like eventf, but with labelsannotations、 attached
+	LabeledAnnotatedEventf(object runtime.Object, labels, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{})
 }
 
 // EventRecorderLogger extends EventRecorder such that a logger can
@@ -436,7 +439,7 @@ type recorderImpl struct {
 
 var _ EventRecorder = &recorderImpl{}
 
-func (recorder *recorderImpl) generateEvent(logger klog.Logger, object runtime.Object, annotations map[string]string, eventtype, reason, message string) {
+func (recorder *recorderImpl) generateEvent(logger klog.Logger, object runtime.Object, labels, annotations map[string]string, eventtype, reason, message string) {
 	ref, err := ref.GetReference(recorder.scheme, object)
 	if err != nil {
 		logger.Error(err, "Could not construct reference, will not report event", "object", object, "eventType", eventtype, "reason", reason, "message", message)
@@ -448,7 +451,7 @@ func (recorder *recorderImpl) generateEvent(logger klog.Logger, object runtime.O
 		return
 	}
 
-	event := recorder.makeEvent(ref, annotations, eventtype, reason, message)
+	event := recorder.makeEvent(ref, labels, annotations, eventtype, reason, message)
 	event.Source = recorder.source
 
 	event.ReportingInstance = recorder.source.Host
@@ -470,18 +473,22 @@ func (recorder *recorderImpl) generateEvent(logger klog.Logger, object runtime.O
 }
 
 func (recorder *recorderImpl) Event(object runtime.Object, eventtype, reason, message string) {
-	recorder.generateEvent(klog.Background(), object, nil, eventtype, reason, message)
+	recorder.generateEvent(klog.Background(), object, nil, nil, eventtype, reason, message)
 }
 
 func (recorder *recorderImpl) Eventf(object runtime.Object, eventtype, reason, messageFmt string, args ...interface{}) {
 	recorder.Event(object, eventtype, reason, fmt.Sprintf(messageFmt, args...))
 }
 
 func (recorder *recorderImpl) AnnotatedEventf(object runtime.Object, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
-	recorder.generateEvent(klog.Background(), object, annotations, eventtype, reason, fmt.Sprintf(messageFmt, args...))
+	recorder.generateEvent(klog.Background(), object, nil, annotations, eventtype, reason, fmt.Sprintf(messageFmt, args...))
+}
+
+func (recorder *recorderImpl) LabeledAnnotatedEventf(object runtime.Object, labels, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
+	recorder.generateEvent(klog.Background(), object, labels, annotations, eventtype, reason, fmt.Sprintf(messageFmt, args...))
 }
 
-func (recorder *recorderImpl) makeEvent(ref *v1.ObjectReference, annotations map[string]string, eventtype, reason, message string) *v1.Event {
+func (recorder *recorderImpl) makeEvent(ref *v1.ObjectReference, labels, annotations map[string]string, eventtype, reason, message string) *v1.Event {
 	t := metav1.Time{Time: recorder.clock.Now()}
 	namespace := ref.Namespace
 	if namespace == "" {
@@ -491,6 +498,7 @@ func (recorder *recorderImpl) makeEvent(ref *v1.ObjectReference, annotations map
 		ObjectMeta: metav1.ObjectMeta{
 			Name:        util.GenerateEventName(ref.Name, t.UnixNano()),
 			Namespace:   namespace,
+			Labels:      labels,
 			Annotations: annotations,
 		},
 		InvolvedObject: *ref,
@@ -511,15 +519,18 @@ type recorderImplLogger struct {
 var _ EventRecorderLogger = &recorderImplLogger{}
 
 func (recorder recorderImplLogger) Event(object runtime.Object, eventtype, reason, message string) {
-	recorder.recorderImpl.generateEvent(recorder.logger, object, nil, eventtype, reason, message)
+	recorder.recorderImpl.generateEvent(recorder.logger, object, nil, nil, eventtype, reason, message)
 }
 
 func (recorder recorderImplLogger) Eventf(object runtime.Object, eventtype, reason, messageFmt string, args ...interface{}) {
 	recorder.Event(object, eventtype, reason, fmt.Sprintf(messageFmt, args...))
 }
 
 func (recorder recorderImplLogger) AnnotatedEventf(object runtime.Object, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
-	recorder.generateEvent(recorder.logger, object, annotations, eventtype, reason, fmt.Sprintf(messageFmt, args...))
+	recorder.generateEvent(recorder.logger, object, nil, annotations, eventtype, reason, fmt.Sprintf(messageFmt, args...))
+}
+func (recorder recorderImplLogger) LabeledAnnotatedEventf(object runtime.Object, labels, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
+	recorder.generateEvent(recorder.logger, object, labels, annotations, eventtype, reason, fmt.Sprintf(messageFmt, args...))
 }
 
 func (recorder recorderImplLogger) WithLogger(logger klog.Logger) EventRecorderLogger {

staging/src/k8s.io/client-go/tools/record/fake.go

@@ -51,24 +51,35 @@ func annotationsString(annotations map[string]string) string {
 		return " " + fmt.Sprint(annotations)
 	}
 }
+func labelsString(labels map[string]string) string {
+	if len(labels) == 0 {
+		return ""
+	} else {
+		return " " + fmt.Sprint(labels)
+	}
+}
 
-func (f *FakeRecorder) writeEvent(object runtime.Object, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
+func (f *FakeRecorder) writeEvent(object runtime.Object, labels, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
 	if f.Events != nil {
 		f.Events <- fmt.Sprintf(eventtype+" "+reason+" "+messageFmt, args...) +
-			objectString(object, f.IncludeObject) + annotationsString(annotations)
+			objectString(object, f.IncludeObject) + annotationsString(annotations) + labelsString(labels)
 	}
 }
 
 func (f *FakeRecorder) Event(object runtime.Object, eventtype, reason, message string) {
-	f.writeEvent(object, nil, eventtype, reason, "%s", message)
+	f.writeEvent(object, nil, nil, eventtype, reason, "%s", message)
 }
 
 func (f *FakeRecorder) Eventf(object runtime.Object, eventtype, reason, messageFmt string, args ...interface{}) {
-	f.writeEvent(object, nil, eventtype, reason, messageFmt, args...)
+	f.writeEvent(object, nil, nil, eventtype, reason, messageFmt, args...)
 }
 
 func (f *FakeRecorder) AnnotatedEventf(object runtime.Object, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
-	f.writeEvent(object, annotations, eventtype, reason, messageFmt, args...)
+	f.writeEvent(object, nil, annotations, eventtype, reason, messageFmt, args...)
+}
+
+func (f *FakeRecorder) LabeledAnnotatedEventf(object runtime.Object, labels, annotations map[string]string, eventtype, reason, messageFmt string, args ...interface{}) {
+	f.writeEvent(object, labels, annotations, eventtype, reason, messageFmt, args...)
 }
 
 func (f *FakeRecorder) WithLogger(logger klog.Logger) EventRecorderLogger {