}

type clusterConfig struct {
	configBase
	config kubeadmapiv1.ClusterConfiguration
}

func (cc *clusterConfig) DeepCopy() kubeadmapi.ComponentConfig {
	result := &clusterConfig{}
	cc.configBase.DeepCopyInto(&result.configBase)
	cc.config.DeepCopyInto(&result.config)
	return result
}

func (cc *clusterConfig) Marshal() ([]byte, error) {
	return cc.configBase.Marshal(&cc.config)
}

	SDSDefaultResourceName = "default"

	// SDSRootResourceName is the sdsconfig name for root CA, used for fetching root cert.
	SDSRootResourceName = "ROOTCA"
)

// Preconfigured SDS configs to avoid excessive memory allocations
var (
	defaultSDSConfig = &tls.SdsSecretConfig{
		Name: SDSDefaultResourceName,
		SdsConfig: &core.ConfigSource{
			ConfigSourceSpecifier: &core.ConfigSource_ApiConfigSource{

	revision, injectorAddress string,
) (*ExternalInjector, *meshconfig.MeshConfig, error) {
	var err error
	// Get configs from IOP files firstly, and if not exists, get configs from files and configmaps.
	values, meshConfig, err := getIOPConfigs()
	if err != nil {
		return nil, nil, err
	}
	if meshConfig == nil {
		if meshConfigFile != "" {

				Configs: echo.ConfigFuture(&customConfig),
			}
			err := addDefaultConfig(ctx, config, &customConfig)
			if err != nil {
				return err
			}
			return nil
		}).
		Setup(deployment.SetupSingleNamespace(&apps, deployment.Config{
			Namespaces: []namespace.Getter{
				namespace.Future(&echo1NS),
			},
			Configs: echo.ConfigFuture(&customConfig),
		})).
		Setup(func(ctx resource.Context) error {

            }
        }
    }

    static class CheckTaskBuilder {
        final Map<String, String> configs = [:]

        void config(String config) {
            configs.put(config, "check${config.capitalize()}")
        }

        void config(String config, String taskName) {
            configs.put(config, taskName)
        }
    }

    @Canonical
    static class Variant {
        String name

		t.Run(tt.name, func(t *testing.T) {
			var configs []*config.Config
			if tt.destRule != nil {
				destinationRuleConfig := config.Config{
					Meta: config.Meta{
						GroupVersionKind: gvk.DestinationRule,
						Name:             "tcp-idle-timeout",
						Namespace:        "not-default",
					},
					Spec: tt.destRule,
				}
				configs = append(configs, &destinationRuleConfig)
			}

	"istio.io/istio/pilot/pkg/model"
	"istio.io/istio/pilot/pkg/networking/core"
	"istio.io/istio/pilot/pkg/util/protoconv"
	"istio.io/istio/pkg/config/schema/kind"
	"istio.io/istio/pkg/util/sets"
)

// NdsGenerator generates config for Nds i.e. Name Discovery Service. Istio agents
// send NDS requests to istiod and istiod responds with a list of services and their
// associated IPs (including service entries).

		return i, err
	}

	// Update config clusters now that external istiod is running.
	for _, c := range ctx.Clusters().Configs().Remotes() {
		if err = i.reinstallConfigCluster(c); err != nil {
			return i, err
		}
	}

	// Install (non-config) remote clusters.
	errG = multierror.Group{}
	for _, c := range ctx.Clusters().Remotes(ctx.Clusters().Configs()...) {
		c := c
		errG.Go(func() error {

	"istio.io/istio/pilot/pkg/networking/core"
	"istio.io/istio/pilot/pkg/util/protoconv"
	"istio.io/istio/pkg/config/schema/kind"
	"istio.io/istio/pkg/util/sets"
)

type LdsGenerator struct {
	ConfigGenerator core.ConfigGenerator
}

var _ model.XdsResourceGenerator = &LdsGenerator{}

// Map of all configs that do not impact LDS
var skippedLdsConfigs = map[model.NodeType]sets.Set[kind.Kind]{
	model.Router: sets.New(

	if !exists {
		return "", fmt.Errorf("missing ConfigMap config key %q", configKey)
	}
	return configYaml, nil
}

func injectConfigToYaml(config *inject.Config) (string, error) {
	bres, err := yaml.Marshal(config)
	return string(bres), err
}

func yamlToInjectConfig(configYaml string) (*inject.Config, error) {
	// Parse the YAML.
	c, err := inject.UnmarshalConfig([]byte(configYaml))