WMS conversion

Makefile

@@ -43,7 +43,8 @@ help: ## Display this help.
 
 .PHONY: manifests
 manifests: controller-gen ## Generate WebhookConfiguration, ClusterRole and CustomResourceDefinition objects.
-	$(CONTROLLER_GEN) rbac:roleName=manager-role crd webhook paths="./..." output:crd:artifacts:config=config/crd/bases
+	$(CONTROLLER_GEN) rbac:roleName=manager-role crd:allowDangerousTypes=true webhook paths="./..." output:crd:artifacts:config=config/crd/bases
+## allowDangerousTypes=true for v2beta structs
 
 .PHONY: generate
 generate: controller-gen ## Generate code containing DeepCopy, DeepCopyInto, and DeepCopyObject method implementations.

api/v2beta1/shared_conversion.go

@@ -2,6 +2,7 @@ package v2beta1
 
 import (
 	pdoknlv3 "github.com/pdok/mapserver-operator/api/v3"
+	shared_model "github.com/pdok/smooth-operator/model"
 	autoscalingv2 "k8s.io/api/autoscaling/v2beta1"
 	corev1 "k8s.io/api/core/v1"
 )
@@ -10,12 +11,36 @@ func Pointer[T interface{}](val T) *T {
 	return &val
 }
 
