Add new Events API group

pkg/api/testapi/testapi.go

@@ -43,6 +43,7 @@ import (
 	"k8s.io/kubernetes/pkg/apis/batch"
 	"k8s.io/kubernetes/pkg/apis/certificates"
 	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/events"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/apis/imagepolicy"
 	"k8s.io/kubernetes/pkg/apis/networking"
@@ -62,6 +63,7 @@ import (
 	_ "k8s.io/kubernetes/pkg/apis/certificates/install"
 	_ "k8s.io/kubernetes/pkg/apis/componentconfig/install"
 	_ "k8s.io/kubernetes/pkg/apis/core/install"
+	_ "k8s.io/kubernetes/pkg/apis/events/install"
 	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
 	_ "k8s.io/kubernetes/pkg/apis/imagepolicy/install"
 	_ "k8s.io/kubernetes/pkg/apis/networking/install"
@@ -79,6 +81,7 @@ var (
 	Autoscaling   TestGroup
 	Batch         TestGroup
 	Extensions    TestGroup
+	Events        TestGroup
 	Apps          TestGroup
 	Policy        TestGroup
 	Rbac          TestGroup
@@ -314,6 +317,15 @@ func init() {
 			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
 		}
 	}
+	if _, ok := Groups[events.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: events.GroupName, Version: legacyscheme.Registry.GroupOrDie(events.GroupName).GroupVersion.Version}
+		Groups[events.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: events.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(events.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
 
 	Default = Groups[api.GroupName]
 	Autoscaling = Groups[autoscaling.GroupName]
@@ -322,6 +334,7 @@ func init() {
 	Policy = Groups[policy.GroupName]
 	Certificates = Groups[certificates.GroupName]
 	Extensions = Groups[extensions.GroupName]
+	Events = Groups[events.GroupName]
 	Rbac = Groups[rbac.GroupName]
 	Scheduling = Groups[scheduling.GroupName]
 	Settings = Groups[settings.GroupName]

pkg/apis/core/field_constants.go

@@ -25,8 +25,8 @@ const (
 	PodStatusField         = "status.phase"
 	SecretTypeField        = "type"
 
-	EventReasonField                  = "reason"
-	EventSourceField                  = "source"
+	EventReasonField                  = "action"
+	EventSourceField                  = "reportingComponent"
 	EventTypeField                    = "type"
 	EventInvolvedKindField            = "involvedObject.kind"
 	EventInvolvedNamespaceField       = "involvedObject.namespace"

pkg/apis/core/fuzzer/fuzzer.go

@@ -19,10 +19,12 @@ package fuzzer
 import (
 	"reflect"
 	"strconv"
+	"time"
 
 	fuzz "github.com/google/gofuzz"
 
 	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/fields"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -483,5 +485,12 @@ var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
 			c.FuzzNoCustom(s)
 			s.Allocatable = s.Capacity
 		},
+		func(e *core.Event, c fuzz.Continue) {
+			c.FuzzNoCustom(e)
+			e.EventTime = metav1.MicroTime{Time: time.Unix(1, 1000)}
+			if e.Series != nil {
+				e.Series.LastObservedTime = metav1.MicroTime{Time: time.Unix(3, 3000)}
+			}
+		},
 	}
 }

pkg/apis/core/types.go

@@ -3958,7 +3958,7 @@ type Event struct {
 	// +optional
 	metav1.ObjectMeta
 
-	// Required. The object that this event is about.
+	// Required. The object that this event is about. Mapped to events.Event.regarding
 	// +optional
 	InvolvedObject ObjectReference
 
@@ -3970,7 +3970,7 @@ type Event struct {
 	Reason string
 
 	// Optional. A human-readable description of the status of this operation.
-	// TODO: decide on maximum length.
+	// TODO: decide on maximum length. Mapped to events.Event.note
 	// +optional
 	Message string
 
@@ -3993,8 +3993,49 @@ type Event struct {
 	// Type of this event (Normal, Warning), new types could be added in the future.
 	// +optional
 	Type string
+
+	// Time when this Event was first observed.
+	// +optional
+	EventTime metav1.MicroTime
+
+	// Data about the Event series this event represents or nil if it's a singleton Event.
+	// +optional
+	Series *EventSeries
+
+	// What action was taken/failed regarding to the Regarding object.
+	// +optional
+	Action string
+
+	// Optional secondary object for more complex actions.
+	// +optional
+	Related *ObjectReference
+
+	// Name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`.
+	// +optional
+	ReportingController string
+
+	// ID of the controller instance, e.g. `kubelet-xyzf`.
+	// +optional
+	ReportingInstance string
 }
 
+type EventSeries struct {
+	// Number of occurrences in this series up to the last heartbeat time
+	Count int32
+	// Time of the last occurence observed
+	LastObservedTime metav1.MicroTime
+	// State of this Series: Ongoing or Finished
+	State EventSeriesState
+}
+
+type EventSeriesState string
+
+const (
+	EventSeriesStateOngoing  EventSeriesState = "Ongoing"
+	EventSeriesStateFinished EventSeriesState = "Finished"
+	EventSeriesStateUnknown  EventSeriesState = "Unknown"
+)
+
 // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
 
 // EventList is a list of events.

pkg/apis/core/validation/events.go

@@ -18,6 +18,7 @@ package validation
 
 import (
 	"fmt"
+	"time"
 
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -28,24 +29,68 @@ import (
 	"k8s.io/kubernetes/pkg/apis/core"
 )
 
+const (
+	ReportingInstanceLengthLimit = 128
+	ActionLengthLimit            = 128
+	ReasonLengthLimit            = 128
+	NoteLengthLimit              = 1024
+)
+
 // ValidateEvent makes sure that the event makes sense.
 func ValidateEvent(event *core.Event) field.ErrorList {
 	allErrs := field.ErrorList{}
+	// Because go
+	zeroTime := time.Time{}
 
-	// Make sure event.Namespace and the involvedObject.Namespace agree
-	if len(event.InvolvedObject.Namespace) == 0 {
-		// event.Namespace must also be empty (or "default", for compatibility with old clients)
-		if event.Namespace != metav1.NamespaceNone && event.Namespace != metav1.NamespaceDefault {
+	// "New" Events need to have EventTime set, so it's validating old object.
+	if event.EventTime.Time == zeroTime {
+		// Make sure event.Namespace and the involvedInvolvedObject.Namespace agree
+		if len(event.InvolvedObject.Namespace) == 0 {
+			// event.Namespace must also be empty (or "default", for compatibility with old clients)
+			if event.Namespace != metav1.NamespaceNone && event.Namespace != metav1.NamespaceDefault {
+				allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, "does not match event.namespace"))
+			}
+		} else {
+			// event namespace must match
+			if event.Namespace != event.InvolvedObject.Namespace {
+				allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, "does not match event.namespace"))
+			}
+		}
+
+	} else {
+		if len(event.InvolvedObject.Namespace) == 0 && event.Namespace != metav1.NamespaceSystem {
 			allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, "does not match event.namespace"))
 		}
-	} else {
-		// event namespace must match
-		if event.Namespace != event.InvolvedObject.Namespace {
-			allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, "does not match event.namespace"))
+		if len(event.ReportingController) == 0 {
+			allErrs = append(allErrs, field.Required(field.NewPath("reportingController"), ""))
+		}
+		for _, msg := range validation.IsQualifiedName(event.ReportingController) {
+			allErrs = append(allErrs, field.Invalid(field.NewPath("reportingController"), event.ReportingController, msg))
+		}
+		if len(event.ReportingInstance) == 0 {
+			allErrs = append(allErrs, field.Required(field.NewPath("reportingInstance"), ""))
+		}
+		if len(event.ReportingInstance) > ReportingInstanceLengthLimit {
+			allErrs = append(allErrs, field.Invalid(field.NewPath("repotingIntance"), "", fmt.Sprintf("can have at most %v characters", ReportingInstanceLengthLimit)))
+		}
+		if len(event.Action) == 0 {
+			allErrs = append(allErrs, field.Required(field.NewPath("action"), ""))
+		}
+		if len(event.Action) > ActionLengthLimit {
+			allErrs = append(allErrs, field.Invalid(field.NewPath("action"), "", fmt.Sprintf("can have at most %v characters", ActionLengthLimit)))
+		}
+		if len(event.Reason) == 0 {
+			allErrs = append(allErrs, field.Required(field.NewPath("reason"), ""))
+		}
+		if len(event.Reason) > ReasonLengthLimit {
+			allErrs = append(allErrs, field.Invalid(field.NewPath("reason"), "", fmt.Sprintf("can have at most %v characters", ReasonLengthLimit)))
+		}
+		if len(event.Message) > NoteLengthLimit {
+			allErrs = append(allErrs, field.Invalid(field.NewPath("message"), "", fmt.Sprintf("can have at most %v characters", NoteLengthLimit)))
 		}
 	}
 
-	// For kinds we recognize, make sure involvedObject.Namespace is set for namespaced kinds
+	// For kinds we recognize, make sure InvolvedObject.Namespace is set for namespaced kinds
 	if namespaced, err := isNamespacedKind(event.InvolvedObject.Kind, event.InvolvedObject.APIVersion); err == nil {
 		if namespaced && len(event.InvolvedObject.Namespace) == 0 {
 			allErrs = append(allErrs, field.Required(field.NewPath("involvedObject", "namespace"), fmt.Sprintf("required for kind %s", event.InvolvedObject.Kind)))

pkg/apis/core/validation/events_test.go

@@ -18,6 +18,7 @@ package validation
 
 import (
 	"testing"
+	"time"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/kubernetes/pkg/apis/core"
@@ -215,7 +216,177 @@ func TestValidateEvent(t *testing.T) {
 
 	for _, item := range table {
 		if e, a := item.valid, len(ValidateEvent(item.Event)) == 0; e != a {
-			t.Errorf("%v: expected %v, got %v", item.Event.Name, e, a)
+			t.Errorf("%v: expected %v, got %v: %v", item.Event.Name, e, a, ValidateEvent(item.Event))
+		}
+	}
+}
+
+func TestValidateNewEvent(t *testing.T) {
+	someTime := metav1.MicroTime{Time: time.Unix(1505828956, 0)}
+	table := []struct {
+		*core.Event
+		valid bool
+		msg   string
+	}{
+		{
+			Event: &core.Event{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "test",
+					Namespace: metav1.NamespaceDefault,
+				},
+				InvolvedObject: core.ObjectReference{
+					APIVersion: "v1",
+					Kind:       "Node",
+				},
+				EventTime: someTime,
+			},
+			valid: false,
+			msg:   "Old Event with EventTime should trigger new validation and fail",
+		},
+		{
+			Event: &core.Event{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "test",
+					Namespace: metav1.NamespaceSystem,
+				},
+				InvolvedObject: core.ObjectReference{
+					APIVersion: "v1",
+					Kind:       "Node",
+				},
+				EventTime:           someTime,
+				ReportingController: "k8s.io/my-controller",
+				ReportingInstance:   "node-xyz",
+				Action:              "Do",
+				Reason:              "Because",
+			},
+			valid: true,
+			msg:   "Valid new Event",
+		},
+		{
+			Event: &core.Event{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "test",
+					Namespace: metav1.NamespaceSystem,
+				},
+				InvolvedObject: core.ObjectReference{
+					APIVersion: "v1",
+					Kind:       "Node",
+				},
+				EventTime:           someTime,
+				ReportingController: "my-contr@ller",
+				ReportingInstance:   "node-xyz",
+				Action:              "Do",
+				Reason:              "Because",
+			},
+			valid: false,
+			msg:   "not qualified reportingController",
+		},
+		{
+			Event: &core.Event{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "test",
+					Namespace: metav1.NamespaceSystem,
+				},
+				InvolvedObject: core.ObjectReference{
+					APIVersion: "v1",
+					Kind:       "Node",
+				},
+				EventTime:           someTime,
+				ReportingController: "k8s.io/my-controller",
+				ReportingInstance:   "node-xyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz",
+				Action:              "Do",
+				Reason:              "Because",
+			},
+			valid: false,
+			msg:   "too long reporting instance",
+		},
+		{
+			Event: &core.Event{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "test",
+					Namespace: metav1.NamespaceSystem,
+				},
+				InvolvedObject: core.ObjectReference{
+					APIVersion: "v1",
+					Kind:       "Node",
+				},
+				EventTime:           someTime,
+				ReportingController: "k8s.io/my-controller",
+				ReportingInstance:   "node-xyz",
+				Action:              "Do",
+			},
+			valid: false,
+			msg:   "missing reason",
+		},
+		{
+			Event: &core.Event{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "test",
+					Namespace: metav1.NamespaceSystem,
+				},
+				InvolvedObject: core.ObjectReference{
+					APIVersion: "v1",
+					Kind:       "Node",
+				},
+				EventTime:           someTime,
+				ReportingController: "k8s.io/my-controller",
+				ReportingInstance:   "node-xyz",
+				Reason:              "Because",
+			},
+			valid: false,
+			msg:   "missing action",
+		},
+		{
+			Event: &core.Event{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "test",
+				},
+				InvolvedObject: core.ObjectReference{
+					APIVersion: "v1",
+					Kind:       "Node",
+				},
+				EventTime:           someTime,
+				ReportingController: "k8s.io/my-controller",
+				ReportingInstance:   "node-xyz",
+				Reason:              "Because",
+			},
+			valid: false,
+			msg:   "missing namespace",
+		},
+		{
+			Event: &core.Event{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "test",
+				},
+				InvolvedObject: core.ObjectReference{
+					APIVersion: "v1",
+					Kind:       "Node",
+				},
+				EventTime:           someTime,
+				ReportingController: "k8s.io/my-controller",
+				ReportingInstance:   "node-xyz",
+				Action:              "Do",
+				Reason:              "Because",
+				Message: `zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
+zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
+zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
+zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
+zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
+zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
+zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
+zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
+zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
+zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
+zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz`,
+			},
+			valid: false,
+			msg:   "too long message",
+		},
+	}
+
+	for _, item := range table {
+		if e, a := item.valid, len(ValidateEvent(item.Event)) == 0; e != a {
+			t.Errorf("%v: expected %v, got %v: %v", item.msg, e, a, ValidateEvent(item.Event))
 		}
 	}
 }

