func newKubeSource(pollDuration time.Duration) (*kubeSource, error) {
if len(*argMaster) == 0 {
return nil, fmt.Errorf("kubernetes_master flag not specified")
}
if !(strings.HasPrefix(*argMaster, "http://") || strings.HasPrefix(*argMaster, "https://")) {
*argMaster = "http://" + *argMaster
}
kubeConfig := kube_client.Config{
Host: *argMaster,
Version: kubeClientVersion,
Insecure: *argMasterInsecure,
}
if len(*argClientAuthFile) > 0 {
clientAuth, err := clientauth.LoadFromFile(*argClientAuthFile)
if err != nil {
return nil, err
}
kubeConfig, err = clientAuth.MergeWithConfig(kubeConfig)
if err != nil {
return nil, err
}
}
kubeClient := kube_client.NewOrDie(&kubeConfig)
nodesApi, err := nodes.NewKubeNodes(kubeClient)
if err != nil {
return nil, err
}
glog.Infof("Using Kubernetes client with master %q and version %s\n", *argMaster, kubeClientVersion)
glog.Infof("Using kubelet port %q", *argKubeletPort)
eventsSource := NewEventsSource(kubeClient)
return &kubeSource{
lastQuery: time.Now(),
pollDuration: pollDuration,
kubeletPort: *argKubeletPort,
kubeletApi: datasource.NewKubelet(),
nodesApi: nodesApi,
podsApi: newPodsApi(kubeClient),
podErrors: make(map[podInstance]int),
eventsApi: eventsSource,
}, nil
}
func CreateKubeSources(uri string, options map[string][]string) ([]api.Source, error) {
var (
kubeConfig *kube_client.Config
err error
)
configOverrides, err := getConfigOverrides(uri, options)
if err != nil {
return nil, err
}
inClusterConfig := defaultInClusterConfig
if len(options["inClusterConfig"]) > 0 {
inClusterConfig, err = strconv.ParseBool(options["inClusterConfig"][0])
if err != nil {
return nil, err
}
}
if inClusterConfig {
kubeConfig, err = kube_client.InClusterConfig()
if err != nil {
return nil, err
}
if configOverrides.ClusterInfo.Server != "" {
kubeConfig.Host = configOverrides.ClusterInfo.Server
}
kubeConfig.Version = configOverrides.ClusterInfo.APIVersion
} else {
authFile := ""
if len(options["auth"]) > 0 {
authFile = options["auth"][0]
}
if authFile != "" {
if kubeConfig, err = kubeClientCmd.NewNonInteractiveDeferredLoadingClientConfig(
&kubeClientCmd.ClientConfigLoadingRules{ExplicitPath: authFile},
configOverrides).ClientConfig(); err != nil {
return nil, err
}
} else {
kubeConfig = &kube_client.Config{
Host: configOverrides.ClusterInfo.Server,
Version: configOverrides.ClusterInfo.APIVersion,
Insecure: configOverrides.ClusterInfo.InsecureSkipTLSVerify,
}
}
}
if len(kubeConfig.Host) == 0 {
return nil, fmt.Errorf("invalid kubernetes master url specified")
}
if len(kubeConfig.Version) == 0 {
return nil, fmt.Errorf("invalid kubernetes API version specified")
}
useServiceAccount := defaultUseServiceAccount
if len(options["useServiceAccount"]) >= 1 {
useServiceAccount, err = strconv.ParseBool(options["useServiceAccount"][0])
if err != nil {
return nil, err
}
}
if useServiceAccount {
// If a readable service account token exists, then use it
if contents, err := ioutil.ReadFile(defaultServiceAccountFile); err == nil {
kubeConfig.BearerToken = string(contents)
}
}
kubeClient := kube_client.NewOrDie(kubeConfig)
nodesApi, err := nodes.NewKubeNodes(kubeClient)
if err != nil {
return nil, err
}
kubeletPort := defaultKubeletPort
if len(options["kubeletPort"]) >= 1 {
kubeletPort, err = strconv.Atoi(options["kubeletPort"][0])
if err != nil {
return nil, err
}
}
kubeletHttps := defaultKubeletHttps
if len(options["kubeletHttps"]) >= 1 {
kubeletHttps, err = strconv.ParseBool(options["kubeletHttps"][0])
if err != nil {
return nil, err
}
}
glog.Infof("Using Kubernetes client with master %q and version %q\n", kubeConfig.Host, kubeConfig.Version)
glog.Infof("Using kubelet port %d", kubeletPort)
kubeletConfig := &kube_client.KubeletConfig{
Port: uint(kubeletPort),
EnableHttps: kubeletHttps,
TLSClientConfig: kubeConfig.TLSClientConfig,
}
kubeletApi, err := datasource.NewKubelet(kubeletConfig)
if err != nil {
return nil, err
}
kubePodsSource := NewKubePodMetrics(kubeletPort, kubeletApi, nodesApi, newPodsApi(kubeClient))
kubeNodeSource := NewKubeNodeMetrics(kubeletPort, kubeletApi, nodesApi)
kubeEventsSource := NewKubeEvents(kubeClient)
return []api.Source{kubePodsSource, kubeNodeSource, kubeEventsSource}, nil
}
