MAJOR: CR: Add core.haproxy.org/v1alpha1.Backend for backend config

A backend CR can be assigned to a service by annotating the latter
via "cr-backend" annotation

Author: Mo3m3n

controller/annotations/models.go

@@ -9,6 +9,19 @@ import (
 	"github.com/haproxytech/kubernetes-ingress/controller/store"
 )
 
+// ModelBackend takes an annotation holding the path of a backend cr and returns corresponding Backend model
+func ModelBackend(name, defaultNS string, k store.K8s, annotations ...map[string]string) (backend *models.Backend, err error) {
+	b, modelErr := model(name, defaultNS, 3, k, annotations...)
+	if modelErr != nil {
+		err = modelErr
+		return
+	}
+	if b != nil {
+		backend = b.(*models.Backend)
+	}
+	return
+}
+
 // ModelDefaults takes an annotation holding the path of a defaults cr and returns corresponding Defaults model
 func ModelDefaults(name, defaultNS string, k store.K8s, annotations ...map[string]string) (defaults *models.Defaults, err error) {
 	d, modelErr := model(name, defaultNS, 2, k, annotations...)
@@ -84,6 +97,12 @@ func model(name, defaultNS string, crType int, k store.K8s, annotations ...map[s
 			return nil, fmt.Errorf("annotation %s: custom resource '%s/%s' doest not exist", name, crNS, crName)
 		}
 		return defaults, nil
+	case 3:
+		backend, backendOk := ns.CRs.Backends[crName]
+		if !backendOk {
+			return nil, fmt.Errorf("annotation %s: custom resource '%s/%s' doest not exist", name, crNS, crName)
+		}
+		return backend, nil
 	}
 	return nil, nil
 }

controller/crmanager.go

@@ -58,6 +58,7 @@ func NewCRManager(s *store.K8s, restCfg *rest.Config, cacheResync time.Duration,
 	}
 	manager.RegisterCoreCR(NewGlobalCR())
 	manager.RegisterCoreCR(NewDefaultsCR())
+	manager.RegisterCoreCR(NewBackendCR())
 	return manager
 }
 

controller/crs.go

@@ -28,6 +28,9 @@ type GlobalCR struct {
 type DefaultsCR struct {
 }
 
+type BackendCR struct {
+}
+
 func NewGlobalCR() GlobalCR {
 	return GlobalCR{}
 }
@@ -36,6 +39,10 @@ func NewDefaultsCR() DefaultsCR {
 	return DefaultsCR{}
 }
 
+func NewBackendCR() BackendCR {
+	return BackendCR{}
+}
+
 func (c GlobalCR) GetKind() string {
 	return "Global"
 }
@@ -129,3 +136,49 @@ func (c DefaultsCR) ProcessEvent(s *store.K8s, job SyncDataEvent) bool {
 	ns.CRs.Defaults[job.Name] = data.Spec.Config
 	return true
 }
+
+func (c BackendCR) GetKind() string {
+	return "Backend"
+}
+
+func (c BackendCR) GetInformer(eventChan chan SyncDataEvent, factory informers.SharedInformerFactory) cache.SharedIndexInformer {
+	informer := factory.Core().V1alpha1().Backends().Informer()
+
+	sendToChannel := func(eventChan chan SyncDataEvent, object interface{}, status store.Status) {
+		data := object.(*corev1alpha1.Backend)
+		logger.Debugf("%s %s: %s", data.GetNamespace(), status, data.GetName())
+		if status == DELETED {
+			eventChan <- SyncDataEvent{SyncType: CUSTOM_RESOURCE, CRKind: c.GetKind(), Namespace: data.GetNamespace(), Name: data.GetName(), Data: nil}
+			return
+		}
+		eventChan <- SyncDataEvent{SyncType: CUSTOM_RESOURCE, CRKind: c.GetKind(), Namespace: data.GetNamespace(), Name: data.GetName(), Data: data}
+	}
+
+	informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
+		AddFunc: func(obj interface{}) {
+			sendToChannel(eventChan, obj, store.ADDED)
+		},
+		UpdateFunc: func(oldObj, newObj interface{}) {
+			sendToChannel(eventChan, newObj, store.MODIFIED)
+		},
+		DeleteFunc: func(obj interface{}) {
+			sendToChannel(eventChan, obj, store.DELETED)
+		},
+	})
+	return informer
+}
+
+func (c BackendCR) ProcessEvent(s *store.K8s, job SyncDataEvent) bool {
+	ns := s.GetNamespace(job.Namespace)
+	if job.Data == nil {
+		delete(ns.CRs.Backends, job.Name)
+		return true
+	}
+	data, ok := job.Data.(*corev1alpha1.Backend)
+	if !ok {
+		logger.Warning(CoreGroupVersion + ": type mismatch with Backend kind")
+		return false
+	}
+	ns.CRs.Backends[job.Name] = data.Spec.Config
+	return true
+}

