338 lines
8.3 KiB
Go
338 lines
8.3 KiB
Go
// Copyright 2014 Google Inc. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// Per-container manager.
|
|
|
|
package manager
|
|
|
|
import (
|
|
"fmt"
|
|
"math/rand"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/cadvisor/container"
|
|
ctest "github.com/google/cadvisor/container/test"
|
|
"github.com/google/cadvisor/info"
|
|
itest "github.com/google/cadvisor/info/test"
|
|
stest "github.com/google/cadvisor/storage/test"
|
|
)
|
|
|
|
func createManagerAndAddContainers(
|
|
driver *stest.MockStorageDriver,
|
|
containers []string,
|
|
f func(*ctest.MockContainerHandler),
|
|
t *testing.T,
|
|
) *manager {
|
|
if driver == nil {
|
|
driver = &stest.MockStorageDriver{}
|
|
}
|
|
factory := &ctest.FactoryForMockContainerHandler{
|
|
Name: "factoryForManager",
|
|
PrepareContainerHandlerFunc: func(name string, handler *ctest.MockContainerHandler) {
|
|
handler.Name = name
|
|
found := false
|
|
for _, c := range containers {
|
|
if c == name {
|
|
found = true
|
|
}
|
|
}
|
|
if !found {
|
|
t.Errorf("Asked to create a container with name %v, which is unknown.", name)
|
|
}
|
|
f(handler)
|
|
},
|
|
}
|
|
container.RegisterContainerHandlerFactory("/", factory)
|
|
mif, err := New(driver)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ret, ok := mif.(*manager); ok {
|
|
for _, container := range containers {
|
|
ret.containers[container], err = NewContainerData(container, driver)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
return ret
|
|
}
|
|
t.Fatal("Wrong type")
|
|
return nil
|
|
}
|
|
|
|
func randomStatsAndSamples(numStats, numSamples int) ([]*info.ContainerStats, []*info.ContainerStatsSample, error) {
|
|
stats := itest.GenerateRandomStats(numStats, 4, 1*time.Second)
|
|
samples := make([]*info.ContainerStatsSample, 0, numSamples)
|
|
for i, s := range stats[1:] {
|
|
prev := stats[i]
|
|
sample, err := info.NewSample(prev, s)
|
|
if err != nil {
|
|
return nil, nil, fmt.Errorf("Unable to generate sample from %+v and %+v: %v",
|
|
prev, s, err)
|
|
}
|
|
samples = append(samples, sample)
|
|
if len(samples) == numSamples {
|
|
break
|
|
}
|
|
}
|
|
return stats, samples, nil
|
|
}
|
|
|
|
func TestGetContainerInfo(t *testing.T) {
|
|
containers := []string{
|
|
"/c1",
|
|
"/c2",
|
|
}
|
|
|
|
query := &info.ContainerInfoQuery{
|
|
NumStats: 256,
|
|
NumSamples: 128,
|
|
CpuUsagePercentages: []int{10, 50, 90},
|
|
MemoryUsagePercentages: []int{10, 80, 90},
|
|
}
|
|
|
|
infosMap := make(map[string]*info.ContainerInfo, len(containers))
|
|
handlerMap := make(map[string]*ctest.MockContainerHandler, len(containers))
|
|
|
|
for _, container := range containers {
|
|
stats, samples, err := randomStatsAndSamples(query.NumStats, query.NumSamples)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cpuPercentiles := make([]info.Percentile, 0, len(query.CpuUsagePercentages))
|
|
for _, p := range query.CpuUsagePercentages {
|
|
percentile := info.Percentile{p, uint64(rand.Int63n(1000))}
|
|
cpuPercentiles = append(cpuPercentiles, percentile)
|
|
}
|
|
memPercentiles := make([]info.Percentile, 0, len(query.MemoryUsagePercentages))
|
|
for _, p := range query.MemoryUsagePercentages {
|
|
percentile := info.Percentile{p, uint64(rand.Int63n(1000))}
|
|
memPercentiles = append(memPercentiles, percentile)
|
|
}
|
|
|
|
percentiles := &info.ContainerStatsPercentiles{
|
|
MaxMemoryUsage: uint64(rand.Int63n(4096)),
|
|
MemoryUsagePercentiles: memPercentiles,
|
|
CpuUsagePercentiles: cpuPercentiles,
|
|
}
|
|
|
|
spec := itest.GenerateRandomContainerSpec(4)
|
|
|
|
infosMap[container] = &info.ContainerInfo{
|
|
ContainerReference: info.ContainerReference{
|
|
Name: container,
|
|
},
|
|
Spec: spec,
|
|
StatsPercentiles: percentiles,
|
|
Samples: samples,
|
|
Stats: stats,
|
|
}
|
|
}
|
|
|
|
driver := &stest.MockStorageDriver{}
|
|
m := createManagerAndAddContainers(
|
|
driver,
|
|
containers,
|
|
func(h *ctest.MockContainerHandler) {
|
|
cinfo := infosMap[h.Name]
|
|
stats := cinfo.Stats
|
|
samples := cinfo.Samples
|
|
percentiles := cinfo.StatsPercentiles
|
|
spec := cinfo.Spec
|
|
driver.On(
|
|
"Percentiles",
|
|
h.Name,
|
|
query.CpuUsagePercentages,
|
|
query.MemoryUsagePercentages,
|
|
).Return(
|
|
percentiles,
|
|
nil,
|
|
)
|
|
|
|
driver.On(
|
|
"Samples",
|
|
h.Name,
|
|
query.NumSamples,
|
|
).Return(
|
|
samples,
|
|
nil,
|
|
)
|
|
|
|
driver.On(
|
|
"RecentStats",
|
|
h.Name,
|
|
query.NumStats,
|
|
).Return(
|
|
stats,
|
|
nil,
|
|
)
|
|
|
|
h.On("ListContainers", container.LIST_SELF).Return(
|
|
[]info.ContainerReference(nil),
|
|
nil,
|
|
)
|
|
h.On("GetSpec").Return(
|
|
spec,
|
|
nil,
|
|
)
|
|
handlerMap[h.Name] = h
|
|
},
|
|
t,
|
|
)
|
|
|
|
returnedInfos := make(map[string]*info.ContainerInfo, len(containers))
|
|
|
|
for _, container := range containers {
|
|
cinfo, err := m.GetContainerInfo(container, query)
|
|
if err != nil {
|
|
t.Fatalf("Unable to get info for container %v: %v", container, err)
|
|
}
|
|
returnedInfos[container] = cinfo
|
|
}
|
|
|
|
for container, handler := range handlerMap {
|
|
handler.AssertExpectations(t)
|
|
returned := returnedInfos[container]
|
|
expected := infosMap[container]
|
|
if !reflect.DeepEqual(returned, expected) {
|
|
t.Errorf("returned unexpected info for container %v; returned %+v; expected %+v", container, returned, expected)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func TestGetContainerInfoWithDefaultValue(t *testing.T) {
|
|
containers := []string{
|
|
"/c1",
|
|
"/c2",
|
|
}
|
|
|
|
var query *info.ContainerInfoQuery
|
|
query = query.FillWithDefaultValues()
|
|
|
|
infosMap := make(map[string]*info.ContainerInfo, len(containers))
|
|
handlerMap := make(map[string]*ctest.MockContainerHandler, len(containers))
|
|
|
|
for _, container := range containers {
|
|
stats, samples, err := randomStatsAndSamples(query.NumStats, query.NumSamples)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cpuPercentiles := make([]info.Percentile, 0, len(query.CpuUsagePercentages))
|
|
for _, p := range query.CpuUsagePercentages {
|
|
percentile := info.Percentile{p, uint64(rand.Int63n(1000))}
|
|
cpuPercentiles = append(cpuPercentiles, percentile)
|
|
}
|
|
memPercentiles := make([]info.Percentile, 0, len(query.MemoryUsagePercentages))
|
|
for _, p := range query.MemoryUsagePercentages {
|
|
percentile := info.Percentile{p, uint64(rand.Int63n(1000))}
|
|
memPercentiles = append(memPercentiles, percentile)
|
|
}
|
|
|
|
percentiles := &info.ContainerStatsPercentiles{
|
|
MaxMemoryUsage: uint64(rand.Int63n(4096)),
|
|
MemoryUsagePercentiles: memPercentiles,
|
|
CpuUsagePercentiles: cpuPercentiles,
|
|
}
|
|
|
|
spec := itest.GenerateRandomContainerSpec(4)
|
|
|
|
infosMap[container] = &info.ContainerInfo{
|
|
ContainerReference: info.ContainerReference{
|
|
Name: container,
|
|
},
|
|
Spec: spec,
|
|
StatsPercentiles: percentiles,
|
|
Samples: samples,
|
|
Stats: stats,
|
|
}
|
|
}
|
|
|
|
driver := &stest.MockStorageDriver{}
|
|
m := createManagerAndAddContainers(
|
|
driver,
|
|
containers,
|
|
func(h *ctest.MockContainerHandler) {
|
|
cinfo := infosMap[h.Name]
|
|
stats := cinfo.Stats
|
|
samples := cinfo.Samples
|
|
percentiles := cinfo.StatsPercentiles
|
|
spec := cinfo.Spec
|
|
driver.On(
|
|
"Percentiles",
|
|
h.Name,
|
|
query.CpuUsagePercentages,
|
|
query.MemoryUsagePercentages,
|
|
).Return(
|
|
percentiles,
|
|
nil,
|
|
)
|
|
|
|
driver.On(
|
|
"Samples",
|
|
h.Name,
|
|
query.NumSamples,
|
|
).Return(
|
|
samples,
|
|
nil,
|
|
)
|
|
|
|
driver.On(
|
|
"RecentStats",
|
|
h.Name,
|
|
query.NumStats,
|
|
).Return(
|
|
stats,
|
|
nil,
|
|
)
|
|
|
|
h.On("ListContainers", container.LIST_SELF).Return(
|
|
[]info.ContainerReference(nil),
|
|
nil,
|
|
)
|
|
h.On("GetSpec").Return(
|
|
spec,
|
|
nil,
|
|
)
|
|
handlerMap[h.Name] = h
|
|
},
|
|
t,
|
|
)
|
|
|
|
returnedInfos := make(map[string]*info.ContainerInfo, len(containers))
|
|
|
|
for _, container := range containers {
|
|
// nil should give us default values
|
|
cinfo, err := m.GetContainerInfo(container, nil)
|
|
if err != nil {
|
|
t.Fatalf("Unable to get info for container %v: %v", container, err)
|
|
}
|
|
returnedInfos[container] = cinfo
|
|
}
|
|
|
|
for container, handler := range handlerMap {
|
|
handler.AssertExpectations(t)
|
|
returned := returnedInfos[container]
|
|
expected := infosMap[container]
|
|
if !reflect.DeepEqual(returned, expected) {
|
|
t.Errorf("returned unexpected info for container %v; returned %+v; expected %+v", container, returned, expected)
|
|
}
|
|
}
|
|
|
|
}
|