-func PointerValWithDefault[T interface{}](ptr *T, defaultValue T) T {
-	if ptr == nil {
-		return defaultValue
+func PointerVal[T interface{}](val *T, def T) T {
+	if val == nil {
+		return def
+	} else {
+		return *val
 	}
+}
 
-	return *ptr
+func ConverseOptionsV2ToV3(src WMSWFSOptions) *pdoknlv3.Options {
+	return &pdoknlv3.Options{
+		AutomaticCasing:             src.AutomaticCasing,
+		IncludeIngress:              src.IncludeIngress,
+		PrefetchData:                src.PrefetchData,
+		ValidateRequests:            src.ValidateRequests,
+		RewriteGroupToDataLayers:    src.RewriteGroupToDataLayers,
+		DisableWebserviceProxy:      src.DisableWebserviceProxy,
+		ValidateChildStyleNameEqual: src.ValidateChildStyleNameEqual,
+	}
+}
+
+func ConverseOptionsV3ToV2(src *pdoknlv3.Options) WMSWFSOptions {
+	return WMSWFSOptions{
+		AutomaticCasing:             src.AutomaticCasing,
+		PrefetchData:                src.PrefetchData,
+		IncludeIngress:              src.IncludeIngress,
+		ValidateRequests:            src.ValidateRequests,
+		RewriteGroupToDataLayers:    src.RewriteGroupToDataLayers,
+		DisableWebserviceProxy:      src.DisableWebserviceProxy,
+		ValidateChildStyleNameEqual: src.ValidateChildStyleNameEqual,
+	}
 }
 
 func ConverseAutoscaling(src Autoscaling) *autoscalingv2.HorizontalPodAutoscalerSpec {
@@ -89,3 +114,128 @@ func ConverseColumnsWithAliasV3ToColumnsAndAliasesV2(columns []pdoknlv3.Columns)
 
 	return v2Columns, v2Aliases
 }
+
+func ConverseV2DataToV3(v2 Data) pdoknlv3.Data {
+	v3 := pdoknlv3.Data{}
+
+	if v2.GPKG != nil {
+		v3.Gpkg = &pdoknlv3.Gpkg{
+			BlobKey:      v2.GPKG.BlobKey,
+			TableName:    v2.GPKG.Table,
+			GeometryType: v2.GPKG.GeometryType,
+			Columns: ConverseColumnAndAliasesV2ToColumnsWithAliasV3(
+				v2.GPKG.Columns,
+				v2.GPKG.Aliases,
+			),
+		}
+	}
+
+	if v2.Postgis != nil {
+		v3.Postgis = &pdoknlv3.Postgis{
+			TableName:    v2.Postgis.Table,
+			GeometryType: v2.Postgis.GeometryType,
+			Columns: ConverseColumnAndAliasesV2ToColumnsWithAliasV3(
+				v2.Postgis.Columns,
+				v2.Postgis.Aliases,
+			),
+		}
+	}
+
+	if v2.Tif != nil {
+		v3.TIF = &pdoknlv3.TIF{
+			BlobKey:                     v2.Tif.BlobKey,
+			Resample:                    v2.Tif.Resample,
+			Offsite:                     v2.Tif.Offsite,
+			GetFeatureInfoIncludesClass: v2.Tif.GetFeatureInfoIncludesClass,
+		}
+	}
+
+	return v3
+}
+
+func ConverseV3DataToV2(v3 pdoknlv3.Data) Data {
+	v2 := Data{}
+
+	if v3.Gpkg != nil {
+		columns, aliases := ConverseColumnsWithAliasV3ToColumnsAndAliasesV2(v3.Gpkg.Columns)
+		v2.GPKG = &GPKG{
+			BlobKey:      v3.Gpkg.BlobKey,
+			Table:        v3.Gpkg.TableName,
+			GeometryType: v3.Gpkg.GeometryType,
+			Columns:      columns,
+			Aliases:      aliases,
+		}
+	}
+
+	if v3.Postgis != nil {
+		columns, aliases := ConverseColumnsWithAliasV3ToColumnsAndAliasesV2(v3.Postgis.Columns)
+		v2.Postgis = &Postgis{
+			Table:        v3.Postgis.TableName,
+			GeometryType: v3.Postgis.GeometryType,
+			Columns:      columns,
+			Aliases:      aliases,
+		}
+	}
+
+	if v3.TIF != nil {
+		v2.Tif = &Tif{
+			BlobKey:                     v3.TIF.BlobKey,
+			Offsite:                     v3.TIF.Offsite,
+			Resample:                    v3.TIF.Resample,
+			GetFeatureInfoIncludesClass: v3.TIF.GetFeatureInfoIncludesClass,
+		}
+	}
+
+	return v2
+}
+
+func NewV2KubernetesObject(lifecycle *shared_model.Lifecycle, podSpecPatch *corev1.PodSpec, scalingSpec *autoscalingv2.HorizontalPodAutoscalerSpec) Kubernetes {
+	kub := Kubernetes{}
+
+	if lifecycle != nil && lifecycle.TTLInDays != nil {
+		kub.Lifecycle = &Lifecycle{
+			TTLInDays: Pointer(int(*lifecycle.TTLInDays)),
+		}
+	}
+
+	// TODO - healthcheck
+	if podSpecPatch != nil {
+		kub.Resources = &podSpecPatch.Containers[0].Resources
+	}
+
+	if scalingSpec != nil {
+		kub.Autoscaling = &Autoscaling{
+			MaxReplicas: Pointer(int(scalingSpec.MaxReplicas)),
+		}
+
+		if scalingSpec.MinReplicas != nil {
+			kub.Autoscaling.MinReplicas = Pointer(int(*scalingSpec.MinReplicas))
+		}
+
+		if scalingSpec.Metrics != nil {
+			kub.Autoscaling.AverageCPUUtilization = Pointer(
+				int(*scalingSpec.Metrics[0].Resource.TargetAverageUtilization),
+			)
+		}
+	}
+
+	return kub
+}
+
+func LabelsToV2General(labels map[string]string) General {
+	general := General{
+		Dataset:      labels["dataset"],
+		DatasetOwner: labels["dataset-owner"],
+		DataVersion:  nil,
+	}
+
+	if serviceVersion, ok := labels["service-version"]; ok {
+		general.ServiceVersion = &serviceVersion
+	}
+
+	if theme, ok := labels["theme"]; ok {
+		general.Theme = &theme
+	}
+
+	return general
+}

api/v2beta1/wfs_conversion.go

@@ -57,13 +57,9 @@ func (src *WFS) ConvertTo(dstRaw conversion.Hub) error {
 		dst.Spec.PodSpecPatch = ConverseResources(*src.Spec.Kubernetes.Resources)
 	}
 
-	dst.Spec.Options = &pdoknlv3.Options{
-		AutomaticCasing: src.Spec.Options.AutomaticCasing,
-		PrefetchData:    PointerValWithDefault(src.Spec.Options.PrefetchData, false),
-		IncludeIngress:  src.Spec.Options.IncludeIngress,
-	}
+	dst.Spec.Options = ConverseOptionsV2ToV3(src.Spec.Options)
 
-	service := pdoknlv3.Service{
+	service := pdoknlv3.WFSService{
 		Prefix:            "",
 		BaseURL:           "https://service.pdok.nl",
 		OwnerInfoRef:      "pdok",
@@ -141,28 +137,7 @@ func convertV2FeatureTypeToV3(src FeatureType) pdoknlv3.FeatureType {
 		}
 	}
 
-	if src.Data.GPKG != nil {
-		featureTypeV3.Data.Gpkg = &pdoknlv3.Gpkg{
-			BlobKey:      src.Data.GPKG.BlobKey,
-			TableName:    src.Data.GPKG.Table,
-			GeometryType: src.Data.GPKG.GeometryType,
-			Columns: ConverseColumnAndAliasesV2ToColumnsWithAliasV3(
-				src.Data.GPKG.Columns,
-				src.Data.GPKG.Aliases,
-			),
-		}
-	}
-
-	if src.Data.Postgis != nil {
-		featureTypeV3.Data.Postgis = &pdoknlv3.Postgis{
-			TableName:    src.Data.Postgis.Table,
-			GeometryType: src.Data.Postgis.GeometryType,
-			Columns: ConverseColumnAndAliasesV2ToColumnsWithAliasV3(
-				src.Data.Postgis.Columns,
-				src.Data.Postgis.Aliases,
-			),
-		}
-	}
+	featureTypeV3.Data = ConverseV2DataToV3(src.Data)
 
 	return featureTypeV3
 }
@@ -177,55 +152,12 @@ func (dst *WFS) ConvertFrom(srcRaw conversion.Hub) error {
 
 	dst.ObjectMeta = src.ObjectMeta
 
-	dst.Spec.General = General{
-		Dataset:      src.ObjectMeta.Labels["dataset"],
-		DatasetOwner: src.ObjectMeta.Labels["dataset-owner"],
-		DataVersion:  nil,
-	}
-
-	if serviceVersion, ok := src.ObjectMeta.Labels["service-version"]; ok {
-		dst.Spec.General.ServiceVersion = &serviceVersion
-	}
-
-	if theme, ok := src.ObjectMeta.Labels["theme"]; ok {
-		dst.Spec.General.Theme = &theme
-	}
-
-	dst.Spec.Kubernetes = Kubernetes{}
-
-	if src.Spec.Lifecycle != nil && src.Spec.Lifecycle.TTLInDays != nil {
-		dst.Spec.Kubernetes.Lifecycle = &Lifecycle{
-			TTLInDays: Pointer(int(*src.Spec.Lifecycle.TTLInDays)),
-		}
-	}
-
-	// TODO - healthcheck
-	if src.Spec.PodSpecPatch != nil {
-		dst.Spec.Kubernetes.Resources = &src.Spec.PodSpecPatch.Containers[0].Resources
-	}
-
-	if src.Spec.HorizontalPodAutoscalerPatch != nil {
-		dst.Spec.Kubernetes.Autoscaling = &Autoscaling{
-			MaxReplicas: Pointer(int(src.Spec.HorizontalPodAutoscalerPatch.MaxReplicas)),
-		}
-
-		if src.Spec.HorizontalPodAutoscalerPatch.MinReplicas != nil {
-			dst.Spec.Kubernetes.Autoscaling.MinReplicas = Pointer(int(*src.Spec.HorizontalPodAutoscalerPatch.MinReplicas))
-		}
+	dst.Spec.General = LabelsToV2General(src.ObjectMeta.Labels)
 
-		if src.Spec.HorizontalPodAutoscalerPatch.Metrics != nil {
-			dst.Spec.Kubernetes.Autoscaling.AverageCPUUtilization = Pointer(
-				int(*src.Spec.HorizontalPodAutoscalerPatch.Metrics[0].Resource.TargetAverageUtilization),
-			)
-		}
-	}
+	dst.Spec.Kubernetes = NewV2KubernetesObject(src.Spec.Lifecycle, src.Spec.PodSpecPatch, src.Spec.HorizontalPodAutoscalerPatch)
 
-	if src.Spec.Options == nil {
-		dst.Spec.Options = WMSWFSOptions{
-			AutomaticCasing: src.Spec.Options.AutomaticCasing,
-			PrefetchData:    &src.Spec.Options.PrefetchData,
-			IncludeIngress:  src.Spec.Options.IncludeIngress,
-		}
+	if src.Spec.Options != nil {
+		dst.Spec.Options = ConverseOptionsV3ToV2(src.Spec.Options)
 	}
 
 	service := WFSService{
@@ -258,6 +190,7 @@ func (dst *WFS) ConvertFrom(srcRaw conversion.Hub) error {
 		service.MetadataIdentifier = src.Spec.Service.Inspire.ServiceMetadataURL.CSW.MetadataIdentifier
 	} else {
 		service.Inspire = false
+		// TODO unable to fill in MetadataIdentifier here untill we know how to handle non inspire services
 	}
 
 	for _, featureType := range src.Spec.Service.FeatureTypes {
@@ -268,7 +201,7 @@ func (dst *WFS) ConvertFrom(srcRaw conversion.Hub) error {
 			Keywords:                  featureType.Keywords,
 			DatasetMetadataIdentifier: featureType.DatasetMetadataURL.CSW.MetadataIdentifier,
 			SourceMetadataIdentifier:  "",
-			Data:                      Data{},
+			Data:                      ConverseV3DataToV2(featureType.Data),
 		}
 
 		if src.Spec.Service.Inspire != nil {
@@ -279,27 +212,6 @@ func (dst *WFS) ConvertFrom(srcRaw conversion.Hub) error {
 			featureTypeV2.Extent = Pointer(featureType.Bbox.DefaultCRS.ToExtent())
 		}
 
-		if featureType.Data.Gpkg != nil {
-			columns, aliases := ConverseColumnsWithAliasV3ToColumnsAndAliasesV2(featureType.Data.Gpkg.Columns)
-			featureTypeV2.Data.GPKG = &GPKG{
-				BlobKey:      featureType.Data.Gpkg.BlobKey,
-				Table:        featureType.Data.Gpkg.TableName,
-				GeometryType: featureType.Data.Gpkg.GeometryType,
-				Columns:      columns,
-				Aliases:      aliases,
-			}
-		}
-
-		if featureType.Data.Postgis != nil {
-			columns, aliases := ConverseColumnsWithAliasV3ToColumnsAndAliasesV2(featureType.Data.Postgis.Columns)
-			featureTypeV2.Data.Postgis = &Postgis{
-				Table:        featureType.Data.Postgis.TableName,
-				GeometryType: featureType.Data.Postgis.GeometryType,
-				Columns:      columns,
-				Aliases:      aliases,
-			}
-		}
-
 		service.FeatureTypes = append(service.FeatureTypes, featureTypeV2)
 	}