controller/ingress.go

@@ -69,25 +69,26 @@ func (c *HAProxyController) handleIngressPath(ingress *store.Ingress, host strin
 		return
 	}
 	// Backend
-	backend, backendReload, err := svc.HandleBackend(c.Client, c.Store)
+	backendReload, err := svc.HandleBackend(c.Client, c.Store)
 	if err != nil {
 		return
 	}
+	backendName, _ := svc.GetBackendName()
 	// Route
 	var routeReload bool
 	ingRoute := route.Route{
 		Host:           host,
 		Path:           path,
 		HAProxyRules:   ruleIDs,
-		BackendName:    backend.Name,
+		BackendName:    backendName,
 		SSLPassthrough: sslPassthrough,
 	}
 
 	routeACLAnn := annotations.String("route-acl", svc.GetService().Annotations)
 	if routeACLAnn == "" {
-		if _, ok := route.CustomRoutes[backend.Name]; ok {
-			delete(route.CustomRoutes, backend.Name)
-			logger.Debugf("Custom Route to backend '%s' deleted, reload required", backend.Name)
+		if _, ok := route.CustomRoutes[backendName]; ok {
+			delete(route.CustomRoutes, backendName)
+			logger.Debugf("Custom Route to backend '%s' deleted, reload required", backendName)
 			routeReload = true
 		}
 		err = route.AddHostPathRoute(ingRoute, c.Cfg.MapFiles)
@@ -97,7 +98,7 @@ func (c *HAProxyController) handleIngressPath(ingress *store.Ingress, host strin
 	if err != nil {
 		return
 	}
-	c.Cfg.ActiveBackends[backend.Name] = struct{}{}
+	c.Cfg.ActiveBackends[backendName] = struct{}{}
 	// Endpoints
 	endpointsReload := svc.HandleEndpoints(c.Client, c.Store)
 	return backendReload || endpointsReload || routeReload, err
@@ -121,26 +122,27 @@ func (c *HAProxyController) setDefaultService(ingress *store.Ingress, frontends
 	if svc.GetStatus() == DELETED {
 		return
 	}
-	backend, bdReload, err := svc.HandleBackend(c.Client, c.Store)
+	bdReload, err := svc.HandleBackend(c.Client, c.Store)
 	if err != nil {
 		return
 	}
-	if frontend.DefaultBackend != backend.Name {
+	backendName, _ := svc.GetBackendName()
+	if frontend.DefaultBackend != backendName {
 		if frontend.Name == c.Cfg.FrontHTTP {
-			logger.Infof("Setting http default backend to '%s'", backend.Name)
+			logger.Infof("Setting http default backend to '%s'", backendName)
 		}
 		for _, frontendName := range frontends {
 			frontend, _ := c.Client.FrontendGet(frontendName)
-			frontend.DefaultBackend = backend.Name
+			frontend.DefaultBackend = backendName
 			err = c.Client.FrontendEdit(frontend)
 			if err != nil {
 				return
 			}
 			ftReload = true
-			logger.Debugf("Setting '%s' default backend to '%s'", frontendName, backend.Name)
+			logger.Debugf("Setting '%s' default backend to '%s'", frontendName, backendName)
 		}
 	}
-	c.Cfg.ActiveBackends[backend.Name] = struct{}{}
+	c.Cfg.ActiveBackends[backendName] = struct{}{}
 	endpointsReload := svc.HandleEndpoints(c.Client, c.Store)
 	reload = bdReload || ftReload || endpointsReload
 	return reload, err

controller/kubernetes.go

@@ -129,6 +129,7 @@ func (k *K8s) EventsNamespaces(channel chan SyncDataEvent, stop chan struct{}, i
 						Global:     make(map[string]*models.Global),
 						Defaults:   make(map[string]*models.Defaults),
 						LogTargets: make(map[string]models.LogTargets),
+						Backends:   make(map[string]*models.Backend),
 					},
 					Status: status,
 				}
@@ -152,6 +153,7 @@ func (k *K8s) EventsNamespaces(channel chan SyncDataEvent, stop chan struct{}, i
 						Global:     make(map[string]*models.Global),
 						Defaults:   make(map[string]*models.Defaults),
 						LogTargets: make(map[string]models.LogTargets),
+						Backends:   make(map[string]*models.Backend),
 					},
 					Status: status,
 				}

controller/service/service.go

@@ -38,6 +38,7 @@ type SvcContext struct {
 	service    *store.Service
 	backend    *models.Backend
 	certs      *haproxy.Certificates
+	modeTCP    bool
 	newBackend bool
 }
 
@@ -46,20 +47,13 @@ func NewCtx(k8s store.K8s, ingress *store.Ingress, path *store.IngressPath, cert
 	if err != nil {
 		return nil, err
 	}
-	backend := models.Backend{
-		Mode:          "http",
-		DefaultServer: &models.DefaultServer{},
-	}
-	if tcpService {
-		backend.Mode = "tcp"
-	}
 	return &SvcContext{
 		store:   k8s,
 		ingress: ingress,
 		path:    path,
 		service: service,
-		backend: &backend,
 		certs:   certs,
+		modeTCP: tcpService,
 	}, nil
 }
 
@@ -77,11 +71,12 @@ func (s *SvcContext) GetService() *store.Service {
 	return s.service
 }
 
-// setBackendName checks if servicePort provided in IngressPath exists and construct corresponding backend name
+// GetBackendName checks if servicePort provided in IngressPath exists and construct corresponding backend name
 // Backend name is in format "ServiceNS-ServiceName-PortName"
-func (s *SvcContext) setBackendName() error {
-	if s.backend.Name != "" {
-		return nil
+func (s *SvcContext) GetBackendName() (name string, err error) {
+	if s.backend != nil && s.backend.Name != "" {
+		name = s.backend.Name
+		return
 	}
 	var svcPort store.ServicePort
 	found := false
@@ -95,61 +90,91 @@ func (s *SvcContext) setBackendName() error {
 	}
 	if !found {
 		if s.path.SvcPortString != "" {
-			return fmt.Errorf("service %s: no service port matching '%s'", s.service.Name, s.path.SvcPortString)
+			err = fmt.Errorf("service %s: no service port matching '%s'", s.service.Name, s.path.SvcPortString)
+		} else {
+			err = fmt.Errorf("service %s: no service port matching '%d'", s.service.Name, s.path.SvcPortInt)
 		}
-		return fmt.Errorf("service %s: no service port matching '%d'", s.service.Name, s.path.SvcPortInt)
+		return
 	}
 	s.path.SvcPortResolved = &svcPort
 	if svcPort.Name != "" {
-		s.backend.Name = fmt.Sprintf("%s-%s-%s", s.service.Namespace, s.service.Name, svcPort.Name)
+		name = fmt.Sprintf("%s-%s-%s", s.service.Namespace, s.service.Name, svcPort.Name)
 	} else {
-		s.backend.Name = fmt.Sprintf("%s-%s-%s", s.service.Namespace, s.service.Name, strconv.Itoa(int(svcPort.Port)))
+		name = fmt.Sprintf("%s-%s-%s", s.service.Namespace, s.service.Name, strconv.Itoa(int(svcPort.Port)))
 	}
-	return nil
+	return
 }
 
 // HandleBackend processes a Service Context and creates/updates corresponding backend configuration in HAProxy
-func (s *SvcContext) HandleBackend(client api.HAProxyClient, store store.K8s) (backend *models.Backend, reload bool, err error) {
-	backend = s.backend
-	if err = s.setBackendName(); err != nil {
+func (s *SvcContext) HandleBackend(client api.HAProxyClient, store store.K8s) (reload bool, err error) {
+	var backend, newBackend *models.Backend
+	newBackend, err = s.getBackendModel(store)
+	s.backend = newBackend
+	if err != nil {
 		return
 	}
 	// Get/Create Backend
-	if s.service.DNS != "" {
-		backend.DefaultServer = &models.DefaultServer{InitAddr: "last,libc,none"}
-	}
-	var oldBackend *models.Backend
-	oldBackend, err = client.BackendGet(s.backend.Name)
-	if err != nil {
-		if err = client.BackendCreate(*backend); err != nil {
+	backend, err = client.BackendGet(newBackend.Name)
+	if err == nil {
+		// Update Backend
+		result := deep.Equal(newBackend, backend)
+		if len(result) != 0 {
+			if err = client.BackendEdit(*newBackend); err != nil {
+				return
+			}
+			reload = true
+			logger.Debugf("Ingress '%s/%s': backend '%s' updated: %s\nReload required", s.ingress.Namespace, s.ingress.Name, newBackend.Name, result)
+		}
+	} else {
+		if err = client.BackendCreate(*newBackend); err != nil {
 			return
 		}
 		s.newBackend = true
 		reload = true
-		logger.Debugf("Ingress '%s/%s': new backend '%s', reload required", s.ingress.Namespace, s.ingress.Name, backend.Name)
+		logger.Debugf("Ingress '%s/%s': new backend '%s', reload required", s.ingress.Namespace, s.ingress.Name, newBackend.Name)
+	}
+	// config-snippet
+	change, errSnipp := annotations.UpdateBackendCfgSnippet(client, newBackend.Name)
+	logger.Error(errSnipp)
+	if len(change) != 0 {
+		reload = true
+		logger.Debugf("Ingress '%s/%s': backend '%s' updated: %s\nReload required", s.ingress.Namespace, s.ingress.Name, newBackend.Name, change)
+	}
+	return
+}
+
+// getBackendModel checks for a corresponding custom resource before falling back to annoations
+func (s *SvcContext) getBackendModel(store store.K8s) (*models.Backend, error) {
+	var backend *models.Backend
+	var err error
+	crInuse := true
+	backend, err = annotations.ModelBackend("cr-backend", s.service.Namespace, store, s.service.Annotations, s.ingress.Annotations, store.ConfigMaps.Main.Annotations)
+	logger.Warning(err)
+	if backend == nil {
+		backend = &models.Backend{DefaultServer: &models.DefaultServer{}}
+		crInuse = false
+	}
+	if s.modeTCP {
+		backend.Mode = "tcp"
+	} else {
+		backend.Mode = "http"
+	}
+	if backend.Name, err = s.GetBackendName(); err != nil {
+		return nil, err
+	}
+	if s.service.DNS != "" {
+		backend.DefaultServer = &models.DefaultServer{InitAddr: "last,libc,none"}
+	}
+	if crInuse {
+		return backend, nil
 	}
 	for _, a := range annotations.Backend(backend, store, s.certs) {
 		err = a.Process(store, s.service.Annotations, s.ingress.Annotations, store.ConfigMaps.Main.Annotations)
 		if err != nil {
 			logger.Errorf("service '%s/%s': annotation '%s': %s", s.service.Namespace, s.service.Name, a.GetName(), err)
 		}
 	}
-	// Update Backend
-	result := deep.Equal(oldBackend, backend)
-	if len(result) != 0 {
-		if err = client.BackendEdit(*backend); err != nil {
-			return
-		}
-		reload = true
-		logger.Debugf("Ingress '%s/%s': backend '%s' updated: %s\nReload required", s.ingress.Namespace, s.ingress.Name, backend.Name, result)
-	}
-	change, errSnipp := annotations.UpdateBackendCfgSnippet(client, backend.Name)
-	logger.Error(errSnipp)
-	if len(change) != 0 {
-		reload = true
-		logger.Debugf("Ingress '%s/%s': backend '%s' updated: %s\nReload required", s.ingress.Namespace, s.ingress.Name, backend.Name, change)
-	}
-	return
+	return backend, nil
 }
 
 func getService(k8s store.K8s, namespace, name string) (*store.Service, error) {

controller/store/store.go

@@ -173,6 +173,7 @@ func (k K8s) GetNamespace(name string) *Namespace {
 			Global:     make(map[string]*models.Global),
 			Defaults:   make(map[string]*models.Defaults),
 			LogTargets: make(map[string]models.LogTargets),
+			Backends:   make(map[string]*models.Backend),
 		},
 		Status: ADDED,
 	}

controller/store/types.go

@@ -84,6 +84,7 @@ type CustomResources struct {
 	Global     map[string]*models.Global
 	Defaults   map[string]*models.Defaults
 	LogTargets map[string]models.LogTargets
+	Backends   map[string]*models.Backend
 }
 
 type IngressClass struct {