pkg/apis/events/doc.go

@@ -0,0 +1,18 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+
+// +groupName=events.k8s.io
+package events // import "k8s.io/kubernetes/pkg/apis/events"

pkg/apis/events/install/install.go

@@ -0,0 +1,48 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+
+// Package install installs the events API group, making it available as
+// an option to all of the API encoding/decoding machinery.
+package install
+
+import (
+	"k8s.io/apimachinery/pkg/apimachinery/announced"
+	"k8s.io/apimachinery/pkg/apimachinery/registered"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/apis/events"
+	"k8s.io/kubernetes/pkg/apis/events/v1beta1"
+)
+
+func init() {
+	Install(legacyscheme.GroupFactoryRegistry, legacyscheme.Registry, legacyscheme.Scheme)
+}
+
+// Install registers the API group and adds types to a scheme
+func Install(groupFactoryRegistry announced.APIGroupFactoryRegistry, registry *registered.APIRegistrationManager, scheme *runtime.Scheme) {
+	if err := announced.NewGroupMetaFactory(
+		&announced.GroupMetaFactoryArgs{
+			GroupName:                  events.GroupName,
+			VersionPreferenceOrder:     []string{v1beta1.SchemeGroupVersion.Version},
+			AddInternalObjectsToScheme: events.AddToScheme,
+		},
+		announced.VersionToSchemeFunc{
+			v1beta1.SchemeGroupVersion.Version: v1beta1.AddToScheme,
+		},
+	).Announce(groupFactoryRegistry).RegisterAndEnable(registry, scheme); err != nil {
+		panic(err)
+	}
+}

