talos

1
// This Source Code Form is subject to the terms of the Mozilla Public
2
// License, v. 2.0. If a copy of the MPL was not distributed with this
3
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
4

5
package qemu
6

7
import (
8
	"context"
9
	"fmt"
10
	"path/filepath"
11

12
	"github.com/siderolabs/talos/pkg/machinery/constants"
13
	"github.com/siderolabs/talos/pkg/provision"
14
	"github.com/siderolabs/talos/pkg/provision/providers/vm"
15
)
16

17
// Create Talos cluster as a set of qemu VMs.
18
//
19
//nolint:gocyclo
20
func (p *provisioner) Create(ctx context.Context, request provision.ClusterRequest, opts ...provision.Option) (provision.Cluster, error) {
21
	options := provision.DefaultOptions()
22

23
	for _, opt := range opts {
24
		if err := opt(&options); err != nil {
25
			return nil, err
26
		}
27
	}
28

29
	arch := Arch(options.TargetArch)
30
	if !arch.Valid() {
31
		return nil, fmt.Errorf("unsupported arch: %q", options.TargetArch)
32
	}
33

34
	if err := p.preflightChecks(ctx, request, options, arch); err != nil {
35
		return nil, err
36
	}
37

38
	statePath := filepath.Join(request.StateDirectory, request.Name)
39

40
	fmt.Fprintf(options.LogWriter, "creating state directory in %q\n", statePath)
41

42
	state, err := vm.NewState(
43
		statePath,
44
		p.Name,
45
		request.Name,
46
	)
47
	if err != nil {
48
		return nil, err
49
	}
50

51
	if options.SiderolinkEnabled {
52
		fmt.Fprintln(options.LogWriter, "creating siderolink agent")
53

54
		if err = p.CreateSiderolinkAgent(state, request); err != nil {
55
			return nil, err
56
		}
57

58
		fmt.Fprintln(options.LogWriter, "created siderolink agent")
59
	}
60

61
	fmt.Fprintln(options.LogWriter, "creating network", request.Network.Name)
62

63
	if err = p.CreateNetwork(ctx, state, request.Network, options); err != nil {
64
		return nil, fmt.Errorf("unable to provision CNI network: %w", err)
65
	}
66

67
	fmt.Fprintln(options.LogWriter, "creating load balancer")
68

69
	if err = p.CreateLoadBalancer(state, request); err != nil {
70
		return nil, fmt.Errorf("error creating loadbalancer: %w", err)
71
	}
72

73
	if options.KMSEndpoint != "" {
74
		fmt.Fprintln(options.LogWriter, "creating KMS server")
75

76
		if err = p.CreateKMS(state, request, options); err != nil {
77
			return nil, fmt.Errorf("error creating KMS server: %w", err)
78
		}
79
	}
80

81
	fmt.Fprintln(options.LogWriter, "creating dhcpd")
82

83
	if err = p.CreateDHCPd(state, request); err != nil {
84
		return nil, fmt.Errorf("error creating dhcpd: %w", err)
85
	}
86

87
	var nodeInfo []provision.NodeInfo
88

89
	fmt.Fprintln(options.LogWriter, "creating controlplane nodes")
90

91
	if nodeInfo, err = p.createNodes(state, request, request.Nodes.ControlPlaneNodes(), &options); err != nil {
92
		return nil, err
93
	}
94

95
	fmt.Fprintln(options.LogWriter, "creating worker nodes")
96

97
	var workerNodeInfo []provision.NodeInfo
98

99
	if workerNodeInfo, err = p.createNodes(state, request, request.Nodes.WorkerNodes(), &options); err != nil {
100
		return nil, err
101
	}
102

103
	var pxeNodeInfo []provision.NodeInfo
104

105
	pxeNodes := request.Nodes.PXENodes()
106
	if len(pxeNodes) > 0 {
107
		fmt.Fprintln(options.LogWriter, "creating PXE nodes")
108

109
		if pxeNodeInfo, err = p.createNodes(state, request, pxeNodes, &options); err != nil {
110
			return nil, err
111
		}
112
	}
113

114
	nodeInfo = append(nodeInfo, workerNodeInfo...)
115

116
	lbPort := constants.DefaultControlPlanePort
117

118
	if len(request.Network.LoadBalancerPorts) > 0 {
119
		lbPort = request.Network.LoadBalancerPorts[0]
120
	}
121

122
	state.ClusterInfo = provision.ClusterInfo{
123
		ClusterName: request.Name,
124
		Network: provision.NetworkInfo{
125
			Name:              request.Network.Name,
126
			CIDRs:             request.Network.CIDRs,
127
			NoMasqueradeCIDRs: request.Network.NoMasqueradeCIDRs,
128
			GatewayAddrs:      request.Network.GatewayAddrs,
129
			MTU:               request.Network.MTU,
130
		},
131
		Nodes:              nodeInfo,
132
		ExtraNodes:         pxeNodeInfo,
133
		KubernetesEndpoint: p.GetExternalKubernetesControlPlaneEndpoint(request.Network, lbPort),
134
	}
135

136
	err = state.Save()
137
	if err != nil {
138
		return nil, err
139
	}
140

141
	return state, nil
142
}
143