func()

in controllers/codebase/service/chain/put_deploy_configs.go [51:156]

• 82 lines of code
• 15 McCabe index (conditional complexity)

func (h *PutDeployConfigs) tryToPushConfigs(ctx context.Context, codebase *codebaseApi.Codebase) error {
	log := ctrl.LoggerFrom(ctx)

	if codebase.Status.Git == util.ProjectTemplatesPushedStatus {
		log.Info("Skip pushing templates. Templates already pushed")

		return nil
	}

	gitServer := &codebaseApi.GitServer{}
	if err := h.client.Get(
		ctx,
		client.ObjectKey{Name: codebase.Spec.GitServer, Namespace: codebase.Namespace},
		gitServer,
	); err != nil {
		setFailedFields(codebase, codebaseApi.SetupDeploymentTemplates, err.Error())
		return fmt.Errorf("failed get GitServer: %w", err)
	}

	gitServerSecret := &corev1.Secret{}
	if err := h.client.Get(
		ctx,
		client.ObjectKey{Name: gitServer.Spec.NameSshKeySecret, Namespace: codebase.Namespace},
		gitServerSecret,
	); err != nil {
		return fmt.Errorf("failed to get GitServer secret: %w", err)
	}

	privateSSHKey := string(gitServerSecret.Data[util.PrivateSShKeyName])
	repoSshUrl := util.GetSSHUrl(gitServer, codebase.Spec.GetProjectID())
	wd := util.GetWorkDir(codebase.Name, codebase.Namespace)

	if !util.DoesDirectoryExist(wd) || util.IsDirectoryEmpty(wd) {
		log.Info("Start cloning repository", "url", repoSshUrl)

		if err := h.git.CloneRepositoryBySsh(
			ctx,
			privateSSHKey,
			gitServer.Spec.GitUser,
			repoSshUrl,
			wd,
			gitServer.Spec.SshPort,
		); err != nil {
			return fmt.Errorf("failed to clone git repository: %w", err)
		}

		log.Info("Repository has been cloned", "url", repoSshUrl)
	}

	if gitServer.Spec.GitProvider == codebaseApi.GitProviderGerrit {
		log.Info("Start adding commit hooks")

		if err := h.addCommitHooks(wd); err != nil {
			return fmt.Errorf("failed to add commit hooks: %w", err)
		}

		log.Info("Commit hooks have been added")
	}

	ru, err := util.GetRepoUrl(codebase)
	if err != nil {
		return fmt.Errorf("failed to build repo url: %w", err)
	}

	log.Info("Start checkout default branch", "branch", codebase.Spec.DefaultBranch, "repo", ru)

	err = CheckoutBranch(ru, wd, codebase.Spec.DefaultBranch, h.git, codebase, h.client)
	if err != nil {
		return fmt.Errorf("failed to checkout default branch %v in put_deploy_config has been failed: %w", codebase.Spec.DefaultBranch, err)
	}

	log.Info("Default branch has been checked out", "branch", codebase.Spec.DefaultBranch, "repo", ru)
	log.Info("Start preparing templates")

	err = template.PrepareTemplates(ctx, h.client, codebase, wd)
	if err != nil {
		return fmt.Errorf("failed to prepare template: %w", err)
	}

	log.Info("Templates have been prepared")
	log.Info("Start committing changes")

	err = h.git.CommitChanges(wd, fmt.Sprintf("Add deployment templates for %s", codebase.Name))
	if err != nil {
		return fmt.Errorf("failed to commit changes: %w", err)
	}

	log.Info("Changes have been committed")
	log.Info("Start pushing changes")

	err = h.git.PushChanges(privateSSHKey, gitServer.Spec.GitUser, wd, gitServer.Spec.SshPort, "--all")
	if err != nil {
		return fmt.Errorf("failed to push changes: %w", err)
	}

	log.Info("Changes have been pushed")

	codebase.Status.Git = util.ProjectTemplatesPushedStatus
	if err = h.client.Status().Update(ctx, codebase); err != nil {
		return fmt.Errorf("failed to set git status %s for codebase %s: %w", util.ProjectTemplatesPushedStatus, codebase.Name, err)
	}

	log.Info("Config has been pushed")

	return nil
}