add controllers

change kiali mux to go-restful

add knative

cmd/controller-manager/app/controllers.go

@@ -0,0 +1,86 @@
+package app
+
+import (
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/rest"
+	"kubesphere.io/kubesphere/pkg/controller/destinationrule"
+	"kubesphere.io/kubesphere/pkg/controller/virtualservice"
+	"kubesphere.io/kubesphere/pkg/informers"
+	"kubesphere.io/kubesphere/pkg/simple/controller/namespace"
+	"sigs.k8s.io/controller-runtime/pkg/manager"
+	"time"
+
+	logf "sigs.k8s.io/controller-runtime/pkg/runtime/log"
+
+	istioclientset "github.com/knative/pkg/client/clientset/versioned"
+	istioinformers "github.com/knative/pkg/client/informers/externalversions"
+	servicemeshclientset "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
+	servicemeshinformers "kubesphere.io/kubesphere/pkg/client/informers/externalversions"
+)
+
+const defaultResync = 600 * time.Second
+
+var log = logf.Log.WithName("controller-manager")
+
+func AddControllers(mgr manager.Manager, cfg *rest.Config, stopCh <-chan struct{}) error {
+
+	kubeClient, err := kubernetes.NewForConfig(cfg)
+	if err != nil {
+		log.Error(err, "building kubernetes client failed")
+	}
+
+	istioclient, err := istioclientset.NewForConfig(cfg)
+	if err != nil {
+		log.Error(err, "create istio client failed")
+		return err
+	}
+
+	informerFactory := informers.SharedInformerFactory()
+	istioInformer := istioinformers.NewSharedInformerFactory(istioclient, defaultResync)
+
+	servicemeshclient, err := servicemeshclientset.NewForConfig(cfg)
+	if err != nil {
+		log.Error(err, "create servicemesh client failed")
+		return err
+	}
+
+	servicemeshinformer := servicemeshinformers.NewSharedInformerFactory(servicemeshclient, defaultResync)
+
+	vsController := virtualservice.NewVirtualServiceController(informerFactory.Core().V1().Services(),
+		istioInformer.Networking().V1alpha3().VirtualServices(),
+		istioInformer.Networking().V1alpha3().DestinationRules(),
+		servicemeshinformer.Servicemesh().V1alpha2().Strategies(),
+		kubeClient,
+		istioclient)
+
+	drController := destinationrule.NewDestinationRuleController(informerFactory.Apps().V1().Deployments(),
+		istioInformer.Networking().V1alpha3().DestinationRules(),
+		informerFactory.Core().V1().Services(),
+		kubeClient,
+		istioclient)
+
+	nsController := namespace.NewNamespaceController(kubeClient,
+		informerFactory.Core().V1().Namespaces(),
+		informerFactory.Rbac().V1().Roles(),
+	)
+
+	servicemeshinformer.Start(stopCh)
+	istioInformer.Start(stopCh)
+	informerFactory.Start(stopCh)
+
+	controllers := map[string]manager.Runnable{
+		"virtualservice-controller":  vsController,
+		"destinationrule-controller": drController,
+		"namespace-controller":       nsController,
+	}
+
+	for name, ctrl := range controllers {
+		err = mgr.Add(ctrl)
+		if err != nil {
+			log.Error(err, "add controller to manager failed", "name", name)
+			return err
+		}
+	}
+
+	return nil
+}

cmd/controller-manager/app/helper.go

@@ -0,0 +1,38 @@
+package app
+
+import (
+	"fmt"
+	"k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/klog"
+	"net/http"
+	"time"
+)
+
+// WaitForAPIServer waits for the API Server's /healthz endpoint to report "ok" with timeout.
+func WaitForAPIServer(client clientset.Interface, timeout time.Duration) error {
+	var lastErr error
+
+	err := wait.PollImmediate(time.Second, timeout, func() (bool, error) {
+		healthStatus := 0
+		result := client.Discovery().RESTClient().Get().AbsPath("/healthz").Do().StatusCode(&healthStatus)
+		if result.Error() != nil {
+			lastErr = fmt.Errorf("failed to get apiserver /healthz status: %v", result.Error())
+			return false, nil
+		}
+		if healthStatus != http.StatusOK {
+			content, _ := result.Raw()
+			lastErr = fmt.Errorf("APIServer isn't healthy: %v", string(content))
+			klog.Warningf("APIServer isn't healthy yet: %v. Waiting a little while.", string(content))
+			return false, nil
+		}
+
+		return true, nil
+	})
+
+	if err != nil {
+		return fmt.Errorf("%v: %v", err, lastErr)
+	}
+
+	return nil
+}

