func()

in eksconfig/env.go [28:629]

• 555 lines of code
• 137 McCabe index (conditional complexity)

func (cfg *Config) UpdateFromEnvs() (err error) {
	cfg.mu.Lock()
	defer func() {
		cfg.unsafeSync()
		cfg.mu.Unlock()
	}()

	if env, ok := os.LookupEnv("AWS_K8S_TESTER_EKS_CONFIG"); ok {
		mu := cfg.mu
		if err = yaml.Unmarshal([]byte(env), cfg, yaml.DisallowUnknownFields); err != nil {
			return err
		}
		cfg.mu = mu
	}

	var vv interface{}
	vv, err = parseEnvs(AWS_K8S_TESTER_EKS_PREFIX, cfg)
	if err != nil {
		return err
	}
	if av, ok := vv.(*Config); ok {
		a1, b1 := av.Role, av.VPC
		cfg = av
		a2, b2 := cfg.Role, cfg.VPC
		if !reflect.DeepEqual(a1, a2) {
			return fmt.Errorf("Role overwritten [before %+v, after %+v]", a1, a2)
		}
		if !reflect.DeepEqual(b1, b2) {
			return fmt.Errorf("VPC overwritten [before %+v, after %+v]", b1, b2)
		}
	} else {
		return fmt.Errorf("expected *Config, got %T", vv)
	}

	if cfg.S3 == nil {
		cfg.S3 = &S3{}
	}
	vv, err = parseEnvs(AWS_K8S_TESTER_EKS_S3_PREFIX, cfg.S3)
	if err != nil {
		return err
	}
	if av, ok := vv.(*S3); ok {
		cfg.S3 = av
	} else {
		return fmt.Errorf("expected *S3, got %T", vv)
	}

	if cfg.Encryption == nil {
		cfg.Encryption = &Encryption{}
	}
	vv, err = parseEnvs(AWS_K8S_TESTER_EKS_ENCRYPTION_PREFIX, cfg.Encryption)
	if err != nil {
		return err
	}
	if av, ok := vv.(*Encryption); ok {
		cfg.Encryption = av
	} else {
		return fmt.Errorf("expected *Encryption, got %T", vv)
	}

	if cfg.Role == nil {
		cfg.Role = &Role{}
	}
	vv, err = parseEnvs(AWS_K8S_TESTER_EKS_ROLE_PREFIX, cfg.Role)
	if err != nil {
		return err
	}
	if av, ok := vv.(*Role); ok {
		cfg.Role = av
	} else {
		return fmt.Errorf("expected *Role, got %T", vv)
	}

	if cfg.VPC == nil {
		cfg.VPC = &VPC{}
	}
	vv, err = parseEnvs(AWS_K8S_TESTER_EKS_VPC_PREFIX, cfg.VPC)
	if err != nil {
		return err
	}
	if av, ok := vv.(*VPC); ok {
		cfg.VPC = av
	} else {
		return fmt.Errorf("expected *VPC, got %T", vv)
	}

	if cfg.AddOnCNIVPC == nil {
		cfg.AddOnCNIVPC = &AddOnCNIVPC{}
	}
	vv, err = parseEnvs(AWS_K8S_TESTER_EKS_ADD_ON_CNI_VPC_PREFIX, cfg.AddOnCNIVPC)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnCNIVPC); ok {
		cfg.AddOnCNIVPC = av
	} else {
		return fmt.Errorf("expected *AddOnCNIVPC, got %T", vv)
	}

	if cfg.AddOnNodeGroups == nil {
		cfg.AddOnNodeGroups = &AddOnNodeGroups{}
	}
	vv, err = parseEnvs(AWS_K8S_TESTER_EKS_ADD_ON_NODE_GROUPS_PREFIX, cfg.AddOnNodeGroups)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnNodeGroups); ok {
		cfg.AddOnNodeGroups = av
	} else {
		return fmt.Errorf("expected *AddOnNodeGroups, got %T", vv)
	}

	if cfg.AddOnNodeGroups.Role == nil {
		cfg.AddOnNodeGroups.Role = &Role{}
	}
	vv, err = parseEnvs(AWS_K8S_TESTER_EKS_ADD_ON_NODE_GROUPS_PREFIX+"ROLE_", cfg.AddOnNodeGroups.Role)
	if err != nil {
		return err
	}
	if av, ok := vv.(*Role); ok {
		cfg.AddOnNodeGroups.Role = av
	} else {
		return fmt.Errorf("expected *AddOnNodeGroups.Role, got %T", vv)
	}

	if cfg.AddOnManagedNodeGroups == nil {
		cfg.AddOnManagedNodeGroups = &AddOnManagedNodeGroups{}
	}
	vv, err = parseEnvs(AWS_K8S_TESTER_EKS_ADD_ON_MANAGED_NODE_GROUPS_PREFIX, cfg.AddOnManagedNodeGroups)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnManagedNodeGroups); ok {
		cfg.AddOnManagedNodeGroups = av
	} else {
		return fmt.Errorf("expected *AddOnManagedNodeGroups, got %T", vv)
	}

	if cfg.AddOnManagedNodeGroups.Role == nil {
		cfg.AddOnManagedNodeGroups.Role = &Role{}
	}
	vv, err = parseEnvs(AWS_K8S_TESTER_EKS_ADD_ON_MANAGED_NODE_GROUPS_PREFIX+"ROLE_", cfg.AddOnManagedNodeGroups.Role)
	if err != nil {
		return err
	}
	if av, ok := vv.(*Role); ok {
		cfg.AddOnManagedNodeGroups.Role = av
	} else {
		return fmt.Errorf("expected *AddOnManagedNodeGroups.Role, got %T", vv)
	}

	if cfg.AddOnCWAgent == nil {
		cfg.AddOnCWAgent = &AddOnCWAgent{}
	}
	vv, err = parseEnvs(AWS_K8S_TESTER_EKS_ADD_ON_CW_AGENT_PREFIX, cfg.AddOnCWAgent)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnCWAgent); ok {
		cfg.AddOnCWAgent = av
	} else {
		return fmt.Errorf("expected *AddOnCWAgent, got %T", vv)
	}

	if cfg.AddOnFluentd == nil {
		cfg.AddOnFluentd = &AddOnFluentd{}
	}
	vv, err = parseEnvs(AWS_K8S_TESTER_EKS_ADD_ON_FLUENTD_PREFIX, cfg.AddOnFluentd)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnFluentd); ok {
		cfg.AddOnFluentd = av
	} else {
		return fmt.Errorf("expected *AddOnFluentd, got %T", vv)
	}

	if cfg.AddOnMetricsServer == nil {
		cfg.AddOnMetricsServer = &AddOnMetricsServer{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnMetricsServer, cfg.AddOnMetricsServer)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnMetricsServer); ok {
		cfg.AddOnMetricsServer = av
	} else {
		return fmt.Errorf("expected *AddOnMetricsServer, got %T", vv)
	}

	if cfg.AddOnConformance == nil {
		cfg.AddOnConformance = &AddOnConformance{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnConformance, cfg.AddOnConformance)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnConformance); ok {
		cfg.AddOnConformance = av
	} else {
		return fmt.Errorf("expected *AddOnConformance, got %T", vv)
	}

	if cfg.AddOnAppMesh == nil {
		cfg.AddOnAppMesh = &AddOnAppMesh{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnAppMesh, cfg.AddOnAppMesh)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnAppMesh); ok {
		cfg.AddOnAppMesh = av
	} else {
		return fmt.Errorf("expected *AddOnAppMesh, got %T", vv)
	}

	if cfg.AddOnCSIEBS == nil {
		cfg.AddOnCSIEBS = &AddOnCSIEBS{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnCSIEBS, cfg.AddOnCSIEBS)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnCSIEBS); ok {
		cfg.AddOnCSIEBS = av
	} else {
		return fmt.Errorf("expected *AddOnCSIEBS, got %T", vv)
	}

	if cfg.AddOnKubernetesDashboard == nil {
		cfg.AddOnKubernetesDashboard = &AddOnKubernetesDashboard{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnKubernetesDashboard, cfg.AddOnKubernetesDashboard)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnKubernetesDashboard); ok {
		cfg.AddOnKubernetesDashboard = av
	} else {
		return fmt.Errorf("expected *AddOnKubernetesDashboard, got %T", vv)
	}

	if cfg.AddOnPrometheusGrafana == nil {
		cfg.AddOnPrometheusGrafana = &AddOnPrometheusGrafana{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnPrometheusGrafana, cfg.AddOnPrometheusGrafana)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnPrometheusGrafana); ok {
		cfg.AddOnPrometheusGrafana = av
	} else {
		return fmt.Errorf("expected *AddOnPrometheusGrafana, got %T", vv)
	}

	if cfg.AddOnPHPApache == nil {
		cfg.AddOnPHPApache = &AddOnPHPApache{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnPHPApache, cfg.AddOnPHPApache)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnPHPApache); ok {
		cfg.AddOnPHPApache = av
	} else {
		return fmt.Errorf("expected *AddOnPHPApache, got %T", vv)
	}

	if cfg.AddOnNLBHelloWorld == nil {
		cfg.AddOnNLBHelloWorld = &AddOnNLBHelloWorld{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnNLBHelloWorld, cfg.AddOnNLBHelloWorld)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnNLBHelloWorld); ok {
		cfg.AddOnNLBHelloWorld = av
	} else {
		return fmt.Errorf("expected *AddOnNLBHelloWorld, got %T", vv)
	}

	if cfg.AddOnNLBGuestbook == nil {
		cfg.AddOnNLBGuestbook = &AddOnNLBGuestbook{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnNLBGuestbook, cfg.AddOnNLBGuestbook)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnNLBGuestbook); ok {
		cfg.AddOnNLBGuestbook = av
	} else {
		return fmt.Errorf("expected *AddOnNLBGuestbook, got %T", vv)
	}

	if cfg.AddOnALB2048 == nil {
		cfg.AddOnALB2048 = &AddOnALB2048{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnALB2048, cfg.AddOnALB2048)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnALB2048); ok {
		cfg.AddOnALB2048 = av
	} else {
		return fmt.Errorf("expected *AddOnALB2048, got %T", vv)
	}

	if cfg.AddOnJobsPi == nil {
		cfg.AddOnJobsPi = &AddOnJobsPi{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnJobsPi, cfg.AddOnJobsPi)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnJobsPi); ok {
		cfg.AddOnJobsPi = av
	} else {
		return fmt.Errorf("expected *AddOnJobsPi, got %T", vv)
	}

	if cfg.AddOnJobsEcho == nil {
		cfg.AddOnJobsEcho = &AddOnJobsEcho{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnJobsEcho, cfg.AddOnJobsEcho)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnJobsEcho); ok {
		cfg.AddOnJobsEcho = av
	} else {
		return fmt.Errorf("expected *AddOnJobsEcho, got %T", vv)
	}

	if cfg.AddOnCronJobs == nil {
		cfg.AddOnCronJobs = &AddOnCronJobs{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnCronJobs, cfg.AddOnCronJobs)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnCronJobs); ok {
		cfg.AddOnCronJobs = av
	} else {
		return fmt.Errorf("expected *AddOnCronJobs, got %T", vv)
	}

	if cfg.AddOnCSRsLocal == nil {
		cfg.AddOnCSRsLocal = &AddOnCSRsLocal{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnCSRsLocal, cfg.AddOnCSRsLocal)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnCSRsLocal); ok {
		cfg.AddOnCSRsLocal = av
	} else {
		return fmt.Errorf("expected *AddOnCSRsLocal, got %T", vv)
	}

	if cfg.AddOnCSRsRemote == nil {
		cfg.AddOnCSRsRemote = &AddOnCSRsRemote{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnCSRsRemote, cfg.AddOnCSRsRemote)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnCSRsRemote); ok {
		cfg.AddOnCSRsRemote = av
	} else {
		return fmt.Errorf("expected *AddOnCSRsRemote, got %T", vv)
	}

	if cfg.AddOnConfigmapsLocal == nil {
		cfg.AddOnConfigmapsLocal = &AddOnConfigmapsLocal{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnConfigmapsLocal, cfg.AddOnConfigmapsLocal)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnConfigmapsLocal); ok {
		cfg.AddOnConfigmapsLocal = av
	} else {
		return fmt.Errorf("expected *AddOnConfigmapsLocal, got %T", vv)
	}

	if cfg.AddOnConfigmapsRemote == nil {
		cfg.AddOnConfigmapsRemote = &AddOnConfigmapsRemote{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnConfigmapsRemote, cfg.AddOnConfigmapsRemote)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnConfigmapsRemote); ok {
		cfg.AddOnConfigmapsRemote = av
	} else {
		return fmt.Errorf("expected *AddOnConfigmapsRemote, got %T", vv)
	}

	if cfg.AddOnSecretsLocal == nil {
		cfg.AddOnSecretsLocal = &AddOnSecretsLocal{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnSecretsLocal, cfg.AddOnSecretsLocal)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnSecretsLocal); ok {
		cfg.AddOnSecretsLocal = av
	} else {
		return fmt.Errorf("expected *AddOnSecretsLocal, got %T", vv)
	}

	if cfg.AddOnSecretsRemote == nil {
		cfg.AddOnSecretsRemote = &AddOnSecretsRemote{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnSecretsRemote, cfg.AddOnSecretsRemote)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnSecretsRemote); ok {
		cfg.AddOnSecretsRemote = av
	} else {
		return fmt.Errorf("expected *AddOnSecretsRemote, got %T", vv)
	}

	if cfg.AddOnFargate == nil {
		cfg.AddOnFargate = &AddOnFargate{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnFargate, cfg.AddOnFargate)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnFargate); ok {
		cfg.AddOnFargate = av
	} else {
		return fmt.Errorf("expected *AddOnFargate, got %T", vv)
	}

	if cfg.AddOnIRSA == nil {
		cfg.AddOnIRSA = &AddOnIRSA{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnIRSA, cfg.AddOnIRSA)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnIRSA); ok {
		cfg.AddOnIRSA = av
	} else {
		return fmt.Errorf("expected *AddOnIRSA, got %T", vv)
	}

	if cfg.AddOnIRSAFargate == nil {
		cfg.AddOnIRSAFargate = &AddOnIRSAFargate{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnIRSAFargate, cfg.AddOnIRSAFargate)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnIRSAFargate); ok {
		cfg.AddOnIRSAFargate = av
	} else {
		return fmt.Errorf("expected *AddOnIRSAFargate, got %T", vv)
	}

	if cfg.AddOnWordpress == nil {
		cfg.AddOnWordpress = &AddOnWordpress{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnWordpress, cfg.AddOnWordpress)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnWordpress); ok {
		cfg.AddOnWordpress = av
	} else {
		return fmt.Errorf("expected *AddOnWordpress, got %T", vv)
	}

	if cfg.AddOnJupyterHub == nil {
		cfg.AddOnJupyterHub = &AddOnJupyterHub{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnJupyterHub, cfg.AddOnJupyterHub)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnJupyterHub); ok {
		cfg.AddOnJupyterHub = av
	} else {
		return fmt.Errorf("expected *AddOnJupyterHub, got %T", vv)
	}

	if cfg.AddOnKubeflow == nil {
		cfg.AddOnKubeflow = &AddOnKubeflow{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnKubeflow, cfg.AddOnKubeflow)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnKubeflow); ok {
		cfg.AddOnKubeflow = av
	} else {
		return fmt.Errorf("expected *AddOnKubeflow, got %T", vv)
	}

	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnCUDAVectorAdd, cfg.AddOnCUDAVectorAdd)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnCUDAVectorAdd); ok {
		cfg.AddOnCUDAVectorAdd = av
	} else {
		return fmt.Errorf("expected *AddOnCUDAVectorAdd, got %T", vv)
	}

	if cfg.AddOnClusterLoaderLocal == nil {
		cfg.AddOnClusterLoaderLocal = &AddOnClusterLoaderLocal{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnClusterLoaderLocal, cfg.AddOnClusterLoaderLocal)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnClusterLoaderLocal); ok {
		cfg.AddOnClusterLoaderLocal = av
	} else {
		return fmt.Errorf("expected *AddOnClusterLoaderLocal, got %T", vv)
	}

	if cfg.AddOnClusterLoaderRemote == nil {
		cfg.AddOnClusterLoaderRemote = &AddOnClusterLoaderRemote{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnClusterLoaderRemote, cfg.AddOnClusterLoaderRemote)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnClusterLoaderRemote); ok {
		cfg.AddOnClusterLoaderRemote = av
	} else {
		return fmt.Errorf("expected *AddOnClusterLoaderRemote, got %T", vv)
	}

	if cfg.AddOnStresserLocal == nil {
		cfg.AddOnStresserLocal = &AddOnStresserLocal{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnStresserLocal, cfg.AddOnStresserLocal)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnStresserLocal); ok {
		cfg.AddOnStresserLocal = av
	} else {
		return fmt.Errorf("expected *AddOnStresserLocal, got %T", vv)
	}

	if cfg.AddOnStresserRemote == nil {
		cfg.AddOnStresserRemote = &AddOnStresserRemote{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnStresserRemote, cfg.AddOnStresserRemote)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnStresserRemote); ok {
		cfg.AddOnStresserRemote = av
	} else {
		return fmt.Errorf("expected *AddOnStresserRemote, got %T", vv)
	}

	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnStresserRemoteV2, cfg.AddOnStresserRemoteV2)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnStresserRemoteV2); ok {
		cfg.AddOnStresserRemoteV2 = av
	} else {
		return fmt.Errorf("expected *AddOnStresserRemoteV2, got %T", vv)
	}

	if cfg.AddOnClusterVersionUpgrade == nil {
		cfg.AddOnClusterVersionUpgrade = &AddOnClusterVersionUpgrade{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnClusterVersionUpgrade, cfg.AddOnClusterVersionUpgrade)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnClusterVersionUpgrade); ok {
		cfg.AddOnClusterVersionUpgrade = av
	} else {
		return fmt.Errorf("expected *AddOnClusterVersionUpgrade, got %T", vv)
	}

	if cfg.AddOnAmiSoftLockupIssue454 == nil {
		cfg.AddOnAmiSoftLockupIssue454 = &AddOnAmiSoftLockupIssue454{}
	}
	vv, err = parseEnvs(EnvironmentVariablePrefixAddOnAmiSoftLockupIssue454, cfg.AddOnAmiSoftLockupIssue454)
	if err != nil {
		return err
	}
	if av, ok := vv.(*AddOnAmiSoftLockupIssue454); ok {
		cfg.AddOnAmiSoftLockupIssue454 = av
	} else {
		return fmt.Errorf("expected *AddOnAmiSoftLockupIssue454, got %T", vv)
	}

	return nil
}