types/vsphere: simplify vsphere platform

data/data/manifests/openshift/cloud-creds-secret.yaml.template

@@ -16,8 +16,6 @@ data:
 {{- else if .CloudCreds.OpenStack}}
   clouds.yaml: {{.CloudCreds.OpenStack.Base64encodeCloudCreds}}
 {{- else if .CloudCreds.VSphere}}
-{{- range .CloudCreds.VSphere.VirtualCenters}}
-  {{.Name}}.username: {{.Base64encodeUsername}}
-  {{.Name}}.password: {{.Base64encodePassword}}
-{{- end}}
+  {{.CloudCreds.VSphere.VCenter}}.username: {{.CloudCreds.VSphere.Base64encodeUsername}}
+  {{.CloudCreds.VSphere.VCenter}}.password: {{.CloudCreds.VSphere.Base64encodePassword}}
 {{- end}}

pkg/asset/manifests/cloudproviderconfig.go

@@ -91,7 +91,10 @@ func (cpc *CloudProviderConfig) Generate(dependencies asset.Parents) error {
 		}
 		cm.Data[cloudProviderConfigDataKey] = string(marshalled)
 	case vspheretypes.Name:
-		vsphereConfig, err := vspheremanifests.CloudProviderConfig(installConfig.Config.Platform.VSphere)
+		vsphereConfig, err := vspheremanifests.CloudProviderConfig(
+			installConfig.Config.ObjectMeta.Name,
+			installConfig.Config.Platform.VSphere,
+		)
 		if err != nil {
 			return errors.Wrap(err, "could not create cloud provider config")
 		}

pkg/asset/manifests/openshift.go

@@ -97,15 +97,11 @@ func (o *Openshift) Generate(dependencies asset.Parents) error {
 			},
 		}
 	case vspheretypes.Name:
-		vcCreds := make([]VSphereVirtualCenterCredsSecretData, len(installConfig.Config.VSphere.VirtualCenters))
-		for i, vc := range installConfig.Config.VSphere.VirtualCenters {
-			vcCreds[i].Name = vc.Name
-			vcCreds[i].Base64encodeUsername = base64.StdEncoding.EncodeToString([]byte(vc.Username))
-			vcCreds[i].Base64encodePassword = base64.StdEncoding.EncodeToString([]byte(vc.Password))
-		}
 		cloudCreds = cloudCredsSecretData{
 			VSphere: &VSphereCredsSecretData{
-				VirtualCenters: vcCreds,
+				VCenter:              installConfig.Config.VSphere.VCenter,
+				Base64encodeUsername: base64.StdEncoding.EncodeToString([]byte(installConfig.Config.VSphere.Username)),
+				Base64encodePassword: base64.StdEncoding.EncodeToString([]byte(installConfig.Config.VSphere.Password)),
 			},
 		}
 	}

pkg/asset/manifests/operators.go

