func resourceGitlabRepositoryFileCreate()

in internal/provider/sdk/resource_gitlab_repository_file.go [133:246]
100 lines of code
21 McCabe index (conditional complexity)

func resourceGitlabRepositoryFileCreate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
	project := d.Get("project").(string)
	filePath := d.Get("file_path").(string)

	tflog.Debug(ctx, fmt.Sprintf("[DEBUG] gitlab_repository_file: waiting for lock to create %s/%s", project, filePath))
	if err := resourceGitlabRepositoryFileApiLock.lock(ctx); err != nil {
		return diag.FromErr(err)
	}
	defer resourceGitlabRepositoryFileApiLock.unlock()
	tflog.Debug(ctx, fmt.Sprintf("[DEBUG] gitlab_repository_file: got lock to create %s/%s", project, filePath))

	client := meta.(*gitlab.Client)
	content := d.Get("content").(string)

	options := &gitlab.CreateFileOptions{
		Branch:      gitlab.Ptr(d.Get("branch").(string)),
		AuthorEmail: gitlab.Ptr(d.Get("author_email").(string)),
		AuthorName:  gitlab.Ptr(d.Get("author_name").(string)),
		Encoding:    gitlab.Ptr(d.Get("encoding").(string)),
		Content:     gitlab.Ptr(content),
	}
	if startBranch, ok := d.GetOk("start_branch"); ok {
		options.StartBranch = gitlab.Ptr(startBranch.(string))
	}
	if executeFilemode, ok := d.GetOk("execute_filemode"); ok {
		options.ExecuteFilemode = gitlab.Ptr(executeFilemode.(bool))
	}
	if commitMessage, ok := d.GetOk("commit_message"); ok {
		options.CommitMessage = gitlab.Ptr(commitMessage.(string))
	} else {
		options.CommitMessage = gitlab.Ptr(d.Get("create_commit_message").(string))
	}

	if overwriteOnCreate, ok := d.GetOk("overwrite_on_create"); ok && overwriteOnCreate.(bool) {
		readOptions := &gitlab.GetFileOptions{
			Ref: gitlab.Ptr(*options.Branch),
		}
		var existingRepositoryFile *gitlab.File
		// Try to get the file to check if it exists
		err := retry.RetryContext(ctx, d.Timeout(schema.TimeoutUpdate), func() *retry.RetryError {
			var err error
			existingRepositoryFile, _, err = client.RepositoryFiles.GetFile(project, filePath, readOptions, gitlab.WithContext(ctx))
			if err != nil {
				if isRefreshError(err) {
					return retry.RetryableError(err)
				}
				if !api.Is404(err) {
					return retry.NonRetryableError(err)
				}
			}

			if existingRepositoryFile != nil {
				tflog.Debug(ctx, fmt.Sprintf("[DEBUG] %s already exists and overwrite_on_create is true. File will be overwritten.", filePath))

				updateOptions := &gitlab.UpdateFileOptions{
					Branch:      gitlab.Ptr(*options.Branch),
					AuthorEmail: gitlab.Ptr(d.Get("author_email").(string)),
					AuthorName:  gitlab.Ptr(d.Get("author_name").(string)),
					Encoding:    gitlab.Ptr(d.Get("encoding").(string)),
					Content:     gitlab.Ptr(content),
				}

				if startBranch, ok := d.GetOk("start_branch"); ok {
					updateOptions.StartBranch = gitlab.Ptr(startBranch.(string))
				}
				if executeFilemode, ok := d.GetOk("execute_filemode"); ok {
					updateOptions.ExecuteFilemode = gitlab.Ptr(executeFilemode.(bool))
				}
				if commitMessage, ok := d.GetOk("commit_message"); ok {
					updateOptions.CommitMessage = gitlab.Ptr(commitMessage.(string))
				} else {
					updateOptions.CommitMessage = gitlab.Ptr(d.Get("update_commit_message").(string))
				}

				updateOptions.LastCommitID = gitlab.Ptr(existingRepositoryFile.LastCommitID)
				_, _, err := client.RepositoryFiles.UpdateFile(project, filePath, updateOptions, gitlab.WithContext(ctx))
				if err != nil {
					if isRefreshError(err) {
						return retry.RetryableError(err)
					}
					return retry.NonRetryableError(err)
				}

			}
			return nil
		})
		if err != nil {
			return diag.FromErr(err)
		}

		if existingRepositoryFile != nil {
			d.SetId(resourceGitLabRepositoryFileBuildId(project, *options.Branch, existingRepositoryFile.FilePath))
			return resourceGitlabRepositoryFileRead(ctx, d, meta)
		}
	}

	err := retry.RetryContext(ctx, d.Timeout(schema.TimeoutCreate), func() *retry.RetryError {
		repositoryFile, _, err := client.RepositoryFiles.CreateFile(project, filePath, options, gitlab.WithContext(ctx))
		if err != nil {
			if isRefreshError(err) {
				return retry.RetryableError(err)
			}
			return retry.NonRetryableError(err)
		}

		d.SetId(resourceGitLabRepositoryFileBuildId(project, repositoryFile.Branch, repositoryFile.FilePath))
		return nil
	})
	if err != nil {
		return diag.FromErr(err)
	}

	return resourceGitlabRepositoryFileRead(ctx, d, meta)
}