diff --git a/custom/conf/app.example.ini b/custom/conf/app.example.ini index 6c7dce994a4..6f4c6df4bab 100644 --- a/custom/conf/app.example.ini +++ b/custom/conf/app.example.ini @@ -2885,6 +2885,8 @@ LEVEL = Info ;LIMIT_SIZE_VAGRANT = -1 ;; Maximum size of a Terraform state upload (`-1` means no limits, format `1000`, `1 MB`, `1 GiB`) ;LIMIT_SIZE_TERRAFORM_STATE = -1 +;; Maximum size of a Terraform module archive upload (`-1` means no limits, format `1000`, `1 MB`, `1 GiB`) +;LIMIT_SIZE_TERRAFORM_MODULE = -1 ;; Enable RPM re-signing by default. (It will overwrite the old signature ,using v4 format, not compatible with CentOS 6 or older) ;DEFAULT_RPM_SIGN_ENABLED = false ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; diff --git a/models/packages/descriptor.go b/models/packages/descriptor.go index e3aef90a8b6..41233a69ef9 100644 --- a/models/packages/descriptor.go +++ b/models/packages/descriptor.go @@ -33,6 +33,7 @@ import ( "gitea.dev/modules/packages/rpm" "gitea.dev/modules/packages/rubygems" "gitea.dev/modules/packages/swift" + "gitea.dev/modules/packages/terraform_module" "gitea.dev/modules/packages/vagrant" "gitea.dev/modules/util" @@ -212,8 +213,10 @@ func GetPackageDescriptorWithCache(ctx context.Context, pv *PackageVersion, c *c metadata = &rubygems.Metadata{} case TypeSwift: metadata = &swift.Metadata{} + case TypeTerraformModule: + metadata = &terraform_module.Metadata{} case TypeTerraformState: - // terraform packages have no metadata + // terraform state packages have no metadata case TypeVagrant: metadata = &vagrant.Metadata{} default: diff --git a/models/packages/package.go b/models/packages/package.go index c4cfcdd39c9..6340ff2452f 100644 --- a/models/packages/package.go +++ b/models/packages/package.go @@ -30,29 +30,30 @@ type Type string // List of supported packages const ( - TypeAlpine Type = "alpine" - TypeArch Type = "arch" - TypeCargo Type = "cargo" - TypeChef Type = "chef" - TypeComposer Type = "composer" - TypeConan Type = "conan" - TypeConda Type = "conda" - TypeContainer Type = "container" - TypeCran Type = "cran" - TypeDebian Type = "debian" - TypeGeneric Type = "generic" - TypeGo Type = "go" - TypeHelm Type = "helm" - TypeMaven Type = "maven" - TypeNpm Type = "npm" - TypeNuGet Type = "nuget" - TypePub Type = "pub" - TypePyPI Type = "pypi" - TypeRpm Type = "rpm" - TypeRubyGems Type = "rubygems" - TypeSwift Type = "swift" - TypeTerraformState Type = "terraform" - TypeVagrant Type = "vagrant" + TypeAlpine Type = "alpine" + TypeArch Type = "arch" + TypeCargo Type = "cargo" + TypeChef Type = "chef" + TypeComposer Type = "composer" + TypeConan Type = "conan" + TypeConda Type = "conda" + TypeContainer Type = "container" + TypeCran Type = "cran" + TypeDebian Type = "debian" + TypeGeneric Type = "generic" + TypeGo Type = "go" + TypeHelm Type = "helm" + TypeMaven Type = "maven" + TypeNpm Type = "npm" + TypeNuGet Type = "nuget" + TypePub Type = "pub" + TypePyPI Type = "pypi" + TypeRpm Type = "rpm" + TypeRubyGems Type = "rubygems" + TypeSwift Type = "swift" + TypeTerraformModule Type = "terraform-module" + TypeTerraformState Type = "terraform" + TypeVagrant Type = "vagrant" ) var TypeList = []Type{ @@ -77,6 +78,7 @@ var TypeList = []Type{ TypeRpm, TypeRubyGems, TypeSwift, + TypeTerraformModule, TypeTerraformState, TypeVagrant, } @@ -126,6 +128,8 @@ func (pt Type) Name() string { return "RubyGems" case TypeSwift: return "Swift" + case TypeTerraformModule: + return "Terraform Module" case TypeTerraformState: return "Terraform State" case TypeVagrant: @@ -179,6 +183,8 @@ func (pt Type) SVGName() string { return "gitea-rubygems" case TypeSwift: return "gitea-swift" + case TypeTerraformModule: + return "gitea-terraform" case TypeTerraformState: return "gitea-terraform" case TypeVagrant: diff --git a/modules/packages/terraform_module/hcl.go b/modules/packages/terraform_module/hcl.go new file mode 100644 index 00000000000..96fc94f9d92 --- /dev/null +++ b/modules/packages/terraform_module/hcl.go @@ -0,0 +1,235 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package terraform_module + +import ( + "bytes" + "strconv" + "strings" + + "gitea.dev/modules/container" +) + +var hclIndexedBlocks = container.SetOf("variable", "output", "terraform", "required_providers") // bodies of other blocks are skipped + +type hclBlock struct { + typ string + labels []string + attrs map[string]string // attribute name -> expression source + blocks []*hclBlock +} + +// hclScanner reads HCL block structure without evaluating expressions, nesting is capped to bound recursion +type hclScanner struct { + src []byte + pos int + nesting int +} + +const hclMaxNesting = 32 + +func (s *hclScanner) peek(offset int) byte { + if s.pos+offset < len(s.src) { + return s.src[s.pos+offset] + } + return 0 +} + +func (s *hclScanner) body(depth int) *hclBlock { + body := &hclBlock{attrs: map[string]string{}} + for { + s.skipSpace(true) + if s.pos >= len(s.src) { + return body + } + if s.src[s.pos] == '}' { + s.pos++ + return body + } + start := s.pos + name := s.ident() + s.skipSpace(false) + if name != "" && s.peek(0) == '=' { + s.pos++ + s.skipSpace(false) + exprStart := s.pos + body.attrs[name] = string(s.src[exprStart:s.skipExpr()]) + continue + } + var labels []string + for name != "" && s.peek(0) != '{' { + labelStart := s.pos + if s.peek(0) == '"' { + s.skipString() + labels = append(labels, hclString(string(s.src[labelStart:s.pos]))) + } else if label := s.ident(); label != "" { + labels = append(labels, label) + } else { + break + } + s.skipSpace(false) + } + if name == "" || s.peek(0) != '{' || depth >= 2 || !hclIndexedBlocks.Contains(name) { // only terraform.required_providers needs two levels + s.skipExpr() + if s.pos == start { + s.pos++ + } + continue + } + s.pos++ + block := s.body(depth + 1) + block.typ, block.labels = name, labels + body.blocks = append(body.blocks, block) + } +} + +// skipExpr advances to the newline, comma or unbalanced closing bracket that ends an expression and returns where its source ends +func (s *hclScanner) skipExpr() (end int) { + end = s.pos + for depth := 0; s.pos < len(s.src); { + switch c := s.src[s.pos]; { + case c == '"': + s.skipString() + case c == '<' && s.skipHeredoc(): + case s.skipComment(): + continue + case (c == '\n' || c == ',') && depth == 0: + return end + case c == '}' || c == ']' || c == ')': + if depth == 0 { + return end + } + depth-- + s.pos++ + case c == '{' || c == '[' || c == '(': + depth++ + s.pos++ + case c == ' ' || c == '\t' || c == '\r' || c == '\n': + s.pos++ + continue + default: + s.pos++ + } + end = s.pos + } + return end +} + +func (s *hclScanner) skipString() { + for s.pos++; s.pos < len(s.src); s.pos++ { + switch c := s.src[s.pos]; { + case c == '\\' && s.pos+1 < len(s.src) || (c == '$' || c == '%') && s.peek(1) == c: + s.pos++ + case c == '"': + s.pos++ + return + case c == '\n': + return + case (c == '$' || c == '%') && s.peek(1) == '{': + if s.nesting >= hclMaxNesting { + return + } + s.nesting++ + s.pos += 2 + for s.skipExpr(); s.peek(0) == ',' || s.peek(0) == '\n'; s.skipExpr() { // commas and newlines don't end a template sequence + s.pos++ + } + s.nesting-- + if s.peek(0) != '}' { + return + } + } + } +} + +func (s *hclScanner) skipHeredoc() bool { + start := s.pos + if s.peek(1) != '<' { + return false + } + s.pos += 2 + if s.peek(0) == '-' { + s.pos++ + } + delim := s.ident() + if s.peek(0) == '\r' { + s.pos++ + } + if delim == "" || s.peek(0) != '\n' { + s.pos = start + return false + } + for s.pos < len(s.src) { + lineStart := s.pos + 1 + s.pos = len(s.src) + if lineEnd := bytes.IndexByte(s.src[lineStart:], '\n'); lineEnd >= 0 { + s.pos = lineStart + lineEnd + } + if string(bytes.TrimSpace(s.src[lineStart:s.pos])) == delim { + break + } + } + return true +} + +func (s *hclScanner) skipComment() bool { + switch { + case s.peek(0) == '#' || s.peek(0) == '/' && s.peek(1) == '/': + for s.pos < len(s.src) && s.src[s.pos] != '\n' { + s.pos++ + } + case s.peek(0) == '/' && s.peek(1) == '*': + if end := bytes.Index(s.src[s.pos+2:], []byte("*/")); end >= 0 { + s.pos += end + 4 + } else { + s.pos = len(s.src) + } + default: + return false + } + return true +} + +func (s *hclScanner) skipSpace(newlines bool) { + for s.pos < len(s.src) { + switch c := s.src[s.pos]; { + case c == ' ' || c == '\t' || c == '\r' || newlines && (c == '\n' || c == ','): + s.pos++ + case !s.skipComment(): + return + } + } +} + +func (s *hclScanner) ident() string { + start := s.pos + for ; s.pos < len(s.src); s.pos++ { + c := s.src[s.pos] + if !(c == '_' || 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || s.pos > start && (c == '-' || '0' <= c && c <= '9')) { + break + } + } + return string(s.src[start:s.pos]) +} + +var ( + hclWithoutEscapedTemplates = strings.NewReplacer("$${", "", "%%{", "") + hclUnescapeTemplates = strings.NewReplacer("$${", "${", "%%{", "%{") +) + +// hclString decodes a string literal or heredoc, returning "" for expressions and templates that need evaluation +func hclString(expr string) string { + if strings.HasPrefix(expr, "<<") { + _, content, _ := strings.Cut(expr, "\n") + return content[:strings.LastIndexByte(content, '\n')+1] + } + if unescaped := hclWithoutEscapedTemplates.Replace(expr); strings.Contains(unescaped, "${") || strings.Contains(unescaped, "%{") { + return "" + } + decoded, err := strconv.Unquote(expr) + if err != nil { + return "" + } + return hclUnescapeTemplates.Replace(decoded) +} diff --git a/modules/packages/terraform_module/metadata.go b/modules/packages/terraform_module/metadata.go new file mode 100644 index 00000000000..2ed3061d446 --- /dev/null +++ b/modules/packages/terraform_module/metadata.go @@ -0,0 +1,41 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package terraform_module + +type Metadata struct { + Readme string `json:"readme,omitempty"` + Root *Module `json:"root,omitempty"` + Submodules map[string]*Submodule `json:"submodules,omitempty"` +} + +// Submodule is a module packaged in the archive's modules/ directory +type Submodule struct { + Readme string `json:"readme,omitempty"` + Module *Module `json:"module,omitempty"` +} + +type Module struct { + Inputs []*Input `json:"inputs,omitempty"` + Outputs []*Output `json:"outputs,omitempty"` + Providers []*Provider `json:"providers,omitempty"` +} + +type Input struct { + Name string `json:"name"` + Type string `json:"type,omitempty"` + Description string `json:"description,omitempty"` + Default string `json:"default,omitempty"` + Required bool `json:"required"` +} + +type Output struct { + Name string `json:"name"` + Description string `json:"description,omitempty"` +} + +type Provider struct { + Name string `json:"name"` + Source string `json:"source,omitempty"` + Version string `json:"version,omitempty"` +} diff --git a/modules/packages/terraform_module/parser.go b/modules/packages/terraform_module/parser.go new file mode 100644 index 00000000000..612b52e5419 --- /dev/null +++ b/modules/packages/terraform_module/parser.go @@ -0,0 +1,172 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package terraform_module + +import ( + "archive/tar" + "bytes" + "compress/gzip" + "errors" + "fmt" + "io" + "maps" + "path" + "regexp" + "slices" + "strings" + + packages_module "gitea.dev/modules/packages" + + "github.com/hashicorp/go-version" +) + +var ( + ErrInvalidNamespace = errors.New("module namespace (owner name) is invalid") + ErrInvalidName = errors.New("module name is invalid") + ErrInvalidProvider = errors.New("module provider is invalid") + ErrInvalidVersion = errors.New("module version is invalid") + ErrNoRootModule = errors.New("no terraform module at the archive root: package the module directory's contents, not the directory itself (e.g. `tar -czf module.tar.gz -C path/to/module .`)") +) + +const maxReadmeSize = 1024 * 1024 // larger READMEs are not stored, they would be rendered on every page view + +// same rules as Terraform's module source address parser (github.com/hashicorp/terraform-registry-address) +var ( + nameRe = regexp.MustCompile(`\A[0-9A-Za-z](?:[0-9A-Za-z_-]{0,62}[0-9A-Za-z])?\z`) + systemRe = regexp.MustCompile(`\A[0-9a-z]{1,64}\z`) +) + +func ValidateAddress(namespace, name, provider string) error { + if !nameRe.MatchString(namespace) { + return ErrInvalidNamespace + } + if !nameRe.MatchString(name) { + return ErrInvalidName + } + if !systemRe.MatchString(provider) { + return ErrInvalidProvider + } + return nil +} + +// NormalizeVersion returns the canonical semver form, so `v1.0.0` and `1.0.0` are the same version +func NormalizeVersion(raw string) (string, error) { + parsed, err := version.NewSemver(raw) + if err != nil { + return "", ErrInvalidVersion + } + return parsed.String(), nil +} + +func ParseModuleArchive(r io.Reader) (*Metadata, error) { + gz, err := gzip.NewReader(r) + if err != nil { + return nil, fmt.Errorf("invalid gzip stream: %w", err) + } + defer gz.Close() + return parseTar(tar.NewReader(packages_module.NewLimitedReader(gz, packages_module.MaxMetadataSize))) +} + +func parseTar(tr *tar.Reader) (*Metadata, error) { + retained := packages_module.NewLimitedReader(tr, packages_module.MaxMetadataSize) // sparse entries read more than they decompress + metadata := &Metadata{} + root := map[string][]byte{} // .tf.json content yields no HCL blocks + submodules := map[string]map[string][]byte{} + subReadmes := map[string]string{} + for { + hdr, err := tr.Next() + if err == io.EOF { + break + } + if err != nil { + return nil, fmt.Errorf("invalid tar stream: %w", err) + } + dir, base := path.Split(path.Clean(hdr.Name)) + if hdr.Typeflag != tar.TypeReg || strings.HasPrefix(base, ".") { // Terraform ignores dotfiles + continue + } + dir = strings.TrimSuffix(dir, "/") + isSource := strings.HasSuffix(base, ".tf") || strings.HasSuffix(base, ".tf.json") + isReadme := strings.EqualFold(base, "readme.md") || strings.EqualFold(base, "readme") + name, isSubmodule := strings.CutPrefix(dir, "modules/") + isSubmodule = isSubmodule && !strings.Contains(name, "/") // standard module structure, one level deep + if !isSource && !isReadme || dir != "" && !isSubmodule || isReadme && hdr.Size > maxReadmeSize { + continue + } + data, err := io.ReadAll(retained) + if err != nil { + return nil, err + } + switch { + case isSubmodule && isSource: + if submodules[name] == nil { + submodules[name] = map[string][]byte{} + } + submodules[name][base] = data + case isSubmodule: + subReadmes[name] = string(data) + case isReadme: + metadata.Readme = string(data) + default: + root[base] = data + } + } + if len(root) == 0 && len(submodules) == 0 { + return nil, ErrNoRootModule + } + if len(root) > 0 { + metadata.Root = parseModule(root) + } + if len(submodules) > 0 { + metadata.Submodules = make(map[string]*Submodule, len(submodules)) + for name, files := range submodules { + metadata.Submodules[name] = &Submodule{Readme: subReadmes[name], Module: parseModule(files)} + } + } + return metadata, nil +} + +func parseModule(files map[string][]byte) *Module { + module := &Module{} + providers := map[string]*Provider{} + for _, filename := range slices.Sorted(maps.Keys(files)) { + for _, block := range (&hclScanner{src: bytes.TrimPrefix(files[filename], []byte("\xef\xbb\xbf"))}).body(0).blocks { + attrs := block.attrs + switch { + case block.typ == "variable" && len(block.labels) == 1: + _, hasDefault := attrs["default"] + module.Inputs = append(module.Inputs, &Input{ + Name: block.labels[0], + Type: attrs["type"], + Description: hclString(attrs["description"]), + Default: attrs["default"], + Required: !hasDefault, + }) + case block.typ == "output" && len(block.labels) == 1: + module.Outputs = append(module.Outputs, &Output{Name: block.labels[0], Description: hclString(attrs["description"])}) + case block.typ == "terraform": + for _, inner := range block.blocks { + if inner.typ != "required_providers" { + continue + } + for name, expr := range inner.attrs { + if providers[name] != nil { + continue + } + provider := &Provider{Name: name} + if strings.HasPrefix(expr, "{") { + fields := (&hclScanner{src: []byte(expr[1:])}).body(2).attrs + provider.Source, provider.Version = hclString(fields["source"]), hclString(fields["version"]) + } else { + provider.Version = hclString(expr) // legacy `name = ""` form + } + providers[name] = provider + } + } + } + } + } + module.Providers = slices.SortedFunc(maps.Values(providers), func(a, b *Provider) int { return strings.Compare(a.Name, b.Name) }) + return module +} diff --git a/modules/packages/terraform_module/parser_test.go b/modules/packages/terraform_module/parser_test.go new file mode 100644 index 00000000000..e71a76461c2 --- /dev/null +++ b/modules/packages/terraform_module/parser_test.go @@ -0,0 +1,114 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package terraform_module + +import ( + "bytes" + "compress/gzip" + "slices" + "strings" + "testing" + + packages_module "gitea.dev/modules/packages" + "gitea.dev/modules/test" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func buildArchive(files map[string]string) *bytes.Buffer { + return test.WriteTarCompression(gzip.NewWriter, files) +} + +func TestParseModuleArchive(t *testing.T) { + metadata, err := ParseModuleArchive(buildArchive(map[string]string{ + "./main.tf": "\xef\xbb\xbf" + `terraform { + required_providers { + aws = { + source = "hashicorp/aws" + version = "~> 5.0" + configuration_aliases = [aws.alternate] + } + random = "~> 3.0" + } +} +# an unbalanced { in a comment +locals { + joined = "%{ for k, v in { a = "b" } }${k}%{ endfor }" +} +variable "region" { + type = string + description = "AWS region, not $${var.template} }" + default = "eu-west-1" // trailing comment +} +variable "tags" { + type = map(string) + description = < 5.0"}, + {Name: "random", Version: "~> 3.0"}, + }, + }, + Submodules: map[string]*Submodule{ + "json": {Module: &Module{}}, + "net": {Readme: "# Net submodule\n", Module: &Module{Inputs: []*Input{{Name: "cidr", Required: true}}}}, + }, + }, metadata) + + metadata, err = ParseModuleArchive(buildArchive(map[string]string{"modules/net/main.tf": ""})) + require.NoError(t, err) + assert.Equal(t, &Metadata{Submodules: map[string]*Submodule{"net": {Module: &Module{}}}}, metadata) + + metadata, err = ParseModuleArchive(buildArchive(map[string]string{ + "main.tf": "", + "README.md": strings.Repeat("#", maxReadmeSize+1), + "modules/net/main.tf": "", + "modules/net/README.md": strings.Repeat("#", maxReadmeSize+1), + })) + require.NoError(t, err) + assert.Equal(t, &Metadata{Root: &Module{}, Submodules: map[string]*Submodule{"net": {Module: &Module{}}}}, metadata) + + _, err = ParseModuleArchive(buildArchive(map[string]string{"mod-1.0.0/main.tf": ""})) + assert.ErrorIs(t, err, ErrNoRootModule) + _, err = ParseModuleArchive(buildArchive(map[string]string{"main.tf": strings.Repeat("#", packages_module.MaxMetadataSize)})) + assert.ErrorIs(t, err, packages_module.ErrContentTooLarge) + + for _, src := range []string{`variable "x" { description = "`, `variable "x" { description = "\`, `x = <{{ctx.Locale.Tr "packages.installation"}} +
+
+
+ +
module "{{$moduleLabel}}" {
+	source  = "{{$moduleSource}}"
+	version = "{{.PackageDescriptor.Version.Version}}"
+}
+
+
+ +
terraform {
+	source = "tfr://{{$moduleSource}}?version={{.PackageDescriptor.Version.Version}}"
+}
+
+
+ +
credentials "{{.PackageRegistryHost}}" {
+	token = "<token>"
+}
+
+
+ +
+
+
+ + {{if $readme}} +

{{ctx.Locale.Tr "packages.about"}}

+
{{ctx.RenderUtils.RenderPackageMarkdown $readme .PackageDescriptor.Repository $treePath}}
+ {{end}} + + {{if and $module $module.Inputs}} +

{{ctx.Locale.Tr "packages.terraform_module.inputs"}}

+
+ + + + + + + + + {{range $input := $module.Inputs}} + + + + + + + {{end}} + +
{{ctx.Locale.Tr "packages.terraform_module.name"}}{{ctx.Locale.Tr "packages.terraform_module.type"}}{{ctx.Locale.Tr "packages.terraform_module.default"}}{{ctx.Locale.Tr "packages.terraform_module.description"}}
{{$input.Name}}{{if $input.Required}} {{ctx.Locale.Tr "packages.terraform_module.required"}}{{end}}{{$input.Type}}{{$input.Default}}{{$input.Description}}
+
+ {{end}} + + {{if and $module $module.Outputs}} +

{{ctx.Locale.Tr "packages.terraform_module.outputs"}}

+
+ + + + + + + {{range $output := $module.Outputs}} + + + + + {{end}} + +
{{ctx.Locale.Tr "packages.terraform_module.name"}}{{ctx.Locale.Tr "packages.terraform_module.description"}}
{{$output.Name}}{{$output.Description}}
+
+ {{end}} + + {{if and $module $module.Providers}} +

{{ctx.Locale.Tr "packages.terraform_module.providers"}}

+
+
    {{range $provider := $module.Providers}}
  • {{$provider.Name}}{{if $provider.Source}} ({{$provider.Source}}){{end}}{{if $provider.Version}} {{$provider.Version}}{{end}}
  • {{end}}
+
+ {{end}} + + {{if and (not $submodule) $metadata.Submodules}} +

{{ctx.Locale.Tr "packages.terraform_module.submodules"}}

+
+ +
+ {{end}} +{{end}} diff --git a/templates/package/shared/view.tmpl b/templates/package/shared/view.tmpl index 21f9a3e7b99..071a6f697df 100644 --- a/templates/package/shared/view.tmpl +++ b/templates/package/shared/view.tmpl @@ -39,6 +39,7 @@ {{template "package/content/rubygems" .}} {{template "package/content/swift" .}} {{template "package/content/terraform" .}} + {{template "package/content/terraform_module" .}} {{template "package/content/vagrant" .}}
diff --git a/templates/swagger/v1-openapi3.generated.json b/templates/swagger/v1-openapi3.generated.json index 66f3aa9d316..d35bd86b129 100644 --- a/templates/swagger/v1-openapi3.generated.json +++ b/templates/swagger/v1-openapi3.generated.json @@ -12011,6 +12011,7 @@ "schema": { "enum": [ "alpine", + "arch", "cargo", "chef", "composer", @@ -12031,6 +12032,7 @@ "rubygems", "swift", "terraform", + "terraform-module", "vagrant" ], "type": "string" @@ -16295,6 +16297,7 @@ "schema": { "enum": [ "alpine", + "arch", "cargo", "chef", "composer", @@ -16315,6 +16318,7 @@ "rubygems", "swift", "terraform", + "terraform-module", "vagrant" ], "type": "string" diff --git a/templates/swagger/v1-swagger.generated.json b/templates/swagger/v1-swagger.generated.json index e6b0cef2010..e210e01e04c 100644 --- a/templates/swagger/v1-swagger.generated.json +++ b/templates/swagger/v1-swagger.generated.json @@ -630,6 +630,7 @@ { "enum": [ "alpine", + "arch", "cargo", "chef", "composer", @@ -650,6 +651,7 @@ "rubygems", "swift", "terraform", + "terraform-module", "vagrant" ], "type": "string", @@ -4728,6 +4730,7 @@ { "enum": [ "alpine", + "arch", "cargo", "chef", "composer", @@ -4748,6 +4751,7 @@ "rubygems", "swift", "terraform", + "terraform-module", "vagrant" ], "type": "string", diff --git a/tests/integration/api_packages_terraform_module_test.go b/tests/integration/api_packages_terraform_module_test.go new file mode 100644 index 00000000000..6702815cd81 --- /dev/null +++ b/tests/integration/api_packages_terraform_module_test.go @@ -0,0 +1,109 @@ +// Copyright 2026 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package integration + +import ( + "bytes" + "compress/gzip" + "net/http" + "net/url" + "strings" + "testing" + + "gitea.dev/models/unittest" + user_model "gitea.dev/models/user" + "gitea.dev/modules/setting" + "gitea.dev/modules/test" + "gitea.dev/tests" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestPackageTerraformModule(t *testing.T) { + defer tests.PrepareTestEnv(t)() + + admin := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1}) + privateOrg := unittest.AssertExistsAndLoadBean(t, &user_model.User{Name: "privated_org"}) + root := "/api/packages/-/terraform/modules/" + privateOrg.Name + base := root + "/vpc/aws" + archive := test.WriteTarCompression(gzip.NewWriter, map[string]string{ + "main.tf": `variable "region" {}`, + "README.md": "# VPC module", + "modules/net/main.tf": "variable \"cidr\" {}\n", + "modules/net/README.md": "# Net submodule\n", + }).Bytes() + + upload := func(t *testing.T, uploadURL string, body []byte, status int) { + MakeRequest(t, NewRequestWithBody(t, "PUT", uploadURL, bytes.NewReader(body)).AddBasicAuth(admin.Name), status) + } + + t.Run("ServiceDiscovery", func(t *testing.T) { + resp := MakeRequest(t, NewRequest(t, "GET", "/.well-known/terraform.json"), http.StatusOK) + assert.JSONEq(t, `{"modules.v1":"/api/packages/-/terraform/modules/"}`, resp.Body.String()) + + defer test.MockVariableValue(&setting.Packages.Enabled, false)() + MakeRequest(t, NewRequest(t, "GET", "/.well-known/terraform.json"), http.StatusForbidden) + }) + + t.Run("Upload", func(t *testing.T) { + upload(t, base+"/v1.0.0", archive, http.StatusCreated) + upload(t, base+"/1.0.0", archive, http.StatusConflict) + upload(t, base+"/not-semver", archive, http.StatusBadRequest) + upload(t, root+"/vpc/my-cloud/1.0.0", archive, http.StatusBadRequest) + upload(t, base+"/2.0.0", test.WriteTarCompression(gzip.NewWriter, map[string]string{"vpc-2.0.0/main.tf": `variable "region" {}`}).Bytes(), http.StatusBadRequest) + MakeRequest(t, NewRequestWithBody(t, "PUT", base+"/2.0.0", bytes.NewReader(archive)), http.StatusUnauthorized) + }) + + t.Run("Web", func(t *testing.T) { + session := loginUser(t, admin.Name) + session.MakeRequest(t, NewRequestWithValues(t, "POST", "/user/settings/packages/rules/add", map[string]string{ + "type": "terraform-module", "action": "save", "keep_count": "0", "remove_days": "0", + }), http.StatusSeeOther) + page := "/" + privateOrg.Name + "/-/packages/terraform-module/vpc%2Faws/1.0.0" + appURL, _ := url.Parse(setting.AppURL) + content := NewHTMLParser(t, session.MakeRequest(t, NewRequest(t, "GET", page), http.StatusOK).Body).Find(".packages-content-left").Text() + assert.Contains(t, content, `source = "`+appURL.Host+"/"+privateOrg.Name+`/vpc/aws"`) + assert.Contains(t, content, "VPC module") + assert.Contains(t, content, "region") + assert.Contains(t, content, "/vpc/aws//modules/net") + + content = NewHTMLParser(t, session.MakeRequest(t, NewRequest(t, "GET", page+"/modules/net"), http.StatusOK).Body).Find(".packages-content-left").Text() + assert.Contains(t, content, `source = "`+appURL.Host+"/"+privateOrg.Name+`/vpc/aws//modules/net"`) + assert.Contains(t, content, "cidr") + assert.Contains(t, content, "Net submodule") + session.MakeRequest(t, NewRequest(t, "GET", page+"/modules/unknown"), http.StatusNotFound) + + MakeRequest(t, NewRequestWithBody(t, "PUT", "/api/packages/"+privateOrg.Name+"/generic/vpc/1.0.0/file.bin", strings.NewReader("x")).AddBasicAuth(admin.Name), http.StatusCreated) + session.MakeRequest(t, NewRequest(t, "GET", "/"+privateOrg.Name+"/-/packages/generic/vpc/1.0.0/modules/net"), http.StatusNotFound) + }) + + t.Run("ListVersions", func(t *testing.T) { + resp := MakeRequest(t, NewRequest(t, "GET", base+"/versions").AddBasicAuth(admin.Name), http.StatusOK) + assert.JSONEq(t, `{"modules":[{"versions":[{"version":"1.0.0"}]}]}`, resp.Body.String()) + MakeRequest(t, NewRequest(t, "GET", base+"/versions"), http.StatusUnauthorized) + MakeRequest(t, NewRequest(t, "GET", root+"/unknown/aws/versions").AddBasicAuth(admin.Name), http.StatusNotFound) + }) + + t.Run("Download", func(t *testing.T) { + downloadURL := base + "/1.0.0/download" + resp := MakeRequest(t, NewRequest(t, "GET", downloadURL).AddBasicAuth(admin.Name), http.StatusNoContent) + location, err := url.Parse(resp.Header().Get("X-Terraform-Get")) + require.NoError(t, err) + assert.Equal(t, "tar.gz", location.Query().Get("archive")) + archiveURL := (&url.URL{Path: downloadURL}).ResolveReference(location).String() + + resp = MakeRequest(t, NewRequest(t, "GET", archiveURL), http.StatusOK) + assert.Equal(t, archive, resp.Body.Bytes()) + MakeRequest(t, NewRequest(t, "GET", strings.Replace(archiveURL, "code=", "code=x", 1)), http.StatusUnauthorized) + MakeRequest(t, NewRequest(t, "GET", base+"/1.0.0/archive").AddBasicAuth(admin.Name), http.StatusOK) + MakeRequest(t, NewRequest(t, "GET", base+"/9.9.9/download").AddBasicAuth(admin.Name), http.StatusNotFound) + }) + + t.Run("Delete", func(t *testing.T) { + MakeRequest(t, NewRequest(t, "DELETE", base+"/1.0.0"), http.StatusUnauthorized) + MakeRequest(t, NewRequest(t, "DELETE", base+"/v1.0.0").AddBasicAuth(admin.Name), http.StatusNoContent) + MakeRequest(t, NewRequest(t, "GET", base+"/versions").AddBasicAuth(admin.Name), http.StatusNotFound) + }) +}