// NewClient returns a new client based on the passed in config. The // codec is ignored, as the dynamic client uses it's own codec. func NewClient(conf *restclient.Config) (*Client, error) { // avoid changing the original config confCopy := *conf conf = &confCopy // TODO: it's questionable that this should be using anything other than unstructured schema and JSON conf.ContentType = runtime.ContentTypeJSON conf.AcceptContentTypes = runtime.ContentTypeJSON if conf.APIPath == "" { conf.APIPath = "/api" } if len(conf.UserAgent) == 0 { conf.UserAgent = restclient.DefaultKubernetesUserAgent() } if conf.NegotiatedSerializer == nil { streamingInfo, _ := api.Codecs.StreamingSerializerForMediaType("application/json;stream=watch", nil) conf.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: dynamicCodec{}}, streamingInfo) } cl, err := restclient.RESTClientFor(conf) if err != nil { return nil, err } return &Client{cl: cl}, nil }
func createKubeClient(flags *flag.FlagSet, inCluster bool) (*kube_client.Client, error) { var config *kube_restclient.Config var err error if inCluster { config, err = kube_restclient.InClusterConfig() } else { clientConfig := kubectl_util.DefaultClientConfig(flags) config, err = clientConfig.ClientConfig() } if err != nil { fmt.Errorf("error connecting to the client: %v", err) } config.ContentType = *contentType return kube_client.NewOrDie(config), nil }
// BeforeEach gets a client and makes a namespace. func (f *Framework) BeforeEach() { // The fact that we need this feels like a bug in ginkgo. // https://github.com/onsi/ginkgo/issues/222 f.cleanupHandle = AddCleanupAction(f.AfterEach) if f.Client == nil { By("Creating a kubernetes client") var config *restclient.Config if TestContext.NodeName != "" { // This is a node e2e test, apply the node e2e configuration config = &restclient.Config{ Host: TestContext.Host, QPS: 100, Burst: 100, } } else { var err error config, err = LoadConfig() Expect(err).NotTo(HaveOccurred()) config.QPS = f.options.ClientQPS config.Burst = f.options.ClientBurst } if TestContext.KubeAPIContentType != "" { config.ContentType = TestContext.KubeAPIContentType } c, err := loadClientFromConfig(config) Expect(err).NotTo(HaveOccurred()) f.Client = c f.Clientset_1_2, err = release_1_2.NewForConfig(config) Expect(err).NotTo(HaveOccurred()) f.Clientset_1_3, err = release_1_3.NewForConfig(config) Expect(err).NotTo(HaveOccurred()) } if f.federated { if f.FederationClient == nil { By("Creating a federated kubernetes client") var err error f.FederationClient, err = LoadFederationClient() Expect(err).NotTo(HaveOccurred()) } if f.FederationClientset == nil { By("Creating an unversioned federation Clientset") var err error f.FederationClientset, err = LoadFederationClientset() Expect(err).NotTo(HaveOccurred()) } if f.FederationClientset_1_3 == nil { By("Creating a release 1.3 federation Clientset") var err error f.FederationClientset_1_3, err = LoadFederationClientset_1_3() Expect(err).NotTo(HaveOccurred()) } By("Waiting for federation-apiserver to be ready") err := WaitForFederationApiserverReady(f.FederationClientset) Expect(err).NotTo(HaveOccurred()) By("federation-apiserver is ready") } By("Building a namespace api object") namespace, err := f.CreateNamespace(f.BaseName, map[string]string{ "e2e-framework": f.BaseName, }) Expect(err).NotTo(HaveOccurred()) f.Namespace = namespace if TestContext.VerifyServiceAccount { By("Waiting for a default service account to be provisioned in namespace") err = WaitForDefaultServiceAccountInNamespace(f.Client, namespace.Name) Expect(err).NotTo(HaveOccurred()) } else { Logf("Skipping waiting for service account") } if TestContext.GatherKubeSystemResourceUsageData != "false" && TestContext.GatherKubeSystemResourceUsageData != "none" { f.gatherer, err = NewResourceUsageGatherer(f.Client, ResourceGathererOptions{ inKubemark: ProviderIs("kubemark"), masterOnly: TestContext.GatherKubeSystemResourceUsageData == "master", }) if err != nil { Logf("Error while creating NewResourceUsageGatherer: %v", err) } else { go f.gatherer.startGatheringData() } } if TestContext.GatherLogsSizes { f.logsSizeWaitGroup = sync.WaitGroup{} f.logsSizeWaitGroup.Add(1) f.logsSizeCloseChannel = make(chan bool) f.logsSizeVerifier = NewLogsVerifier(f.Client, f.logsSizeCloseChannel) go func() { f.logsSizeVerifier.Run() f.logsSizeWaitGroup.Done() }() } }
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 }