}

	if data.Cfg().ControlPlane == nil {
		return nil
	}

	// gets access to the cluster using the identity defined in admin.conf
	client, err := data.Client()
	if err != nil {
		return errors.Wrap(err, "couldn't create Kubernetes client")
	}
	cfg, err := data.InitCfg()
	if err != nil {
		return err
	}
	// in case of external etcd
	if cfg.Etcd.External != nil {

	// TODO(garyan): enable the test for "PILOT_JWT_ENABLE_REMOTE_JWKS: true" as well.
	cfg.ControlPlaneValues = tmpl.MustEvaluate(`
values:
  pilot: 
    jwksResolverExtraRootCA: |
{{.pem | indent 6}}
    env: 
      PILOT_JWT_ENABLE_REMOTE_JWKS: false
meshConfig:
  accessLogFile: /dev/stdout`, map[string]string{"pem": rootCaCert})
	cfg.ConfigClusterValues = cfg.ControlPlaneValues

			cfg.CRISocket = kubeadmapiv1.DefaultContainerRuntimeURLScheme + "://" + cfg.CRISocket
		}
	}

	return nil
}

// SetAPIEndpointDynamicDefaults checks and sets configuration values for the APIEndpoint object
func SetAPIEndpointDynamicDefaults(cfg *kubeadmapi.APIEndpoint) error {
	// validate cfg.API.AdvertiseAddress.
	addressIP := netutils.ParseIPSloppy(cfg.AdvertiseAddress)

        this.hexCode = hexCode;
        this.scope = scope != null && scope.length() > 0 ? scope : cfg.getNetbiosScope();
        this.srcHashCode = 0;
    }


    /**
     * @param cfg
     * @param name
     */
    public Name ( Configuration cfg, NetbiosName name ) {
        this.config = cfg;
        this.name = name.getName();
        this.hexCode = name.getNameType();
        this.scope = name.getScope();

		opts = append(opts, grpc.WithResolvers(r))
	}

	if cfg.getClientCertificate != nil {
		security = grpc.WithTransportCredentials(credentials.NewTLS(cfg.tlsConfig))
	}

	address := cfg.Request.Url

	// Connect to the GRPC server.
	ctx, cancel := context.WithTimeout(context.Background(), common.ConnectionTimeout)
	defer cancel()
	opts = append(opts, security, grpc.WithAuthority(cfg.hostHeader))
	return grpc.DialContext(ctx, address, opts...)

		in.LendablePercent = ptr.To(int32(0))
	}
}

func SetDefaults_QueuingConfiguration(cfg *v1beta3.QueuingConfiguration) {
	if cfg.HandSize == 0 {
		cfg.HandSize = PriorityLevelConfigurationDefaultHandSize
	}
	if cfg.Queues == 0 {
		cfg.Queues = PriorityLevelConfigurationDefaultQueues
	}
	if cfg.QueueLengthLimit == 0 {
		cfg.QueueLengthLimit = PriorityLevelConfigurationDefaultQueueLengthLimit
	}

					Valu("b", OpConst64, cfg.config.Types.Int64, 26, nil),
					Valu("sum", OpAdd64, cfg.config.Types.Int64, 0, nil, "a", "b"),
					Exit("mem"))),
			cfg.Fun("entry",
				Bloc("entry",
					Valu("mem", OpInitMem, types.TypeMem, 0, nil),
					Valu("a", OpConst64, cfg.config.Types.Int64, 0, nil),
					Valu("b", OpConst64, cfg.config.Types.Int64, 14, nil),

func ReadSpecificDockerConfigJSONFile(filePath string) (cfg DockerConfig, err error) {
	var contents []byte

	if contents, err = os.ReadFile(filePath); err != nil {
		return nil, err
	}
	return readDockerConfigJSONFileFromBytes(contents)
}

// ReadDockerConfigFile read a docker config file from default path
func ReadDockerConfigFile() (cfg DockerConfig, err error) {
	if cfg, err := ReadDockerConfigJSONFile(nil); err == nil {

func LookupConfig(kvs config.KVS) (cfg Config, err error) {
	if err = config.CheckValidKeys(config.CallhomeSubSys, kvs, DefaultKVS); err != nil {
		return cfg, err
	}

	cfg.Enable = env.Get(config.EnvMinIOCallhomeEnable,
		kvs.GetWithDefault(Enable, DefaultKVS)) == config.EnableOn
	cfg.Frequency, err = time.ParseDuration(env.Get(config.EnvMinIOCallhomeFrequency,

)

func createCNIConfigFile(ctx context.Context, cfg *config.InstallConfig) (string, error) {
	pluginConfig := plugin.Config{
		PluginLogLevel:  cfg.PluginLogLevel,
		LogUDSAddress:   cfg.LogUDSAddress,
		CNIEventAddress: cfg.CNIEventAddress,
		AmbientEnabled:  cfg.AmbientEnabled,
		Kubernetes: plugin.Kubernetes{
			Kubeconfig:        filepath.Join(cfg.CNINetDir, cfg.KubeconfigFilename),