Support Config Generation

internal/events/loop.go

@@ -5,28 +5,36 @@ import (
 	"fmt"
 
 	"github.com/go-logr/logr"
+	"github.com/nginxinc/nginx-gateway-kubernetes/internal/nginx/config"
 	"github.com/nginxinc/nginx-gateway-kubernetes/internal/state"
 	"github.com/nginxinc/nginx-gateway-kubernetes/internal/status"
 	apiv1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/gateway-api/apis/v1alpha2"
 )
 
 // EventLoop is the main event loop of the Gateway.
 type EventLoop struct {
 	conf          state.Configuration
 	serviceStore  state.ServiceStore
+	generator     config.Generator
 	eventCh       <-chan interface{}
 	logger        logr.Logger
 	statusUpdater status.Updater
 }
 
 // NewEventLoop creates a new EventLoop.
-func NewEventLoop(conf state.Configuration, serviceStore state.ServiceStore, eventCh <-chan interface{},
-	statusUpdater status.Updater, logger logr.Logger) *EventLoop {
+func NewEventLoop(
+	conf state.Configuration,
+	serviceStore state.ServiceStore,
+	generator config.Generator,
+	eventCh <-chan interface{},
+	statusUpdater status.Updater,
+	logger logr.Logger,
+) *EventLoop {
 	return &EventLoop{
 		conf:          conf,
 		serviceStore:  serviceStore,
+		generator:     generator,
 		eventCh:       eventCh,
 		statusUpdater: statusUpdater,
 		logger:        logger.WithName("eventLoop"),
@@ -114,38 +122,19 @@ func (el *EventLoop) processChangesAndStatusUpdates(ctx context.Context, changes
 		fmt.Printf("%+v\n", c)
 
 		if c.Op == state.Upsert {
-			// The code below resolves service backend refs into their cluster IPs
-			// TO-DO: this code will be removed once we have the component that generates NGINX config and
-			// uses the ServiceStore to resolve services.
-			for _, g := range c.Host.PathRouteGroups {
-				for _, r := range g.Routes {
-					for _, b := range r.Source.Spec.Rules[r.RuleIdx].BackendRefs {
-						if b.BackendRef.Kind == nil || *b.BackendRef.Kind == "Service" {
-							ns := r.Source.Namespace
-							if b.BackendRef.Namespace != nil {
-								ns = string(*b.BackendRef.Namespace)
-							}
-
-							address, err := el.serviceStore.Resolve(types.NamespacedName{
-								Namespace: ns,
-								Name:      string(b.BackendRef.Name),
-							})
-
-							if err != nil {
-								fmt.Printf("Service %s/%s error: %v\n", ns, b.BackendRef.Name, err)
-								continue
-							}
-
-							var port int32 = 80
-							if b.BackendRef.Port != nil {
-								port = int32(*b.BackendRef.Port)
-							}
-
-							address = fmt.Sprintf("%s:%d", address, port)
-
-							fmt.Printf("Service %s/%s: %s\n", ns, b.BackendRef.Name, address)
-						}
-					}
+			cfg, warnings := el.generator.GenerateForHost(c.Host)
+			// TO-DO: for now, we only print the generated config, without writing it on the file system
+			// and reloading NGINX.
+			fmt.Println(string(cfg))
+
+			for obj, objWarnings := range warnings {
+				for _, w := range objWarnings {
+					// TO-DO: report warnings via Object status
+					el.logger.Info("got warning while generating config",
+						"kind", obj.GetObjectKind().GroupVersionKind().Kind,
+						"namespace", obj.GetNamespace(),
+						"name", obj.GetName(),
+						"warning", w)
 				}
 			}
 		}

internal/events/loop_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/nginxinc/nginx-gateway-kubernetes/internal/events"
+	"github.com/nginxinc/nginx-gateway-kubernetes/internal/nginx/config/configfakes"
 	"github.com/nginxinc/nginx-gateway-kubernetes/internal/state"
 	"github.com/nginxinc/nginx-gateway-kubernetes/internal/state/statefakes"
 	"github.com/nginxinc/nginx-gateway-kubernetes/internal/status/statusfakes"
@@ -35,6 +36,7 @@ var _ = Describe("EventLoop", func() {
 	var fakeConf *statefakes.FakeConfiguration
 	var fakeUpdater *statusfakes.FakeUpdater
 	var fakeServiceStore *statefakes.FakeServiceStore
+	var fakeGenerator *configfakes.FakeGenerator
 	var cancel context.CancelFunc
 	var eventCh chan interface{}
 	var errorCh chan error
@@ -44,7 +46,8 @@ var _ = Describe("EventLoop", func() {
 		eventCh = make(chan interface{})
 		fakeUpdater = &statusfakes.FakeUpdater{}
 		fakeServiceStore = &statefakes.FakeServiceStore{}
-		ctrl = events.NewEventLoop(fakeConf, fakeServiceStore, eventCh, fakeUpdater, zap.New())
+		fakeGenerator = &configfakes.FakeGenerator{}
+		ctrl = events.NewEventLoop(fakeConf, fakeServiceStore, fakeGenerator, eventCh, fakeUpdater, zap.New())
 
 		var ctx context.Context
 
@@ -66,15 +69,19 @@ var _ = Describe("EventLoop", func() {
 		})
 
 		It("should process upsert event", func() {
+			fakeChanges := []state.Change{
+				{
+					Op:   state.Upsert,
+					Host: state.Host{},
+				},
+			}
 			fakeStatusUpdates := []state.StatusUpdate{
 				{
 					NamespacedName: types.NamespacedName{},
 					Status:         nil,
 				},
 			}
-			// for now, we pass nil, because we don't need to test how EventLoop processes changes yet. We will start
-			// testing once we have NGINX Configuration Manager component.
-			fakeConf.UpsertHTTPRouteReturns(nil, fakeStatusUpdates)
+			fakeConf.UpsertHTTPRouteReturns(fakeChanges, fakeStatusUpdates)
 
 			hr := &v1alpha2.HTTPRoute{}
 
@@ -87,23 +94,30 @@ var _ = Describe("EventLoop", func() {
 				return fakeConf.UpsertHTTPRouteArgsForCall(0)
 			}).Should(Equal(hr))
 
-			Eventually(fakeUpdater.ProcessStatusUpdatesCallCount()).Should(Equal(1))
+			Eventually(fakeUpdater.ProcessStatusUpdatesCallCount).Should(Equal(1))
 			Eventually(func() []state.StatusUpdate {
 				_, updates := fakeUpdater.ProcessStatusUpdatesArgsForCall(0)
 				return updates
 			}).Should(Equal(fakeStatusUpdates))
+
+			Eventually(fakeGenerator.GenerateForHostCallCount).Should(Equal(1))
+			Expect(fakeGenerator.GenerateForHostArgsForCall(0)).Should(Equal(fakeChanges[0].Host))
 		})
 
 		It("should process delete event", func() {
+			fakeChanges := []state.Change{
+				{
+					Op:   state.Delete,
+					Host: state.Host{},
+				},
+			}
 			fakeStatusUpdates := []state.StatusUpdate{
 				{
 					NamespacedName: types.NamespacedName{},
 					Status:         nil,
 				},
 			}
-			// for now, we pass nil, because we don't need to test how EventLoop processes changes yet. We will start
-			// testing once we have NGINX Configuration Manager component.
-			fakeConf.DeleteHTTPRouteReturns(nil, fakeStatusUpdates)
+			fakeConf.DeleteHTTPRouteReturns(fakeChanges, fakeStatusUpdates)
 
 			nsname := types.NamespacedName{Namespace: "test", Name: "route"}
 
@@ -117,11 +131,15 @@ var _ = Describe("EventLoop", func() {
 				return fakeConf.DeleteHTTPRouteArgsForCall(0)
 			}).Should(Equal(nsname))
 
-			Eventually(fakeUpdater.ProcessStatusUpdatesCallCount()).Should(Equal(1))
+			Eventually(fakeUpdater.ProcessStatusUpdatesCallCount).Should(Equal(1))
 			Eventually(func() []state.StatusUpdate {
 				_, updates := fakeUpdater.ProcessStatusUpdatesArgsForCall(0)
 				return updates
 			}).Should(Equal(fakeStatusUpdates))
+
+			// TO-DO:
+			// once we have a component that processes host deletion, ensure that
+			// its corresponding method is eventually called
 		})
 	})
 

internal/helpers/helpers.go

@@ -13,3 +13,13 @@ func Diff(x, y interface{}) string {
 	}
 	return r
 }
+
+// GetStringPointer takes a string and returns a pointer to it. Useful in unit tests when initializing structs.
+func GetStringPointer(s string) *string {
+	return &s
+}
+
+// GetInt32Pointer takes an int32 and returns a pointer to it. Useful in unit tests when initializing structs.
+func GetInt32Pointer(i int32) *int32 {
+	return &i
+}

internal/manager/manager.go

@@ -11,6 +11,7 @@ import (
 	gcfg "github.com/nginxinc/nginx-gateway-kubernetes/internal/implementations/gatewayconfig"
 	hr "github.com/nginxinc/nginx-gateway-kubernetes/internal/implementations/httproute"
 	svc "github.com/nginxinc/nginx-gateway-kubernetes/internal/implementations/service"
+	ngxcfg "github.com/nginxinc/nginx-gateway-kubernetes/internal/nginx/config"
 	"github.com/nginxinc/nginx-gateway-kubernetes/internal/state"
 	"github.com/nginxinc/nginx-gateway-kubernetes/internal/status"
 	nginxgwv1alpha1 "github.com/nginxinc/nginx-gateway-kubernetes/pkg/apis/gateway/v1alpha1"
@@ -76,7 +77,8 @@ func Start(cfg config.Config) error {
 	conf := state.NewConfiguration(cfg.GatewayCtlrName, state.NewRealClock())
 	serviceStore := state.NewServiceStore()
 	reporter := status.NewUpdater(mgr.GetClient(), cfg.Logger)
-	eventLoop := events.NewEventLoop(conf, serviceStore, eventCh, reporter, cfg.Logger)
+	configGenerator := ngxcfg.NewGeneratorImpl(serviceStore)
+	eventLoop := events.NewEventLoop(conf, serviceStore, configGenerator, eventCh, reporter, cfg.Logger)
 
 	err = mgr.Add(eventLoop)
 	if err != nil {