Fix Ops type validating (#1517)

obaydullahmhs · web-flow · commit fc0225614293 · 2025-09-17T17:13:46.000+06:00
Signed-off-by: obaydullahmhs &lt;obaydullah@appscode.com&gt;
diff --git a/pkg/webhooks/ops/v1alpha1/cassandra.go b/pkg/webhooks/ops/v1alpha1/cassandra.go
@@ -82,6 +82,11 @@ func (w *CassandraOpsRequestCustomWebhook) ValidateDelete(ctx context.Context, o
 }
 
 func (rv *CassandraOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.CassandraOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.CassandraOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Cassandra are %s", req.Spec.Type, strings.Join(opsapi.CassandraOpsRequestTypeNames(), ", ")))
+	}
+
 	var allErr field.ErrorList
 	switch req.GetRequestType().(opsapi.CassandraOpsRequestType) {
 	case opsapi.CassandraOpsRequestTypeRestart:
@@ -136,10 +141,6 @@ func (rv *CassandraOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.C
 		}
 	}
 
-	if validType, _ := arrays.Contains(opsapi.CassandraOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Cassandra are %s", req.Spec.Type, strings.Join(opsapi.CassandraOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/clickhouse.go b/pkg/webhooks/ops/v1alpha1/clickhouse.go
@@ -79,6 +79,10 @@ func (w *ClickHouseOpsRequestCustomWebhook) ValidateDelete(ctx context.Context,
 }
 
 func (rv *ClickHouseOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.ClickHouseOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.ClickHouseOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for ClickHouse are %s", req.Spec.Type, strings.Join(opsapi.ClickHouseOpsRequestTypeNames(), ", ")))
+	}
 	var allErr field.ErrorList
 	switch req.GetRequestType().(opsapi.ClickHouseOpsRequestType) {
 	case opsapi.ClickHouseOpsRequestTypeRestart:
@@ -94,10 +98,7 @@ func (rv *ClickHouseOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.
 				err.Error()))
 		}
 	}
-	if validType, _ := arrays.Contains(opsapi.ClickHouseOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for ClickHouse are %s", req.Spec.Type, strings.Join(opsapi.ClickHouseOpsRequestTypeNames(), ", "))))
-	}
+
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/druid.go b/pkg/webhooks/ops/v1alpha1/druid.go
@@ -110,6 +110,10 @@ func validateDruidOpsRequest(req *opsapi.DruidOpsRequest, oldReq *opsapi.DruidOp
 }
 
 func (w *DruidOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.DruidOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.DruidOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Druid are %s", req.Spec.Type, strings.Join(opsapi.DruidOpsRequestTypeNames(), ", ")))
+	}
 	druid, err := w.hasDatabaseRef(req)
 	if err != nil {
 		return err
@@ -169,10 +173,6 @@ func (w *DruidOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.DruidO
 		}
 	}
 
