func updateNodeResources() {
res.ComputeUsedResources()
log.WithFields(log.Fields{
"totalcpu": res.GetResources().CPU.Total,
"usedcpu": res.GetResources().CPU.Used,
"totalmem": res.GetResources().Memory.Total,
"usedmem": res.GetResources().Memory.Used,
}).Debugln("Updated node resources")
}
func computeSysMetrics(instMetrics map[string]data.MetricData) data.MetricData {
// TODO - improve by adding capacity
baseMetrics := make(map[string]float64)
cpuSys := 0.0
memSys := make([]float64, 0, len(instMetrics))
for instance, metrics := range instMetrics {
service, err := srv.GetServiceById(instance)
if err != nil {
log.WithFields(log.Fields{
"instance": instance,
}).Errorln("Cannot find service by instance")
} else {
instCpus := service.Docker.CPUnumber
instCpuValue := metrics.BaseMetrics[enum.METRIC_CPU_AVG.ToString()] * float64(instCpus)
// CPU
cpuSys += instCpuValue
// MEM
// TODO
}
}
baseMetrics[enum.METRIC_CPU_AVG.ToString()] = cpuSys / float64(res.GetResources().CPU.Total)
baseMetrics[enum.METRIC_MEM_AVG.ToString()] = utils.Mean(memSys)
sysMetrics := data.MetricData{
BaseMetrics: baseMetrics,
}
return sysMetrics
}
func initializeNode(nodeName string, clusterName string) {
if nodeName == "random_name" {
nodeName = utils.GetRandomName(0)
}
counter := -2
for nameExist(nodeName, clusterName) {
nodeName = utils.GetRandomName(counter)
counter++
}
log.Debugln("Node name: ", nodeName)
node.CreateNode(nodeName, res.GetResources())
}
// Since linux compute the cpu usage in units of jiffies, it needs to be converted
// in % using the formula used in this function.
// Explaination: http://stackoverflow.com/questions/1420426/calculating-cpu-usage-of-a-process-in-linux
// TODO probably I just need the first and the last value...
// 2015/11/16 - corrected according to what the docker client does:
// https://github.com/docker/docker/blob/master/api/client/stats.go#L316
func computeInstanceCpuPerc(instCpus []float64, sysCpus []float64) float64 {
sum := 0.0
instNext := 0.0
sysNext := 0.0
instPrev := 0.0
sysPrev := 0.0
cpu := 0.0
cpuTotal := res.GetResources().CPU.Total
valid := 0
nValues := int(math.Min(float64(len(instCpus)), float64(len(sysCpus))))
for i := 1; i < nValues; i++ {
instPrev = instCpus[i-1]
sysPrev = sysCpus[i-1]
instNext = instCpus[i]
sysNext = sysCpus[i]
instDelta := instNext - instPrev
if instDelta > 0 {
sysDelta := sysNext - sysPrev
if sysDelta == 0 {
cpu = 0
} else {
// "100 * cpu" should produce values in [0, 100]
cpu = (instDelta / sysDelta) * float64(cpuTotal)
}
sum += cpu
valid++
}
}
if valid > 0.0 {
return math.Min(1.0, sum/float64(valid))
}
return 0.0
}
func updateMetrics() {
var err error
metrics = newMetrics()
metrics.Node.UUID = cfg.GetNodeConfig().UUID
metrics.Node.Name = cfg.GetNodeConfig().Name
metrics.Node.Resources.CPU.Total = res.GetResources().CPU.Total
metrics.Node.Resources.CPU.Availabe = res.GetResources().CPU.Total - res.GetResources().CPU.Used
localShared, err := data.GetSharedLocal()
if err != nil {
log.WithField("err", err).Warnln("Cannot update node active metric")
} else {
metrics.Node.ActiveServices = len(localShared.System.ActiveServices)
}
for _, name := range service.List() {
srv, _ := service.GetServiceByName(name)
srv_metrics := metrics.Service[name]
srv_metrics.Name = name
srv_metrics.Image = srv.Image
srv_metrics.Type = srv.Type
srv_metrics.Instances.All = len(srv.Instances.All)
srv_metrics.Instances.Pending = len(srv.Instances.Pending)
srv_metrics.Instances.Running = len(srv.Instances.Running)
srv_metrics.Instances.Paused = len(srv.Instances.Paused)
srv_metrics.Instances.Stopped = len(srv.Instances.Stopped)
stats, err := data.GetStats()
if err != nil {
log.WithFields(log.Fields{
"err": err,
"service": name,
}).Warnln("Cannot update stats metrics")
} else {
if srv_stats, ok := stats.Metrics.Service[name]; ok {
srv_metrics.Stats = srv_stats
} else {
log.Warnln("Cannot find stats metrics for service ", name)
}
metrics.Node.Stats = stats.Metrics.System
}
analytics, err := data.GetAnalytics()
if err != nil {
log.WithFields(log.Fields{
"err": err,
"service": name,
}).Warnln("Cannot update analytics metrics")
} else {
if srv_analytisc, ok := analytics.Service[name]; ok {
srv_metrics.Analytics = srv_analytisc
} else {
log.Debugln("Cannot find analytics metrics for service ", name)
}
}
shared, err := data.GetSharedCluster()
if err != nil {
log.WithFields(log.Fields{
"err": err,
"service": name,
}).Warnln("Cannot update shared data metrics")
} else {
if srv_shared, ok := shared.Service[name]; ok {
srv_metrics.Shared = srv_shared.Data
}
}
metrics.Service[name] = srv_metrics
}
plc, err := data.GetPolicy()
if err != nil {
log.WithField("err", err).Warnln("Cannot update plans metrics")
} else {
metrics.Policy.Name = plc.Name
metrics.Policy.Weight = plc.Weight
}
}