pkg/apis/events/register.go

@@ -0,0 +1,52 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+
+package events
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubernetes/pkg/apis/core"
+)
+
+// GroupName is the group name use in this package
+const GroupName = "events.k8s.io"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
+
+// Kind takes an unqualified kind and returns a Group qualified GroupKind
+func Kind(kind string) schema.GroupKind {
+	return SchemeGroupVersion.WithKind(kind).GroupKind()
+}
+
+// Resource takes an unqualified resource and returns a Group qualified GroupResource
+func Resource(resource string) schema.GroupResource {
+	return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+var (
+	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
+	AddToScheme   = SchemeBuilder.AddToScheme
+)
+
+func addKnownTypes(scheme *runtime.Scheme) error {
+	scheme.AddKnownTypes(SchemeGroupVersion,
+		&core.Event{},
+		&core.EventList{},
+	)
+	return nil
+}

pkg/apis/events/v1beta1/conversion.go

@@ -0,0 +1,58 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+
+package v1beta1
+
+import (
+	v1beta1 "k8s.io/api/events/v1beta1"
+	conversion "k8s.io/apimachinery/pkg/conversion"
+	k8s_api "k8s.io/kubernetes/pkg/apis/core"
+	k8s_api_v1 "k8s.io/kubernetes/pkg/apis/core/v1"
+)
+
+func Convert_v1beta1_Event_To_core_Event(in *v1beta1.Event, out *k8s_api.Event, s conversion.Scope) error {
+	if err := autoConvert_v1beta1_Event_To_core_Event(in, out, s); err != nil {
+		return err
+	}
+	if err := k8s_api_v1.Convert_v1_ObjectReference_To_core_ObjectReference(&in.Regarding, &out.InvolvedObject, s); err != nil {
+		return err
+	}
+	if err := k8s_api_v1.Convert_v1_EventSource_To_core_EventSource(&in.DeprecatedSource, &out.Source, s); err != nil {
+		return err
+	}
+	out.Message = in.Note
+	out.FirstTimestamp = in.DeprecatedFirstTimestamp
+	out.LastTimestamp = in.DeprecatedLastTimestamp
+	out.Count = in.DeprecatedCount
+	return nil
+}
+
+func Convert_core_Event_To_v1beta1_Event(in *k8s_api.Event, out *v1beta1.Event, s conversion.Scope) error {
+	if err := autoConvert_core_Event_To_v1beta1_Event(in, out, s); err != nil {
+		return err
+	}
+	if err := k8s_api_v1.Convert_core_ObjectReference_To_v1_ObjectReference(&in.InvolvedObject, &out.Regarding, s); err != nil {
+		return err
+	}
+	if err := k8s_api_v1.Convert_core_EventSource_To_v1_EventSource(&in.Source, &out.DeprecatedSource, s); err != nil {
+		return err
+	}
+	out.Note = in.Message
+	out.DeprecatedFirstTimestamp = in.FirstTimestamp
+	out.DeprecatedLastTimestamp = in.LastTimestamp
+	out.DeprecatedCount = in.Count
+	return nil
+}

pkg/apis/events/v1beta1/doc.go

@@ -0,0 +1,23 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+
+// +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/events
+// +k8s:conversion-gen-external-types=../../../../vendor/k8s.io/api/events/v1beta1
+// +k8s:defaulter-gen=TypeMeta
+// +k8s:defaulter-gen-input=../../../../vendor/k8s.io/api/events/v1beta1
+
+// +groupName=events.k8s.io
+package v1beta1 // import "k8s.io/kubernetes/pkg/apis/events/v1beta1"

pkg/apis/events/v1beta1/register.go

@@ -0,0 +1,45 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+
+package v1beta1
+
+import (
+	eventsv1beta1 "k8s.io/api/events/v1beta1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+// GroupName is the group name use in this package
+const GroupName = "events.k8s.io"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}
+
+// Resource takes an unqualified resource and returns a Group qualified GroupResource
+func Resource(resource string) schema.GroupResource {
+	return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+var (
+	localSchemeBuilder = &eventsv1beta1.SchemeBuilder
+	AddToScheme        = localSchemeBuilder.AddToScheme
+)
+
+func init() {
+	// We only register manually written functions here. The registration of the
+	// generated functions takes place in the generated files. The separation
+	// makes the code compile even when the generated files are missing.
+	localSchemeBuilder.Register(RegisterDefaults)
+}

pkg/master/import_known_versions.go

@@ -32,6 +32,7 @@ import (
 	_ "k8s.io/kubernetes/pkg/apis/certificates/install"
 	_ "k8s.io/kubernetes/pkg/apis/componentconfig/install"
 	_ "k8s.io/kubernetes/pkg/apis/core/install"
+	_ "k8s.io/kubernetes/pkg/apis/events/install"
 	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
 	_ "k8s.io/kubernetes/pkg/apis/imagepolicy/install"
 	_ "k8s.io/kubernetes/pkg/apis/networking/install"

pkg/master/master.go

@@ -37,6 +37,7 @@ import (
 	batchapiv1beta1 "k8s.io/api/batch/v1beta1"
 	certificatesapiv1beta1 "k8s.io/api/certificates/v1beta1"
 	apiv1 "k8s.io/api/core/v1"
+	eventsv1beta1 "k8s.io/api/events/v1beta1"
 	extensionsapiv1beta1 "k8s.io/api/extensions/v1beta1"
 	networkingapiv1 "k8s.io/api/networking/v1"
 	policyapiv1beta1 "k8s.io/api/policy/v1beta1"
@@ -77,6 +78,7 @@ import (
 	batchrest "k8s.io/kubernetes/pkg/registry/batch/rest"
 	certificatesrest "k8s.io/kubernetes/pkg/registry/certificates/rest"
 	corerest "k8s.io/kubernetes/pkg/registry/core/rest"
+	eventsrest "k8s.io/kubernetes/pkg/registry/events/rest"
 	extensionsrest "k8s.io/kubernetes/pkg/registry/extensions/rest"
 	networkingrest "k8s.io/kubernetes/pkg/registry/networking/rest"
 	policyrest "k8s.io/kubernetes/pkg/registry/policy/rest"
@@ -350,6 +352,7 @@ func (c completedConfig) New(delegationTarget genericapiserver.DelegationTarget)
 		// See https://github.com/kubernetes/kubernetes/issues/42392
 		appsrest.RESTStorageProvider{},
 		admissionregistrationrest.RESTStorageProvider{},
+		eventsrest.RESTStorageProvider{TTL: c.ExtraConfig.EventTTL},
 	}
 	m.InstallAPIs(c.ExtraConfig.APIResourceConfigSource, c.GenericConfig.RESTOptionsGetter, restStorageProviders...)
 
@@ -479,6 +482,7 @@ func DefaultAPIResourceConfigSource() *serverstorage.ResourceConfig {
 		authorizationapiv1.SchemeGroupVersion,
 		authorizationapiv1beta1.SchemeGroupVersion,
 		networkingapiv1.SchemeGroupVersion,
+		eventsv1beta1.SchemeGroupVersion,
 	)
 
 	// all extensions resources except these are disabled by default

pkg/registry/events/OWNERS

@@ -0,0 +1,8 @@
+reviewers:
+- gmarek
+- deads2k
+- sttts
+approvers:
+- gmarek
+- deads2k
+- sttts

pkg/registry/events/event/doc.go

@@ -0,0 +1,17 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+
+package event // import "k8s.io/kubernetes/pkg/registry/events/event"

pkg/registry/events/event/strategy.go

@@ -0,0 +1,104 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+
+package event
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/fields"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
+	"k8s.io/apiserver/pkg/registry/generic"
+	apistorage "k8s.io/apiserver/pkg/storage"
+	"k8s.io/apiserver/pkg/storage/names"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/core/validation"
+)
+
+// eventStrategy implements verification logic for Pod Presets.
+type eventStrategy struct {
+	runtime.ObjectTyper
+	names.NameGenerator
+}
+
+// Strategy is the default logic that applies when creating and updating Pod Preset objects.
+var Strategy = eventStrategy{legacyscheme.Scheme, names.SimpleNameGenerator}
+
+// NamespaceScoped returns true because all Events need to be within a namespace.
+func (eventStrategy) NamespaceScoped() bool {
+	return true
+}
+
+// PrepareForCreate clears the status of a Pod Preset before creation.
+func (eventStrategy) PrepareForCreate(ctx genericapirequest.Context, obj runtime.Object) {
+}
+
+// PrepareForUpdate clears fields that are not allowed to be set by end users on update.
+func (eventStrategy) PrepareForUpdate(ctx genericapirequest.Context, obj, old runtime.Object) {
+}
+
+// Validate validates a new Event.
+func (eventStrategy) Validate(ctx genericapirequest.Context, obj runtime.Object) field.ErrorList {
+	event := obj.(*api.Event)
+	return validation.ValidateEvent(event)
+}
+
+// Canonicalize normalizes the object after validation.
+// AllowCreateOnUpdate is false for Event; this means POST is needed to create one.
+func (eventStrategy) AllowCreateOnUpdate() bool {
+	return false
+}
+
+func (eventStrategy) Canonicalize(obj runtime.Object) {}
+
+// ValidateUpdate is the default update validation for an end user.
+func (eventStrategy) ValidateUpdate(ctx genericapirequest.Context, obj, old runtime.Object) field.ErrorList {
+	event := obj.(*api.Event)
+	return validation.ValidateEvent(event)
+}
+
+// AllowUnconditionalUpdate is the default update policy for Event objects.
+func (eventStrategy) AllowUnconditionalUpdate() bool {
+	return true
+}
+
+// SelectableFields returns a field set that represents the object.
+func SelectableFields(pip *api.Event) fields.Set {
+	return generic.ObjectMetaFieldsSet(&pip.ObjectMeta, true)
+}
+
+// GetAttrs returns labels and fields of a given object for filtering purposes.
+func GetAttrs(obj runtime.Object) (labels.Set, fields.Set, bool, error) {
+	pip, ok := obj.(*api.Event)
+	if !ok {
+		return nil, nil, false, fmt.Errorf("given object is not a Event")
+	}
+	return labels.Set(pip.ObjectMeta.Labels), SelectableFields(pip), pip.Initializers != nil, nil
+}
+
+// Matcher is the filter used by the generic etcd backend to watch events
+// from etcd to clients of the apiserver only interested in specific labels/fields.
+func Matcher(label labels.Selector, field fields.Selector) apistorage.SelectionPredicate {
+	return apistorage.SelectionPredicate{
+		Label:    label,
+		Field:    field,
+		GetAttrs: GetAttrs,
+	}
+}

pkg/registry/events/rest/storage_events.go

@@ -0,0 +1,62 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+*/
+
+package rest
+
+import (
+	"time"
+
+	eventsapiv1beta1 "k8s.io/api/events/v1beta1"
+	"k8s.io/apiserver/pkg/registry/generic"
+	"k8s.io/apiserver/pkg/registry/rest"
+	genericapiserver "k8s.io/apiserver/pkg/server"
+	serverstorage "k8s.io/apiserver/pkg/server/storage"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/apis/events"
+	eventstore "k8s.io/kubernetes/pkg/registry/core/event/storage"
+)
+
+type RESTStorageProvider struct {
+	TTL time.Duration
+}
+
+func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (genericapiserver.APIGroupInfo, bool) {
+	apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(events.GroupName, legacyscheme.Registry, legacyscheme.Scheme, legacyscheme.ParameterCodec, legacyscheme.Codecs)
+	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
+	// TODO refactor the plumbing to provide the information in the APIGroupInfo
+
+	if apiResourceConfigSource.AnyResourcesForVersionEnabled(eventsapiv1beta1.SchemeGroupVersion) {
+		apiGroupInfo.VersionedResourcesStorageMap[eventsapiv1beta1.SchemeGroupVersion.Version] = p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter)
+		apiGroupInfo.GroupMeta.GroupVersion = eventsapiv1beta1.SchemeGroupVersion
+	}
+
+	return apiGroupInfo, true
+}
+
+func (p RESTStorageProvider) v1beta1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) map[string]rest.Storage {
+	version := eventsapiv1beta1.SchemeGroupVersion
+
+	storage := map[string]rest.Storage{}
+	if apiResourceConfigSource.ResourceEnabled(version.WithResource("events")) {
+		eventsStorage := eventstore.NewREST(restOptionsGetter, uint64(p.TTL.Seconds()))
+		storage["events"] = eventsStorage
+	}
+	return storage
+}
+
+func (p RESTStorageProvider) GroupName() string {
+	return events.GroupName
+}