// RecordConfigEvent records an event for the deployment config referenced by the // deployment. func RecordConfigEvent(client kcoreclient.EventsGetter, deployment *kapi.ReplicationController, decoder runtime.Decoder, eventType, reason, msg string) { t := unversioned.Time{Time: time.Now()} var obj runtime.Object = deployment if config, err := deployutil.DecodeDeploymentConfig(deployment, decoder); err == nil { obj = config } else { glog.Errorf("Unable to decode deployment config from %s/%s: %v", deployment.Namespace, deployment.Name, err) } ref, err := kapi.GetReference(obj) if err != nil { glog.Errorf("Unable to get reference for %#v: %v", obj, err) return } event := &kapi.Event{ ObjectMeta: kapi.ObjectMeta{ Name: fmt.Sprintf("%v.%x", ref.Name, t.UnixNano()), Namespace: ref.Namespace, }, InvolvedObject: *ref, Reason: reason, Message: msg, Source: kapi.EventSource{ Component: deployutil.DeployerPodNameFor(deployment), }, FirstTimestamp: t, LastTimestamp: t, Count: 1, Type: eventType, } if _, err := client.Events(ref.Namespace).Create(event); err != nil { glog.Errorf("Could not create event '%#v': %v", event, err) } }
func NewUnidlingController(scaleNS kextclient.ScalesGetter, endptsNS kclient.EndpointsGetter, evtNS kclient.EventsGetter, dcNamespacer deployclient.DeploymentConfigsGetter, rcNamespacer kclient.ReplicationControllersGetter, resyncPeriod time.Duration) *UnidlingController { fieldSet := fields.Set{} fieldSet["reason"] = unidlingapi.NeedPodsReason fieldSelector := fieldSet.AsSelector() unidlingController := &UnidlingController{ scaleNamespacer: scaleNS, endpointsNamespacer: endptsNS, queue: workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()), lastFiredCache: &lastFiredCache{ items: make(map[types.NamespacedName]time.Time), }, dcNamespacer: dcNamespacer, rcNamespacer: rcNamespacer, } _, controller := framework.NewInformer( &cache.ListWatch{ // No need to list -- we only care about new events ListFunc: func(options kapi.ListOptions) (runtime.Object, error) { return &kapi.EventList{}, nil }, WatchFunc: func(options kapi.ListOptions) (watch.Interface, error) { options.FieldSelector = fieldSelector return evtNS.Events(kapi.NamespaceAll).Watch(options) }, }, &kapi.Event{}, resyncPeriod, framework.ResourceEventHandlerFuncs{ AddFunc: func(obj interface{}) { event := obj.(*kapi.Event) unidlingController.enqueueEvent(event) }, UpdateFunc: func(oldObj interface{}, newObj interface{}) { // retrigger on new last-seen times event := newObj.(*kapi.Event) unidlingController.enqueueEvent(event) }, DeleteFunc: func(obj interface{}) { // this is just to clean up our cache of the last seen times event := obj.(*kapi.Event) unidlingController.clearEventFromCache(event) }, }, ) unidlingController.controller = controller return unidlingController }
func NewHorizontalController(evtNamespacer unversionedcore.EventsGetter, scaleNamespacer unversionedextensions.ScalesGetter, hpaNamespacer unversionedextensions.HorizontalPodAutoscalersGetter, metricsClient metrics.MetricsClient, resyncPeriod time.Duration) *HorizontalController { broadcaster := record.NewBroadcaster() broadcaster.StartRecordingToSink(&unversionedcore.EventSinkImpl{evtNamespacer.Events("")}) recorder := broadcaster.NewRecorder(api.EventSource{Component: "horizontal-pod-autoscaler"}) controller := &HorizontalController{ metricsClient: metricsClient, eventRecorder: recorder, scaleNamespacer: scaleNamespacer, hpaNamespacer: hpaNamespacer, } store, frameworkController := newInformer(controller, resyncPeriod) controller.store = store controller.controller = frameworkController return controller }
// RecordConfigWarnings records all warning events from the replication controller to the // associated deployment config. func RecordConfigWarnings(client kcoreclient.EventsGetter, rc *kapi.ReplicationController, decoder runtime.Decoder, out io.Writer) { if rc == nil { return } events, err := client.Events(rc.Namespace).Search(rc) if err != nil { fmt.Fprintf(out, "--> Error listing events for replication controller %s: %v\n", rc.Name, err) return } // TODO: Do we need to sort the events? for _, e := range events.Items { if e.Type == kapi.EventTypeWarning { fmt.Fprintf(out, "--> %s: %s %s\n", e.Reason, rc.Name, e.Message) RecordConfigEvent(client, rc, decoder, e.Type, e.Reason, e.Message) } } }