forked from metacontroller/metacontroller
-
Notifications
You must be signed in to change notification settings - Fork 0
/
main.go
119 lines (98 loc) · 3.92 KB
/
main.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
/*
Copyright 2017 Google Inc.
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
https://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 main
import (
"context"
"flag"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"k8s.io/client-go/tools/record"
"github.com/prometheus/client_golang/prometheus/promhttp"
"k8s.io/klog/v2"
"k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd"
"k8s.io/component-base/metrics/legacyregistry"
_ "k8s.io/component-base/metrics/prometheus/clientgo"
"metacontroller.io/options"
"metacontroller.io/server"
_ "k8s.io/client-go/plugin/pkg/client/auth/oidc"
)
var (
discoveryInterval = flag.Duration("discovery-interval", 30*time.Second, "How often to refresh discovery cache to pick up newly-installed resources")
informerRelist = flag.Duration("cache-flush-interval", 30*time.Minute, "How often to flush local caches and relist objects from the API server")
debugAddr = flag.String("debug-addr", ":9999", "The address to bind the debug http endpoints")
clientConfigPath = flag.String("client-config-path", "", "Path to kubeconfig file (same format as used by kubectl); if not specified, use in-cluster config")
clientGoQPS = flag.Float64("client-go-qps", 5, "Number of queries per second client-go is allowed to make (default 5)")
clientGoBurst = flag.Int("client-go-burst", 10, "Allowed burst queries for client-go (default 10)")
workers = flag.Int("workers", 5, "Number of sync workers to run (default 5)")
eventsQPS = flag.Float64("events-qps", 1./300., "Rate of events flowing per object (default - 1 event per 5 minutes)")
eventsBurst = flag.Int("events-burst", 25, "Number of events allowed to send per object (default 25)")
version = "No version provided"
)
func main() {
klog.InitFlags(nil)
flag.Parse()
klog.InfoS("Discovery cache flush interval", "discovery_interval", *discoveryInterval)
klog.InfoS("API server object cache flush interval", "cache_flush_interval", *informerRelist)
klog.InfoS("Http server address", "port", *debugAddr)
klog.InfoS("Metacontroller build information", "version", version)
var config *rest.Config
var err error
if *clientConfigPath != "" {
klog.InfoS("Using current context from kubeconfig file", "path", *clientConfigPath)
config, err = clientcmd.BuildConfigFromFlags("", *clientConfigPath)
} else {
klog.InfoS("No kubeconfig file specified; trying in-cluster auto-config...")
config, err = rest.InClusterConfig()
}
if err != nil {
klog.ErrorS(err, "Terminating")
os.Exit(1)
}
config.QPS = float32(*clientGoQPS)
config.Burst = *clientGoBurst
configuration := options.Configuration{
RestConfig: config,
DiscoveryInterval: *discoveryInterval,
InformerRelist: *informerRelist,
Workers: *workers,
CorrelatorOptions: record.CorrelatorOptions{
BurstSize: *eventsBurst,
QPS: float32(*eventsQPS),
},
}
stopServer, err := server.Start(configuration)
if err != nil {
klog.ErrorS(err, "Terminating")
os.Exit(1)
}
mux := http.NewServeMux()
mux.Handle("/metrics", promhttp.HandlerFor(legacyregistry.DefaultGatherer, promhttp.HandlerOpts{}))
srv := &http.Server{
Addr: *debugAddr,
Handler: mux,
}
go func() {
klog.ErrorS(srv.ListenAndServe(), "Error serving http endpoint")
}()
// On SIGTERM, stop all controllers gracefully.
sigchan := make(chan os.Signal, 2)
signal.Notify(sigchan, os.Interrupt, syscall.SIGTERM)
sig := <-sigchan
klog.InfoS("Shutting down...", "signal", sig)
stopServer()
srv.Shutdown(context.Background())
}