cadvisor详解

    for _, watcher := range self.containerWatchers {
        err := watcher.Start(self.eventsChannel)
        if err != nil {
            return err
        }
    }

    outStream := make(chan *oomparser.OomInstance, 10)
    oomLog, err := oomparser.New()
    if err != nil {
        return err
    }
    go oomLog.StreamOoms(outStream)

    go func() {
        for oomInstance := range outStream {
            // Surface OOM and OOM kill events.
            newEvent := &info.Event{
                ContainerName: oomInstance.ContainerName,
                Timestamp:     oomInstance.TimeOfDeath,
                EventType:     info.EventOom,
            }
            err := self.eventHandler.AddEvent(newEvent)
            if err != nil {
                klog.Errorf("failed to add OOM event for %q: %v", oomInstance.ContainerName, err)
            }

// events provides an implementation for the EventManager interface.
type events struct {
    // eventStore holds the events by event type.
    eventStore map[info.EventType]*utils.TimedStore
    // map of registered watchers keyed by watch id.
    watchers map[int]*watch
    // lock guarding the eventStore.
    eventsLock sync.RWMutex
    // lock guarding watchers.
    watcherLock sync.RWMutex
    // last allocated watch id.
    lastId int
    // Event storage policy.
    storagePolicy StoragePolicy
}

// initialized by a call to WatchEvents(), a watch struct will then be added
// to the events slice of *watch objects. When AddEvent() finds an event that
// satisfies the request parameter of a watch object in events.watchers,
// it will send that event out over the watch object‘s channel. The caller that
// called WatchEvents will receive the event over the channel provided to
// WatchEvents
type watch struct {
    // request parameters passed in by the caller of WatchEvents()
    request *Request
    // a channel used to send event back to the caller.
    eventChannel *EventChannel
}

// Request holds a set of parameters by which Event objects may be screened.
// The caller may want events that occurred within a specific timeframe
// or of a certain type, which may be specified in the *Request object
// they pass to an EventManager function
type Request struct {
    // events falling before StartTime do not satisfy the request. StartTime
    // must be left blank in calls to WatchEvents
    StartTime time.Time
    // events falling after EndTime do not satisfy the request. EndTime
    // must be left blank in calls to WatchEvents
    EndTime time.Time
    // EventType is a map that specifies the type(s) of events wanted
    EventType map[info.EventType]bool
    // allows the caller to put a limit on how many
    // events to receive. If there are more events than MaxEventsReturned
    // then the most chronologically recent events in the time period
    // specified are returned. Must be >= 1
    MaxEventsReturned int
    // the absolute container name for which the event occurred
    ContainerName string
    // if IncludeSubcontainers is false, only events occurring in the specific
    // container, and not the subcontainers, will be returned
    IncludeSubcontainers bool
}