mirror of https://github.com/prometheus/prometheus
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1480 lines
38 KiB
1480 lines
38 KiB
// Copyright 2016 The Prometheus Authors
|
|
// 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.
|
|
|
|
package discovery
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sort"
|
|
"strconv"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/go-kit/log"
|
|
client_testutil "github.com/prometheus/client_golang/prometheus/testutil"
|
|
"github.com/prometheus/common/model"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/prometheus/prometheus/discovery/targetgroup"
|
|
"github.com/prometheus/prometheus/util/testutil"
|
|
)
|
|
|
|
func TestMain(m *testing.M) {
|
|
testutil.TolerantVerifyLeak(m)
|
|
}
|
|
|
|
// TestTargetUpdatesOrder checks that the target updates are received in the expected order.
|
|
func TestTargetUpdatesOrder(t *testing.T) {
|
|
// The order by which the updates are send is determined by the interval passed to the mock discovery adapter
|
|
// Final targets array is ordered alphabetically by the name of the discoverer.
|
|
// For example discoverer "A" with targets "t2,t3" and discoverer "B" with targets "t1,t2" will result in "t2,t3,t1,t2" after the merge.
|
|
testCases := []struct {
|
|
title string
|
|
updates map[string][]update
|
|
expectedTargets [][]*targetgroup.Group
|
|
}{
|
|
{
|
|
title: "Single TP no updates",
|
|
updates: map[string][]update{
|
|
"tp1": {},
|
|
},
|
|
expectedTargets: nil,
|
|
},
|
|
{
|
|
title: "Multiple TPs no updates",
|
|
updates: map[string][]update{
|
|
"tp1": {},
|
|
"tp2": {},
|
|
"tp3": {},
|
|
},
|
|
expectedTargets: nil,
|
|
},
|
|
{
|
|
title: "Single TP empty initials",
|
|
updates: map[string][]update{
|
|
"tp1": {
|
|
{
|
|
targetGroups: []targetgroup.Group{},
|
|
interval: 5 * time.Millisecond,
|
|
},
|
|
},
|
|
},
|
|
expectedTargets: [][]*targetgroup.Group{
|
|
{},
|
|
},
|
|
},
|
|
{
|
|
title: "Multiple TPs empty initials",
|
|
updates: map[string][]update{
|
|
"tp1": {
|
|
{
|
|
targetGroups: []targetgroup.Group{},
|
|
interval: 5 * time.Millisecond,
|
|
},
|
|
},
|
|
"tp2": {
|
|
{
|
|
targetGroups: []targetgroup.Group{},
|
|
interval: 200 * time.Millisecond,
|
|
},
|
|
},
|
|
"tp3": {
|
|
{
|
|
targetGroups: []targetgroup.Group{},
|
|
interval: 100 * time.Millisecond,
|
|
},
|
|
},
|
|
},
|
|
expectedTargets: [][]*targetgroup.Group{
|
|
{},
|
|
{},
|
|
{},
|
|
},
|
|
},
|
|
{
|
|
title: "Single TP initials only",
|
|
updates: map[string][]update{
|
|
"tp1": {
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedTargets: [][]*targetgroup.Group{
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
title: "Multiple TPs initials only",
|
|
updates: map[string][]update{
|
|
"tp1": {
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"tp2": {
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp2_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "3"}},
|
|
},
|
|
},
|
|
interval: 10 * time.Millisecond,
|
|
},
|
|
},
|
|
},
|
|
expectedTargets: [][]*targetgroup.Group{
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
}, {
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
{
|
|
Source: "tp2_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "3"}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
title: "Single TP initials followed by empty updates",
|
|
updates: map[string][]update{
|
|
"tp1": {
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
interval: 0,
|
|
},
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{},
|
|
},
|
|
},
|
|
interval: 10 * time.Millisecond,
|
|
},
|
|
},
|
|
},
|
|
expectedTargets: [][]*targetgroup.Group{
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
title: "Single TP initials and new groups",
|
|
updates: map[string][]update{
|
|
"tp1": {
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
interval: 0,
|
|
},
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "3"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "4"}},
|
|
},
|
|
{
|
|
Source: "tp1_group3",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
},
|
|
interval: 10 * time.Millisecond,
|
|
},
|
|
},
|
|
},
|
|
expectedTargets: [][]*targetgroup.Group{
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "3"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "4"}},
|
|
},
|
|
{
|
|
Source: "tp1_group3",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
title: "Multiple TPs initials and new groups",
|
|
updates: map[string][]update{
|
|
"tp1": {
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
interval: 10 * time.Millisecond,
|
|
},
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group3",
|
|
Targets: []model.LabelSet{{"__instance__": "3"}},
|
|
},
|
|
{
|
|
Source: "tp1_group4",
|
|
Targets: []model.LabelSet{{"__instance__": "4"}},
|
|
},
|
|
},
|
|
interval: 500 * time.Millisecond,
|
|
},
|
|
},
|
|
"tp2": {
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp2_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "5"}},
|
|
},
|
|
{
|
|
Source: "tp2_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "6"}},
|
|
},
|
|
},
|
|
interval: 100 * time.Millisecond,
|
|
},
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp2_group3",
|
|
Targets: []model.LabelSet{{"__instance__": "7"}},
|
|
},
|
|
{
|
|
Source: "tp2_group4",
|
|
Targets: []model.LabelSet{{"__instance__": "8"}},
|
|
},
|
|
},
|
|
interval: 10 * time.Millisecond,
|
|
},
|
|
},
|
|
},
|
|
expectedTargets: [][]*targetgroup.Group{
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
{
|
|
Source: "tp2_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "5"}},
|
|
},
|
|
{
|
|
Source: "tp2_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "6"}},
|
|
},
|
|
},
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
{
|
|
Source: "tp2_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "5"}},
|
|
},
|
|
{
|
|
Source: "tp2_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "6"}},
|
|
},
|
|
{
|
|
Source: "tp2_group3",
|
|
Targets: []model.LabelSet{{"__instance__": "7"}},
|
|
},
|
|
{
|
|
Source: "tp2_group4",
|
|
Targets: []model.LabelSet{{"__instance__": "8"}},
|
|
},
|
|
},
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
{
|
|
Source: "tp1_group3",
|
|
Targets: []model.LabelSet{{"__instance__": "3"}},
|
|
},
|
|
{
|
|
Source: "tp1_group4",
|
|
Targets: []model.LabelSet{{"__instance__": "4"}},
|
|
},
|
|
{
|
|
Source: "tp2_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "5"}},
|
|
},
|
|
{
|
|
Source: "tp2_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "6"}},
|
|
},
|
|
{
|
|
Source: "tp2_group3",
|
|
Targets: []model.LabelSet{{"__instance__": "7"}},
|
|
},
|
|
{
|
|
Source: "tp2_group4",
|
|
Targets: []model.LabelSet{{"__instance__": "8"}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
title: "One TP initials arrive after other TP updates.",
|
|
updates: map[string][]update{
|
|
"tp1": {
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
interval: 10 * time.Millisecond,
|
|
},
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "3"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "4"}},
|
|
},
|
|
},
|
|
interval: 150 * time.Millisecond,
|
|
},
|
|
},
|
|
"tp2": {
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp2_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "5"}},
|
|
},
|
|
{
|
|
Source: "tp2_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "6"}},
|
|
},
|
|
},
|
|
interval: 200 * time.Millisecond,
|
|
},
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp2_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "7"}},
|
|
},
|
|
{
|
|
Source: "tp2_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "8"}},
|
|
},
|
|
},
|
|
interval: 100 * time.Millisecond,
|
|
},
|
|
},
|
|
},
|
|
expectedTargets: [][]*targetgroup.Group{
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "3"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "4"}},
|
|
},
|
|
},
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "3"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "4"}},
|
|
},
|
|
{
|
|
Source: "tp2_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "5"}},
|
|
},
|
|
{
|
|
Source: "tp2_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "6"}},
|
|
},
|
|
},
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "3"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "4"}},
|
|
},
|
|
{
|
|
Source: "tp2_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "7"}},
|
|
},
|
|
{
|
|
Source: "tp2_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "8"}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
title: "Single TP empty update in between",
|
|
updates: map[string][]update{
|
|
"tp1": {
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
interval: 30 * time.Millisecond,
|
|
},
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{},
|
|
},
|
|
},
|
|
interval: 10 * time.Millisecond,
|
|
},
|
|
{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "3"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "4"}},
|
|
},
|
|
},
|
|
interval: 300 * time.Millisecond,
|
|
},
|
|
},
|
|
},
|
|
expectedTargets: [][]*targetgroup.Group{
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{},
|
|
},
|
|
},
|
|
{
|
|
{
|
|
Source: "tp1_group1",
|
|
Targets: []model.LabelSet{{"__instance__": "3"}},
|
|
},
|
|
{
|
|
Source: "tp1_group2",
|
|
Targets: []model.LabelSet{{"__instance__": "4"}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, tc := range testCases {
|
|
tc := tc
|
|
t.Run(tc.title, func(t *testing.T) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
|
|
discoveryManager := NewManager(ctx, log.NewNopLogger())
|
|
discoveryManager.updatert = 100 * time.Millisecond
|
|
|
|
var totalUpdatesCount int
|
|
for _, up := range tc.updates {
|
|
if len(up) > 0 {
|
|
totalUpdatesCount += len(up)
|
|
}
|
|
}
|
|
provUpdates := make(chan []*targetgroup.Group, totalUpdatesCount)
|
|
|
|
for _, up := range tc.updates {
|
|
go newMockDiscoveryProvider(up...).Run(ctx, provUpdates)
|
|
}
|
|
|
|
for x := 0; x < totalUpdatesCount; x++ {
|
|
select {
|
|
case <-ctx.Done():
|
|
t.Fatalf("%d: no update arrived within the timeout limit", x)
|
|
case tgs := <-provUpdates:
|
|
discoveryManager.updateGroup(poolKey{setName: strconv.Itoa(i), provider: tc.title}, tgs)
|
|
for _, got := range discoveryManager.allGroups() {
|
|
assertEqualGroups(t, got, tc.expectedTargets[x])
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func assertEqualGroups(t *testing.T, got, expected []*targetgroup.Group) {
|
|
t.Helper()
|
|
|
|
// Need to sort by the groups's source as the received order is not guaranteed.
|
|
sort.Sort(byGroupSource(got))
|
|
sort.Sort(byGroupSource(expected))
|
|
|
|
require.Equal(t, expected, got)
|
|
}
|
|
|
|
func staticConfig(addrs ...string) StaticConfig {
|
|
var cfg StaticConfig
|
|
for i, addr := range addrs {
|
|
cfg = append(cfg, &targetgroup.Group{
|
|
Source: fmt.Sprint(i),
|
|
Targets: []model.LabelSet{
|
|
{model.AddressLabel: model.LabelValue(addr)},
|
|
},
|
|
})
|
|
}
|
|
return cfg
|
|
}
|
|
|
|
func verifySyncedPresence(t *testing.T, tGroups map[string][]*targetgroup.Group, key, label string, present bool) {
|
|
t.Helper()
|
|
if _, ok := tGroups[key]; !ok {
|
|
t.Fatalf("'%s' should be present in Group map keys: %v", key, tGroups)
|
|
return
|
|
}
|
|
match := false
|
|
var mergedTargets string
|
|
for _, targetGroups := range tGroups[key] {
|
|
for _, l := range targetGroups.Targets {
|
|
mergedTargets = mergedTargets + " " + l.String()
|
|
if l.String() == label {
|
|
match = true
|
|
}
|
|
}
|
|
}
|
|
if match != present {
|
|
msg := ""
|
|
if !present {
|
|
msg = "not"
|
|
}
|
|
t.Fatalf("%q should %s be present in Group labels: %q", label, msg, mergedTargets)
|
|
}
|
|
}
|
|
|
|
func verifyPresence(t *testing.T, tSets map[poolKey]map[string]*targetgroup.Group, poolKey poolKey, label string, present bool) {
|
|
t.Helper()
|
|
if _, ok := tSets[poolKey]; !ok {
|
|
t.Fatalf("'%s' should be present in Pool keys: %v", poolKey, tSets)
|
|
return
|
|
}
|
|
|
|
match := false
|
|
var mergedTargets string
|
|
for _, targetGroup := range tSets[poolKey] {
|
|
for _, l := range targetGroup.Targets {
|
|
mergedTargets = mergedTargets + " " + l.String()
|
|
if l.String() == label {
|
|
match = true
|
|
}
|
|
}
|
|
}
|
|
if match != present {
|
|
msg := ""
|
|
if !present {
|
|
msg = "not"
|
|
}
|
|
t.Fatalf("%q should %s be present in Targets labels: %q", label, msg, mergedTargets)
|
|
}
|
|
}
|
|
|
|
func pk(provider, setName string, n int) poolKey {
|
|
return poolKey{
|
|
setName: setName,
|
|
provider: fmt.Sprintf("%s/%d", provider, n),
|
|
}
|
|
}
|
|
|
|
func TestTargetSetTargetGroupsPresentOnConfigReload(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
discoveryManager := NewManager(ctx, log.NewNopLogger())
|
|
discoveryManager.updatert = 100 * time.Millisecond
|
|
go discoveryManager.Run()
|
|
|
|
c := map[string]Configs{
|
|
"prometheus": {
|
|
staticConfig("foo:9090"),
|
|
},
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
|
|
syncedTargets := <-discoveryManager.SyncCh()
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus"]))
|
|
p := pk("static", "prometheus", 0)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(discoveryManager.targets))
|
|
|
|
discoveryManager.ApplyConfig(c)
|
|
|
|
syncedTargets = <-discoveryManager.SyncCh()
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(discoveryManager.targets))
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus"]))
|
|
}
|
|
|
|
func TestTargetSetTargetGroupsPresentOnConfigRename(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
discoveryManager := NewManager(ctx, log.NewNopLogger())
|
|
discoveryManager.updatert = 100 * time.Millisecond
|
|
go discoveryManager.Run()
|
|
|
|
c := map[string]Configs{
|
|
"prometheus": {
|
|
staticConfig("foo:9090"),
|
|
},
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
|
|
syncedTargets := <-discoveryManager.SyncCh()
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus"]))
|
|
p := pk("static", "prometheus", 0)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(discoveryManager.targets))
|
|
|
|
c["prometheus2"] = c["prometheus"]
|
|
delete(c, "prometheus")
|
|
discoveryManager.ApplyConfig(c)
|
|
|
|
syncedTargets = <-discoveryManager.SyncCh()
|
|
p = pk("static", "prometheus2", 0)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(discoveryManager.targets))
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus2", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus2"]))
|
|
}
|
|
|
|
func TestTargetSetTargetGroupsPresentOnConfigDuplicateAndDeleteOriginal(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
discoveryManager := NewManager(ctx, log.NewNopLogger())
|
|
discoveryManager.updatert = 100 * time.Millisecond
|
|
go discoveryManager.Run()
|
|
|
|
c := map[string]Configs{
|
|
"prometheus": {
|
|
staticConfig("foo:9090"),
|
|
},
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
<-discoveryManager.SyncCh()
|
|
|
|
c["prometheus2"] = c["prometheus"]
|
|
discoveryManager.ApplyConfig(c)
|
|
syncedTargets := <-discoveryManager.SyncCh()
|
|
require.Equal(t, 2, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus"]))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus2", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus2"]))
|
|
p := pk("static", "prometheus", 0)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 2, len(discoveryManager.targets))
|
|
|
|
delete(c, "prometheus")
|
|
discoveryManager.ApplyConfig(c)
|
|
syncedTargets = <-discoveryManager.SyncCh()
|
|
p = pk("static", "prometheus2", 0)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(discoveryManager.targets))
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus2", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus2"]))
|
|
}
|
|
|
|
func TestTargetSetTargetGroupsPresentOnConfigChange(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
discoveryManager := NewManager(ctx, log.NewNopLogger())
|
|
discoveryManager.updatert = 100 * time.Millisecond
|
|
go discoveryManager.Run()
|
|
|
|
c := map[string]Configs{
|
|
"prometheus": {
|
|
staticConfig("foo:9090"),
|
|
},
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
|
|
syncedTargets := <-discoveryManager.SyncCh()
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus"]))
|
|
|
|
var mu sync.Mutex
|
|
c["prometheus2"] = Configs{
|
|
lockStaticConfig{
|
|
mu: &mu,
|
|
config: staticConfig("bar:9090"),
|
|
},
|
|
}
|
|
mu.Lock()
|
|
discoveryManager.ApplyConfig(c)
|
|
|
|
// Original targets should be present as soon as possible.
|
|
syncedTargets = <-discoveryManager.SyncCh()
|
|
mu.Unlock()
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus"]))
|
|
|
|
// prometheus2 configs should be ready on second sync.
|
|
syncedTargets = <-discoveryManager.SyncCh()
|
|
require.Equal(t, 2, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus"]))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus2", "{__address__=\"bar:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus2"]))
|
|
|
|
p := pk("static", "prometheus", 0)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"foo:9090\"}", true)
|
|
p = pk("lockstatic", "prometheus2", 1)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"bar:9090\"}", true)
|
|
require.Equal(t, 2, len(discoveryManager.targets))
|
|
|
|
// Delete part of config and ensure only original targets exist.
|
|
delete(c, "prometheus2")
|
|
discoveryManager.ApplyConfig(c)
|
|
syncedTargets = <-discoveryManager.SyncCh()
|
|
require.Equal(t, 1, len(discoveryManager.targets))
|
|
verifyPresence(t, discoveryManager.targets, pk("static", "prometheus", 0), "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus"]))
|
|
}
|
|
|
|
func TestTargetSetRecreatesTargetGroupsOnConfigChange(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
discoveryManager := NewManager(ctx, log.NewNopLogger())
|
|
discoveryManager.updatert = 100 * time.Millisecond
|
|
go discoveryManager.Run()
|
|
|
|
c := map[string]Configs{
|
|
"prometheus": {
|
|
staticConfig("foo:9090", "bar:9090"),
|
|
},
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
|
|
syncedTargets := <-discoveryManager.SyncCh()
|
|
p := pk("static", "prometheus", 0)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"foo:9090\"}", true)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"bar:9090\"}", true)
|
|
require.Equal(t, 1, len(discoveryManager.targets))
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"bar:9090\"}", true)
|
|
require.Equal(t, 2, len(syncedTargets["prometheus"]))
|
|
|
|
c["prometheus"] = Configs{
|
|
staticConfig("foo:9090"),
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
syncedTargets = <-discoveryManager.SyncCh()
|
|
require.Equal(t, 1, len(discoveryManager.targets))
|
|
p = pk("static", "prometheus", 1)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"foo:9090\"}", true)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"bar:9090\"}", false)
|
|
require.Equal(t, 1, len(discoveryManager.targets))
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus"]))
|
|
}
|
|
|
|
func TestDiscovererConfigs(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
discoveryManager := NewManager(ctx, log.NewNopLogger())
|
|
discoveryManager.updatert = 100 * time.Millisecond
|
|
go discoveryManager.Run()
|
|
|
|
c := map[string]Configs{
|
|
"prometheus": {
|
|
staticConfig("foo:9090", "bar:9090"),
|
|
staticConfig("baz:9090"),
|
|
},
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
|
|
syncedTargets := <-discoveryManager.SyncCh()
|
|
p := pk("static", "prometheus", 0)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"foo:9090\"}", true)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"bar:9090\"}", true)
|
|
p = pk("static", "prometheus", 1)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"baz:9090\"}", true)
|
|
require.Equal(t, 2, len(discoveryManager.targets))
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"bar:9090\"}", true)
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"baz:9090\"}", true)
|
|
require.Equal(t, 3, len(syncedTargets["prometheus"]))
|
|
}
|
|
|
|
// TestTargetSetRecreatesEmptyStaticConfigs ensures that reloading a config file after
|
|
// removing all targets from the static_configs sends an update with empty targetGroups.
|
|
// This is required to signal the receiver that this target set has no current targets.
|
|
func TestTargetSetRecreatesEmptyStaticConfigs(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
discoveryManager := NewManager(ctx, log.NewNopLogger())
|
|
discoveryManager.updatert = 100 * time.Millisecond
|
|
go discoveryManager.Run()
|
|
|
|
c := map[string]Configs{
|
|
"prometheus": {
|
|
staticConfig("foo:9090"),
|
|
},
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
|
|
syncedTargets := <-discoveryManager.SyncCh()
|
|
p := pk("static", "prometheus", 0)
|
|
verifyPresence(t, discoveryManager.targets, p, "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus"]))
|
|
|
|
c["prometheus"] = Configs{
|
|
StaticConfig{{}},
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
|
|
syncedTargets = <-discoveryManager.SyncCh()
|
|
p = pk("static", "prometheus", 1)
|
|
targetGroups, ok := discoveryManager.targets[p]
|
|
if !ok {
|
|
t.Fatalf("'%v' should be present in target groups", p)
|
|
}
|
|
group, ok := targetGroups[""]
|
|
if !ok {
|
|
t.Fatalf("missing '' key in target groups %v", targetGroups)
|
|
}
|
|
|
|
if len(group.Targets) != 0 {
|
|
t.Fatalf("Invalid number of targets: expected 0, got %d", len(group.Targets))
|
|
}
|
|
require.Equal(t, 1, len(syncedTargets))
|
|
require.Equal(t, 1, len(syncedTargets["prometheus"]))
|
|
if lbls := syncedTargets["prometheus"][0].Labels; lbls != nil {
|
|
t.Fatalf("Unexpected Group: expected nil Labels, got %v", lbls)
|
|
}
|
|
}
|
|
|
|
func TestIdenticalConfigurationsAreCoalesced(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
discoveryManager := NewManager(ctx, nil)
|
|
discoveryManager.updatert = 100 * time.Millisecond
|
|
go discoveryManager.Run()
|
|
|
|
c := map[string]Configs{
|
|
"prometheus": {
|
|
staticConfig("foo:9090"),
|
|
},
|
|
"prometheus2": {
|
|
staticConfig("foo:9090"),
|
|
},
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
|
|
syncedTargets := <-discoveryManager.SyncCh()
|
|
verifyPresence(t, discoveryManager.targets, pk("static", "prometheus", 0), "{__address__=\"foo:9090\"}", true)
|
|
verifyPresence(t, discoveryManager.targets, pk("static", "prometheus2", 0), "{__address__=\"foo:9090\"}", true)
|
|
if len(discoveryManager.providers) != 1 {
|
|
t.Fatalf("Invalid number of providers: expected 1, got %d", len(discoveryManager.providers))
|
|
}
|
|
require.Equal(t, 2, len(syncedTargets))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus"]))
|
|
verifySyncedPresence(t, syncedTargets, "prometheus2", "{__address__=\"foo:9090\"}", true)
|
|
require.Equal(t, 1, len(syncedTargets["prometheus2"]))
|
|
}
|
|
|
|
func TestApplyConfigDoesNotModifyStaticTargets(t *testing.T) {
|
|
originalConfig := Configs{
|
|
staticConfig("foo:9090", "bar:9090", "baz:9090"),
|
|
}
|
|
processedConfig := Configs{
|
|
staticConfig("foo:9090", "bar:9090", "baz:9090"),
|
|
}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
discoveryManager := NewManager(ctx, log.NewNopLogger())
|
|
discoveryManager.updatert = 100 * time.Millisecond
|
|
go discoveryManager.Run()
|
|
|
|
cfgs := map[string]Configs{
|
|
"prometheus": processedConfig,
|
|
}
|
|
discoveryManager.ApplyConfig(cfgs)
|
|
<-discoveryManager.SyncCh()
|
|
|
|
for _, cfg := range cfgs {
|
|
require.Equal(t, originalConfig, cfg)
|
|
}
|
|
}
|
|
|
|
type errorConfig struct{ err error }
|
|
|
|
func (e errorConfig) Name() string { return "error" }
|
|
func (e errorConfig) NewDiscoverer(DiscovererOptions) (Discoverer, error) { return nil, e.err }
|
|
|
|
type lockStaticConfig struct {
|
|
mu *sync.Mutex
|
|
config StaticConfig
|
|
}
|
|
|
|
func (s lockStaticConfig) Name() string { return "lockstatic" }
|
|
func (s lockStaticConfig) NewDiscoverer(DiscovererOptions) (Discoverer, error) {
|
|
return (lockStaticDiscoverer)(s), nil
|
|
}
|
|
|
|
type lockStaticDiscoverer lockStaticConfig
|
|
|
|
func (s lockStaticDiscoverer) Run(ctx context.Context, up chan<- []*targetgroup.Group) {
|
|
// TODO: existing implementation closes up chan, but documentation explicitly forbids it...?
|
|
defer close(up)
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
select {
|
|
case <-ctx.Done():
|
|
case up <- s.config:
|
|
}
|
|
}
|
|
|
|
func TestGaugeFailedConfigs(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
discoveryManager := NewManager(ctx, log.NewNopLogger())
|
|
discoveryManager.updatert = 100 * time.Millisecond
|
|
go discoveryManager.Run()
|
|
|
|
c := map[string]Configs{
|
|
"prometheus": {
|
|
errorConfig{fmt.Errorf("tests error 0")},
|
|
errorConfig{fmt.Errorf("tests error 1")},
|
|
errorConfig{fmt.Errorf("tests error 2")},
|
|
},
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
<-discoveryManager.SyncCh()
|
|
|
|
failedCount := client_testutil.ToFloat64(failedConfigs)
|
|
if failedCount != 3 {
|
|
t.Fatalf("Expected to have 3 failed configs, got: %v", failedCount)
|
|
}
|
|
|
|
c["prometheus"] = Configs{
|
|
staticConfig("foo:9090"),
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
<-discoveryManager.SyncCh()
|
|
|
|
failedCount = client_testutil.ToFloat64(failedConfigs)
|
|
if failedCount != 0 {
|
|
t.Fatalf("Expected to get no failed config, got: %v", failedCount)
|
|
}
|
|
}
|
|
|
|
func TestCoordinationWithReceiver(t *testing.T) {
|
|
updateDelay := 100 * time.Millisecond
|
|
|
|
type expect struct {
|
|
delay time.Duration
|
|
tgs map[string][]*targetgroup.Group
|
|
}
|
|
|
|
testCases := []struct {
|
|
title string
|
|
providers map[string]Discoverer
|
|
expected []expect
|
|
}{
|
|
{
|
|
title: "Receiver should get all updates even when one provider closes its channel",
|
|
providers: map[string]Discoverer{
|
|
"once1": &onceProvider{
|
|
tgs: []*targetgroup.Group{
|
|
{
|
|
Source: "tg1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
},
|
|
},
|
|
"mock1": newMockDiscoveryProvider(
|
|
update{
|
|
interval: 2 * updateDelay,
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tg2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
},
|
|
),
|
|
},
|
|
expected: []expect{
|
|
{
|
|
tgs: map[string][]*targetgroup.Group{
|
|
"once1": {
|
|
{
|
|
Source: "tg1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
tgs: map[string][]*targetgroup.Group{
|
|
"once1": {
|
|
{
|
|
Source: "tg1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
},
|
|
"mock1": {
|
|
{
|
|
Source: "tg2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
title: "Receiver should get all updates even when the channel is blocked",
|
|
providers: map[string]Discoverer{
|
|
"mock1": newMockDiscoveryProvider(
|
|
update{
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tg1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
},
|
|
},
|
|
update{
|
|
interval: 4 * updateDelay,
|
|
targetGroups: []targetgroup.Group{
|
|
{
|
|
Source: "tg2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
},
|
|
),
|
|
},
|
|
expected: []expect{
|
|
{
|
|
delay: 2 * updateDelay,
|
|
tgs: map[string][]*targetgroup.Group{
|
|
"mock1": {
|
|
{
|
|
Source: "tg1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
delay: 4 * updateDelay,
|
|
tgs: map[string][]*targetgroup.Group{
|
|
"mock1": {
|
|
{
|
|
Source: "tg1",
|
|
Targets: []model.LabelSet{{"__instance__": "1"}},
|
|
},
|
|
{
|
|
Source: "tg2",
|
|
Targets: []model.LabelSet{{"__instance__": "2"}},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(tc.title, func(t *testing.T) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
|
|
mgr := NewManager(ctx, nil)
|
|
mgr.updatert = updateDelay
|
|
go mgr.Run()
|
|
|
|
for name, p := range tc.providers {
|
|
mgr.StartCustomProvider(ctx, name, p)
|
|
}
|
|
|
|
for i, expected := range tc.expected {
|
|
time.Sleep(expected.delay)
|
|
select {
|
|
case <-ctx.Done():
|
|
t.Fatalf("step %d: no update received in the expected timeframe", i)
|
|
case tgs, ok := <-mgr.SyncCh():
|
|
if !ok {
|
|
t.Fatalf("step %d: discovery manager channel is closed", i)
|
|
}
|
|
if len(tgs) != len(expected.tgs) {
|
|
t.Fatalf("step %d: target groups mismatch, got: %d, expected: %d\ngot: %#v\nexpected: %#v",
|
|
i, len(tgs), len(expected.tgs), tgs, expected.tgs)
|
|
}
|
|
for k := range expected.tgs {
|
|
if _, ok := tgs[k]; !ok {
|
|
t.Fatalf("step %d: target group not found: %s\ngot: %#v", i, k, tgs)
|
|
}
|
|
assertEqualGroups(t, tgs[k], expected.tgs[k])
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
type update struct {
|
|
targetGroups []targetgroup.Group
|
|
interval time.Duration
|
|
}
|
|
|
|
type mockdiscoveryProvider struct {
|
|
updates []update
|
|
}
|
|
|
|
func newMockDiscoveryProvider(updates ...update) mockdiscoveryProvider {
|
|
tp := mockdiscoveryProvider{
|
|
updates: updates,
|
|
}
|
|
return tp
|
|
}
|
|
|
|
func (tp mockdiscoveryProvider) Run(ctx context.Context, upCh chan<- []*targetgroup.Group) {
|
|
for _, u := range tp.updates {
|
|
if u.interval > 0 {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case <-time.After(u.interval):
|
|
}
|
|
}
|
|
tgs := make([]*targetgroup.Group, len(u.targetGroups))
|
|
for i := range u.targetGroups {
|
|
tgs[i] = &u.targetGroups[i]
|
|
}
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case upCh <- tgs:
|
|
}
|
|
}
|
|
<-ctx.Done()
|
|
}
|
|
|
|
// byGroupSource implements sort.Interface so we can sort by the Source field.
|
|
type byGroupSource []*targetgroup.Group
|
|
|
|
func (a byGroupSource) Len() int { return len(a) }
|
|
func (a byGroupSource) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
|
func (a byGroupSource) Less(i, j int) bool { return a[i].Source < a[j].Source }
|
|
|
|
// onceProvider sends updates once (if any) and closes the update channel.
|
|
type onceProvider struct {
|
|
tgs []*targetgroup.Group
|
|
}
|
|
|
|
func (o onceProvider) Run(_ context.Context, ch chan<- []*targetgroup.Group) {
|
|
if len(o.tgs) > 0 {
|
|
ch <- o.tgs
|
|
}
|
|
close(ch)
|
|
}
|
|
|
|
// TestTargetSetTargetGroupsUpdateDuringApplyConfig is used to detect races when
|
|
// ApplyConfig happens at the same time as targets update.
|
|
func TestTargetSetTargetGroupsUpdateDuringApplyConfig(*testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
discoveryManager := NewManager(ctx, log.NewNopLogger())
|
|
discoveryManager.updatert = 100 * time.Millisecond
|
|
go discoveryManager.Run()
|
|
|
|
td := newTestDiscoverer()
|
|
|
|
c := map[string]Configs{
|
|
"prometheus": {
|
|
td,
|
|
},
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
|
|
var wg sync.WaitGroup
|
|
wg.Add(2000)
|
|
|
|
start := make(chan struct{})
|
|
for i := 0; i < 1000; i++ {
|
|
go func() {
|
|
<-start
|
|
td.update([]*targetgroup.Group{
|
|
{
|
|
Targets: []model.LabelSet{
|
|
{model.AddressLabel: model.LabelValue("127.0.0.1:9090")},
|
|
},
|
|
},
|
|
})
|
|
wg.Done()
|
|
}()
|
|
}
|
|
|
|
for i := 0; i < 1000; i++ {
|
|
go func(i int) {
|
|
<-start
|
|
c := map[string]Configs{
|
|
fmt.Sprintf("prometheus-%d", i): {
|
|
td,
|
|
},
|
|
}
|
|
discoveryManager.ApplyConfig(c)
|
|
wg.Done()
|
|
}(i)
|
|
}
|
|
|
|
close(start)
|
|
wg.Wait()
|
|
}
|
|
|
|
// testDiscoverer is a config and a discoverer that can adjust targets with a
|
|
// simple function.
|
|
type testDiscoverer struct {
|
|
up chan<- []*targetgroup.Group
|
|
ready chan struct{}
|
|
}
|
|
|
|
func newTestDiscoverer() *testDiscoverer {
|
|
return &testDiscoverer{
|
|
ready: make(chan struct{}),
|
|
}
|
|
}
|
|
|
|
// Name implements Config.
|
|
func (t *testDiscoverer) Name() string {
|
|
return "test"
|
|
}
|
|
|
|
// NewDiscoverer implements Config.
|
|
func (t *testDiscoverer) NewDiscoverer(DiscovererOptions) (Discoverer, error) {
|
|
return t, nil
|
|
}
|
|
|
|
// Run implements Discoverer.
|
|
func (t *testDiscoverer) Run(ctx context.Context, up chan<- []*targetgroup.Group) {
|
|
t.up = up
|
|
close(t.ready)
|
|
<-ctx.Done()
|
|
}
|
|
|
|
func (t *testDiscoverer) update(tgs []*targetgroup.Group) {
|
|
<-t.ready
|
|
t.up <- tgs
|
|
}
|