func createKubeClientOrDie(kubernetesUrl *url.URL) *kube_client.Client {
kubeConfig, err := kube_config.GetKubeClientConfig(kubernetesUrl)
if err != nil {
glog.Fatalf("Failed to get client config: %v", err)
}
return kube_client.NewOrDie(kubeConfig)
}
func GetKubeConfigs(uri *url.URL) (*kube_client.Config, *kubelet_client.KubeletClientConfig, error) {
kubeConfig, err := kube_config.GetKubeClientConfig(uri)
if err != nil {
return nil, nil, err
}
opts := uri.Query()
kubeletPort := defaultKubeletPort
if len(opts["kubeletPort"]) >= 1 {
kubeletPort, err = strconv.Atoi(opts["kubeletPort"][0])
if err != nil {
return nil, nil, err
}
}
kubeletHttps := defaultKubeletHttps
if len(opts["kubeletHttps"]) >= 1 {
kubeletHttps, err = strconv.ParseBool(opts["kubeletHttps"][0])
if err != nil {
return nil, nil, err
}
}
glog.Infof("Using Kubernetes client with master %q and version %q\n", kubeConfig.Host, kubeConfig.GroupVersion.Version)
glog.Infof("Using kubelet port %d", kubeletPort)
kubeletConfig := &kubelet_client.KubeletClientConfig{
Port: uint(kubeletPort),
EnableHttps: kubeletHttps,
TLSClientConfig: kubeConfig.TLSClientConfig,
BearerToken: kubeConfig.BearerToken,
}
return kubeConfig, kubeletConfig, nil
}
func getPodLister(url *url.URL) (*cache.StoreToPodLister, error) {
kubeConfig, err := kube_config.GetKubeClientConfig(url)
if err != nil {
return nil, err
}
kubeClient := kube_client.NewOrDie(kubeConfig)
lw := cache.NewListWatchFromClient(kubeClient, "pods", kube_api.NamespaceAll, fields.Everything())
store := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
podLister := &cache.StoreToPodLister{Indexer: store}
reflector := cache.NewReflector(lw, &kube_api.Pod{}, store, time.Hour)
reflector.Run()
return podLister, nil
}
func NewNodeAutoscalingEnricher(url *url.URL) (*NodeAutoscalingEnricher, error) {
kubeConfig, err := kube_config.GetKubeClientConfig(url)
if err != nil {
return nil, err
}
kubeClient := kube_client.NewOrDie(kubeConfig)
// watch nodes
lw := cache.NewListWatchFromClient(kubeClient, "nodes", kube_api.NamespaceAll, fields.Everything())
nodeLister := &cache.StoreToNodeLister{Store: cache.NewStore(cache.MetaNamespaceKeyFunc)}
reflector := cache.NewReflector(lw, &kube_api.Node{}, nodeLister.Store, time.Hour)
reflector.Run()
return &NodeAutoscalingEnricher{
nodeLister: nodeLister,
reflector: reflector,
}, nil
}
func NewNamespaceBasedEnricher(url *url.URL) (*NamespaceBasedEnricher, error) {
kubeConfig, err := kube_config.GetKubeClientConfig(url)
if err != nil {
return nil, err
}
kubeClient := kube_client.NewOrDie(kubeConfig)
// watch nodes
lw := cache.NewListWatchFromClient(kubeClient, "namespaces", kube_api.NamespaceAll, fields.Everything())
store := cache.NewStore(cache.MetaNamespaceKeyFunc)
reflector := cache.NewReflector(lw, &kube_api.Namespace{}, store, time.Hour)
reflector.Run()
return &NamespaceBasedEnricher{
store: store,
reflector: reflector,
}, nil
}
func NewKubernetesSource(uri *url.URL) (*KubernetesEventSource, error) {
kubeConfig, err := kubeconfig.GetKubeClientConfig(uri)
if err != nil {
return nil, err
}
kubeClient, err := kubeclient.New(kubeConfig)
if err != nil {
return nil, err
}
eventClient := kubeClient.Events(kubeapi.NamespaceAll)
result := KubernetesEventSource{
localEventsBuffer: make(chan *kubeapi.Event, LocalEventsBufferSize),
stopChannel: make(chan struct{}),
eventClient: eventClient,
}
go result.watch()
return &result, nil
}