Cleanup deadcode in preperation for k8s gogo changes

See
kubernetes/enhancements#5590 (comment);
we use a lot of very questionable gogoproto on k8s type operations.

The good news is, as far as I can every single one of these is on code
paths that never actually touch k8s types (anymore), or are on entirely
dead code paths.

My plan is to split this into two PRs to make things simpler/safer.

This PR removes strictly dead code that is in this area. There is a
surprising amount here! I think this is as we moved more and more stuff
away from these legacy `config.Config` paths towards kclient/krt the
cruft just stayed around.

In the next PRs I will remove the gogo proto handling (TBD how, if we
want to fail or fallback).

I've analyzed the remaining usages:

```
DeepCopy
  UpdateHealth, DeleteHealthCondition (WE only)
  mergeVirtualServicesIfNeeded (on VS spec)
  mergeDestinationRule
  mergeHTTPRoutes (its a VirtualService though, not a HTTPRoute)
  resolveVirtualServiceShortnames (on VS only)
  convertToWasmPluginWrapper (On WasmPlugin)
  In a bunch of tests

ApplyJSON
  FromJSON
    ConvertObject
      webhook.validate (only called for istio types)
      ParseInputs (should be called for everything)
        kube/file.NewController
          Only allows Istio objects but I think its going to read all of them, so we couldn't panic or something?
ApplyJSONStrict
  fromSchemaAndJSONMap
    validateResource (in istioctl, only used on Istio types)

Equals()
  We already explicitly do not use gogoproto.Equals EXCEPT in `needsPush` which only operates on istio.io types

ToProto():
  PilotConfigToResource (I think this will only have Istio types)

ToJSON():
  ToRaw()
    ConvertConfig
      used in configz handler, which should only have Istio types
ToPrettyJSON():
  Not even used on protos, bug in xds/debug.go
```

Author: howardjohn

pilot/pkg/autoregistration/internal/state/store.go

@@ -76,7 +76,7 @@ func (s *Store) UpdateHealth(proxyID, entryName, entryNs string, condition *v1al
 	}
 
 	// replace the updated status
