@@ -8,42 +8,39 @@ import (
88 apiv1 "k8s.io/api/core/v1"
99 "sigs.k8s.io/gateway-api/apis/v1alpha2"
1010
11+ "github.com/nginxinc/nginx-kubernetes-gateway/internal/newstate"
1112 "github.com/nginxinc/nginx-kubernetes-gateway/internal/nginx/config"
1213 "github.com/nginxinc/nginx-kubernetes-gateway/internal/nginx/file"
1314 "github.com/nginxinc/nginx-kubernetes-gateway/internal/nginx/runtime"
1415 "github.com/nginxinc/nginx-kubernetes-gateway/internal/state"
15- "github.com/nginxinc/nginx-kubernetes-gateway/internal/status"
1616)
1717
1818// EventLoop is the main event loop of the Gateway.
1919type EventLoop struct {
20- conf state. Configuration
20+ processor newstate. ChangeProcessor
2121 serviceStore state.ServiceStore
2222 generator config.Generator
2323 eventCh <- chan interface {}
2424 logger logr.Logger
25- statusUpdater status.Updater
2625 nginxFileMgr file.Manager
2726 nginxRuntimeMgr runtime.Manager
2827}
2928
3029// NewEventLoop creates a new EventLoop.
3130func NewEventLoop (
32- conf state. Configuration ,
31+ processor newstate. ChangeProcessor ,
3332 serviceStore state.ServiceStore ,
3433 generator config.Generator ,
3534 eventCh <- chan interface {},
36- statusUpdater status.Updater ,
3735 logger logr.Logger ,
3836 nginxFileMgr file.Manager ,
3937 nginxRuntimeMgr runtime.Manager ,
4038) * EventLoop {
4139 return & EventLoop {
42- conf : conf ,
40+ processor : processor ,
4341 serviceStore : serviceStore ,
4442 generator : generator ,
4543 eventCh : eventCh ,
46- statusUpdater : statusUpdater ,
4744 logger : logger .WithName ("eventLoop" ),
4845 nginxFileMgr : nginxFileMgr ,
4946 nginxRuntimeMgr : nginxRuntimeMgr ,
@@ -58,112 +55,94 @@ func (el *EventLoop) Start(ctx context.Context) error {
5855 for {
5956 select {
6057 case <- ctx .Done ():
58+ // although we always return nil, Start must return it to satisfy
59+ // "sigs.k8s.io/controller-runtime/pkg/manager".Runnable
6160 return nil
6261 case e := <- el .eventCh :
63- err := el .handleEvent (ctx , e )
64- if err != nil {
65- return err
66- }
62+ el .handleEvent (ctx , e )
6763 }
6864 }
6965}
7066
7167// FIXME(pleshakov): think about how to avoid using an interface{} here
72- func (el * EventLoop ) handleEvent (ctx context.Context , event interface {}) error {
73- var changes []state.Change
74- var updates []state.StatusUpdate
75- var err error
76-
68+ func (el * EventLoop ) handleEvent (ctx context.Context , event interface {}) {
7769 switch e := event .(type ) {
7870 case * UpsertEvent :
79- changes , updates , err = el .propagateUpsert (e )
71+ el .propagateUpsert (e )
8072 case * DeleteEvent :
81- changes , updates , err = el .propagateDelete (e )
73+ el .propagateDelete (e )
8274 default :
83- // FIXME(pleshakov): panic because it is a coding error
84- return fmt .Errorf ("unknown event type %T" , e )
75+ panic (fmt .Errorf ("unknown event type %T" , e ))
76+ }
77+
78+ changed , conf , statuses := el .processor .Process ()
79+ if ! changed {
80+ return
8581 }
8682
83+ err := el .updateNginx (ctx , conf )
84+ if err != nil {
85+ el .logger .Error (err , "Failed to update NGINX configuration" )
86+ }
87+
88+ // FIXME(pleshakov) Update resource statuses instead of printing to stdout
89+ for name , s := range statuses .ListenerStatuses {
90+ fmt .Printf ("Listener %q, Statuses: %v\n " , name , s )
91+ }
92+ for nsname , s := range statuses .HTTPRouteStatuses {
93+ fmt .Printf ("HTTPRoute %q, Statuses: %v\n " , nsname , s )
94+ }
95+ }
96+
97+ func (el * EventLoop ) updateNginx (ctx context.Context , conf newstate.Configuration ) error {
98+ cfg , warnings := el .generator .Generate (conf )
99+
100+ // For now, we keep all http servers in one config
101+ // We might rethink that. For example, we can write each server to its file
102+ // or group servers in some way.
103+ err := el .nginxFileMgr .WriteHTTPServersConfig ("http-servers" , cfg )
87104 if err != nil {
88105 return err
89106 }
90107
91- el .processChangesAndStatusUpdates (ctx , changes , updates )
92- return nil
108+ for obj , objWarnings := range warnings {
109+ for _ , w := range objWarnings {
110+ // FIXME(pleshakov): report warnings via Object status
111+ el .logger .Info ("got warning while generating config" ,
112+ "kind" , obj .GetObjectKind ().GroupVersionKind ().Kind ,
113+ "namespace" , obj .GetNamespace (),
114+ "name" , obj .GetName (),
115+ "warning" , w )
116+ }
117+ }
118+
119+ return el .nginxRuntimeMgr .Reload (ctx )
93120}
94121
95- func (el * EventLoop ) propagateUpsert (e * UpsertEvent ) ([]state. Change , []state. StatusUpdate , error ) {
122+ func (el * EventLoop ) propagateUpsert (e * UpsertEvent ) {
96123 switch r := e .Resource .(type ) {
124+ case * v1alpha2.Gateway :
125+ el .processor .CaptureUpsertChange (r )
97126 case * v1alpha2.HTTPRoute :
98- changes , statusUpdates := el .conf .UpsertHTTPRoute (r )
99- return changes , statusUpdates , nil
127+ el .processor .CaptureUpsertChange (r )
100128 case * apiv1.Service :
101- el .serviceStore .Upsert (r )
102129 // FIXME(pleshakov): make sure the affected hosts are updated
103- return nil , nil , nil
130+ el .serviceStore .Upsert (r )
131+ default :
132+ panic (fmt .Errorf ("unknown resource type %T" , e .Resource ))
104133 }
105-
106- // FIXME(pleshakov): panic because it is a coding error
107- return nil , nil , fmt .Errorf ("unknown resource type %T" , e .Resource )
108134}
109135
110- func (el * EventLoop ) propagateDelete (e * DeleteEvent ) ([]state. Change , []state. StatusUpdate , error ) {
136+ func (el * EventLoop ) propagateDelete (e * DeleteEvent ) {
111137 switch e .Type .(type ) {
138+ case * v1alpha2.Gateway :
139+ el .processor .CaptureDeleteChange (e .Type , e .NamespacedName )
112140 case * v1alpha2.HTTPRoute :
113- changes , statusUpdates := el .conf .DeleteHTTPRoute (e .NamespacedName )
114- return changes , statusUpdates , nil
141+ el .processor .CaptureDeleteChange (e .Type , e .NamespacedName )
115142 case * apiv1.Service :
116- el .serviceStore .Delete (e .NamespacedName )
117143 // FIXME(pleshakov): make sure the affected hosts are updated
118- return nil , nil , nil
119- }
120-
121- // FIXME(pleshakov): panic because it is a coding error
122- return nil , nil , fmt .Errorf ("unknown resource type %T" , e .Type )
123- }
124-
125- func (el * EventLoop ) processChangesAndStatusUpdates (ctx context.Context , changes []state.Change , updates []state.StatusUpdate ) {
126- for _ , c := range changes {
127- el .logger .Info ("Processing a change" ,
128- "host" , c .Host .Value )
129-
130- if c .Op == state .Upsert {
131- cfg , warnings := el .generator .GenerateForHost (c .Host )
132-
133- for obj , objWarnings := range warnings {
134- for _ , w := range objWarnings {
135- // FIXME(pleshakov): report warnings via Object status
136- el .logger .Info ("got warning while generating config" ,
137- "kind" , obj .GetObjectKind ().GroupVersionKind ().Kind ,
138- "namespace" , obj .GetNamespace (),
139- "name" , obj .GetName (),
140- "warning" , w )
141- }
142- }
143-
144- el .logger .Info ("Writing configuration" ,
145- "host" , c .Host .Value )
146-
147- err := el .nginxFileMgr .WriteServerConfig (c .Host .Value , cfg )
148- if err != nil {
149- el .logger .Error (err , "Failed to write configuration" ,
150- "host" , c .Host .Value )
151- }
152- } else {
153- err := el .nginxFileMgr .DeleteServerConfig (c .Host .Value )
154- if err != nil {
155- el .logger .Error (err , "Failed to delete configuration" ,
156- "host" , c .Host .Value )
157- }
158- }
159- }
160-
161- if len (changes ) > 0 {
162- err := el .nginxRuntimeMgr .Reload (ctx )
163- if err != nil {
164- el .logger .Error (err , "Failed to reload NGINX" )
165- }
144+ el .serviceStore .Delete (e .NamespacedName )
145+ default :
146+ panic (fmt .Errorf ("unknown resource type %T" , e .Type ))
166147 }
167-
168- el .statusUpdater .ProcessStatusUpdates (ctx , updates )
169148}
0 commit comments