feat: Add nexus_repository_alpine_proxy resource and data source

internal/provider/main.go

@@ -19,6 +19,7 @@ func Provider() *schema.Provider {
 			"nexus_blobstore_group":                       blobstore.DataSourceBlobstoreGroup(),
 			"nexus_blobstore_s3":                          blobstore.DataSourceBlobstoreS3(),
 			"nexus_blobstore_list":                        blobstore.DataSourceBlobstoreList(),
+			"nexus_repository_alpine_proxy":               repository.DataSourceRepositoryAlpineProxy(),
 			"nexus_repository_apt_hosted":                 repository.DataSourceRepositoryAptHosted(),
 			"nexus_repository_apt_proxy":                  repository.DataSourceRepositoryAptProxy(),
 			"nexus_repository_bower_group":                repository.DataSourceRepositoryBowerGroup(),
@@ -90,6 +91,7 @@ func Provider() *schema.Provider {
 			"nexus_blobstore_s3":                          blobstore.ResourceBlobstoreS3(),
 			"nexus_capability":                            other.ResourceCapability(),
 			"nexus_iqserver":                              other.ResourceIQServer(),
+			"nexus_repository_alpine_proxy":               repository.ResourceRepositoryAlpineProxy(),
 			"nexus_repository_apt_hosted":                 repository.ResourceRepositoryAptHosted(),
 			"nexus_repository_apt_proxy":                  repository.ResourceRepositoryAptProxy(),
 			"nexus_repository_bower_group":                repository.ResourceRepositoryBowerGroup(),

internal/services/repository/data_source_repository_alpine_proxy.go

@@ -0,0 +1,57 @@
+package repository
+
+import (
+	"github.com/datadrivers/terraform-provider-nexus/internal/schema/common"
+	repositorySchema "github.com/datadrivers/terraform-provider-nexus/internal/schema/repository"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func DataSourceRepositoryAlpineProxy() *schema.Resource {
+	return &schema.Resource{
+		Description: "Use this data source to get an existing alpine proxy repository.",
+
+		Read: dataSourceRepositoryAlpineProxyRead,
+
+		Schema: map[string]*schema.Schema{
+			// Common schemas
+			"id":     common.DataSourceID,
+			"name":   repositorySchema.DataSourceName,
+			"online": repositorySchema.DataSourceOnline,
+			// Proxy schemas
+			"cleanup":        repositorySchema.DataSourceCleanup,
+			"http_client":    repositorySchema.DataSourceHTTPClient,
+			"negative_cache": repositorySchema.DataSourceNegativeCache,
+			"proxy":          repositorySchema.DataSourceProxy,
+			"routing_rule":   repositorySchema.DataSourceRoutingRule,
+			"storage":        repositorySchema.DataSourceStorage,
+			// Alpine signing
+			"alpine_signing": {
+				Description: "PGP signing key for the alpine repository",
+				Computed:    true,
+				Type:        schema.TypeList,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"keypair": {
+							Description: "PEM-encoded RSA private key used to sign APKINDEX",
+							Computed:    true,
+							Sensitive:   true,
+							Type:        schema.TypeString,
+						},
+						"passphrase": {
+							Description: "Passphrase to access the signing key",
+							Computed:    true,
+							Sensitive:   true,
+							Type:        schema.TypeString,
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func dataSourceRepositoryAlpineProxyRead(resourceData *schema.ResourceData, m interface{}) error {
+	resourceData.SetId(resourceData.Get("name").(string))
+
+	return resourceAlpineProxyRepositoryRead(resourceData, m)
+}

internal/services/repository/resource_repository_alpine_proxy.go

@@ -0,0 +1,243 @@
+package repository
+
+import (
+	nexus "github.com/datadrivers/go-nexus-client/nexus3"
+	"github.com/datadrivers/go-nexus-client/nexus3/schema/repository"
+	"github.com/datadrivers/terraform-provider-nexus/internal/schema/common"
+	repositorySchema "github.com/datadrivers/terraform-provider-nexus/internal/schema/repository"
+	"github.com/datadrivers/terraform-provider-nexus/internal/tools"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func ResourceRepositoryAlpineProxy() *schema.Resource {
+	return &schema.Resource{
+		Description: "Use this resource to create an alpine proxy repository.",
+
+		Create: resourceAlpineProxyRepositoryCreate,
+		Delete: resourceAlpineProxyRepositoryDelete,
+		Exists: resourceAlpineProxyRepositoryExists,
+		Read:   resourceAlpineProxyRepositoryRead,
+		Update: resourceAlpineProxyRepositoryUpdate,
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+
+		Schema: map[string]*schema.Schema{
+			// Common schemas
+			"id":     common.ResourceID,
+			"name":   repositorySchema.ResourceName,
+			"online": repositorySchema.ResourceOnline,
+			// Proxy schemas
+			"cleanup":        repositorySchema.ResourceCleanup,
+			"http_client":    repositorySchema.ResourceHTTPClient,
+			"negative_cache": repositorySchema.ResourceNegativeCache,
+			"proxy":          repositorySchema.ResourceProxy,
+			"routing_rule":   repositorySchema.ResourceRoutingRule,
+			"storage":        repositorySchema.ResourceStorage,
+			// Alpine signing
+			"alpine_signing": {
+				Description: "PGP signing key for the alpine repository",
+				Optional:    true,
+				MaxItems:    1,
+				Type:        schema.TypeList,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"keypair": {
+							Description: "PEM-encoded RSA private key used to sign APKINDEX",
+							Required:    true,
+							Sensitive:   true,
+							Type:        schema.TypeString,
+						},
+						"passphrase": {
+							Description: "Passphrase to access the signing key",
+							Optional:    true,
+							Sensitive:   true,
+							Type:        schema.TypeString,
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func getAlpineProxyRepositoryFromResourceData(resourceData *schema.ResourceData) repository.AlpineProxyRepository {
+	httpClientConfig := resourceData.Get("http_client").([]interface{})[0].(map[string]interface{})
+	negativeCacheConfig := resourceData.Get("negative_cache").([]interface{})[0].(map[string]interface{})
+	proxyConfig := resourceData.Get("proxy").([]interface{})[0].(map[string]interface{})
+	storageConfig := resourceData.Get("storage").([]interface{})[0].(map[string]interface{})
+
+	repo := repository.AlpineProxyRepository{
+		Name:   resourceData.Get("name").(string),
+		Online: resourceData.Get("online").(bool),
+		Storage: repository.Storage{
+			BlobStoreName:               storageConfig["blob_store_name"].(string),
+			StrictContentTypeValidation: storageConfig["strict_content_type_validation"].(bool),
+		},
+		HTTPClient: repository.HTTPClient{
+			AutoBlock: httpClientConfig["auto_block"].(bool),
+			Blocked:   httpClientConfig["blocked"].(bool),
+		},
+		NegativeCache: repository.NegativeCache{
+			Enabled: negativeCacheConfig["enabled"].(bool),
+			TTL:     negativeCacheConfig["ttl"].(int),
+		},
+		Proxy: repository.Proxy{
+			ContentMaxAge:  proxyConfig["content_max_age"].(int),
+			MetadataMaxAge: proxyConfig["metadata_max_age"].(int),
+			RemoteURL:      proxyConfig["remote_url"].(string),
+		},
+	}
+
+	if signingList := resourceData.Get("alpine_signing").([]interface{}); len(signingList) > 0 && signingList[0] != nil {
+		signingConfig := signingList[0].(map[string]interface{})
+		repo.AlpineSigning = repository.AlpineSigning{
+			Keypair: signingConfig["keypair"].(string),
+		}
+		if passphrase, ok := signingConfig["passphrase"].(string); ok && passphrase != "" {
+			repo.AlpineSigning.Passphrase = tools.GetStringPointer(passphrase)
+		}
+	}
+
+	if routingRule, ok := resourceData.GetOk("routing_rule"); ok {
+		repo.RoutingRule = tools.GetStringPointer(routingRule.(string))
+		repo.RoutingRuleName = tools.GetStringPointer(routingRule.(string))
+	}
+
+	cleanupList := resourceData.Get("cleanup").([]interface{})
+	if len(cleanupList) > 0 && cleanupList[0] != nil {
+		cleanupConfig := cleanupList[0].(map[string]interface{})
+		if len(cleanupConfig) > 0 {
+			policy_names, ok := cleanupConfig["policy_names"]
+			if ok {
+				repo.Cleanup = &repository.Cleanup{
+					PolicyNames: tools.InterfaceSliceToStringSlice(policy_names.(*schema.Set).List()),
+				}
+			}
+		}
+	}
+
+	if v, ok := httpClientConfig["authentication"]; ok {
+		authList := v.([]interface{})
+		if len(authList) == 1 && authList[0] != nil {
+			authConfig := authList[0].(map[string]interface{})
+
+			repo.HTTPClient.Authentication = &repository.HTTPClientAuthentication{
+				NTLMDomain: authConfig["ntlm_domain"].(string),
+				NTLMHost:   authConfig["ntlm_host"].(string),
+				Type:       repository.HTTPClientAuthenticationType(authConfig["type"].(string)),
+				Username:   authConfig["username"].(string),
+				Password:   authConfig["password"].(string),
+			}
+		}
+	}
+
+	if v, ok := httpClientConfig["connection"]; ok {
+		repo.HTTPClient.Connection = getHTTPClientConnection(v.([]interface{}))
+	}
+
+	return repo
+}
+
+func setAlpineProxyRepositoryToResourceData(repo *repository.AlpineProxyRepository, resourceData *schema.ResourceData) error {
+	resourceData.SetId(repo.Name)
+	resourceData.Set("name", repo.Name)
+	resourceData.Set("online", repo.Online)
+
+	if repo.RoutingRuleName != nil {
+		resourceData.Set("routing_rule", repo.RoutingRuleName)
+	} else if repo.RoutingRule != nil {
+		resourceData.Set("routing_rule", repo.RoutingRule)
+	} else if repo.RoutingRuleName == nil && repo.RoutingRule == nil {
+		resourceData.Set("routing_rule", nil)
+	}
+
+	if err := resourceData.Set("storage", flattenStorage(&repo.Storage)); err != nil {
+		return err
+	}
+
+	if err := resourceData.Set("http_client", flattenHTTPClient(&repo.HTTPClient, resourceData)); err != nil {
+		return err
+	}
+
+	if err := resourceData.Set("negative_cache", flattenNegativeCache(&repo.NegativeCache)); err != nil {
+		return err
+	}
+
+	if err := resourceData.Set("proxy", flattenProxy(&repo.Proxy)); err != nil {
+		return err
+	}
+
+	if repo.AlpineSigning.Keypair != "" || repo.AlpineSigning.Passphrase != nil {
+		signing := map[string]interface{}{
+			"keypair": repo.AlpineSigning.Keypair,
+		}
+		if repo.AlpineSigning.Passphrase != nil {
+			signing["passphrase"] = *repo.AlpineSigning.Passphrase
+		}
+		if err := resourceData.Set("alpine_signing", []interface{}{signing}); err != nil {
+			return err
+		}
+	}
+
+	if repo.Cleanup != nil {
+		if err := resourceData.Set("cleanup", flattenCleanup(repo.Cleanup)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func resourceAlpineProxyRepositoryCreate(resourceData *schema.ResourceData, m interface{}) error {
+	client := m.(*nexus.NexusClient)
+
+	repo := getAlpineProxyRepositoryFromResourceData(resourceData)
+
+	if err := client.Repository.Alpine.Proxy.Create(repo); err != nil {
+		return err
+	}
+	resourceData.SetId(repo.Name)
+
+	return resourceAlpineProxyRepositoryRead(resourceData, m)
+}
+
+func resourceAlpineProxyRepositoryRead(resourceData *schema.ResourceData, m interface{}) error {
+	client := m.(*nexus.NexusClient)
+
+	repo, err := client.Repository.Alpine.Proxy.Get(resourceData.Id())
+	if err != nil {
+		return err
+	}
+
+	if repo == nil {
+		resourceData.SetId("")
+		return nil
+	}
+
+	return setAlpineProxyRepositoryToResourceData(repo, resourceData)
+}
+
+func resourceAlpineProxyRepositoryUpdate(resourceData *schema.ResourceData, m interface{}) error {
+	client := m.(*nexus.NexusClient)
+
+	repoName := resourceData.Id()
+	repo := getAlpineProxyRepositoryFromResourceData(resourceData)
+
+	if err := client.Repository.Alpine.Proxy.Update(repoName, repo); err != nil {
+		return err
+	}
+
+	return resourceAlpineProxyRepositoryRead(resourceData, m)
+}
+
+func resourceAlpineProxyRepositoryDelete(resourceData *schema.ResourceData, m interface{}) error {
+	client := m.(*nexus.NexusClient)
+	return client.Repository.Alpine.Proxy.Delete(resourceData.Id())
+}
+
+func resourceAlpineProxyRepositoryExists(resourceData *schema.ResourceData, m interface{}) (bool, error) {
+	client := m.(*nexus.NexusClient)
+
+	repo, err := client.Repository.Alpine.Proxy.Get(resourceData.Id())
+	return repo != nil, err
+}