feat: migrated to deck dump

Signed-off-by: Mattia Lavacca <[email protected]>

internal/dataplane/kong_client.go

@@ -9,6 +9,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/kong/deck/dump"
 	"github.com/kong/deck/file"
 	"github.com/kong/go-kong/kong"
 	"github.com/samber/lo"
@@ -439,22 +440,24 @@ func (c *KongClient) FetchLastGoodConfiguration(ctx context.Context) error {
 
 		var goodKongState *kongStateWithHash
 		_, err := iter.MapErr(gatewayClients, func(client **adminapi.Client) (*kongStateWithHash, error) {
-			state, rawState, err := c.configGetter.GetCurrentKongState(ctx, (*client).AdminAPIClient(), (*client).AdminAPIClient().Routes)
+			rs, err := dump.Get(ctx, (*client).AdminAPIClient(), dump.Config{})
+			if err != nil {
+				return nil, err
+			}
+			fmt.Println(rs)
+			ks := kongstate.RawStateToKongState(rs)
+
+			_, rawState, err := c.configGetter.GetCurrentKongState(ctx, (*client).AdminAPIClient(), (*client).AdminAPIClient().Routes)
 			if err != nil {
 				return nil, err
 			}
 			status, err := c.configGetter.GetCurrentStatus(ctx, (*client).AdminAPIClient())
 			if err != nil {
 				return nil, err
 			}
-			// version, err := c.configGetter.GetNodeVersion(ctx, (*client).AdminAPIClient())
-			// if err != nil {
-			// 	return nil, err
-			// }
-			// state.Version = *version
 			(*client).SetLastConfigSHA([]byte(status.ConfigurationHash))
 			kongStateWithHash := &kongStateWithHash{
-				kongState: state,
+				kongState: ks,
 				hash:      status.ConfigurationHash,
 				rawState:  rawState,
 			}

internal/dataplane/kongstate/kongstate.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/blang/semver/v4"
+	"github.com/kong/deck/utils"
 	"github.com/kong/go-kong/kong"
 	"github.com/sirupsen/logrus"
 
@@ -386,3 +387,102 @@ func (ks *KongState) FillIDs(logger logrus.FieldLogger) {
 		}
 	}
 }
+
+func RawStateToKongState(rawstate *utils.KongRawState) *KongState {
+	kongState := &KongState{}
+
+	routes := make(map[string][]*kong.Route)
+	for _, r := range rawstate.Routes {
+		if r.Service != nil && r.Service.ID != nil {
+			routes[*r.Service.ID] = append(routes[*r.Service.ID], r)
+		}
+	}
+
+	targets := make(map[string][]*kong.Target)
+	for _, u := range rawstate.Targets {
+		if u.Upstream != nil && u.Upstream.ID != nil {
+			targets[*u.Upstream.ID] = append(targets[*u.Upstream.ID], u)
+		}
+	}
+
+	for i, s := range rawstate.Services {
+		kongState.Services = append(kongState.Services, Service{
+			Service: sanitizeKongService(*s),
+			Routes:  []Route{},
+		})
+		for _, r := range routes[*s.ID] {
+			kongState.Services[i].Routes = append(kongState.Services[i].Routes, Route{
+				Route: sanitizeKongRoute(*r),
+			})
+		}
+		for _, u := range rawstate.Upstreams {
+			newUpstream := Upstream{
+				Upstream: *u,
+				Service:  kongState.Services[i],
+			}
+			if u.ID != nil {
+				newUpstream.Targets = targetsConversion(targets[*u.ID])
+			}
+			kongState.Upstreams = append(kongState.Upstreams, sanitizeUpstream(newUpstream))
+		}
+	}
+
+	kongState.CACertificates = caCertificatesConversion(rawstate.CACertificates)
+	kongState.Certificates = certificatesConversion(rawstate.Certificates)
+
+	return kongState
+}
+
+func targetsConversion(targets []*kong.Target) []Target {
+	ts := []Target{}
+
+	for _, t := range targets {
+		ts = append(ts, Target{Target: *t})
+	}
+	return ts
+}
+
+func certificatesConversion(certificates []*kong.Certificate) []Certificate {
+	certs := []Certificate{}
+
+	for _, c := range certificates {
+		certs = append(certs, Certificate{
+			Certificate: *c,
+		})
+	}
+	return certs
+}
+
+func caCertificatesConversion(certificates []*kong.CACertificate) []kong.CACertificate {
+	certs := []kong.CACertificate{}
+
+	for _, c := range certificates {
+		certs = append(certs, *c)
+	}
+	return certs
+}
+
+func sanitizeKongService(service kong.Service) kong.Service {
+	service.CreatedAt = nil
+	service.ID = nil
+	service.UpdatedAt = nil
+	return service
+}
+
+func sanitizeKongRoute(route kong.Route) kong.Route {
+	route.CreatedAt = nil
+	route.ID = nil
+	route.UpdatedAt = nil
+	return route
+}
+
+func sanitizeUpstream(upstream Upstream) Upstream {
+	upstream.Upstream.CreatedAt = nil
+	upstream.Upstream.ID = nil
+	for i := range upstream.Targets {
+		upstream.Targets[i].CreatedAt = nil
+		upstream.Targets[i].ID = nil
+		upstream.Targets[i].Upstream = nil
+	}
+	return upstream
+}