add service mesh controller

add service mesh metrics

remove unused circle yaml

fix travis misconfiguration

fix travis misconfiguration

fix travis misconfiguration

vendor/k8s.io/client-go/discovery/cached_discovery.go

@@ -25,8 +25,8 @@ import (
 	"sync"
 	"time"
 
-	"github.com/golang/glog"
 	"github.com/googleapis/gnostic/OpenAPIv2"
+	"k8s.io/klog"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -67,23 +67,23 @@ func (d *CachedDiscoveryClient) ServerResourcesForGroupVersion(groupVersion stri
 	if err == nil {
 		cachedResources := &metav1.APIResourceList{}
 		if err := runtime.DecodeInto(scheme.Codecs.UniversalDecoder(), cachedBytes, cachedResources); err == nil {
-			glog.V(10).Infof("returning cached discovery info from %v", filename)
+			klog.V(10).Infof("returning cached discovery info from %v", filename)
 			return cachedResources, nil
 		}
 	}
 
 	liveResources, err := d.delegate.ServerResourcesForGroupVersion(groupVersion)
 	if err != nil {
-		glog.V(3).Infof("skipped caching discovery info due to %v", err)
+		klog.V(3).Infof("skipped caching discovery info due to %v", err)
 		return liveResources, err
 	}
 	if liveResources == nil || len(liveResources.APIResources) == 0 {
-		glog.V(3).Infof("skipped caching discovery info, no resources found")
+		klog.V(3).Infof("skipped caching discovery info, no resources found")
 		return liveResources, err
 	}
 
 	if err := d.writeCachedFile(filename, liveResources); err != nil {
-		glog.V(1).Infof("failed to write cache to %v due to %v", filename, err)
+		klog.V(1).Infof("failed to write cache to %v due to %v", filename, err)
 	}
 
 	return liveResources, nil
@@ -94,6 +94,8 @@ func (d *CachedDiscoveryClient) ServerResources() ([]*metav1.APIResourceList, er
 	return ServerResources(d)
 }
 
+// ServerGroups returns the supported groups, with information like supported versions and the
+// preferred version.
 func (d *CachedDiscoveryClient) ServerGroups() (*metav1.APIGroupList, error) {
 	filename := filepath.Join(d.cacheDirectory, "servergroups.json")
 	cachedBytes, err := d.getCachedFile(filename)
@@ -101,23 +103,23 @@ func (d *CachedDiscoveryClient) ServerGroups() (*metav1.APIGroupList, error) {
 	if err == nil {
 		cachedGroups := &metav1.APIGroupList{}
 		if err := runtime.DecodeInto(scheme.Codecs.UniversalDecoder(), cachedBytes, cachedGroups); err == nil {
-			glog.V(10).Infof("returning cached discovery info from %v", filename)
+			klog.V(10).Infof("returning cached discovery info from %v", filename)
 			return cachedGroups, nil
 		}
 	}
 
 	liveGroups, err := d.delegate.ServerGroups()
 	if err != nil {
-		glog.V(3).Infof("skipped caching discovery info due to %v", err)
+		klog.V(3).Infof("skipped caching discovery info due to %v", err)
 		return liveGroups, err
 	}
 	if liveGroups == nil || len(liveGroups.Groups) == 0 {
-		glog.V(3).Infof("skipped caching discovery info, no groups found")
+		klog.V(3).Infof("skipped caching discovery info, no groups found")
 		return liveGroups, err
 	}
 
 	if err := d.writeCachedFile(filename, liveGroups); err != nil {
-		glog.V(1).Infof("failed to write cache to %v due to %v", filename, err)
+		klog.V(1).Infof("failed to write cache to %v due to %v", filename, err)
 	}
 
 	return liveGroups, nil
@@ -202,26 +204,36 @@ func (d *CachedDiscoveryClient) writeCachedFile(filename string, obj runtime.Obj
 	return err
 }
 
+// RESTClient returns a RESTClient that is used to communicate with API server
+// by this client implementation.
 func (d *CachedDiscoveryClient) RESTClient() restclient.Interface {
 	return d.delegate.RESTClient()
 }
 
+// ServerPreferredResources returns the supported resources with the version preferred by the
+// server.
 func (d *CachedDiscoveryClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
 	return ServerPreferredResources(d)
 }
 
+// ServerPreferredNamespacedResources returns the supported namespaced resources with the
+// version preferred by the server.
 func (d *CachedDiscoveryClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
 	return ServerPreferredNamespacedResources(d)
 }
 
+// ServerVersion retrieves and parses the server's version (git version).
 func (d *CachedDiscoveryClient) ServerVersion() (*version.Info, error) {
 	return d.delegate.ServerVersion()
 }
 
+// OpenAPISchema retrieves and parses the swagger API schema the server supports.
 func (d *CachedDiscoveryClient) OpenAPISchema() (*openapi_v2.Document, error) {
 	return d.delegate.OpenAPISchema()
 }
 
+// Fresh is supposed to tell the caller whether or not to retry if the cache
+// fails to find something (false = retry, true = no need to retry).
 func (d *CachedDiscoveryClient) Fresh() bool {
 	d.mutex.Lock()
 	defer d.mutex.Unlock()
@@ -229,6 +241,7 @@ func (d *CachedDiscoveryClient) Fresh() bool {
 	return d.fresh
 }
 
+// Invalidate enforces that no cached data is used in the future that is older than the current time.
 func (d *CachedDiscoveryClient) Invalidate() {
 	d.mutex.Lock()
 	defer d.mutex.Unlock()

vendor/k8s.io/client-go/discovery/discovery_client.go

@@ -263,8 +263,8 @@ func ServerPreferredResources(d DiscoveryInterface) ([]*metav1.APIResourceList,
 
 	result := []*metav1.APIResourceList{}
 	grVersions := map[schema.GroupResource]string{}                         // selected version of a GroupResource
-	grApiResources := map[schema.GroupResource]*metav1.APIResource{}        // selected APIResource for a GroupResource
-	gvApiResourceLists := map[schema.GroupVersion]*metav1.APIResourceList{} // blueprint for a APIResourceList for later grouping
+	grAPIResources := map[schema.GroupResource]*metav1.APIResource{}        // selected APIResource for a GroupResource
+	gvAPIResourceLists := map[schema.GroupVersion]*metav1.APIResourceList{} // blueprint for a APIResourceList for later grouping
 
 	for _, apiGroup := range serverGroupList.Groups {
 		for _, version := range apiGroup.Versions {
@@ -276,11 +276,11 @@ func ServerPreferredResources(d DiscoveryInterface) ([]*metav1.APIResourceList,
 			}
 
 			// create empty list which is filled later in another loop
-			emptyApiResourceList := metav1.APIResourceList{
+			emptyAPIResourceList := metav1.APIResourceList{
 				GroupVersion: version.GroupVersion,
 			}
-			gvApiResourceLists[groupVersion] = &emptyApiResourceList
-			result = append(result, &emptyApiResourceList)
+			gvAPIResourceLists[groupVersion] = &emptyAPIResourceList
+			result = append(result, &emptyAPIResourceList)
 
 			for i := range apiResourceList.APIResources {
 				apiResource := &apiResourceList.APIResources[i]
@@ -288,21 +288,21 @@ func ServerPreferredResources(d DiscoveryInterface) ([]*metav1.APIResourceList,
 					continue
 				}
 				gv := schema.GroupResource{Group: apiGroup.Name, Resource: apiResource.Name}
-				if _, ok := grApiResources[gv]; ok && version.Version != apiGroup.PreferredVersion.Version {
+				if _, ok := grAPIResources[gv]; ok && version.Version != apiGroup.PreferredVersion.Version {
 					// only override with preferred version
 					continue
 				}
 				grVersions[gv] = version.Version
-				grApiResources[gv] = apiResource
+				grAPIResources[gv] = apiResource
 			}
 		}
 	}
 
 	// group selected APIResources according to GroupVersion into APIResourceLists
-	for groupResource, apiResource := range grApiResources {
+	for groupResource, apiResource := range grAPIResources {
 		version := grVersions[groupResource]
 		groupVersion := schema.GroupVersion{Group: groupResource.Group, Version: version}
-		apiResourceList := gvApiResourceLists[groupVersion]
+		apiResourceList := gvAPIResourceLists[groupVersion]
 		apiResourceList.APIResources = append(apiResourceList.APIResources, *apiResource)
 	}
 
@@ -464,9 +464,9 @@ func NewDiscoveryClient(c restclient.Interface) *DiscoveryClient {
 
 // RESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (c *DiscoveryClient) RESTClient() restclient.Interface {
-	if c == nil {
+func (d *DiscoveryClient) RESTClient() restclient.Interface {
+	if d == nil {
 		return nil
 	}
-	return c.restClient
+	return d.restClient
 }

vendor/k8s.io/client-go/discovery/helper.go

@@ -31,11 +31,11 @@ import (
 func MatchesServerVersion(clientVersion apimachineryversion.Info, client DiscoveryInterface) error {
 	sVer, err := client.ServerVersion()
 	if err != nil {
-		return fmt.Errorf("couldn't read version from server: %v\n", err)
+		return fmt.Errorf("couldn't read version from server: %v", err)
 	}
 	// GitVersion includes GitCommit and GitTreeState, but best to be safe?
 	if clientVersion.GitVersion != sVer.GitVersion || clientVersion.GitCommit != sVer.GitCommit || clientVersion.GitTreeState != sVer.GitTreeState {
-		return fmt.Errorf("server version (%#v) differs from client version (%#v)!\n", sVer, clientVersion)
+		return fmt.Errorf("server version (%#v) differs from client version (%#v)", sVer, clientVersion)
 	}
 
 	return nil
@@ -101,12 +101,15 @@ func FilteredBy(pred ResourcePredicate, rls []*metav1.APIResourceList) []*metav1
 	return result
 }
 
+// ResourcePredicate has a method to check if a resource matches a given condition.
 type ResourcePredicate interface {
 	Match(groupVersion string, r *metav1.APIResource) bool
 }
 
+// ResourcePredicateFunc returns true if it matches a resource based on a custom condition.
 type ResourcePredicateFunc func(groupVersion string, r *metav1.APIResource) bool
 
+// Match is a wrapper around ResourcePredicateFunc.
 func (fn ResourcePredicateFunc) Match(groupVersion string, r *metav1.APIResource) bool {
 	return fn(groupVersion, r)
 }
@@ -116,6 +119,7 @@ type SupportsAllVerbs struct {
 	Verbs []string
 }
 
+// Match checks if a resource contains all the given verbs.
 func (p SupportsAllVerbs) Match(groupVersion string, r *metav1.APIResource) bool {
 	return sets.NewString([]string(r.Verbs)...).HasAll(p.Verbs...)
 }

vendor/k8s.io/client-go/discovery/round_tripper.go

@@ -20,10 +20,10 @@ import (
 	"net/http"
 	"path/filepath"
 
-	"github.com/golang/glog"
 	"github.com/gregjones/httpcache"
 	"github.com/gregjones/httpcache/diskcache"
 	"github.com/peterbourgon/diskv"
+	"k8s.io/klog"
 )
 
 type cacheRoundTripper struct {
@@ -55,7 +55,7 @@ func (rt *cacheRoundTripper) CancelRequest(req *http.Request) {
 	if cr, ok := rt.rt.Transport.(canceler); ok {
 		cr.CancelRequest(req)
 	} else {
-		glog.Errorf("CancelRequest not implemented by %T", rt.rt.Transport)
+		klog.Errorf("CancelRequest not implemented by %T", rt.rt.Transport)
 	}
 }