pkg/asset: Add asset for Master machines

pkg/asset/machines/aws/master.go

@@ -0,0 +1,73 @@
+// Package aws generates Machine objects for aws.
+package aws
+
+import (
+	"text/template"
+)
+
+// MasterConfig is used to generate master machines
+type MasterConfig struct {
+	MachineConfig
+	Instances []MasterInstance
+}
+
+// MasterInstance contains information specific to each
+// master machine instance to create.
+type MasterInstance struct {
+	AvailabilityZone string
+}
+
+// MasterMachineTmpl is a template for a list of master machines.
+var MasterMachineTmpl = template.Must(template.New("aws-master-machine").Parse(`
+{{- $c := . -}}
+kind: List
+apiVersion: v1
+metadata:
+  resourceVersion: ""
+  selfLink: ""
+items:
+{{- range $index,$instance := $c.Instances}}
+- apiVersion: cluster.k8s.io/v1alpha1
+  kind: Machine
+  metadata:
+    name: {{$c.ClusterName}}-master-{{$index}}
+    namespace: openshift-cluster-api
+    labels:
+      sigs.k8s.io/cluster-api-cluster: {{$c.ClusterName}}
+      sigs.k8s.io/cluster-api-machine-role: master
+      sigs.k8s.io/cluster-api-machine-type: master
+  spec:
+    providerConfig:
+      value:
+        apiVersion: aws.cluster.k8s.io/v1alpha1
+        kind: AWSMachineProviderConfig
+        ami:
+          id: {{$c.AMIID}}
+        instanceType: {{$c.Machine.InstanceType}}
+        placement:
+          region: {{$c.Region}}
+          availabilityZone: {{$instance.AvailabilityZone}}
+        subnet:
+          filters:
+          - name: "tag:Name"
+            values:
+            - "{{$c.ClusterName}}-master-{{$instance.AvailabilityZone}}"
+        iamInstanceProfile:
+          id: "{{$c.ClusterName}}-master-profile"
+        tags:
+{{- range $key,$value := $c.Tags}}
+          - name: "{{$key}}"
+            value: "{{$value}}"
+{{- end}}
+        securityGroups:
+          - filters:
+            - name: "tag:Name"
+              values:
+              - "{{$c.ClusterName}}_master_sg"
+        userDataSecret:
+          name: "master-user-data-{{$index}}"
+    versions:
+      kubelet: ""
+      controlPlane: ""
+{{- end}}
+`))

pkg/asset/machines/aws/aws.go → pkg/asset/machines/aws/worker.go

@@ -7,10 +7,16 @@ import (
 	"github.com/openshift/installer/pkg/types"
 )
 
