r/glue_registry - new resource

aws/internal/service/glue/finder/finder.go

@@ -0,0 +1,20 @@
+package finder
+
+import (
+	"github.com/aws/aws-sdk-go/service/glue"
+	tfglue "github.com/terraform-providers/terraform-provider-aws/aws/internal/service/glue"
+)
+
+// RegistryByID returns the Registry corresponding to the specified ID.
+func RegistryByID(conn *glue.Glue, id string) (*glue.GetRegistryOutput, error) {
+	input := &glue.GetRegistryInput{
+		RegistryId: tfglue.CreateAwsGlueRegistryID(id),
+	}
+
+	output, err := conn.GetRegistry(input)
+	if err != nil {
+		return nil, err
+	}
+
+	return output, nil
+}

aws/internal/service/glue/id.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/glue"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 )
 
@@ -30,3 +32,9 @@ func stringifyAwsGluePartition(partValues *schema.Set) string {
 
 	return vals
 }
+
+func CreateAwsGlueRegistryID(id string) *glue.RegistryId {
+	return &glue.RegistryId{
+		RegistryArn: aws.String(id),
+	}
+}

aws/internal/service/glue/waiter/status.go

@@ -7,10 +7,12 @@ import (
 	"github.com/aws/aws-sdk-go/service/glue"
 	"github.com/hashicorp/aws-sdk-go-base/tfawserr"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/terraform-providers/terraform-provider-aws/aws/internal/service/glue/finder"
 )
 
 const (
 	MLTransformStatusUnknown = "Unknown"
+	RegistryStatusUnknown    = "Unknown"
 	TriggerStatusUnknown     = "Unknown"
 )
 
@@ -35,6 +37,22 @@ func MLTransformStatus(conn *glue.Glue, transformId string) resource.StateRefres
 	}
 }
 
