From d1107e337ad83a781f3b961935d51fd91b7c992f Mon Sep 17 00:00:00 2001 From: "Aaron J. Smith" Date: Wed, 9 Jan 2019 11:45:10 -0600 Subject: [PATCH 1/8] r/aws_fsx_file_system: Adding support and resource for managing FSx filesystems --- aws/config.go | 3 + aws/provider.go | 1 + aws/resource_aws_fsx_file_system.go | 448 +++++++++++++++++++ aws/resource_aws_fsx_file_system_test.go | 365 +++++++++++++++ aws/tagsFSX.go | 117 +++++ website/aws.erb | 11 + website/docs/r/fsx_file_system.html.markdown | 91 ++++ 7 files changed, 1036 insertions(+) create mode 100644 aws/resource_aws_fsx_file_system.go create mode 100644 aws/resource_aws_fsx_file_system_test.go create mode 100644 aws/tagsFSX.go create mode 100644 website/docs/r/fsx_file_system.html.markdown diff --git a/aws/config.go b/aws/config.go index 03a1b69d2b6..e249576ec2d 100644 --- a/aws/config.go +++ b/aws/config.go @@ -62,6 +62,7 @@ import ( "github.com/aws/aws-sdk-go/service/emr" "github.com/aws/aws-sdk-go/service/firehose" "github.com/aws/aws-sdk-go/service/fms" + "github.com/aws/aws-sdk-go/service/fsx" "github.com/aws/aws-sdk-go/service/gamelift" "github.com/aws/aws-sdk-go/service/glacier" "github.com/aws/aws-sdk-go/service/glue" @@ -263,6 +264,7 @@ type AWSClient struct { workspacesconn *workspaces.WorkSpaces appmeshconn *appmesh.AppMesh transferconn *transfer.Transfer + fsxconn *fsx.FSx } func (c *AWSClient) S3() *s3.S3 { @@ -552,6 +554,7 @@ func (c *Config) Client() (interface{}, error) { client.esconn = elasticsearch.New(awsEsSess) client.firehoseconn = firehose.New(sess) client.fmsconn = fms.New(sess) + client.fsxconn = fsx.New(sess) client.inspectorconn = inspector.New(sess) client.gameliftconn = gamelift.New(sess) client.glacierconn = glacier.New(sess) diff --git a/aws/provider.go b/aws/provider.go index 074aa98995a..45e57be6e1d 100644 --- a/aws/provider.go +++ b/aws/provider.go @@ -463,6 +463,7 @@ func Provider() terraform.ResourceProvider { "aws_emr_instance_group": resourceAwsEMRInstanceGroup(), "aws_emr_security_configuration": resourceAwsEMRSecurityConfiguration(), "aws_flow_log": resourceAwsFlowLog(), + "aws_fsx_file_system": resourceAwsFsxFileSystem(), "aws_gamelift_alias": resourceAwsGameliftAlias(), "aws_gamelift_build": resourceAwsGameliftBuild(), "aws_gamelift_fleet": resourceAwsGameliftFleet(), diff --git a/aws/resource_aws_fsx_file_system.go b/aws/resource_aws_fsx_file_system.go new file mode 100644 index 00000000000..91413b7091b --- /dev/null +++ b/aws/resource_aws_fsx_file_system.go @@ -0,0 +1,448 @@ +package aws + +import ( + "fmt" + "log" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/service/fsx" + + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/helper/schema" + "github.com/hashicorp/terraform/helper/validation" +) + +func resourceAwsFsxFileSystem() *schema.Resource { + return &schema.Resource{ + Create: resourceAwsFsxFileSystemCreate, + Read: resourceAwsFsxFileSystemRead, + Update: resourceAwsFsxFileSystemUpdate, + Delete: resourceAwsFsxFileSystemDelete, + Importer: &schema.ResourceImporter{ + State: schema.ImportStatePassthrough, + }, + + Schema: map[string]*schema.Schema{ + "type": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringInSlice([]string{"LUSTRE", "WINDOWS"}, false), + }, + "capacity": { + Type: schema.TypeInt, + Required: true, + ForceNew: true, + ValidateFunc: validation.IntAtLeast(300), + }, + "kms_key_id": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + "subnet_ids": { + Type: schema.TypeList, + Required: true, + Elem: &schema.Schema{Type: schema.TypeString}, + }, + "security_group_ids": { + Type: schema.TypeList, + Optional: true, + Elem: &schema.Schema{Type: schema.TypeString}, + }, + "lustre_configuration": { + Type: schema.TypeList, + Optional: true, + MaxItems: 1, + ConflictsWith: []string{"windows_configuration"}, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "import_path": { + Type: schema.TypeString, + Required: true, + }, + "chunk_size": { + Type: schema.TypeInt, + Optional: true, + Default: 1024, + }, + "weekly_maintenance_start_time": { + Type: schema.TypeString, + Optional: true, + Default: "3:03:30", + }, + }, + }, + }, + "windows_configuration": { + Type: schema.TypeList, + Optional: true, + MaxItems: 1, + ConflictsWith: []string{"lustre_configuration"}, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "active_directory_id": { + Type: schema.TypeString, + Required: true, + }, + "backup_retention": { + Type: schema.TypeInt, + Optional: true, + Default: 7, + }, + "copy_tags_to_backups": { + Type: schema.TypeBool, + Optional: true, + Default: false, + }, + "daily_backup_start_time": { + Type: schema.TypeString, + Optional: true, + Default: "06:00", + }, + "throughput_capacity": { + Type: schema.TypeInt, + Required: true, + }, + "weekly_maintenance_start_time": { + Type: schema.TypeString, + Optional: true, + Default: "3:03:30", + }, + }, + }, + }, + "arn": { + Type: schema.TypeString, + Computed: true, + }, + "dns_name": { + Type: schema.TypeString, + Computed: true, + }, + "tags": tagsSchema(), + }, + } +} + +func resourceAwsFsxFileSystemCreate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).fsxconn + + request := &fsx.CreateFileSystemInput{ + FileSystemType: aws.String(d.Get("type").(string)), + StorageCapacity: aws.Int64(int64(d.Get("capacity").(int))), + SubnetIds: expandStringList(d.Get("subnet_ids").([]interface{})), + KmsKeyId: aws.String(d.Get("kms_key_id").(string)), + } + + if value, ok := d.GetOk("security_group_ids"); ok { + request.SecurityGroupIds = expandStringList(value.([]interface{})) + } + + if _, ok := d.GetOk("lustre_configuration"); ok { + request.LustreConfiguration = expandFsxLustreConfigurationCreate(d.Get("lustre_configuration").([]interface{})) + } + + if _, ok := d.GetOk("windows_configuration"); ok { + request.WindowsConfiguration = expandFsxWindowsConfigurationCreate(d.Get("windows_configuration").([]interface{})) + } + + if value, ok := d.GetOk("tags"); ok { + request.Tags = tagsFromMapFSX(value.(map[string]interface{})) + } + + log.Printf("[DEBUG] FSx Filesystem create opts: %s", request) + result, err := conn.CreateFileSystem(request) + if err != nil { + return fmt.Errorf("Error creating FSx filesystem: %s", err) + } + + log.Println("[DEBUG] Waiting for filesystem to become available") + + stateConf := &resource.StateChangeConf{ + Pending: []string{"CREATING"}, + Target: []string{"AVAILABLE"}, + Refresh: func() (interface{}, string, error) { + resp, err := conn.DescribeFileSystems(&fsx.DescribeFileSystemsInput{ + FileSystemIds: []*string{aws.String(*result.FileSystem.FileSystemId)}, + }) + + if err != nil { + if ec2err, ok := err.(awserr.Error); ok { + log.Printf("Error on FSx State Refresh: message: \"%s\", code:\"%s\"", ec2err.Message(), ec2err.Code()) + resp = nil + return nil, "", err + } else { + log.Printf("Error on FSx State Refresh: %s", err) + return nil, "", err + } + } + + v := resp.FileSystems[0] + return v, *v.Lifecycle, nil + }, + Timeout: 60 * time.Minute, + Delay: 30 * time.Second, + MinTimeout: 15 * time.Second, + } + + _, err = stateConf.WaitForState() + if err != nil { + return fmt.Errorf( + "Error waiting for filesystem (%s) to become available: %s", + *result.FileSystem.FileSystemId, err) + } + + d.SetId(*result.FileSystem.FileSystemId) + + return resourceAwsFsxFileSystemRead(d, meta) +} + +func resourceAwsFsxFileSystemUpdate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).fsxconn + + if _, ok := d.GetOk("tags"); ok { + if err := setTagsFSX(conn, d); err != nil { + return fmt.Errorf("Error updating tags for FSx filesystem: %s", err) + } + } + + requestUpdate := false + params := &fsx.UpdateFileSystemInput{ + FileSystemId: aws.String(d.Id()), + } + + if d.HasChange("lustre_configuration") { + params.LustreConfiguration = expandFsxLustreConfigurationUpdate(d.Get("lustre_configuration").([]interface{})) + requestUpdate = true + } + + if d.HasChange("windows_configuration") { + params.WindowsConfiguration = expandFsxWindowsConfigurationUpdate(d.Get("windows_configuration").([]interface{})) + requestUpdate = true + } + + if requestUpdate { + _, err := conn.UpdateFileSystem(params) + if err != nil { + return err + } + } + + return resourceAwsFsxFileSystemRead(d, meta) +} + +func resourceAwsFsxFileSystemRead(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).fsxconn + + request := &fsx.DescribeFileSystemsInput{ + FileSystemIds: []*string{aws.String(d.Id())}, + } + + response, err := conn.DescribeFileSystems(request) + if err != nil { + return fmt.Errorf("Error reading FSx filesystem %s: %s", d.Id(), err) + } + + d.Set("type", *response.FileSystems[0].FileSystemType) + d.Set("capacity", *response.FileSystems[0].StorageCapacity) + d.Set("arn", *response.FileSystems[0].ResourceARN) + d.Set("dns_name", *response.FileSystems[0].DNSName) + + d.Set("tags", tagsToMapFSX(response.FileSystems[0].Tags)) + + subnets := make([]string, 0) + for _, subnet := range response.FileSystems[0].SubnetIds { + subnets = append(subnets, aws.StringValue(subnet)) + } + + d.Set("subnet_ids", subnets) + + if response.FileSystems[0].KmsKeyId != nil { + d.Set("kms_key_id", *response.FileSystems[0].KmsKeyId) + } + + if _, ok := d.GetOk("lustre_configuration"); ok { + err = d.Set("lustre_configuration", flattenLustreOptsConfig(response.FileSystems[0].LustreConfiguration)) + if err != nil { + return err + } + } + + if _, ok := d.GetOk("windows_configuration"); ok { + err = d.Set("windows_configuration", flattenWindowsOptsConfig(response.FileSystems[0].WindowsConfiguration)) + if err != nil { + return err + } + } + + return nil +} + +func resourceAwsFsxFileSystemDelete(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).fsxconn + + request := &fsx.DeleteFileSystemInput{ + FileSystemId: aws.String(d.Id()), + } + + _, err := conn.DeleteFileSystem(request) + if err != nil { + return fmt.Errorf("Error deleting FSx filesystem: %s", err) + } + + log.Println("[DEBUG] Waiting for filesystem to delete") + + stateConf := &resource.StateChangeConf{ + Pending: []string{"AVAILABLE", "DELETING"}, + Target: []string{}, + Refresh: func() (interface{}, string, error) { + resp, err := conn.DescribeFileSystems(&fsx.DescribeFileSystemsInput{ + FileSystemIds: []*string{aws.String(d.Id())}, + }) + if err != nil { + efsErr, ok := err.(awserr.Error) + if ok && efsErr.Code() == "FileSystemNotFound" { + return nil, "", nil + } + return nil, "error", err + } + + if hasEmptyFsxFileSystems(resp) { + return nil, "", nil + } + + v := resp.FileSystems[0] + log.Printf("[DEBUG] current status of %q: %q", *v.FileSystemId, *v.Lifecycle) + return v, *v.Lifecycle, nil + }, + Timeout: 60 * time.Minute, + Delay: 30 * time.Second, + MinTimeout: 15 * time.Second, + } + + _, err = stateConf.WaitForState() + if err != nil { + return fmt.Errorf("Error waiting for filesystem (%s) to delete: %s", d.Id(), err) + } + + return nil +} + +func hasEmptyFsxFileSystems(fs *fsx.DescribeFileSystemsOutput) bool { + if fs != nil && len(fs.FileSystems) > 0 { + return false + } + return true +} + +func expandFsxLustreConfigurationCreate(l []interface{}) *fsx.CreateFileSystemLustreConfiguration { + data := l[0].(map[string]interface{}) + req := &fsx.CreateFileSystemLustreConfiguration{} + + if data["import_path"].(string) != "" { + req.ImportPath = aws.String(data["import_path"].(string)) + } + + if data["chunk_size"] != nil { + req.ImportedFileChunkSize = aws.Int64(int64(data["chunk_size"].(int))) + } + + if data["weekly_maintenance_start_time"].(string) != "" { + req.WeeklyMaintenanceStartTime = aws.String(data["weekly_maintenance_start_time"].(string)) + } + + return req +} + +func expandFsxLustreConfigurationUpdate(l []interface{}) *fsx.UpdateFileSystemLustreConfiguration { + data := l[0].(map[string]interface{}) + req := &fsx.UpdateFileSystemLustreConfiguration{} + + if data["weekly_maintenance_start_time"].(string) != "" { + req.WeeklyMaintenanceStartTime = aws.String(data["weekly_maintenance_start_time"].(string)) + } + + return req +} + +func expandFsxWindowsConfigurationCreate(l []interface{}) *fsx.CreateFileSystemWindowsConfiguration { + data := l[0].(map[string]interface{}) + req := &fsx.CreateFileSystemWindowsConfiguration{ + ThroughputCapacity: aws.Int64(int64(data["throughput_capacity"].(int))), + } + + if data["active_directory_id"].(string) != "" { + req.ActiveDirectoryId = aws.String(data["active_directory_id"].(string)) + } + + if data["backup_retention"] != nil { + req.AutomaticBackupRetentionDays = aws.Int64(int64(data["backup_retention"].(int))) + } + + if data["copy_tags_to_backups"] != nil { + req.CopyTagsToBackups = aws.Bool(data["copy_tags_to_backups"].(bool)) + } + + if data["daily_backup_start_time"].(string) != "" { + req.DailyAutomaticBackupStartTime = aws.String(data["daily_backup_start_time"].(string)) + } + + if data["weekly_maintenance_start_time"].(string) != "" { + req.WeeklyMaintenanceStartTime = aws.String(data["weekly_maintenance_start_time"].(string)) + } + + return req +} + +func expandFsxWindowsConfigurationUpdate(l []interface{}) *fsx.UpdateFileSystemWindowsConfiguration { + data := l[0].(map[string]interface{}) + req := &fsx.UpdateFileSystemWindowsConfiguration{} + + if data["backup_retention"] != nil { + req.AutomaticBackupRetentionDays = aws.Int64(int64(data["backup_retention"].(int))) + } + + if data["daily_backup_start_time"].(string) != "" { + req.DailyAutomaticBackupStartTime = aws.String(data["daily_backup_start_time"].(string)) + } + + if data["weekly_maintenance_start_time"].(string) != "" { + req.WeeklyMaintenanceStartTime = aws.String(data["weekly_maintenance_start_time"].(string)) + } + + return req +} + +func flattenLustreOptsConfig(lopts *fsx.LustreFileSystemConfiguration) []map[string]interface{} { + if lopts == nil { + return []map[string]interface{}{} + } + + m := map[string]interface{}{ + "import_path": aws.StringValue(lopts.DataRepositoryConfiguration.ImportPath), + "chunk_size": aws.Int64Value(lopts.DataRepositoryConfiguration.ImportedFileChunkSize), + "weekly_maintenance_start_time": aws.StringValue(lopts.WeeklyMaintenanceStartTime), + } + + return []map[string]interface{}{m} +} + +func flattenWindowsOptsConfig(wopts *fsx.WindowsFileSystemConfiguration) []map[string]interface{} { + if wopts == nil { + return []map[string]interface{}{} + } + + m := map[string]interface{}{ + "active_directory_id": aws.StringValue(wopts.ActiveDirectoryId), + "backup_retention": aws.Int64Value(wopts.AutomaticBackupRetentionDays), + "copy_tags_to_backups": aws.BoolValue(wopts.CopyTagsToBackups), + "daily_backup_start_time": aws.StringValue(wopts.DailyAutomaticBackupStartTime), + "throughput_capacity": aws.Int64Value(wopts.ThroughputCapacity), + "weekly_maintenance_start_time": aws.StringValue(wopts.WeeklyMaintenanceStartTime), + } + + return []map[string]interface{}{m} +} diff --git a/aws/resource_aws_fsx_file_system_test.go b/aws/resource_aws_fsx_file_system_test.go new file mode 100644 index 00000000000..e5fcb44c6bb --- /dev/null +++ b/aws/resource_aws_fsx_file_system_test.go @@ -0,0 +1,365 @@ +package aws + +import ( + "fmt" + "testing" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/fsx" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" +) + +func TestAccAWSFsxFileSystem_lustreBasic(t *testing.T) { + var v fsx.FileSystem + resourceName := "aws_fsx_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + IDRefreshName: resourceName, + Providers: testAccProviders, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxFileSystemLustreBasic, + Check: resource.ComposeTestCheckFunc( + testAccCheckFileSystemExists(resourceName, &v), + resource.TestCheckResourceAttr(resourceName, "type", "LUSTRE"), + resource.TestCheckResourceAttr(resourceName, "capacity", "3600"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"kms_key_id"}, + }, + }, + }) +} + +func TestAccAWSFsxFileSystem_lustreConfig(t *testing.T) { + var v fsx.FileSystem + resourceName := "aws_fsx_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + IDRefreshName: resourceName, + Providers: testAccProviders, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxFileSystemLustreConfigOpts, + Check: resource.ComposeTestCheckFunc( + testAccCheckFileSystemExists(resourceName, &v), + resource.TestCheckResourceAttr(resourceName, "lustre_configuration.#", "1"), + resource.TestCheckResourceAttr(resourceName, "lustre_configuration.0.import_path", "s3://nasanex"), + resource.TestCheckResourceAttr(resourceName, "lustre_configuration.0.chunk_size", "2048"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"kms_key_id"}, + }, + }, + }) +} + +func TestAccAWSFsxFileSystem_lustreUpdate(t *testing.T) { + var v fsx.FileSystem + resourceName := "aws_fsx_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + IDRefreshName: resourceName, + Providers: testAccProviders, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxFileSystemLustreConfigOpts, + Check: resource.ComposeTestCheckFunc( + testAccCheckFileSystemExists(resourceName, &v), + resource.TestCheckResourceAttr(resourceName, "lustre_configuration.#", "1"), + resource.TestCheckResourceAttr(resourceName, "lustre_configuration.0.weekly_maintenance_start_time", "3:03:30"), + ), + }, + { + Config: testAccAwsFsxFileSystemLustreUpdateOpts, + Check: resource.ComposeTestCheckFunc( + testAccCheckFileSystemExists(resourceName, &v), + resource.TestCheckResourceAttr(resourceName, "lustre_configuration.#", "1"), + resource.TestCheckResourceAttr(resourceName, "lustre_configuration.0.weekly_maintenance_start_time", "5:05:50"), + ), + }, + }, + }) +} + +func TestAccAWSFsxFileSystem_windowsConfig(t *testing.T) { + var v fsx.FileSystem + resourceName := "aws_fsx_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + IDRefreshName: resourceName, + Providers: testAccProviders, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxFileSystemWindowsConfigOpts, + Check: resource.ComposeTestCheckFunc( + testAccCheckFileSystemExists(resourceName, &v), + resource.TestCheckResourceAttr(resourceName, "windows_configuration.#", "1"), + resource.TestCheckResourceAttr(resourceName, "windows_configuration.0.backup_retention", "3"), + resource.TestCheckResourceAttr(resourceName, "windows_configuration.0.copy_tags_to_backups", "true"), + resource.TestCheckResourceAttr(resourceName, "windows_configuration.0.throughput_capacity", "1024"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"kms_key_id"}, + }, + }, + }) +} + +func TestAccAWSFsxFileSystem_windowsUpdate(t *testing.T) { + var v fsx.FileSystem + resourceName := "aws_fsx_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + IDRefreshName: resourceName, + Providers: testAccProviders, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxFileSystemWindowsConfigOpts, + Check: resource.ComposeTestCheckFunc( + testAccCheckFileSystemExists(resourceName, &v), + resource.TestCheckResourceAttr(resourceName, "windows_configuration.#", "1"), + resource.TestCheckResourceAttr(resourceName, "windows_configuration.0.backup_retention", "3"), + ), + }, + { + Config: testAccAwsFsxFileSystemWindowsUpdateOpts, + Check: resource.ComposeTestCheckFunc( + testAccCheckFileSystemExists(resourceName, &v), + resource.TestCheckResourceAttr(resourceName, "windows_configuration.#", "1"), + resource.TestCheckResourceAttr(resourceName, "windows_configuration.0.backup_retention", "30"), + ), + }, + }, + }) +} + +func testAccCheckFileSystemExists(n string, v *fsx.FileSystem) resource.TestCheckFunc { + return func(s *terraform.State) error { + rs, ok := s.RootModule().Resources[n] + if !ok { + return fmt.Errorf("Not found: %s", n) + } + + if rs.Primary.ID == "" { + return fmt.Errorf("No ID is set") + } + + conn := testAccProvider.Meta().(*AWSClient).fsxconn + + request := &fsx.DescribeFileSystemsInput{ + FileSystemIds: []*string{aws.String(rs.Primary.ID)}, + } + + response, err := conn.DescribeFileSystems(request) + if err == nil { + if response.FileSystems != nil && len(response.FileSystems) > 0 { + *v = *response.FileSystems[0] + return nil + } + } + return fmt.Errorf("Error finding FSx filesystem %s", rs.Primary.ID) + } +} + +const testAccAwsFsxFileSystemLustreBasic = ` +resource "aws_vpc" "test" { + cidr_block = "10.0.0.0/16" +} + +resource "aws_subnet" "test" { + vpc_id = "${aws_vpc.test.id}" + cidr_block = "10.0.1.0/24" + availability_zone = "us-east-1a" +} + +resource "aws_kms_key" "test" { + description = "FSx KMS Testing key" + deletion_window_in_days = 7 +} + +resource "aws_fsx_file_system" "test" { + depends_on = ["aws_subnet.test", "aws_kms_key.test"] + type = "LUSTRE" + capacity = 3600 + kms_key_id = "${aws_kms_key.test.key_id}" + subnet_ids = ["${aws_subnet.test.id}"] +} +` + +const testAccAwsFsxFileSystemLustreConfigOpts = ` +resource "aws_vpc" "test" { + cidr_block = "10.0.0.0/16" +} + +resource "aws_subnet" "test" { + vpc_id = "${aws_vpc.test.id}" + cidr_block = "10.0.1.0/24" + availability_zone = "us-east-1a" +} + +resource "aws_kms_key" "test" { + description = "FSx KMS Testing key" + deletion_window_in_days = 7 +} + +resource "aws_fsx_file_system" "test" { + depends_on = ["aws_subnet.test", "aws_kms_key.test"] + type = "LUSTRE" + capacity = 3600 + kms_key_id = "${aws_kms_key.test.key_id}" + subnet_ids = ["${aws_subnet.test.id}"] + + lustre_configuration { + import_path = "s3://nasanex" + chunk_size = 2048 + } +} +` + +const testAccAwsFsxFileSystemLustreUpdateOpts = ` +resource "aws_vpc" "test" { + cidr_block = "10.0.0.0/16" +} + +resource "aws_subnet" "test" { + vpc_id = "${aws_vpc.test.id}" + cidr_block = "10.0.1.0/24" + availability_zone = "us-east-1a" +} + +resource "aws_kms_key" "test" { + description = "FSx KMS Testing key" + deletion_window_in_days = 7 +} + +resource "aws_fsx_file_system" "test" { + depends_on = ["aws_subnet.test", "aws_kms_key.test"] + type = "LUSTRE" + capacity = 3600 + kms_key_id = "${aws_kms_key.test.key_id}" + subnet_ids = ["${aws_subnet.test.id}"] + + lustre_configuration { + import_path = "s3://nasanex" + chunk_size = 2048 + weekly_maintenance_start_time = "5:05:50" + } +} +` + +const testAccAwsFsxFileSystemWindowsConfigOpts = ` +resource "aws_vpc" "test" { + cidr_block = "10.0.0.0/16" +} + +resource "aws_subnet" "test1" { + vpc_id = "${aws_vpc.test.id}" + cidr_block = "10.0.1.0/24" + availability_zone = "us-east-1a" +} + +resource "aws_subnet" "test2" { + vpc_id = "${aws_vpc.test.id}" + cidr_block = "10.0.2.0/24" + availability_zone = "us-east-1d" +} + +resource "aws_kms_key" "test" { + description = "FSx KMS Testing key" + deletion_window_in_days = 7 +} + +resource "aws_directory_service_directory" "test" { + name = "corp.notexample.com" + password = "SuperSecretPassw0rd" + type = "MicrosoftAD" + + vpc_settings { + vpc_id = "${aws_vpc.test.id}" + subnet_ids = ["${aws_subnet.test1.id}", "${aws_subnet.test2.id}"] + } +} + +resource "aws_fsx_file_system" "test" { + depends_on = ["aws_subnet.test1", "aws_kms_key.test", "aws_directory_service_directory.test"] + type = "WINDOWS" + capacity = 300 + kms_key_id = "${aws_kms_key.test.arn}" + subnet_ids = ["${aws_subnet.test1.id}"] + + windows_configuration { + active_directory_id = "${aws_directory_service_directory.test.id}" + backup_retention = 3 + copy_tags_to_backups = true + throughput_capacity = 1024 + } +} +` + +const testAccAwsFsxFileSystemWindowsUpdateOpts = ` +resource "aws_vpc" "test" { + cidr_block = "10.0.0.0/16" +} + +resource "aws_subnet" "test1" { + vpc_id = "${aws_vpc.test.id}" + cidr_block = "10.0.1.0/24" + availability_zone = "us-east-1a" +} + +resource "aws_subnet" "test2" { + vpc_id = "${aws_vpc.test.id}" + cidr_block = "10.0.2.0/24" + availability_zone = "us-east-1d" +} + +resource "aws_kms_key" "test" { + description = "FSx KMS Testing key" + deletion_window_in_days = 7 +} + +resource "aws_directory_service_directory" "test" { + name = "corp.notexample.com" + password = "SuperSecretPassw0rd" + type = "MicrosoftAD" + + vpc_settings { + vpc_id = "${aws_vpc.test.id}" + subnet_ids = ["${aws_subnet.test1.id}", "${aws_subnet.test2.id}"] + } +} + +resource "aws_fsx_file_system" "test" { + depends_on = ["aws_subnet.test1", "aws_kms_key.test", "aws_directory_service_directory.test"] + type = "WINDOWS" + capacity = 300 + kms_key_id = "${aws_kms_key.test.arn}" + subnet_ids = ["${aws_subnet.test1.id}"] + + windows_configuration { + active_directory_id = "${aws_directory_service_directory.test.id}" + backup_retention = 30 + copy_tags_to_backups = true + throughput_capacity = 1024 + } +} +` diff --git a/aws/tagsFSX.go b/aws/tagsFSX.go new file mode 100644 index 00000000000..f2eed55a87b --- /dev/null +++ b/aws/tagsFSX.go @@ -0,0 +1,117 @@ +package aws + +import ( + "log" + "regexp" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/fsx" + "github.com/hashicorp/terraform/helper/schema" +) + +// setTags is a helper to set the tags for a resource. It expects the +// tags field to be named "tags". It also expects to take the resource +// ARN as the primary ID based on the requirements of the FSx API (as +// opposed to the resource ID like other tagging helpers). +func setTagsFSX(conn *fsx.FSx, d *schema.ResourceData) error { + if d.HasChange("tags") { + oraw, nraw := d.GetChange("tags") + o := oraw.(map[string]interface{}) + n := nraw.(map[string]interface{}) + create, remove := diffTagsFSX(tagsFromMapFSX(o), tagsFromMapFSX(n)) + + // Set tags + if len(remove) > 0 { + log.Printf("[DEBUG] Removing tags: %#v", remove) + k := make([]*string, 0, len(remove)) + for _, t := range remove { + k = append(k, t.Key) + } + _, err := conn.UntagResource(&fsx.UntagResourceInput{ + ResourceARN: aws.String(d.Get("arn").(string)), + TagKeys: k, + }) + if err != nil { + return err + } + } + if len(create) > 0 { + log.Printf("[DEBUG] Creating tags: %#v", create) + _, err := conn.TagResource(&fsx.TagResourceInput{ + ResourceARN: aws.String(d.Get("arn").(string)), + Tags: create, + }) + if err != nil { + return err + } + } + } + + return nil +} + +// diffTags takes our tags locally and the ones remotely and returns +// the set of tags that must be created, and the set of tags that must +// be destroyed. +func diffTagsFSX(oldTags, newTags []*fsx.Tag) ([]*fsx.Tag, []*fsx.Tag) { + // First, we're creating everything we have + create := make(map[string]interface{}) + for _, t := range newTags { + create[*t.Key] = *t.Value + } + + // Build the list of what to remove + var remove []*fsx.Tag + for _, t := range oldTags { + old, ok := create[*t.Key] + if !ok || old != *t.Value { + // Delete it! + remove = append(remove, t) + } + } + + return tagsFromMapFSX(create), remove +} + +// tagsFromMap returns the tags for the given map of data. +func tagsFromMapFSX(m map[string]interface{}) []*fsx.Tag { + var result []*fsx.Tag + for k, v := range m { + t := &fsx.Tag{ + Key: aws.String(k), + Value: aws.String(v.(string)), + } + if !tagIgnoredFSX(t) { + result = append(result, t) + } + } + + return result +} + +// tagsToMap turns the list of tags into a map. +func tagsToMapFSX(ts []*fsx.Tag) map[string]string { + result := make(map[string]string) + for _, t := range ts { + if !tagIgnoredFSX(t) { + result[*t.Key] = *t.Value + } + } + + return result +} + +// compare a tag against a list of strings and checks if it should +// be ignored or not +func tagIgnoredFSX(t *fsx.Tag) bool { + filter := []string{"^aws:"} + for _, v := range filter { + log.Printf("[DEBUG] Matching %v with %v\n", v, *t.Key) + r, _ := regexp.MatchString(v, *t.Key) + if r { + log.Printf("[DEBUG] Found AWS specific tag %s (val: %s), ignoring.\n", *t.Key, *t.Value) + return true + } + } + return false +} diff --git a/website/aws.erb b/website/aws.erb index d16a7f690d7..a1291ddd53a 100644 --- a/website/aws.erb +++ b/website/aws.erb @@ -1366,6 +1366,17 @@ + > + FSx Resources + + + > Gamelift Resources
    diff --git a/website/docs/r/fsx_file_system.html.markdown b/website/docs/r/fsx_file_system.html.markdown new file mode 100644 index 00000000000..758e0d0a399 --- /dev/null +++ b/website/docs/r/fsx_file_system.html.markdown @@ -0,0 +1,91 @@ +--- +layout: "aws" +page_title: "AWS: aws_fsx_file_system" +sidebar_current: "docs-aws-resource-fsx-file-system" +description: |- + Provides an FSx filesystem resource. +--- + +# aws_fsx_file_system + +Provides an FSx filesystem resource. + +## Example Usage + +```hcl +resource "aws_fsx_file_system" "lustre" { + type = "LUSTRE" + capacity = 3600 + kms_key_id = "${aws_kms_key.example.key_id}" + subnet_ids = ["${aws_subnet.example.id}"] + + lustre_configuration { + import_path = "s3://example-bucket" + chunk_size = 2048 + } +} +``` + +```hcl +resource "aws_fsx_file_system" "windows" { + type = "WINDOWS" + capacity = 300 + kms_key_id = "${aws_kms_key.example.arn}" + subnet_ids = ["${aws_subnet.example.id}"] + + windows_configuration { + active_directory_id = "${aws_directory_service_directory.example.id}" + backup_retention = 7 + copy_tags_to_backups = true + throughput_capacity = 1024 + } +} +``` + +## Argument Reference + +The following arguments are supported: + +* `type` - (Required) The type of file system. `LUSTRE` +* `capacity` - (Required) The storage capacity of the file system. For Windows file systems, the storage capacity has a minimum of 300 GiB, and a maximum of 65,536 GiB. For Lustre file systems, the storage capacity has a minimum of 3,600 GiB. Storage capacity is provisioned in increments of 3,600 GiB. +* `kms_key_id` - (Required) The ARN for the KMS encryption key. +* `subnet_ids` - (Required) A list of IDs for the subnets that the file system will be accessible from. File systems support only one subnet. The file server is also launched in that subnet's Availability Zone. +* `security_group_ids` - (Optional) A list of IDs for the security groups that apply to the specified network interfaces created for file system access. These security groups will apply to all network interfaces. +* `lustre_configuration` - (Optional) The configuration for this Lustre file system. +* `windows_configuration` - (Optional) The configuration for this Microsoft Windows file system. +* `tags` - (Optional) A mapping of tags to assign to the file system. + +## lustre_configuration + +Attributes for Lustre configuration + +* `import_path` - (Required) The path to the Amazon S3 bucket (and optional prefix) that you're using as the data repository for your FSx for Lustre file system. +* `chunk_size` - (Optional) For files imported from a data repository, this value determines the stripe count and maximum amount of data per file (in MiB) stored on a single physical disk. +* `weekly_maintenance_start_time` - (Optional) The preferred time to perform weekly maintenance, in the UTC time zone. + +## windows_configuration + +Attributes for Windows configuration + +* `active_directory_id` - (Required) The ID for an existing Microsoft Active Directory instance that the file system should join when it's created. +* `backup_retention` - (Optional) The number of days to retain automatic backups. +* `copy_tags_to_backups` - (Optional) A boolean flag indicating whether tags on the file system should be copied to backups. +* `daily_backup_start_time` - (Optional) The preferred time to take daily automatic backups, in the UTC time zone. +* `throughput_capacity` - (Required) The throughput of an Amazon FSx file system, measured in megabytes per second. +* `weekly_maintenance_start_time` - (Optional) The preferred start time to perform weekly maintenance, in the UTC time zone. + +## Attributes Reference + +In addition to all arguments above, the following attributes are exported: + +* `id` - The ID that identifies the file system. +* `arn` - Amazon Resource Name of the file system. +* `dns_name` - The DNS name for the filesystem per [documented convention](https://docs.aws.amazon.com/fsx/index.html#lang/en_us). + +## Import + +The FSx file systems can be imported using the `id`, e.g. + +``` +$ terraform import aws_fsx_file_system.example fs-543ab12b1ca672f33 +``` From 7b028d8baeef304015df3159d4578e484622e547 Mon Sep 17 00:00:00 2001 From: "Aaron J. Smith" Date: Wed, 6 Feb 2019 19:23:41 -0600 Subject: [PATCH 2/8] removing merge cruft --- aws/config.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/aws/config.go b/aws/config.go index 7332ab362b3..b223cafe46e 100644 --- a/aws/config.go +++ b/aws/config.go @@ -604,10 +604,6 @@ func (c *Config) Client() (interface{}, error) { client.firehoseconn = firehose.New(sess) client.fmsconn = fms.New(sess) client.fsxconn = fsx.New(sess) -<<<<<<< HEAD - client.inspectorconn = inspector.New(sess) -======= ->>>>>>> master client.gameliftconn = gamelift.New(sess) client.glacierconn = glacier.New(sess) client.globalacceleratorconn = globalaccelerator.New(sess) From 01f58be1aec36c884d3a8cd18647a505d99ae6c1 Mon Sep 17 00:00:00 2001 From: "Aaron J. Smith" Date: Sun, 11 Aug 2019 22:56:18 -0500 Subject: [PATCH 3/8] addressing various review items and requests --- aws/resource_aws_fsx_file_system.go | 426 ++++++++++++++----- aws/resource_aws_fsx_file_system_test.go | 320 +++++++------- website/docs/r/fsx_file_system.html.markdown | 60 ++- 3 files changed, 515 insertions(+), 291 deletions(-) diff --git a/aws/resource_aws_fsx_file_system.go b/aws/resource_aws_fsx_file_system.go index 91413b7091b..c1d0d9bc86d 100644 --- a/aws/resource_aws_fsx_file_system.go +++ b/aws/resource_aws_fsx_file_system.go @@ -6,7 +6,6 @@ import ( "time" "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/service/fsx" "github.com/hashicorp/terraform/helper/resource" @@ -26,10 +25,13 @@ func resourceAwsFsxFileSystem() *schema.Resource { Schema: map[string]*schema.Schema{ "type": { - Type: schema.TypeString, - Required: true, - ForceNew: true, - ValidateFunc: validation.StringInSlice([]string{"LUSTRE", "WINDOWS"}, false), + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringInSlice([]string{ + fsx.FileSystemTypeLustre, + fsx.FileSystemTypeWindows, + }, false), }, "capacity": { Type: schema.TypeInt, @@ -38,40 +40,57 @@ func resourceAwsFsxFileSystem() *schema.Resource { ValidateFunc: validation.IntAtLeast(300), }, "kms_key_id": { - Type: schema.TypeString, - Required: true, - ForceNew: true, + Type: schema.TypeString, + Optional: true, + ForceNew: true, + ConflictsWith: []string{"lustre_configuration"}, }, "subnet_ids": { - Type: schema.TypeList, + Type: schema.TypeSet, Required: true, + ForceNew: true, Elem: &schema.Schema{Type: schema.TypeString}, }, "security_group_ids": { - Type: schema.TypeList, + Type: schema.TypeSet, Optional: true, + ForceNew: true, Elem: &schema.Schema{Type: schema.TypeString}, }, + "timeout": { + Type: schema.TypeInt, + Optional: true, + Default: 120, + ValidateFunc: validation.IntAtLeast(60), + }, "lustre_configuration": { Type: schema.TypeList, Optional: true, + Computed: true, MaxItems: 1, ConflictsWith: []string{"windows_configuration"}, Elem: &schema.Resource{ Schema: map[string]*schema.Schema{ "import_path": { Type: schema.TypeString, - Required: true, + Optional: true, + ForceNew: true, + }, + "export_path": { + Type: schema.TypeString, + Optional: true, + Computed: true, + ForceNew: true, }, "chunk_size": { Type: schema.TypeInt, Optional: true, - Default: 1024, + ForceNew: true, }, "weekly_maintenance_start_time": { Type: schema.TypeString, Optional: true, - Default: "3:03:30", + Computed: true, }, }, }, @@ -79,37 +98,76 @@ func resourceAwsFsxFileSystem() *schema.Resource { "windows_configuration": { Type: schema.TypeList, Optional: true, + Computed: true, MaxItems: 1, ConflictsWith: []string{"lustre_configuration"}, Elem: &schema.Resource{ Schema: map[string]*schema.Schema{ "active_directory_id": { Type: schema.TypeString, - Required: true, + Optional: true, + ForceNew: true, }, - "backup_retention": { - Type: schema.TypeInt, + "self_managed_active_directory": { + Type: schema.TypeList, Optional: true, - Default: 7, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "username": { + Type: schema.TypeString, + Required: true, + }, + "password": { + Type: schema.TypeString, + Required: true, + }, + "dns_ips": { + Type: schema.TypeSet, + Required: true, + Elem: &schema.Schema{Type: schema.TypeString}, + }, + "domain_name": { + Type: schema.TypeString, + Required: true, + }, + "administrators_group": { + Type: schema.TypeString, + Optional: true, + }, + "ou_distinguished_name": { + Type: schema.TypeString, + Optional: true, + }, + }, + }, + }, + "backup_retention": { + Type: schema.TypeInt, + Optional: true, + Default: 7, + ValidateFunc: validation.IntBetween(0, 35), }, "copy_tags_to_backups": { Type: schema.TypeBool, Optional: true, Default: false, + ForceNew: true, }, "daily_backup_start_time": { Type: schema.TypeString, Optional: true, - Default: "06:00", + Computed: true, }, "throughput_capacity": { Type: schema.TypeInt, Required: true, + ForceNew: true, }, "weekly_maintenance_start_time": { Type: schema.TypeString, Optional: true, - Default: "3:03:30", + Computed: true, }, }, }, @@ -133,12 +191,15 @@ func resourceAwsFsxFileSystemCreate(d *schema.ResourceData, meta interface{}) er request := &fsx.CreateFileSystemInput{ FileSystemType: aws.String(d.Get("type").(string)), StorageCapacity: aws.Int64(int64(d.Get("capacity").(int))), - SubnetIds: expandStringList(d.Get("subnet_ids").([]interface{})), - KmsKeyId: aws.String(d.Get("kms_key_id").(string)), + SubnetIds: expandStringList(d.Get("subnet_ids").(*schema.Set).List()), + } + + if _, ok := d.GetOk("kms_key_id"); ok { + request.KmsKeyId = aws.String(d.Get("kms_key_id").(string)) } - if value, ok := d.GetOk("security_group_ids"); ok { - request.SecurityGroupIds = expandStringList(value.([]interface{})) + if _, ok := d.GetOk("security_group_ids"); ok { + request.SecurityGroupIds = expandStringList(d.Get("security_group_ids").(*schema.Set).List()) } if _, ok := d.GetOk("lustre_configuration"); ok { @@ -159,31 +220,15 @@ func resourceAwsFsxFileSystemCreate(d *schema.ResourceData, meta interface{}) er return fmt.Errorf("Error creating FSx filesystem: %s", err) } + d.SetId(*result.FileSystem.FileSystemId) + log.Println("[DEBUG] Waiting for filesystem to become available") stateConf := &resource.StateChangeConf{ - Pending: []string{"CREATING"}, - Target: []string{"AVAILABLE"}, - Refresh: func() (interface{}, string, error) { - resp, err := conn.DescribeFileSystems(&fsx.DescribeFileSystemsInput{ - FileSystemIds: []*string{aws.String(*result.FileSystem.FileSystemId)}, - }) - - if err != nil { - if ec2err, ok := err.(awserr.Error); ok { - log.Printf("Error on FSx State Refresh: message: \"%s\", code:\"%s\"", ec2err.Message(), ec2err.Code()) - resp = nil - return nil, "", err - } else { - log.Printf("Error on FSx State Refresh: %s", err) - return nil, "", err - } - } - - v := resp.FileSystems[0] - return v, *v.Lifecycle, nil - }, - Timeout: 60 * time.Minute, + Pending: []string{fsx.FileSystemLifecycleCreating}, + Target: []string{fsx.FileSystemLifecycleAvailable}, + Refresh: fsxStateRefreshFunc(conn, d.Id()), + Timeout: time.Duration(d.Get("timeout").(int)) * time.Minute, Delay: 30 * time.Second, MinTimeout: 15 * time.Second, } @@ -195,15 +240,13 @@ func resourceAwsFsxFileSystemCreate(d *schema.ResourceData, meta interface{}) er *result.FileSystem.FileSystemId, err) } - d.SetId(*result.FileSystem.FileSystemId) - return resourceAwsFsxFileSystemRead(d, meta) } func resourceAwsFsxFileSystemUpdate(d *schema.ResourceData, meta interface{}) error { conn := meta.(*AWSClient).fsxconn - if _, ok := d.GetOk("tags"); ok { + if d.HasChange("tags") { if err := setTagsFSX(conn, d); err != nil { return fmt.Errorf("Error updating tags for FSx filesystem: %s", err) } @@ -227,7 +270,7 @@ func resourceAwsFsxFileSystemUpdate(d *schema.ResourceData, meta interface{}) er if requestUpdate { _, err := conn.UpdateFileSystem(params) if err != nil { - return err + fmt.Errorf("error updating FSX File System (%s): %s", d.Id(), err) } } @@ -237,45 +280,50 @@ func resourceAwsFsxFileSystemUpdate(d *schema.ResourceData, meta interface{}) er func resourceAwsFsxFileSystemRead(d *schema.ResourceData, meta interface{}) error { conn := meta.(*AWSClient).fsxconn - request := &fsx.DescribeFileSystemsInput{ - FileSystemIds: []*string{aws.String(d.Id())}, + filesystem, err := describeFsxFileSystem(conn, d.Id()) + + if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { + log.Printf("[WARN] FSx File System (%s) not found, removing from state", d.Id()) + d.SetId("") + return nil } - response, err := conn.DescribeFileSystems(request) if err != nil { - return fmt.Errorf("Error reading FSx filesystem %s: %s", d.Id(), err) + return fmt.Errorf("Error reading FSx File System (%s): %s", d.Id(), err) } - d.Set("type", *response.FileSystems[0].FileSystemType) - d.Set("capacity", *response.FileSystems[0].StorageCapacity) - d.Set("arn", *response.FileSystems[0].ResourceARN) - d.Set("dns_name", *response.FileSystems[0].DNSName) + if filesystem == nil { + log.Printf("[WARN] FSx File System (%s) not found, removing from state", d.Id()) + d.SetId("") + return nil + } - d.Set("tags", tagsToMapFSX(response.FileSystems[0].Tags)) + d.Set("type", filesystem.FileSystemType) + d.Set("capacity", filesystem.StorageCapacity) + d.Set("arn", filesystem.ResourceARN) + d.Set("dns_name", filesystem.DNSName) + d.Set("kms_key_id", filesystem.KmsKeyId) - subnets := make([]string, 0) - for _, subnet := range response.FileSystems[0].SubnetIds { - subnets = append(subnets, aws.StringValue(subnet)) - } + d.Set("tags", tagsToMapFSX(filesystem.Tags)) - d.Set("subnet_ids", subnets) + err = d.Set("lustre_configuration", flattenLustreOptsConfig(filesystem.LustreConfiguration)) + if err != nil { + return err + } - if response.FileSystems[0].KmsKeyId != nil { - d.Set("kms_key_id", *response.FileSystems[0].KmsKeyId) + err = d.Set("windows_configuration", flattenWindowsOptsConfig(filesystem.WindowsConfiguration)) + if err != nil { + return err } - if _, ok := d.GetOk("lustre_configuration"); ok { - err = d.Set("lustre_configuration", flattenLustreOptsConfig(response.FileSystems[0].LustreConfiguration)) - if err != nil { - return err - } + err = d.Set("subnet_ids", aws.StringValueSlice(filesystem.SubnetIds)) + if err != nil { + return err } - if _, ok := d.GetOk("windows_configuration"); ok { - err = d.Set("windows_configuration", flattenWindowsOptsConfig(response.FileSystems[0].WindowsConfiguration)) - if err != nil { - return err - } + err = d.Set("security_group_ids", expandStringList(d.Get("security_group_ids").(*schema.Set).List())) + if err != nil { + return err } return nil @@ -296,29 +344,10 @@ func resourceAwsFsxFileSystemDelete(d *schema.ResourceData, meta interface{}) er log.Println("[DEBUG] Waiting for filesystem to delete") stateConf := &resource.StateChangeConf{ - Pending: []string{"AVAILABLE", "DELETING"}, - Target: []string{}, - Refresh: func() (interface{}, string, error) { - resp, err := conn.DescribeFileSystems(&fsx.DescribeFileSystemsInput{ - FileSystemIds: []*string{aws.String(d.Id())}, - }) - if err != nil { - efsErr, ok := err.(awserr.Error) - if ok && efsErr.Code() == "FileSystemNotFound" { - return nil, "", nil - } - return nil, "error", err - } - - if hasEmptyFsxFileSystems(resp) { - return nil, "", nil - } - - v := resp.FileSystems[0] - log.Printf("[DEBUG] current status of %q: %q", *v.FileSystemId, *v.Lifecycle) - return v, *v.Lifecycle, nil - }, - Timeout: 60 * time.Minute, + Pending: []string{fsx.FileSystemLifecycleAvailable, fsx.FileSystemLifecycleDeleting}, + Target: []string{}, + Refresh: fsxStateRefreshFunc(conn, d.Id()), + Timeout: time.Duration(d.Get("timeout").(int)) * time.Minute, Delay: 30 * time.Second, MinTimeout: 15 * time.Second, } @@ -331,6 +360,49 @@ func resourceAwsFsxFileSystemDelete(d *schema.ResourceData, meta interface{}) er return nil } +func describeFsxFileSystem(conn *fsx.FSx, id string) (*fsx.FileSystem, error) { + input := &fsx.DescribeFileSystemsInput{ + FileSystemIds: []*string{aws.String(id)}, + } + var filesystem *fsx.FileSystem + + err := conn.DescribeFileSystemsPages(input, func(page *fsx.DescribeFileSystemsOutput, lastPage bool) bool { + for _, fs := range page.FileSystems { + if aws.StringValue(fs.FileSystemId) == id { + filesystem = fs + break + } + } + + return !lastPage + }) + + return filesystem, err +} + +func fsxStateRefreshFunc(conn *fsx.FSx, id string) resource.StateRefreshFunc { + return func() (interface{}, string, error) { + resp, err := conn.DescribeFileSystems(&fsx.DescribeFileSystemsInput{ + FileSystemIds: []*string{aws.String(id)}, + }) + + if resp == nil { + return nil, "", nil + } + + if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { + return nil, "", nil + } + + if err != nil { + return nil, "", err + } + + filesystem := resp.FileSystems[0] + return filesystem, *filesystem.Lifecycle, nil + } +} + func hasEmptyFsxFileSystems(fs *fsx.DescribeFileSystemsOutput) bool { if fs != nil && len(fs.FileSystems) > 0 { return false @@ -339,6 +411,10 @@ func hasEmptyFsxFileSystems(fs *fsx.DescribeFileSystemsOutput) bool { } func expandFsxLustreConfigurationCreate(l []interface{}) *fsx.CreateFileSystemLustreConfiguration { + if len(l) == 0 || l[0] == nil { + return nil + } + data := l[0].(map[string]interface{}) req := &fsx.CreateFileSystemLustreConfiguration{} @@ -346,6 +422,10 @@ func expandFsxLustreConfigurationCreate(l []interface{}) *fsx.CreateFileSystemLu req.ImportPath = aws.String(data["import_path"].(string)) } + if data["export_path"].(string) != "" { + req.ExportPath = aws.String(data["export_path"].(string)) + } + if data["chunk_size"] != nil { req.ImportedFileChunkSize = aws.Int64(int64(data["chunk_size"].(int))) } @@ -358,6 +438,10 @@ func expandFsxLustreConfigurationCreate(l []interface{}) *fsx.CreateFileSystemLu } func expandFsxLustreConfigurationUpdate(l []interface{}) *fsx.UpdateFileSystemLustreConfiguration { + if len(l) == 0 || l[0] == nil { + return nil + } + data := l[0].(map[string]interface{}) req := &fsx.UpdateFileSystemLustreConfiguration{} @@ -369,6 +453,10 @@ func expandFsxLustreConfigurationUpdate(l []interface{}) *fsx.UpdateFileSystemLu } func expandFsxWindowsConfigurationCreate(l []interface{}) *fsx.CreateFileSystemWindowsConfiguration { + if len(l) == 0 || l[0] == nil { + return nil + } + data := l[0].(map[string]interface{}) req := &fsx.CreateFileSystemWindowsConfiguration{ ThroughputCapacity: aws.Int64(int64(data["throughput_capacity"].(int))), @@ -378,6 +466,10 @@ func expandFsxWindowsConfigurationCreate(l []interface{}) *fsx.CreateFileSystemW req.ActiveDirectoryId = aws.String(data["active_directory_id"].(string)) } + if data["self_managed_active_directory"] != nil { + req.SelfManagedActiveDirectoryConfiguration = expandSelfManagedAdOptsCreate(data["self_managed_active_directory"].([]interface{})) + } + if data["backup_retention"] != nil { req.AutomaticBackupRetentionDays = aws.Int64(int64(data["backup_retention"].(int))) } @@ -398,6 +490,10 @@ func expandFsxWindowsConfigurationCreate(l []interface{}) *fsx.CreateFileSystemW } func expandFsxWindowsConfigurationUpdate(l []interface{}) *fsx.UpdateFileSystemWindowsConfiguration { + if len(l) == 0 || l[0] == nil { + return nil + } + data := l[0].(map[string]interface{}) req := &fsx.UpdateFileSystemWindowsConfiguration{} @@ -413,6 +509,68 @@ func expandFsxWindowsConfigurationUpdate(l []interface{}) *fsx.UpdateFileSystemW req.WeeklyMaintenanceStartTime = aws.String(data["weekly_maintenance_start_time"].(string)) } + if data["self_managed_active_directory"] != nil { + req.SelfManagedActiveDirectoryConfiguration = expandSelfManagedAdOptsUpdate(data["self_managed_active_directory"].([]interface{})) + } + + return req +} + +func expandSelfManagedAdOptsCreate(l []interface{}) *fsx.SelfManagedActiveDirectoryConfiguration { + if len(l) == 0 || l[0] == nil { + return nil + } + + data := l[0].(map[string]interface{}) + req := &fsx.SelfManagedActiveDirectoryConfiguration{} + + if d, ok := data["dns_ips"]; ok { + req.DnsIps = expandStringList(d.([]interface{})) + } + + if data["domain_name"].(string) != "" { + req.DomainName = aws.String(data["domain_name"].(string)) + } + + if data["administrators_group"].(string) != "" { + req.FileSystemAdministratorsGroup = aws.String(data["administrators_group"].(string)) + } + + if data["ou_distinguished_name"].(string) != "" { + req.OrganizationalUnitDistinguishedName = aws.String(data["ou_distinguished_name"].(string)) + } + + if data["password"].(string) != "" { + req.Password = aws.String(data["password"].(string)) + } + + if data["username"].(string) != "" { + req.UserName = aws.String(data["username"].(string)) + } + + return req +} + +func expandSelfManagedAdOptsUpdate(l []interface{}) *fsx.SelfManagedActiveDirectoryConfigurationUpdates { + if len(l) == 0 || l[0] == nil { + return nil + } + + data := l[0].(map[string]interface{}) + req := &fsx.SelfManagedActiveDirectoryConfigurationUpdates{} + + if d, ok := data["dns_ips"]; ok { + req.DnsIps = expandStringList(d.([]interface{})) + } + + if data["password"].(string) != "" { + req.Password = aws.String(data["password"].(string)) + } + + if data["username"].(string) != "" { + req.UserName = aws.String(data["username"].(string)) + } + return req } @@ -421,10 +579,19 @@ func flattenLustreOptsConfig(lopts *fsx.LustreFileSystemConfiguration) []map[str return []map[string]interface{}{} } - m := map[string]interface{}{ - "import_path": aws.StringValue(lopts.DataRepositoryConfiguration.ImportPath), - "chunk_size": aws.Int64Value(lopts.DataRepositoryConfiguration.ImportedFileChunkSize), - "weekly_maintenance_start_time": aws.StringValue(lopts.WeeklyMaintenanceStartTime), + m := map[string]interface{}{} + + if lopts.DataRepositoryConfiguration != nil && *lopts.DataRepositoryConfiguration.ImportPath != "" { + m["import_path"] = aws.StringValue(lopts.DataRepositoryConfiguration.ImportPath) + } + if lopts.DataRepositoryConfiguration != nil && *lopts.DataRepositoryConfiguration.ExportPath != "" { + m["export_path"] = aws.StringValue(lopts.DataRepositoryConfiguration.ExportPath) + } + if lopts.DataRepositoryConfiguration != nil && *lopts.DataRepositoryConfiguration.ImportedFileChunkSize != 0 { + m["chunk_size"] = aws.Int64Value(lopts.DataRepositoryConfiguration.ImportedFileChunkSize) + } + if lopts.WeeklyMaintenanceStartTime != nil { + m["weekly_maintenance_start_time"] = aws.StringValue(lopts.WeeklyMaintenanceStartTime) } return []map[string]interface{}{m} @@ -435,13 +602,54 @@ func flattenWindowsOptsConfig(wopts *fsx.WindowsFileSystemConfiguration) []map[s return []map[string]interface{}{} } - m := map[string]interface{}{ - "active_directory_id": aws.StringValue(wopts.ActiveDirectoryId), - "backup_retention": aws.Int64Value(wopts.AutomaticBackupRetentionDays), - "copy_tags_to_backups": aws.BoolValue(wopts.CopyTagsToBackups), - "daily_backup_start_time": aws.StringValue(wopts.DailyAutomaticBackupStartTime), - "throughput_capacity": aws.Int64Value(wopts.ThroughputCapacity), - "weekly_maintenance_start_time": aws.StringValue(wopts.WeeklyMaintenanceStartTime), + m := map[string]interface{}{} + + if wopts.ActiveDirectoryId != nil { + m["active_directory_id"] = aws.StringValue(wopts.ActiveDirectoryId) + } + if wopts.AutomaticBackupRetentionDays != nil { + m["backup_retention"] = aws.Int64Value(wopts.AutomaticBackupRetentionDays) + } + if wopts.CopyTagsToBackups != nil { + m["copy_tags_to_backups"] = aws.BoolValue(wopts.CopyTagsToBackups) + } + if wopts.DailyAutomaticBackupStartTime != nil { + m["daily_backup_start_time"] = aws.StringValue(wopts.DailyAutomaticBackupStartTime) + } + if wopts.ThroughputCapacity != nil { + m["throughput_capacity"] = aws.Int64Value(wopts.ThroughputCapacity) + } + if wopts.WeeklyMaintenanceStartTime != nil { + m["weekly_maintenance_start_time"] = aws.StringValue(wopts.WeeklyMaintenanceStartTime) + } + if wopts.SelfManagedActiveDirectoryConfiguration != nil { + m["self_managed_active_directory"] = flattenSelfManagedAdOptsConfig(wopts.SelfManagedActiveDirectoryConfiguration) + } + + return []map[string]interface{}{m} +} + +func flattenSelfManagedAdOptsConfig(adopts *fsx.SelfManagedActiveDirectoryAttributes) []map[string]interface{} { + if adopts == nil { + return []map[string]interface{}{} + } + + m := map[string]interface{}{} + + if adopts.UserName != nil { + m["username"] = aws.StringValue(adopts.UserName) + } + if adopts.DnsIps != nil { + m["dns_ips"] = aws.StringValueSlice(adopts.DnsIps) + } + if adopts.DomainName != nil { + m["domain_name"] = aws.StringValue(adopts.DomainName) + } + if adopts.FileSystemAdministratorsGroup != nil { + m["administrators_group"] = aws.StringValue(adopts.FileSystemAdministratorsGroup) + } + if adopts.OrganizationalUnitDistinguishedName != nil { + m["ou_distinguished_name"] = aws.StringValue(adopts.OrganizationalUnitDistinguishedName) } return []map[string]interface{}{m} diff --git a/aws/resource_aws_fsx_file_system_test.go b/aws/resource_aws_fsx_file_system_test.go index e5fcb44c6bb..5c6cd0b2955 100644 --- a/aws/resource_aws_fsx_file_system_test.go +++ b/aws/resource_aws_fsx_file_system_test.go @@ -18,20 +18,23 @@ func TestAccAWSFsxFileSystem_lustreBasic(t *testing.T) { PreCheck: func() { testAccPreCheck(t) }, IDRefreshName: resourceName, Providers: testAccProviders, + CheckDestroy: testAccCheckFsxFileSystemDestroy, Steps: []resource.TestStep{ { - Config: testAccAwsFsxFileSystemLustreBasic, + Config: testAccAwsFsxFileSystemLustreBasic(), Check: resource.ComposeTestCheckFunc( testAccCheckFileSystemExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "type", "LUSTRE"), resource.TestCheckResourceAttr(resourceName, "capacity", "3600"), + resource.TestCheckResourceAttr(resourceName, "subnet_ids.#", "1"), + resource.TestCheckResourceAttr(resourceName, "security_group_ids.#", "1"), ), }, { ResourceName: resourceName, ImportState: true, ImportStateVerify: true, - ImportStateVerifyIgnore: []string{"kms_key_id"}, + ImportStateVerifyIgnore: []string{"timeout", "security_group_ids"}, }, }, }) @@ -42,12 +45,12 @@ func TestAccAWSFsxFileSystem_lustreConfig(t *testing.T) { resourceName := "aws_fsx_file_system.test" resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - IDRefreshName: resourceName, - Providers: testAccProviders, + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxFileSystemDestroy, Steps: []resource.TestStep{ { - Config: testAccAwsFsxFileSystemLustreConfigOpts, + Config: testAccAwsFsxFileSystemLustreConfigOpts(), Check: resource.ComposeTestCheckFunc( testAccCheckFileSystemExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "lustre_configuration.#", "1"), @@ -59,7 +62,7 @@ func TestAccAWSFsxFileSystem_lustreConfig(t *testing.T) { ResourceName: resourceName, ImportState: true, ImportStateVerify: true, - ImportStateVerifyIgnore: []string{"kms_key_id"}, + ImportStateVerifyIgnore: []string{"timeout", "security_group_ids"}, }, }, }) @@ -70,20 +73,20 @@ func TestAccAWSFsxFileSystem_lustreUpdate(t *testing.T) { resourceName := "aws_fsx_file_system.test" resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - IDRefreshName: resourceName, - Providers: testAccProviders, + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxFileSystemDestroy, Steps: []resource.TestStep{ { - Config: testAccAwsFsxFileSystemLustreConfigOpts, + Config: testAccAwsFsxFileSystemLustreConfigOpts(), Check: resource.ComposeTestCheckFunc( testAccCheckFileSystemExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "lustre_configuration.#", "1"), - resource.TestCheckResourceAttr(resourceName, "lustre_configuration.0.weekly_maintenance_start_time", "3:03:30"), + resource.TestCheckResourceAttrSet(resourceName, "lustre_configuration.0.weekly_maintenance_start_time"), ), }, { - Config: testAccAwsFsxFileSystemLustreUpdateOpts, + Config: testAccAwsFsxFileSystemLustreUpdateOpts(), Check: resource.ComposeTestCheckFunc( testAccCheckFileSystemExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "lustre_configuration.#", "1"), @@ -99,12 +102,12 @@ func TestAccAWSFsxFileSystem_windowsConfig(t *testing.T) { resourceName := "aws_fsx_file_system.test" resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - IDRefreshName: resourceName, - Providers: testAccProviders, + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxFileSystemDestroy, Steps: []resource.TestStep{ { - Config: testAccAwsFsxFileSystemWindowsConfigOpts, + Config: testAccAwsFsxFileSystemWindowsConfigOpts(), Check: resource.ComposeTestCheckFunc( testAccCheckFileSystemExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "windows_configuration.#", "1"), @@ -117,7 +120,7 @@ func TestAccAWSFsxFileSystem_windowsConfig(t *testing.T) { ResourceName: resourceName, ImportState: true, ImportStateVerify: true, - ImportStateVerifyIgnore: []string{"kms_key_id"}, + ImportStateVerifyIgnore: []string{"timeout", "security_group_ids"}, }, }, }) @@ -128,12 +131,12 @@ func TestAccAWSFsxFileSystem_windowsUpdate(t *testing.T) { resourceName := "aws_fsx_file_system.test" resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - IDRefreshName: resourceName, - Providers: testAccProviders, + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxFileSystemDestroy, Steps: []resource.TestStep{ { - Config: testAccAwsFsxFileSystemWindowsConfigOpts, + Config: testAccAwsFsxFileSystemWindowsConfigOpts(), Check: resource.ComposeTestCheckFunc( testAccCheckFileSystemExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "windows_configuration.#", "1"), @@ -141,7 +144,7 @@ func TestAccAWSFsxFileSystem_windowsUpdate(t *testing.T) { ), }, { - Config: testAccAwsFsxFileSystemWindowsUpdateOpts, + Config: testAccAwsFsxFileSystemWindowsUpdateOpts(), Check: resource.ComposeTestCheckFunc( testAccCheckFileSystemExists(resourceName, &v), resource.TestCheckResourceAttr(resourceName, "windows_configuration.#", "1"), @@ -180,186 +183,185 @@ func testAccCheckFileSystemExists(n string, v *fsx.FileSystem) resource.TestChec } } -const testAccAwsFsxFileSystemLustreBasic = ` -resource "aws_vpc" "test" { - cidr_block = "10.0.0.0/16" -} +func testAccCheckFsxFileSystemDestroy(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).fsxconn -resource "aws_subnet" "test" { - vpc_id = "${aws_vpc.test.id}" - cidr_block = "10.0.1.0/24" - availability_zone = "us-east-1a" -} + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_fsx_file_system" { + continue + } -resource "aws_kms_key" "test" { - description = "FSx KMS Testing key" - deletion_window_in_days = 7 -} + filesystem, err := describeFsxFileSystem(conn, rs.Primary.ID) -resource "aws_fsx_file_system" "test" { - depends_on = ["aws_subnet.test", "aws_kms_key.test"] - type = "LUSTRE" - capacity = 3600 - kms_key_id = "${aws_kms_key.test.key_id}" - subnet_ids = ["${aws_subnet.test.id}"] -} -` + if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { + continue + } -const testAccAwsFsxFileSystemLustreConfigOpts = ` -resource "aws_vpc" "test" { - cidr_block = "10.0.0.0/16" -} + if err != nil { + return err + } -resource "aws_subnet" "test" { - vpc_id = "${aws_vpc.test.id}" - cidr_block = "10.0.1.0/24" - availability_zone = "us-east-1a" + if filesystem != nil { + return fmt.Errorf("FSx File System (%s) still exists", rs.Primary.ID) + } + } + return nil } -resource "aws_kms_key" "test" { - description = "FSx KMS Testing key" - deletion_window_in_days = 7 +const testAccAwsFsxFileSystemBaseConfig = ` +data "aws_availability_zones" "available" { + state = "available" } -resource "aws_fsx_file_system" "test" { - depends_on = ["aws_subnet.test", "aws_kms_key.test"] - type = "LUSTRE" - capacity = 3600 - kms_key_id = "${aws_kms_key.test.key_id}" - subnet_ids = ["${aws_subnet.test.id}"] - - lustre_configuration { - import_path = "s3://nasanex" - chunk_size = 2048 - } -} -` - -const testAccAwsFsxFileSystemLustreUpdateOpts = ` resource "aws_vpc" "test" { cidr_block = "10.0.0.0/16" } -resource "aws_subnet" "test" { - vpc_id = "${aws_vpc.test.id}" - cidr_block = "10.0.1.0/24" - availability_zone = "us-east-1a" +resource "aws_subnet" "test1" { + vpc_id = "${aws_vpc.test.id}" + cidr_block = "10.0.1.0/24" + availability_zone = "${data.aws_availability_zones.available.names[0]}" } -resource "aws_kms_key" "test" { - description = "FSx KMS Testing key" - deletion_window_in_days = 7 +resource "aws_subnet" "test2" { + vpc_id = "${aws_vpc.test.id}" + cidr_block = "10.0.2.0/24" + availability_zone = "${data.aws_availability_zones.available.names[1]}" } -resource "aws_fsx_file_system" "test" { - depends_on = ["aws_subnet.test", "aws_kms_key.test"] - type = "LUSTRE" - capacity = 3600 - kms_key_id = "${aws_kms_key.test.key_id}" - subnet_ids = ["${aws_subnet.test.id}"] - - lustre_configuration { - import_path = "s3://nasanex" - chunk_size = 2048 - weekly_maintenance_start_time = "5:05:50" - } -} -` +resource "aws_security_group" "test1" { + description = "security group for FSx testing" + vpc_id = "${aws_vpc.test.id}" -const testAccAwsFsxFileSystemWindowsConfigOpts = ` -resource "aws_vpc" "test" { - cidr_block = "10.0.0.0/16" -} + ingress { + from_port = 988 + to_port = 988 + protocol = "tcp" + cidr_blocks = ["10.0.0.0/16"] + } -resource "aws_subnet" "test1" { - vpc_id = "${aws_vpc.test.id}" - cidr_block = "10.0.1.0/24" - availability_zone = "us-east-1a" -} + ingress { + from_port = 135 + to_port = 135 + protocol = "tcp" + cidr_blocks = ["10.0.0.0/16"] + } -resource "aws_subnet" "test2" { - vpc_id = "${aws_vpc.test.id}" - cidr_block = "10.0.2.0/24" - availability_zone = "us-east-1d" + ingress { + from_port = 445 + to_port = 445 + protocol = "tcp" + cidr_blocks = ["10.0.0.0/16"] + } + + ingress { + from_port = 55555 + to_port = 55555 + protocol = "tcp" + cidr_blocks = ["10.0.0.0/16"] + } + + egress { + from_port = 0 + to_port = 0 + protocol = "-1" + cidr_blocks = ["0.0.0.0/0"] + } } +` +const testAccAwsFsxFileSystemBaseWindowsConfig = ` resource "aws_kms_key" "test" { description = "FSx KMS Testing key" deletion_window_in_days = 7 } resource "aws_directory_service_directory" "test" { - name = "corp.notexample.com" + name = "corp.notexample.com" password = "SuperSecretPassw0rd" - type = "MicrosoftAD" - + type = "MicrosoftAD" + vpc_settings { - vpc_id = "${aws_vpc.test.id}" - subnet_ids = ["${aws_subnet.test1.id}", "${aws_subnet.test2.id}"] + vpc_id = "${aws_vpc.test.id}" + subnet_ids = ["${aws_subnet.test1.id}", "${aws_subnet.test2.id}"] } } +` +func testAccAwsFsxFileSystemLustreBasic() string { + return testAccAwsFsxFileSystemBaseConfig + fmt.Sprintf(` resource "aws_fsx_file_system" "test" { - depends_on = ["aws_subnet.test1", "aws_kms_key.test", "aws_directory_service_directory.test"] - type = "WINDOWS" - capacity = 300 - kms_key_id = "${aws_kms_key.test.arn}" - subnet_ids = ["${aws_subnet.test1.id}"] - - windows_configuration { - active_directory_id = "${aws_directory_service_directory.test.id}" - backup_retention = 3 - copy_tags_to_backups = true - throughput_capacity = 1024 - } + type = "LUSTRE" + capacity = 3600 + subnet_ids = ["${aws_subnet.test1.id}"] + security_group_ids = ["${aws_security_group.test1.id}"] } -` - -const testAccAwsFsxFileSystemWindowsUpdateOpts = ` -resource "aws_vpc" "test" { - cidr_block = "10.0.0.0/16" +`) } -resource "aws_subnet" "test1" { - vpc_id = "${aws_vpc.test.id}" - cidr_block = "10.0.1.0/24" - availability_zone = "us-east-1a" -} +func testAccAwsFsxFileSystemLustreConfigOpts() string { + return testAccAwsFsxFileSystemBaseConfig + fmt.Sprintf(` +resource "aws_fsx_file_system" "test" { + type = "LUSTRE" + capacity = 3600 + subnet_ids = ["${aws_subnet.test1.id}"] -resource "aws_subnet" "test2" { - vpc_id = "${aws_vpc.test.id}" - cidr_block = "10.0.2.0/24" - availability_zone = "us-east-1d" + lustre_configuration { + import_path = "s3://nasanex" + chunk_size = 2048 + } } - -resource "aws_kms_key" "test" { - description = "FSx KMS Testing key" - deletion_window_in_days = 7 +`) } -resource "aws_directory_service_directory" "test" { - name = "corp.notexample.com" - password = "SuperSecretPassw0rd" - type = "MicrosoftAD" - - vpc_settings { - vpc_id = "${aws_vpc.test.id}" - subnet_ids = ["${aws_subnet.test1.id}", "${aws_subnet.test2.id}"] +func testAccAwsFsxFileSystemLustreUpdateOpts() string { + return testAccAwsFsxFileSystemBaseConfig + fmt.Sprintf(` +resource "aws_fsx_file_system" "test" { + type = "LUSTRE" + capacity = 3600 + subnet_ids = ["${aws_subnet.test1.id}"] + + lustre_configuration { + import_path = "s3://nasanex" + chunk_size = 2048 + weekly_maintenance_start_time = "5:05:50" } } +`) +} +func testAccAwsFsxFileSystemWindowsConfigOpts() string { + return testAccAwsFsxFileSystemBaseConfig + testAccAwsFsxFileSystemBaseWindowsConfig + fmt.Sprintf(` resource "aws_fsx_file_system" "test" { - depends_on = ["aws_subnet.test1", "aws_kms_key.test", "aws_directory_service_directory.test"] - type = "WINDOWS" + type = "WINDOWS" capacity = 300 - kms_key_id = "${aws_kms_key.test.arn}" - subnet_ids = ["${aws_subnet.test1.id}"] - - windows_configuration { - active_directory_id = "${aws_directory_service_directory.test.id}" - backup_retention = 30 - copy_tags_to_backups = true - throughput_capacity = 1024 - } + kms_key_id = "${aws_kms_key.test.arn}" + subnet_ids = ["${aws_subnet.test1.id}"] + + windows_configuration { + active_directory_id = "${aws_directory_service_directory.test.id}" + backup_retention = 3 + copy_tags_to_backups = true + throughput_capacity = 1024 + } +} +`) +} + +func testAccAwsFsxFileSystemWindowsUpdateOpts() string { + return testAccAwsFsxFileSystemBaseConfig + testAccAwsFsxFileSystemBaseWindowsConfig + fmt.Sprintf(` +resource "aws_fsx_file_system" "test" { + type = "WINDOWS" + capacity = 300 + kms_key_id = "${aws_kms_key.test.arn}" + subnet_ids = ["${aws_subnet.test1.id}"] + + windows_configuration { + active_directory_id = "${aws_directory_service_directory.test.id}" + backup_retention = 30 + copy_tags_to_backups = true + throughput_capacity = 1024 + } +} +`) } -` diff --git a/website/docs/r/fsx_file_system.html.markdown b/website/docs/r/fsx_file_system.html.markdown index 758e0d0a399..af0280816ae 100644 --- a/website/docs/r/fsx_file_system.html.markdown +++ b/website/docs/r/fsx_file_system.html.markdown @@ -6,7 +6,7 @@ description: |- Provides an FSx filesystem resource. --- -# aws_fsx_file_system +# Resource: aws_fsx_file_system Provides an FSx filesystem resource. @@ -14,31 +14,31 @@ Provides an FSx filesystem resource. ```hcl resource "aws_fsx_file_system" "lustre" { - type = "LUSTRE" - capacity = 3600 - kms_key_id = "${aws_kms_key.example.key_id}" - subnet_ids = ["${aws_subnet.example.id}"] - - lustre_configuration { - import_path = "s3://example-bucket" - chunk_size = 2048 - } + type = "LUSTRE" + capacity = 3600 + kms_key_id = "${aws_kms_key.example.key_id}" + subnet_ids = ["${aws_subnet.example.id}"] + + lustre_configuration { + import_path = "s3://example-bucket" + chunk_size = 2048 + } } ``` ```hcl resource "aws_fsx_file_system" "windows" { - type = "WINDOWS" - capacity = 300 - kms_key_id = "${aws_kms_key.example.arn}" - subnet_ids = ["${aws_subnet.example.id}"] - - windows_configuration { - active_directory_id = "${aws_directory_service_directory.example.id}" - backup_retention = 7 - copy_tags_to_backups = true - throughput_capacity = 1024 - } + type = "WINDOWS" + capacity = 300 + kms_key_id = "${aws_kms_key.example.arn}" + subnet_ids = ["${aws_subnet.example.id}"] + + windows_configuration { + active_directory_id = "${aws_directory_service_directory.example.id}" + backup_retention = 7 + copy_tags_to_backups = true + throughput_capacity = 1024 + } } ``` @@ -46,20 +46,22 @@ resource "aws_fsx_file_system" "windows" { The following arguments are supported: -* `type` - (Required) The type of file system. `LUSTRE` +* `type` - (Required) The type of file system. Valid values: `LUSTRE` or `WINDOWS` * `capacity` - (Required) The storage capacity of the file system. For Windows file systems, the storage capacity has a minimum of 300 GiB, and a maximum of 65,536 GiB. For Lustre file systems, the storage capacity has a minimum of 3,600 GiB. Storage capacity is provisioned in increments of 3,600 GiB. -* `kms_key_id` - (Required) The ARN for the KMS encryption key. +* `kms_key_id` - (Optional) The ARN for the KMS encryption key (For Windows File Servers only). * `subnet_ids` - (Required) A list of IDs for the subnets that the file system will be accessible from. File systems support only one subnet. The file server is also launched in that subnet's Availability Zone. * `security_group_ids` - (Optional) A list of IDs for the security groups that apply to the specified network interfaces created for file system access. These security groups will apply to all network interfaces. * `lustre_configuration` - (Optional) The configuration for this Lustre file system. * `windows_configuration` - (Optional) The configuration for this Microsoft Windows file system. * `tags` - (Optional) A mapping of tags to assign to the file system. +* `timeout` - (Optional) A Terraform specific value dedicated to establishing custom timeouts for varying data import sizes. ## lustre_configuration Attributes for Lustre configuration * `import_path` - (Required) The path to the Amazon S3 bucket (and optional prefix) that you're using as the data repository for your FSx for Lustre file system. +* `export_path` - (Optional) The path in Amazon S3 where the root of your Amazon FSx file system is exported. The path must use the same Amazon S3 bucket as specified in ImportPath. * `chunk_size` - (Optional) For files imported from a data repository, this value determines the stripe count and maximum amount of data per file (in MiB) stored on a single physical disk. * `weekly_maintenance_start_time` - (Optional) The preferred time to perform weekly maintenance, in the UTC time zone. @@ -68,12 +70,24 @@ Attributes for Lustre configuration Attributes for Windows configuration * `active_directory_id` - (Required) The ID for an existing Microsoft Active Directory instance that the file system should join when it's created. +* `self_managed_active_directory` - (Required) The configuration that Amazon FSx uses to join the Windows File Server instance to your self-managed (including on-premises) Microsoft Active Directory (AD) directory. * `backup_retention` - (Optional) The number of days to retain automatic backups. * `copy_tags_to_backups` - (Optional) A boolean flag indicating whether tags on the file system should be copied to backups. * `daily_backup_start_time` - (Optional) The preferred time to take daily automatic backups, in the UTC time zone. * `throughput_capacity` - (Required) The throughput of an Amazon FSx file system, measured in megabytes per second. * `weekly_maintenance_start_time` - (Optional) The preferred start time to perform weekly maintenance, in the UTC time zone. +### self_managed_active_directory + +Attributes for Self Managed Active Directory configuration + +* `domain_name` - (Required) The fully qualified domain name of the self-managed AD directory. +* `username` - (Required) The user name for the service account on your self-managed AD domain that Amazon FSx will use to join to your AD domain. +* `password` - (Required) The password for the service account on your self-managed AD domain that Amazon FSx will use to join to your AD domain. +* `dns_ips` - (Required) A list of up to two IP addresses of DNS servers or domain controllers in the self-managed AD directory. +* `administrators_group` - (Optional) The name of the domain group whose members are granted administrative privileges for the file system. Administrative privileges include taking ownership of files and folders, and setting audit controls (audit ACLs) on files and folders. +* `ou_distinguished_name` - (Optional) The fully qualified distinguished name of the organizational unit within your self-managed AD directory that the Windows File Server instance will join. + ## Attributes Reference In addition to all arguments above, the following attributes are exported: From 8ea615aea6f4010c3479aeabb39ceda97da132c0 Mon Sep 17 00:00:00 2001 From: "Aaron J. Smith" Date: Sun, 11 Aug 2019 23:08:29 -0500 Subject: [PATCH 4/8] a few linter corrections --- aws/resource_aws_fsx_file_system.go | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/aws/resource_aws_fsx_file_system.go b/aws/resource_aws_fsx_file_system.go index c1d0d9bc86d..de469c45dba 100644 --- a/aws/resource_aws_fsx_file_system.go +++ b/aws/resource_aws_fsx_file_system.go @@ -270,7 +270,7 @@ func resourceAwsFsxFileSystemUpdate(d *schema.ResourceData, meta interface{}) er if requestUpdate { _, err := conn.UpdateFileSystem(params) if err != nil { - fmt.Errorf("error updating FSX File System (%s): %s", d.Id(), err) + return fmt.Errorf("error updating FSX File System (%s): %s", d.Id(), err) } } @@ -403,13 +403,6 @@ func fsxStateRefreshFunc(conn *fsx.FSx, id string) resource.StateRefreshFunc { } } -func hasEmptyFsxFileSystems(fs *fsx.DescribeFileSystemsOutput) bool { - if fs != nil && len(fs.FileSystems) > 0 { - return false - } - return true -} - func expandFsxLustreConfigurationCreate(l []interface{}) *fsx.CreateFileSystemLustreConfiguration { if len(l) == 0 || l[0] == nil { return nil From 25e677587da8e9a876f7414fa940c60466fc2205 Mon Sep 17 00:00:00 2001 From: "Aaron J. Smith" Date: Mon, 12 Aug 2019 09:33:45 -0500 Subject: [PATCH 5/8] adding unit tests for fsx tags --- aws/tagsFSX_test.go | 77 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 aws/tagsFSX_test.go diff --git a/aws/tagsFSX_test.go b/aws/tagsFSX_test.go new file mode 100644 index 00000000000..5bf1c309b6e --- /dev/null +++ b/aws/tagsFSX_test.go @@ -0,0 +1,77 @@ +package aws + +import ( + "reflect" + "testing" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/fsx" +) + +func TestDiffFSXTags(t *testing.T) { + cases := []struct { + Old, New map[string]interface{} + Create, Remove map[string]string + }{ + // Basic add/remove + { + Old: map[string]interface{}{ + "foo": "bar", + }, + New: map[string]interface{}{ + "bar": "baz", + }, + Create: map[string]string{ + "bar": "baz", + }, + Remove: map[string]string{ + "foo": "bar", + }, + }, + + // Modify + { + Old: map[string]interface{}{ + "foo": "bar", + }, + New: map[string]interface{}{ + "foo": "baz", + }, + Create: map[string]string{ + "foo": "baz", + }, + Remove: map[string]string{ + "foo": "bar", + }, + }, + } + + for i, tc := range cases { + c, r := diffTagsFSX(tagsFromMapFSX(tc.Old), tagsFromMapFSX(tc.New)) + cm := tagsToMapFSX(c) + rm := tagsToMapFSX(r) + if !reflect.DeepEqual(cm, tc.Create) { + t.Fatalf("%d: bad create: %#v", i, cm) + } + if !reflect.DeepEqual(rm, tc.Remove) { + t.Fatalf("%d: bad remove: %#v", i, rm) + } + } +} + +func TestIgnoringTagsFSX(t *testing.T) { + var ignoredTags []*fsx.Tag + ignoredTags = append(ignoredTags, &fsx.Tag{ + Key: aws.String("aws:cloudformation:logical-id"), + Value: aws.String("foo"), + }) + ignoredTags = append(ignoredTags, &fsx.Tag{ + Key: aws.String("aws:foo:bar"), + Value: aws.String("baz"), + }) + for _, tag := range ignoredTags { + if !tagIgnoredFSX(tag) { + t.Fatalf("Tag %v with value %v not ignored, but should be!", *tag.Key, *tag.Value) + } + } +} From 446a22a6db9fcc46ef8d497bafe967fa3739890b Mon Sep 17 00:00:00 2001 From: Brian Flad Date: Tue, 13 Aug 2019 22:56:14 -0400 Subject: [PATCH 6/8] New Resources: aws_fsx_lustre_file_system and aws_fsx_windows_file_system Reference: https://github.com/terraform-providers/terraform-provider-aws/issues/7035 Reference: https://github.com/terraform-providers/terraform-provider-aws/pull/7074 Builds on #7074 with the following changes: - Split into two separate resources (`aws_fsx_lustre_file_system` and `aws_fsx_windows_file_system`) to simplify practitioner configuration (e.g. lose the required configuration blocks), ease maintenance for resource logic and single file system arguments (e.g. `kms_key_id` only for Windows), and enhance validations (e.g. `storage_capacity` differences between file systems) - Add covering acceptance testing with updates/force new for all arguments - Better alignment with API naming for some arguments (e.g. changing `capacity` into `storage_capacity` to remove ambiguity with `throughput_capacity`) - Implement [resource Customizable Timeouts](https://www.terraform.io/docs/extend/resources/retries-and-customizable-timeouts.html) - Implement `skip_final_backup` argument for Windows - Implement `network_interface_ids`, `owner_id`, and `vpc_id` attributes - Augment resource documentation with additional notes found in [API reference](https://docs.aws.amazon.com/fsx/latest/APIReference/) and clarify `security_group_ids` import behavior Output from acceptance testing: ``` --- PASS: TestAccAWSFsxLustreFileSystem_Tags (458.62s) --- PASS: TestAccAWSFsxLustreFileSystem_basic (526.79s) --- PASS: TestAccAWSFsxLustreFileSystem_disappears (564.58s) --- PASS: TestAccAWSFsxLustreFileSystem_WeeklyMaintenanceStartTime (697.83s) --- PASS: TestAccAWSFsxLustreFileSystem_StorageCapacity (940.13s) --- PASS: TestAccAWSFsxLustreFileSystem_SecurityGroupIds (1074.08s) --- PASS: TestAccAWSFsxLustreFileSystem_ImportedFileChunkSize (1276.18s) --- PASS: TestAccAWSFsxLustreFileSystem_ImportPath (1322.13s) --- PASS: TestAccAWSFsxLustreFileSystem_ExportPath (1338.75s) --- PASS: TestAccAWSFsxWindowsFileSystem_Tags (2256.64s) --- PASS: TestAccAWSFsxWindowsFileSystem_WeeklyMaintenanceStartTime (2346.44s) --- PASS: TestAccAWSFsxWindowsFileSystem_basic (2404.35s) --- PASS: TestAccAWSFsxWindowsFileSystem_disappears (2412.10s) --- PASS: TestAccAWSFsxWindowsFileSystem_AutomaticBackupRetentionDays (2514.61s) --- PASS: TestAccAWSFsxWindowsFileSystem_DailyAutomaticBackupStartTime (2849.43s) --- PASS: TestAccAWSFsxWindowsFileSystem_SelfManagedActiveDirectory (2850.64s) --- PASS: TestAccAWSFsxWindowsFileSystem_ThroughputCapacity (3292.44s) --- PASS: TestAccAWSFsxWindowsFileSystem_SecurityGroupIds (3609.37s) --- PASS: TestAccAWSFsxWindowsFileSystem_KmsKeyId (3977.10s) --- PASS: TestAccAWSFsxWindowsFileSystem_StorageCapacity (4026.67s) --- PASS: TestAccAWSFsxWindowsFileSystem_CopyTagsToBackups (4389.57s) ``` --- aws/fsx.go | 77 ++ aws/provider.go | 3 +- aws/resource_aws_fsx_file_system.go | 649 -------------- aws/resource_aws_fsx_file_system_test.go | 367 -------- aws/resource_aws_fsx_lustre_file_system.go | 296 ++++++ ...esource_aws_fsx_lustre_file_system_test.go | 611 +++++++++++++ aws/resource_aws_fsx_windows_file_system.go | 439 +++++++++ ...source_aws_fsx_windows_file_system_test.go | 846 ++++++++++++++++++ aws/tagsFSX.go | 7 +- aws/tagsFSX_test.go | 33 + website/aws.erb | 14 +- website/docs/r/fsx_file_system.html.markdown | 105 --- .../r/fsx_lustre_file_system.html.markdown | 75 ++ .../r/fsx_windows_file_system.html.markdown | 119 +++ 14 files changed, 2514 insertions(+), 1127 deletions(-) create mode 100644 aws/fsx.go delete mode 100644 aws/resource_aws_fsx_file_system.go delete mode 100644 aws/resource_aws_fsx_file_system_test.go create mode 100644 aws/resource_aws_fsx_lustre_file_system.go create mode 100644 aws/resource_aws_fsx_lustre_file_system_test.go create mode 100644 aws/resource_aws_fsx_windows_file_system.go create mode 100644 aws/resource_aws_fsx_windows_file_system_test.go delete mode 100644 website/docs/r/fsx_file_system.html.markdown create mode 100644 website/docs/r/fsx_lustre_file_system.html.markdown create mode 100644 website/docs/r/fsx_windows_file_system.html.markdown diff --git a/aws/fsx.go b/aws/fsx.go new file mode 100644 index 00000000000..f8c5450b1c9 --- /dev/null +++ b/aws/fsx.go @@ -0,0 +1,77 @@ +package aws + +import ( + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/fsx" + "github.com/hashicorp/terraform/helper/resource" +) + +func describeFsxFileSystem(conn *fsx.FSx, id string) (*fsx.FileSystem, error) { + input := &fsx.DescribeFileSystemsInput{ + FileSystemIds: []*string{aws.String(id)}, + } + var filesystem *fsx.FileSystem + + err := conn.DescribeFileSystemsPages(input, func(page *fsx.DescribeFileSystemsOutput, lastPage bool) bool { + for _, fs := range page.FileSystems { + if aws.StringValue(fs.FileSystemId) == id { + filesystem = fs + return false + } + } + + return !lastPage + }) + + return filesystem, err +} + +func refreshFsxFileSystemLifecycle(conn *fsx.FSx, id string) resource.StateRefreshFunc { + return func() (interface{}, string, error) { + filesystem, err := describeFsxFileSystem(conn, id) + + if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { + return nil, "", nil + } + + if err != nil { + return nil, "", err + } + + if filesystem == nil { + return nil, "", nil + } + + return filesystem, aws.StringValue(filesystem.Lifecycle), nil + } +} + +func waitForFsxFileSystemCreation(conn *fsx.FSx, id string, timeout time.Duration) error { + stateConf := &resource.StateChangeConf{ + Pending: []string{fsx.FileSystemLifecycleCreating}, + Target: []string{fsx.FileSystemLifecycleAvailable}, + Refresh: refreshFsxFileSystemLifecycle(conn, id), + Timeout: timeout, + Delay: 30 * time.Second, + } + + _, err := stateConf.WaitForState() + + return err +} + +func waitForFsxFileSystemDeletion(conn *fsx.FSx, id string, timeout time.Duration) error { + stateConf := &resource.StateChangeConf{ + Pending: []string{fsx.FileSystemLifecycleAvailable, fsx.FileSystemLifecycleDeleting}, + Target: []string{}, + Refresh: refreshFsxFileSystemLifecycle(conn, id), + Timeout: timeout, + Delay: 30 * time.Second, + } + + _, err := stateConf.WaitForState() + + return err +} diff --git a/aws/provider.go b/aws/provider.go index a68aabd43f2..a3597a77c9a 100644 --- a/aws/provider.go +++ b/aws/provider.go @@ -496,7 +496,8 @@ func Provider() terraform.ResourceProvider { "aws_emr_instance_group": resourceAwsEMRInstanceGroup(), "aws_emr_security_configuration": resourceAwsEMRSecurityConfiguration(), "aws_flow_log": resourceAwsFlowLog(), - "aws_fsx_file_system": resourceAwsFsxFileSystem(), + "aws_fsx_lustre_file_system": resourceAwsFsxLustreFileSystem(), + "aws_fsx_windows_file_system": resourceAwsFsxWindowsFileSystem(), "aws_fms_admin_account": resourceAwsFmsAdminAccount(), "aws_gamelift_alias": resourceAwsGameliftAlias(), "aws_gamelift_build": resourceAwsGameliftBuild(), diff --git a/aws/resource_aws_fsx_file_system.go b/aws/resource_aws_fsx_file_system.go deleted file mode 100644 index de469c45dba..00000000000 --- a/aws/resource_aws_fsx_file_system.go +++ /dev/null @@ -1,649 +0,0 @@ -package aws - -import ( - "fmt" - "log" - "time" - - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/fsx" - - "github.com/hashicorp/terraform/helper/resource" - "github.com/hashicorp/terraform/helper/schema" - "github.com/hashicorp/terraform/helper/validation" -) - -func resourceAwsFsxFileSystem() *schema.Resource { - return &schema.Resource{ - Create: resourceAwsFsxFileSystemCreate, - Read: resourceAwsFsxFileSystemRead, - Update: resourceAwsFsxFileSystemUpdate, - Delete: resourceAwsFsxFileSystemDelete, - Importer: &schema.ResourceImporter{ - State: schema.ImportStatePassthrough, - }, - - Schema: map[string]*schema.Schema{ - "type": { - Type: schema.TypeString, - Required: true, - ForceNew: true, - ValidateFunc: validation.StringInSlice([]string{ - fsx.FileSystemTypeLustre, - fsx.FileSystemTypeWindows, - }, false), - }, - "capacity": { - Type: schema.TypeInt, - Required: true, - ForceNew: true, - ValidateFunc: validation.IntAtLeast(300), - }, - "kms_key_id": { - Type: schema.TypeString, - Optional: true, - ForceNew: true, - ConflictsWith: []string{"lustre_configuration"}, - }, - "subnet_ids": { - Type: schema.TypeSet, - Required: true, - ForceNew: true, - Elem: &schema.Schema{Type: schema.TypeString}, - }, - "security_group_ids": { - Type: schema.TypeSet, - Optional: true, - ForceNew: true, - Elem: &schema.Schema{Type: schema.TypeString}, - }, - "timeout": { - Type: schema.TypeInt, - Optional: true, - Default: 120, - ValidateFunc: validation.IntAtLeast(60), - }, - "lustre_configuration": { - Type: schema.TypeList, - Optional: true, - Computed: true, - MaxItems: 1, - ConflictsWith: []string{"windows_configuration"}, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "import_path": { - Type: schema.TypeString, - Optional: true, - ForceNew: true, - }, - "export_path": { - Type: schema.TypeString, - Optional: true, - Computed: true, - ForceNew: true, - }, - "chunk_size": { - Type: schema.TypeInt, - Optional: true, - ForceNew: true, - }, - "weekly_maintenance_start_time": { - Type: schema.TypeString, - Optional: true, - Computed: true, - }, - }, - }, - }, - "windows_configuration": { - Type: schema.TypeList, - Optional: true, - Computed: true, - MaxItems: 1, - ConflictsWith: []string{"lustre_configuration"}, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "active_directory_id": { - Type: schema.TypeString, - Optional: true, - ForceNew: true, - }, - "self_managed_active_directory": { - Type: schema.TypeList, - Optional: true, - MaxItems: 1, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "username": { - Type: schema.TypeString, - Required: true, - }, - "password": { - Type: schema.TypeString, - Required: true, - }, - "dns_ips": { - Type: schema.TypeSet, - Required: true, - Elem: &schema.Schema{Type: schema.TypeString}, - }, - "domain_name": { - Type: schema.TypeString, - Required: true, - }, - "administrators_group": { - Type: schema.TypeString, - Optional: true, - }, - "ou_distinguished_name": { - Type: schema.TypeString, - Optional: true, - }, - }, - }, - }, - "backup_retention": { - Type: schema.TypeInt, - Optional: true, - Default: 7, - ValidateFunc: validation.IntBetween(0, 35), - }, - "copy_tags_to_backups": { - Type: schema.TypeBool, - Optional: true, - Default: false, - ForceNew: true, - }, - "daily_backup_start_time": { - Type: schema.TypeString, - Optional: true, - Computed: true, - }, - "throughput_capacity": { - Type: schema.TypeInt, - Required: true, - ForceNew: true, - }, - "weekly_maintenance_start_time": { - Type: schema.TypeString, - Optional: true, - Computed: true, - }, - }, - }, - }, - "arn": { - Type: schema.TypeString, - Computed: true, - }, - "dns_name": { - Type: schema.TypeString, - Computed: true, - }, - "tags": tagsSchema(), - }, - } -} - -func resourceAwsFsxFileSystemCreate(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).fsxconn - - request := &fsx.CreateFileSystemInput{ - FileSystemType: aws.String(d.Get("type").(string)), - StorageCapacity: aws.Int64(int64(d.Get("capacity").(int))), - SubnetIds: expandStringList(d.Get("subnet_ids").(*schema.Set).List()), - } - - if _, ok := d.GetOk("kms_key_id"); ok { - request.KmsKeyId = aws.String(d.Get("kms_key_id").(string)) - } - - if _, ok := d.GetOk("security_group_ids"); ok { - request.SecurityGroupIds = expandStringList(d.Get("security_group_ids").(*schema.Set).List()) - } - - if _, ok := d.GetOk("lustre_configuration"); ok { - request.LustreConfiguration = expandFsxLustreConfigurationCreate(d.Get("lustre_configuration").([]interface{})) - } - - if _, ok := d.GetOk("windows_configuration"); ok { - request.WindowsConfiguration = expandFsxWindowsConfigurationCreate(d.Get("windows_configuration").([]interface{})) - } - - if value, ok := d.GetOk("tags"); ok { - request.Tags = tagsFromMapFSX(value.(map[string]interface{})) - } - - log.Printf("[DEBUG] FSx Filesystem create opts: %s", request) - result, err := conn.CreateFileSystem(request) - if err != nil { - return fmt.Errorf("Error creating FSx filesystem: %s", err) - } - - d.SetId(*result.FileSystem.FileSystemId) - - log.Println("[DEBUG] Waiting for filesystem to become available") - - stateConf := &resource.StateChangeConf{ - Pending: []string{fsx.FileSystemLifecycleCreating}, - Target: []string{fsx.FileSystemLifecycleAvailable}, - Refresh: fsxStateRefreshFunc(conn, d.Id()), - Timeout: time.Duration(d.Get("timeout").(int)) * time.Minute, - Delay: 30 * time.Second, - MinTimeout: 15 * time.Second, - } - - _, err = stateConf.WaitForState() - if err != nil { - return fmt.Errorf( - "Error waiting for filesystem (%s) to become available: %s", - *result.FileSystem.FileSystemId, err) - } - - return resourceAwsFsxFileSystemRead(d, meta) -} - -func resourceAwsFsxFileSystemUpdate(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).fsxconn - - if d.HasChange("tags") { - if err := setTagsFSX(conn, d); err != nil { - return fmt.Errorf("Error updating tags for FSx filesystem: %s", err) - } - } - - requestUpdate := false - params := &fsx.UpdateFileSystemInput{ - FileSystemId: aws.String(d.Id()), - } - - if d.HasChange("lustre_configuration") { - params.LustreConfiguration = expandFsxLustreConfigurationUpdate(d.Get("lustre_configuration").([]interface{})) - requestUpdate = true - } - - if d.HasChange("windows_configuration") { - params.WindowsConfiguration = expandFsxWindowsConfigurationUpdate(d.Get("windows_configuration").([]interface{})) - requestUpdate = true - } - - if requestUpdate { - _, err := conn.UpdateFileSystem(params) - if err != nil { - return fmt.Errorf("error updating FSX File System (%s): %s", d.Id(), err) - } - } - - return resourceAwsFsxFileSystemRead(d, meta) -} - -func resourceAwsFsxFileSystemRead(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).fsxconn - - filesystem, err := describeFsxFileSystem(conn, d.Id()) - - if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { - log.Printf("[WARN] FSx File System (%s) not found, removing from state", d.Id()) - d.SetId("") - return nil - } - - if err != nil { - return fmt.Errorf("Error reading FSx File System (%s): %s", d.Id(), err) - } - - if filesystem == nil { - log.Printf("[WARN] FSx File System (%s) not found, removing from state", d.Id()) - d.SetId("") - return nil - } - - d.Set("type", filesystem.FileSystemType) - d.Set("capacity", filesystem.StorageCapacity) - d.Set("arn", filesystem.ResourceARN) - d.Set("dns_name", filesystem.DNSName) - d.Set("kms_key_id", filesystem.KmsKeyId) - - d.Set("tags", tagsToMapFSX(filesystem.Tags)) - - err = d.Set("lustre_configuration", flattenLustreOptsConfig(filesystem.LustreConfiguration)) - if err != nil { - return err - } - - err = d.Set("windows_configuration", flattenWindowsOptsConfig(filesystem.WindowsConfiguration)) - if err != nil { - return err - } - - err = d.Set("subnet_ids", aws.StringValueSlice(filesystem.SubnetIds)) - if err != nil { - return err - } - - err = d.Set("security_group_ids", expandStringList(d.Get("security_group_ids").(*schema.Set).List())) - if err != nil { - return err - } - - return nil -} - -func resourceAwsFsxFileSystemDelete(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).fsxconn - - request := &fsx.DeleteFileSystemInput{ - FileSystemId: aws.String(d.Id()), - } - - _, err := conn.DeleteFileSystem(request) - if err != nil { - return fmt.Errorf("Error deleting FSx filesystem: %s", err) - } - - log.Println("[DEBUG] Waiting for filesystem to delete") - - stateConf := &resource.StateChangeConf{ - Pending: []string{fsx.FileSystemLifecycleAvailable, fsx.FileSystemLifecycleDeleting}, - Target: []string{}, - Refresh: fsxStateRefreshFunc(conn, d.Id()), - Timeout: time.Duration(d.Get("timeout").(int)) * time.Minute, - Delay: 30 * time.Second, - MinTimeout: 15 * time.Second, - } - - _, err = stateConf.WaitForState() - if err != nil { - return fmt.Errorf("Error waiting for filesystem (%s) to delete: %s", d.Id(), err) - } - - return nil -} - -func describeFsxFileSystem(conn *fsx.FSx, id string) (*fsx.FileSystem, error) { - input := &fsx.DescribeFileSystemsInput{ - FileSystemIds: []*string{aws.String(id)}, - } - var filesystem *fsx.FileSystem - - err := conn.DescribeFileSystemsPages(input, func(page *fsx.DescribeFileSystemsOutput, lastPage bool) bool { - for _, fs := range page.FileSystems { - if aws.StringValue(fs.FileSystemId) == id { - filesystem = fs - break - } - } - - return !lastPage - }) - - return filesystem, err -} - -func fsxStateRefreshFunc(conn *fsx.FSx, id string) resource.StateRefreshFunc { - return func() (interface{}, string, error) { - resp, err := conn.DescribeFileSystems(&fsx.DescribeFileSystemsInput{ - FileSystemIds: []*string{aws.String(id)}, - }) - - if resp == nil { - return nil, "", nil - } - - if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { - return nil, "", nil - } - - if err != nil { - return nil, "", err - } - - filesystem := resp.FileSystems[0] - return filesystem, *filesystem.Lifecycle, nil - } -} - -func expandFsxLustreConfigurationCreate(l []interface{}) *fsx.CreateFileSystemLustreConfiguration { - if len(l) == 0 || l[0] == nil { - return nil - } - - data := l[0].(map[string]interface{}) - req := &fsx.CreateFileSystemLustreConfiguration{} - - if data["import_path"].(string) != "" { - req.ImportPath = aws.String(data["import_path"].(string)) - } - - if data["export_path"].(string) != "" { - req.ExportPath = aws.String(data["export_path"].(string)) - } - - if data["chunk_size"] != nil { - req.ImportedFileChunkSize = aws.Int64(int64(data["chunk_size"].(int))) - } - - if data["weekly_maintenance_start_time"].(string) != "" { - req.WeeklyMaintenanceStartTime = aws.String(data["weekly_maintenance_start_time"].(string)) - } - - return req -} - -func expandFsxLustreConfigurationUpdate(l []interface{}) *fsx.UpdateFileSystemLustreConfiguration { - if len(l) == 0 || l[0] == nil { - return nil - } - - data := l[0].(map[string]interface{}) - req := &fsx.UpdateFileSystemLustreConfiguration{} - - if data["weekly_maintenance_start_time"].(string) != "" { - req.WeeklyMaintenanceStartTime = aws.String(data["weekly_maintenance_start_time"].(string)) - } - - return req -} - -func expandFsxWindowsConfigurationCreate(l []interface{}) *fsx.CreateFileSystemWindowsConfiguration { - if len(l) == 0 || l[0] == nil { - return nil - } - - data := l[0].(map[string]interface{}) - req := &fsx.CreateFileSystemWindowsConfiguration{ - ThroughputCapacity: aws.Int64(int64(data["throughput_capacity"].(int))), - } - - if data["active_directory_id"].(string) != "" { - req.ActiveDirectoryId = aws.String(data["active_directory_id"].(string)) - } - - if data["self_managed_active_directory"] != nil { - req.SelfManagedActiveDirectoryConfiguration = expandSelfManagedAdOptsCreate(data["self_managed_active_directory"].([]interface{})) - } - - if data["backup_retention"] != nil { - req.AutomaticBackupRetentionDays = aws.Int64(int64(data["backup_retention"].(int))) - } - - if data["copy_tags_to_backups"] != nil { - req.CopyTagsToBackups = aws.Bool(data["copy_tags_to_backups"].(bool)) - } - - if data["daily_backup_start_time"].(string) != "" { - req.DailyAutomaticBackupStartTime = aws.String(data["daily_backup_start_time"].(string)) - } - - if data["weekly_maintenance_start_time"].(string) != "" { - req.WeeklyMaintenanceStartTime = aws.String(data["weekly_maintenance_start_time"].(string)) - } - - return req -} - -func expandFsxWindowsConfigurationUpdate(l []interface{}) *fsx.UpdateFileSystemWindowsConfiguration { - if len(l) == 0 || l[0] == nil { - return nil - } - - data := l[0].(map[string]interface{}) - req := &fsx.UpdateFileSystemWindowsConfiguration{} - - if data["backup_retention"] != nil { - req.AutomaticBackupRetentionDays = aws.Int64(int64(data["backup_retention"].(int))) - } - - if data["daily_backup_start_time"].(string) != "" { - req.DailyAutomaticBackupStartTime = aws.String(data["daily_backup_start_time"].(string)) - } - - if data["weekly_maintenance_start_time"].(string) != "" { - req.WeeklyMaintenanceStartTime = aws.String(data["weekly_maintenance_start_time"].(string)) - } - - if data["self_managed_active_directory"] != nil { - req.SelfManagedActiveDirectoryConfiguration = expandSelfManagedAdOptsUpdate(data["self_managed_active_directory"].([]interface{})) - } - - return req -} - -func expandSelfManagedAdOptsCreate(l []interface{}) *fsx.SelfManagedActiveDirectoryConfiguration { - if len(l) == 0 || l[0] == nil { - return nil - } - - data := l[0].(map[string]interface{}) - req := &fsx.SelfManagedActiveDirectoryConfiguration{} - - if d, ok := data["dns_ips"]; ok { - req.DnsIps = expandStringList(d.([]interface{})) - } - - if data["domain_name"].(string) != "" { - req.DomainName = aws.String(data["domain_name"].(string)) - } - - if data["administrators_group"].(string) != "" { - req.FileSystemAdministratorsGroup = aws.String(data["administrators_group"].(string)) - } - - if data["ou_distinguished_name"].(string) != "" { - req.OrganizationalUnitDistinguishedName = aws.String(data["ou_distinguished_name"].(string)) - } - - if data["password"].(string) != "" { - req.Password = aws.String(data["password"].(string)) - } - - if data["username"].(string) != "" { - req.UserName = aws.String(data["username"].(string)) - } - - return req -} - -func expandSelfManagedAdOptsUpdate(l []interface{}) *fsx.SelfManagedActiveDirectoryConfigurationUpdates { - if len(l) == 0 || l[0] == nil { - return nil - } - - data := l[0].(map[string]interface{}) - req := &fsx.SelfManagedActiveDirectoryConfigurationUpdates{} - - if d, ok := data["dns_ips"]; ok { - req.DnsIps = expandStringList(d.([]interface{})) - } - - if data["password"].(string) != "" { - req.Password = aws.String(data["password"].(string)) - } - - if data["username"].(string) != "" { - req.UserName = aws.String(data["username"].(string)) - } - - return req -} - -func flattenLustreOptsConfig(lopts *fsx.LustreFileSystemConfiguration) []map[string]interface{} { - if lopts == nil { - return []map[string]interface{}{} - } - - m := map[string]interface{}{} - - if lopts.DataRepositoryConfiguration != nil && *lopts.DataRepositoryConfiguration.ImportPath != "" { - m["import_path"] = aws.StringValue(lopts.DataRepositoryConfiguration.ImportPath) - } - if lopts.DataRepositoryConfiguration != nil && *lopts.DataRepositoryConfiguration.ExportPath != "" { - m["export_path"] = aws.StringValue(lopts.DataRepositoryConfiguration.ExportPath) - } - if lopts.DataRepositoryConfiguration != nil && *lopts.DataRepositoryConfiguration.ImportedFileChunkSize != 0 { - m["chunk_size"] = aws.Int64Value(lopts.DataRepositoryConfiguration.ImportedFileChunkSize) - } - if lopts.WeeklyMaintenanceStartTime != nil { - m["weekly_maintenance_start_time"] = aws.StringValue(lopts.WeeklyMaintenanceStartTime) - } - - return []map[string]interface{}{m} -} - -func flattenWindowsOptsConfig(wopts *fsx.WindowsFileSystemConfiguration) []map[string]interface{} { - if wopts == nil { - return []map[string]interface{}{} - } - - m := map[string]interface{}{} - - if wopts.ActiveDirectoryId != nil { - m["active_directory_id"] = aws.StringValue(wopts.ActiveDirectoryId) - } - if wopts.AutomaticBackupRetentionDays != nil { - m["backup_retention"] = aws.Int64Value(wopts.AutomaticBackupRetentionDays) - } - if wopts.CopyTagsToBackups != nil { - m["copy_tags_to_backups"] = aws.BoolValue(wopts.CopyTagsToBackups) - } - if wopts.DailyAutomaticBackupStartTime != nil { - m["daily_backup_start_time"] = aws.StringValue(wopts.DailyAutomaticBackupStartTime) - } - if wopts.ThroughputCapacity != nil { - m["throughput_capacity"] = aws.Int64Value(wopts.ThroughputCapacity) - } - if wopts.WeeklyMaintenanceStartTime != nil { - m["weekly_maintenance_start_time"] = aws.StringValue(wopts.WeeklyMaintenanceStartTime) - } - if wopts.SelfManagedActiveDirectoryConfiguration != nil { - m["self_managed_active_directory"] = flattenSelfManagedAdOptsConfig(wopts.SelfManagedActiveDirectoryConfiguration) - } - - return []map[string]interface{}{m} -} - -func flattenSelfManagedAdOptsConfig(adopts *fsx.SelfManagedActiveDirectoryAttributes) []map[string]interface{} { - if adopts == nil { - return []map[string]interface{}{} - } - - m := map[string]interface{}{} - - if adopts.UserName != nil { - m["username"] = aws.StringValue(adopts.UserName) - } - if adopts.DnsIps != nil { - m["dns_ips"] = aws.StringValueSlice(adopts.DnsIps) - } - if adopts.DomainName != nil { - m["domain_name"] = aws.StringValue(adopts.DomainName) - } - if adopts.FileSystemAdministratorsGroup != nil { - m["administrators_group"] = aws.StringValue(adopts.FileSystemAdministratorsGroup) - } - if adopts.OrganizationalUnitDistinguishedName != nil { - m["ou_distinguished_name"] = aws.StringValue(adopts.OrganizationalUnitDistinguishedName) - } - - return []map[string]interface{}{m} -} diff --git a/aws/resource_aws_fsx_file_system_test.go b/aws/resource_aws_fsx_file_system_test.go deleted file mode 100644 index 5c6cd0b2955..00000000000 --- a/aws/resource_aws_fsx_file_system_test.go +++ /dev/null @@ -1,367 +0,0 @@ -package aws - -import ( - "fmt" - "testing" - - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/fsx" - "github.com/hashicorp/terraform/helper/resource" - "github.com/hashicorp/terraform/terraform" -) - -func TestAccAWSFsxFileSystem_lustreBasic(t *testing.T) { - var v fsx.FileSystem - resourceName := "aws_fsx_file_system.test" - - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - IDRefreshName: resourceName, - Providers: testAccProviders, - CheckDestroy: testAccCheckFsxFileSystemDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAwsFsxFileSystemLustreBasic(), - Check: resource.ComposeTestCheckFunc( - testAccCheckFileSystemExists(resourceName, &v), - resource.TestCheckResourceAttr(resourceName, "type", "LUSTRE"), - resource.TestCheckResourceAttr(resourceName, "capacity", "3600"), - resource.TestCheckResourceAttr(resourceName, "subnet_ids.#", "1"), - resource.TestCheckResourceAttr(resourceName, "security_group_ids.#", "1"), - ), - }, - { - ResourceName: resourceName, - ImportState: true, - ImportStateVerify: true, - ImportStateVerifyIgnore: []string{"timeout", "security_group_ids"}, - }, - }, - }) -} - -func TestAccAWSFsxFileSystem_lustreConfig(t *testing.T) { - var v fsx.FileSystem - resourceName := "aws_fsx_file_system.test" - - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - Providers: testAccProviders, - CheckDestroy: testAccCheckFsxFileSystemDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAwsFsxFileSystemLustreConfigOpts(), - Check: resource.ComposeTestCheckFunc( - testAccCheckFileSystemExists(resourceName, &v), - resource.TestCheckResourceAttr(resourceName, "lustre_configuration.#", "1"), - resource.TestCheckResourceAttr(resourceName, "lustre_configuration.0.import_path", "s3://nasanex"), - resource.TestCheckResourceAttr(resourceName, "lustre_configuration.0.chunk_size", "2048"), - ), - }, - { - ResourceName: resourceName, - ImportState: true, - ImportStateVerify: true, - ImportStateVerifyIgnore: []string{"timeout", "security_group_ids"}, - }, - }, - }) -} - -func TestAccAWSFsxFileSystem_lustreUpdate(t *testing.T) { - var v fsx.FileSystem - resourceName := "aws_fsx_file_system.test" - - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - Providers: testAccProviders, - CheckDestroy: testAccCheckFsxFileSystemDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAwsFsxFileSystemLustreConfigOpts(), - Check: resource.ComposeTestCheckFunc( - testAccCheckFileSystemExists(resourceName, &v), - resource.TestCheckResourceAttr(resourceName, "lustre_configuration.#", "1"), - resource.TestCheckResourceAttrSet(resourceName, "lustre_configuration.0.weekly_maintenance_start_time"), - ), - }, - { - Config: testAccAwsFsxFileSystemLustreUpdateOpts(), - Check: resource.ComposeTestCheckFunc( - testAccCheckFileSystemExists(resourceName, &v), - resource.TestCheckResourceAttr(resourceName, "lustre_configuration.#", "1"), - resource.TestCheckResourceAttr(resourceName, "lustre_configuration.0.weekly_maintenance_start_time", "5:05:50"), - ), - }, - }, - }) -} - -func TestAccAWSFsxFileSystem_windowsConfig(t *testing.T) { - var v fsx.FileSystem - resourceName := "aws_fsx_file_system.test" - - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - Providers: testAccProviders, - CheckDestroy: testAccCheckFsxFileSystemDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAwsFsxFileSystemWindowsConfigOpts(), - Check: resource.ComposeTestCheckFunc( - testAccCheckFileSystemExists(resourceName, &v), - resource.TestCheckResourceAttr(resourceName, "windows_configuration.#", "1"), - resource.TestCheckResourceAttr(resourceName, "windows_configuration.0.backup_retention", "3"), - resource.TestCheckResourceAttr(resourceName, "windows_configuration.0.copy_tags_to_backups", "true"), - resource.TestCheckResourceAttr(resourceName, "windows_configuration.0.throughput_capacity", "1024"), - ), - }, - { - ResourceName: resourceName, - ImportState: true, - ImportStateVerify: true, - ImportStateVerifyIgnore: []string{"timeout", "security_group_ids"}, - }, - }, - }) -} - -func TestAccAWSFsxFileSystem_windowsUpdate(t *testing.T) { - var v fsx.FileSystem - resourceName := "aws_fsx_file_system.test" - - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - Providers: testAccProviders, - CheckDestroy: testAccCheckFsxFileSystemDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAwsFsxFileSystemWindowsConfigOpts(), - Check: resource.ComposeTestCheckFunc( - testAccCheckFileSystemExists(resourceName, &v), - resource.TestCheckResourceAttr(resourceName, "windows_configuration.#", "1"), - resource.TestCheckResourceAttr(resourceName, "windows_configuration.0.backup_retention", "3"), - ), - }, - { - Config: testAccAwsFsxFileSystemWindowsUpdateOpts(), - Check: resource.ComposeTestCheckFunc( - testAccCheckFileSystemExists(resourceName, &v), - resource.TestCheckResourceAttr(resourceName, "windows_configuration.#", "1"), - resource.TestCheckResourceAttr(resourceName, "windows_configuration.0.backup_retention", "30"), - ), - }, - }, - }) -} - -func testAccCheckFileSystemExists(n string, v *fsx.FileSystem) resource.TestCheckFunc { - return func(s *terraform.State) error { - rs, ok := s.RootModule().Resources[n] - if !ok { - return fmt.Errorf("Not found: %s", n) - } - - if rs.Primary.ID == "" { - return fmt.Errorf("No ID is set") - } - - conn := testAccProvider.Meta().(*AWSClient).fsxconn - - request := &fsx.DescribeFileSystemsInput{ - FileSystemIds: []*string{aws.String(rs.Primary.ID)}, - } - - response, err := conn.DescribeFileSystems(request) - if err == nil { - if response.FileSystems != nil && len(response.FileSystems) > 0 { - *v = *response.FileSystems[0] - return nil - } - } - return fmt.Errorf("Error finding FSx filesystem %s", rs.Primary.ID) - } -} - -func testAccCheckFsxFileSystemDestroy(s *terraform.State) error { - conn := testAccProvider.Meta().(*AWSClient).fsxconn - - for _, rs := range s.RootModule().Resources { - if rs.Type != "aws_fsx_file_system" { - continue - } - - filesystem, err := describeFsxFileSystem(conn, rs.Primary.ID) - - if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { - continue - } - - if err != nil { - return err - } - - if filesystem != nil { - return fmt.Errorf("FSx File System (%s) still exists", rs.Primary.ID) - } - } - return nil -} - -const testAccAwsFsxFileSystemBaseConfig = ` -data "aws_availability_zones" "available" { - state = "available" -} - -resource "aws_vpc" "test" { - cidr_block = "10.0.0.0/16" -} - -resource "aws_subnet" "test1" { - vpc_id = "${aws_vpc.test.id}" - cidr_block = "10.0.1.0/24" - availability_zone = "${data.aws_availability_zones.available.names[0]}" -} - -resource "aws_subnet" "test2" { - vpc_id = "${aws_vpc.test.id}" - cidr_block = "10.0.2.0/24" - availability_zone = "${data.aws_availability_zones.available.names[1]}" -} - -resource "aws_security_group" "test1" { - description = "security group for FSx testing" - vpc_id = "${aws_vpc.test.id}" - - ingress { - from_port = 988 - to_port = 988 - protocol = "tcp" - cidr_blocks = ["10.0.0.0/16"] - } - - ingress { - from_port = 135 - to_port = 135 - protocol = "tcp" - cidr_blocks = ["10.0.0.0/16"] - } - - ingress { - from_port = 445 - to_port = 445 - protocol = "tcp" - cidr_blocks = ["10.0.0.0/16"] - } - - ingress { - from_port = 55555 - to_port = 55555 - protocol = "tcp" - cidr_blocks = ["10.0.0.0/16"] - } - - egress { - from_port = 0 - to_port = 0 - protocol = "-1" - cidr_blocks = ["0.0.0.0/0"] - } -} -` - -const testAccAwsFsxFileSystemBaseWindowsConfig = ` -resource "aws_kms_key" "test" { - description = "FSx KMS Testing key" - deletion_window_in_days = 7 -} - -resource "aws_directory_service_directory" "test" { - name = "corp.notexample.com" - password = "SuperSecretPassw0rd" - type = "MicrosoftAD" - - vpc_settings { - vpc_id = "${aws_vpc.test.id}" - subnet_ids = ["${aws_subnet.test1.id}", "${aws_subnet.test2.id}"] - } -} -` - -func testAccAwsFsxFileSystemLustreBasic() string { - return testAccAwsFsxFileSystemBaseConfig + fmt.Sprintf(` -resource "aws_fsx_file_system" "test" { - type = "LUSTRE" - capacity = 3600 - subnet_ids = ["${aws_subnet.test1.id}"] - security_group_ids = ["${aws_security_group.test1.id}"] -} -`) -} - -func testAccAwsFsxFileSystemLustreConfigOpts() string { - return testAccAwsFsxFileSystemBaseConfig + fmt.Sprintf(` -resource "aws_fsx_file_system" "test" { - type = "LUSTRE" - capacity = 3600 - subnet_ids = ["${aws_subnet.test1.id}"] - - lustre_configuration { - import_path = "s3://nasanex" - chunk_size = 2048 - } -} -`) -} - -func testAccAwsFsxFileSystemLustreUpdateOpts() string { - return testAccAwsFsxFileSystemBaseConfig + fmt.Sprintf(` -resource "aws_fsx_file_system" "test" { - type = "LUSTRE" - capacity = 3600 - subnet_ids = ["${aws_subnet.test1.id}"] - - lustre_configuration { - import_path = "s3://nasanex" - chunk_size = 2048 - weekly_maintenance_start_time = "5:05:50" - } -} -`) -} - -func testAccAwsFsxFileSystemWindowsConfigOpts() string { - return testAccAwsFsxFileSystemBaseConfig + testAccAwsFsxFileSystemBaseWindowsConfig + fmt.Sprintf(` -resource "aws_fsx_file_system" "test" { - type = "WINDOWS" - capacity = 300 - kms_key_id = "${aws_kms_key.test.arn}" - subnet_ids = ["${aws_subnet.test1.id}"] - - windows_configuration { - active_directory_id = "${aws_directory_service_directory.test.id}" - backup_retention = 3 - copy_tags_to_backups = true - throughput_capacity = 1024 - } -} -`) -} - -func testAccAwsFsxFileSystemWindowsUpdateOpts() string { - return testAccAwsFsxFileSystemBaseConfig + testAccAwsFsxFileSystemBaseWindowsConfig + fmt.Sprintf(` -resource "aws_fsx_file_system" "test" { - type = "WINDOWS" - capacity = 300 - kms_key_id = "${aws_kms_key.test.arn}" - subnet_ids = ["${aws_subnet.test1.id}"] - - windows_configuration { - active_directory_id = "${aws_directory_service_directory.test.id}" - backup_retention = 30 - copy_tags_to_backups = true - throughput_capacity = 1024 - } -} -`) -} diff --git a/aws/resource_aws_fsx_lustre_file_system.go b/aws/resource_aws_fsx_lustre_file_system.go new file mode 100644 index 00000000000..f9ac456c0f1 --- /dev/null +++ b/aws/resource_aws_fsx_lustre_file_system.go @@ -0,0 +1,296 @@ +package aws + +import ( + "fmt" + "log" + "regexp" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/fsx" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/helper/schema" + "github.com/hashicorp/terraform/helper/validation" +) + +func resourceAwsFsxLustreFileSystem() *schema.Resource { + return &schema.Resource{ + Create: resourceAwsFsxLustreFileSystemCreate, + Read: resourceAwsFsxLustreFileSystemRead, + Update: resourceAwsFsxLustreFileSystemUpdate, + Delete: resourceAwsFsxLustreFileSystemDelete, + Importer: &schema.ResourceImporter{ + State: schema.ImportStatePassthrough, + }, + + Timeouts: &schema.ResourceTimeout{ + Create: schema.DefaultTimeout(30 * time.Minute), + Delete: schema.DefaultTimeout(30 * time.Minute), + }, + + Schema: map[string]*schema.Schema{ + "arn": { + Type: schema.TypeString, + Computed: true, + }, + "dns_name": { + Type: schema.TypeString, + Computed: true, + }, + "export_path": { + Type: schema.TypeString, + Optional: true, + Computed: true, + ForceNew: true, + ValidateFunc: validation.All( + validation.StringLenBetween(3, 900), + validation.StringMatch(regexp.MustCompile(`^s3://`), "must begin with s3://"), + ), + }, + "import_path": { + Type: schema.TypeString, + Optional: true, + ForceNew: true, + ValidateFunc: validation.All( + validation.StringLenBetween(3, 900), + validation.StringMatch(regexp.MustCompile(`^s3://`), "must begin with s3://"), + ), + }, + "imported_file_chunk_size": { + Type: schema.TypeInt, + Optional: true, + Computed: true, + ForceNew: true, + ValidateFunc: validation.IntBetween(1, 512000), + }, + "network_interface_ids": { + Type: schema.TypeSet, + Computed: true, + Elem: &schema.Schema{Type: schema.TypeString}, + }, + "owner_id": { + Type: schema.TypeString, + Computed: true, + }, + "security_group_ids": { + Type: schema.TypeSet, + Optional: true, + ForceNew: true, + MaxItems: 50, + Elem: &schema.Schema{Type: schema.TypeString}, + }, + "storage_capacity": { + Type: schema.TypeInt, + Required: true, + ForceNew: true, + ValidateFunc: validation.IntAtLeast(3600), + }, + "subnet_ids": { + Type: schema.TypeSet, + Required: true, + ForceNew: true, + MinItems: 1, + MaxItems: 1, + Elem: &schema.Schema{Type: schema.TypeString}, + }, + "tags": tagsSchema(), + "vpc_id": { + Type: schema.TypeString, + Computed: true, + }, + "weekly_maintenance_start_time": { + Type: schema.TypeString, + Optional: true, + Computed: true, + ValidateFunc: validation.All( + validation.StringLenBetween(7, 7), + validation.StringMatch(regexp.MustCompile(`^[1-7]:([01]\d|2[0-3]):?([0-5]\d)$`), "must be in the format d:HH:MM"), + ), + }, + }, + } +} + +func resourceAwsFsxLustreFileSystemCreate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).fsxconn + + input := &fsx.CreateFileSystemInput{ + ClientRequestToken: aws.String(resource.UniqueId()), + FileSystemType: aws.String(fsx.FileSystemTypeLustre), + StorageCapacity: aws.Int64(int64(d.Get("storage_capacity").(int))), + SubnetIds: expandStringSet(d.Get("subnet_ids").(*schema.Set)), + } + + if v, ok := d.GetOk("export_path"); ok { + if input.LustreConfiguration == nil { + input.LustreConfiguration = &fsx.CreateFileSystemLustreConfiguration{} + } + + input.LustreConfiguration.ExportPath = aws.String(v.(string)) + } + + if v, ok := d.GetOk("import_path"); ok { + if input.LustreConfiguration == nil { + input.LustreConfiguration = &fsx.CreateFileSystemLustreConfiguration{} + } + + input.LustreConfiguration.ImportPath = aws.String(v.(string)) + } + + if v, ok := d.GetOk("imported_file_chunk_size"); ok { + if input.LustreConfiguration == nil { + input.LustreConfiguration = &fsx.CreateFileSystemLustreConfiguration{} + } + + input.LustreConfiguration.ImportedFileChunkSize = aws.Int64(int64(v.(int))) + } + + if v, ok := d.GetOk("security_group_ids"); ok { + input.SecurityGroupIds = expandStringSet(v.(*schema.Set)) + } + + if v, ok := d.GetOk("tags"); ok { + input.Tags = tagsFromMapFSX(v.(map[string]interface{})) + } + + if v, ok := d.GetOk("weekly_maintenance_start_time"); ok { + if input.LustreConfiguration == nil { + input.LustreConfiguration = &fsx.CreateFileSystemLustreConfiguration{} + } + + input.LustreConfiguration.WeeklyMaintenanceStartTime = aws.String(v.(string)) + } + + result, err := conn.CreateFileSystem(input) + if err != nil { + return fmt.Errorf("Error creating FSx filesystem: %s", err) + } + + d.SetId(*result.FileSystem.FileSystemId) + + log.Println("[DEBUG] Waiting for filesystem to become available") + + if err := waitForFsxFileSystemCreation(conn, d.Id(), d.Timeout(schema.TimeoutCreate)); err != nil { + return fmt.Errorf("Error waiting for filesystem (%s) to become available: %s", d.Id(), err) + } + + return resourceAwsFsxLustreFileSystemRead(d, meta) +} + +func resourceAwsFsxLustreFileSystemUpdate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).fsxconn + + if d.HasChange("tags") { + if err := setTagsFSX(conn, d); err != nil { + return fmt.Errorf("Error updating tags for FSx filesystem: %s", err) + } + } + + requestUpdate := false + input := &fsx.UpdateFileSystemInput{ + ClientRequestToken: aws.String(resource.UniqueId()), + FileSystemId: aws.String(d.Id()), + LustreConfiguration: &fsx.UpdateFileSystemLustreConfiguration{}, + } + + if d.HasChange("weekly_maintenance_start_time") { + input.LustreConfiguration.WeeklyMaintenanceStartTime = aws.String(d.Get("weekly_maintenance_start_time").(string)) + requestUpdate = true + } + + if requestUpdate { + _, err := conn.UpdateFileSystem(input) + if err != nil { + return fmt.Errorf("error updating FSX File System (%s): %s", d.Id(), err) + } + } + + return resourceAwsFsxLustreFileSystemRead(d, meta) +} + +func resourceAwsFsxLustreFileSystemRead(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).fsxconn + + filesystem, err := describeFsxFileSystem(conn, d.Id()) + + if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { + log.Printf("[WARN] FSx File System (%s) not found, removing from state", d.Id()) + d.SetId("") + return nil + } + + if err != nil { + return fmt.Errorf("Error reading FSx File System (%s): %s", d.Id(), err) + } + + if filesystem == nil { + log.Printf("[WARN] FSx File System (%s) not found, removing from state", d.Id()) + d.SetId("") + return nil + } + + if filesystem.WindowsConfiguration != nil { + return fmt.Errorf("expected FSx Lustre File System, found FSx Windows File System: %s", d.Id()) + } + + if filesystem.LustreConfiguration == nil { + return fmt.Errorf("error describing FSx Lustre File System (%s): empty Lustre configuration", d.Id()) + } + + if filesystem.LustreConfiguration.DataRepositoryConfiguration == nil { + // Initialize an empty structure to simplify d.Set() handling + filesystem.LustreConfiguration.DataRepositoryConfiguration = &fsx.DataRepositoryConfiguration{} + } + + d.Set("arn", filesystem.ResourceARN) + d.Set("dns_name", filesystem.DNSName) + d.Set("export_path", filesystem.LustreConfiguration.DataRepositoryConfiguration.ExportPath) + d.Set("import_path", filesystem.LustreConfiguration.DataRepositoryConfiguration.ImportPath) + d.Set("imported_file_chunk_size", filesystem.LustreConfiguration.DataRepositoryConfiguration.ImportedFileChunkSize) + + if err := d.Set("network_interface_ids", aws.StringValueSlice(filesystem.NetworkInterfaceIds)); err != nil { + return fmt.Errorf("error setting network_interface_ids: %s", err) + } + + d.Set("owner_id", filesystem.OwnerId) + d.Set("storage_capacity", filesystem.StorageCapacity) + + if err := d.Set("subnet_ids", aws.StringValueSlice(filesystem.SubnetIds)); err != nil { + return fmt.Errorf("error setting subnet_ids: %s", err) + } + + if err := d.Set("tags", tagsToMapFSX(filesystem.Tags)); err != nil { + return fmt.Errorf("error setting tags: %s", err) + } + + d.Set("vpc_id", filesystem.VpcId) + d.Set("weekly_maintenance_start_time", filesystem.LustreConfiguration.WeeklyMaintenanceStartTime) + + return nil +} + +func resourceAwsFsxLustreFileSystemDelete(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).fsxconn + + request := &fsx.DeleteFileSystemInput{ + FileSystemId: aws.String(d.Id()), + } + + _, err := conn.DeleteFileSystem(request) + + if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { + return nil + } + + if err != nil { + return fmt.Errorf("Error deleting FSx filesystem: %s", err) + } + + log.Println("[DEBUG] Waiting for filesystem to delete") + + if err := waitForFsxFileSystemDeletion(conn, d.Id(), d.Timeout(schema.TimeoutDelete)); err != nil { + return fmt.Errorf("Error waiting for filesystem (%s) to delete: %s", d.Id(), err) + } + + return nil +} diff --git a/aws/resource_aws_fsx_lustre_file_system_test.go b/aws/resource_aws_fsx_lustre_file_system_test.go new file mode 100644 index 00000000000..94c6f17f204 --- /dev/null +++ b/aws/resource_aws_fsx_lustre_file_system_test.go @@ -0,0 +1,611 @@ +package aws + +import ( + "fmt" + "regexp" + "testing" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/fsx" + "github.com/hashicorp/terraform/helper/acctest" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" +) + +func TestAccAWSFsxLustreFileSystem_basic(t *testing.T) { + var filesystem fsx.FileSystem + resourceName := "aws_fsx_lustre_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxLustreFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxLustreFileSystemConfigSubnetIds1(), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem), + testAccMatchResourceAttrRegionalARN(resourceName, "arn", "fsx", regexp.MustCompile(`file-system/fs-.+`)), + resource.TestMatchResourceAttr(resourceName, "dns_name", regexp.MustCompile(`fs-.+\.fsx\.`)), + resource.TestCheckResourceAttr(resourceName, "export_path", ""), + resource.TestCheckResourceAttr(resourceName, "import_path", ""), + resource.TestCheckResourceAttr(resourceName, "imported_file_chunk_size", "0"), + resource.TestCheckResourceAttr(resourceName, "network_interface_ids.#", "2"), + testAccCheckResourceAttrAccountID(resourceName, "owner_id"), + resource.TestCheckResourceAttr(resourceName, "storage_capacity", "3600"), + resource.TestCheckResourceAttr(resourceName, "subnet_ids.#", "1"), + resource.TestCheckResourceAttr(resourceName, "security_group_ids.#", "0"), + resource.TestCheckResourceAttr(resourceName, "tags.%", "0"), + resource.TestMatchResourceAttr(resourceName, "vpc_id", regexp.MustCompile(`^vpc-.+`)), + resource.TestMatchResourceAttr(resourceName, "weekly_maintenance_start_time", regexp.MustCompile(`^\d:\d\d:\d\d$`)), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"security_group_ids"}, + }, + }, + }) +} + +func TestAccAWSFsxLustreFileSystem_disappears(t *testing.T) { + var filesystem fsx.FileSystem + resourceName := "aws_fsx_lustre_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxLustreFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxLustreFileSystemConfigSubnetIds1(), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem), + testAccCheckFsxLustreFileSystemDisappears(&filesystem), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + +func TestAccAWSFsxLustreFileSystem_ExportPath(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + resourceName := "aws_fsx_lustre_file_system.test" + rName := acctest.RandomWithPrefix("tf-acc-test") + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxLustreFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxLustreFileSystemConfigExportPath(rName, ""), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "export_path", fmt.Sprintf("s3://%s", rName)), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"security_group_ids"}, + }, + { + Config: testAccAwsFsxLustreFileSystemConfigExportPath(rName, "/prefix/"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxLustreFileSystemRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "export_path", fmt.Sprintf("s3://%s/prefix/", rName)), + ), + }, + }, + }) +} + +func TestAccAWSFsxLustreFileSystem_ImportPath(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + resourceName := "aws_fsx_lustre_file_system.test" + rName := acctest.RandomWithPrefix("tf-acc-test") + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxLustreFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxLustreFileSystemConfigImportPath(rName, ""), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "import_path", fmt.Sprintf("s3://%s", rName)), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"security_group_ids"}, + }, + { + Config: testAccAwsFsxLustreFileSystemConfigImportPath(rName, "/prefix/"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxLustreFileSystemRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "import_path", fmt.Sprintf("s3://%s/prefix/", rName)), + ), + }, + }, + }) +} + +func TestAccAWSFsxLustreFileSystem_ImportedFileChunkSize(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + resourceName := "aws_fsx_lustre_file_system.test" + rName := acctest.RandomWithPrefix("tf-acc-test") + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxLustreFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxLustreFileSystemConfigImportedFileChunkSize(rName, 2048), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "imported_file_chunk_size", "2048"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"security_group_ids"}, + }, + { + Config: testAccAwsFsxLustreFileSystemConfigImportedFileChunkSize(rName, 4096), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxLustreFileSystemRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "imported_file_chunk_size", "4096"), + ), + }, + }, + }) +} + +func TestAccAWSFsxLustreFileSystem_SecurityGroupIds(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + resourceName := "aws_fsx_lustre_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxLustreFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxLustreFileSystemConfigSecurityGroupIds1(), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "security_group_ids.#", "1"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"security_group_ids"}, + }, + { + Config: testAccAwsFsxLustreFileSystemConfigSecurityGroupIds2(), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxLustreFileSystemRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "security_group_ids.#", "2"), + ), + }, + }, + }) +} + +func TestAccAWSFsxLustreFileSystem_StorageCapacity(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + resourceName := "aws_fsx_lustre_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxLustreFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxLustreFileSystemConfigStorageCapacity(7200), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "storage_capacity", "7200"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"security_group_ids"}, + }, + { + Config: testAccAwsFsxLustreFileSystemConfigStorageCapacity(3600), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxLustreFileSystemRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "storage_capacity", "3600"), + ), + }, + }, + }) +} + +func TestAccAWSFsxLustreFileSystem_Tags(t *testing.T) { + var filesystem1, filesystem2, filesystem3 fsx.FileSystem + resourceName := "aws_fsx_lustre_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxLustreFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxLustreFileSystemConfigTags1("key1", "value1"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "tags.%", "1"), + resource.TestCheckResourceAttr(resourceName, "tags.key1", "value1"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"security_group_ids"}, + }, + { + Config: testAccAwsFsxLustreFileSystemConfigTags2("key1", "value1updated", "key2", "value2"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxLustreFileSystemNotRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "tags.%", "2"), + resource.TestCheckResourceAttr(resourceName, "tags.key1", "value1updated"), + resource.TestCheckResourceAttr(resourceName, "tags.key2", "value2"), + ), + }, + { + Config: testAccAwsFsxLustreFileSystemConfigTags1("key2", "value2"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem3), + testAccCheckFsxLustreFileSystemNotRecreated(&filesystem2, &filesystem3), + resource.TestCheckResourceAttr(resourceName, "tags.%", "1"), + resource.TestCheckResourceAttr(resourceName, "tags.key2", "value2"), + ), + }, + }, + }) +} + +func TestAccAWSFsxLustreFileSystem_WeeklyMaintenanceStartTime(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + resourceName := "aws_fsx_lustre_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxLustreFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxLustreFileSystemConfigWeeklyMaintenanceStartTime("1:01:01"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "weekly_maintenance_start_time", "1:01:01"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"security_group_ids"}, + }, + { + Config: testAccAwsFsxLustreFileSystemConfigWeeklyMaintenanceStartTime("2:02:02"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxLustreFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxLustreFileSystemNotRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "weekly_maintenance_start_time", "2:02:02"), + ), + }, + }, + }) +} + +func testAccCheckFsxLustreFileSystemExists(resourceName string, fs *fsx.FileSystem) resource.TestCheckFunc { + return func(s *terraform.State) error { + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return fmt.Errorf("Not found: %s", resourceName) + } + + conn := testAccProvider.Meta().(*AWSClient).fsxconn + + filesystem, err := describeFsxFileSystem(conn, rs.Primary.ID) + + if err != nil { + return err + } + + if filesystem == nil { + return fmt.Errorf("FSx File System (%s) not found", rs.Primary.ID) + } + + *fs = *filesystem + + return nil + } +} + +func testAccCheckFsxLustreFileSystemDestroy(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).fsxconn + + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_fsx_lustre_file_system" { + continue + } + + filesystem, err := describeFsxFileSystem(conn, rs.Primary.ID) + + if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { + continue + } + + if err != nil { + return err + } + + if filesystem != nil { + return fmt.Errorf("FSx File System (%s) still exists", rs.Primary.ID) + } + } + return nil +} + +func testAccCheckFsxLustreFileSystemDisappears(filesystem *fsx.FileSystem) resource.TestCheckFunc { + return func(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).fsxconn + + input := &fsx.DeleteFileSystemInput{ + FileSystemId: filesystem.FileSystemId, + } + + _, err := conn.DeleteFileSystem(input) + + if err != nil { + return err + } + + return waitForFsxFileSystemDeletion(conn, aws.StringValue(filesystem.FileSystemId), 30*time.Minute) + } +} + +func testAccCheckFsxLustreFileSystemNotRecreated(i, j *fsx.FileSystem) resource.TestCheckFunc { + return func(s *terraform.State) error { + if aws.StringValue(i.FileSystemId) != aws.StringValue(j.FileSystemId) { + return fmt.Errorf("FSx File System (%s) recreated", aws.StringValue(i.FileSystemId)) + } + + return nil + } +} + +func testAccCheckFsxLustreFileSystemRecreated(i, j *fsx.FileSystem) resource.TestCheckFunc { + return func(s *terraform.State) error { + if aws.StringValue(i.FileSystemId) == aws.StringValue(j.FileSystemId) { + return fmt.Errorf("FSx File System (%s) not recreated", aws.StringValue(i.FileSystemId)) + } + + return nil + } +} + +func testAccAwsFsxLustreFileSystemConfigBase() string { + return fmt.Sprintf(` +data "aws_availability_zones" "available" { + state = "available" +} + +resource "aws_vpc" "test" { + cidr_block = "10.0.0.0/16" +} + +resource "aws_subnet" "test1" { + vpc_id = "${aws_vpc.test.id}" + cidr_block = "10.0.1.0/24" + availability_zone = "${data.aws_availability_zones.available.names[0]}" +} +`) +} + +func testAccAwsFsxLustreFileSystemConfigExportPath(rName, exportPrefix string) string { + return testAccAwsFsxLustreFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_s3_bucket" "test" { + acl = "private" + bucket = %[1]q +} + +resource "aws_fsx_lustre_file_system" "test" { + export_path = "s3://${aws_s3_bucket.test.bucket}%[2]s" + import_path = "s3://${aws_s3_bucket.test.bucket}" + storage_capacity = 3600 + subnet_ids = ["${aws_subnet.test1.id}"] +} +`, rName, exportPrefix) +} + +func testAccAwsFsxLustreFileSystemConfigImportPath(rName, importPrefix string) string { + return testAccAwsFsxLustreFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_s3_bucket" "test" { + acl = "private" + bucket = %[1]q +} + +resource "aws_fsx_lustre_file_system" "test" { + import_path = "s3://${aws_s3_bucket.test.bucket}%[2]s" + storage_capacity = 3600 + subnet_ids = ["${aws_subnet.test1.id}"] +} +`, rName, importPrefix) +} + +func testAccAwsFsxLustreFileSystemConfigImportedFileChunkSize(rName string, importedFileChunkSize int) string { + return testAccAwsFsxLustreFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_s3_bucket" "test" { + acl = "private" + bucket = %[1]q +} + +resource "aws_fsx_lustre_file_system" "test" { + import_path = "s3://${aws_s3_bucket.test.bucket}" + imported_file_chunk_size = %[2]d + storage_capacity = 3600 + subnet_ids = ["${aws_subnet.test1.id}"] +} +`, rName, importedFileChunkSize) +} + +func testAccAwsFsxLustreFileSystemConfigSecurityGroupIds1() string { + return testAccAwsFsxLustreFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_security_group" "test1" { + description = "security group for FSx testing" + vpc_id = "${aws_vpc.test.id}" + + ingress { + cidr_blocks = ["${aws_vpc.test.cidr_block}"] + from_port = 0 + protocol = -1 + to_port = 0 + } + + egress { + cidr_blocks = ["0.0.0.0/0"] + from_port = 0 + protocol = "-1" + to_port = 0 + } +} + +resource "aws_fsx_lustre_file_system" "test" { + security_group_ids = ["${aws_security_group.test1.id}"] + storage_capacity = 3600 + subnet_ids = ["${aws_subnet.test1.id}"] +} +`) +} + +func testAccAwsFsxLustreFileSystemConfigSecurityGroupIds2() string { + return testAccAwsFsxLustreFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_security_group" "test1" { + description = "security group for FSx testing" + vpc_id = "${aws_vpc.test.id}" + + ingress { + cidr_blocks = ["${aws_vpc.test.cidr_block}"] + from_port = 0 + protocol = -1 + to_port = 0 + } + + egress { + cidr_blocks = ["0.0.0.0/0"] + from_port = 0 + protocol = "-1" + to_port = 0 + } +} + +resource "aws_security_group" "test2" { + description = "security group for FSx testing" + vpc_id = "${aws_vpc.test.id}" + + ingress { + cidr_blocks = ["${aws_vpc.test.cidr_block}"] + from_port = 0 + protocol = -1 + to_port = 0 + } + + egress { + cidr_blocks = ["0.0.0.0/0"] + from_port = 0 + protocol = "-1" + to_port = 0 + } +} + +resource "aws_fsx_lustre_file_system" "test" { + security_group_ids = ["${aws_security_group.test1.id}", "${aws_security_group.test2.id}"] + storage_capacity = 3600 + subnet_ids = ["${aws_subnet.test1.id}"] +} +`) +} + +func testAccAwsFsxLustreFileSystemConfigStorageCapacity(storageCapacity int) string { + return testAccAwsFsxLustreFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_lustre_file_system" "test" { + storage_capacity = %[1]d + subnet_ids = ["${aws_subnet.test1.id}"] +} +`, storageCapacity) +} + +func testAccAwsFsxLustreFileSystemConfigSubnetIds1() string { + return testAccAwsFsxLustreFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_lustre_file_system" "test" { + storage_capacity = 3600 + subnet_ids = ["${aws_subnet.test1.id}"] +} +`) +} + +func testAccAwsFsxLustreFileSystemConfigTags1(tagKey1, tagValue1 string) string { + return testAccAwsFsxLustreFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_lustre_file_system" "test" { + storage_capacity = 3600 + subnet_ids = ["${aws_subnet.test1.id}"] + + tags = { + %[1]q = %[2]q + } +} +`, tagKey1, tagValue1) +} + +func testAccAwsFsxLustreFileSystemConfigTags2(tagKey1, tagValue1, tagKey2, tagValue2 string) string { + return testAccAwsFsxLustreFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_lustre_file_system" "test" { + storage_capacity = 3600 + subnet_ids = ["${aws_subnet.test1.id}"] + + tags = { + %[1]q = %[2]q + %[3]q = %[4]q + } +} +`, tagKey1, tagValue1, tagKey2, tagValue2) +} + +func testAccAwsFsxLustreFileSystemConfigWeeklyMaintenanceStartTime(weeklyMaintenanceStartTime string) string { + return testAccAwsFsxLustreFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_lustre_file_system" "test" { + storage_capacity = 3600 + subnet_ids = ["${aws_subnet.test1.id}"] + weekly_maintenance_start_time = %[1]q +} +`, weeklyMaintenanceStartTime) +} diff --git a/aws/resource_aws_fsx_windows_file_system.go b/aws/resource_aws_fsx_windows_file_system.go new file mode 100644 index 00000000000..b29112a1d9f --- /dev/null +++ b/aws/resource_aws_fsx_windows_file_system.go @@ -0,0 +1,439 @@ +package aws + +import ( + "fmt" + "log" + "regexp" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/fsx" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/helper/schema" + "github.com/hashicorp/terraform/helper/validation" +) + +func resourceAwsFsxWindowsFileSystem() *schema.Resource { + return &schema.Resource{ + Create: resourceAwsFsxWindowsFileSystemCreate, + Read: resourceAwsFsxWindowsFileSystemRead, + Update: resourceAwsFsxWindowsFileSystemUpdate, + Delete: resourceAwsFsxWindowsFileSystemDelete, + Importer: &schema.ResourceImporter{ + State: func(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) { + d.Set("skip_final_backup", false) + + return []*schema.ResourceData{d}, nil + }, + }, + + Timeouts: &schema.ResourceTimeout{ + Create: schema.DefaultTimeout(30 * time.Minute), + Delete: schema.DefaultTimeout(30 * time.Minute), + }, + + Schema: map[string]*schema.Schema{ + "active_directory_id": { + Type: schema.TypeString, + Optional: true, + ForceNew: true, + ConflictsWith: []string{"self_managed_active_directory"}, + }, + "arn": { + Type: schema.TypeString, + Computed: true, + }, + "automatic_backup_retention_days": { + Type: schema.TypeInt, + Optional: true, + Default: 7, + ValidateFunc: validation.IntBetween(0, 35), + }, + "copy_tags_to_backups": { + Type: schema.TypeBool, + Optional: true, + Default: false, + ForceNew: true, + }, + "daily_automatic_backup_start_time": { + Type: schema.TypeString, + Optional: true, + Computed: true, + ValidateFunc: validation.All( + validation.StringLenBetween(5, 5), + validation.StringMatch(regexp.MustCompile(`^([01]\d|2[0-3]):?([0-5]\d)$`), "must be in the format HH:MM"), + ), + }, + "dns_name": { + Type: schema.TypeString, + Computed: true, + }, + "kms_key_id": { + Type: schema.TypeString, + Optional: true, + Computed: true, + ForceNew: true, + ValidateFunc: validateArn, + }, + "network_interface_ids": { + Type: schema.TypeSet, + Computed: true, + Elem: &schema.Schema{Type: schema.TypeString}, + }, + "owner_id": { + Type: schema.TypeString, + Computed: true, + }, + "security_group_ids": { + Type: schema.TypeSet, + Optional: true, + ForceNew: true, + MaxItems: 50, + Elem: &schema.Schema{Type: schema.TypeString}, + }, + "self_managed_active_directory": { + Type: schema.TypeList, + Optional: true, + MaxItems: 1, + ConflictsWith: []string{"active_directory_id"}, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "dns_ips": { + Type: schema.TypeSet, + Required: true, + MinItems: 1, + MaxItems: 2, + Elem: &schema.Schema{Type: schema.TypeString}, + }, + "domain_name": { + Type: schema.TypeString, + Required: true, + }, + "file_system_administrators_group": { + Type: schema.TypeString, + Optional: true, + Default: "Domain Admins", + ValidateFunc: validation.StringLenBetween(1, 256), + }, + "organizational_unit_distinguished_name": { + Type: schema.TypeString, + Optional: true, + ValidateFunc: validation.StringLenBetween(1, 2000), + }, + "password": { + Type: schema.TypeString, + Required: true, + Sensitive: true, + ValidateFunc: validation.StringLenBetween(1, 256), + }, + "username": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringLenBetween(1, 256), + }, + }, + }, + }, + "skip_final_backup": { + Type: schema.TypeBool, + Optional: true, + Default: false, + }, + "storage_capacity": { + Type: schema.TypeInt, + Required: true, + ForceNew: true, + ValidateFunc: validation.IntBetween(300, 65536), + }, + "subnet_ids": { + Type: schema.TypeSet, + Required: true, + ForceNew: true, + MinItems: 1, + MaxItems: 1, + Elem: &schema.Schema{Type: schema.TypeString}, + }, + "tags": tagsSchema(), + "throughput_capacity": { + Type: schema.TypeInt, + Required: true, + ForceNew: true, + ValidateFunc: validation.IntBetween(8, 2048), + }, + "vpc_id": { + Type: schema.TypeString, + Computed: true, + }, + "weekly_maintenance_start_time": { + Type: schema.TypeString, + Optional: true, + Computed: true, + ValidateFunc: validation.All( + validation.StringLenBetween(7, 7), + validation.StringMatch(regexp.MustCompile(`^[1-7]:([01]\d|2[0-3]):?([0-5]\d)$`), "must be in the format d:HH:MM"), + ), + }, + }, + } +} + +func resourceAwsFsxWindowsFileSystemCreate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).fsxconn + + input := &fsx.CreateFileSystemInput{ + ClientRequestToken: aws.String(resource.UniqueId()), + FileSystemType: aws.String(fsx.FileSystemTypeWindows), + StorageCapacity: aws.Int64(int64(d.Get("storage_capacity").(int))), + SubnetIds: expandStringSet(d.Get("subnet_ids").(*schema.Set)), + WindowsConfiguration: &fsx.CreateFileSystemWindowsConfiguration{ + AutomaticBackupRetentionDays: aws.Int64(int64(d.Get("automatic_backup_retention_days").(int))), + CopyTagsToBackups: aws.Bool(d.Get("copy_tags_to_backups").(bool)), + ThroughputCapacity: aws.Int64(int64(d.Get("throughput_capacity").(int))), + }, + } + + if v, ok := d.GetOk("active_directory_id"); ok { + input.WindowsConfiguration.ActiveDirectoryId = aws.String(v.(string)) + } + + if v, ok := d.GetOk("daily_automatic_backup_start_time"); ok { + input.WindowsConfiguration.DailyAutomaticBackupStartTime = aws.String(v.(string)) + } + + if v, ok := d.GetOk("kms_key_id"); ok { + input.KmsKeyId = aws.String(v.(string)) + } + + if v, ok := d.GetOk("security_group_ids"); ok { + input.SecurityGroupIds = expandStringSet(v.(*schema.Set)) + } + + if v, ok := d.GetOk("self_managed_active_directory"); ok { + input.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration = expandFsxSelfManagedActiveDirectoryConfigurationCreate(v.([]interface{})) + } + + if v, ok := d.GetOk("tags"); ok { + input.Tags = tagsFromMapFSX(v.(map[string]interface{})) + } + + if v, ok := d.GetOk("weekly_maintenance_start_time"); ok { + input.WindowsConfiguration.WeeklyMaintenanceStartTime = aws.String(v.(string)) + } + + result, err := conn.CreateFileSystem(input) + if err != nil { + return fmt.Errorf("Error creating FSx filesystem: %s", err) + } + + d.SetId(*result.FileSystem.FileSystemId) + + log.Println("[DEBUG] Waiting for filesystem to become available") + + if err := waitForFsxFileSystemCreation(conn, d.Id(), d.Timeout(schema.TimeoutCreate)); err != nil { + return fmt.Errorf("Error waiting for filesystem (%s) to become available: %s", d.Id(), err) + } + + return resourceAwsFsxWindowsFileSystemRead(d, meta) +} + +func resourceAwsFsxWindowsFileSystemUpdate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).fsxconn + + if d.HasChange("tags") { + if err := setTagsFSX(conn, d); err != nil { + return fmt.Errorf("Error updating tags for FSx filesystem: %s", err) + } + } + + requestUpdate := false + input := &fsx.UpdateFileSystemInput{ + ClientRequestToken: aws.String(resource.UniqueId()), + FileSystemId: aws.String(d.Id()), + WindowsConfiguration: &fsx.UpdateFileSystemWindowsConfiguration{}, + } + + if d.HasChange("automatic_backup_retention_days") { + input.WindowsConfiguration.AutomaticBackupRetentionDays = aws.Int64(int64(d.Get("automatic_backup_retention_days").(int))) + requestUpdate = true + } + + if d.HasChange("daily_automatic_backup_start_time") { + input.WindowsConfiguration.DailyAutomaticBackupStartTime = aws.String(d.Get("daily_automatic_backup_start_time").(string)) + requestUpdate = true + } + + if d.HasChange("self_managed_active_directory") { + input.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration = expandFsxSelfManagedActiveDirectoryConfigurationUpdate(d.Get("self_managed_active_directory").([]interface{})) + requestUpdate = true + } + + if d.HasChange("weekly_maintenance_start_time") { + input.WindowsConfiguration.WeeklyMaintenanceStartTime = aws.String(d.Get("weekly_maintenance_start_time").(string)) + requestUpdate = true + } + + if requestUpdate { + _, err := conn.UpdateFileSystem(input) + if err != nil { + return fmt.Errorf("error updating FSX File System (%s): %s", d.Id(), err) + } + } + + return resourceAwsFsxWindowsFileSystemRead(d, meta) +} + +func resourceAwsFsxWindowsFileSystemRead(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).fsxconn + + filesystem, err := describeFsxFileSystem(conn, d.Id()) + + if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { + log.Printf("[WARN] FSx File System (%s) not found, removing from state", d.Id()) + d.SetId("") + return nil + } + + if err != nil { + return fmt.Errorf("Error reading FSx File System (%s): %s", d.Id(), err) + } + + if filesystem == nil { + log.Printf("[WARN] FSx File System (%s) not found, removing from state", d.Id()) + d.SetId("") + return nil + } + + if filesystem.LustreConfiguration != nil { + return fmt.Errorf("expected FSx Windows File System, found FSx Lustre File System: %s", d.Id()) + } + + if filesystem.WindowsConfiguration == nil { + return fmt.Errorf("error describing FSx Windows File System (%s): empty Windows configuration", d.Id()) + } + + d.Set("active_directory_id", filesystem.WindowsConfiguration.ActiveDirectoryId) + d.Set("arn", filesystem.ResourceARN) + d.Set("automatic_backup_retention_days", filesystem.WindowsConfiguration.AutomaticBackupRetentionDays) + d.Set("copy_tags_to_backups", filesystem.WindowsConfiguration.CopyTagsToBackups) + d.Set("daily_automatic_backup_start_time", filesystem.WindowsConfiguration.DailyAutomaticBackupStartTime) + d.Set("dns_name", filesystem.DNSName) + d.Set("kms_key_id", filesystem.KmsKeyId) + + if err := d.Set("network_interface_ids", aws.StringValueSlice(filesystem.NetworkInterfaceIds)); err != nil { + return fmt.Errorf("error setting network_interface_ids: %s", err) + } + + d.Set("owner_id", filesystem.OwnerId) + + if err := d.Set("self_managed_active_directory", flattenFsxSelfManagedActiveDirectoryConfiguration(d, filesystem.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration)); err != nil { + return fmt.Errorf("error setting self_managed_active_directory: %s", err) + } + + d.Set("storage_capacity", filesystem.StorageCapacity) + + if err := d.Set("subnet_ids", aws.StringValueSlice(filesystem.SubnetIds)); err != nil { + return fmt.Errorf("error setting subnet_ids: %s", err) + } + + if err := d.Set("tags", tagsToMapFSX(filesystem.Tags)); err != nil { + return fmt.Errorf("error setting tags: %s", err) + } + + d.Set("throughput_capacity", filesystem.WindowsConfiguration.ThroughputCapacity) + d.Set("vpc_id", filesystem.VpcId) + d.Set("weekly_maintenance_start_time", filesystem.WindowsConfiguration.WeeklyMaintenanceStartTime) + + return nil +} + +func resourceAwsFsxWindowsFileSystemDelete(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).fsxconn + + input := &fsx.DeleteFileSystemInput{ + ClientRequestToken: aws.String(resource.UniqueId()), + FileSystemId: aws.String(d.Id()), + WindowsConfiguration: &fsx.DeleteFileSystemWindowsConfiguration{ + SkipFinalBackup: aws.Bool(d.Get("skip_final_backup").(bool)), + }, + } + + _, err := conn.DeleteFileSystem(input) + + if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { + return nil + } + + if err != nil { + return fmt.Errorf("Error deleting FSx filesystem: %s", err) + } + + log.Println("[DEBUG] Waiting for filesystem to delete") + + if err := waitForFsxFileSystemDeletion(conn, d.Id(), d.Timeout(schema.TimeoutDelete)); err != nil { + return fmt.Errorf("Error waiting for filesystem (%s) to delete: %s", d.Id(), err) + } + + return nil +} + +func expandFsxSelfManagedActiveDirectoryConfigurationCreate(l []interface{}) *fsx.SelfManagedActiveDirectoryConfiguration { + if len(l) == 0 || l[0] == nil { + return nil + } + + data := l[0].(map[string]interface{}) + req := &fsx.SelfManagedActiveDirectoryConfiguration{ + DomainName: aws.String(data["domain_name"].(string)), + DnsIps: expandStringSet(data["dns_ips"].(*schema.Set)), + Password: aws.String(data["password"].(string)), + UserName: aws.String(data["username"].(string)), + } + + if v, ok := data["file_system_administrators_group"]; ok && v.(string) != "" { + req.FileSystemAdministratorsGroup = aws.String(v.(string)) + } + + if v, ok := data["organizational_unit_distinguished_name"]; ok && v.(string) != "" { + req.OrganizationalUnitDistinguishedName = aws.String(v.(string)) + } + + return req +} + +func expandFsxSelfManagedActiveDirectoryConfigurationUpdate(l []interface{}) *fsx.SelfManagedActiveDirectoryConfigurationUpdates { + if len(l) == 0 || l[0] == nil { + return nil + } + + data := l[0].(map[string]interface{}) + req := &fsx.SelfManagedActiveDirectoryConfigurationUpdates{ + DnsIps: expandStringList(data["dns_ips"].([]interface{})), + Password: aws.String(data["password"].(string)), + UserName: aws.String(data["username"].(string)), + } + + return req +} + +func flattenFsxSelfManagedActiveDirectoryConfiguration(d *schema.ResourceData, adopts *fsx.SelfManagedActiveDirectoryAttributes) []map[string]interface{} { + if adopts == nil { + return []map[string]interface{}{} + } + + // Since we are in a configuration block and the FSx API does not return + // the password, we need to set the value if we can or Terraform will + // show a difference for the argument from empty string to the value. + // This is not a pattern that should be used normally. + // See also: flattenEmrKerberosAttributes + + m := map[string]interface{}{ + "dns_ips": aws.StringValueSlice(adopts.DnsIps), + "domain_name": aws.StringValue(adopts.DomainName), + "file_system_administrators_group": aws.StringValue(adopts.FileSystemAdministratorsGroup), + "organizational_unit_distinguished_name": aws.StringValue(adopts.OrganizationalUnitDistinguishedName), + "password": d.Get("self_managed_active_directory.0.password").(string), + "username": aws.StringValue(adopts.UserName), + } + + return []map[string]interface{}{m} +} diff --git a/aws/resource_aws_fsx_windows_file_system_test.go b/aws/resource_aws_fsx_windows_file_system_test.go new file mode 100644 index 00000000000..01e0a1733c2 --- /dev/null +++ b/aws/resource_aws_fsx_windows_file_system_test.go @@ -0,0 +1,846 @@ +package aws + +import ( + "fmt" + "regexp" + "testing" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/fsx" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" +) + +func TestAccAWSFsxWindowsFileSystem_basic(t *testing.T) { + var filesystem fsx.FileSystem + resourceName := "aws_fsx_windows_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxWindowsFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxWindowsFileSystemConfigSubnetIds1(), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem), + testAccMatchResourceAttrRegionalARN(resourceName, "arn", "fsx", regexp.MustCompile(`file-system/fs-.+`)), + resource.TestCheckResourceAttr(resourceName, "automatic_backup_retention_days", "7"), + resource.TestCheckResourceAttr(resourceName, "copy_tags_to_backups", "false"), + resource.TestMatchResourceAttr(resourceName, "daily_automatic_backup_start_time", regexp.MustCompile(`^\d\d:\d\d$`)), + resource.TestMatchResourceAttr(resourceName, "dns_name", regexp.MustCompile(`fs-.+\..+`)), + resource.TestMatchResourceAttr(resourceName, "kms_key_id", regexp.MustCompile(`^arn:`)), + resource.TestCheckResourceAttr(resourceName, "network_interface_ids.#", "1"), + testAccCheckResourceAttrAccountID(resourceName, "owner_id"), + resource.TestCheckResourceAttr(resourceName, "security_group_ids.#", "0"), + resource.TestCheckResourceAttr(resourceName, "self_managed_active_directory.#", "0"), + resource.TestCheckResourceAttr(resourceName, "skip_final_backup", "true"), + resource.TestCheckResourceAttr(resourceName, "storage_capacity", "300"), + resource.TestCheckResourceAttr(resourceName, "subnet_ids.#", "1"), + resource.TestCheckResourceAttr(resourceName, "tags.%", "0"), + resource.TestCheckResourceAttr(resourceName, "throughput_capacity", "8"), + resource.TestMatchResourceAttr(resourceName, "vpc_id", regexp.MustCompile(`^vpc-.+`)), + resource.TestMatchResourceAttr(resourceName, "weekly_maintenance_start_time", regexp.MustCompile(`^\d:\d\d:\d\d$`)), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{ + "security_group_ids", + "skip_final_backup", + }, + }, + }, + }) +} + +func TestAccAWSFsxWindowsFileSystem_disappears(t *testing.T) { + var filesystem fsx.FileSystem + resourceName := "aws_fsx_windows_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxWindowsFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxWindowsFileSystemConfigSubnetIds1(), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem), + testAccCheckFsxWindowsFileSystemDisappears(&filesystem), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + +func TestAccAWSFsxWindowsFileSystem_AutomaticBackupRetentionDays(t *testing.T) { + var filesystem1, filesystem2, filesystem3 fsx.FileSystem + resourceName := "aws_fsx_windows_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxWindowsFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxWindowsFileSystemConfigAutomaticBackupRetentionDays(35), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "automatic_backup_retention_days", "35"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{ + "security_group_ids", + "skip_final_backup", + }, + }, + { + Config: testAccAwsFsxWindowsFileSystemConfigAutomaticBackupRetentionDays(0), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxWindowsFileSystemNotRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "automatic_backup_retention_days", "0"), + ), + }, + { + Config: testAccAwsFsxWindowsFileSystemConfigAutomaticBackupRetentionDays(14), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem3), + testAccCheckFsxWindowsFileSystemNotRecreated(&filesystem2, &filesystem3), + resource.TestCheckResourceAttr(resourceName, "automatic_backup_retention_days", "14"), + ), + }, + }, + }) +} + +func TestAccAWSFsxWindowsFileSystem_CopyTagsToBackups(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + resourceName := "aws_fsx_windows_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxWindowsFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxWindowsFileSystemConfigCopyTagsToBackups(true), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "copy_tags_to_backups", "true"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{ + "security_group_ids", + "skip_final_backup", + }, + }, + { + Config: testAccAwsFsxWindowsFileSystemConfigCopyTagsToBackups(false), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxWindowsFileSystemRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "copy_tags_to_backups", "false"), + ), + }, + }, + }) +} + +func TestAccAWSFsxWindowsFileSystem_DailyAutomaticBackupStartTime(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + resourceName := "aws_fsx_windows_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxWindowsFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxWindowsFileSystemConfigDailyAutomaticBackupStartTime("01:01"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "daily_automatic_backup_start_time", "01:01"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{ + "security_group_ids", + "skip_final_backup", + }, + }, + { + Config: testAccAwsFsxWindowsFileSystemConfigDailyAutomaticBackupStartTime("02:02"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxWindowsFileSystemNotRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "daily_automatic_backup_start_time", "02:02"), + ), + }, + }, + }) +} + +func TestAccAWSFsxWindowsFileSystem_KmsKeyId(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + kmsKeyResourceName1 := "aws_kms_key.test1" + kmsKeyResourceName2 := "aws_kms_key.test2" + resourceName := "aws_fsx_windows_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxWindowsFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxWindowsFileSystemConfigKmsKeyId1(), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttrPair(resourceName, "kms_key_id", kmsKeyResourceName1, "arn"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{ + "security_group_ids", + "skip_final_backup", + }, + }, + { + Config: testAccAwsFsxWindowsFileSystemConfigKmsKeyId2(), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxWindowsFileSystemRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttrPair(resourceName, "kms_key_id", kmsKeyResourceName2, "arn"), + ), + }, + }, + }) +} + +func TestAccAWSFsxWindowsFileSystem_SecurityGroupIds(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + resourceName := "aws_fsx_windows_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxWindowsFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxWindowsFileSystemConfigSecurityGroupIds1(), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "security_group_ids.#", "1"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{ + "security_group_ids", + "skip_final_backup", + }, + }, + { + Config: testAccAwsFsxWindowsFileSystemConfigSecurityGroupIds2(), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxWindowsFileSystemRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "security_group_ids.#", "2"), + ), + }, + }, + }) +} + +func TestAccAWSFsxWindowsFileSystem_SelfManagedActiveDirectory(t *testing.T) { + var filesystem fsx.FileSystem + resourceName := "aws_fsx_windows_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxWindowsFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxWindowsFileSystemConfigSelfManagedActiveDirectory(), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem), + resource.TestCheckResourceAttr(resourceName, "self_managed_active_directory.#", "1"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{ + "security_group_ids", + "self_managed_active_directory", + "skip_final_backup", + }, + }, + }, + }) +} + +func TestAccAWSFsxWindowsFileSystem_StorageCapacity(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + resourceName := "aws_fsx_windows_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxWindowsFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxWindowsFileSystemConfigStorageCapacity(301), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "storage_capacity", "301"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{ + "security_group_ids", + "skip_final_backup", + }, + }, + { + Config: testAccAwsFsxWindowsFileSystemConfigStorageCapacity(302), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxWindowsFileSystemRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "storage_capacity", "302"), + ), + }, + }, + }) +} + +func TestAccAWSFsxWindowsFileSystem_Tags(t *testing.T) { + var filesystem1, filesystem2, filesystem3 fsx.FileSystem + resourceName := "aws_fsx_windows_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxWindowsFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxWindowsFileSystemConfigTags1("key1", "value1"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "tags.%", "1"), + resource.TestCheckResourceAttr(resourceName, "tags.key1", "value1"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{ + "security_group_ids", + "skip_final_backup", + }, + }, + { + Config: testAccAwsFsxWindowsFileSystemConfigTags2("key1", "value1updated", "key2", "value2"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxWindowsFileSystemNotRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "tags.%", "2"), + resource.TestCheckResourceAttr(resourceName, "tags.key1", "value1updated"), + resource.TestCheckResourceAttr(resourceName, "tags.key2", "value2"), + ), + }, + { + Config: testAccAwsFsxWindowsFileSystemConfigTags1("key2", "value2"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem3), + testAccCheckFsxWindowsFileSystemNotRecreated(&filesystem2, &filesystem3), + resource.TestCheckResourceAttr(resourceName, "tags.%", "1"), + resource.TestCheckResourceAttr(resourceName, "tags.key2", "value2"), + ), + }, + }, + }) +} + +func TestAccAWSFsxWindowsFileSystem_ThroughputCapacity(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + resourceName := "aws_fsx_windows_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxWindowsFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxWindowsFileSystemConfigThroughputCapacity(16), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "throughput_capacity", "16"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{ + "security_group_ids", + "skip_final_backup", + }, + }, + { + Config: testAccAwsFsxWindowsFileSystemConfigThroughputCapacity(32), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxWindowsFileSystemRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "throughput_capacity", "32"), + ), + }, + }, + }) +} + +func TestAccAWSFsxWindowsFileSystem_WeeklyMaintenanceStartTime(t *testing.T) { + var filesystem1, filesystem2 fsx.FileSystem + resourceName := "aws_fsx_windows_file_system.test" + + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckFsxWindowsFileSystemDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAwsFsxWindowsFileSystemConfigWeeklyMaintenanceStartTime("1:01:01"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem1), + resource.TestCheckResourceAttr(resourceName, "weekly_maintenance_start_time", "1:01:01"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{ + "security_group_ids", + "skip_final_backup", + }, + }, + { + Config: testAccAwsFsxWindowsFileSystemConfigWeeklyMaintenanceStartTime("2:02:02"), + Check: resource.ComposeTestCheckFunc( + testAccCheckFsxWindowsFileSystemExists(resourceName, &filesystem2), + testAccCheckFsxWindowsFileSystemNotRecreated(&filesystem1, &filesystem2), + resource.TestCheckResourceAttr(resourceName, "weekly_maintenance_start_time", "2:02:02"), + ), + }, + }, + }) +} + +func testAccCheckFsxWindowsFileSystemExists(resourceName string, fs *fsx.FileSystem) resource.TestCheckFunc { + return func(s *terraform.State) error { + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return fmt.Errorf("Not found: %s", resourceName) + } + + conn := testAccProvider.Meta().(*AWSClient).fsxconn + + filesystem, err := describeFsxFileSystem(conn, rs.Primary.ID) + + if err != nil { + return err + } + + if filesystem == nil { + return fmt.Errorf("FSx File System (%s) not found", rs.Primary.ID) + } + + *fs = *filesystem + + return nil + } +} + +func testAccCheckFsxWindowsFileSystemDestroy(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).fsxconn + + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_fsx_windows_file_system" { + continue + } + + filesystem, err := describeFsxFileSystem(conn, rs.Primary.ID) + + if isAWSErr(err, fsx.ErrCodeFileSystemNotFound, "") { + continue + } + + if err != nil { + return err + } + + if filesystem != nil { + return fmt.Errorf("FSx File System (%s) still exists", rs.Primary.ID) + } + } + return nil +} + +func testAccCheckFsxWindowsFileSystemDisappears(filesystem *fsx.FileSystem) resource.TestCheckFunc { + return func(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).fsxconn + + input := &fsx.DeleteFileSystemInput{ + FileSystemId: filesystem.FileSystemId, + } + + _, err := conn.DeleteFileSystem(input) + + if err != nil { + return err + } + + return waitForFsxFileSystemDeletion(conn, aws.StringValue(filesystem.FileSystemId), 30*time.Minute) + } +} + +func testAccCheckFsxWindowsFileSystemNotRecreated(i, j *fsx.FileSystem) resource.TestCheckFunc { + return func(s *terraform.State) error { + if aws.StringValue(i.FileSystemId) != aws.StringValue(j.FileSystemId) { + return fmt.Errorf("FSx File System (%s) recreated", aws.StringValue(i.FileSystemId)) + } + + return nil + } +} + +func testAccCheckFsxWindowsFileSystemRecreated(i, j *fsx.FileSystem) resource.TestCheckFunc { + return func(s *terraform.State) error { + if aws.StringValue(i.FileSystemId) == aws.StringValue(j.FileSystemId) { + return fmt.Errorf("FSx File System (%s) not recreated", aws.StringValue(i.FileSystemId)) + } + + return nil + } +} + +func testAccAwsFsxWindowsFileSystemConfigBase() string { + return fmt.Sprintf(` +data "aws_availability_zones" "available" { + state = "available" +} + +resource "aws_vpc" "test" { + cidr_block = "10.0.0.0/16" +} + +resource "aws_subnet" "test1" { + vpc_id = "${aws_vpc.test.id}" + cidr_block = "10.0.1.0/24" + availability_zone = "${data.aws_availability_zones.available.names[0]}" +} + +resource "aws_subnet" "test2" { + vpc_id = "${aws_vpc.test.id}" + cidr_block = "10.0.2.0/24" + availability_zone = "${data.aws_availability_zones.available.names[1]}" +} + +resource "aws_directory_service_directory" "test" { + edition = "Standard" + name = "corp.notexample.com" + password = "SuperSecretPassw0rd" + type = "MicrosoftAD" + + vpc_settings { + subnet_ids = ["${aws_subnet.test1.id}", "${aws_subnet.test2.id}"] + vpc_id = "${aws_vpc.test.id}" + } +} +`) +} + +func testAccAwsFsxWindowsFileSystemConfigAutomaticBackupRetentionDays(automaticBackupRetentionDays int) string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + automatic_backup_retention_days = %[1]d + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 +} +`, automaticBackupRetentionDays) +} + +func testAccAwsFsxWindowsFileSystemConfigCopyTagsToBackups(copyTagsToBackups bool) string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + copy_tags_to_backups = %[1]t + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 +} +`, copyTagsToBackups) +} + +func testAccAwsFsxWindowsFileSystemConfigDailyAutomaticBackupStartTime(dailyAutomaticBackupStartTime string) string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + daily_automatic_backup_start_time = %[1]q + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 +} +`, dailyAutomaticBackupStartTime) +} + +func testAccAwsFsxWindowsFileSystemConfigKmsKeyId1() string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_kms_key" "test1" { + description = "FSx KMS Testing key" + deletion_window_in_days = 7 +} + +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + kms_key_id = "${aws_kms_key.test1.arn}" + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 +} +`) +} + +func testAccAwsFsxWindowsFileSystemConfigKmsKeyId2() string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_kms_key" "test2" { + description = "FSx KMS Testing key" + deletion_window_in_days = 7 +} + +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + kms_key_id = "${aws_kms_key.test2.arn}" + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 +} +`) +} + +func testAccAwsFsxWindowsFileSystemConfigSecurityGroupIds1() string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_security_group" "test1" { + description = "security group for FSx testing" + vpc_id = "${aws_vpc.test.id}" + + ingress { + cidr_blocks = ["${aws_vpc.test.cidr_block}"] + from_port = 0 + protocol = -1 + to_port = 0 + } + + egress { + cidr_blocks = ["0.0.0.0/0"] + from_port = 0 + protocol = "-1" + to_port = 0 + } +} + +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + security_group_ids = ["${aws_security_group.test1.id}"] + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 +} +`) +} + +func testAccAwsFsxWindowsFileSystemConfigSecurityGroupIds2() string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_security_group" "test1" { + description = "security group for FSx testing" + vpc_id = "${aws_vpc.test.id}" + + ingress { + cidr_blocks = ["${aws_vpc.test.cidr_block}"] + from_port = 0 + protocol = -1 + to_port = 0 + } + + egress { + cidr_blocks = ["0.0.0.0/0"] + from_port = 0 + protocol = "-1" + to_port = 0 + } +} + +resource "aws_security_group" "test2" { + description = "security group for FSx testing" + vpc_id = "${aws_vpc.test.id}" + + ingress { + cidr_blocks = ["${aws_vpc.test.cidr_block}"] + from_port = 0 + protocol = -1 + to_port = 0 + } + + egress { + cidr_blocks = ["0.0.0.0/0"] + from_port = 0 + protocol = "-1" + to_port = 0 + } +} + +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + security_group_ids = ["${aws_security_group.test1.id}", "${aws_security_group.test2.id}"] + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 +} +`) +} + +func testAccAwsFsxWindowsFileSystemConfigSelfManagedActiveDirectory() string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_windows_file_system" "test" { + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 + + self_managed_active_directory { + dns_ips = aws_directory_service_directory.test.dns_ip_addresses + domain_name = aws_directory_service_directory.test.name + password = aws_directory_service_directory.test.password + username = "Admin" + } +} +`) +} + +func testAccAwsFsxWindowsFileSystemConfigStorageCapacity(storageCapacity int) string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + skip_final_backup = true + storage_capacity = %[1]d + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 +} +`, storageCapacity) +} + +func testAccAwsFsxWindowsFileSystemConfigSubnetIds1() string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 +} +`) +} + +func testAccAwsFsxWindowsFileSystemConfigTags1(tagKey1, tagValue1 string) string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 + + tags = { + %[1]q = %[2]q + } +} +`, tagKey1, tagValue1) +} + +func testAccAwsFsxWindowsFileSystemConfigTags2(tagKey1, tagValue1, tagKey2, tagValue2 string) string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 + + tags = { + %[1]q = %[2]q + %[3]q = %[4]q + } +} +`, tagKey1, tagValue1, tagKey2, tagValue2) +} + +func testAccAwsFsxWindowsFileSystemConfigThroughputCapacity(throughputCapacity int) string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = %[1]d +} +`, throughputCapacity) +} + +func testAccAwsFsxWindowsFileSystemConfigWeeklyMaintenanceStartTime(weeklyMaintenanceStartTime string) string { + return testAccAwsFsxWindowsFileSystemConfigBase() + fmt.Sprintf(` +resource "aws_fsx_windows_file_system" "test" { + active_directory_id = "${aws_directory_service_directory.test.id}" + skip_final_backup = true + storage_capacity = 300 + subnet_ids = ["${aws_subnet.test1.id}"] + throughput_capacity = 8 + weekly_maintenance_start_time = %[1]q +} +`, weeklyMaintenanceStartTime) +} diff --git a/aws/tagsFSX.go b/aws/tagsFSX.go index f2eed55a87b..213b84653df 100644 --- a/aws/tagsFSX.go +++ b/aws/tagsFSX.go @@ -63,10 +63,13 @@ func diffTagsFSX(oldTags, newTags []*fsx.Tag) ([]*fsx.Tag, []*fsx.Tag) { // Build the list of what to remove var remove []*fsx.Tag for _, t := range oldTags { - old, ok := create[*t.Key] - if !ok || old != *t.Value { + old, ok := create[aws.StringValue(t.Key)] + if !ok || old != aws.StringValue(t.Value) { // Delete it! remove = append(remove, t) + } else if ok { + // already present so remove from new + delete(create, aws.StringValue(t.Key)) } } diff --git a/aws/tagsFSX_test.go b/aws/tagsFSX_test.go index 5bf1c309b6e..84cacd1c84c 100644 --- a/aws/tagsFSX_test.go +++ b/aws/tagsFSX_test.go @@ -44,6 +44,39 @@ func TestDiffFSXTags(t *testing.T) { "foo": "bar", }, }, + + // Overlap + { + Old: map[string]interface{}{ + "foo": "bar", + "hello": "world", + }, + New: map[string]interface{}{ + "foo": "baz", + "hello": "world", + }, + Create: map[string]string{ + "foo": "baz", + }, + Remove: map[string]string{ + "foo": "bar", + }, + }, + + // Remove + { + Old: map[string]interface{}{ + "foo": "bar", + "bar": "baz", + }, + New: map[string]interface{}{ + "foo": "bar", + }, + Create: map[string]string{}, + Remove: map[string]string{ + "bar": "baz", + }, + }, } for i, tc := range cases { diff --git a/website/aws.erb b/website/aws.erb index e5201269ae6..ed8d10ca4e9 100644 --- a/website/aws.erb +++ b/website/aws.erb @@ -1478,10 +1478,18 @@
  • - FSx Resources -
      + File System (FSx) + diff --git a/website/docs/r/fsx_file_system.html.markdown b/website/docs/r/fsx_file_system.html.markdown deleted file mode 100644 index af0280816ae..00000000000 --- a/website/docs/r/fsx_file_system.html.markdown +++ /dev/null @@ -1,105 +0,0 @@ ---- -layout: "aws" -page_title: "AWS: aws_fsx_file_system" -sidebar_current: "docs-aws-resource-fsx-file-system" -description: |- - Provides an FSx filesystem resource. ---- - -# Resource: aws_fsx_file_system - -Provides an FSx filesystem resource. - -## Example Usage - -```hcl -resource "aws_fsx_file_system" "lustre" { - type = "LUSTRE" - capacity = 3600 - kms_key_id = "${aws_kms_key.example.key_id}" - subnet_ids = ["${aws_subnet.example.id}"] - - lustre_configuration { - import_path = "s3://example-bucket" - chunk_size = 2048 - } -} -``` - -```hcl -resource "aws_fsx_file_system" "windows" { - type = "WINDOWS" - capacity = 300 - kms_key_id = "${aws_kms_key.example.arn}" - subnet_ids = ["${aws_subnet.example.id}"] - - windows_configuration { - active_directory_id = "${aws_directory_service_directory.example.id}" - backup_retention = 7 - copy_tags_to_backups = true - throughput_capacity = 1024 - } -} -``` - -## Argument Reference - -The following arguments are supported: - -* `type` - (Required) The type of file system. Valid values: `LUSTRE` or `WINDOWS` -* `capacity` - (Required) The storage capacity of the file system. For Windows file systems, the storage capacity has a minimum of 300 GiB, and a maximum of 65,536 GiB. For Lustre file systems, the storage capacity has a minimum of 3,600 GiB. Storage capacity is provisioned in increments of 3,600 GiB. -* `kms_key_id` - (Optional) The ARN for the KMS encryption key (For Windows File Servers only). -* `subnet_ids` - (Required) A list of IDs for the subnets that the file system will be accessible from. File systems support only one subnet. The file server is also launched in that subnet's Availability Zone. -* `security_group_ids` - (Optional) A list of IDs for the security groups that apply to the specified network interfaces created for file system access. These security groups will apply to all network interfaces. -* `lustre_configuration` - (Optional) The configuration for this Lustre file system. -* `windows_configuration` - (Optional) The configuration for this Microsoft Windows file system. -* `tags` - (Optional) A mapping of tags to assign to the file system. -* `timeout` - (Optional) A Terraform specific value dedicated to establishing custom timeouts for varying data import sizes. - -## lustre_configuration - -Attributes for Lustre configuration - -* `import_path` - (Required) The path to the Amazon S3 bucket (and optional prefix) that you're using as the data repository for your FSx for Lustre file system. -* `export_path` - (Optional) The path in Amazon S3 where the root of your Amazon FSx file system is exported. The path must use the same Amazon S3 bucket as specified in ImportPath. -* `chunk_size` - (Optional) For files imported from a data repository, this value determines the stripe count and maximum amount of data per file (in MiB) stored on a single physical disk. -* `weekly_maintenance_start_time` - (Optional) The preferred time to perform weekly maintenance, in the UTC time zone. - -## windows_configuration - -Attributes for Windows configuration - -* `active_directory_id` - (Required) The ID for an existing Microsoft Active Directory instance that the file system should join when it's created. -* `self_managed_active_directory` - (Required) The configuration that Amazon FSx uses to join the Windows File Server instance to your self-managed (including on-premises) Microsoft Active Directory (AD) directory. -* `backup_retention` - (Optional) The number of days to retain automatic backups. -* `copy_tags_to_backups` - (Optional) A boolean flag indicating whether tags on the file system should be copied to backups. -* `daily_backup_start_time` - (Optional) The preferred time to take daily automatic backups, in the UTC time zone. -* `throughput_capacity` - (Required) The throughput of an Amazon FSx file system, measured in megabytes per second. -* `weekly_maintenance_start_time` - (Optional) The preferred start time to perform weekly maintenance, in the UTC time zone. - -### self_managed_active_directory - -Attributes for Self Managed Active Directory configuration - -* `domain_name` - (Required) The fully qualified domain name of the self-managed AD directory. -* `username` - (Required) The user name for the service account on your self-managed AD domain that Amazon FSx will use to join to your AD domain. -* `password` - (Required) The password for the service account on your self-managed AD domain that Amazon FSx will use to join to your AD domain. -* `dns_ips` - (Required) A list of up to two IP addresses of DNS servers or domain controllers in the self-managed AD directory. -* `administrators_group` - (Optional) The name of the domain group whose members are granted administrative privileges for the file system. Administrative privileges include taking ownership of files and folders, and setting audit controls (audit ACLs) on files and folders. -* `ou_distinguished_name` - (Optional) The fully qualified distinguished name of the organizational unit within your self-managed AD directory that the Windows File Server instance will join. - -## Attributes Reference - -In addition to all arguments above, the following attributes are exported: - -* `id` - The ID that identifies the file system. -* `arn` - Amazon Resource Name of the file system. -* `dns_name` - The DNS name for the filesystem per [documented convention](https://docs.aws.amazon.com/fsx/index.html#lang/en_us). - -## Import - -The FSx file systems can be imported using the `id`, e.g. - -``` -$ terraform import aws_fsx_file_system.example fs-543ab12b1ca672f33 -``` diff --git a/website/docs/r/fsx_lustre_file_system.html.markdown b/website/docs/r/fsx_lustre_file_system.html.markdown new file mode 100644 index 00000000000..c8695a61188 --- /dev/null +++ b/website/docs/r/fsx_lustre_file_system.html.markdown @@ -0,0 +1,75 @@ +--- +layout: "aws" +page_title: "AWS: aws_fsx_lustre_file_system" +sidebar_current: "docs-aws-resource-fsx-lustre-file-system" +description: |- + Manages a FSx Lustre File System. +--- + +# Resource: aws_fsx_lustre_file_system + +Manages a FSx Lustre File System. See the [FSx Lustre Guide](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) for more information. + +## Example Usage + +```hcl +resource "aws_fsx_lustre_file_system" "example" { + import_path = "s3://${aws_s3_bucket.example.bucket}" + storage_capacity = 3600 + subnet_ids = ["${aws_subnet.example.id}"] +} +``` + +## Argument Reference + +The following arguments are supported: + +* `storage_capacity` - (Required) The storage capacity (GiB) of the file system. Minimum of `3600`. Storage capacity is provisioned in increments of 3,600 GiB. +* `subnet_ids` - (Required) A list of IDs for the subnets that the file system will be accessible from. File systems currently support only one subnet. The file server is also launched in that subnet's Availability Zone. +* `export_path` - (Optional) S3 URI (with optional prefix) where the root of your Amazon FSx file system is exported. Can only be specified with `import_path` argument and the path must use the same Amazon S3 bucket as specified in `import_path`. Set equal to `import_path` to overwrite files on export. Defaults to `s3://{IMPORT BUCKET}/FSxLustre{CREATION TIMESTAMP}`. +* `import_path` - (Optional) S3 URI (with optional prefix) that you're using as the data repository for your FSx for Lustre file system. For example, `s3://example-bucket/optional-prefix/`. +* `imported_file_chunk_size` - (Optional) For files imported from a data repository, this value determines the stripe count and maximum amount of data per file (in MiB) stored on a single physical disk. Can only be specified with `import_path` argument. Defaults to `1024`. Minimum of `1` and maximum of `512000`. +* `security_group_ids` - (Optional) A list of IDs for the security groups that apply to the specified network interfaces created for file system access. These security groups will apply to all network interfaces. +* `tags` - (Optional) A mapping of tags to assign to the file system. +* `weekly_maintenance_start_time` - (Optional) The preferred start time (in `d:HH:MM` format) to perform weekly maintenance, in the UTC time zone. + +## Attributes Reference + +In addition to all arguments above, the following attributes are exported: + +* `arn` - Amazon Resource Name of the file system. +* `dns_name` - DNS name for the file system, e.g. `fs-12345678.fsx.us-west-2.amazonaws.com` +* `id` - Identifier of the file system, e.g. `fs-12345678` +* `network_interface_ids` - Set of Elastic Network Interface identifiers from which the file system is accessible. +* `owner_id` - AWS account identifier that created the file system. +* `vpc_id` - Identifier of the Virtual Private Cloud for the file system. + +## Timeouts + +`aws_fsx_lustre_file_system` provides the following [Timeouts](/docs/configuration/resources.html#timeouts) +configuration options: + +* `create` - (Default `30m`) How long to wait for the file system to be created. +* `delete` - (Default `30m`) How long to wait for the file system to be deleted. + +## Import + +FSx File Systems can be imported using the `id`, e.g. + +``` +$ terraform import aws_fsx_windows_file_system.example fs-543ab12b1ca672f33 +``` + +Certain resource arguments, like `security_group_ids`, do not have a FSx API method for reading the information after creation. If the argument is set in the Terraform configuration on an imported resource, Terraform will always show a difference. To workaround this behavior, either omit the argument from the Terraform configuration or use [`ignore_changes`](/docs/configuration/resources.html#ignore_changes) to hide the difference, e.g. + +```hcl +resource "aws_fsx_lustre_file_system" "example" { + # ... other configuration ... + security_group_ids = ["${aws_security_group.example.id}"] + + # There is no FSx API for reading security_group_ids + lifecycle { + ignore_changes = ["security_group_ids"] + } +} +``` diff --git a/website/docs/r/fsx_windows_file_system.html.markdown b/website/docs/r/fsx_windows_file_system.html.markdown new file mode 100644 index 00000000000..216426f0c24 --- /dev/null +++ b/website/docs/r/fsx_windows_file_system.html.markdown @@ -0,0 +1,119 @@ +--- +layout: "aws" +page_title: "AWS: aws_fsx_windows_file_system" +sidebar_current: "docs-aws-resource-fsx-windows-file-system" +description: |- + Manages a FSx Windows File System. +--- + +# Resource: aws_fsx_windows_file_system + +Manages a FSx Windows File System. See the [FSx Windows Guide](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) for more information. + +~> **NOTE:** Either the `active_directory_id` argument or `self_managed_active_directory` configuration block must be specified. + +## Example Usage + +### Using AWS Directory Service + +Additional information for using AWS Directory Service with Windows File Systems can be found in the [FSx Windows Guide](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/fsx-aws-managed-ad.html). + +```hcl +resource "aws_fsx_windows_file_system" "example" { + active_directory_id = "${aws_directory_service_directory.example.id}" + kms_key_id = "${aws_kms_key.example.arn}" + storage_capacity = 300 + subnet_ids = ["${aws_subnet.example.id}"] + throughput_capacity = 1024 +} +``` + +### Using a Self-Managed Microsoft Active Directory + +Additional information for using AWS Directory Service with Windows File Systems can be found in the [FSx Windows Guide](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/self-managed-AD.html). + +```hcl +resource "aws_fsx_windows_file_system" "example" { + kms_key_id = "${aws_kms_key.example.arn}" + storage_capacity = 300 + subnet_ids = ["${aws_subnet.example.id}"] + throughput_capacity = 1024 + + self_managed_active_directory { + dns_ips = ["10.0.0.111", "10.0.0.222"] + domain_name = "corp.example.com" + password = "avoid-plaintext-passwords" + username = "Admin" + } +} +``` + +## Argument Reference + +The following arguments are supported: + +* `storage_capacity` - (Required) Storage capacity (GiB) of the file system. Minimum of 300 and maximum of 65536. +* `subnet_ids` - (Required) A list of IDs for the subnets that the file system will be accessible from. File systems support only one subnet. The file server is also launched in that subnet's Availability Zone. +* `throughput_capacity` - (Required) Throughput (megabytes per second) of the file system in power of 2 increments. Minimum of `8` and maximum of `2048`. +* `active_directory_id` - (Optional) The ID for an existing Microsoft Active Directory instance that the file system should join when it's created. Cannot be specified with `self_managed_active_directory`. +* `automatic_backup_retention_days` - (Optional) The number of days to retain automatic backups. Minimum of `0` and maximum of `35`. Defaults to `7`. Set to `0` to disable. +* `copy_tags_to_backups` - (Optional) A boolean flag indicating whether tags on the file system should be copied to backups. Defaults to `false`. +* `daily_automatic_backup_start_time` - (Optional) The preferred time (in `HH:MM` format) to take daily automatic backups, in the UTC time zone. +* `kms_key_id` - (Optional) ARN for the KMS Key to encrypt the file system at rest. Defaults to an AWS managed KMS Key. +* `security_group_ids` - (Optional) A list of IDs for the security groups that apply to the specified network interfaces created for file system access. These security groups will apply to all network interfaces. +* `self_managed_active_directory` - (Optional) Configuration block that Amazon FSx uses to join the Windows File Server instance to your self-managed (including on-premises) Microsoft Active Directory (AD) directory. Cannot be specified with `active_directory_id`. Detailed below. +* `skip_final_snapshot` - (Optional) When enabled, will skip the default final backup taken when the file system is deleted. This configuration must be applied separately before attempting to delete the resource to have the desired behavior. Defaults to `false`. +* `tags` - (Optional) A mapping of tags to assign to the file system. +* `weekly_maintenance_start_time` - (Optional) The preferred start time (in `d:HH:MM` format) to perform weekly maintenance, in the UTC time zone. + +### self_managed_active_directory + +The following arguments are supported for `self_managed_active_directory` configuration block: + +* `dns_ips` - (Required) A list of up to two IP addresses of DNS servers or domain controllers in the self-managed AD directory. The IP addresses need to be either in the same VPC CIDR range as the file system or in the private IP version 4 (IPv4) address ranges as specified in [RFC 1918](https://tools.ietf.org/html/rfc1918). +* `domain_name` - (Required) The fully qualified domain name of the self-managed AD directory. For example, `corp.example.com`. +* `password` - (Required) The password for the service account on your self-managed AD domain that Amazon FSx will use to join to your AD domain. +* `username` - (Required) The user name for the service account on your self-managed AD domain that Amazon FSx will use to join to your AD domain. +* `file_system_administrators_group` - (Optional) The name of the domain group whose members are granted administrative privileges for the file system. Administrative privileges include taking ownership of files and folders, and setting audit controls (audit ACLs) on files and folders. The group that you specify must already exist in your domain. Defaults to `Domain Admins`. +* `organizational_unit_distinguished_name` - (Optional) The fully qualified distinguished name of the organizational unit within your self-managed AD directory that the Windows File Server instance will join. For example, `OU=FSx,DC=yourdomain,DC=corp,DC=com`. Only accepts OU as the direct parent of the file system. If none is provided, the FSx file system is created in the default location of your self-managed AD directory. To learn more, see [RFC 2253](https://tools.ietf.org/html/rfc2253). + +## Attributes Reference + +In addition to all arguments above, the following attributes are exported: + +* `arn` - Amazon Resource Name of the file system. +* `dns_name` - DNS name for the file system, e.g. `fs-12345678.corp.example.com` (domain name matching the Active Directory domain name) +* `id` - Identifier of the file system, e.g. `fs-12345678` +* `network_interface_ids` - Set of Elastic Network Interface identifiers from which the file system is accessible. +* `owner_id` - AWS account identifier that created the file system. +* `vpc_id` - Identifier of the Virtual Private Cloud for the file system. + +## Timeouts + +`aws_fsx_windows_file_system` provides the following [Timeouts](/docs/configuration/resources.html#timeouts) +configuration options: + +* `create` - (Default `30m`) How long to wait for the file system to be created. +* `delete` - (Default `30m`) How long to wait for the file system to be deleted. + +## Import + +FSx File Systems can be imported using the `id`, e.g. + +``` +$ terraform import aws_fsx_windows_file_system.example fs-543ab12b1ca672f33 +``` + +Certain resource arguments, like `security_group_ids` and the `self_managed_active_directory` configuation block `password`, do not have a FSx API method for reading the information after creation. If these arguments are set in the Terraform configuration on an imported resource, Terraform will always show a difference. To workaround this behavior, either omit the argument from the Terraform configuration or use [`ignore_changes`](/docs/configuration/resources.html#ignore_changes) to hide the difference, e.g. + +```hcl +resource "aws_fsx_windows_file_system" "example" { + # ... other configuration ... + security_group_ids = ["${aws_security_group.example.id}"] + + # There is no FSx API for reading security_group_ids + lifecycle { + ignore_changes = ["security_group_ids"] + } +} +``` From cc039acbdd192cc2869520d88a35a31933e78811 Mon Sep 17 00:00:00 2001 From: Brian Flad Date: Wed, 14 Aug 2019 09:35:21 -0400 Subject: [PATCH 7/8] Update website/docs/r/fsx_lustre_file_system.html.markdown Co-Authored-By: Ryn Daniels --- website/docs/r/fsx_lustre_file_system.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/website/docs/r/fsx_lustre_file_system.html.markdown b/website/docs/r/fsx_lustre_file_system.html.markdown index c8695a61188..71155b9af21 100644 --- a/website/docs/r/fsx_lustre_file_system.html.markdown +++ b/website/docs/r/fsx_lustre_file_system.html.markdown @@ -57,7 +57,7 @@ configuration options: FSx File Systems can be imported using the `id`, e.g. ``` -$ terraform import aws_fsx_windows_file_system.example fs-543ab12b1ca672f33 +$ terraform import aws_fsx_lustre_file_system.example fs-543ab12b1ca672f33 ``` Certain resource arguments, like `security_group_ids`, do not have a FSx API method for reading the information after creation. If the argument is set in the Terraform configuration on an imported resource, Terraform will always show a difference. To workaround this behavior, either omit the argument from the Terraform configuration or use [`ignore_changes`](/docs/configuration/resources.html#ignore_changes) to hide the difference, e.g. From f923aa6480e54b5a86b05a92a2bdab62a14227dc Mon Sep 17 00:00:00 2001 From: Ryn Daniels Date: Wed, 14 Aug 2019 16:24:47 +0200 Subject: [PATCH 8/8] Add test sweepers for fsx filesystems --- ...ce_aws_directory_service_directory_test.go | 5 +- ...esource_aws_fsx_lustre_file_system_test.go | 55 +++++++++++++++++ ...source_aws_fsx_windows_file_system_test.go | 59 +++++++++++++++++++ aws/resource_aws_subnet_test.go | 2 + 4 files changed, 119 insertions(+), 2 deletions(-) diff --git a/aws/resource_aws_directory_service_directory_test.go b/aws/resource_aws_directory_service_directory_test.go index ffbc21cb002..8cbd5b5118b 100644 --- a/aws/resource_aws_directory_service_directory_test.go +++ b/aws/resource_aws_directory_service_directory_test.go @@ -16,8 +16,9 @@ import ( func init() { resource.AddTestSweepers("aws_directory_service_directory", &resource.Sweeper{ - Name: "aws_directory_service_directory", - F: testSweepDirectoryServiceDirectories, + Name: "aws_directory_service_directory", + F: testSweepDirectoryServiceDirectories, + Dependencies: []string{"aws_fsx_windows_file_system"}, }) } diff --git a/aws/resource_aws_fsx_lustre_file_system_test.go b/aws/resource_aws_fsx_lustre_file_system_test.go index 94c6f17f204..8e0c3179a41 100644 --- a/aws/resource_aws_fsx_lustre_file_system_test.go +++ b/aws/resource_aws_fsx_lustre_file_system_test.go @@ -2,6 +2,7 @@ package aws import ( "fmt" + "log" "regexp" "testing" "time" @@ -13,6 +14,60 @@ import ( "github.com/hashicorp/terraform/terraform" ) +func init() { + resource.AddTestSweepers("aws_fsx_lustre_file_system", &resource.Sweeper{ + Name: "aws_fsx_lustre_file_system", + F: testSweepFSXLustreFileSystems, + }) +} + +func testSweepFSXLustreFileSystems(region string) error { + client, err := sharedClientForRegion(region) + if err != nil { + return fmt.Errorf("error getting client: %s", err) + } + conn := client.(*AWSClient).fsxconn + input := &fsx.DescribeFileSystemsInput{} + + err = conn.DescribeFileSystemsPages(input, func(page *fsx.DescribeFileSystemsOutput, lastPage bool) bool { + for _, fs := range page.FileSystems { + if aws.StringValue(fs.FileSystemType) != fsx.FileSystemTypeLustre { + continue + } + + input := &fsx.DeleteFileSystemInput{ + FileSystemId: fs.FileSystemId, + } + + log.Printf("[INFO] Deleting FSx lustre filesystem: %s", aws.StringValue(fs.FileSystemId)) + _, err := conn.DeleteFileSystem(input) + + if err != nil { + log.Printf("[ERROR] Error deleting FSx filesystem: %s", err) + continue + } + + if err := waitForFsxFileSystemDeletion(conn, aws.StringValue(fs.FileSystemId), 30*time.Minute); err != nil { + log.Printf("[ERROR] Error waiting for filesystem (%s) to delete: %s", aws.StringValue(fs.FileSystemId), err) + } + } + + return !lastPage + }) + + if testSweepSkipSweepError(err) { + log.Printf("[WARN] Skipping FSx Lustre Filesystem sweep for %s: %s", region, err) + return nil + } + + if err != nil { + return fmt.Errorf("error listing FSx Lustre Filesystems: %s", err) + } + + return nil + +} + func TestAccAWSFsxLustreFileSystem_basic(t *testing.T) { var filesystem fsx.FileSystem resourceName := "aws_fsx_lustre_file_system.test" diff --git a/aws/resource_aws_fsx_windows_file_system_test.go b/aws/resource_aws_fsx_windows_file_system_test.go index 01e0a1733c2..c617f427d21 100644 --- a/aws/resource_aws_fsx_windows_file_system_test.go +++ b/aws/resource_aws_fsx_windows_file_system_test.go @@ -2,6 +2,7 @@ package aws import ( "fmt" + "log" "regexp" "testing" "time" @@ -12,6 +13,64 @@ import ( "github.com/hashicorp/terraform/terraform" ) +func init() { + resource.AddTestSweepers("aws_fsx_windows_file_system", &resource.Sweeper{ + Name: "aws_fsx_windows_file_system", + F: testSweepFSXWindowsFileSystems, + }) +} + +func testSweepFSXWindowsFileSystems(region string) error { + client, err := sharedClientForRegion(region) + if err != nil { + return fmt.Errorf("error getting client: %s", err) + } + conn := client.(*AWSClient).fsxconn + input := &fsx.DescribeFileSystemsInput{} + + err = conn.DescribeFileSystemsPages(input, func(page *fsx.DescribeFileSystemsOutput, lastPage bool) bool { + for _, fs := range page.FileSystems { + if aws.StringValue(fs.FileSystemType) != fsx.FileSystemTypeWindows { + continue + } + + input := &fsx.DeleteFileSystemInput{ + ClientRequestToken: aws.String(resource.UniqueId()), + FileSystemId: fs.FileSystemId, + WindowsConfiguration: &fsx.DeleteFileSystemWindowsConfiguration{ + SkipFinalBackup: aws.Bool(true), + }, + } + + log.Printf("[INFO] Deleting FSx windows filesystem: %s", aws.StringValue(fs.FileSystemId)) + _, err := conn.DeleteFileSystem(input) + + if err != nil { + log.Printf("[ERROR] Error deleting FSx filesystem: %s", err) + continue + } + + if err := waitForFsxFileSystemDeletion(conn, aws.StringValue(fs.FileSystemId), 30*time.Minute); err != nil { + log.Printf("[ERROR] Error waiting for filesystem (%s) to delete: %s", aws.StringValue(fs.FileSystemId), err) + } + } + + return !lastPage + }) + + if testSweepSkipSweepError(err) { + log.Printf("[WARN] Skipping FSx Windows Filesystem sweep for %s: %s", region, err) + return nil + } + + if err != nil { + return fmt.Errorf("error listing FSx Windows Filesystems: %s", err) + } + + return nil + +} + func TestAccAWSFsxWindowsFileSystem_basic(t *testing.T) { var filesystem fsx.FileSystem resourceName := "aws_fsx_windows_file_system.test" diff --git a/aws/resource_aws_subnet_test.go b/aws/resource_aws_subnet_test.go index 0b2a87b73e0..e0c89109eab 100644 --- a/aws/resource_aws_subnet_test.go +++ b/aws/resource_aws_subnet_test.go @@ -33,6 +33,8 @@ func init() { "aws_elasticsearch_domain", "aws_elb", "aws_emr_cluster", + "aws_fsx_lustre_file_system", + "aws_fsx_windows_file_system", "aws_lambda_function", "aws_lb", "aws_mq_broker",