func initiailizeMonitoring() {
defer log.Infoln("Initializing autonomic monitoring")
ch_aut_err := chn.GetAutonomicErrChannel()
enableLogReading = cfg.GetAgentAutonomic().EnableLogReading
mtr.Initialize(srv.List())
// Start log reader if needed
if enableLogReading {
lgr.StartLogReader()
log.WithField("logreader", enableLogReading).Debugln("Log reading is enabled")
}
// Get the list of containers (running or not) to monitor
containers, err := container.Docker().Client.ListContainers(true, false, "")
if err != nil {
log.WithField("err", err).Debugln("Error monitoring containers")
ch_aut_err <- err
}
// Start the monitor for each configured service
for _, c := range containers {
info, _ := container.Docker().Client.InspectContainer(c.Id)
status := getContainerStatus(info)
service, err := srv.GetServiceByImage(c.Image)
if err != nil {
log.WithFields(log.Fields{
"err": err,
"image": c.Image,
}).Warningln("Error monitoring service")
} else {
e := evt.Event{
Service: service.Name,
Image: c.Image,
Instance: c.Id,
Status: status,
}
evt.HandleCreateEvent(e)
evt.HanldeStartEvent(e)
mtr.AddInstance(c.Id)
if _, ok := instBuffer[c.Id]; !ok {
instBuffer[c.Id] = instanceMetricBuffer{
cpuInst: utils.BuildBuffer(c_B_SIZE),
cpuSys: utils.BuildBuffer(c_B_SIZE),
}
}
container.Docker().Client.StartMonitorStats(c.Id, statCallBack, ch_mnt_stats_err)
if status == enum.PENDING && enableLogReading {
startMonitorLog(c.Id)
}
}
}
}
func RunLoop(loopTimeInterval int) {
// Start the metric collector
metric.StartMetricCollector()
// Set the ticker for the periodic execution
ticker := time.NewTicker(time.Duration(loopTimeInterval) * time.Second)
log.Infoln("Running autonomic loop")
for {
select {
case <-ticker.C:
stats := monitor.Run()
analytics := analyzer.Run(stats)
policy := planner.Run(analytics)
executor.Run(policy)
log.Infoln("-------------------------")
case <-ch_err:
log.Debugln("Error running autonomic loop")
}
}
}
func startMonitoring() {
log.Infoln("Running autonomic monitoring")
ch_aut_err := chn.GetAutonomicErrChannel()
container.Docker().Client.StartMonitorEvents(eventCallback, ch_mnt_events_err)
for {
select {
case err := <-ch_mnt_events_err:
log.WithField("err", err).Fatalln("Error monitoring containers events")
ch_aut_err <- err
case err := <-ch_mnt_stats_err:
log.WithField("err", err).Debugln("Error monitoring containers stats")
ch_aut_err <- err
case <-ch_stop:
return
}
}
}