Refactor handlers to return object and error

app/app.go

@@ -62,7 +62,7 @@ func buildScaledContext(ctx context.Context, kubeConfig rest.Config, cfg *Config
 	}
 
 	scaledContext.Dialer = dialerFactory
-	scaledContext.PeerManager, err = tunnelserver.NewPeerManager(scaledContext, dialerFactory.TunnelServer)
+	scaledContext.PeerManager, err = tunnelserver.NewPeerManager(ctx, scaledContext, dialerFactory.TunnelServer)
 	if err != nil {
 		return nil, nil, err
 	}

pkg/api/controllers/dynamiclistener/listener_controller.go

@@ -45,26 +45,26 @@ func Start(ctx context.Context, context *config.ScaledContext, httpPort, httpsPo
 		listenConfig:       context.Management.ListenConfigs(""),
 		listenConfigLister: context.Management.ListenConfigs("").Controller().Lister(),
 	}
-	context.Management.ListenConfigs("").AddHandler("listener", c.sync)
+	context.Management.ListenConfigs("").AddHandler(ctx, "listener", c.sync)
 	go func() {
 		<-ctx.Done()
 		c.server.Shutdown()
 	}()
 }
 
-func (c *Controller) sync(key string, listener *v3.ListenConfig) error {
+func (c *Controller) sync(key string, listener *v3.ListenConfig) (*v3.ListenConfig, error) {
 	if listener == nil {
-		return nil
+		return nil, nil
 	}
 
 	if listener.Enabled {
-		return c.enable(listener)
+		return nil, c.enable(listener)
 	}
 
 	c.server.Disable(listener)
 	allConfigs, err := c.listenConfigLister.List("", labels.Everything())
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	var lastConfig *v3.ListenConfig
@@ -78,10 +78,10 @@ func (c *Controller) sync(key string, listener *v3.ListenConfig) error {
 	}
 
 	if lastConfig != nil {
-		return c.enable(listener)
+		return nil, c.enable(listener)
 	}
 
-	return nil
+	return nil, nil
 }
 
 func (c *Controller) enable(listener *v3.ListenConfig) error {

pkg/api/controllers/dynamiclistener/listener_controller_test.go

@@ -68,7 +68,7 @@ func testCACertIsTransformedTo(t *testing.T, original string, final string) {
 		server:             &StubServerInterface{},
 	}
 
-	err := controller.sync("", &v3.ListenConfig{Enabled: true, CACerts: original})
+	_, err := controller.sync("", &v3.ListenConfig{Enabled: true, CACerts: original})
 	if err != nil {
 		t.Error(err)
 	}

pkg/api/controllers/dynamicschema/dynamicschema.go

@@ -1,6 +1,7 @@
 package dynamicschema
 
 import (
+	"context"
 	"sync"
 
 	"github.com/rancher/norman/types"
@@ -17,22 +18,22 @@ type Controller struct {
 	known   map[string]bool
 }
 
-func Register(management *config.ScaledContext, schemas *types.Schemas) {
+func Register(ctx context.Context, management *config.ScaledContext, schemas *types.Schemas) {
 	c := &Controller{
 		Schemas: schemas,
 	}
-	management.Management.DynamicSchemas("").AddHandler("dynamic-schema", c.Sync)
+	management.Management.DynamicSchemas("").AddHandler(ctx, "dynamic-schema", c.Sync)
 }
 
-func (c *Controller) Sync(key string, dynamicSchema *v3.DynamicSchema) error {
+func (c *Controller) Sync(key string, dynamicSchema *v3.DynamicSchema) (*v3.DynamicSchema, error) {
 	c.Lock()
 	defer c.Unlock()
 
 	if dynamicSchema == nil {
-		return c.remove(key)
+		return nil, c.remove(key)
 	}
 
-	return c.add(dynamicSchema)
+	return nil, c.add(dynamicSchema)
 }
 
 func (c *Controller) remove(id string) error {

pkg/api/controllers/samlconfig/samlconfig.go

@@ -1,6 +1,7 @@
 package samlconfig
 
 import (
+	"context"
 	"fmt"
 
 	"github.com/mitchellh/mapstructure"
@@ -19,9 +20,9 @@ type authProvider struct {
 	secrets     corev1.SecretInterface
 }
 
-func Register(apiContext *config.ScaledContext) {
+func Register(ctx context.Context, apiContext *config.ScaledContext) {
 	a := newAuthProvider(apiContext)
-	apiContext.Management.AuthConfigs("").AddHandler("authConfigController", a.sync)
+	apiContext.Management.AuthConfigs("").AddHandler(ctx, "authConfigController", a.sync)
 }
 
 func newAuthProvider(apiContext *config.ScaledContext) *authProvider {
@@ -32,35 +33,35 @@ func newAuthProvider(apiContext *config.ScaledContext) *authProvider {
 	return a
 }
 
-func (a *authProvider) sync(key string, config *v3.AuthConfig) error {
+func (a *authProvider) sync(key string, config *v3.AuthConfig) (*v3.AuthConfig, error) {
 	samlConfig := &v3.SamlConfig{}
 	if key == "" || config == nil {
-		return nil
+		return nil, nil
 	}
 
 	if config.Name != saml.PingName && config.Name != saml.ADFSName && config.Name != saml.KeyCloakName {
-		return nil
+		return nil, nil
 	}
 
 	if !config.Enabled {
-		return nil
+		return nil, nil
 	}
 
 	authConfigObj, err := a.authConfigs.ObjectClient().UnstructuredClient().Get(config.Name, metav1.GetOptions{})
 	if err != nil {
-		return fmt.Errorf("failed to retrieve SamlConfig, error: %v", err)
+		return nil, fmt.Errorf("failed to retrieve SamlConfig, error: %v", err)
 	}
 
 	u, ok := authConfigObj.(runtime.Unstructured)
 	if !ok {
-		return fmt.Errorf("failed to retrieve SamlConfig, cannot read k8s Unstructured data")
+		return nil, fmt.Errorf("failed to retrieve SamlConfig, cannot read k8s Unstructured data")
 	}
 	storedSamlConfigMap := u.UnstructuredContent()
 	mapstructure.Decode(storedSamlConfigMap, samlConfig)
 
 	metadataMap, ok := storedSamlConfigMap["metadata"].(map[string]interface{})
 	if !ok {
-		return fmt.Errorf("failed to retrieve SamlConfig metadata, cannot read k8s Unstructured data")
+		return nil, fmt.Errorf("failed to retrieve SamlConfig metadata, cannot read k8s Unstructured data")
 	}
 
 	typemeta := &metav1.ObjectMeta{}
@@ -71,10 +72,10 @@ func (a *authProvider) sync(key string, config *v3.AuthConfig) error {
 		value, err := common.ReadFromSecret(a.secrets, samlConfig.SpKey, "spkey")
 
 		if err != nil {
-			return err
+			return nil, err
 		}
 		samlConfig.SpKey = value
 	}
 
-	return saml.InitializeSamlServiceProvider(samlConfig, config.Name)
+	return nil, saml.InitializeSamlServiceProvider(samlConfig, config.Name)
 }

pkg/api/controllers/usercontrollers/usercontroller.go

@@ -29,7 +29,7 @@ func Register(ctx context.Context, scaledContext *config.ScaledContext, clusterM
 		start:         time.Now(),
 	}
 
-	scaledContext.Management.Clusters("").AddHandler("user-controllers-controller", u.sync)
+	scaledContext.Management.Clusters("").AddHandler(ctx, "user-controllers-controller", u.sync)
 
 	if scaledContext.PeerManager != nil {
 		c := make(chan tpeermanager.Peers, 100)
@@ -75,14 +75,14 @@ type userControllersController struct {
 	start         time.Time
 }
 
-func (u *userControllersController) sync(key string, cluster *v3.Cluster) error {
+func (u *userControllersController) sync(key string, cluster *v3.Cluster) (*v3.Cluster, error) {
 	if cluster != nil && cluster.DeletionTimestamp != nil {
 		err := u.cleanFinalizers(key, cluster)
 		if err != nil {
-			return err
+			return nil, err
 		}
 	}
-	return u.setPeers(nil)
+	return nil, u.setPeers(nil)
 }
 
 func (u *userControllersController) setPeers(peers *tpeermanager.Peers) error {

pkg/api/controllers/whitelistproxy/whitelistproxy.go

@@ -1,28 +1,30 @@
 package whitelistproxy
 
 import (
+	"context"
+
 	"github.com/rancher/rancher/server/whitelist"
 	"github.com/rancher/types/apis/management.cattle.io/v3"
 	"github.com/rancher/types/config"
 )
 
-func Register(management *config.ScaledContext) {
-	management.Management.NodeDrivers("").AddHandler("whitelist-proxy", sync)
+func Register(ctx context.Context, management *config.ScaledContext) {
+	management.Management.NodeDrivers("").AddHandler(ctx, "whitelist-proxy", sync)
 }
 
-func sync(key string, nodeDriver *v3.NodeDriver) error {
+func sync(key string, nodeDriver *v3.NodeDriver) (*v3.NodeDriver, error) {
 	if key == "" || nodeDriver == nil {
-		return nil
+		return nil, nil
 	}
 	if nodeDriver.DeletionTimestamp != nil {
 		for _, d := range nodeDriver.Spec.WhitelistDomains {
 			whitelist.Proxy.Rm(d)
 		}
-		return nil
+		return nil, nil
 	}
 
 	for _, d := range nodeDriver.Spec.WhitelistDomains {
 		whitelist.Proxy.Add(d)
 	}
-	return nil
+	return nil, nil
 }

pkg/api/server/server.go

@@ -43,9 +43,9 @@ func New(ctx context.Context, scaledContext *config.ScaledContext, clusterManage
 		return nil, err
 	}
 
-	dynamicschema.Register(scaledContext, server.Schemas)
-	whitelistproxy.Register(scaledContext)
-	samlconfig.Register(scaledContext)
+	dynamicschema.Register(ctx, scaledContext, server.Schemas)
+	whitelistproxy.Register(ctx, scaledContext)
+	samlconfig.Register(ctx, scaledContext)
 	usercontrollers.Register(ctx, scaledContext, clusterManager)
 	err := settings.Register(scaledContext)
 

pkg/catalog/manager/catalog_sync.go

@@ -7,23 +7,23 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-func (m *Manager) Sync(key string, obj *v3.Catalog) error {
+func (m *Manager) Sync(key string, obj *v3.Catalog) (*v3.Catalog, error) {
 	if obj == nil {
-		return m.deleteTemplates(key)
+		return nil, m.deleteTemplates(key)
 	}
 
 	// always get a refresh catalog from etcd
 	catalog, err := m.catalogClient.Get(key, metav1.GetOptions{})
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	repoPath, commit, err := m.prepareRepoPath(*catalog)
 	if err != nil {
 		v3.CatalogConditionRefreshed.False(catalog)
 		v3.CatalogConditionRefreshed.ReasonAndMessageFromError(catalog, err)
 		m.catalogClient.Update(catalog)
-		return err
+		return nil, err
 	}
 
 	if commit == catalog.Status.Commit {
@@ -33,13 +33,13 @@ func (m *Manager) Sync(key string, obj *v3.Catalog) error {
 			v3.CatalogConditionRefreshed.Reason(catalog, "")
 			m.catalogClient.Update(catalog)
 		}
-		return nil
+		return nil, nil
 	}
 
 	cmt := &CatalogInfo{
 		catalog: catalog,
 	}
 
 	logrus.Infof("Updating catalog %s", catalog.Name)
-	return m.traverseAndUpdate(repoPath, commit, cmt)
+	return nil, m.traverseAndUpdate(repoPath, commit, cmt)
 }

pkg/catalog/manager/cluster_catalog_sync.go

@@ -7,28 +7,28 @@ import (
 	"k8s.io/client-go/tools/cache"
 )
 
-func (m *Manager) ClusterCatalogSync(key string, obj *v3.ClusterCatalog) error {
+func (m *Manager) ClusterCatalogSync(key string, obj *v3.ClusterCatalog) (*v3.ClusterCatalog, error) {
 	ns, name, err := cache.SplitMetaNamespaceKey(key)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	if obj == nil {
-		return m.deleteTemplates(name)
+		return nil, m.deleteTemplates(name)
 	}
 
 	// always get a refresh catalog from etcd
 	clusterCatalog, err := m.clusterCatalogClient.GetNamespaced(ns, name, metav1.GetOptions{})
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	repoPath, commit, err := m.prepareRepoPath(obj.Catalog)
 	if err != nil {
 		v3.CatalogConditionRefreshed.False(clusterCatalog)
 		v3.CatalogConditionRefreshed.ReasonAndMessageFromError(clusterCatalog, err)
 		m.clusterCatalogClient.Update(clusterCatalog)
-		return err
+		return nil, err
 	}
 
 	if commit == clusterCatalog.Status.Commit {
@@ -38,7 +38,7 @@ func (m *Manager) ClusterCatalogSync(key string, obj *v3.ClusterCatalog) error {
 			v3.CatalogConditionRefreshed.Reason(clusterCatalog, "")
 			m.clusterCatalogClient.Update(clusterCatalog)
 		}
-		return nil
+		return nil, nil
 	}
 
 	cmt := &CatalogInfo{
@@ -47,5 +47,5 @@ func (m *Manager) ClusterCatalogSync(key string, obj *v3.ClusterCatalog) error {
 	}
 
 	logrus.Infof("Updating catalog %s", clusterCatalog.Name)
-	return m.traverseAndUpdate(repoPath, commit, cmt)
+	return nil, m.traverseAndUpdate(repoPath, commit, cmt)
 }

pkg/catalog/manager/project_catalog_sync.go

@@ -7,28 +7,28 @@ import (
 	"k8s.io/client-go/tools/cache"
 )
 
-func (m *Manager) ProjectCatalogSync(key string, obj *v3.ProjectCatalog) error {
+func (m *Manager) ProjectCatalogSync(key string, obj *v3.ProjectCatalog) (*v3.ProjectCatalog, error) {
 	ns, name, err := cache.SplitMetaNamespaceKey(key)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	if obj == nil {
-		return m.deleteTemplates(name)
+		return nil, m.deleteTemplates(name)
 	}
 
 	// always get a refresh catalog from etcd
 	projectCatalog, err := m.projectCatalogClient.GetNamespaced(ns, name, metav1.GetOptions{})
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	repoPath, commit, err := m.prepareRepoPath(obj.Catalog)
 	if err != nil {
 		v3.CatalogConditionRefreshed.False(projectCatalog)
 		v3.CatalogConditionRefreshed.ReasonAndMessageFromError(projectCatalog, err)
 		m.projectCatalogClient.Update(projectCatalog)
-		return err
+		return nil, err
 	}
 
 	if commit == projectCatalog.Status.Commit {
@@ -38,7 +38,7 @@ func (m *Manager) ProjectCatalogSync(key string, obj *v3.ProjectCatalog) error {
 			v3.CatalogConditionRefreshed.Reason(projectCatalog, "")
 			m.projectCatalogClient.Update(projectCatalog)
 		}
-		return nil
+		return nil, nil
 	}
 
 	cmt := &CatalogInfo{
@@ -47,5 +47,5 @@ func (m *Manager) ProjectCatalogSync(key string, obj *v3.ProjectCatalog) error {
 	}
 
 	logrus.Infof("Updating project catalog %s", projectCatalog.Name)
-	return m.traverseAndUpdate(repoPath, commit, cmt)
+	return nil, m.traverseAndUpdate(repoPath, commit, cmt)
 }