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

Use consistent names for k8s API imports

pull/4253/head
Thomas Stromberg 2019-05-13 21:57:59 -07:00
parent 6e693d22ee
commit 25579f5a58
7 changed files with 118 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -22,7 +22,7 @@ import (
"github.com/olekukonko/tablewriter" "github.com/olekukonko/tablewriter"
"github.com/spf13/cobra" "github.com/spf13/cobra"
v1 "k8s.io/api/core/v1" core "k8s.io/api/core/v1"
"k8s.io/minikube/pkg/minikube/console" "k8s.io/minikube/pkg/minikube/console"
"k8s.io/minikube/pkg/minikube/exit" "k8s.io/minikube/pkg/minikube/exit"
"k8s.io/minikube/pkg/minikube/machine" "k8s.io/minikube/pkg/minikube/machine"
@ -69,6 +69,6 @@ var serviceListCmd = &cobra.Command{
} }
func init() { func init() {
serviceListCmd.Flags().StringVarP(&serviceListNamespace, "namespace", "n", v1.NamespaceAll, "The services namespace") serviceListCmd.Flags().StringVarP(&serviceListNamespace, "namespace", "n", core.NamespaceAll, "The services namespace")
serviceCmd.AddCommand(serviceListCmd) serviceCmd.AddCommand(serviceListCmd)
} }

33
pkg/minikube/bootstrapper/kubeadm/util.go
View File

