Use k8s.io/client-go

nginx-controller/controller/utils.go

@@ -20,11 +20,13 @@ import (
 	"fmt"
 	"time"
 
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/apis/extensions"
-	"k8s.io/kubernetes/pkg/client/cache"
-	"k8s.io/kubernetes/pkg/util/wait"
-	"k8s.io/kubernetes/pkg/util/workqueue"
+	"k8s.io/apimachinery/pkg/util/intstr"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/client-go/tools/cache"
+	"k8s.io/client-go/util/workqueue"
+
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	extensions "k8s.io/client-go/pkg/apis/extensions/v1beta1"
 
 	"github.com/golang/glog"
 )
@@ -119,7 +121,7 @@ func (s *StoreToIngressLister) List() (ing extensions.IngressList, err error) {
 
 // GetServiceIngress gets all the Ingress' that have rules pointing to a service.
 // Note that this ignores services without the right nodePorts.
-func (s *StoreToIngressLister) GetServiceIngress(svc *api.Service) (ings []extensions.Ingress, err error) {
+func (s *StoreToIngressLister) GetServiceIngress(svc *api_v1.Service) (ings []extensions.Ingress, err error) {
 	for _, m := range s.Store.List() {
 		ing := *m.(*extensions.Ingress)
 		if ing.Namespace != svc.Namespace {
@@ -153,9 +155,49 @@ type StoreToConfigMapLister struct {
 }
 
 // List lists all Ingress' in the store.
-func (s *StoreToConfigMapLister) List() (cfgm api.ConfigMapList, err error) {
+func (s *StoreToConfigMapLister) List() (cfgm api_v1.ConfigMapList, err error) {
 	for _, m := range s.Store.List() {
-		cfgm.Items = append(cfgm.Items, *(m.(*api.ConfigMap)))
+		cfgm.Items = append(cfgm.Items, *(m.(*api_v1.ConfigMap)))
 	}
 	return cfgm, nil
 }
+
+// StoreToEndpointLister makes a Store that lists Endponts
+type StoreToEndpointLister struct {
+	cache.Store
+}
+
+// GetServiceEndpoints returns the endpoints of a service, matched on service name.
+func (s *StoreToEndpointLister) GetServiceEndpoints(svc *api_v1.Service) (ep api_v1.Endpoints, err error) {
+	for _, m := range s.Store.List() {
+		ep = *m.(*api_v1.Endpoints)
+		if svc.Name == ep.Name && svc.Namespace == ep.Namespace {
+			return ep, nil
+		}
+	}
+	err = fmt.Errorf("could not find endpoints for service: %v", svc.Name)
+	return
+}
+
+// FindPort locates the container port for the given pod and portName.  If the
+// targetPort is a number, use that.  If the targetPort is a string, look that
+// string up in all named ports in all containers in the target pod.  If no
+// match is found, fail.
+func FindPort(pod *api_v1.Pod, svcPort *api_v1.ServicePort) (int32, error) {
+	portName := svcPort.TargetPort
+	switch portName.Type {
+	case intstr.String:
+		name := portName.StrVal
+		for _, container := range pod.Spec.Containers {
+			for _, port := range container.Ports {
+				if port.Name == name && port.Protocol == svcPort.Protocol {
+					return port.ContainerPort, nil
+				}
+			}
+		}
+	case intstr.Int:
+		return int32(portName.IntValue()), nil
+	}
+
+	return 0, fmt.Errorf("no suitable port for manifest: %s", pod.UID)
+}

nginx-controller/main.go

@@ -8,8 +8,11 @@ import (
 
 	"github.com/nginxinc/kubernetes-ingress/nginx-controller/controller"
 	"github.com/nginxinc/kubernetes-ingress/nginx-controller/nginx"
-	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/pkg/api"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
 )
 
 var (
@@ -37,29 +40,38 @@ var (
 
 func main() {
 	flag.Parse()
+	flag.Lookup("logtostderr").Value.Set("true")
 
 	glog.Infof("Starting NGINX Ingress controller Version %v\n", version)
 
-	var kubeClient *client.Client
-	var local = false
-
+	var err error
+	var config *rest.Config
 	if *proxyURL != "" {
-		kubeClient = client.NewOrDie(&client.Config{
-			Host: *proxyURL,
-		})
-		local = true
-	} else {
-		var err error
-		kubeClient, err = client.NewInCluster()
+		config, err = clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
+			&clientcmd.ClientConfigLoadingRules{},
+			&clientcmd.ConfigOverrides{
+				ClusterInfo: clientcmdapi.Cluster{
+					Server: *proxyURL,
+				},
+			}).ClientConfig()
 		if err != nil {
-			glog.Fatalf("Failed to create client: %v.", err)
+			glog.Fatalf("error creating client configuration: %v", err)
+		}
+	} else {
+		if config, err = rest.InClusterConfig(); err != nil {
+			glog.Fatalf("error creating client configuration: %v", err)
 		}
 	}
 
-	ngxc, _ := nginx.NewNginxController("/etc/nginx/", local, *healthStatus)
+	kubeClient, err := kubernetes.NewForConfig(config)
+	if err != nil {
+		glog.Fatalf("Failed to create client: %v.", err)
+	}
+
+	ngxc, _ := nginx.NewNginxController("/etc/nginx/", *proxyURL != "", *healthStatus)
 	ngxc.Start()
-	config := nginx.NewDefaultConfig()
-	cnf := nginx.NewConfigurator(ngxc, config)
+	nginxConfig := nginx.NewDefaultConfig()
+	cnf := nginx.NewConfigurator(ngxc, nginxConfig)
 	lbc, _ := controller.NewLoadBalancerController(kubeClient, 30*time.Second, *watchNamespace, cnf, *nginxConfigMaps)
 	lbc.Run()
 }

nginx-controller/nginx/configurator.go

@@ -6,8 +6,8 @@ import (
 	"sync"
 
 	"github.com/golang/glog"
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/apis/extensions"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	extensions "k8s.io/client-go/pkg/apis/extensions/v1beta1"
 )
 
 const emptyHost = ""
@@ -55,12 +55,12 @@ func (cnf *Configurator) updateCertificates(ingEx *IngressEx) map[string]string
 		if !exist {
 			continue
 		}
-		cert, ok := secret.Data[api.TLSCertKey]
+		cert, ok := secret.Data[api_v1.TLSCertKey]
 		if !ok {
 			glog.Warningf("Secret %v has no cert", secretName)
 			continue
 		}
-		key, ok := secret.Data[api.TLSPrivateKeyKey]
+		key, ok := secret.Data[api_v1.TLSPrivateKeyKey]
 		if !ok {
 			glog.Warningf("Secret %v has no private key", secretName)
 			continue

nginx-controller/nginx/convert.go

@@ -5,14 +5,14 @@ import (
 	"strconv"
 	"strings"
 
-	"k8s.io/kubernetes/pkg/api/meta"
-	"k8s.io/kubernetes/pkg/runtime"
+	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
 )
 
 // There seems to be no composite interface in the kubernetes api package,
 // so we have to declare our own.
 type apiObject interface {
-	meta.Object
+	meta_v1.Object
 	runtime.Object
 }
 

nginx-controller/nginx/convert_test.go

@@ -4,27 +4,27 @@ import (
 	"reflect"
 	"testing"
 
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/unversioned"
-	"k8s.io/kubernetes/pkg/apis/extensions"
+	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	extensions "k8s.io/client-go/pkg/apis/extensions/v1beta1"
 )
 
-var configMap = api.ConfigMap{
-	ObjectMeta: api.ObjectMeta{
+var configMap = api_v1.ConfigMap{
+	ObjectMeta: meta_v1.ObjectMeta{
 		Name:      "test",
 		Namespace: "default",
 	},
-	TypeMeta: unversioned.TypeMeta{
+	TypeMeta: meta_v1.TypeMeta{
 		Kind:       "ConfigMap",
 		APIVersion: "v1",
 	},
 }
 var ingress = extensions.Ingress{
-	ObjectMeta: api.ObjectMeta{
+	ObjectMeta: meta_v1.ObjectMeta{
 		Name:      "test",
 		Namespace: "kube-system",
 	},
-	TypeMeta: unversioned.TypeMeta{
+	TypeMeta: meta_v1.TypeMeta{
 		Kind:       "Ingress",
 		APIVersion: "extensions/v1beta1",
 	},

nginx-controller/nginx/ingress.go

@@ -1,12 +1,14 @@
 package nginx
 
-import "k8s.io/kubernetes/pkg/api"
-import "k8s.io/kubernetes/pkg/apis/extensions"
+import (
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	extensions "k8s.io/client-go/pkg/apis/extensions/v1beta1"
+)
 
 // IngressEx holds an Ingress along with Secrets and Endpoints of the services
 // that are referenced in this Ingress
 type IngressEx struct {
 	Ingress   *extensions.Ingress
-	Secrets   map[string]*api.Secret
+	Secrets   map[string]*api_v1.Secret
 	Endpoints map[string][]string
 }