+// RegistryStatus fetches the Registry and its Status
+func RegistryStatus(conn *glue.Glue, id string) resource.StateRefreshFunc {
+	return func() (interface{}, string, error) {
+		output, err := finder.RegistryByID(conn, id)
+		if err != nil {
+			return nil, RegistryStatusUnknown, err
+		}
+
+		if output == nil {
+			return output, RegistryStatusUnknown, nil
+		}
+
+		return output, aws.StringValue(output.Status), nil
+	}
+}
+
 // TriggerStatus fetches the Trigger and its Status
 func TriggerStatus(conn *glue.Glue, triggerName string) resource.StateRefreshFunc {
 	return func() (interface{}, string, error) {

aws/internal/service/glue/waiter/waiter.go

@@ -10,6 +10,7 @@ import (
 const (
 	// Maximum amount of time to wait for an Operation to return Deleted
 	MLTransformDeleteTimeout = 2 * time.Minute
+	RegistryDeleteTimeout    = 2 * time.Minute
 	TriggerCreateTimeout     = 2 * time.Minute
 	TriggerDeleteTimeout     = 2 * time.Minute
 )
@@ -32,6 +33,24 @@ func MLTransformDeleted(conn *glue.Glue, transformId string) (*glue.GetMLTransfo
 	return nil, err
 }
 
+// RegistryDeleted waits for a Registry to return Deleted
+func RegistryDeleted(conn *glue.Glue, registryID string) (*glue.GetRegistryOutput, error) {
+	stateConf := &resource.StateChangeConf{
+		Pending: []string{glue.RegistryStatusDeleting},
+		Target:  []string{},
+		Refresh: RegistryStatus(conn, registryID),
+		Timeout: RegistryDeleteTimeout,
+	}
+
+	outputRaw, err := stateConf.WaitForState()
+
+	if output, ok := outputRaw.(*glue.GetRegistryOutput); ok {
+		return output, err
+	}
+
+	return nil, err
+}
+
 // TriggerCreated waits for a Trigger to return Created
 func TriggerCreated(conn *glue.Glue, triggerName string) (*glue.GetTriggerOutput, error) {
 	stateConf := &resource.StateChangeConf{

aws/provider.go

@@ -671,6 +671,7 @@ func Provider() *schema.Provider {
 			"aws_glue_job":                                            resourceAwsGlueJob(),
 			"aws_glue_ml_transform":                                   resourceAwsGlueMLTransform(),
 			"aws_glue_partition":                                      resourceAwsGluePartition(),
+			"aws_glue_registry":                                       resourceAwsGlueRegistry(),
 			"aws_glue_security_configuration":                         resourceAwsGlueSecurityConfiguration(),
 			"aws_glue_trigger":                                        resourceAwsGlueTrigger(),
 			"aws_glue_user_defined_function":                          resourceAwsGlueUserDefinedFunction(),

aws/resource_aws_glue_registry.go

@@ -0,0 +1,166 @@
+package aws
+
+import (
+	"fmt"
+	"log"
+	"regexp"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/glue"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
+	"github.com/terraform-providers/terraform-provider-aws/aws/internal/keyvaluetags"
+	tfglue "github.com/terraform-providers/terraform-provider-aws/aws/internal/service/glue"
+	"github.com/terraform-providers/terraform-provider-aws/aws/internal/service/glue/finder"
+	"github.com/terraform-providers/terraform-provider-aws/aws/internal/service/glue/waiter"
+)
+
+func resourceAwsGlueRegistry() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAwsGlueRegistryCreate,
+		Read:   resourceAwsGlueRegistryRead,
+		Update: resourceAwsGlueRegistryUpdate,
+		Delete: resourceAwsGlueRegistryDelete,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"arn": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"description": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ValidateFunc: validation.StringLenBetween(0, 2048),
+			},
+			"registry_name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+				ValidateFunc: validation.All(
+					validation.StringLenBetween(1, 255),
+					validation.StringMatch(regexp.MustCompile(`[a-zA-Z0-9-_$#]+$`), ""),
+				),
+			},
+			"tags": tagsSchema(),
+		},
+	}
+}
+
+func resourceAwsGlueRegistryCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).glueconn
+
+	input := &glue.CreateRegistryInput{
+		RegistryName: aws.String(d.Get("registry_name").(string)),
+		Tags:         keyvaluetags.New(d.Get("tags").(map[string]interface{})).IgnoreAws().GlueTags(),
+	}
+
+	if v, ok := d.GetOk("description"); ok {
+		input.Description = aws.String(v.(string))
+	}
+
+	log.Printf("[DEBUG] Creating Glue Registry: %s", input)
+	output, err := conn.CreateRegistry(input)
+	if err != nil {
+		return fmt.Errorf("error creating Glue Registry: %w", err)
+	}
+	d.SetId(aws.StringValue(output.RegistryArn))
+
+	return resourceAwsGlueRegistryRead(d, meta)
+}
+
+func resourceAwsGlueRegistryRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).glueconn
+	ignoreTagsConfig := meta.(*AWSClient).IgnoreTagsConfig
+
+	output, err := finder.RegistryByID(conn, d.Id())
+	if err != nil {
+		if isAWSErr(err, glue.ErrCodeEntityNotFoundException, "") {
+			log.Printf("[WARN] Glue Registry (%s) not found, removing from state", d.Id())
+			d.SetId("")
+			return nil
+		}
+		return fmt.Errorf("error reading Glue Registry (%s): %w", d.Id(), err)
+	}
+
+	if output == nil {
+		log.Printf("[WARN] Glue Registry (%s) not found, removing from state", d.Id())
+		d.SetId("")
+		return nil
+	}
+
+	arn := aws.StringValue(output.RegistryArn)
+	d.Set("arn", arn)
+	d.Set("description", output.Description)
+	d.Set("registry_name", output.RegistryName)
+
+	tags, err := keyvaluetags.GlueListTags(conn, arn)
+
+	if err != nil {
+		return fmt.Errorf("error listing tags for Glue Registry (%s): %w", arn, err)
+	}
+
+	if err := d.Set("tags", tags.IgnoreAws().IgnoreConfig(ignoreTagsConfig).Map()); err != nil {
+		return fmt.Errorf("error setting tags: %w", err)
+	}
+
+	return nil
+}
+
+func resourceAwsGlueRegistryUpdate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).glueconn
+
+	if d.HasChanges("description") {
+		input := &glue.UpdateRegistryInput{
+			RegistryId: tfglue.CreateAwsGlueRegistryID(d.Id()),
+		}
+
+		if v, ok := d.GetOk("description"); ok {
+			input.Description = aws.String(v.(string))
+		}
+
+		log.Printf("[DEBUG] Updating Glue Registry: %#v", input)
+		_, err := conn.UpdateRegistry(input)
+		if err != nil {
+			return fmt.Errorf("error updating Glue Registry (%s): %w", d.Id(), err)
+		}
+	}
+
+	if d.HasChange("tags") {
+		o, n := d.GetChange("tags")
+		if err := keyvaluetags.GlueUpdateTags(conn, d.Get("arn").(string), o, n); err != nil {
+			return fmt.Errorf("error updating tags: %s", err)
+		}
+	}
+
+	return resourceAwsGlueRegistryRead(d, meta)
+}
+
+func resourceAwsGlueRegistryDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).glueconn
+
+	log.Printf("[DEBUG] Deleting Glue Registry: %s", d.Id())
+	input := &glue.DeleteRegistryInput{
+		RegistryId: tfglue.CreateAwsGlueRegistryID(d.Id()),
+	}
+
+	_, err := conn.DeleteRegistry(input)
+	if err != nil {
+		if isAWSErr(err, glue.ErrCodeEntityNotFoundException, "") {
+			return nil
+		}
+		return fmt.Errorf("error deleting Glue Registry (%s): %w", d.Id(), err)
+	}
+
+	_, err = waiter.RegistryDeleted(conn, d.Id())
+	if err != nil {
+		if isAWSErr(err, glue.ErrCodeEntityNotFoundException, "") {
+			return nil
+		}
+		return fmt.Errorf("error waiting for Glue Registry (%s) to be deleted: %w", d.Id(), err)
+	}
+
+	return nil
+}