func GenerateRandomStats(numStats, numCores int, duration time.Duration) []*info.ContainerStats { ret := make([]*info.ContainerStats, numStats) perCoreUsages := make([]uint64, numCores) currentTime := time.Now() for i := range perCoreUsages { perCoreUsages[i] = uint64(rand.Int63n(1000)) } for i := 0; i < numStats; i++ { stats := new(info.ContainerStats) stats.Timestamp = currentTime currentTime = currentTime.Add(duration) percore := make([]uint64, numCores) for i := range perCoreUsages { perCoreUsages[i] += uint64(rand.Int63n(1000)) percore[i] = perCoreUsages[i] stats.Cpu.Usage.Total += percore[i] } stats.Cpu.Usage.PerCpu = percore stats.Cpu.Usage.User = stats.Cpu.Usage.Total stats.Cpu.Usage.System = 0 stats.Memory.Usage = uint64(rand.Int63n(4096)) stats.Memory.Cache = uint64(rand.Int63n(4096)) stats.Memory.RSS = uint64(rand.Int63n(4096)) ret[i] = stats } return ret }
func buildTrace(cpu, mem []uint64, duration time.Duration) []*info.ContainerStats { if len(cpu) != len(mem) { panic("len(cpu) != len(mem)") } ret := make([]*info.ContainerStats, len(cpu)) currentTime := time.Now() var cpuTotalUsage uint64 = 0 for i, cpuUsage := range cpu { cpuTotalUsage += cpuUsage stats := new(info.ContainerStats) stats.Timestamp = currentTime currentTime = currentTime.Add(duration) stats.Cpu.Usage.Total = cpuTotalUsage stats.Cpu.Usage.User = stats.Cpu.Usage.Total stats.Cpu.Usage.System = 0 stats.Cpu.Usage.PerCpu = []uint64{cpuTotalUsage} stats.Memory.Usage = mem[i] stats.Network.RxBytes = uint64(rand.Intn(10000)) stats.Network.RxErrors = uint64(rand.Intn(1000)) stats.Network.TxBytes = uint64(rand.Intn(100000)) stats.Network.TxErrors = uint64(rand.Intn(1000)) stats.Filesystem = make([]info.FsStats, 1) stats.Filesystem[0].Device = "/dev/sda1" stats.Filesystem[0].Limit = 1024000000 stats.Filesystem[0].Usage = 1024000 ret[i] = stats } return ret }
// Convert libcontainer stats to info.ContainerStats. func toContainerStats(libcontainerStats *libcontainer.Stats) *info.ContainerStats { s := libcontainerStats.CgroupStats ret := new(info.ContainerStats) ret.Timestamp = time.Now() if s != nil { ret.Cpu.Usage.User = s.CpuStats.CpuUsage.UsageInUsermode ret.Cpu.Usage.System = s.CpuStats.CpuUsage.UsageInKernelmode n := len(s.CpuStats.CpuUsage.PercpuUsage) ret.Cpu.Usage.PerCpu = make([]uint64, n) ret.Cpu.Usage.Total = 0 for i := 0; i < n; i++ { ret.Cpu.Usage.PerCpu[i] = s.CpuStats.CpuUsage.PercpuUsage[i] ret.Cpu.Usage.Total += s.CpuStats.CpuUsage.PercpuUsage[i] } ret.DiskIo.IoServiceBytes = DiskStatsCopy(s.BlkioStats.IoServiceBytesRecursive) ret.DiskIo.IoServiced = DiskStatsCopy(s.BlkioStats.IoServicedRecursive) ret.DiskIo.IoQueued = DiskStatsCopy(s.BlkioStats.IoQueuedRecursive) ret.DiskIo.Sectors = DiskStatsCopy(s.BlkioStats.SectorsRecursive) ret.DiskIo.IoServiceTime = DiskStatsCopy(s.BlkioStats.IoServiceTimeRecursive) ret.DiskIo.IoWaitTime = DiskStatsCopy(s.BlkioStats.IoWaitTimeRecursive) ret.DiskIo.IoMerged = DiskStatsCopy(s.BlkioStats.IoMergedRecursive) ret.DiskIo.IoTime = DiskStatsCopy(s.BlkioStats.IoTimeRecursive) ret.Memory.Usage = s.MemoryStats.Usage if v, ok := s.MemoryStats.Stats["pgfault"]; ok { ret.Memory.ContainerData.Pgfault = v ret.Memory.HierarchicalData.Pgfault = v } if v, ok := s.MemoryStats.Stats["pgmajfault"]; ok { ret.Memory.ContainerData.Pgmajfault = v ret.Memory.HierarchicalData.Pgmajfault = v } if v, ok := s.MemoryStats.Stats["total_inactive_anon"]; ok { ret.Memory.WorkingSet = ret.Memory.Usage - v if v, ok := s.MemoryStats.Stats["total_active_file"]; ok { ret.Memory.WorkingSet -= v } } } if len(libcontainerStats.Interfaces) > 0 { // TODO(vmarmol): Handle multiple interfaces. ret.Network.RxBytes = libcontainerStats.Interfaces[0].RxBytes ret.Network.RxPackets = libcontainerStats.Interfaces[0].RxPackets ret.Network.RxErrors = libcontainerStats.Interfaces[0].RxErrors ret.Network.RxDropped = libcontainerStats.Interfaces[0].RxDropped ret.Network.TxBytes = libcontainerStats.Interfaces[0].TxBytes ret.Network.TxPackets = libcontainerStats.Interfaces[0].TxPackets ret.Network.TxErrors = libcontainerStats.Interfaces[0].TxErrors ret.Network.TxDropped = libcontainerStats.Interfaces[0].TxDropped } return ret }
// Convert libcontainer stats to info.ContainerStats. func toContainerStats(libcontainerStats *libcontainer.ContainerStats) *info.ContainerStats { s := libcontainerStats.CgroupStats ret := new(info.ContainerStats) ret.Timestamp = time.Now() if s != nil { ret.Cpu.Usage.User = s.CpuStats.CpuUsage.UsageInUsermode ret.Cpu.Usage.System = s.CpuStats.CpuUsage.UsageInKernelmode n := len(s.CpuStats.CpuUsage.PercpuUsage) ret.Cpu.Usage.PerCpu = make([]uint64, n) ret.Cpu.Usage.Total = 0 for i := 0; i < n; i++ { ret.Cpu.Usage.PerCpu[i] = s.CpuStats.CpuUsage.PercpuUsage[i] ret.Cpu.Usage.Total += s.CpuStats.CpuUsage.PercpuUsage[i] } ret.DiskIo.IoServiceBytes = DiskStatsCopy(s.BlkioStats.IoServiceBytesRecursive) ret.DiskIo.IoServiced = DiskStatsCopy(s.BlkioStats.IoServicedRecursive) ret.DiskIo.IoQueued = DiskStatsCopy(s.BlkioStats.IoQueuedRecursive) ret.DiskIo.Sectors = DiskStatsCopy(s.BlkioStats.SectorsRecursive) ret.DiskIo.IoServiceTime = DiskStatsCopy(s.BlkioStats.IoServiceTimeRecursive) ret.DiskIo.IoWaitTime = DiskStatsCopy(s.BlkioStats.IoWaitTimeRecursive) ret.DiskIo.IoMerged = DiskStatsCopy(s.BlkioStats.IoMergedRecursive) ret.DiskIo.IoTime = DiskStatsCopy(s.BlkioStats.IoTimeRecursive) ret.Memory.Usage = s.MemoryStats.Usage if v, ok := s.MemoryStats.Stats["pgfault"]; ok { ret.Memory.ContainerData.Pgfault = v ret.Memory.HierarchicalData.Pgfault = v } if v, ok := s.MemoryStats.Stats["pgmajfault"]; ok { ret.Memory.ContainerData.Pgmajfault = v ret.Memory.HierarchicalData.Pgmajfault = v } if v, ok := s.MemoryStats.Stats["total_inactive_anon"]; ok { ret.Memory.WorkingSet = ret.Memory.Usage - v if v, ok := s.MemoryStats.Stats["total_active_file"]; ok { ret.Memory.WorkingSet -= v } } } // TODO(vishh): Perform a deep copy or alias libcontainer network stats. if libcontainerStats.NetworkStats != nil { ret.Network = *(*info.NetworkStats)(libcontainerStats.NetworkStats) } return ret }
func toContainerStats(libcontainerStats *libcontainer.Stats) *info.ContainerStats { s := libcontainerStats.CgroupStats ret := new(info.ContainerStats) ret.Timestamp = time.Now() if s != nil { toContainerStats0(s, ret) toContainerStats1(s, ret) toContainerStats2(s, ret) } if len(libcontainerStats.Interfaces) > 0 { toContainerStats3(libcontainerStats, ret) } return ret }
// emptyCMEFactory generates an empty ContainerMetricElement. func emptyCMEFactory() *cache.ContainerMetricElement { f := fuzz.New().NilChance(0).NumElements(1, 1) containerSpec := cadvisor.ContainerSpec{ CreationTime: time.Now(), HasCpu: false, HasMemory: false, HasNetwork: false, HasFilesystem: false, HasDiskIo: false, } var containerStats cadvisor.ContainerStats f.Fuzz(&containerStats) containerStats.Timestamp = time.Now() return &cache.ContainerMetricElement{ Spec: &containerSpec, Stats: &containerStats, } }
// cmeFactory generates a complete ContainerMetricElement with fuzzed data. // CMEs created by cmeFactory contain partially fuzzed stats, aside from hardcoded values for Memory usage. // The timestamp of the CME is rouded to the current minute and offset by a random number of hours. func cmeFactory() *cache.ContainerMetricElement { f := fuzz.New().NilChance(0).NumElements(1, 1) containerSpec := cadvisor.ContainerSpec{ CreationTime: time.Now(), HasCpu: true, HasMemory: true, HasNetwork: true, HasFilesystem: true, HasDiskIo: true, } containerSpec.Cpu.Limit = 1024 containerSpec.Memory.Limit = 10000000 // Create a fuzzed ContainerStats struct var containerStats cadvisor.ContainerStats f.Fuzz(&containerStats) // Standardize timestamp to the current minute plus a random number of hours ([1, 10]) now_time := time.Now().Round(time.Minute) new_time := now_time for new_time == now_time { new_time = now_time.Add(time.Duration(rand.Intn(10)) * 5 * time.Minute) } containerStats.Timestamp = new_time containerSpec.CreationTime = new_time.Add(-time.Hour) // Standardize memory usage and limit to test aggregation containerStats.Memory.Usage = uint64(5000) containerStats.Memory.WorkingSet = uint64(602) // Standardize the device name, usage and limit new_fs := cadvisor.FsStats{} f.Fuzz(&new_fs) new_fs.Device = "/dev/device1" new_fs.Usage = 50000 new_fs.Limit = 100000 containerStats.Filesystem = []cadvisor.FsStats{new_fs} return &cache.ContainerMetricElement{ Spec: &containerSpec, Stats: &containerStats, } }
// cmeFactory generates a complete ContainerMetricElement with fuzzed data. func cmeFactory() *cache.ContainerMetricElement { f := fuzz.New().NilChance(0).NumElements(1, 1) containerSpec := cadvisor.ContainerSpec{ CreationTime: time.Now(), HasCpu: true, HasMemory: true, HasNetwork: true, HasFilesystem: true, HasDiskIo: true, } var containerStats cadvisor.ContainerStats f.Fuzz(&containerStats) containerStats.Timestamp = time.Now() new_fs := cadvisor.FsStats{} f.Fuzz(&new_fs) new_fs.Device = "/dev/device1" containerStats.Filesystem = []cadvisor.FsStats{new_fs} return &cache.ContainerMetricElement{ Spec: &containerSpec, Stats: &containerStats, } }