Merge pull request #857 from font/klog

Switch from glog to klog

cmd/controller-manager/app/controller-manager.go

@@ -27,9 +27,9 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/golang/glog"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
+
 	apiextv1b1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -38,6 +38,7 @@ import (
 	"k8s.io/apiserver/pkg/util/logs"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/klog"
 
 	"github.com/kubernetes-sigs/federation-v2/cmd/controller-manager/app/leaderelection"
 	"github.com/kubernetes-sigs/federation-v2/cmd/controller-manager/app/options"
@@ -82,7 +83,7 @@ member clusters and does the necessary reconciliation`,
 		},
 	}
 
-	// Add the command line flags from other dependencies(glog, kubebuilder, etc.)
+	// Add the command line flags from other dependencies(klog, kubebuilder, etc.)
 	cmd.Flags().AddGoFlagSet(flag.CommandLine)
 
 	opts.AddFlags(cmd.Flags())
@@ -113,15 +114,15 @@ func Run(opts *options.Options) error {
 	setOptionsByFederationConfig(opts)
 
 	if err := utilfeature.DefaultFeatureGate.SetFromMap(opts.FeatureGates); err != nil {
-		glog.Fatalf("Invalid Feature Gate: %v", err)
+		klog.Fatalf("Invalid Feature Gate: %v", err)
 	}
 
 	if opts.Scope == apiextv1b1.NamespaceScoped {
 		opts.Config.TargetNamespace = opts.Config.FederationNamespace
-		glog.Infof("Federation will be limited to the %q namespace", opts.Config.FederationNamespace)
+		klog.Infof("Federation will be limited to the %q namespace", opts.Config.FederationNamespace)
 	} else {
 		opts.Config.TargetNamespace = metav1.NamespaceAll
-		glog.Info("Federation will target all namespaces")
+		klog.Info("Federation will target all namespaces")
 	}
 
 	elector, err := leaderelection.NewFederationLeaderElector(opts, startControllers)
@@ -142,44 +143,44 @@ func Run(opts *options.Options) error {
 
 	elector.Run(ctx)
 
-	glog.Errorf("lost lease")
+	klog.Errorf("lost lease")
 	return errors.New("lost lease")
 }
 
 func startControllers(opts *options.Options, stopChan <-chan struct{}) {
 	if err := federatedcluster.StartClusterController(opts.Config, opts.ClusterHealthCheckConfig, stopChan); err != nil {
-		glog.Fatalf("Error starting cluster controller: %v", err)
+		klog.Fatalf("Error starting cluster controller: %v", err)
 	}
 
 	if utilfeature.DefaultFeatureGate.Enabled(features.SchedulerPreferences) {
 		if _, err := schedulingmanager.StartSchedulingManager(opts.Config, stopChan); err != nil {
-			glog.Fatalf("Error starting scheduling manager: %v", err)
+			klog.Fatalf("Error starting scheduling manager: %v", err)
 		}
 	}
 
 	if utilfeature.DefaultFeatureGate.Enabled(features.CrossClusterServiceDiscovery) {
 		if err := servicedns.StartController(opts.Config, stopChan); err != nil {
-			glog.Fatalf("Error starting dns controller: %v", err)
+			klog.Fatalf("Error starting dns controller: %v", err)
 		}
 
 		if err := dnsendpoint.StartServiceDNSEndpointController(opts.Config, stopChan); err != nil {
-			glog.Fatalf("Error starting dns endpoint controller: %v", err)
+			klog.Fatalf("Error starting dns endpoint controller: %v", err)
 		}
 	}
 
 	if utilfeature.DefaultFeatureGate.Enabled(features.FederatedIngress) {
 		if err := ingressdns.StartController(opts.Config, stopChan); err != nil {
-			glog.Fatalf("Error starting ingress dns controller: %v", err)
+			klog.Fatalf("Error starting ingress dns controller: %v", err)
 		}
 
 		if err := dnsendpoint.StartIngressDNSEndpointController(opts.Config, stopChan); err != nil {
-			glog.Fatalf("Error starting ingress dns endpoint controller: %v", err)
+			klog.Fatalf("Error starting ingress dns endpoint controller: %v", err)
 		}
 	}
 
 	if utilfeature.DefaultFeatureGate.Enabled(features.PushReconciler) {
 		if err := federatedtypeconfig.StartController(opts.Config, stopChan); err != nil {
-			glog.Fatalf("Error starting federated type config controller: %v", err)
+			klog.Fatalf("Error starting federated type config controller: %v", err)
 		}
 	}
 }
@@ -199,33 +200,33 @@ func getFederationConfig(opts *options.Options) *corev1a1.FederationConfig {
 
 		err := client.Get(context.Background(), fedConfig, namespace, name)
 		if apierrors.IsNotFound(err) {
-			glog.Infof("Cannot retrieve FederationConfig %q: %v. Default options are used.", qualifiedName.String(), err)
+			klog.Infof("Cannot retrieve FederationConfig %q: %v. Default options are used.", qualifiedName.String(), err)
 			return nil
 		}
 		if err != nil {
-			glog.Fatalf("Error retrieving FederationConfig %q: %v.", qualifiedName.String(), err)
+			klog.Fatalf("Error retrieving FederationConfig %q: %v.", qualifiedName.String(), err)
 		}
 
-		glog.Infof("Setting Options with FederationConfig %q", qualifiedName.String())
+		klog.Infof("Setting Options with FederationConfig %q", qualifiedName.String())
 		return fedConfig
 	}
 
 	file, err := os.Open(federationConfig)
 	if err != nil {
 		// when federation config file is specified, it should be fatal error if the file does not valid
-		glog.Fatalf("Cannot open federation config file %q: %v", federationConfig, err)
+		klog.Fatalf("Cannot open federation config file %q: %v", federationConfig, err)
 	}
 	defer file.Close()
 
 	decoder := yaml.NewYAMLToJSONDecoder(file)
 	err = decoder.Decode(fedConfig)
 	if err != nil {
-		glog.Fatalf("Cannot decode FederationConfig from file %q: %v", federationConfig, err)
+		klog.Fatalf("Cannot decode FederationConfig from file %q: %v", federationConfig, err)
 	}
 
 	// set to current namespace to make sure `FederationConfig` is updated in correct namespace
 	fedConfig.Namespace = opts.Config.FederationNamespace
-	glog.Infof("Setting Options with FederationConfig from file %q: %v", federationConfig, fedConfig.Spec)
+	klog.Infof("Setting Options with FederationConfig from file %q: %v", federationConfig, fedConfig.Spec)
 	return fedConfig
 }
 
@@ -258,7 +259,7 @@ func setDefaultFederationConfig(fedConfig *corev1a1.FederationConfig) {
 		defaultScope := os.Getenv(defaultScopeEnv)
 		if len(defaultScope) != 0 {
 			if defaultScope != string(apiextv1b1.ClusterScoped) && defaultScope != string(apiextv1b1.NamespaceScoped) {
-				glog.Fatalf("%s must be Cluster or Namespaced; got %q", defaultScopeEnv, defaultScope)
+				klog.Fatalf("%s must be Cluster or Namespaced; got %q", defaultScopeEnv, defaultScope)
 			}
 			spec.Scope = apiextv1b1.ResourceScope(defaultScope)
 		}
@@ -299,19 +300,19 @@ func updateFederationConfig(config *rest.Config, fedConfig *corev1a1.FederationC
 	client := genericclient.NewForConfigOrDieWithUserAgent(config, "federationconfig")
 	err := client.Get(context.Background(), configResource, namespace, name)
 	if err != nil && !apierrors.IsNotFound(err) {
-		glog.Fatalf("Error retrieving FederationConfig %q: %v", qualifiedName, err)
+		klog.Fatalf("Error retrieving FederationConfig %q: %v", qualifiedName, err)
 	}
 	if apierrors.IsNotFound(err) {
 		// if `--federation-config` is specifed but there is not FederationConfig resource accordingly
 		err = client.Create(context.Background(), fedConfig)
 		if err != nil {
-			glog.Fatalf("Error creating FederationConfig %q: %v", qualifiedName, err)
+			klog.Fatalf("Error creating FederationConfig %q: %v", qualifiedName, err)
 		}
 	} else {
 		configResource.Spec = fedConfig.Spec
 		err = client.Update(context.Background(), configResource)
 		if err != nil {
-			glog.Fatalf("Error updating FederationConfig %q: %v", qualifiedName, err)
+			klog.Fatalf("Error updating FederationConfig %q: %v", qualifiedName, err)
 		}
 	}
 }
@@ -325,7 +326,7 @@ func setOptionsByFederationConfig(opts *options.Options) {
 			Name:      util.FederationConfigName,
 		}
 
-		glog.Infof("Creating FederationConfig %q with default values", qualifiedName)
+		klog.Infof("Creating FederationConfig %q with default values", qualifiedName)
 
 		fedConfig = &corev1a1.FederationConfig{
 			ObjectMeta: metav1.ObjectMeta{
@@ -367,13 +368,13 @@ func setOptionsByFederationConfig(opts *options.Options) {
 	}
 
 	opts.FeatureGates = featureGates
-	glog.V(1).Infof("\"feature-gates\" will be set to %v", featureGates)
+	klog.V(1).Infof("\"feature-gates\" will be set to %v", featureGates)
 }
 
 // PrintFlags logs the flags in the flagset
 func PrintFlags(flags *pflag.FlagSet) {
 	flags.VisitAll(func(flag *pflag.Flag) {
-		glog.V(1).Infof("FLAG: --%s=%q", flag.Name, flag.Value)
+		klog.V(1).Infof("FLAG: --%s=%q", flag.Name, flag.Value)
 	})
 }
 
@@ -405,5 +406,5 @@ func serveHealthz(address string) {
 		_, _ = w.Write([]byte("OK"))
 	})
 
-	glog.Fatal(http.ListenAndServe(address, nil))
+	klog.Fatal(http.ListenAndServe(address, nil))
 }

cmd/controller-manager/app/leaderelection/leaderelection.go

@@ -20,7 +20,6 @@ import (
 	"context"
 	"os"
 
-	"github.com/golang/glog"
 	"k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/util/uuid"
 	kubeclient "k8s.io/client-go/kubernetes"
@@ -30,6 +29,7 @@ import (
 	"k8s.io/client-go/tools/leaderelection"
 	"k8s.io/client-go/tools/leaderelection/resourcelock"
 	"k8s.io/client-go/tools/record"
+	"k8s.io/klog"
 
 	"github.com/kubernetes-sigs/federation-v2/cmd/controller-manager/app/options"
 )
@@ -41,7 +41,7 @@ func NewFederationLeaderElector(opts *options.Options, fnStartControllers func(*
 
 	hostname, err := os.Hostname()
 	if err != nil {
-		glog.Infof("unable to get hostname: %v", err)
+		klog.Infof("unable to get hostname: %v", err)
 		return nil, err
 	}
 
@@ -61,7 +61,7 @@ func NewFederationLeaderElector(opts *options.Options, fnStartControllers func(*
 			EventRecorder: eventRecorder,
 		})
 	if err != nil {
-		glog.Infof("couldn't create resource lock: %v", err)
+		klog.Infof("couldn't create resource lock: %v", err)
 		return nil, err
 	}
 
@@ -72,13 +72,13 @@ func NewFederationLeaderElector(opts *options.Options, fnStartControllers func(*
 		RetryPeriod:   opts.LeaderElection.RetryPeriod,
 		Callbacks: leaderelection.LeaderCallbacks{
 			OnStartedLeading: func(ctx context.Context) {
-				glog.Info("promoted as leader")
+				klog.Info("promoted as leader")
 				stopChan := ctx.Done()
 				fnStartControllers(opts, stopChan)
 				<-stopChan
 			},
 			OnStoppedLeading: func() {
-				glog.Info("leader election lost")
+				klog.Info("leader election lost")
 			},
 		},
 	})

cmd/controller-manager/app/options/options.go

@@ -18,9 +18,11 @@ limitations under the License.
 package options
 
 import (
-	"github.com/kubernetes-sigs/federation-v2/pkg/controller/util"
 	"github.com/spf13/pflag"
+
 	apiextv1b1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
+
+	"github.com/kubernetes-sigs/federation-v2/pkg/controller/util"
 )
 
 // Options contains everything necessary to create and run controller-manager.

cmd/hyperfed/main.go

@@ -31,6 +31,7 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
+
 	utilflag "k8s.io/apiserver/pkg/util/flag"
 	"k8s.io/apiserver/pkg/util/logs"
 	_ "k8s.io/client-go/plugin/pkg/client/auth" // Load all client auth plugins for GCP, Azure, Openstack, etc

pkg/client/generic/scheme/register.go

@@ -17,14 +17,15 @@ limitations under the License.
 package scheme
 
 import (
-	fedapis "github.com/kubernetes-sigs/federation-v2/pkg/apis"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	schema "k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	k8sscheme "k8s.io/client-go/kubernetes/scheme"
 	crapis "k8s.io/cluster-registry/pkg/apis/clusterregistry/v1alpha1"
+
+	fedapis "github.com/kubernetes-sigs/federation-v2/pkg/apis"
 )
 
 var Scheme = runtime.NewScheme()

pkg/controller/dnsendpoint/common.go

@@ -20,10 +20,9 @@ import (
 	"net"
 	"sort"
 
-	"github.com/golang/glog"
-
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/klog"
 
 	feddnsv1a1 "github.com/kubernetes-sigs/federation-v2/pkg/apis/multiclusterdns/v1alpha1"
 )
@@ -64,7 +63,7 @@ func getResolvedTargets(targets feddnsv1a1.Targets, netWrapper NetWrapper) (fedd
 			// through an interface abstracting the internet
 			ipAddrs, err := netWrapper.LookupHost(target)
 			if err != nil {
-				glog.Errorf("Failed to resolve %s, err: %v", target, err)
+				klog.Errorf("Failed to resolve %s, err: %v", target, err)
 				return resolvedTargets.List(), err
 			}
 			for _, ip := range ipAddrs {