@ -25,11 +25,10 @@ import (
"github.com/golang/glog" "github.com/golang/glog"
"github.com/pkg/errors" "github.com/pkg/errors"
clientv1 "k8s.io/api/core/v1" core "k8s.io/api/core/v1"
rbacv1beta1 "k8s.io/api/rbac/v1beta1" rbac "k8s.io/api/rbac/v1beta1"
apierrs "k8s.io/apimachinery/pkg/api/errors" apierr "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" meta "k8s.io/apimachinery/pkg/apis/meta/v1"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/strategicpatch" "k8s.io/apimachinery/pkg/util/strategicpatch"
@ -52,7 +51,7 @@ func unmarkMaster() error {
if err != nil { if err != nil {
return errors.Wrap(err, "getting core client") return errors.Wrap(err, "getting core client")
} }
n, err := client.Nodes().Get(master, v1.GetOptions{}) n, err := client.Nodes().Get(master, meta.GetOptions{})
if err != nil { if err != nil {
return errors.Wrapf(err, "getting node %s", master) return errors.Wrapf(err, "getting node %s", master)
} }
@ -62,7 +61,7 @@ func unmarkMaster() error {
return errors.Wrap(err, "json marshalling data before patch") return errors.Wrap(err, "json marshalling data before patch")
} }
newTaints := []clientv1.Taint{} newTaints := []core.Taint{}
for _, taint := range n.Spec.Taints { for _, taint := range n.Spec.Taints {
if taint.Key == masterTaint { if taint.Key == masterTaint {
continue continue
@ -77,13 +76,13 @@ func unmarkMaster() error {
return errors.Wrapf(err, "json marshalling data after patch") return errors.Wrapf(err, "json marshalling data after patch")
} }
patchBytes, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, clientv1.Node{}) patchBytes, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, core.Node{})
if err != nil { if err != nil {
return errors.Wrap(err, "creating strategic patch") return errors.Wrap(err, "creating strategic patch")
} }
if _, err := client.Nodes().Patch(n.Name, types.StrategicMergePatchType, patchBytes); err != nil { if _, err := client.Nodes().Patch(n.Name, types.StrategicMergePatchType, patchBytes); err != nil {
if apierrs.IsConflict(err) { if apierr.IsConflict(err) {
return errors.Wrap(err, "strategic patch conflict") return errors.Wrap(err, "strategic patch conflict")
} }
return errors.Wrap(err, "applying strategic patch") return errors.Wrap(err, "applying strategic patch")
@ -100,24 +99,24 @@ func elevateKubeSystemPrivileges() error {
if err != nil { if err != nil {
return errors.Wrap(err, "getting clientset") return errors.Wrap(err, "getting clientset")
} }
clusterRoleBinding := &rbacv1beta1.ClusterRoleBinding{ clusterRoleBinding := &rbac.ClusterRoleBinding{
ObjectMeta: v1.ObjectMeta{ ObjectMeta: meta.ObjectMeta{
Name: rbacName, Name: rbacName,
}, },
Subjects: []rbacv1beta1.Subject{ Subjects: []rbac.Subject{
{ {
Kind: "ServiceAccount", Kind: "ServiceAccount",
Name: "default", Name: "default",
Namespace: "kube-system", Namespace: "kube-system",
}, },
}, },
RoleRef: rbacv1beta1.RoleRef{ RoleRef: rbac.RoleRef{
Kind: "ClusterRole", Kind: "ClusterRole",
Name: "cluster-admin", Name: "cluster-admin",
}, },
} }
if _, err := client.RbacV1beta1().ClusterRoleBindings().Get(rbacName, metav1.GetOptions{}); err == nil { if _, err := client.RbacV1beta1().ClusterRoleBindings().Get(rbacName, meta.GetOptions{}); err == nil {
glog.Infof("Role binding %s already exists. Skipping creation.", rbacName) glog.Infof("Role binding %s already exists. Skipping creation.", rbacName)
return nil return nil
} }
@ -167,7 +166,7 @@ func updateKubeProxyConfigMap(k8s config.KubernetesConfig) error {
return errors.Wrap(err, "kube-proxy not running") return errors.Wrap(err, "kube-proxy not running")
} }
cfgMap, err := client.CoreV1().ConfigMaps("kube-system").Get("kube-proxy", metav1.GetOptions{}) cfgMap, err := client.CoreV1().ConfigMaps("kube-system").Get("kube-proxy", meta.GetOptions{})
if err != nil { if err != nil {
return &util.RetriableError{Err: errors.Wrap(err, "getting kube-proxy configmap")} return &util.RetriableError{Err: errors.Wrap(err, "getting kube-proxy configmap")}
} }
@ -206,7 +205,7 @@ func updateKubeProxyConfigMap(k8s config.KubernetesConfig) error {
return &util.RetriableError{Err: errors.Wrap(err, "updating configmap")} return &util.RetriableError{Err: errors.Wrap(err, "updating configmap")}
} }
pods, err := client.CoreV1().Pods("kube-system").List(metav1.ListOptions{ pods, err := client.CoreV1().Pods("kube-system").List(meta.ListOptions{
LabelSelector: "k8s-app=kube-proxy", LabelSelector: "k8s-app=kube-proxy",
}) })
if err != nil { if err != nil {
@ -214,7 +213,7 @@ func updateKubeProxyConfigMap(k8s config.KubernetesConfig) error {
} }
for _, pod := range pods.Items { for _, pod := range pods.Items {
// Retriable, as known to fail with: pods "<name>" not found // Retriable, as known to fail with: pods "<name>" not found
if err := client.CoreV1().Pods(pod.Namespace).Delete(pod.Name, &metav1.DeleteOptions{}); err != nil { if err := client.CoreV1().Pods(pod.Namespace).Delete(pod.Name, &meta.DeleteOptions{}); err != nil {
return &util.RetriableError{Err: errors.Wrapf(err, "deleting pod %+v", pod)} return &util.RetriableError{Err: errors.Wrapf(err, "deleting pod %+v", pod)}
} }
} }

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

@ -29,11 +29,11 @@ import (
"github.com/pkg/browser" "github.com/pkg/browser"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/spf13/viper" "github.com/spf13/viper"
v1 "k8s.io/api/core/v1" core "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" meta "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/kubernetes" "k8s.io/client-go/kubernetes"
corev1 "k8s.io/client-go/kubernetes/typed/core/v1" typed_core "k8s.io/client-go/kubernetes/typed/core/v1"
"k8s.io/client-go/tools/clientcmd" "k8s.io/client-go/tools/clientcmd"
clientcmdapi "k8s.io/client-go/tools/clientcmd/api" clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
"k8s.io/minikube/pkg/minikube/cluster" "k8s.io/minikube/pkg/minikube/cluster"
@ -45,7 +45,7 @@ import (
// K8sClient represents a kubernetes client // K8sClient represents a kubernetes client
type K8sClient interface { type K8sClient interface {
GetCoreClient() (corev1.CoreV1Interface, error) GetCoreClient() (typed_core.CoreV1Interface, error)
GetClientset(timeout time.Duration) (*kubernetes.Clientset, error) GetClientset(timeout time.Duration) (*kubernetes.Clientset, error)
} }
@ -60,7 +60,7 @@ func init() {
} }
// GetCoreClient returns a core client // GetCoreClient returns a core client
func (k *K8sClientGetter) GetCoreClient() (corev1.CoreV1Interface, error) { func (k *K8sClientGetter) GetCoreClient() (typed_core.CoreV1Interface, error) {
client, err := k.GetClientset(constants.DefaultK8sClientTimeout) client, err := k.GetClientset(constants.DefaultK8sClientTimeout)
if err != nil { if err != nil {
return nil, errors.Wrap(err, "getting clientset") return nil, errors.Wrap(err, "getting clientset")
@ -122,7 +122,7 @@ func GetServiceURLs(api libmachine.API, namespace string, t *template.Template)
serviceInterface := client.Services(namespace) serviceInterface := client.Services(namespace)
svcs, err := serviceInterface.List(metav1.ListOptions{}) svcs, err := serviceInterface.List(meta.ListOptions{})
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -160,19 +160,19 @@ func GetServiceURLsForService(api libmachine.API, namespace, service string, t *
return printURLsForService(client, ip, service, namespace, t) return printURLsForService(client, ip, service, namespace, t)
} }
func printURLsForService(c corev1.CoreV1Interface, ip, service, namespace string, t *template.Template) ([]string, error) { func printURLsForService(c typed_core.CoreV1Interface, ip, service, namespace string, t *template.Template) ([]string, error) {
if t == nil { if t == nil {
return nil, errors.New("Error, attempted to generate service url with nil --format template") return nil, errors.New("Error, attempted to generate service url with nil --format template")
} }
s := c.Services(namespace) s := c.Services(namespace)
svc, err := s.Get(service, metav1.GetOptions{}) svc, err := s.Get(service, meta.GetOptions{})
if err != nil { if err != nil {
return nil, errors.Wrapf(err, "service '%s' could not be found running", service) return nil, errors.Wrapf(err, "service '%s' could not be found running", service)
} }
e := c.Endpoints(namespace) e := c.Endpoints(namespace)
endpoints, err := e.Get(service, metav1.GetOptions{}) endpoints, err := e.Get(service, meta.GetOptions{})
m := make(map[int32]string) m := make(map[int32]string)
if err == nil && endpoints != nil && len(endpoints.Subsets) > 0 { if err == nil && endpoints != nil && len(endpoints.Subsets) > 0 {
for _, ept := range endpoints.Subsets { for _, ept := range endpoints.Subsets {
@ -211,7 +211,7 @@ func CheckService(namespace string, service string) error {
return errors.Wrap(err, "Error getting kubernetes client") return errors.Wrap(err, "Error getting kubernetes client")
} }
svc, err := client.Services(namespace).Get(service, metav1.GetOptions{}) svc, err := client.Services(namespace).Get(service, meta.GetOptions{})
if err != nil { if err != nil {
return &util.RetriableError{ return &util.RetriableError{
Err: errors.Wrapf(err, "Error getting service %s", service), Err: errors.Wrapf(err, "Error getting service %s", service),
@ -267,19 +267,19 @@ func WaitAndMaybeOpenService(api libmachine.API, namespace string, service strin
} }
// GetServiceListByLabel returns a ServiceList by label // GetServiceListByLabel returns a ServiceList by label
func GetServiceListByLabel(namespace string, key string, value string) (*v1.ServiceList, error) { func GetServiceListByLabel(namespace string, key string, value string) (*core.ServiceList, error) {
client, err := K8s.GetCoreClient() client, err := K8s.GetCoreClient()
if err != nil { if err != nil {
return &v1.ServiceList{}, &util.RetriableError{Err: err} return &core.ServiceList{}, &util.RetriableError{Err: err}
} }
return getServiceListFromServicesByLabel(client.Services(namespace), key, value) return getServiceListFromServicesByLabel(client.Services(namespace), key, value)
} }
func getServiceListFromServicesByLabel(services corev1.ServiceInterface, key string, value string) (*v1.ServiceList, error) { func getServiceListFromServicesByLabel(services typed_core.ServiceInterface, key string, value string) (*core.ServiceList, error) {
selector := labels.SelectorFromSet(labels.Set(map[string]string{key: value})) selector := labels.SelectorFromSet(labels.Set(map[string]string{key: value}))
serviceList, err := services.List(metav1.ListOptions{LabelSelector: selector.String()}) serviceList, err := services.List(meta.ListOptions{LabelSelector: selector.String()})
if err != nil { if err != nil {
return &v1.ServiceList{}, &util.RetriableError{Err: err} return &core.ServiceList{}, &util.RetriableError{Err: err}
} }
return serviceList, nil return serviceList, nil
@ -292,7 +292,7 @@ func CreateSecret(namespace, name string, dataValues map[string]string, labels m
return &util.RetriableError{Err: err} return &util.RetriableError{Err: err}
} }
secrets := client.Secrets(namespace) secrets := client.Secrets(namespace)
secret, _ := secrets.Get(name, metav1.GetOptions{}) secret, _ := secrets.Get(name, meta.GetOptions{})
// Delete existing secret // Delete existing secret
if len(secret.Name) > 0 { if len(secret.Name) > 0 {
@ -309,13 +309,13 @@ func CreateSecret(namespace, name string, dataValues map[string]string, labels m
} }
// Create Secret // Create Secret
secretObj := &v1.Secret{ secretObj := &core.Secret{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: meta.ObjectMeta{
Name: name, Name: name,
Labels: labels, Labels: labels,
}, },
Data: data, Data: data,
Type: v1.SecretTypeOpaque, Type: core.SecretTypeOpaque,
} }
_, err = secrets.Create(secretObj) _, err = secrets.Create(secretObj)
@ -334,7 +334,7 @@ func DeleteSecret(namespace, name string) error {
} }
secrets := client.Secrets(namespace) secrets := client.Secrets(namespace)
err = secrets.Delete(name, &metav1.DeleteOptions{}) err = secrets.Delete(name, &meta.DeleteOptions{})
if err != nil { if err != nil {
return &util.RetriableError{Err: err} return &util.RetriableError{Err: err}
} }

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

@ -27,22 +27,22 @@ import (
"github.com/docker/machine/libmachine" "github.com/docker/machine/libmachine"
"github.com/docker/machine/libmachine/host" "github.com/docker/machine/libmachine/host"
"github.com/pkg/errors" "github.com/pkg/errors"
v1 "k8s.io/api/core/v1" core "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" meta "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/client-go/kubernetes" "k8s.io/client-go/kubernetes"
corev1 "k8s.io/client-go/kubernetes/typed/core/v1" typed_core "k8s.io/client-go/kubernetes/typed/core/v1"
"k8s.io/client-go/kubernetes/typed/core/v1/fake" "k8s.io/client-go/kubernetes/typed/core/v1/fake"
"k8s.io/minikube/pkg/minikube/config" "k8s.io/minikube/pkg/minikube/config"
"k8s.io/minikube/pkg/minikube/tests" "k8s.io/minikube/pkg/minikube/tests"
) )
type MockClientGetter struct { type MockClientGetter struct {
servicesMap map[string]corev1.ServiceInterface servicesMap map[string]typed_core.ServiceInterface
endpointsMap map[string]corev1.EndpointsInterface endpointsMap map[string]typed_core.EndpointsInterface
} }
func (m *MockClientGetter) GetCoreClient() (corev1.CoreV1Interface, error) { func (m *MockClientGetter) GetCoreClient() (typed_core.CoreV1Interface, error) {
return &MockCoreClient{ return &MockCoreClient{
servicesMap: m.servicesMap, servicesMap: m.servicesMap,
endpointsMap: m.endpointsMap, endpointsMap: m.endpointsMap,
@ -55,24 +55,24 @@ func (m *MockClientGetter) GetClientset(timeout time.Duration) (*kubernetes.Clie
type MockCoreClient struct { type MockCoreClient struct {
fake.FakeCoreV1 fake.FakeCoreV1
servicesMap map[string]corev1.ServiceInterface servicesMap map[string]typed_core.ServiceInterface
endpointsMap map[string]corev1.EndpointsInterface endpointsMap map[string]typed_core.EndpointsInterface
} }
var serviceNamespaces = map[string]corev1.ServiceInterface{ var serviceNamespaces = map[string]typed_core.ServiceInterface{
"default": defaultNamespaceServiceInterface, "default": defaultNamespaceServiceInterface,
} }
var defaultNamespaceServiceInterface = &MockServiceInterface{ var defaultNamespaceServiceInterface = &MockServiceInterface{
ServiceList: &v1.ServiceList{ ServiceList: &core.ServiceList{
Items: []v1.Service{ Items: []core.Service{
{ {
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: meta.ObjectMeta{
Name: "mock-dashboard", Name: "mock-dashboard",
Namespace: "default", Namespace: "default",
}, },
Spec: v1.ServiceSpec{ Spec: core.ServiceSpec{
Ports: []v1.ServicePort{ Ports: []core.ServicePort{
{ {
NodePort: int32(1111), NodePort: int32(1111),
TargetPort: intstr.IntOrString{ TargetPort: intstr.IntOrString{
@ -89,44 +89,44 @@ var defaultNamespaceServiceInterface = &MockServiceInterface{
}, },
}, },
{ {
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: meta.ObjectMeta{
Name: "mock-dashboard-no-ports", Name: "mock-dashboard-no-ports",
Namespace: "default", Namespace: "default",
}, },
Spec: v1.ServiceSpec{ Spec: core.ServiceSpec{
Ports: []v1.ServicePort{}, Ports: []core.ServicePort{},
}, },
}, },
}, },
}, },
} }
var endpointNamespaces = map[string]corev1.EndpointsInterface{ var endpointNamespaces = map[string]typed_core.EndpointsInterface{
"default": defaultNamespaceEndpointInterface, "default": defaultNamespaceEndpointInterface,
} }
var defaultNamespaceEndpointInterface = &MockEndpointsInterface{} var defaultNamespaceEndpointInterface = &MockEndpointsInterface{}
func (m *MockCoreClient) Endpoints(namespace string) corev1.EndpointsInterface { func (m *MockCoreClient) Endpoints(namespace string) typed_core.EndpointsInterface {
return m.endpointsMap[namespace] return m.endpointsMap[namespace]
} }
func (m *MockCoreClient) Services(namespace string) corev1.ServiceInterface { func (m *MockCoreClient) Services(namespace string) typed_core.ServiceInterface {
return m.servicesMap[namespace] return m.servicesMap[namespace]
} }
type MockEndpointsInterface struct { type MockEndpointsInterface struct {
fake.FakeEndpoints fake.FakeEndpoints
Endpoints *v1.Endpoints Endpoints *core.Endpoints
} }
var endpointMap = map[string]*v1.Endpoints{ var endpointMap = map[string]*core.Endpoints{
"no-subsets": {}, "no-subsets": {},
"not-ready": { "not-ready": {
Subsets: []v1.EndpointSubset{ Subsets: []core.EndpointSubset{
{ {
Addresses: []v1.EndpointAddress{}, Addresses: []core.EndpointAddress{},
NotReadyAddresses: []v1.EndpointAddress{ NotReadyAddresses: []core.EndpointAddress{
{IP: "1.1.1.1"}, {IP: "1.1.1.1"},
{IP: "2.2.2.2"}, {IP: "2.2.2.2"},
}, },
@ -134,21 +134,21 @@ var endpointMap = map[string]*v1.Endpoints{
}, },
}, },
"one-ready": { "one-ready": {
Subsets: []v1.EndpointSubset{ Subsets: []core.EndpointSubset{
{ {
Addresses: []v1.EndpointAddress{ Addresses: []core.EndpointAddress{
{IP: "1.1.1.1"}, {IP: "1.1.1.1"},
}, },
NotReadyAddresses: []v1.EndpointAddress{ NotReadyAddresses: []core.EndpointAddress{
{IP: "2.2.2.2"}, {IP: "2.2.2.2"},
}, },
}, },
}, },
}, },
"mock-dashboard": { "mock-dashboard": {
Subsets: []v1.EndpointSubset{ Subsets: []core.EndpointSubset{
{ {
Ports: []v1.EndpointPort{ Ports: []core.EndpointPort{
{ {
Name: "port1", Name: "port1",
Port: int32(11111), Port: int32(11111),
@ -163,7 +163,7 @@ var endpointMap = map[string]*v1.Endpoints{
}, },
} }
func (e MockEndpointsInterface) Get(name string, _ metav1.GetOptions) (*v1.Endpoints, error) { func (e MockEndpointsInterface) Get(name string, _ meta.GetOptions) (*core.Endpoints, error) {
endpoint, ok := endpointMap[name] endpoint, ok := endpointMap[name]
if !ok { if !ok {
return nil, errors.New("Endpoint not found") return nil, errors.New("Endpoint not found")
@ -173,12 +173,12 @@ func (e MockEndpointsInterface) Get(name string, _ metav1.GetOptions) (*v1.Endpo
type MockServiceInterface struct { type MockServiceInterface struct {
fake.FakeServices fake.FakeServices
ServiceList *v1.ServiceList ServiceList *core.ServiceList
} }
func (s MockServiceInterface) List(opts metav1.ListOptions) (*v1.ServiceList, error) { func (s MockServiceInterface) List(opts meta.ListOptions) (*core.ServiceList, error) {
serviceList := &v1.ServiceList{ serviceList := &core.ServiceList{
Items: []v1.Service{}, Items: []core.Service{},
} }
if opts.LabelSelector != "" { if opts.LabelSelector != "" {
keyValArr := strings.Split(opts.LabelSelector, "=") keyValArr := strings.Split(opts.LabelSelector, "=")
@ -195,7 +195,7 @@ func (s MockServiceInterface) List(opts metav1.ListOptions) (*v1.ServiceList, er
return s.ServiceList, nil return s.ServiceList, nil
} }
func (s MockServiceInterface) Get(name string, _ metav1.GetOptions) (*v1.Service, error) { func (s MockServiceInterface) Get(name string, _ meta.GetOptions) (*core.Service, error) {
for _, svc := range s.ServiceList.Items { for _, svc := range s.ServiceList.Items {
if svc.ObjectMeta.Name == name { if svc.ObjectMeta.Name == name {
return &svc, nil return &svc, nil
@ -206,10 +206,10 @@ func (s MockServiceInterface) Get(name string, _ metav1.GetOptions) (*v1.Service
} }
func TestGetServiceListFromServicesByLabel(t *testing.T) { func TestGetServiceListFromServicesByLabel(t *testing.T) {
serviceList := &v1.ServiceList{ serviceList := &core.ServiceList{
Items: []v1.Service{ Items: []core.Service{
{ {
Spec: v1.ServiceSpec{ Spec: core.ServiceSpec{
Selector: map[string]string{ Selector: map[string]string{
"foo": "bar", "foo": "bar",
}, },

26
pkg/storage/storage_provisioner.go
View File

@ -24,13 +24,13 @@ import (
"github.com/golang/glog" "github.com/golang/glog"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/r2d4/external-storage/lib/controller" "github.com/r2d4/external-storage/lib/controller"
v1 "k8s.io/api/core/v1" core "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" meta "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/uuid" "k8s.io/apimachinery/pkg/util/uuid"
"k8s.io/apimachinery/pkg/util/wait" "k8s.io/apimachinery/pkg/util/wait"
"k8s.io/client-go/kubernetes" "k8s.io/client-go/kubernetes"
restclient "k8s.io/client-go/rest" "k8s.io/client-go/rest"
) )
const provisionerName = "k8s.io/minikube-hostpath" const provisionerName = "k8s.io/minikube-hostpath"
@ -55,7 +55,7 @@ func NewHostPathProvisioner() controller.Provisioner {
var _ controller.Provisioner = &hostPathProvisioner{} var _ controller.Provisioner = &hostPathProvisioner{}
// Provision creates a storage asset and returns a PV object representing it. // Provision creates a storage asset and returns a PV object representing it.
func (p *hostPathProvisioner) Provision(options controller.VolumeOptions) (*v1.PersistentVolume, error) { func (p *hostPathProvisioner) Provision(options controller.VolumeOptions) (*core.PersistentVolume, error) {
glog.Infof("Provisioning volume %v", options) glog.Infof("Provisioning volume %v", options)
path := path.Join(p.pvDir, options.PVName) path := path.Join(p.pvDir, options.PVName)
if err := os.MkdirAll(path, 0777); err != nil { if err := os.MkdirAll(path, 0777); err != nil {
@ -67,21 +67,21 @@ func (p *hostPathProvisioner) Provision(options controller.VolumeOptions) (*v1.P
return nil, err return nil, err
} }
pv := &v1.PersistentVolume{ pv := &core.PersistentVolume{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: meta.ObjectMeta{
Name: options.PVName, Name: options.PVName,
Annotations: map[string]string{ Annotations: map[string]string{
"hostPathProvisionerIdentity": string(p.identity), "hostPathProvisionerIdentity": string(p.identity),
}, },
}, },
Spec: v1.PersistentVolumeSpec{ Spec: core.PersistentVolumeSpec{
PersistentVolumeReclaimPolicy: options.PersistentVolumeReclaimPolicy, PersistentVolumeReclaimPolicy: options.PersistentVolumeReclaimPolicy,
AccessModes: options.PVC.Spec.AccessModes, AccessModes: options.PVC.Spec.AccessModes,
Capacity: v1.ResourceList{ Capacity: core.ResourceList{
v1.ResourceStorage: options.PVC.Spec.Resources.Requests[v1.ResourceStorage], core.ResourceStorage: options.PVC.Spec.Resources.Requests[core.ResourceStorage],
}, },
PersistentVolumeSource: v1.PersistentVolumeSource{ PersistentVolumeSource: core.PersistentVolumeSource{
HostPath: &v1.HostPathVolumeSource{ HostPath: &core.HostPathVolumeSource{
Path: path, Path: path,
}, },
}, },
@ -93,7 +93,7 @@ func (p *hostPathProvisioner) Provision(options controller.VolumeOptions) (*v1.P
// Delete removes the storage asset that was created by Provision represented // Delete removes the storage asset that was created by Provision represented
// by the given PV. // by the given PV.
func (p *hostPathProvisioner) Delete(volume *v1.PersistentVolume) error { func (p *hostPathProvisioner) Delete(volume *core.PersistentVolume) error {
glog.Infof("Deleting volume %v", volume) glog.Infof("Deleting volume %v", volume)
ann, ok := volume.Annotations["hostPathProvisionerIdentity"] ann, ok := volume.Annotations["hostPathProvisionerIdentity"]
if !ok { if !ok {
@ -114,7 +114,7 @@ func (p *hostPathProvisioner) Delete(volume *v1.PersistentVolume) error {
// StartStorageProvisioner will start storage provisioner server // StartStorageProvisioner will start storage provisioner server
func StartStorageProvisioner() error { func StartStorageProvisioner() error {
glog.Infof("Initializing the Minikube storage provisioner...") glog.Infof("Initializing the Minikube storage provisioner...")
config, err := restclient.InClusterConfig() config, err := rest.InClusterConfig()
if err != nil { if err != nil {
return err return err
} }

52
pkg/util/kubernetes.go
View File

@ -22,10 +22,10 @@ import (
"github.com/golang/glog" "github.com/golang/glog"
"github.com/pkg/errors" "github.com/pkg/errors"
appsv1 "k8s.io/api/apps/v1" apps "k8s.io/api/apps/v1"
v1 "k8s.io/api/core/v1" core "k8s.io/api/core/v1"
apierrs "k8s.io/apimachinery/pkg/api/errors" apierr "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" meta "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/fields" "k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime"
@ -53,11 +53,11 @@ type PodStore struct {
} }
// List lists the pods // List lists the pods
func (s *PodStore) List() []*v1.Pod { func (s *PodStore) List() []*core.Pod {
objects := s.Store.List() objects := s.Store.List()
pods := make([]*v1.Pod, 0) pods := make([]*core.Pod, 0)
for _, o := range objects { for _, o := range objects {
pods = append(pods, o.(*v1.Pod)) pods = append(pods, o.(*core.Pod))
} }
return pods return pods
} }
@ -86,13 +86,13 @@ func GetClient() (kubernetes.Interface, error) {
// NewPodStore creates a new PodStore // NewPodStore creates a new PodStore
func NewPodStore(c kubernetes.Interface, namespace string, label fmt.Stringer, field fmt.Stringer) *PodStore { func NewPodStore(c kubernetes.Interface, namespace string, label fmt.Stringer, field fmt.Stringer) *PodStore {
lw := &cache.ListWatch{ lw := &cache.ListWatch{
ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { ListFunc: func(options meta.ListOptions) (runtime.Object, error) {
options.LabelSelector = label.String() options.LabelSelector = label.String()
options.FieldSelector = field.String() options.FieldSelector = field.String()
obj, err := c.CoreV1().Pods(namespace).List(options) obj, err := c.CoreV1().Pods(namespace).List(options)
return runtime.Object(obj), err return runtime.Object(obj), err
}, },
WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { WatchFunc: func(options meta.ListOptions) (watch.Interface, error) {
options.LabelSelector = label.String() options.LabelSelector = label.String()
options.FieldSelector = field.String() options.FieldSelector = field.String()
return c.CoreV1().Pods(namespace).Watch(options) return c.CoreV1().Pods(namespace).Watch(options)
@ -100,13 +100,13 @@ func NewPodStore(c kubernetes.Interface, namespace string, label fmt.Stringer, f
} }
store := cache.NewStore(cache.MetaNamespaceKeyFunc) store := cache.NewStore(cache.MetaNamespaceKeyFunc)
stopCh := make(chan struct{}) stopCh := make(chan struct{})
reflector := cache.NewReflector(lw, &v1.Pod{}, store, 0) reflector := cache.NewReflector(lw, &core.Pod{}, store, 0)
go reflector.Run(stopCh) go reflector.Run(stopCh)
return &PodStore{Store: store, stopCh: stopCh, Reflector: reflector} return &PodStore{Store: store, stopCh: stopCh, Reflector: reflector}
} }
// StartPods starts all pods // StartPods starts all pods
func StartPods(c kubernetes.Interface, namespace string, pod v1.Pod, waitForRunning bool) error { func StartPods(c kubernetes.Interface, namespace string, pod core.Pod, waitForRunning bool) error {
pod.ObjectMeta.Labels["name"] = pod.Name pod.ObjectMeta.Labels["name"] = pod.Name
if waitForRunning { if waitForRunning {
label := labels.SelectorFromSet(labels.Set(map[string]string{"name": pod.Name})) label := labels.SelectorFromSet(labels.Set(map[string]string{"name": pod.Name}))
@ -123,7 +123,7 @@ func WaitForPodsWithLabelRunning(c kubernetes.Interface, ns string, label labels
glog.Infof("Waiting for pod with label %q in ns %q ...", ns, label) glog.Infof("Waiting for pod with label %q in ns %q ...", ns, label)
lastKnownPodNumber := -1 lastKnownPodNumber := -1
return wait.PollImmediate(constants.APICallRetryInterval, ReasonableStartTime, func() (bool, error) { return wait.PollImmediate(constants.APICallRetryInterval, ReasonableStartTime, func() (bool, error) {
listOpts := metav1.ListOptions{LabelSelector: label.String()} listOpts := meta.ListOptions{LabelSelector: label.String()}
pods, err := c.CoreV1().Pods(ns).List(listOpts) pods, err := c.CoreV1().Pods(ns).List(listOpts)
if err != nil { if err != nil {
glog.Infof("error getting Pods with label selector %q [%v]\n", label.String(), err) glog.Infof("error getting Pods with label selector %q [%v]\n", label.String(), err)
@ -140,7 +140,7 @@ func WaitForPodsWithLabelRunning(c kubernetes.Interface, ns string, label labels
} }
for _, pod := range pods.Items { for _, pod := range pods.Items {
if pod.Status.Phase != v1.PodRunning { if pod.Status.Phase != core.PodRunning {
return false, nil return false, nil
} }
} }
@ -152,7 +152,7 @@ func WaitForPodsWithLabelRunning(c kubernetes.Interface, ns string, label labels
// WaitForPodDelete waits for a pod to be deleted // WaitForPodDelete waits for a pod to be deleted
func WaitForPodDelete(c kubernetes.Interface, ns string, label fmt.Stringer) error { func WaitForPodDelete(c kubernetes.Interface, ns string, label fmt.Stringer) error {
return wait.PollImmediate(constants.APICallRetryInterval, ReasonableMutateTime, func() (bool, error) { return wait.PollImmediate(constants.APICallRetryInterval, ReasonableMutateTime, func() (bool, error) {
listOpts := metav1.ListOptions{LabelSelector: label.String()} listOpts := meta.ListOptions{LabelSelector: label.String()}
pods, err := c.CoreV1().Pods(ns).List(listOpts) pods, err := c.CoreV1().Pods(ns).List(listOpts)
if err != nil { if err != nil {
glog.Infof("error getting Pods with label selector %q [%v]\n", label.String(), err) glog.Infof("error getting Pods with label selector %q [%v]\n", label.String(), err)
@ -165,7 +165,7 @@ func WaitForPodDelete(c kubernetes.Interface, ns string, label fmt.Stringer) err
// WaitForEvent waits for the given event to appear // WaitForEvent waits for the given event to appear
func WaitForEvent(c kubernetes.Interface, ns string, reason string) error { func WaitForEvent(c kubernetes.Interface, ns string, reason string) error {
return wait.PollImmediate(constants.APICallRetryInterval, ReasonableMutateTime, func() (bool, error) { return wait.PollImmediate(constants.APICallRetryInterval, ReasonableMutateTime, func() (bool, error) {
events, err := c.EventsV1beta1().Events("default").List(metav1.ListOptions{}) events, err := c.EventsV1beta1().Events("default").List(meta.ListOptions{})
if err != nil { if err != nil {
glog.Infof("error getting events: %v", err) glog.Infof("error getting events: %v", err)
return false, nil return false, nil
@ -181,7 +181,7 @@ func WaitForEvent(c kubernetes.Interface, ns string, reason string) error {
// WaitForRCToStabilize waits till the RC has a matching generation/replica count between spec and status. // WaitForRCToStabilize waits till the RC has a matching generation/replica count between spec and status.
func WaitForRCToStabilize(c kubernetes.Interface, ns, name string, timeout time.Duration) error { func WaitForRCToStabilize(c kubernetes.Interface, ns, name string, timeout time.Duration) error {
options := metav1.ListOptions{FieldSelector: fields.Set{ options := meta.ListOptions{FieldSelector: fields.Set{
"metadata.name": name, "metadata.name": name,
"metadata.namespace": ns, "metadata.namespace": ns,
}.AsSelector().String()} }.AsSelector().String()}
@ -191,10 +191,10 @@ func WaitForRCToStabilize(c kubernetes.Interface, ns, name string, timeout time.
} }
_, err = watch.Until(timeout, w, func(event watch.Event) (bool, error) { _, err = watch.Until(timeout, w, func(event watch.Event) (bool, error) {
if event.Type == watch.Deleted { if event.Type == watch.Deleted {
return false, apierrs.NewNotFound(schema.GroupResource{Resource: "replicationcontrollers"}, "") return false, apierr.NewNotFound(schema.GroupResource{Resource: "replicationcontrollers"}, "")
} }
rc, ok := event.Object.(*v1.ReplicationController) rc, ok := event.Object.(*core.ReplicationController)
if ok { if ok {
if rc.Name == name && rc.Namespace == ns && if rc.Name == name && rc.Namespace == ns &&
rc.Generation <= rc.Status.ObservedGeneration && rc.Generation <= rc.Status.ObservedGeneration &&
@ -211,7 +211,7 @@ func WaitForRCToStabilize(c kubernetes.Interface, ns, name string, timeout time.
// WaitForDeploymentToStabilize waits till the Deployment has a matching generation/replica count between spec and status. // WaitForDeploymentToStabilize waits till the Deployment has a matching generation/replica count between spec and status.
func WaitForDeploymentToStabilize(c kubernetes.Interface, ns, name string, timeout time.Duration) error { func WaitForDeploymentToStabilize(c kubernetes.Interface, ns, name string, timeout time.Duration) error {
options := metav1.ListOptions{FieldSelector: fields.Set{ options := meta.ListOptions{FieldSelector: fields.Set{
"metadata.name": name, "metadata.name": name,
"metadata.namespace": ns, "metadata.namespace": ns,
}.AsSelector().String()} }.AsSelector().String()}
@ -221,9 +221,9 @@ func WaitForDeploymentToStabilize(c kubernetes.Interface, ns, name string, timeo
} }
_, err = watch.Until(timeout, w, func(event watch.Event) (bool, error) { _, err = watch.Until(timeout, w, func(event watch.Event) (bool, error) {
if event.Type == watch.Deleted { if event.Type == watch.Deleted {
return false, apierrs.NewNotFound(schema.GroupResource{Resource: "deployments"}, "") return false, apierr.NewNotFound(schema.GroupResource{Resource: "deployments"}, "")
} }
dp, ok := event.Object.(*appsv1.Deployment) dp, ok := event.Object.(*apps.Deployment)
if ok { if ok {
if dp.Name == name && dp.Namespace == ns && if dp.Name == name && dp.Namespace == ns &&
dp.Generation <= dp.Status.ObservedGeneration && dp.Generation <= dp.Status.ObservedGeneration &&
@ -241,12 +241,12 @@ func WaitForDeploymentToStabilize(c kubernetes.Interface, ns, name string, timeo
// WaitForService waits until the service appears (exist == true), or disappears (exist == false) // WaitForService waits until the service appears (exist == true), or disappears (exist == false)
func WaitForService(c kubernetes.Interface, namespace, name string, exist bool, interval, timeout time.Duration) error { func WaitForService(c kubernetes.Interface, namespace, name string, exist bool, interval, timeout time.Duration) error {
err := wait.PollImmediate(interval, timeout, func() (bool, error) { err := wait.PollImmediate(interval, timeout, func() (bool, error) {
_, err := c.CoreV1().Services(namespace).Get(name, metav1.GetOptions{}) _, err := c.CoreV1().Services(namespace).Get(name, meta.GetOptions{})
switch { switch {
case err == nil: case err == nil:
glog.Infof("Service %s in namespace %s found.", name, namespace) glog.Infof("Service %s in namespace %s found.", name, namespace)
return exist, nil return exist, nil
case apierrs.IsNotFound(err): case apierr.IsNotFound(err):
glog.Infof("Service %s in namespace %s disappeared.", name, namespace) glog.Infof("Service %s in namespace %s disappeared.", name, namespace)
return !exist, nil return !exist, nil
case !IsRetryableAPIError(err): case !IsRetryableAPIError(err):
@ -268,7 +268,7 @@ func WaitForService(c kubernetes.Interface, namespace, name string, exist bool,
func WaitForServiceEndpointsNum(c kubernetes.Interface, namespace, serviceName string, expectNum int, interval, timeout time.Duration) error { func WaitForServiceEndpointsNum(c kubernetes.Interface, namespace, serviceName string, expectNum int, interval, timeout time.Duration) error {
return wait.Poll(interval, timeout, func() (bool, error) { return wait.Poll(interval, timeout, func() (bool, error) {
glog.Infof("Waiting for amount of service:%s endpoints to be %d", serviceName, expectNum) glog.Infof("Waiting for amount of service:%s endpoints to be %d", serviceName, expectNum)
list, err := c.CoreV1().Endpoints(namespace).List(metav1.ListOptions{}) list, err := c.CoreV1().Endpoints(namespace).List(meta.ListOptions{})
if err != nil { if err != nil {
return false, err return false, err
} }
@ -282,7 +282,7 @@ func WaitForServiceEndpointsNum(c kubernetes.Interface, namespace, serviceName s
}) })
} }
func countEndpointsNum(e *v1.Endpoints) int { func countEndpointsNum(e *core.Endpoints) int {
num := 0 num := 0
for _, sub := range e.Subsets { for _, sub := range e.Subsets {
num += len(sub.Addresses) num += len(sub.Addresses)
@ -292,5 +292,5 @@ func countEndpointsNum(e *v1.Endpoints) int {
// IsRetryableAPIError returns if this error is retryable or not // IsRetryableAPIError returns if this error is retryable or not
func IsRetryableAPIError(err error) bool { func IsRetryableAPIError(err error) bool {
return apierrs.IsTimeout(err) || apierrs.IsServerTimeout(err) || apierrs.IsTooManyRequests(err) || apierrs.IsInternalError(err) return apierr.IsTimeout(err) || apierr.IsServerTimeout(err) || apierr.IsTooManyRequests(err) || apierr.IsInternalError(err)
} }

4
test/integration/pv_test.go
View File

@ -26,7 +26,7 @@ import (
"github.com/pkg/errors" "github.com/pkg/errors"
api "k8s.io/api/core/v1" core "k8s.io/api/core/v1"
storage "k8s.io/api/storage/v1" storage "k8s.io/api/storage/v1"
"k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/labels"
commonutil "k8s.io/minikube/pkg/util" commonutil "k8s.io/minikube/pkg/util"
@ -94,7 +94,7 @@ func testProvisioning(t *testing.T) {
// And check that it gets bound to a PV. // And check that it gets bound to a PV.
checkStorage := func() error { checkStorage := func() error {
pvc := api.PersistentVolumeClaim{} pvc := core.PersistentVolumeClaim{}
if err := kubectlRunner.RunCommandParseOutput(pvcCmd, &pvc); err != nil { if err := kubectlRunner.RunCommandParseOutput(pvcCmd, &pvc); err != nil {
return err return err
} }