func (k8scc *K8sClientConfig) UnversionedClient() *unversioned.Client { config := clientcmdapi.NewConfig() config.Clusters[k8scc.ClusterID] = &clientcmdapi.Cluster{ InsecureSkipTLSVerify: k8scc.InsecureSkipTLSVerify, Server: k8scc.Server, CertificateAuthority: k8scc.CertificateAuthority, CertificateAuthorityData: k8scc.CertificateAuthorityData, } config.AuthInfos[k8scc.ClusterID] = &clientcmdapi.AuthInfo{ ClientCertificate: k8scc.ClientCertificate, ClientKey: k8scc.ClientKey, ClientCertificateData: k8scc.ClientCertificateData, ClientKeyData: k8scc.ClientKeyData, } config.Contexts[k8scc.ClusterID] = &clientcmdapi.Context{ Cluster: k8scc.ClusterID, AuthInfo: k8scc.ClusterID, } config.CurrentContext = k8scc.ClusterID clientBuilder := clientcmd.NewNonInteractiveClientConfig(*config, k8scc.ClusterID, &clientcmd.ConfigOverrides{}) clientConfig, err := clientBuilder.ClientConfig() if err != nil { log.Fatalf("Unexpected error: %v", err) } client, err := unversioned.New(clientConfig) if err != nil { log.Fatalf("Unexpected error: %v", err) } return client }
func TestKubectlValidation(t *testing.T) { testCases := []struct { data string err bool }{ {`{"apiVersion": "v1", "kind": "thisObjectShouldNotExistInAnyGroup"}`, true}, {`{"apiVersion": "invalidVersion", "kind": "Pod"}`, true}, {`{"apiVersion": "v1", "kind": "Pod"}`, false}, // The following test the experimental api. // TODO: Replace with something more robust. These may move. {`{"apiVersion": "extensions/v1beta1", "kind": "Ingress"}`, false}, {`{"apiVersion": "extensions/v1beta1", "kind": "Job"}`, false}, {`{"apiVersion": "vNotAVersion", "kind": "Job"}`, true}, } components := framework.NewMasterComponents(&framework.Config{}) defer components.Stop(true, true) ctx := clientcmdapi.NewContext() cfg := clientcmdapi.NewConfig() // Enable swagger api on master. components.KubeMaster.InstallSwaggerAPI() cluster := clientcmdapi.NewCluster() cluster.Server = components.ApiServer.URL cluster.InsecureSkipTLSVerify = true cfg.Contexts = map[string]*clientcmdapi.Context{"test": ctx} cfg.CurrentContext = "test" overrides := clientcmd.ConfigOverrides{ ClusterInfo: *cluster, } cmdConfig := clientcmd.NewNonInteractiveClientConfig(*cfg, "test", &overrides, nil) factory := util.NewFactory(cmdConfig) schema, err := factory.Validator(true, "") if err != nil { t.Errorf("failed to get validator: %v", err) return } for i, test := range testCases { err := schema.ValidateBytes([]byte(test.data)) if err == nil { if test.err { t.Errorf("case %d: expected error", i) } } else { if !test.err { t.Errorf("case %d: unexpected error: %v", i, err) } } } }
func loadRESTClientConfig(kubeconfig string) (*restclient.Config, error) { // Load structured kubeconfig data from the given path. loader := &clientcmd.ClientConfigLoadingRules{ExplicitPath: kubeconfig} loadedConfig, err := loader.Load() if err != nil { return nil, err } // Flatten the loaded data to a particular restclient.Config based on the current context. return clientcmd.NewNonInteractiveClientConfig( *loadedConfig, loadedConfig.CurrentContext, &clientcmd.ConfigOverrides{}, loader, ).ClientConfig() }
func createClientsetForCluster(c federationapi.Cluster, i int, userAgentName string) *kubeclientset.Clientset { kubecfg, err := clientcmd.LoadFromFile(framework.TestContext.KubeConfig) framework.ExpectNoError(err, "error loading KubeConfig: %v", err) cfgOverride := &clientcmd.ConfigOverrides{ ClusterInfo: clientcmdapi.Cluster{ Server: c.Spec.ServerAddressByClientCIDRs[0].ServerAddress, }, } ccfg := clientcmd.NewNonInteractiveClientConfig(*kubecfg, c.Name, cfgOverride, clientcmd.NewDefaultClientConfigLoadingRules()) cfg, err := ccfg.ClientConfig() framework.ExpectNoError(err, "Error creating client config in cluster #%d (%q)", i, c.Name) cfg.QPS = KubeAPIQPS cfg.Burst = KubeAPIBurst return kubeclientset.NewForConfigOrDie(restclient.AddUserAgent(cfg, userAgentName)) }
// k8s.io/kubernetes/pkg/client/unversioned/clientcmd/loader.go func directKClientConfig(kubeconfigPath string, context, server string) clientcmd.ClientConfig { conf, err := clientcmd.LoadFromFile(kubeconfigPath) //conf, err := clientcmd.NewDefaultPathOptions().GetStartingConfig() if err != nil { glog.Errorf("client not configured: %v\n", err) return nil } glog.Infof("kube client configured: %+v\n", conf) var clientConfig clientcmd.ClientConfig overrides := &clientcmd.ConfigOverrides{} if server != "" { overrides.ClusterInfo = kclientcmdapi.Cluster{Server: server} } if context != "" { overrides.CurrentContext = context } clientConfig = clientcmd.NewNonInteractiveClientConfig(*conf, context, overrides) return clientConfig }
// NewKubeClusterFromContext creates a KubeCluster using a Kubernetes client with the configuration of the given context. // If the context name is empty, the default context will be used. func NewKubeClusterFromContext(name string) (*KubeCluster, error) { rulesConfig, err := defaultLoadingRules().Load() if err != nil { return nil, fmt.Errorf("could not load rules: %v", err) } clientConfig := clientcmd.NewNonInteractiveClientConfig(*rulesConfig, name, &clientcmd.ConfigOverrides{}) rawConfig, err := clientConfig.RawConfig() if err != nil || rawConfig.Contexts == nil { return nil, fmt.Errorf("could not access kubectl config: %v", err) } if name == DefaultContext { name = rawConfig.CurrentContext } if rawConfig.Contexts[name] == nil { return nil, fmt.Errorf("context '%s' does not exist", name) } restClientConfig, err := clientConfig.ClientConfig() if err != nil { return nil, fmt.Errorf("could not get ClientConfig: %v", err) } client, err := kubecli.New(restClientConfig) if err != nil { return nil, fmt.Errorf("could not create Kubernetes client: %v", err) } return &KubeCluster{ Client: client, context: name, localkube: name == "localkube", }, nil }
clusters = map[string]*cluster{} primaryClusterName = clusterList.Items[0].Name By(fmt.Sprintf("Labeling %q as the first cluster", primaryClusterName)) for i, c := range clusterList.Items { framework.Logf("Creating a clientset for the cluster %s", c.Name) Expect(framework.TestContext.KubeConfig).ToNot(Equal(""), "KubeConfig must be specified to load clusters' client config") kubecfg, err := clientcmd.LoadFromFile(framework.TestContext.KubeConfig) framework.ExpectNoError(err, "error loading KubeConfig: %v", err) cfgOverride := &clientcmd.ConfigOverrides{ ClusterInfo: clientcmdapi.Cluster{ Server: c.Spec.ServerAddressByClientCIDRs[0].ServerAddress, }, } ccfg := clientcmd.NewNonInteractiveClientConfig(*kubecfg, c.Name, cfgOverride, clientcmd.NewDefaultClientConfigLoadingRules()) cfg, err := ccfg.ClientConfig() framework.ExpectNoError(err, "Error creating client config in cluster #%d (%q)", i, c.Name) cfg.QPS = KubeAPIQPS cfg.Burst = KubeAPIBurst clset := release_1_3.NewForConfigOrDie(restclient.AddUserAgent(cfg, UserAgentName)) clusters[c.Name] = &cluster{c.Name, clset, false, nil} } for name, c := range clusters { // The e2e Framework created the required namespace in one of the clusters, but we need to create it in all the others, if it doesn't yet exist. if _, err := c.Clientset.Core().Namespaces().Get(f.Namespace.Name); errors.IsNotFound(err) { ns := &v1.Namespace{ ObjectMeta: v1.ObjectMeta{ Name: f.Namespace.Name,
func GetKubeClientConfig(uri *url.URL) (*kube_client.Config, error) { var ( kubeConfig *kube_client.Config err error ) opts := uri.Query() configOverrides, err := getConfigOverrides(uri) if err != nil { return nil, err } inClusterConfig := defaultInClusterConfig if len(opts["inClusterConfig"]) > 0 { inClusterConfig, err = strconv.ParseBool(opts["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.GroupVersion = &unversioned.GroupVersion{Version: configOverrides.ClusterInfo.APIVersion} kubeConfig.Insecure = configOverrides.ClusterInfo.InsecureSkipTLSVerify if configOverrides.ClusterInfo.InsecureSkipTLSVerify { kubeConfig.TLSClientConfig.CAFile = "" } } else { authFile := "" if len(opts["auth"]) > 0 { authFile = opts["auth"][0] } if authFile != "" { // Load structured kubeconfig data from the given path. loader := &kubeClientCmd.ClientConfigLoadingRules{ExplicitPath: authFile} loadedConfig, err := loader.Load() if err != nil { return nil, err } // Flatten the loaded data to a particular restclient.Config based on the current context. if kubeConfig, err = kubeClientCmd.NewNonInteractiveClientConfig( *loadedConfig, loadedConfig.CurrentContext, &kubeClientCmd.ConfigOverrides{}, loader).ClientConfig(); err != nil { return nil, err } } else { kubeConfig = &kube_client.Config{ Host: configOverrides.ClusterInfo.Server, Insecure: configOverrides.ClusterInfo.InsecureSkipTLSVerify, } kubeConfig.GroupVersion = &unversioned.GroupVersion{Version: configOverrides.ClusterInfo.APIVersion} } } if len(kubeConfig.Host) == 0 { return nil, fmt.Errorf("invalid kubernetes master url specified") } useServiceAccount := defaultUseServiceAccount if len(opts["useServiceAccount"]) >= 1 { useServiceAccount, err = strconv.ParseBool(opts["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) } } kubeConfig.ContentType = "application/vnd.kubernetes.protobuf" return kubeConfig, nil }