-// Config is used to generate the machine.
-type Config struct {
+// WorkerConfig is used to generate the worker machineset.
+type WorkerConfig struct {
+	Replicas int64
+	MachineConfig
+}
+
+// MachineConfig contains fields common to worker and master
+// machine configurations
+type MachineConfig struct {
 	ClusterName string
-	Replicas    int64
 	AMIID       string
 	Tags        map[string]string
 	Region      string

pkg/asset/machines/aws/zones.go

@@ -0,0 +1,48 @@
+package aws
+
+import (
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/ec2"
+)
+
+// AvailabilityZones retrieves a list of availability zones for the given region.
+func AvailabilityZones(region string) ([]string, error) {
+	ec2Client := ec2Client(region)
+	zones, err := fetchAvailabilityZones(ec2Client, region)
+	if err != nil {
+		return nil, fmt.Errorf("cannot fetch availability zones: %v", err)
+	}
+	return zones, nil
+}
+
+func ec2Client(region string) *ec2.EC2 {
+	ssn := session.Must(session.NewSessionWithOptions(session.Options{
+		SharedConfigState: session.SharedConfigEnable,
+		Config: aws.Config{
+			Region: aws.String(region),
+		},
+	}))
+	return ec2.New(ssn)
+}
+
+func fetchAvailabilityZones(client *ec2.EC2, region string) ([]string, error) {
+	zoneFilter := &ec2.Filter{
+		Name:   aws.String("region-name"),
+		Values: []*string{aws.String(region)},
+	}
+	req := &ec2.DescribeAvailabilityZonesInput{
+		Filters: []*ec2.Filter{zoneFilter},
+	}
+	resp, err := client.DescribeAvailabilityZones(req)
+	if err != nil {
+		return nil, err
+	}
+	zones := []string{}
+	for _, zone := range resp.AvailabilityZones {
+		zones = append(zones, *zone.ZoneName)
+	}
+	return zones, nil
+}

pkg/asset/machines/libvirt/master.go

@@ -0,0 +1,55 @@
+// Package libvirt generates Machine objects for libvirt.
+package libvirt
+
+import (
+	"text/template"
+
+	"github.com/openshift/installer/pkg/types"
+)
+
+// MasterConfig is used to generate the master machine list.
+type MasterConfig struct {
+	ClusterName string
+	Instances   []string
+	Platform    types.LibvirtPlatform
+}
+
+// MasterMachinesTmpl is the template for master machines
+var MasterMachinesTmpl = template.Must(template.New("master-machines").Parse(`
+{{- $c := . -}}
+kind: List
+apiVersion: v1
+metadata:
+  resourceVersion: ""
+  selfLink: ""
+items:
+{{- range $index,$instance := .Instances}}
+- apiVersion: cluster.k8s.io/v1alpha1
+  kind: Machine
+  metadata:
+    name: {{$c.ClusterName}}-master-{{$index}}
+    namespace: openshift-cluster-api
+    labels:
+      sigs.k8s.io/cluster-api-cluster: {{$c.ClusterName}}
+      sigs.k8s.io/cluster-api-machine-role: master
+      sigs.k8s.io/cluster-api-machine-type: master
+  spec:
+    providerConfig:
+      value:
+        apiVersion: libvirtproviderconfig/v1alpha1
+        kind: LibvirtMachineProviderConfig
+        domainMemory: 2048
+        domainVcpu: 2
+        ignKey: /var/lib/libvirt/images/master-{{$index}}.ign
+        volume:
+          poolName: default
+          baseVolumeID: /var/lib/libvirt/images/coreos_base
+        networkInterfaceName: {{$c.Platform.Network.Name}}
+        networkInterfaceAddress: {{$c.Platform.Network.IPRange}}
+        autostart: false
+        uri: {{$c.Platform.URI}}
+    versions:
+      kubelet: ""
+      controlPlane: ""
+{{- end }}
+`))

pkg/asset/machines/master.go

@@ -0,0 +1,148 @@
+package machines
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/pkg/errors"
+
+	"github.com/openshift/installer/pkg/asset"
+	"github.com/openshift/installer/pkg/asset/ignition/machine"
+	"github.com/openshift/installer/pkg/asset/installconfig"
+	"github.com/openshift/installer/pkg/asset/machines/aws"
+	"github.com/openshift/installer/pkg/asset/machines/libvirt"
+	"github.com/openshift/installer/pkg/asset/machines/openstack"
+	"github.com/openshift/installer/pkg/rhcos"
+	"github.com/openshift/installer/pkg/types"
+)
+
+// Master generates the machines for the `master` machine pool.
+type Master struct {
+	MachinesRaw        []byte
+	UserDataSecretsRaw []byte
+}
+
+var _ asset.Asset = (*Master)(nil)
+
+// Name returns a human friendly name for the Master Asset.
+func (m *Master) Name() string {
+	return "Master Machines"
+}
+
+// Dependencies returns all of the dependencies directly needed by the
+// Master asset
+func (m *Master) Dependencies() []asset.Asset {
+	return []asset.Asset{
+		&installconfig.InstallConfig{},
+		&machine.Master{},
+	}
+}
+
+// Generate generates the Master asset.
+func (m *Master) Generate(dependencies asset.Parents) error {
+	installconfig := &installconfig.InstallConfig{}
+	mign := &machine.Master{}
+	dependencies.Get(installconfig, mign)
+
+	userDataContent := map[string][]byte{}
+	for i, file := range mign.FileList {
+		userDataContent[fmt.Sprintf("master-user-data-%d", i)] = file.Data
+	}
+
+	var err error
+	m.UserDataSecretsRaw, err = userDataList(userDataContent)
+	if err != nil {
+		return errors.Wrap(err, "failed to create user-data secrets for master machines")
+	}
+
+	ic := installconfig.Config
+	pool := masterPool(ic.Machines)
+	numOfMasters := int64(0)
+	if pool.Replicas != nil {
+		numOfMasters = *pool.Replicas
+	}
+
+	switch ic.Platform.Name() {
+	case "aws":
+		config := aws.MasterConfig{}
+		config.ClusterName = ic.ObjectMeta.Name
+		config.Region = ic.Platform.AWS.Region
+		config.Machine = defaultAWSMachinePoolPlatform()
+
+		tags := map[string]string{
+			"tectonicClusterID": ic.ClusterID,
+		}
+		for k, v := range ic.Platform.AWS.UserTags {
+			tags[k] = v
+		}
+		config.Tags = tags
+
+		config.Machine.Set(ic.Platform.AWS.DefaultMachinePlatform)
+		config.Machine.Set(pool.Platform.AWS)
+
+		ctx, cancel := context.WithTimeout(context.TODO(), 60*time.Second)
+		defer cancel()
+		ami, err := rhcos.AMI(ctx, rhcos.DefaultChannel, config.Region)
+		if err != nil {
+			return errors.Wrap(err, "failed to determine default AMI")
+		}
+		config.AMIID = ami
+		azs, err := aws.AvailabilityZones(config.Region)
+		if err != nil {
+			return errors.Wrap(err, "failed to fetch availability zones")
+		}
+
+		for i := 0; i < int(numOfMasters); i++ {
+			azIndex := i % len(azs)
+			config.Instances = append(config.Instances, aws.MasterInstance{AvailabilityZone: azs[azIndex]})
+		}
+
+		m.MachinesRaw = applyTemplateData(aws.MasterMachineTmpl, config)
+	case "libvirt":
+		instances := []string{}
+		for i := 0; i < int(numOfMasters); i++ {
+			instances = append(instances, fmt.Sprintf("master-%d", i))
+		}
+		config := libvirt.MasterConfig{
+			ClusterName: ic.ObjectMeta.Name,
+			Instances:   instances,
+			Platform:    *ic.Platform.Libvirt,
+		}
+		m.MachinesRaw = applyTemplateData(libvirt.MasterMachinesTmpl, config)
+	case "openstack":
+		instances := []string{}
+		for i := 0; i < int(numOfMasters); i++ {
+			instances = append(instances, fmt.Sprintf("master-%d", i))
+		}
+		config := openstack.MasterConfig{
+			ClusterName: ic.ObjectMeta.Name,
+			Instances:   instances,
+			Image:       ic.Platform.OpenStack.BaseImage,
+			Region:      ic.Platform.OpenStack.Region,
+			Machine:     defaultOpenStackMachinePoolPlatform(),
+		}
+
+		tags := map[string]string{
+			"tectonicClusterID": ic.ClusterID,
+		}
+		config.Tags = tags
+
+		config.Machine.Set(ic.Platform.OpenStack.DefaultMachinePlatform)
+		config.Machine.Set(pool.Platform.OpenStack)
+
+		m.MachinesRaw = applyTemplateData(openstack.MasterMachinesTmpl, config)
+	default:
+		return fmt.Errorf("invalid Platform")
+	}
+	return nil
+}
+
+func masterPool(pools []types.MachinePool) types.MachinePool {
+	for idx, pool := range pools {
+		if pool.Name == "master" {
+			return pools[idx]
+		}
+	}
+	return types.MachinePool{}
+}