Merge pull request #724 from timofurrer/feature/gitlab_repository_file

feature: add gitlab_repository_file resource. Closes #720, #688, #350

Author: nagyv

docs/resources/repository_file.md

@@ -0,0 +1,76 @@
+# gitlab\_repository\_file
+
+This resource allows you to create and manage GitLab repository files.
+
+**Limitations**:
+
+The [GitLab Repository Files API](https://docs.gitlab.com/ee/api/repository_files.html)
+can only create, update or delete a single file at the time.
+The API will also
+[fail with a `400`](https://docs.gitlab.com/ee/api/repository_files.html#update-existing-file-in-repository)
+response status code if the underlying repository is changed while the API tries to make changes.
+Therefore, it's recommended to make sure that you execute it with
+[`-parallelism=1`](https://www.terraform.io/docs/cli/commands/apply.html#parallelism-n)
+and that no other entity than the terraform at hand makes changes to the
+underlying repository while it's executing.
+
+## Example Usage
+
+```hcl
+resource "gitlab_group" "this" {
+    name        = "example"
+    path        = "example"
+    description = "An example group"
+}
+resource "gitlab_project" "this" {
+    name                   = "example"
+    namespace_id           = gitlab_group.this.id
+    initialize_with_readme = true
+}
+resource "gitlab_repository_file" "this" {
+    project        = gitlab_project.this.id
+    file_path      = "meow.txt"
+    branch         = "main"
+    content        = base64encode("Meow goes the cat")
+    author_email   = "[email protected]"
+    author_name    = "Terraform"
+    commit_message = "feature: add meow file"
+}
+```
+
+## Argument Reference
+
+The following arguments are supported:
+
+* `project` - (Required) The ID of the project.
+
+* `file_path` - (Required) The full path of the file.
+                It must be relative to the root of the project without a leading slash `/`.
+
+* `branch` - (Required) Name of the branch to which to commit to.
+
+* `content` - (Required) base64 encoded file content.
+              No other encoding is currently supported,
+              because of a [GitLab API bug](https://gitlab.com/gitlab-org/gitlab/-/issues/342430).
+
+* `commit_message` - (Required) Commit message.
+
+* `start_branch` - (Optional) Name of the branch to start the new commit from.
+
+* `author_email` - (Optional) Email of the commit author.
+
+* `author_name` - (Optional) Name of the commit author.
+
+## Attribute Reference
+
+The resource exports the following attributes:
+
+* `id` - The unique ID assigned to the file.
+
+## Import
+
+A Repository File can be imported using the following id pattern, e.g.
+
+```
+$ terraform import gitlab_repository_file.this <project-id>:<branch-name>:<file-path>
+```

gitlab/provider.go

@@ -108,6 +108,7 @@ func Provider() *schema.Provider {
 			"gitlab_group_share_group":          resourceGitlabGroupShareGroup(),
 			"gitlab_project_badge":              resourceGitlabProjectBadge(),
 			"gitlab_group_badge":                resourceGitlabGroupBadge(),
+			"gitlab_repository_file":            resourceGitLabRepositoryFile(),
 		},
 	}
 

gitlab/resource_gitlab_repository_file.go

@@ -0,0 +1,221 @@
+package gitlab
+
+import (
+	"context"
+	"encoding/base64"
+	"fmt"
+	"log"
+	"strings"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	gitlab "github.com/xanzy/go-gitlab"
+)
+
+const encoding = "base64"
+
+func resourceGitLabRepositoryFile() *schema.Resource {
+	return &schema.Resource{
+		CreateContext: resourceGitlabRepositoryFileCreate,
+		ReadContext:   resourceGitlabRepositoryFileRead,
+		UpdateContext: resourceGitlabRepositoryFileUpdate,
+		DeleteContext: resourceGitlabRepositoryFileDelete,
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+
+		// the schema matches https://docs.gitlab.com/ee/api/repository_files.html#create-new-file-in-repository
+		// However, we don't support the `encoding` parameter as it seems to be broken.
+		// Only a value of `base64` is supported, all others, including the documented default `text`, lead to
+		// a `400 {error: encoding does not have a valid value}` error.
+		Schema: map[string]*schema.Schema{
+			"project": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"file_path": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"branch": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"start_branch": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+			"author_email": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+			"author_name": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+			"content": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ValidateFunc: validateBase64Content,
+			},
+			"commit_message": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"encoding": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func resourceGitlabRepositoryFileCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	client := meta.(*gitlab.Client)
+	project := d.Get("project").(string)
+	filePath := d.Get("file_path").(string)
+
+	options := &gitlab.CreateFileOptions{
+		Branch:        gitlab.String(d.Get("branch").(string)),
+		Encoding:      gitlab.String(encoding),
+		AuthorEmail:   gitlab.String(d.Get("author_email").(string)),
+		AuthorName:    gitlab.String(d.Get("author_name").(string)),
+		Content:       gitlab.String(d.Get("content").(string)),
+		CommitMessage: gitlab.String(d.Get("commit_message").(string)),
+	}
+	if startBranch, ok := d.GetOk("start_branch"); ok {
+		options.StartBranch = gitlab.String(startBranch.(string))
+	}
+
+	repositoryFile, _, err := client.RepositoryFiles.CreateFile(project, filePath, options, gitlab.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId(resourceGitLabRepositoryFileBuildId(project, repositoryFile.Branch, repositoryFile.FilePath))
+	return resourceGitlabRepositoryFileRead(ctx, d, meta)
+}
+
+func resourceGitlabRepositoryFileRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	client := meta.(*gitlab.Client)
+	project, branch, filePath, err := resourceGitLabRepositoryFileParseId(d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	options := &gitlab.GetFileOptions{
+		Ref: gitlab.String(branch),
+	}
+
+	repositoryFile, _, err := client.RepositoryFiles.GetFile(project, filePath, options, gitlab.WithContext(ctx))
+	if err != nil {
+		if strings.Contains(err.Error(), "404 File Not Found") {
+			log.Printf("[WARN] file %s not found, removing from state", filePath)
+			d.SetId("")
+			return nil
+		}
+		return diag.FromErr(err)
+	}
+
+	d.SetId(resourceGitLabRepositoryFileBuildId(project, branch, repositoryFile.FilePath))
+	d.Set("project", project)
+	d.Set("file_path", repositoryFile.FilePath)
+	d.Set("branch", repositoryFile.Ref)
+	d.Set("encoding", repositoryFile.Encoding)
+	d.Set("content", repositoryFile.Content)
+
+	return nil
+}
+
+func resourceGitlabRepositoryFileUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	client := meta.(*gitlab.Client)
+	project, branch, filePath, err := resourceGitLabRepositoryFileParseId(d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	readOptions := &gitlab.GetFileOptions{
+		Ref: gitlab.String(branch),
+	}
+
+	existingRepositoryFile, _, err := client.RepositoryFiles.GetFile(project, filePath, readOptions, gitlab.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	options := &gitlab.UpdateFileOptions{
+		Branch:        gitlab.String(branch),
+		Encoding:      gitlab.String(encoding),
+		AuthorEmail:   gitlab.String(d.Get("author_email").(string)),
+		AuthorName:    gitlab.String(d.Get("author_name").(string)),
+		Content:       gitlab.String(d.Get("content").(string)),
+		CommitMessage: gitlab.String(d.Get("commit_message").(string)),
+		LastCommitID:  gitlab.String(existingRepositoryFile.LastCommitID),
+	}
+	if startBranch, ok := d.GetOk("start_branch"); ok {
+		options.StartBranch = gitlab.String(startBranch.(string))
+	}
+
+	_, _, err = client.RepositoryFiles.UpdateFile(project, filePath, options, gitlab.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	return resourceGitlabRepositoryFileRead(ctx, d, meta)
+}
+
+func resourceGitlabRepositoryFileDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	client := meta.(*gitlab.Client)
+	project, branch, filePath, err := resourceGitLabRepositoryFileParseId(d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	readOptions := &gitlab.GetFileOptions{
+		Ref: gitlab.String(branch),
+	}
+
+	existingRepositoryFile, _, err := client.RepositoryFiles.GetFile(project, filePath, readOptions, gitlab.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	options := &gitlab.DeleteFileOptions{
+		Branch:        gitlab.String(d.Get("branch").(string)),
+		AuthorEmail:   gitlab.String(d.Get("author_email").(string)),
+		AuthorName:    gitlab.String(d.Get("author_name").(string)),
+		CommitMessage: gitlab.String(fmt.Sprintf("[DELETE]: %s", d.Get("commit_message").(string))),
+		LastCommitID:  gitlab.String(existingRepositoryFile.LastCommitID),
+	}
+
+	resp, err := client.RepositoryFiles.DeleteFile(project, filePath, options)
+	if err != nil {
+		return diag.Errorf("%s failed to delete repository file: (%s) %v", d.Id(), resp.Status, err)
+	}
+
+	return nil
+}
+
+func validateBase64Content(v interface{}, k string) (we []string, errors []error) {
+	content := v.(string)
+	if _, err := base64.StdEncoding.DecodeString(content); err != nil {
+		errors = append(errors, fmt.Errorf("given repository file content '%s' is not base64 encoded, but must be", content))
+	}
+	return
+}
+
+func resourceGitLabRepositoryFileParseId(id string) (string, string, string, error) {
+	parts := strings.SplitN(id, ":", 3)
+	if len(parts) != 3 {
+		return "", "", "", fmt.Errorf("Unexpected ID format (%q). Expected project:branch:repository_file_path", id)
+	}
+
+	return parts[0], parts[1], parts[2], nil
+}
+
+func resourceGitLabRepositoryFileBuildId(project string, branch string, filePath string) string {
+	return fmt.Sprintf("%s:%s:%s", project, branch, filePath)
+}