}
	cmd.Flag.StringVar(&cfg.BuildContext.InstallSuffix, "installsuffix", "", "")
	cmd.Flag.Var(&load.BuildLdflags, "ldflags", "")
	cmd.Flag.BoolVar(&cfg.BuildLinkshared, "linkshared", false, "")
	cmd.Flag.StringVar(&cfg.BuildPGO, "pgo", "auto", "")
	cmd.Flag.StringVar(&cfg.BuildPkgdir, "pkgdir", "", "")
	cmd.Flag.BoolVar(&cfg.BuildRace, "race", false, "")
	cmd.Flag.BoolVar(&cfg.BuildMSan, "msan", false, "")

		ctx:     ctx,
		cluster: cfg.Cluster,
	}

	// Deploy echo to the cluster
	c.deployment, err = newDeployment(ctx, cfg)
	if err != nil {
		return nil, err
	}

	// Create the manager for echo workloads for this instance.
	c.workloadMgr, err = newWorkloadManager(ctx, cfg, c.deployment)
	if err != nil {
		return nil, err
	}

	// Now that we have the successfully created the workload manager, track this resource so

type testCertsData struct {
	testInitData
	cfg *kubeadmapi.InitConfiguration
}

func (t *testCertsData) Cfg() *kubeadmapi.InitConfiguration { return t.cfg }
func (t *testCertsData) ExternalCA() bool                   { return false }
func (t *testCertsData) CertificateDir() string             { return t.cfg.CertificatesDir }
func (t *testCertsData) CertificateWriteDir() string        { return t.cfg.CertificatesDir }

func DiscoverValidatedKubeConfig(cfg *kubeadmapi.JoinConfiguration) (*clientcmdapi.Config, error) {
	timeout := cfg.Timeouts.Discovery.Duration
	switch {
	case cfg.Discovery.File != nil:
		kubeConfigPath := cfg.Discovery.File.KubeConfigPath
		if isHTTPSURL(kubeConfigPath) {
			return https.RetrieveValidatedConfigInfo(kubeConfigPath, timeout)
		}

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

	var proxyURL *xnet.URL
	proxy := env.Get(config.EnvMinIOSubnetProxy, kvs.Get(config.Proxy))
	if len(proxy) > 0 {
		proxyURL, err = xnet.ParseHTTPURL(proxy)
		if err != nil {
			return cfg, err
		}

	}

	if cfg.secure {
		return hbone.TLSDialWithDialer(newDialer(cfg), "tcp", address, cfg.tlsConfig)
	}

	ctx, cancel := context.WithTimeout(context.Background(), common.ConnectionTimeout)
	defer cancel()

	return newDialer(cfg).DialContext(ctx, "tcp", address)

func New(ctx resource.Context, cfg Config) (i Instance, err error) {
	start := time.Now()
	scopes.Framework.Infof("=== BEGIN: Create namespace %s ===", cfg.Prefix)
	defer func() {
		if err != nil {
			scopes.Framework.Errorf("=== FAILED: Create namespace %s ===", cfg.Prefix)
			scopes.Framework.Error(err)
		} else {
			scopes.Framework.Infof("=== SUCCEEDED: Create namespace %s in %v ===", cfg.Prefix, time.Since(start))
		}
	}()

	}

	cfgs := s.store.List(gvk.WorkloadEntry, namespace)
	for _, cfg := range cfgs {
		s.workloadEntryHandler(cfg, cfg, event)
	}

	if !s.workloadEntryController {
		cfgs := s.store.List(gvk.ServiceEntry, namespace)
		for _, cfg := range cfgs {
			s.serviceEntryHandler(cfg, cfg, event)
		}
	}

							},
						},
					},
				}
				if diff := cmp.Diff(validData, data, cmp.AllowUnexported(initData{}), cmpopts.IgnoreFields(initData{}, "client", "cfg.ClusterConfiguration", "cfg.NodeRegistration.Taints", "cfg.Timeouts")); diff != "" {
					t.Fatalf("newInitData returned data (-want,+got):\n%s", diff)
				}
			},
		},
		{
			name: "--node-name flags override config from file",

	if configs == nil {
		configs = make(map[string]config.Config)
		nsConfigs[cfg.Namespace] = configs
	}

	configs[cfg.Name] = cfg
	return "", nil
}

func (s *FakeStore) Update(cfg config.Config) (newRevision string, err error) {
	nsConfigs := s.store[cfg.GroupVersionKind]
	if nsConfigs != nil {
		configs := nsConfigs[cfg.Namespace]
		if configs != nil {
			if _, f := configs[cfg.Name]; f {