RepoMirrors
/
prometheus
mirror of https://github.com/prometheus/prometheus
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
prometheus/retrieval/targetpool_test.go

138 lines
3.2 KiB
Go
Raw Normal View History

Create ``TargetPool`` priority queue. ``TargetPool`` is a pool of targets pending scraping. For now, it uses the ``heap.Interface`` from ``container/heap`` to provide a priority queue for the system to scrape from the next target. It is my supposition that we'll use a model whereby we create a ``TargetPool`` for each scrape interval, into which ``Target`` instances are registered.
2013-01-04 11:17:31 +00:00
// Copyright 2013 Prometheus Team
// 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 retrieval
Refactor target scheduling to separate facility. ``Target`` will be refactored down the road to support various nuanced endpoint types. Thusly incorporating the scheduling behavior within it will be problematic. To that end, the scheduling behavior has been moved into a separate assistance type to improve conciseness and testability. ``make format`` was also run.
2013-01-12 20:22:59 +00:00
// import (
// "container/heap"
// "testing"
// "time"
// )
Create ``TargetPool`` priority queue. ``TargetPool`` is a pool of targets pending scraping. For now, it uses the ``heap.Interface`` from ``container/heap`` to provide a priority queue for the system to scrape from the next target. It is my supposition that we'll use a model whereby we create a ``TargetPool`` for each scrape interval, into which ``Target`` instances are registered.
2013-01-04 11:17:31 +00:00
Refactor target scheduling to separate facility. ``Target`` will be refactored down the road to support various nuanced endpoint types. Thusly incorporating the scheduling behavior within it will be problematic. To that end, the scheduling behavior has been moved into a separate assistance type to improve conciseness and testability. ``make format`` was also run.
2013-01-12 20:22:59 +00:00
type literalScheduler time.Time
func (s literalScheduler) ScheduledFor() time.Time {
return time.Time(s)
}
func (s literalScheduler) Reschedule(earliest time.Time, future TargetState) {
}
Create ``TargetPool`` priority queue. ``TargetPool`` is a pool of targets pending scraping. For now, it uses the ``heap.Interface`` from ``container/heap`` to provide a priority queue for the system to scrape from the next target. It is my supposition that we'll use a model whereby we create a ``TargetPool`` for each scrape interval, into which ``Target`` instances are registered.
2013-01-04 11:17:31 +00:00
func TestTargetPool(t *testing.T) {
type expectation struct {
size int
}
Refactor target scheduling to separate facility. ``Target`` will be refactored down the road to support various nuanced endpoint types. Thusly incorporating the scheduling behavior within it will be problematic. To that end, the scheduling behavior has been moved into a separate assistance type to improve conciseness and testability. ``make format`` was also run.
2013-01-12 20:22:59 +00:00
// type input struct {
// address string
// scheduledFor time.Time
// }
Create ``TargetPool`` priority queue. ``TargetPool`` is a pool of targets pending scraping. For now, it uses the ``heap.Interface`` from ``container/heap`` to provide a priority queue for the system to scrape from the next target. It is my supposition that we'll use a model whereby we create a ``TargetPool`` for each scrape interval, into which ``Target`` instances are registered.
2013-01-04 11:17:31 +00:00
Refactor target scheduling to separate facility. ``Target`` will be refactored down the road to support various nuanced endpoint types. Thusly incorporating the scheduling behavior within it will be problematic. To that end, the scheduling behavior has been moved into a separate assistance type to improve conciseness and testability. ``make format`` was also run.
2013-01-12 20:22:59 +00:00
// type output struct {
// address string
// }
Create ``TargetPool`` priority queue. ``TargetPool`` is a pool of targets pending scraping. For now, it uses the ``heap.Interface`` from ``container/heap`` to provide a priority queue for the system to scrape from the next target. It is my supposition that we'll use a model whereby we create a ``TargetPool`` for each scrape interval, into which ``Target`` instances are registered.
2013-01-04 11:17:31 +00:00
Refactor target scheduling to separate facility. ``Target`` will be refactored down the road to support various nuanced endpoint types. Thusly incorporating the scheduling behavior within it will be problematic. To that end, the scheduling behavior has been moved into a separate assistance type to improve conciseness and testability. ``make format`` was also run.
2013-01-12 20:22:59 +00:00
// var scenarios = []struct {
// name string
// outputs []output
// inputs []input
// }{
// {
// name: "empty",
// inputs: []input{},
// outputs: []output{},
// },
// {
// name: "single element",
// inputs: []input{
// {
// address: "http://single.com",
// },
// },
// outputs: []output{
// {
// address: "http://single.com",
// },
// },
// },
// {
// name: "plural descending schedules",
// inputs: []input{
// {
// address: "http://plural-descending.com",
// scheduledFor: time.Date(2013, 1, 4, 12, 0, 0, 0, time.UTC),
// },
// {
// address: "http://plural-descending.net",
// scheduledFor: time.Date(2013, 1, 4, 11, 0, 0, 0, time.UTC),
// },
// },
// outputs: []output{
// {
// address: "http://plural-descending.net",
// },
// {
// address: "http://plural-descending.com",
// },
// },
// },
// {
// name: "plural ascending schedules",
// inputs: []input{
// {
// address: "http://plural-ascending.net",
// scheduledFor: time.Date(2013, 1, 4, 11, 0, 0, 0, time.UTC),
// },
// {
// address: "http://plural-ascending.com",
// scheduledFor: time.Date(2013, 1, 4, 12, 0, 0, 0, time.UTC),
// },
// },
// outputs: []output{
// {
// address: "http://plural-ascending.net",
// },
// {
// address: "http://plural-ascending.com",
// },
// },
// },
// }
Create ``TargetPool`` priority queue. ``TargetPool`` is a pool of targets pending scraping. For now, it uses the ``heap.Interface`` from ``container/heap`` to provide a priority queue for the system to scrape from the next target. It is my supposition that we'll use a model whereby we create a ``TargetPool`` for each scrape interval, into which ``Target`` instances are registered.
2013-01-04 11:17:31 +00:00
Refactor target scheduling to separate facility. ``Target`` will be refactored down the road to support various nuanced endpoint types. Thusly incorporating the scheduling behavior within it will be problematic. To that end, the scheduling behavior has been moved into a separate assistance type to improve conciseness and testability. ``make format`` was also run.
2013-01-12 20:22:59 +00:00
// for i, scenario := range scenarios {
// pool := TargetPool{}
Create ``TargetPool`` priority queue. ``TargetPool`` is a pool of targets pending scraping. For now, it uses the ``heap.Interface`` from ``container/heap`` to provide a priority queue for the system to scrape from the next target. It is my supposition that we'll use a model whereby we create a ``TargetPool`` for each scrape interval, into which ``Target`` instances are registered.
2013-01-04 11:17:31 +00:00
for _, input := range scenario.inputs {
target := Target{
Refactor target scheduling to separate facility. ``Target`` will be refactored down the road to support various nuanced endpoint types. Thusly incorporating the scheduling behavior within it will be problematic. To that end, the scheduling behavior has been moved into a separate assistance type to improve conciseness and testability. ``make format`` was also run.
2013-01-12 20:22:59 +00:00
Address: input.address,
scheduler: literalScheduler(input.scheduledFor),
Create ``TargetPool`` priority queue. ``TargetPool`` is a pool of targets pending scraping. For now, it uses the ``heap.Interface`` from ``container/heap`` to provide a priority queue for the system to scrape from the next target. It is my supposition that we'll use a model whereby we create a ``TargetPool`` for each scrape interval, into which ``Target`` instances are registered.
2013-01-04 11:17:31 +00:00
}
Refactor target scheduling to separate facility. ``Target`` will be refactored down the road to support various nuanced endpoint types. Thusly incorporating the scheduling behavior within it will be problematic. To that end, the scheduling behavior has been moved into a separate assistance type to improve conciseness and testability. ``make format`` was also run.
2013-01-12 20:22:59 +00:00
// heap.Push(&pool, &target)
// }
Create ``TargetPool`` priority queue. ``TargetPool`` is a pool of targets pending scraping. For now, it uses the ``heap.Interface`` from ``container/heap`` to provide a priority queue for the system to scrape from the next target. It is my supposition that we'll use a model whereby we create a ``TargetPool`` for each scrape interval, into which ``Target`` instances are registered.
2013-01-04 11:17:31 +00:00
Refactor target scheduling to separate facility. ``Target`` will be refactored down the road to support various nuanced endpoint types. Thusly incorporating the scheduling behavior within it will be problematic. To that end, the scheduling behavior has been moved into a separate assistance type to improve conciseness and testability. ``make format`` was also run.
2013-01-12 20:22:59 +00:00
// if pool.Len() != len(scenario.outputs) {
// t.Errorf("%s %d. expected TargetPool size to be %d but was %d", scenario.name, i, len(scenario.outputs), pool.Len())
// } else {
// for j, output := range scenario.outputs {
// target := heap.Pop(&pool).(*Target)
Create ``TargetPool`` priority queue. ``TargetPool`` is a pool of targets pending scraping. For now, it uses the ``heap.Interface`` from ``container/heap`` to provide a priority queue for the system to scrape from the next target. It is my supposition that we'll use a model whereby we create a ``TargetPool`` for each scrape interval, into which ``Target`` instances are registered.
2013-01-04 11:17:31 +00:00
Refactor target scheduling to separate facility. ``Target`` will be refactored down the road to support various nuanced endpoint types. Thusly incorporating the scheduling behavior within it will be problematic. To that end, the scheduling behavior has been moved into a separate assistance type to improve conciseness and testability. ``make format`` was also run.
2013-01-12 20:22:59 +00:00
// if target.Address != output.address {
// t.Errorf("%s %d.%d. expected Target address to be %s but was %s", scenario.name, i, j, output.address, target.Address)
Create ``TargetPool`` priority queue. ``TargetPool`` is a pool of targets pending scraping. For now, it uses the ``heap.Interface`` from ``container/heap`` to provide a priority queue for the system to scrape from the next target. It is my supposition that we'll use a model whereby we create a ``TargetPool`` for each scrape interval, into which ``Target`` instances are registered.
2013-01-04 11:17:31 +00:00
Refactor target scheduling to separate facility. ``Target`` will be refactored down the road to support various nuanced endpoint types. Thusly incorporating the scheduling behavior within it will be problematic. To that end, the scheduling behavior has been moved into a separate assistance type to improve conciseness and testability. ``make format`` was also run.
2013-01-12 20:22:59 +00:00
// }
// }
// }
// }
// }