-	if validType, _ := arrays.Contains(opsapi.DruidOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Druid are %s", req.Spec.Type, strings.Join(opsapi.DruidOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/elasticsearch.go b/pkg/webhooks/ops/v1alpha1/elasticsearch.go
@@ -130,6 +130,10 @@ func (w *ElasticsearchOpsRequestCustomWebhook) validateOpensearchVersionCompatib
 }
 
 func (w *ElasticsearchOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.ElasticsearchOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.ElasticsearchOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Elasticsearch are %s", req.Spec.Type, strings.Join(opsapi.ElasticsearchOpsRequestTypeNames(), ", ")))
+	}
 	var allErr field.ErrorList
 	db := &dbapi.Elasticsearch{}
 	err := w.DefaultClient.Get(context.TODO(), types.NamespacedName{
@@ -155,10 +159,6 @@ func (w *ElasticsearchOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsap
 		}
 	}
 
-	if validType, _ := arrays.Contains(opsapi.ElasticsearchOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Elasticsearch are %s", req.Spec.Type, strings.Join(opsapi.ElasticsearchOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/ferretdb.go b/pkg/webhooks/ops/v1alpha1/ferretdb.go
@@ -101,6 +101,11 @@ func validateFerretDBOpsRequest(req *opsapi.FerretDBOpsRequest, oldReq *opsapi.F
 }
 
 func (w *FerretDBOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.FerretDBOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.FerretDBOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for FerretDB are %s", req.Spec.Type, strings.Join(opsapi.FerretDBOpsRequestTypeNames(), ", ")))
+	}
+
 	var allErr field.ErrorList
 	switch req.GetRequestType().(opsapi.FerretDBOpsRequestType) {
 	case opsapi.FerretDBOpsRequestTypeRestart:
@@ -124,10 +129,6 @@ func (w *FerretDBOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.Fer
 		}
 	}
 
-	if validType, _ := arrays.Contains(opsapi.FerretDBOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for FerretDB are %s", req.Spec.Type, strings.Join(opsapi.FerretDBOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/hazelcast.go b/pkg/webhooks/ops/v1alpha1/hazelcast.go
@@ -105,6 +105,11 @@ func validateHazelcastOpsRequest(req *opsapi.HazelcastOpsRequest, oldReq *opsapi
 }
 
 func (w *HazelcastOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.HazelcastOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.HazelcastOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Hazelcast are %s", req.Spec.Type, strings.Join(opsapi.HazelcastOpsRequestTypeNames(), ", ")))
+	}
+
 	var allErr field.ErrorList
 	switch req.GetRequestType().(opsapi.HazelcastOpsRequestType) {
 	case opsapi.HazelcastOpsRequestTypeRestart:
@@ -157,10 +162,6 @@ func (w *HazelcastOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.Ha
 		}
 	}
 
-	if validType, _ := arrays.Contains(opsapi.HazelcastOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Hazelcast are %s", req.Spec.Type, strings.Join(opsapi.HazelcastOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/ignite.go b/pkg/webhooks/ops/v1alpha1/ignite.go
@@ -105,6 +105,11 @@ func validateIgniteOpsRequest(req *opsapi.IgniteOpsRequest, oldReq *opsapi.Ignit
 }
 
 func (rv *IgniteOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.IgniteOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.IgniteOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Ignite are %s", req.Spec.Type, strings.Join(opsapi.IgniteOpsRequestTypeNames(), ", ")))
+	}
+
 	var allErr field.ErrorList
 	switch req.GetRequestType().(opsapi.IgniteOpsRequestType) {
 	case opsapi.IgniteOpsRequestTypeRestart:
@@ -157,10 +162,6 @@ func (rv *IgniteOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.Igni
 		}
 	}
 
-	if validType, _ := arrays.Contains(opsapi.IgniteOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Ignite are %s", req.Spec.Type, strings.Join(opsapi.IgniteOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/kafka.go b/pkg/webhooks/ops/v1alpha1/kafka.go
@@ -110,6 +110,11 @@ func validateKafkaOpsRequest(req *opsapi.KafkaOpsRequest, oldReq *opsapi.KafkaOp
 }
 
 func (w *KafkaOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.KafkaOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.KafkaOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Kafka are %s", req.Spec.Type, strings.Join(opsapi.KafkaOpsRequestTypeNames(), ", ")))
+	}
+
 	var (
 		err   error
 		kafka *dbapi.Kafka
@@ -164,10 +169,6 @@ func (w *KafkaOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.KafkaO
 		}
 	}
 
-	if validType, _ := arrays.Contains(opsapi.KafkaOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for kafka are %s", req.Spec.Type, strings.Join(opsapi.KafkaOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/mariadb.go b/pkg/webhooks/ops/v1alpha1/mariadb.go
@@ -91,6 +91,11 @@ func (w *MariaDBOpsRequestCustomWebhook) ValidateDelete(ctx context.Context, obj
 }
 
 func (w *MariaDBOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.MariaDBOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.MariaDBOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for MariaDB are %s", req.Spec.Type, strings.Join(opsapi.MariaDBOpsRequestTypeNames(), ", ")))
+	}
+
 	var allErr field.ErrorList
 	switch req.GetRequestType().(opsapi.MariaDBOpsRequestType) {
 	case opsapi.MariaDBOpsRequestTypeRestart:
@@ -144,10 +149,6 @@ func (w *MariaDBOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.Mari
 
 	}
 
-	if validType, _ := arrays.Contains(opsapi.MariaDBOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for MariaDB are %s", req.Spec.Type, strings.Join(opsapi.MariaDBOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/memcached.go b/pkg/webhooks/ops/v1alpha1/memcached.go
@@ -106,6 +106,11 @@ func validateMemcachedOpsRequest(req *opsapi.MemcachedOpsRequest, oldReq *opsapi
 }
 
 func (c *MemcachedOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.MemcachedOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.MemcachedOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Memcached are %s", req.Spec.Type, strings.Join(opsapi.MemcachedOpsRequestTypeNames(), ", ")))
+	}
+
 	var allErr field.ErrorList
 	switch req.GetRequestType().(opsapi.MemcachedOpsRequestType) {
 	case opsapi.MemcachedOpsRequestTypeRestart:
@@ -153,10 +158,6 @@ func (c *MemcachedOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.Me
 		}
 	}
 
-	if validType, _ := arrays.Contains(opsapi.MemcachedOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Memcached are %s", req.Spec.Type, strings.Join(opsapi.MemcachedOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/mongodb.go b/pkg/webhooks/ops/v1alpha1/mongodb.go
@@ -26,7 +26,6 @@ import (
 	dbapi "kubedb.dev/apimachinery/apis/kubedb/v1"
 	opsapi "kubedb.dev/apimachinery/apis/ops/v1alpha1"
 
-	"gomodules.xyz/x/arrays"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	kerr "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -93,13 +92,13 @@ func (w *MongoDBOpsRequestCustomWebhook) ValidateDelete(ctx context.Context, obj
 }
 
 func (w *MongoDBOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.MongoDBOpsRequest) error {
-	var allErr field.ErrorList
 	// validate MongoDBOpsRequest specs
-	if !IsOpsTypeSupported(opsapi.MongoDBOpsRequestTypeNames(), string(req.Spec.Type)) {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for MongoDB are %s", req.Spec.Type, strings.Join(opsapi.MongoDBOpsRequestTypeNames(), ", "))))
+	if !IsOpsTypeSupported(opsapi.MongoDBOpsRequestTypeNames(), string(string(req.Spec.Type))) {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for MongoDB are %s", req.Spec.Type, strings.Join(opsapi.MongoDBOpsRequestTypeNames(), ", ")))
 	}
 
+	var allErr field.ErrorList
 	var db dbapi.MongoDB
 	err := w.DefaultClient.Get(context.TODO(), types.NamespacedName{
 		Name:      req.GetDBRefName(),
@@ -124,10 +123,7 @@ func (w *MongoDBOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.Mong
 				err.Error()))
 		}
 	}
-	if validType, _ := arrays.Contains(opsapi.MongoDBOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for MongoDB are %s", req.Spec.Type, strings.Join(opsapi.MongoDBOpsRequestTypeNames(), ", "))))
-	}
+
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/mssqlserver.go b/pkg/webhooks/ops/v1alpha1/mssqlserver.go
@@ -107,6 +107,11 @@ func validateMSSQLServerOpsRequest(req *opsapi.MSSQLServerOpsRequest, oldReq *op
 }
 
 func (w *MSSQLServerOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.MSSQLServerOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.MSSQLServerOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for MSSQLServer are %s", req.Spec.Type, strings.Join(opsapi.MSSQLServerOpsRequestTypeNames(), ", ")))
+	}
+
 	var allErr field.ErrorList
 	switch req.GetRequestType().(opsapi.MSSQLServerOpsRequestType) {
 	case opsapi.MSSQLServerOpsRequestTypeRestart:
@@ -160,10 +165,6 @@ func (w *MSSQLServerOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.
 
 	}
 
-	if validType, _ := arrays.Contains(opsapi.MSSQLServerOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for MSSQLServer are %s", req.Spec.Type, strings.Join(opsapi.MSSQLServerOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/mysql.go b/pkg/webhooks/ops/v1alpha1/mysql.go
@@ -92,6 +92,11 @@ func (w *MySQLOpsRequestCustomWebhook) ValidateDelete(ctx context.Context, obj r
 }
 
 func (w *MySQLOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.MySQLOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.MySQLOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for MySQL are %s", req.Spec.Type, strings.Join(opsapi.MySQLOpsRequestTypeNames(), ", ")))
+	}
+
 	var allErr field.ErrorList
 	switch req.GetRequestType().(opsapi.MySQLOpsRequestType) {
 	case opsapi.MySQLOpsRequestTypeRestart:
@@ -157,10 +162,6 @@ func (w *MySQLOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.MySQLO
 
 	}
 
-	if validType, _ := arrays.Contains(opsapi.MySQLOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for MySQL are %s", req.Spec.Type, strings.Join(opsapi.MySQLOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/perconaxtradb.go b/pkg/webhooks/ops/v1alpha1/perconaxtradb.go
@@ -90,6 +90,11 @@ func (w *PerconaXtraDBOpsRequestCustomWebhook) ValidateDelete(ctx context.Contex
 }
 
 func (w *PerconaXtraDBOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.PerconaXtraDBOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.PerconaXtraDBOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for PerconaXtraDB are %s", req.Spec.Type, strings.Join(opsapi.PerconaXtraDBOpsRequestTypeNames(), ", ")))
+	}
+
 	var allErr field.ErrorList
 	switch req.GetRequestType().(opsapi.PerconaXtraDBOpsRequestType) {
 	case opsapi.PerconaXtraDBOpsRequestTypeRestart:
@@ -136,10 +141,6 @@ func (w *PerconaXtraDBOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsap
 		}
 	}
 
-	if validType, _ := arrays.Contains(opsapi.PerconaXtraDBOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for PerconaXtraDB are %s", req.Spec.Type, strings.Join(opsapi.PerconaXtraDBOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/pgbouncer.go b/pkg/webhooks/ops/v1alpha1/pgbouncer.go
@@ -87,6 +87,9 @@ func (w *PgBouncerOpsRequestCustomWebhook) ValidateDelete(ctx context.Context, o
 }
 
 func (w *PgBouncerOpsRequestCustomWebhook) validateCreateOrUpdate(obj *opsapi.PgBouncerOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.PgBouncerOpsRequestTypeNames(), string(obj.Spec.Type)); !validType {
+		return fmt.Errorf("defined OpsRequestType %s is not supported, supported types for PgBouncer are %s", obj.Spec.Type, strings.Join(opsapi.PgBouncerOpsRequestTypeNames(), ", "))
+	}
 	if !w.isDatabaseRefValid(obj) {
 		return fmt.Errorf("target database pgbouncer %s is not valid", obj.GetDBRefName())
 	}
@@ -106,10 +109,6 @@ func (w *PgBouncerOpsRequestCustomWebhook) validateCreateOrUpdate(obj *opsapi.Pg
 		return w.validatePgBouncerReconfigureTLSOpsRequest(obj)
 	}
 
-	if validType, _ := arrays.Contains(opsapi.PgBouncerOpsRequestTypeNames(), obj.Spec.Type); !validType {
-		return fmt.Errorf("defined OpsRequestType %s is not supported, supported types for PgBouncer are %s", obj.Spec.Type, strings.Join(opsapi.PgBouncerOpsRequestTypeNames(), ", "))
-	}
-
 	return nil
 }
 
diff --git a/pkg/webhooks/ops/v1alpha1/pgpool.go b/pkg/webhooks/ops/v1alpha1/pgpool.go
@@ -105,6 +105,11 @@ func validatePgpoolOpsRequest(req *opsapi.PgpoolOpsRequest, oldReq *opsapi.Pgpoo
 }
 
 func (w *PgpoolOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.PgpoolOpsRequest) error {
+	if validType, _ := arrays.Contains(opsapi.PgpoolOpsRequestTypeNames(), string(req.Spec.Type)); !validType {
+		return field.Invalid(field.NewPath("spec").Child("type"), req.Name,
+			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Pgpool are %s", req.Spec.Type, strings.Join(opsapi.PgpoolOpsRequestTypeNames(), ", ")))
+	}
+
 	var allErr field.ErrorList
 	switch req.GetRequestType().(opsapi.PgpoolOpsRequestType) {
 	case opsapi.PgpoolOpsRequestTypeRestart:
@@ -145,10 +150,6 @@ func (w *PgpoolOpsRequestCustomWebhook) validateCreateOrUpdate(req *opsapi.Pgpoo
 		}
 	}
 
-	if validType, _ := arrays.Contains(opsapi.PgpoolOpsRequestTypeNames(), req.Spec.Type); !validType {
-		allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,
-			fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Pgpool are %s", req.Spec.Type, strings.Join(opsapi.PgpoolOpsRequestTypeNames(), ", "))))
-	}
 	if len(allErr) == 0 {
 		return nil
 	}
diff --git a/pkg/webhooks/ops/v1alpha1/postgres.go b/pkg/webhooks/ops/v1alpha1/postgres.go
diff --git a/pkg/webhooks/ops/v1alpha1/proxysql.go b/pkg/webhooks/ops/v1alpha1/proxysql.go
diff --git a/pkg/webhooks/ops/v1alpha1/rabbitmq.go b/pkg/webhooks/ops/v1alpha1/rabbitmq.go
diff --git a/pkg/webhooks/ops/v1alpha1/redis.go b/pkg/webhooks/ops/v1alpha1/redis.go
diff --git a/pkg/webhooks/ops/v1alpha1/redissentinel.go b/pkg/webhooks/ops/v1alpha1/redissentinel.go
diff --git a/pkg/webhooks/ops/v1alpha1/singlestore.go b/pkg/webhooks/ops/v1alpha1/singlestore.go
diff --git a/pkg/webhooks/ops/v1alpha1/solr.go b/pkg/webhooks/ops/v1alpha1/solr.go
diff --git a/pkg/webhooks/ops/v1alpha1/zookeeper.go b/pkg/webhooks/ops/v1alpha1/zookeeper.go

Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,11 @@ func (w *CassandraOpsRequestCustomWebhook) ValidateDelete(ctx context.Context, o`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`func (rv CassandraOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.CassandraOpsRequest) error {`
	`85`	`+ if validType, _ := arrays.Contains(opsapi.CassandraOpsRequestTypeNames(), string(req.Spec.Type)); !validType {`
	`86`	`+ return field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
	`87`	`+ fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Cassandra are %s", req.Spec.Type, strings.Join(opsapi.CassandraOpsRequestTypeNames(), ", ")))`
	`88`	`+ }`
	`89`	`+`
`85`	`90`	`var allErr field.ErrorList`
`86`	`91`	`switch req.GetRequestType().(opsapi.CassandraOpsRequestType) {`
`87`	`92`	`case opsapi.CassandraOpsRequestTypeRestart:`
`@@ -136,10 +141,6 @@ func (rv CassandraOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.C`
`136`	`141`	`}`
`137`	`142`	`}`
`138`	`143`
`139`		`- if validType, _ := arrays.Contains(opsapi.CassandraOpsRequestTypeNames(), req.Spec.Type); !validType {`
`140`		`- allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
`141`		`- fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Cassandra are %s", req.Spec.Type, strings.Join(opsapi.CassandraOpsRequestTypeNames(), ", "))))`
`142`		`- }`
`143`	`144`	`if len(allErr) == 0 {`
`144`	`145`	`return nil`
`145`	`146`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,6 +79,10 @@ func (w *ClickHouseOpsRequestCustomWebhook) ValidateDelete(ctx context.Context,`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`func (rv ClickHouseOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.ClickHouseOpsRequest) error {`
	`82`	`+ if validType, _ := arrays.Contains(opsapi.ClickHouseOpsRequestTypeNames(), string(req.Spec.Type)); !validType {`
	`83`	`+ return field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
	`84`	`+ fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for ClickHouse are %s", req.Spec.Type, strings.Join(opsapi.ClickHouseOpsRequestTypeNames(), ", ")))`
	`85`	`+ }`
`82`	`86`	`var allErr field.ErrorList`
`83`	`87`	`switch req.GetRequestType().(opsapi.ClickHouseOpsRequestType) {`
`84`	`88`	`case opsapi.ClickHouseOpsRequestTypeRestart:`
`@@ -94,10 +98,7 @@ func (rv ClickHouseOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.`
`94`	`98`	`err.Error()))`
`95`	`99`	`}`
`96`	`100`	`}`
`97`		`- if validType, _ := arrays.Contains(opsapi.ClickHouseOpsRequestTypeNames(), req.Spec.Type); !validType {`
`98`		`- allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
`99`		`- fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for ClickHouse are %s", req.Spec.Type, strings.Join(opsapi.ClickHouseOpsRequestTypeNames(), ", "))))`
`100`		`- }`
	`101`	`+`
`101`	`102`	`if len(allErr) == 0 {`
`102`	`103`	`return nil`
`103`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,6 +110,10 @@ func validateDruidOpsRequest(req opsapi.DruidOpsRequest, oldReq opsapi.DruidOp`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`func (w DruidOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.DruidOpsRequest) error {`
	`113`	`+ if validType, _ := arrays.Contains(opsapi.DruidOpsRequestTypeNames(), string(req.Spec.Type)); !validType {`
	`114`	`+ return field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
	`115`	`+ fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Druid are %s", req.Spec.Type, strings.Join(opsapi.DruidOpsRequestTypeNames(), ", ")))`
	`116`	`+ }`
`113`	`117`	`druid, err := w.hasDatabaseRef(req)`
`114`	`118`	`if err != nil {`
`115`	`119`	`return err`
`@@ -169,10 +173,6 @@ func (w DruidOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.DruidO`
`169`	`173`	`}`
`170`	`174`	`}`
`171`	`175`
`172`		`- if validType, _ := arrays.Contains(opsapi.DruidOpsRequestTypeNames(), req.Spec.Type); !validType {`
`173`		`- allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
`174`		`- fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Druid are %s", req.Spec.Type, strings.Join(opsapi.DruidOpsRequestTypeNames(), ", "))))`
`175`		`- }`
`176`	`176`	`if len(allErr) == 0 {`
`177`	`177`	`return nil`
`178`	`178`	`}`
Original file line number	Diff line number	Diff line change
`@@ -130,6 +130,10 @@ func (w *ElasticsearchOpsRequestCustomWebhook) validateOpensearchVersionCompatib`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`func (w ElasticsearchOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.ElasticsearchOpsRequest) error {`
	`133`	`+ if validType, _ := arrays.Contains(opsapi.ElasticsearchOpsRequestTypeNames(), string(req.Spec.Type)); !validType {`
	`134`	`+ return field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
	`135`	`+ fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Elasticsearch are %s", req.Spec.Type, strings.Join(opsapi.ElasticsearchOpsRequestTypeNames(), ", ")))`
	`136`	`+ }`
`133`	`137`	`var allErr field.ErrorList`
`134`	`138`	`db := &dbapi.Elasticsearch{}`
`135`	`139`	`err := w.DefaultClient.Get(context.TODO(), types.NamespacedName{`
`@@ -155,10 +159,6 @@ func (w ElasticsearchOpsRequestCustomWebhook) validateCreateOrUpdate(req opsap`
`155`	`159`	`}`
`156`	`160`	`}`
`157`	`161`
`158`		`- if validType, _ := arrays.Contains(opsapi.ElasticsearchOpsRequestTypeNames(), req.Spec.Type); !validType {`
`159`		`- allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
`160`		`- fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Elasticsearch are %s", req.Spec.Type, strings.Join(opsapi.ElasticsearchOpsRequestTypeNames(), ", "))))`
`161`		`- }`
`162`	`162`	`if len(allErr) == 0 {`
`163`	`163`	`return nil`
`164`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -101,6 +101,11 @@ func validateFerretDBOpsRequest(req opsapi.FerretDBOpsRequest, oldReq opsapi.F`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`func (w FerretDBOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.FerretDBOpsRequest) error {`
	`104`	`+ if validType, _ := arrays.Contains(opsapi.FerretDBOpsRequestTypeNames(), string(req.Spec.Type)); !validType {`
	`105`	`+ return field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
	`106`	`+ fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for FerretDB are %s", req.Spec.Type, strings.Join(opsapi.FerretDBOpsRequestTypeNames(), ", ")))`
	`107`	`+ }`
	`108`	`+`
`104`	`109`	`var allErr field.ErrorList`
`105`	`110`	`switch req.GetRequestType().(opsapi.FerretDBOpsRequestType) {`
`106`	`111`	`case opsapi.FerretDBOpsRequestTypeRestart:`
`@@ -124,10 +129,6 @@ func (w FerretDBOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.Fer`
`124`	`129`	`}`
`125`	`130`	`}`
`126`	`131`
`127`		`- if validType, _ := arrays.Contains(opsapi.FerretDBOpsRequestTypeNames(), req.Spec.Type); !validType {`
`128`		`- allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
`129`		`- fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for FerretDB are %s", req.Spec.Type, strings.Join(opsapi.FerretDBOpsRequestTypeNames(), ", "))))`
`130`		`- }`
`131`	`132`	`if len(allErr) == 0 {`
`132`	`133`	`return nil`
`133`	`134`	`}`
Original file line number	Diff line number	Diff line change
`@@ -105,6 +105,11 @@ func validateHazelcastOpsRequest(req opsapi.HazelcastOpsRequest, oldReq opsapi`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`func (w HazelcastOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.HazelcastOpsRequest) error {`
	`108`	`+ if validType, _ := arrays.Contains(opsapi.HazelcastOpsRequestTypeNames(), string(req.Spec.Type)); !validType {`
	`109`	`+ return field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
	`110`	`+ fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Hazelcast are %s", req.Spec.Type, strings.Join(opsapi.HazelcastOpsRequestTypeNames(), ", ")))`
	`111`	`+ }`
	`112`	`+`
`108`	`113`	`var allErr field.ErrorList`
`109`	`114`	`switch req.GetRequestType().(opsapi.HazelcastOpsRequestType) {`
`110`	`115`	`case opsapi.HazelcastOpsRequestTypeRestart:`
`@@ -157,10 +162,6 @@ func (w HazelcastOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.Ha`
`157`	`162`	`}`
`158`	`163`	`}`
`159`	`164`
`160`		`- if validType, _ := arrays.Contains(opsapi.HazelcastOpsRequestTypeNames(), req.Spec.Type); !validType {`
`161`		`- allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
`162`		`- fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Hazelcast are %s", req.Spec.Type, strings.Join(opsapi.HazelcastOpsRequestTypeNames(), ", "))))`
`163`		`- }`
`164`	`165`	`if len(allErr) == 0 {`
`165`	`166`	`return nil`
`166`	`167`	`}`
Original file line number	Diff line number	Diff line change
`@@ -105,6 +105,11 @@ func validateIgniteOpsRequest(req opsapi.IgniteOpsRequest, oldReq opsapi.Ignit`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`func (rv IgniteOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.IgniteOpsRequest) error {`
	`108`	`+ if validType, _ := arrays.Contains(opsapi.IgniteOpsRequestTypeNames(), string(req.Spec.Type)); !validType {`
	`109`	`+ return field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
	`110`	`+ fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Ignite are %s", req.Spec.Type, strings.Join(opsapi.IgniteOpsRequestTypeNames(), ", ")))`
	`111`	`+ }`
	`112`	`+`
`108`	`113`	`var allErr field.ErrorList`
`109`	`114`	`switch req.GetRequestType().(opsapi.IgniteOpsRequestType) {`
`110`	`115`	`case opsapi.IgniteOpsRequestTypeRestart:`
`@@ -157,10 +162,6 @@ func (rv IgniteOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.Igni`
`157`	`162`	`}`
`158`	`163`	`}`
`159`	`164`
`160`		`- if validType, _ := arrays.Contains(opsapi.IgniteOpsRequestTypeNames(), req.Spec.Type); !validType {`
`161`		`- allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
`162`		`- fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Ignite are %s", req.Spec.Type, strings.Join(opsapi.IgniteOpsRequestTypeNames(), ", "))))`
`163`		`- }`
`164`	`165`	`if len(allErr) == 0 {`
`165`	`166`	`return nil`
`166`	`167`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,6 +110,11 @@ func validateKafkaOpsRequest(req opsapi.KafkaOpsRequest, oldReq opsapi.KafkaOp`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`func (w KafkaOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.KafkaOpsRequest) error {`
	`113`	`+ if validType, _ := arrays.Contains(opsapi.KafkaOpsRequestTypeNames(), string(req.Spec.Type)); !validType {`
	`114`	`+ return field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
	`115`	`+ fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Kafka are %s", req.Spec.Type, strings.Join(opsapi.KafkaOpsRequestTypeNames(), ", ")))`
	`116`	`+ }`
	`117`	`+`
`113`	`118`	`var (`
`114`	`119`	`err error`
`115`	`120`	`kafka *dbapi.Kafka`
`@@ -164,10 +169,6 @@ func (w KafkaOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.KafkaO`
`164`	`169`	`}`
`165`	`170`	`}`
`166`	`171`
`167`		`- if validType, _ := arrays.Contains(opsapi.KafkaOpsRequestTypeNames(), req.Spec.Type); !validType {`
`168`		`- allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
`169`		`- fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for kafka are %s", req.Spec.Type, strings.Join(opsapi.KafkaOpsRequestTypeNames(), ", "))))`
`170`		`- }`
`171`	`172`	`if len(allErr) == 0 {`
`172`	`173`	`return nil`
`173`	`174`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,6 +91,11 @@ func (w *MariaDBOpsRequestCustomWebhook) ValidateDelete(ctx context.Context, obj`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`func (w MariaDBOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.MariaDBOpsRequest) error {`
	`94`	`+ if validType, _ := arrays.Contains(opsapi.MariaDBOpsRequestTypeNames(), string(req.Spec.Type)); !validType {`
	`95`	`+ return field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
	`96`	`+ fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for MariaDB are %s", req.Spec.Type, strings.Join(opsapi.MariaDBOpsRequestTypeNames(), ", ")))`
	`97`	`+ }`
	`98`	`+`
`94`	`99`	`var allErr field.ErrorList`
`95`	`100`	`switch req.GetRequestType().(opsapi.MariaDBOpsRequestType) {`
`96`	`101`	`case opsapi.MariaDBOpsRequestTypeRestart:`
`@@ -144,10 +149,6 @@ func (w MariaDBOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.Mari`
`144`	`149`
`145`	`150`	`}`
`146`	`151`
`147`		`- if validType, _ := arrays.Contains(opsapi.MariaDBOpsRequestTypeNames(), req.Spec.Type); !validType {`
`148`		`- allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
`149`		`- fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for MariaDB are %s", req.Spec.Type, strings.Join(opsapi.MariaDBOpsRequestTypeNames(), ", "))))`
`150`		`- }`
`151`	`152`	`if len(allErr) == 0 {`
`152`	`153`	`return nil`
`153`	`154`	`}`
Original file line number	Diff line number	Diff line change
`@@ -106,6 +106,11 @@ func validateMemcachedOpsRequest(req opsapi.MemcachedOpsRequest, oldReq opsapi`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`func (c MemcachedOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.MemcachedOpsRequest) error {`
	`109`	`+ if validType, _ := arrays.Contains(opsapi.MemcachedOpsRequestTypeNames(), string(req.Spec.Type)); !validType {`
	`110`	`+ return field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
	`111`	`+ fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Memcached are %s", req.Spec.Type, strings.Join(opsapi.MemcachedOpsRequestTypeNames(), ", ")))`
	`112`	`+ }`
	`113`	`+`
`109`	`114`	`var allErr field.ErrorList`
`110`	`115`	`switch req.GetRequestType().(opsapi.MemcachedOpsRequestType) {`
`111`	`116`	`case opsapi.MemcachedOpsRequestTypeRestart:`
`@@ -153,10 +158,6 @@ func (c MemcachedOpsRequestCustomWebhook) validateCreateOrUpdate(req opsapi.Me`
`153`	`158`	`}`
`154`	`159`	`}`
`155`	`160`
`156`		`- if validType, _ := arrays.Contains(opsapi.MemcachedOpsRequestTypeNames(), req.Spec.Type); !validType {`
`157`		`- allErr = append(allErr, field.Invalid(field.NewPath("spec").Child("type"), req.Name,`
`158`		`- fmt.Sprintf("defined OpsRequestType %s is not supported, supported types for Memcached are %s", req.Spec.Type, strings.Join(opsapi.MemcachedOpsRequestTypeNames(), ", "))))`
`159`		`- }`
`160`	`161`	`if len(allErr) == 0 {`
`161`	`162`	`return nil`
`162`	`163`	`}`