@@ -17,7 +17,6 @@ import (
 	"github.com/openshift/installer/pkg/asset/templates/content/bootkube"
 	"github.com/openshift/installer/pkg/asset/tls"
 	"github.com/openshift/installer/pkg/types"
-	vspheretypes "github.com/openshift/installer/pkg/types/vsphere"
 )
 
 const (
@@ -268,12 +267,8 @@ func redactedInstallConfig(config types.InstallConfig) ([]byte, error) {
 	config.PullSecret = ""
 	if config.Platform.VSphere != nil {
 		p := *config.Platform.VSphere
-		p.VirtualCenters = make([]vspheretypes.VirtualCenter, len(config.Platform.VSphere.VirtualCenters))
-		for i, vc := range config.Platform.VSphere.VirtualCenters {
-			vc.Username = ""
-			vc.Password = ""
-			p.VirtualCenters[i] = vc
-		}
+		p.Username = ""
+		p.Password = ""
 		config.Platform.VSphere = &p
 	}
 	return yaml.Marshal(config)

pkg/asset/manifests/operators_test.go

@@ -44,29 +44,11 @@ func TestRedactedInstallConfig(t *testing.T) {
 			},
 			Platform: types.Platform{
 				VSphere: &vspheretypes.Platform{
-					VirtualCenters: []vspheretypes.VirtualCenter{
-						{
-							Name:        "test-server-1",
-							Username:    "test-user-1",
-							Password:    "test-pass-1",
-							Datacenters: []string{"test-datacenter-1"},
-						},
-						{
-							Name:        "test-server-2",
-							Username:    "test-user-2",
-							Password:    "test-pass-2",
-							Datacenters: []string{"test-datacenter-2"},
-						},
-					},
-					Workspace: vspheretypes.Workspace{
-						Server:           "test-server-1",
-						Datacenter:       "test-datacenter-1",
-						DefaultDatastore: "test-datastore",
-						ResourcePoolPath: "test-resource-pool",
-						Folder:           "test-folder",
-					},
-					SCSIControllerType: "test-controller-type",
-					PublicNetwork:      "test-network",
+					VCenter:          "test-server-1",
+					Username:         "test-user-1",
+					Password:         "test-pass-1",
+					Datacenter:       "test-datacenter",
+					DefaultDatastore: "test-datastore",
 				},
 			},
 			PullSecret: "test-pull-secret",
@@ -95,25 +77,11 @@ networking:
   - 1.2.3.4/5
 platform:
   vsphere:
-    publicNetwork: test-network
-    scsiControllerType: test-controller-type
-    virtualCenters:
-    - datacenters:
-      - test-datacenter-1
-      name: test-server-1
-      password: ""
-      username: ""
-    - datacenters:
-      - test-datacenter-2
-      name: test-server-2
-      password: ""
-      username: ""
-    workspace:
-      datacenter: test-datacenter-1
-      defaultDatastore: test-datastore
-      folder: test-folder
-      resourcePoolPath: test-resource-pool
-      server: test-server-1
+    datacenter: test-datacenter
+    defaultDatastore: test-datastore
+    password: ""
+    username: ""
+    vCenter: test-server-1
 pullSecret: ""
 sshKey: test-ssh-key
 `

pkg/asset/manifests/template.go

@@ -13,12 +13,7 @@ type OpenStackCredsSecretData struct {
 
 // VSphereCredsSecretData holds encoded credentials and is used to generated cloud-creds secret
 type VSphereCredsSecretData struct {
-	VirtualCenters []VSphereVirtualCenterCredsSecretData
-}
-
-// VSphereVirtualCenterCredsSecretData holds the encoded credentials for a vSphere vCenter.
-type VSphereVirtualCenterCredsSecretData struct {
-	Name                 string
+	VCenter              string
 	Base64encodeUsername string
 	Base64encodePassword string
 }

pkg/asset/manifests/vsphere/cloudproviderconfig.go

@@ -13,71 +13,53 @@ import (
 type config struct {
 	Global    global
 	Workspace workspace
-	Disk      disk
-	Network   network
 }
 
 type global struct {
 	SecretName      string `ini:"secret-name"`
 	SecretNamespace string `ini:"secret-namespace"`
+	InsecureFlag    int    `ini:"insecure-flag"`
 }
 
 type workspace struct {
 	Server           string `ini:"server"`
 	Datacenter       string `ini:"datacenter"`
 	DefaultDatastore string `ini:"default-datastore"`
-	ResourcePoolPath string `ini:"resourcepool-path,omitempty"`
 	Folder           string `ini:"folder"`
 }
 
-type disk struct {
-	SCSIControllerType string `ini:"scsicontrollertype"`
-}
-
-type network struct {
-	PublicNetwork string `ini:"public-network"`
-}
-
 type virtualCenter struct {
-	Datacenters []string `ini:"datacenters"`
+	Datacenters string `ini:"datacenters"`
 }
 
 // CloudProviderConfig generates the cloud provider config for the vSphere platform.
-func CloudProviderConfig(p *vspheretypes.Platform) (string, error) {
+func CloudProviderConfig(clusterName string, p *vspheretypes.Platform) (string, error) {
 	file := ini.Empty()
 	config := &config{
 		Global: global{
 			SecretName:      "vsphere-creds",
 			SecretNamespace: "kube-system",
+			InsecureFlag:    1,
 		},
 		Workspace: workspace{
-			Server:           p.Workspace.Server,
-			Datacenter:       p.Workspace.Datacenter,
-			DefaultDatastore: p.Workspace.DefaultDatastore,
-			ResourcePoolPath: p.Workspace.ResourcePoolPath,
-			Folder:           p.Workspace.Folder,
-		},
-		Disk: disk{
-			SCSIControllerType: p.SCSIControllerType,
-		},
-		Network: network{
-			PublicNetwork: p.PublicNetwork,
+			Server:           p.VCenter,
+			Datacenter:       p.Datacenter,
+			DefaultDatastore: p.DefaultDatastore,
+			Folder:           clusterName,
 		},
 	}
 	if err := file.ReflectFrom(config); err != nil {
 		return "", errors.Wrap(err, "failed to reflect from config")
 	}
-	for _, vc := range p.VirtualCenters {
-		s, err := file.NewSection(fmt.Sprintf("VirtualCenter %q", vc.Name))
-		if err != nil {
-			return "", errors.Wrapf(err, "failed to create section for virtual center %q", vc.Name)
-		}
-		if err := s.ReflectFrom(
-			&virtualCenter{
-				Datacenters: vc.Datacenters,
-			}); err != nil {
-			return "", errors.Wrapf(err, "failed to reflect from virtual center %q", vc.Name)
-		}
+	s, err := file.NewSection(fmt.Sprintf("VirtualCenter %q", p.VCenter))
+	if err != nil {
+		return "", errors.Wrapf(err, "failed to create section for virtual center")
+	}
+	if err := s.ReflectFrom(
+		&virtualCenter{
+			Datacenters: p.Datacenter,
+		}); err != nil {
+		return "", errors.Wrapf(err, "failed to reflect from virtual center")
 	}
 	buf := &bytes.Buffer{}
 	if _, err := file.WriteTo(buf); err != nil {