cmd/controller-manager/controller-manager.go

@@ -20,93 +20,59 @@ package main
 
 import (
 	"flag"
-
+	"k8s.io/client-go/tools/clientcmd"
+	"kubesphere.io/kubesphere/cmd/controller-manager/app"
+	"kubesphere.io/kubesphere/pkg/apis"
+	"kubesphere.io/kubesphere/pkg/controller"
 	"os"
-	"sigs.k8s.io/application/pkg/apis/app/v1beta1"
-
-	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
-	"kubesphere.io/kubesphere/pkg/informers"
-	"kubesphere.io/kubesphere/pkg/simple/client/k8s"
-	"kubesphere.io/kubesphere/pkg/simple/controller/namespace"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 	logf "sigs.k8s.io/controller-runtime/pkg/runtime/log"
 	"sigs.k8s.io/controller-runtime/pkg/runtime/signals"
-
-	"kubesphere.io/kubesphere/pkg/apis"
-	"kubesphere.io/kubesphere/pkg/controller"
-	"kubesphere.io/kubesphere/pkg/webhook"
 )
 
 func main() {
-	var metricsAddr string
+	var metricsAddr, kubeConfigPath, masterURL string
 	flag.StringVar(&metricsAddr, "metrics-addr", ":8080", "The address the metric endpoint binds to.")
 	flag.Parse()
 	logf.SetLogger(logf.ZapLogger(false))
-	log := logf.Log.WithName("entrypoint")
+	log := logf.Log.WithName("controller-manager")
 
-	// Get a config to talk to the apiserver
-	log.Info("setting up client for manager")
-	cfg, err := k8s.Config()
+	kubeConfig, err := clientcmd.BuildConfigFromFlags(masterURL, kubeConfigPath)
 	if err != nil {
-		log.Error(err, "unable to set up client config")
+		log.Error(err, "failed to build kubeconfig")
 		os.Exit(1)
 	}
 
-	// Create a new Cmd to provide shared dependencies and start components
+	stopCh := signals.SetupSignalHandler()
+
 	log.Info("setting up manager")
-	mgr, err := manager.New(cfg, manager.Options{})
+	mgr, err := manager.New(kubeConfig, manager.Options{})
 	if err != nil {
 		log.Error(err, "unable to set up overall controller manager")
 		os.Exit(1)
 	}
 
-	log.Info("Registering Components.")
-
-	// Setup Scheme for all resources
 	log.Info("setting up scheme")
 	if err := apis.AddToScheme(mgr.GetScheme()); err != nil {
 		log.Error(err, "unable add APIs to scheme")
 		os.Exit(1)
 	}
 
-	log.Info("Print all known types")
-	for k, v := range mgr.GetScheme().AllKnownTypes() {
-		if k.Group == v1beta1.SchemeGroupVersion.Group {
-			log.Info(k.String() + " / " + v.String())
-		}
-	}
-
-	// Setup all Controllers
-	log.Info("Setting up controller")
+	log.Info("Setting up controllers")
 	if err := controller.AddToManager(mgr); err != nil {
 		log.Error(err, "unable to register controllers to the manager")
 		os.Exit(1)
 	}
 
-	log.Info("setting up webhooks")
-	if err := webhook.AddToManager(mgr); err != nil {
-		log.Error(err, "unable to register webhooks to the manager")
+	if err := app.AddControllers(mgr, kubeConfig, stopCh); err != nil {
+		log.Error(err, "unable to register controllers to the manager")
 		os.Exit(1)
 	}
 
-	err = mgr.Add(manager.RunnableFunc(func(s <-chan struct{}) error {
-		informerFactory := informers.SharedInformerFactory()
-		informerFactory.Start(s)
-		namespace.NewNamespaceController(k8s.Client(),
-			informerFactory.Core().V1().Namespaces(),
-			informerFactory.Rbac().V1().Roles()).Start(s)
-		return nil
-	}))
-
-	if err != nil {
-		log.Error(err, "error Adding controllers to the Manager")
-		os.Exit(1)
-	}
-
-	// Start the Cmd
 	log.Info("Starting the Cmd.")
-	if err := mgr.Start(signals.SetupSignalHandler()); err != nil {
+	if err := mgr.Start(stopCh); err != nil {
 		log.Error(err, "unable to run the manager")
 		os.Exit(1)
 	}
+
 }