terraform-provider-gitea/gitea/resource_gitea_repository_key.go
Tobias Trabelsi 8095c2a513
All checks were successful
continuous-integration/drone/push Build is passing
continuous-integration/drone/tag Build is passing
prepare next release
2023-01-04 19:15:00 +01:00

170 lines
3.8 KiB
Go

package gitea
import (
"fmt"
"strconv"
"strings"
"code.gitea.io/sdk/gitea"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)
const (
deployKeyRepoId string = "repository"
deployKeyName string = "title"
deployKeyKey string = "key"
deployKeyReadOnly string = "read_only"
)
func resourceRepoKeyIdParts(d *schema.ResourceData) (bool, int64, int64, error) {
parts := strings.Split(d.Id(), "/")
if len(parts) != 2 {
return false, 0, 0, nil
}
repoId, err := strconv.ParseInt(parts[0], 10, 64)
if err != nil {
return false, 0, 0, err
}
keyId, err := strconv.ParseInt(parts[1], 10, 64)
if err != nil {
return false, 0, 0, err
}
return true, repoId, keyId, err
}
func resourceRepoKeyRead(d *schema.ResourceData, meta interface{}) (err error) {
client := meta.(*gitea.Client)
hasId, repoId, keyId, err := resourceRepoKeyIdParts(d)
if err != nil {
return err
}
if !hasId {
d.SetId("")
return nil
}
repo, resp, err := client.GetRepoByID(repoId)
if err != nil {
if resp.StatusCode == 404 {
d.SetId("")
return nil
} else {
return err
}
}
key, resp, err := client.GetDeployKey(repo.Owner.UserName, repo.Name, keyId)
if err != nil {
if resp.StatusCode == 404 {
d.SetId("")
return nil
} else {
return err
}
}
err = setRepoKeyResourceData(key, repoId, d)
return
}
func resourceRepoKeyCreate(d *schema.ResourceData, meta interface{}) (err error) {
client := meta.(*gitea.Client)
repo, _, err := client.GetRepoByID(int64(d.Get(deployKeyRepoId).(int)))
if err != nil {
return err
}
dk, _, err := client.CreateDeployKey(repo.Owner.UserName, repo.Name, gitea.CreateKeyOption{
Title: d.Get(deployKeyName).(string),
ReadOnly: d.Get(deployKeyReadOnly).(bool),
Key: d.Get(deployKeyKey).(string),
})
if err != nil {
return err
}
setRepoKeyResourceData(dk, repo.ID, d)
return nil
}
func respurceRepoKeyDelete(d *schema.ResourceData, meta interface{}) (err error) {
client := meta.(*gitea.Client)
hasId, repoId, keyId, err := resourceRepoKeyIdParts(d)
if err != nil {
return err
}
if !hasId {
d.SetId("")
return nil
}
repo, resp, err := client.GetRepoByID(repoId)
if err != nil {
if resp.StatusCode == 404 {
d.SetId("")
return nil
}
return err
}
client.DeleteDeployKey(repo.Owner.UserName, repo.Name, keyId)
return nil
}
func setRepoKeyResourceData(dk *gitea.DeployKey, repoId int64, d *schema.ResourceData) (err error) {
d.SetId(fmt.Sprintf("%d/%d", repoId, dk.ID))
d.Set(deployKeyRepoId, repoId)
d.Set(deployKeyReadOnly, dk.ReadOnly)
d.Set(deployKeyKey, dk.Key)
d.Set(deployKeyName, dk.Title)
return
}
func resourceGiteaRepositoryKey() *schema.Resource {
return &schema.Resource{
Read: resourceRepoKeyRead,
Create: resourceRepoKeyCreate,
Delete: respurceRepoKeyDelete,
Importer: &schema.ResourceImporter{
StateContext: schema.ImportStatePassthroughContext,
},
Schema: map[string]*schema.Schema{
deployKeyRepoId: {
Type: schema.TypeInt,
Required: true,
ForceNew: true,
Description: "The ID of the repository where the deploy key belongs to",
},
deployKeyKey: {
Type: schema.TypeString,
Required: true,
ForceNew: true,
Description: "Armored SSH key to add",
},
deployKeyReadOnly: {
Type: schema.TypeBool,
Required: false,
Optional: true,
Default: true,
ForceNew: true,
Description: "Whether this key has read or read/write access",
},
deployKeyName: {
Type: schema.TypeString,
Required: true,
ForceNew: true,
Description: "Name of the deploy key",
},
},
Description: "`gitea_repository_key` manages a deploy key for a single gitea_repository.\n\n" +
"Every key needs a unique name and unique key, i.e. no key can be added twice to the same repo",
}
}