kubernetes
/
minikube
mirror of https://github.com/kubernetes/minikube.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #7749 from tstromberg/storageclass-kapi 

Unify Kubernetes client creation around kapi.Client
pull/7700/head^2
Medya Ghazizadeh 2020-04-17 14:54:27 -07:00 committed by GitHub
parent 74e34c0221 8fc8abb6df
commit 14b6582c7b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 59 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/minikube/cmd/config/configure.go
View File

@ -100,8 +100,11 @@ var addonsConfigureCmd = &cobra.Command{
acrPassword = AskForPasswordValue("-- Enter service principal password to access Azure Container Registry: ")
}
cname := ClusterFlagValue()
// Create ECR Secret
err := service.CreateSecret(
cname,
"kube-system",
"registry-creds-ecr",
map[string]string{
@ -124,6 +127,7 @@ var addonsConfigureCmd = &cobra.Command{
// Create GCR Secret
err = service.CreateSecret(
cname,
"kube-system",
"registry-creds-gcr",
map[string]string{
@ -142,6 +146,7 @@ var addonsConfigureCmd = &cobra.Command{
// Create Docker Secret
err = service.CreateSecret(
cname,
"kube-system",
"registry-creds-dpr",
map[string]string{
@ -161,6 +166,7 @@ var addonsConfigureCmd = &cobra.Command{
// Create Azure Container Registry Secret
err = service.CreateSecret(
cname,
"kube-system",
"registry-creds-acr",
map[string]string{

4
cmd/minikube/cmd/config/open.go
View File

@ -77,7 +77,7 @@ minikube addons enable {{.name}}`, out.V{"name": addonName})
namespace := "kube-system"
key := "kubernetes.io/minikube-addons-endpoint"
serviceList, err := service.GetServiceListByLabel(namespace, key, addonName)
serviceList, err := service.GetServiceListByLabel(cname, namespace, key, addonName)
if err != nil {
exit.WithCodeT(exit.Unavailable, "Error getting service with namespace: {{.namespace}} and labels {{.labelName}}:{{.addonName}}: {{.error}}", out.V{"namespace": namespace, "labelName": key, "addonName": addonName, "error": err})
}
@ -89,7 +89,7 @@ You can add one by annotating a service with the label {{.labelName}}:{{.addonNa
svc := serviceList.Items[i].ObjectMeta.Name
var urlString []string
if urlString, err = service.WaitForService(co.API, namespace, svc, addonsURLTemplate, addonsURLMode, https, wait, interval); err != nil {
if urlString, err = service.WaitForService(co.API, co.Config.Name, namespace, svc, addonsURLTemplate, addonsURLMode, https, wait, interval); err != nil {
exit.WithCodeT(exit.Unavailable, "Wait failed: {{.error}}", out.V{"error": err})
}

2
cmd/minikube/cmd/dashboard.go
View File

@ -83,7 +83,7 @@ var dashboardCmd = &cobra.Command{
ns := "kubernetes-dashboard"
svc := "kubernetes-dashboard"
out.ErrT(out.Verifying, "Verifying dashboard health ...")
checkSVC := func() error { return service.CheckService(ns, svc) }
checkSVC := func() error { return service.CheckService(cname, ns, svc) }
// for slow machines or parallels in CI to avoid #7503
if err = retry.Expo(checkSVC, 100*time.Microsecond, time.Minute*10); err != nil {
exit.WithCodeT(exit.Unavailable, "dashboard service is not running: {{.error}}", out.V{"error": err})

5
cmd/minikube/cmd/service.go
View File

@ -33,6 +33,7 @@ import (
"github.com/spf13/cobra"
"k8s.io/minikube/pkg/drivers/kic/oci"
"k8s.io/minikube/pkg/kapi"
"k8s.io/minikube/pkg/minikube/browser"
"k8s.io/minikube/pkg/minikube/driver"
"k8s.io/minikube/pkg/minikube/exit"
@ -84,7 +85,7 @@ var serviceCmd = &cobra.Command{
return
}
urls, err := service.WaitForService(co.API, namespace, svc, serviceURLTemplate, serviceURLMode, https, wait, interval)
urls, err := service.WaitForService(co.API, co.Config.Name, namespace, svc, serviceURLTemplate, serviceURLMode, https, wait, interval)
if err != nil {
var s *service.SVCNotFoundError
if errors.As(err, &s) {
@ -113,7 +114,7 @@ func startKicServiceTunnel(svc, configName string) {
ctrlC := make(chan os.Signal, 1)
signal.Notify(ctrlC, os.Interrupt)
clientset, err := service.K8s.GetClientset(1 * time.Second)
clientset, err := kapi.Client(configName)
if err != nil {
exit.WithError("error creating clientset", err)
}

2
cmd/minikube/cmd/service_list.go
View File

@ -40,7 +40,7 @@ var serviceListCmd = &cobra.Command{
Run: func(cmd *cobra.Command, args []string) {
co := mustload.Healthy(ClusterFlagValue())
serviceURLs, err := service.GetServiceURLs(co.API, serviceListNamespace, serviceURLTemplate)
serviceURLs, err := service.GetServiceURLs(co.API, co.Config.Name, serviceListNamespace, serviceURLTemplate)
if err != nil {
out.FatalT("Failed to get service URL: {{.error}}", out.V{"error": err})
out.ErrT(out.Notice, "Check that minikube is running and that you have specified the correct namespace (-n flag) if required.")

5
cmd/minikube/cmd/tunnel.go
View File

@ -22,18 +22,17 @@ import (
"os/signal"
"path/filepath"
"strconv"
"time"
"github.com/golang/glog"
"github.com/spf13/cobra"
"k8s.io/minikube/pkg/drivers/kic/oci"
"k8s.io/minikube/pkg/kapi"
"k8s.io/minikube/pkg/minikube/config"
"k8s.io/minikube/pkg/minikube/driver"
"k8s.io/minikube/pkg/minikube/exit"
"k8s.io/minikube/pkg/minikube/localpath"
"k8s.io/minikube/pkg/minikube/mustload"
"k8s.io/minikube/pkg/minikube/service"
"k8s.io/minikube/pkg/minikube/tunnel"
"k8s.io/minikube/pkg/minikube/tunnel/kic"
)
@ -65,7 +64,7 @@ var tunnelCmd = &cobra.Command{
// We define the tunnel and minikube error free if the API server responds within a second.
// This also contributes to better UX, the tunnel status check can happen every second and
// doesn't hang on the API server call during startup and shutdown time or if there is a temporary error.
clientset, err := service.K8s.GetClientset(1 * time.Second)
clientset, err := kapi.Client(cname)
if err != nil {
exit.WithError("error creating clientset", err)
}

9
pkg/addons/addons.go
View File

@ -259,10 +259,6 @@ func enableOrDisableStorageClasses(cc *config.ClusterConfig, name string, val st
if name == "storage-provisioner-gluster" {
class = "glusterfile"
}
storagev1, err := storageclass.GetStoragev1()
if err != nil {
return errors.Wrapf(err, "Error getting storagev1 interface %v ", err)
}
api, err := machine.NewAPIClient()
if err != nil {
@ -279,6 +275,11 @@ func enableOrDisableStorageClasses(cc *config.ClusterConfig, name string, val st
return enableOrDisableAddon(cc, name, val)
}
storagev1, err := storageclass.GetStoragev1(cc.Name)
if err != nil {
return errors.Wrapf(err, "Error getting storagev1 interface %v ", err)
}
if enable {
// Only StorageClass for 'name' should be marked as default
err = storageclass.SetDefaultStorageClass(storagev1, class)

80
pkg/minikube/service/service.go
View File

@ -31,23 +31,17 @@ import (
"github.com/golang/glog"
"github.com/olekukonko/tablewriter"
"github.com/pkg/errors"
"github.com/spf13/viper"
core "k8s.io/api/core/v1"
meta "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/kubernetes"
typed_core "k8s.io/client-go/kubernetes/typed/core/v1"
"k8s.io/client-go/tools/clientcmd"
clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
"k8s.io/minikube/pkg/minikube/config"
"k8s.io/minikube/pkg/kapi"
"k8s.io/minikube/pkg/minikube/machine"
"k8s.io/minikube/pkg/minikube/out"
"k8s.io/minikube/pkg/minikube/proxy"
"k8s.io/minikube/pkg/util/retry"
)
const (
defaultK8sClientTimeout = 60 * time.Second
// DefaultWait is the default wait time, in seconds
DefaultWait = 2
// DefaultInterval is the default interval, in seconds
@ -56,8 +50,7 @@ const (
// K8sClient represents a kubernetes client
type K8sClient interface {
GetCoreClient() (typed_core.CoreV1Interface, error)
GetClientset(timeout time.Duration) (*kubernetes.Clientset, error)
GetCoreClient(string) (typed_core.CoreV1Interface, error)
}
// K8sClientGetter can get a K8sClient
@ -71,39 +64,14 @@ func init() {
}
// GetCoreClient returns a core client
func (k *K8sClientGetter) GetCoreClient() (typed_core.CoreV1Interface, error) {
client, err := k.GetClientset(defaultK8sClientTimeout)
func (k *K8sClientGetter) GetCoreClient(context string) (typed_core.CoreV1Interface, error) {
client, err := kapi.Client(context)
if err != nil {
return nil, errors.Wrap(err, "getting clientset")
return nil, errors.Wrap(err, "client")
}
return client.CoreV1(), nil
}
// GetClientset returns a clientset
func (*K8sClientGetter) GetClientset(timeout time.Duration) (*kubernetes.Clientset, error) {
loadingRules := clientcmd.NewDefaultClientConfigLoadingRules()
profile := viper.GetString(config.ProfileName)
configOverrides := &clientcmd.ConfigOverrides{
Context: clientcmdapi.Context{
Cluster: profile,
AuthInfo: profile,
},
}
kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, configOverrides)
clientConfig, err := kubeConfig.ClientConfig()
if err != nil {
return nil, fmt.Errorf("kubeConfig: %v", err)
}
clientConfig.Timeout = timeout
clientConfig = proxy.UpdateTransport(clientConfig)
client, err := kubernetes.NewForConfig(clientConfig)
if err != nil {
return nil, errors.Wrap(err, "client from config")
}
return client, nil
}
// SvcURL represents a service URL. Each item in the URLs field combines the service URL with one of the configured
// node ports. The PortNames field contains the configured names of the ports in the URLs field (sorted correspondingly -
// first item in PortNames belongs to the first item in URLs).
@ -119,8 +87,8 @@ type URLs []SvcURL
// GetServiceURLs returns a SvcURL object for every service in a particular namespace.
// Accepts a template for formatting
func GetServiceURLs(api libmachine.API, namespace string, t *template.Template) (URLs, error) {
host, err := machine.LoadHost(api, viper.GetString(config.ProfileName))
func GetServiceURLs(api libmachine.API, cname string, namespace string, t *template.Template) (URLs, error) {
host, err := machine.LoadHost(api, cname)
if err != nil {
return nil, err
}
@ -130,7 +98,7 @@ func GetServiceURLs(api libmachine.API, namespace string, t *template.Template)
return nil, err
}
client, err := K8s.GetCoreClient()
client, err := K8s.GetCoreClient(cname)
if err != nil {
return nil, err
}
@ -155,8 +123,8 @@ func GetServiceURLs(api libmachine.API, namespace string, t *template.Template)
}
// GetServiceURLsForService returns a SvcUrl object for a service in a namespace. Supports optional formatting.
func GetServiceURLsForService(api libmachine.API, namespace, service string, t *template.Template) (SvcURL, error) {
host, err := machine.LoadHost(api, viper.GetString(config.ProfileName))
func GetServiceURLsForService(api libmachine.API, cname string, namespace, service string, t *template.Template) (SvcURL, error) {
host, err := machine.LoadHost(api, cname)
if err != nil {
return SvcURL{}, errors.Wrap(err, "Error checking if api exist and loading it")
}
@ -166,7 +134,7 @@ func GetServiceURLsForService(api libmachine.API, namespace, service string, t *
return SvcURL{}, errors.Wrap(err, "Error getting ip from host")
}
client, err := K8s.GetCoreClient()
client, err := K8s.GetCoreClient(cname)
if err != nil {
return SvcURL{}, err
}
@ -226,8 +194,8 @@ func printURLsForService(c typed_core.CoreV1Interface, ip, service, namespace st
}
// CheckService checks if a service is listening on a port.
func CheckService(namespace string, service string) error {
client, err := K8s.GetCoreClient()
func CheckService(cname string, namespace string, service string) error {
client, err := K8s.GetCoreClient(cname)
if err != nil {
return errors.Wrap(err, "Error getting kubernetes client")
}
@ -283,7 +251,7 @@ func (t SVCNotFoundError) Error() string {
}
// WaitForService waits for a service, and return the urls when available
func WaitForService(api libmachine.API, namespace string, service string, urlTemplate *template.Template, urlMode bool, https bool,
func WaitForService(api libmachine.API, cname string, namespace string, service string, urlTemplate *template.Template, urlMode bool, https bool,
wait int, interval int) ([]string, error) {
var urlList []string
// Convert "Amount of time to wait" and "interval of each check" to attempts
@ -291,18 +259,18 @@ func WaitForService(api libmachine.API, namespace string, service string, urlTem
interval = 1
}
err := CheckService(namespace, service)
err := CheckService(cname, namespace, service)
if err != nil {
return nil, &SVCNotFoundError{err}
}
chkSVC := func() error { return CheckService(namespace, service) }
chkSVC := func() error { return CheckService(cname, namespace, service) }
if err := retry.Expo(chkSVC, time.Duration(interval)*time.Second, time.Duration(wait)*time.Second); err != nil {
return nil, &SVCNotFoundError{err}
}
serviceURL, err := GetServiceURLsForService(api, namespace, service, urlTemplate)
serviceURL, err := GetServiceURLsForService(api, cname, namespace, service, urlTemplate)
if err != nil {
return urlList, errors.Wrap(err, "Check that minikube is running and that you have specified the correct namespace")
}
@ -330,8 +298,8 @@ func WaitForService(api libmachine.API, namespace string, service string, urlTem
}
// GetServiceListByLabel returns a ServiceList by label
func GetServiceListByLabel(namespace string, key string, value string) (*core.ServiceList, error) {
client, err := K8s.GetCoreClient()
func GetServiceListByLabel(cname string, namespace string, key string, value string) (*core.ServiceList, error) {
client, err := K8s.GetCoreClient(cname)
if err != nil {
return &core.ServiceList{}, &retry.RetriableError{Err: err}
}
@ -349,8 +317,8 @@ func getServiceListFromServicesByLabel(services typed_core.ServiceInterface, key
}
// CreateSecret creates or modifies secrets
func CreateSecret(namespace, name string, dataValues map[string]string, labels map[string]string) error {
client, err := K8s.GetCoreClient()
func CreateSecret(cname string, namespace, name string, dataValues map[string]string, labels map[string]string) error {
client, err := K8s.GetCoreClient(cname)
if err != nil {
return &retry.RetriableError{Err: err}
}
@ -363,7 +331,7 @@ func CreateSecret(namespace, name string, dataValues map[string]string, labels m
// Delete existing secret
if len(secret.Name) > 0 {
err = DeleteSecret(namespace, name)
err = DeleteSecret(cname, namespace, name)
if err != nil {
return &retry.RetriableError{Err: err}
}
@ -394,8 +362,8 @@ func CreateSecret(namespace, name string, dataValues map[string]string, labels m
}
// DeleteSecret deletes a secret from a namespace
func DeleteSecret(namespace, name string) error {
client, err := K8s.GetCoreClient()
func DeleteSecret(cname string, namespace, name string) error {
client, err := K8s.GetCoreClient(cname)
if err != nil {
return &retry.RetriableError{Err: err}
}

27
pkg/minikube/service/service_test.go
View File

@ -26,8 +26,6 @@ import (
"testing"
"text/template"
"time"
"github.com/docker/machine/libmachine"
"github.com/docker/machine/libmachine/host"
"github.com/pkg/errors"
@ -35,7 +33,6 @@ import (
core "k8s.io/api/core/v1"
meta "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/client-go/kubernetes"
typed_core "k8s.io/client-go/kubernetes/typed/core/v1"
"k8s.io/client-go/kubernetes/typed/core/v1/fake"
testing_fake "k8s.io/client-go/testing"
@ -55,7 +52,7 @@ type MockClientGetter struct {
// Force GetCoreClient to fail
var getCoreClientFail bool
func (m *MockClientGetter) GetCoreClient() (typed_core.CoreV1Interface, error) {
func (m *MockClientGetter) GetCoreClient(string) (typed_core.CoreV1Interface, error) {
if getCoreClientFail {
return nil, fmt.Errorf("test Error - Mocked Get")
}
@ -65,10 +62,6 @@ func (m *MockClientGetter) GetCoreClient() (typed_core.CoreV1Interface, error) {
secretsMap: m.secretsMap}, nil
}
func (m *MockClientGetter) GetClientset(timeout time.Duration) (*kubernetes.Clientset, error) {
return nil, nil
}
func (m *MockCoreClient) Secrets(ns string) typed_core.SecretInterface {
return &fake.FakeSecrets{Fake: &fake.FakeCoreV1{Fake: &testing_fake.Fake{}}}
}
@ -476,7 +469,7 @@ func TestGetServiceURLs(t *testing.T) {
servicesMap: serviceNamespaces,
endpointsMap: endpointNamespaces,
}
urls, err := GetServiceURLs(test.api, test.namespace, defaultTemplate)
urls, err := GetServiceURLs(test.api, "minikube", test.namespace, defaultTemplate)
if err != nil && !test.err {
t.Errorf("Error GetServiceURLs %v", err)
}
@ -544,7 +537,7 @@ func TestGetServiceURLsForService(t *testing.T) {
servicesMap: serviceNamespaces,
endpointsMap: endpointNamespaces,
}
svcURL, err := GetServiceURLsForService(test.api, test.namespace, test.service, defaultTemplate)
svcURL, err := GetServiceURLsForService(test.api, "minikube", test.namespace, test.service, defaultTemplate)
if err != nil && !test.err {
t.Errorf("Error GetServiceURLsForService %v", err)
}
@ -626,7 +619,7 @@ users:
os.Setenv("KUBECONFIG", mockK8sConfigPath)
k8s := K8sClientGetter{}
_, err = k8s.GetCoreClient()
_, err = k8s.GetCoreClient("minikube")
if err != nil && !test.err {
t.Fatalf("GetCoreClient returned unexpected error: %v", err)
}
@ -691,7 +684,7 @@ func TestGetServiceListByLabel(t *testing.T) {
secretsMap: secretsNamespaces,
}
getCoreClientFail = test.failedGetClient
svcs, err := GetServiceListByLabel(test.ns, test.name, test.label)
svcs, err := GetServiceListByLabel("minikube", test.ns, test.name, test.label)
if err != nil && !test.err {
t.Fatalf("Test %v got unexpected error: %v", test.description, err)
}
@ -741,7 +734,7 @@ func TestCheckService(t *testing.T) {
secretsMap: secretsNamespaces,
}
getCoreClientFail = test.failedGetClient
err := CheckService(test.ns, test.name)
err := CheckService("minikube", test.ns, test.name)
if err == nil && test.err {
t.Fatalf("Test %v expected error but got nil", test.description)
}
@ -780,7 +773,7 @@ func TestDeleteSecret(t *testing.T) {
secretsMap: secretsNamespaces,
}
getCoreClientFail = test.failedGetClient
err := DeleteSecret(test.ns, test.name)
err := DeleteSecret("minikube", test.ns, test.name)
if err == nil && test.err {
t.Fatalf("Test %v expected error but got nil", test.description)
}
@ -819,7 +812,7 @@ func TestCreateSecret(t *testing.T) {
secretsMap: secretsNamespaces,
}
getCoreClientFail = test.failedGetClient
err := CreateSecret(test.ns, test.name, map[string]string{"ns": "secret"}, map[string]string{"ns": "baz"})
err := CreateSecret("minikube", test.ns, test.name, map[string]string{"ns": "secret"}, map[string]string{"ns": "baz"})
if err == nil && test.err {
t.Fatalf("Test %v expected error but got nil", test.description)
}
@ -921,7 +914,7 @@ func TestWaitAndMaybeOpenService(t *testing.T) {
}
var urlList []string
urlList, err := WaitForService(test.api, test.namespace, test.service, defaultTemplate, test.urlMode, test.https, 1, 0)
urlList, err := WaitForService(test.api, "minikube", test.namespace, test.service, defaultTemplate, test.urlMode, test.https, 1, 0)
if test.err && err == nil {
t.Fatalf("WaitForService expected to fail for test: %v", test)
}
@ -986,7 +979,7 @@ func TestWaitAndMaybeOpenServiceForNotDefaultNamspace(t *testing.T) {
servicesMap: serviceNamespaceOther,
endpointsMap: endpointNamespaces,
}
_, err := WaitForService(test.api, test.namespace, test.service, defaultTemplate, test.urlMode, test.https, 1, 0)
_, err := WaitForService(test.api, "minikube", test.namespace, test.service, defaultTemplate, test.urlMode, test.https, 1, 0)
if test.err && err == nil {
t.Fatalf("WaitForService expected to fail for test: %v", test)
}

21
pkg/minikube/storageclass/storageclass.go
View File

@ -22,9 +22,8 @@ import (
"github.com/pkg/errors"
v1 "k8s.io/api/storage/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/kubernetes"
storagev1 "k8s.io/client-go/kubernetes/typed/storage/v1"
"k8s.io/client-go/tools/clientcmd"
"k8s.io/minikube/pkg/kapi"
)
func annotateDefaultStorageClass(storage storagev1.StorageV1Interface, class *v1.StorageClass, enable bool) error {
@ -71,25 +70,11 @@ func SetDefaultStorageClass(storage storagev1.StorageV1Interface, name string) e
}
// GetStoragev1 return storage v1 interface for client
func GetStoragev1() (storagev1.StorageV1Interface, error) {
client, err := getClient()
func GetStoragev1(context string) (storagev1.StorageV1Interface, error) {
client, err := kapi.Client(context)
if err != nil {
return nil, err
}
sv1 := client.StorageV1()
return sv1, nil
}
func getClient() (*kubernetes.Clientset, error) {
loadingRules := clientcmd.NewDefaultClientConfigLoadingRules()
kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, &clientcmd.ConfigOverrides{})
config, err := kubeConfig.ClientConfig()
if err != nil {
return nil, errors.Wrap(err, "Error creating kubeConfig")
}
client, err := kubernetes.NewForConfig(config)
if err != nil {
return nil, errors.Wrap(err, "Error creating new client from kubeConfig.ClientConfig()")
}
return client, nil
}

42
pkg/minikube/storageclass/storageclass_test.go
View File

@ -212,45 +212,6 @@ users:
- name: minikube
`
func TestGetClient(t *testing.T) {
var tests = []struct {
description string
config string
err bool
}{
{
description: "ok",
config: mockK8sConfig,
},
{
description: "no valid config",
config: "this is not valid config",
err: true,
},
}
configFile, err := ioutil.TempFile("/tmp", "")
if err != nil {
t.Fatalf(err.Error())
}
defer os.Remove(configFile.Name())
for _, test := range tests {
t.Run(test.description, func(t *testing.T) {
if err := setK8SConfig(test.config, configFile.Name()); err != nil {
t.Fatalf(err.Error())
}
_, err = getClient()
if err != nil && !test.err {
t.Fatalf("Unexpected err: %v for test: %v", err, test.description)
}
if err == nil && test.err {
t.Fatalf("Expected err for test: %v", test.description)
}
})
}
}
func TestGetStoragev1(t *testing.T) {
var tests = []struct {
description string
@ -278,7 +239,8 @@ func TestGetStoragev1(t *testing.T) {
t.Fatalf(err.Error())
}
_, err = GetStoragev1()
// context name is hardcoded by mockK8sConfig
_, err = GetStoragev1("minikube")
if err != nil && !test.err {
t.Fatalf("Unexpected err: %v for test: %v", err, test.description)
}