-	wle := status.UpdateConfigCondition(*cfg, condition)
+	wle := status.UpdateIstioConfigCondition(*cfg, condition)
 	// update the status
 	_, err := s.store.UpdateStatus(wle)
 	if err != nil {
@@ -89,7 +89,7 @@ func (s *Store) UpdateHealth(proxyID, entryName, entryNs string, condition *v1al
 // DeleteHealthCondition updates WorkloadEntry of a workload that is not using auto-registration
 // to remove information about the health status (since we can no longer be certain about it).
 func (s *Store) DeleteHealthCondition(wle config.Config) error {
-	wle = status.DeleteConfigCondition(wle, status.ConditionHealthy)
+	wle = status.DeleteIstioConfigCondition(wle, status.ConditionHealthy)
 	// update the status
 	_, err := s.store.UpdateStatus(wle)
 	if err != nil && !errors.IsNotFound(err) {

pilot/pkg/config/aggregate/config.go

@@ -166,13 +166,6 @@ func (cr *store) UpdateStatus(c config.Config) (string, error) {
 	return cr.writer.UpdateStatus(c)
 }
 
-func (cr *store) Patch(orig config.Config, patchFn config.PatchFunc) (string, error) {
-	if cr.writer == nil {
-		return "", errorUnsupported
-	}
-	return cr.writer.Patch(orig, patchFn)
-}
-
 type storeCache struct {
 	model.ConfigStore
 	caches []model.ConfigStoreController

pilot/pkg/config/file/store.go

@@ -101,10 +101,6 @@ func (s *KubeSource) UpdateStatus(config config.Config) (newRevision string, err
 	return s.inner.UpdateStatus(config)
 }
 
-func (s *KubeSource) Patch(orig config.Config, patchFn config.PatchFunc) (string, error) {
-	return s.inner.Patch(orig, patchFn)
-}
-
 func (s *KubeSource) Delete(typ config.GroupVersionKind, name, namespace string, resourceVersion *string) error {
 	return s.inner.Delete(typ, name, namespace, resourceVersion)
 }

pilot/pkg/config/kube/crd/conversion.go

@@ -21,16 +21,13 @@ import (
 	"io"
 	"reflect"
 
-	"github.com/hashicorp/go-multierror"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/types"
-	kubeyaml "k8s.io/apimachinery/pkg/util/yaml"
-	"sigs.k8s.io/yaml"
-
 	"istio.io/istio/pkg/config"
 	"istio.io/istio/pkg/config/schema/collections"
 	"istio.io/istio/pkg/config/schema/resource"
 	"istio.io/istio/pkg/log"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	kubeyaml "k8s.io/apimachinery/pkg/util/yaml"
 )
 
 // FromJSON converts a canonical JSON to a proto message
@@ -45,17 +42,6 @@ func FromJSON(s resource.Schema, js string) (config.Spec, error) {
 	return c, nil
 }
 
-func FromJSONStrict(s resource.Schema, js string) (config.Spec, error) {
-	c, err := s.NewInstance()
-	if err != nil {
-		return nil, err
-	}
-	if err = config.ApplyJSONStrict(c, js); err != nil {
-		return nil, err
-	}
-	return c, nil
-}
-
 func StatusJSONFromMap(schema resource.Schema, jsonMap *json.RawMessage) (config.Status, error) {
 	if jsonMap == nil {
 		return nil, nil
@@ -75,33 +61,6 @@ func StatusJSONFromMap(schema resource.Schema, jsonMap *json.RawMessage) (config
 	return status, nil
 }
 
-// FromYAML converts a canonical YAML to a proto message
-func FromYAML(s resource.Schema, yml string) (config.Spec, error) {
-	c, err := s.NewInstance()
-	if err != nil {
-		return nil, err
-	}
-	if err = config.ApplyYAML(c, yml); err != nil {
-		return nil, err
-	}
-	return c, nil
-}
-
-// FromJSONMap converts from a generic map to a proto message using canonical JSON encoding
-// JSON encoding is specified here: https://developers.google.com/protocol-buffers/docs/proto3#json
-func FromJSONMap(s resource.Schema, data any) (config.Spec, error) {
-	// Marshal to YAML bytes
-	str, err := yaml.Marshal(data)
-	if err != nil {
-		return nil, err
-	}
-	out, err := FromYAML(s, string(str))
-	if err != nil {
-		return nil, multierror.Prefix(err, fmt.Sprintf("YAML decoding error: %v", string(str)))
-	}
-	return out, nil
-}
-
 type ConversionFunc = func(s resource.Schema, js string) (config.Spec, error)
 
 func ConvertObjectInternal(schema resource.Schema, object IstioObject, domain string, convert ConversionFunc) (*config.Config, error) {

pilot/pkg/config/kube/crdclient/client.go

@@ -272,18 +272,6 @@ func (cl *Client) UpdateStatus(cfg config.Config) (string, error) {
 	return meta.GetResourceVersion(), nil
 }
 
-// Patch applies only the modifications made in the PatchFunc rather than doing a full replace. Useful to avoid
-// read-modify-write conflicts when there are many concurrent-writers to the same resource.
-func (cl *Client) Patch(orig config.Config, patchFn config.PatchFunc) (string, error) {
-	modified, patchType := patchFn(orig.DeepCopy())
-
-	meta, err := patch(cl.client, orig, getObjectMetadata(orig), modified, getObjectMetadata(modified), patchType)
-	if err != nil {
-		return "", err
-	}
-	return meta.GetResourceVersion(), nil
-}
-
 // Delete implements store interface
 // `resourceVersion` must be matched before deletion is carried out. If not possible, a 409 Conflict status will be
 func (cl *Client) Delete(typ config.GroupVersionKind, name, namespace string, resourceVersion *string) error {

pilot/pkg/config/kube/crdclient/client_test.go

@@ -23,7 +23,6 @@ import (
 
 	"go.uber.org/atomic"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/gateway-api/pkg/consts"
 
 	"istio.io/api/meta/v1alpha1"
@@ -239,24 +238,6 @@ func TestClient(t *testing.T) {
 				return nil
 			})
 
-			// check we can patch items
-			var patchedCfg config.Config
-			if _, err := store.(*Client).Patch(*cfg, func(cfg config.Config) (config.Config, types.PatchType) {
-				cfg.Annotations["fizz"] = "buzz"
-				patchedCfg = cfg
-				return cfg, types.JSONPatchType
-			}); err != nil {
-				t.Errorf("unexpected err in Patch: %v", err)
-			}
-			// validate it is updated
-			retry.UntilSuccessOrFail(t, func() error {
-				cfg := store.Get(r.GroupVersionKind(), configName, configMeta.Namespace)
-				if cfg == nil || !reflect.DeepEqual(cfg.Meta, patchedCfg.Meta) {
-					return fmt.Errorf("get(%v) => got unexpected object %v", name, cfg)
-				}
-				return nil
-			})
-
 			// Check we can remove items
 			if err := store.Delete(r.GroupVersionKind(), configName, configNamespace, nil); err != nil {
 				t.Fatalf("failed to delete: %v", err)

pilot/pkg/config/kube/file/controller.go

@@ -144,10 +144,6 @@ func (c *Controller) UpdateStatus(config config.Config) (newRevision string, err
 	return "", errUnsupportedOp
 }
 
-func (c *Controller) Patch(orig config.Config, patchFn config.PatchFunc) (string, error) {
-	return "", errUnsupportedOp
-}
-
 func (c *Controller) Delete(typ config.GroupVersionKind, name, namespace string, _ *string) error {
 	return errUnsupportedOp
 }

pilot/pkg/config/kube/gateway/controller.go

@@ -541,10 +541,6 @@ func (c *Controller) UpdateStatus(config config.Config) (newRevision string, err
 	return "", errUnsupportedOp
 }
 
-func (c *Controller) Patch(orig config.Config, patchFn config.PatchFunc) (string, error) {
-	return "", errUnsupportedOp
-}
-
 func (c *Controller) Delete(typ config.GroupVersionKind, name, namespace string, _ *string) error {
 	return errUnsupportedOp
 }

pilot/pkg/config/memory/controller.go

@@ -17,8 +17,6 @@ package memory
 import (
 	"fmt"
 
-	"k8s.io/apimachinery/pkg/types"
-
 	"istio.io/istio/pilot/pkg/model"
 	"istio.io/istio/pkg/config"
 	"istio.io/istio/pkg/config/schema/collection"
@@ -123,24 +121,6 @@ func (c *Controller) UpdateStatus(config config.Config) (newRevision string, err
 	return newRevision, err
 }
 
-func (c *Controller) Patch(orig config.Config, patchFn config.PatchFunc) (newRevision string, err error) {
-	cfg, typ := patchFn(orig.DeepCopy())
-	switch typ {
-	case types.MergePatchType:
-	case types.JSONPatchType:
-	default:
-		return "", fmt.Errorf("unsupported merge type: %s", typ)
-	}
-	if newRevision, err = c.configStore.Patch(cfg, patchFn); err == nil {
-		c.monitor.ScheduleProcessEvent(ConfigEvent{
-			old:    orig,
-			config: cfg,
-			event:  model.EventUpdate,
-		})
-	}
-	return newRevision, err
-}
-
 func (c *Controller) Delete(kind config.GroupVersionKind, key, namespace string, resourceVersion *string) error {
 	if config := c.Get(kind, key, namespace); config != nil {
 		if err := c.configStore.Delete(kind, key, namespace, resourceVersion); err != nil {

pilot/pkg/config/memory/store.go

@@ -227,39 +227,6 @@ func (cr *store) UpdateStatus(cfg config.Config) (string, error) {
 	return cr.Update(cfg)
 }
 
-func (cr *store) Patch(orig config.Config, patchFn config.PatchFunc) (string, error) {
-	cr.mutex.Lock()
-	defer cr.mutex.Unlock()
-
-	gvk := orig.GroupVersionKind
-	s, ok := cr.schemas.FindByGroupVersionKind(gvk)
-	if !ok {
-		return "", fmt.Errorf("unknown type %v", gvk)
-	}
-
-	cfg, _ := patchFn(orig)
-	if !cr.skipValidation {
-		if _, err := s.ValidateConfig(cfg); err != nil {
-			return "", err
-		}
-	}
-
-	_, ok = cr.data[gvk]
-	if !ok {
-		return "", errNotFound
-	}
-	ns, exists := cr.data[gvk][orig.Namespace]
-	if !exists {
-		return "", errNotFound
-	}
-
-	rev := time.Now().String()
-	cfg.ResourceVersion = rev
-	ns[cfg.Name] = cfg
-
-	return rev, nil
-}
-
 // hasConflict checks if the two resources have a conflict, which will block Update calls
 func hasConflict(existing, replacement config.Config) bool {
 	if replacement.ResourceVersion == "" {