func()

in controllers/etcdadmconfig_controller.go [288:370]
73 lines of code
12 McCabe index (conditional complexity)

func (r *EtcdadmConfigReconciler) joinEtcd(ctx context.Context, scope *Scope) (_ ctrl.Result, rerr error) {
	log := r.Log
	etcdSecretName := fmt.Sprintf("%v-%v", scope.Cluster.Name, "etcd-init")
	existingSecret := &corev1.Secret{}
	if err := r.Client.Get(ctx, client.ObjectKey{Namespace: scope.Cluster.Namespace, Name: etcdSecretName}, existingSecret); err != nil {
		if apierrors.IsNotFound(err) {
			// this is not an error, just means the first machine didn't get an address yet, reconcile
			log.Info("Waiting for Machine Controller to set address on init machine and returning error")
			return ctrl.Result{}, err
		}
		log.Error(err, "Failed to get secret containing first machine address")
		return ctrl.Result{}, err
	}
	log.Info("Machine Controller has set address on init machine")

	etcdCerts := etcdCACertKeyPair()
	if err := etcdCerts.Lookup(
		ctx,
		r.Client,
		util.ObjectKey(scope.Cluster),
	); err != nil {
		return ctrl.Result{}, errors.Wrap(err, "failed doing a lookup for certs during join")
	}

	var joinAddress string
	if clientURL, ok := existingSecret.Data["clientUrls"]; ok {
		joinAddress = string(clientURL)
	} else {
		initMachineAddress := string(existingSecret.Data["address"])
		joinAddress = fmt.Sprintf("https://%v:2379", initMachineAddress)
	}

	joinInput := userdata.EtcdPlaneJoinInput{
		BaseUserData: userdata.BaseUserData{
			Users:              scope.Config.Spec.Users,
			PreEtcdadmCommands: scope.Config.Spec.PreEtcdadmCommands,
			NTP:                scope.Config.Spec.NTP,
			Hostname:           scope.Machine.Name,
		},
		JoinAddress:  joinAddress,
		Certificates: etcdCerts,
	}

	// grab user pass for registry mirror
	if scope.Config.Spec.RegistryMirror != nil {
		username, password, err := r.resolveRegistryCredentials(ctx, scope.Config)
		if err != nil {
			log.Info("Cannot find secret for registry credentials, proceeding without registry credentials")
		} else {
			joinInput.RegistryMirrorCredentials.Username = string(username)
			joinInput.RegistryMirrorCredentials.Password = string(password)
		}
	}

	if !scope.Config.Spec.EtcdadmBuiltin {
		if len(scope.Config.Spec.EtcdadmInstallCommands) > 0 {
			joinInput.PreEtcdadmCommands = append(joinInput.PreEtcdadmCommands, scope.Config.Spec.EtcdadmInstallCommands...)
		} else {
			joinInput.PreEtcdadmCommands = append(joinInput.PreEtcdadmCommands, defaultEtcdadmInstallCommands...)
		}
	}

	var bootstrapData []byte
	var err error

	switch scope.Config.Spec.Format {
	case etcdbootstrapv1.Bottlerocket:
		bootstrapData, err = bottlerocket.NewJoinEtcdPlane(&joinInput, scope.Config.Spec, log)
	default:
		joinInput.PreEtcdadmCommands = append(joinInput.PreEtcdadmCommands, stopKubeletCommand)
		bootstrapData, err = cloudinit.NewJoinEtcdPlane(&joinInput, scope.Config.Spec)
	}
	if err != nil {
		log.Error(err, "Failed to generate cloud init for bootstrap etcd plane - join")
		return ctrl.Result{}, err
	}

	if err := r.storeBootstrapData(ctx, scope.Config, bootstrapData, scope.Cluster.Name); err != nil {
		log.Error(err, "Failed to store bootstrap data - join")
		return ctrl.Result{}, err
	}
	return ctrl.Result{}, nil
}