From 1718649f3b3011271e593c69d585671ff3382c12 Mon Sep 17 00:00:00 2001 From: anton-sidelnikov Date: Wed, 15 Jan 2025 11:08:16 +0100 Subject: [PATCH 1/2] [Fix] public zones in nl --- ...ource_opentelekomcloud_dns_zone_v2_test.go | 28 ++++ ...mport_opentelekomcloud_dns_zone_v2_test.go | 32 ---- ...ource_opentelekomcloud_dns_zone_v2_test.go | 151 +++++++++--------- .../resource_opentelekomcloud_dns_zone_v2.go | 85 +++++++++- 4 files changed, 180 insertions(+), 116 deletions(-) delete mode 100644 opentelekomcloud/acceptance/dns/import_opentelekomcloud_dns_zone_v2_test.go diff --git a/opentelekomcloud/acceptance/dns/data_source_opentelekomcloud_dns_zone_v2_test.go b/opentelekomcloud/acceptance/dns/data_source_opentelekomcloud_dns_zone_v2_test.go index feebf27c6..55af41f3c 100644 --- a/opentelekomcloud/acceptance/dns/data_source_opentelekomcloud_dns_zone_v2_test.go +++ b/opentelekomcloud/acceptance/dns/data_source_opentelekomcloud_dns_zone_v2_test.go @@ -2,11 +2,15 @@ package acceptance import ( "fmt" + "strings" "testing" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" + "github.com/opentelekomcloud/gophertelekomcloud/openstack/dns/v2/zones" + "github.com/opentelekomcloud/terraform-provider-opentelekomcloud/opentelekomcloud/acceptance/env" + "github.com/opentelekomcloud/terraform-provider-opentelekomcloud/opentelekomcloud/common/cfg" "github.com/opentelekomcloud/terraform-provider-opentelekomcloud/opentelekomcloud/acceptance/common" ) @@ -85,6 +89,30 @@ func TestAccOpenStackDNSZoneV2DataSource_private(t *testing.T) { }) } +func testAccCheckDNSV2ZoneDestroy(s *terraform.State) error { + config := common.TestAccProvider.Meta().(*cfg.Config) + client, err := config.DnsV2Client(env.OS_REGION_NAME) + if err != nil { + return fmt.Errorf("error creating OpenTelekomCloud DNS client: %s", err) + } + for _, rs := range s.RootModule().Resources { + if rs.Primary.Attributes["type"] == "public" && env.OS_REGION_NAME == "eu-nl" { + client.Endpoint = strings.Replace(client.Endpoint, "eu-nl", "eu-de", 1) + client.ResourceBase = strings.Replace(client.ResourceBase, "eu-nl", "eu-de", 1) + } + if rs.Type != "opentelekomcloud_dns_zone_v2" { + continue + } + + _, err := zones.Get(client, rs.Primary.ID).Extract() + if err == nil { + return fmt.Errorf("zone still exists") + } + } + + return nil +} + func testAccCheckDNSZoneV2DataSourceID(n string) resource.TestCheckFunc { return func(s *terraform.State) error { rs, ok := s.RootModule().Resources[n] diff --git a/opentelekomcloud/acceptance/dns/import_opentelekomcloud_dns_zone_v2_test.go b/opentelekomcloud/acceptance/dns/import_opentelekomcloud_dns_zone_v2_test.go deleted file mode 100644 index 232863781..000000000 --- a/opentelekomcloud/acceptance/dns/import_opentelekomcloud_dns_zone_v2_test.go +++ /dev/null @@ -1,32 +0,0 @@ -package acceptance - -import ( - "fmt" - "testing" - - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" - - "github.com/opentelekomcloud/terraform-provider-opentelekomcloud/opentelekomcloud/acceptance/common" -) - -func TestAccDNSV2Zone_importBasic(t *testing.T) { - var zoneName = fmt.Sprintf("accepttest%s.com.", acctest.RandString(5)) - - resource.Test(t, resource.TestCase{ - PreCheck: func() { common.TestAccPreCheck(t) }, - ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2ZoneDestroy, - Steps: []resource.TestStep{ - { - Config: testAccDNSV2ZoneBasic(zoneName), - }, - - { - ResourceName: resourceZoneName, - ImportState: true, - ImportStateVerify: true, - }, - }, - }) -} diff --git a/opentelekomcloud/acceptance/dns/resource_opentelekomcloud_dns_zone_v2_test.go b/opentelekomcloud/acceptance/dns/resource_opentelekomcloud_dns_zone_v2_test.go index 751cf3758..ea2d63ab0 100644 --- a/opentelekomcloud/acceptance/dns/resource_opentelekomcloud_dns_zone_v2_test.go +++ b/opentelekomcloud/acceptance/dns/resource_opentelekomcloud_dns_zone_v2_test.go @@ -18,25 +18,50 @@ import ( const resourceZoneName = "opentelekomcloud_dns_zone_v2.zone_1" +func getDnsZoneFunc(conf *cfg.Config, state *terraform.ResourceState) (interface{}, error) { + c, err := conf.DnsV2Client(env.OS_REGION_NAME) + if err != nil { + return nil, fmt.Errorf("error creating OpenTelekomCloud DNS v2 client: %s", err) + } + if state.Primary.Attributes["type"] == "public" && env.OS_REGION_NAME == "eu-nl" { + c.Endpoint = strings.Replace(c.Endpoint, "eu-nl", "eu-de", 1) + c.ResourceBase = strings.Replace(c.ResourceBase, "eu-nl", "eu-de", 1) + } + return zones.Get(c, state.Primary.ID).Extract() +} + func TestAccDNSV2Zone_basic(t *testing.T) { - var zone zones.Zone // TODO: Why does it lowercase names in back-end? - var zoneName = fmt.Sprintf("accepttest%s.com.", acctest.RandString(5)) + var ( + zone zones.Zone + zoneName = fmt.Sprintf("accbasictest%s.com.", acctest.RandString(5)) + ) + + rc := common.InitResourceCheck( + resourceZoneName, + &zone, + getDnsZoneFunc, + ) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheck(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2ZoneDestroy, + CheckDestroy: rc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccDNSV2ZoneBasic(zoneName), Check: resource.ComposeTestCheckFunc( - testAccCheckDNSV2ZoneExists(resourceZoneName, &zone), + rc.CheckResourceExists(), resource.TestCheckResourceAttr(resourceZoneName, "description", "a public zone"), resource.TestCheckResourceAttr(resourceZoneName, "tags.foo", "bar"), resource.TestCheckResourceAttr(resourceZoneName, "tags.key", "value"), ), }, + { + ResourceName: resourceZoneName, + ImportState: true, + ImportStateVerify: true, + }, { Config: testAccDNSV2ZoneUpdate(zoneName), Check: resource.ComposeTestCheckFunc( @@ -54,12 +79,21 @@ func TestAccDNSV2Zone_basic(t *testing.T) { } func TestAccDNSV2Zone_unDotted(t *testing.T) { - zoneName := randomZoneName() + var ( + zone zones.Zone + zoneName = randomZoneName() + ) + + rc := common.InitResourceCheck( + resourceZoneName, + &zone, + getDnsZoneFunc, + ) zoneName = strings.TrimSuffix(zoneName, ".") resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheck(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2ZoneDestroy, + CheckDestroy: rc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccDNSV2ZoneBasic(zoneName), @@ -69,20 +103,27 @@ func TestAccDNSV2Zone_unDotted(t *testing.T) { } func TestAccDNSV2Zone_private(t *testing.T) { - var zone zones.Zone - // TODO: Why does it lowercase names in back-end? - var zoneName = fmt.Sprintf("acpttest%s.com.", acctest.RandString(5)) + var ( + zone zones.Zone + zoneName = fmt.Sprintf("accprivatetest%s.com.", acctest.RandString(5)) + ) + + rc := common.InitResourceCheck( + resourceZoneName, + &zone, + getDnsZoneFunc, + ) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheck(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2ZoneDestroy, + CheckDestroy: rc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccDNSV2ZonePrivate(zoneName), // ExpectNonEmptyPlan: true, Check: resource.ComposeTestCheckFunc( - testAccCheckDNSV2ZoneExists(resourceZoneName, &zone), + rc.CheckResourceExists(), resource.TestCheckResourceAttr(resourceZoneName, "description", "a private zone"), resource.TestCheckResourceAttr(resourceZoneName, "type", "private"), resource.TestCheckResourceAttr(resourceZoneName, "tags.foo", "bar"), @@ -94,20 +135,26 @@ func TestAccDNSV2Zone_private(t *testing.T) { } func TestAccDNSV2Zone_readTTL(t *testing.T) { - var zone zones.Zone - var zoneName = fmt.Sprintf("ACPTTEST%s.com.", acctest.RandString(5)) + var ( + zone zones.Zone + zoneName = fmt.Sprintf("accttltest%s.com.", acctest.RandString(5)) + ) + + rc := common.InitResourceCheck( + resourceZoneName, + &zone, + getDnsZoneFunc, + ) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheck(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2ZoneDestroy, + CheckDestroy: rc.CheckResourceDestroy(), Steps: []resource.TestStep{ { - Config: testAccDNSV2ZoneReadTTL(zoneName), - ExpectNonEmptyPlan: true, + Config: testAccDNSV2ZoneReadTTL(zoneName), Check: resource.ComposeTestCheckFunc( - testAccCheckDNSV2ZoneExists(resourceZoneName, &zone), - // resource.TestCheckResourceAttr(resourceZoneName, "type", "PRIMARY"), + rc.CheckResourceExists(), resource.TestMatchResourceAttr(resourceZoneName, "ttl", regexp.MustCompile("^[0-9]+$")), ), }, @@ -117,18 +164,21 @@ func TestAccDNSV2Zone_readTTL(t *testing.T) { func TestAccDNSV2Zone_timeout(t *testing.T) { var zone zones.Zone - var zoneName = fmt.Sprintf("ACPTTEST%s.com.", acctest.RandString(5)) - + var zoneName = fmt.Sprintf("acctimeouttest%s.com.", acctest.RandString(5)) + rc := common.InitResourceCheck( + resourceZoneName, + &zone, + getDnsZoneFunc, + ) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheck(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2ZoneDestroy, + CheckDestroy: rc.CheckResourceDestroy(), Steps: []resource.TestStep{ { - Config: testAccDNSV2ZoneTimeout(zoneName), - ExpectNonEmptyPlan: true, + Config: testAccDNSV2ZoneTimeout(zoneName), Check: resource.ComposeTestCheckFunc( - testAccCheckDNSV2ZoneExists(resourceZoneName, &zone), + rc.CheckResourceExists(), ), }, }, @@ -149,59 +199,6 @@ func TestAccCheckDNSV2Zone_routerValidation(t *testing.T) { }) } -func testAccCheckDNSV2ZoneDestroy(s *terraform.State) error { - config := common.TestAccProvider.Meta().(*cfg.Config) - client, err := config.DnsV2Client(env.OS_REGION_NAME) - if err != nil { - return fmt.Errorf("error creating OpenTelekomCloud DNS client: %s", err) - } - - for _, rs := range s.RootModule().Resources { - if rs.Type != "opentelekomcloud_dns_zone_v2" { - continue - } - - _, err := zones.Get(client, rs.Primary.ID).Extract() - if err == nil { - return fmt.Errorf("zone still exists") - } - } - - return nil -} - -func testAccCheckDNSV2ZoneExists(n string, zone *zones.Zone) 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") - } - - config := common.TestAccProvider.Meta().(*cfg.Config) - client, err := config.DnsV2Client(env.OS_REGION_NAME) - if err != nil { - return fmt.Errorf("error creating OpenTelekomCloud DNS client: %s", err) - } - - found, err := zones.Get(client, rs.Primary.ID).Extract() - if err != nil { - return err - } - - if found.ID != rs.Primary.ID { - return fmt.Errorf("zone not found") - } - - *zone = *found - - return nil - } -} - func testAccDNSV2ZoneBasic(zoneName string) string { return fmt.Sprintf(` resource "opentelekomcloud_dns_zone_v2" "zone_1" { diff --git a/opentelekomcloud/services/dns/resource_opentelekomcloud_dns_zone_v2.go b/opentelekomcloud/services/dns/resource_opentelekomcloud_dns_zone_v2.go index d004ffe3c..d323c27d6 100644 --- a/opentelekomcloud/services/dns/resource_opentelekomcloud_dns_zone_v2.go +++ b/opentelekomcloud/services/dns/resource_opentelekomcloud_dns_zone_v2.go @@ -33,7 +33,7 @@ func ResourceDNSZoneV2() *schema.Resource { UpdateContext: resourceDNSZoneV2Update, DeleteContext: resourceDNSZoneV2Delete, Importer: &schema.ResourceImporter{ - StateContext: schema.ImportStatePassthroughContext, + StateContext: resourceDnsZoneV2ImportState, }, Timeouts: &schema.ResourceTimeout{ @@ -126,16 +126,19 @@ func resourceDNSRouter(d *schema.ResourceData) map[string]string { func resourceDNSZoneV2Create(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { config := meta.(*cfg.Config) + region := config.GetRegion(d) client, err := common.ClientFromCtx(ctx, keyClientV2, func() (*golangsdk.ServiceClient, error) { - return config.DnsV2Client(config.GetRegion(d)) + return config.DnsV2Client(region) }) if err != nil { return fmterr.Errorf(errCreationClient, err) } - zone_type := d.Get("type").(string) router := d.Get("router").(*schema.Set).List() + // Dirty hack for nl region without it impossible to create public zone + nlClientOverride(d, region, client) + // router is required when creating private zone if zone_type == "private" { if len(router) < 1 { @@ -237,13 +240,17 @@ func resourceDNSZoneV2Create(ctx context.Context, d *schema.ResourceData, meta i func resourceDNSZoneV2Read(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { config := meta.(*cfg.Config) + region := config.GetRegion(d) client, err := common.ClientFromCtx(ctx, keyClientV2, func() (*golangsdk.ServiceClient, error) { - return config.DnsV2Client(config.GetRegion(d)) + return config.DnsV2Client(region) }) if err != nil { return fmterr.Errorf(errCreationClient, err) } + // Dirty hack for nl region without it impossible to create public zone + nlClientOverride(d, region, client) + n, err := zones.Get(client, d.Id()).Extract() if err != nil { return common.CheckDeletedDiag(d, err, "zone") @@ -283,16 +290,19 @@ func resourceDNSZoneV2Read(ctx context.Context, d *schema.ResourceData, meta int func resourceDNSZoneV2Update(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { config := meta.(*cfg.Config) + region := config.GetRegion(d) client, err := common.ClientFromCtx(ctx, keyClientV2, func() (*golangsdk.ServiceClient, error) { - return config.DnsV2Client(config.GetRegion(d)) + return config.DnsV2Client(region) }) if err != nil { return fmterr.Errorf(errCreationClient, err) } - zone_type := d.Get("type").(string) router := d.Get("router").(*schema.Set).List() + // Dirty hack for nl region without it impossible to create public zone + nlClientOverride(d, region, client) + // router is required when updating private zone if zone_type == "private" { if len(router) < 1 { @@ -412,13 +422,17 @@ func resourceDNSZoneV2Update(ctx context.Context, d *schema.ResourceData, meta i func resourceDNSZoneV2Delete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { config := meta.(*cfg.Config) + region := config.GetRegion(d) client, err := common.ClientFromCtx(ctx, keyClientV2, func() (*golangsdk.ServiceClient, error) { - return config.DnsV2Client(config.GetRegion(d)) + return config.DnsV2Client(region) }) if err != nil { return fmterr.Errorf(errCreationClient, err) } + // Dirty hack for nl region without it impossible to create public zone + nlClientOverride(d, region, client) + _, err = zones.Delete(client, d.Id()).Extract() if err != nil { return fmterr.Errorf("error deleting OpenTelekomCloud DNS Zone: %s", err) @@ -447,6 +461,13 @@ func resourceDNSZoneV2Delete(ctx context.Context, d *schema.ResourceData, meta i return nil } +func nlClientOverride(d *schema.ResourceData, region string, client *golangsdk.ServiceClient) { + if d.Get("type").(string) == "public" && region == "eu-nl" { + client.Endpoint = strings.Replace(client.Endpoint, "eu-nl", "eu-de", 1) + client.ResourceBase = strings.Replace(client.ResourceBase, "eu-nl", "eu-de", 1) + } +} + func parseStatus(rawStatus string) string { // rawStatus maybe one of PENDING_CREATE, PENDING_UPDATE, PENDING_DELETE, ACTIVE, or ERROR splits := strings.Split(rawStatus, "_") @@ -577,3 +598,53 @@ func logHttpError(err error) error { } return err } + +func resourceDnsZoneV2ImportState(ctx context.Context, d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) { + config := meta.(*cfg.Config) + region := config.GetRegion(d) + client, err := common.ClientFromCtx(ctx, keyClientV2, func() (*golangsdk.ServiceClient, error) { + return config.DnsV2Client(region) + }) + if err != nil { + return []*schema.ResourceData{d}, fmt.Errorf(errCreationClient, err) + } + _, err = zones.Get(client, d.Id()).Extract() + if err != nil { + // Check if the region is "eu-nl" and attempt to retry with "eu-de" + if region == "eu-nl" { + client.Endpoint = strings.Replace(client.Endpoint, "eu-nl", "eu-de", 1) + client.ResourceBase = strings.Replace(client.ResourceBase, "eu-nl", "eu-de", 1) + zoneId := d.Id() + n, err := zones.Get(client, zoneId).Extract() + if err != nil { + return []*schema.ResourceData{d}, fmt.Errorf("error getting OpenTelekomCloud DNS zone from server: %s", err) + } + mErr := multierror.Append( + d.Set("name", n.Name), + d.Set("email", n.Email), + d.Set("description", n.Description), + d.Set("ttl", n.TTL), + d.Set("type", n.ZoneType), + d.Set("region", config.GetRegion(d)), + ) + if err := mErr.ErrorOrNil(); err != nil { + return []*schema.ResourceData{d}, fmt.Errorf("error saving OpenTelekomCloud DNS attributes to state: %s", err) + } + if err = d.Set("masters", n.Masters); err != nil { + return []*schema.ResourceData{d}, fmt.Errorf("error saving masters to state for OpenTelekomCloud DNS zone (%s): %s", d.Id(), err) + } + resourceTags, err := tags.Get(client, serviceMap[n.ZoneType], d.Id()).Extract() + if err != nil { + return []*schema.ResourceData{d}, fmt.Errorf("error fetching OpenTelekomCloud DNS zone tags: %s", err) + } + tagmap := common.TagsToMap(resourceTags) + if err := d.Set("tags", tagmap); err != nil { + return []*schema.ResourceData{d}, fmt.Errorf("error saving tags for OpenTelekomCloud DNS zone %s: %s", d.Id(), err) + } + return []*schema.ResourceData{d}, nil + } + return []*schema.ResourceData{d}, fmt.Errorf("error getting OpenTelekomCloud DNS zone from server: %s", err) + } + + return []*schema.ResourceData{d}, nil +} From a6348013fa9d41393803902af411491e62f32e97 Mon Sep 17 00:00:00 2001 From: anton-sidelnikov Date: Wed, 15 Jan 2025 14:37:22 +0100 Subject: [PATCH 2/2] [Fix] rework of all dns resources to make it works within nl region --- ...pentelekomcloud_dns_nameservers_v2_test.go | 3 +- ...ource_opentelekomcloud_dns_zone_v2_test.go | 39 +---- ..._opentelekomcloud_dns_recordset_v2_test.go | 29 ---- ..._opentelekomcloud_dns_recordset_v2_test.go | 157 +++++++++--------- ...rce_opentelekomcloud_dns_nameservers_v2.go | 19 ++- ...ata_source_opentelekomcloud_dns_zone_v2.go | 16 ++ ...ource_opentelekomcloud_dns_recordset_v2.go | 60 ++++++- 7 files changed, 176 insertions(+), 147 deletions(-) delete mode 100644 opentelekomcloud/acceptance/dns/import_opentelekomcloud_dns_recordset_v2_test.go diff --git a/opentelekomcloud/acceptance/dns/data_source_opentelekomcloud_dns_nameservers_v2_test.go b/opentelekomcloud/acceptance/dns/data_source_opentelekomcloud_dns_nameservers_v2_test.go index d1993e19d..cab3fb00e 100644 --- a/opentelekomcloud/acceptance/dns/data_source_opentelekomcloud_dns_nameservers_v2_test.go +++ b/opentelekomcloud/acceptance/dns/data_source_opentelekomcloud_dns_nameservers_v2_test.go @@ -12,11 +12,12 @@ const dataDNSNameserverName = "data.opentelekomcloud_dns_nameservers_v2.nameserv func TestAccDNSV2NameserverDataSource_basic(t *testing.T) { zoneName := randomZoneName() + dc := common.InitDataSourceCheck(dataZoneName) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheckRequiredEnvVars(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2ZoneDestroy, + CheckDestroy: dc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccDNSV2NameserverDataSource_nameserver(zoneName), diff --git a/opentelekomcloud/acceptance/dns/data_source_opentelekomcloud_dns_zone_v2_test.go b/opentelekomcloud/acceptance/dns/data_source_opentelekomcloud_dns_zone_v2_test.go index 55af41f3c..e7d87df5d 100644 --- a/opentelekomcloud/acceptance/dns/data_source_opentelekomcloud_dns_zone_v2_test.go +++ b/opentelekomcloud/acceptance/dns/data_source_opentelekomcloud_dns_zone_v2_test.go @@ -2,16 +2,11 @@ package acceptance import ( "fmt" - "strings" "testing" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" - "github.com/opentelekomcloud/gophertelekomcloud/openstack/dns/v2/zones" - "github.com/opentelekomcloud/terraform-provider-opentelekomcloud/opentelekomcloud/acceptance/env" - "github.com/opentelekomcloud/terraform-provider-opentelekomcloud/opentelekomcloud/common/cfg" - "github.com/opentelekomcloud/terraform-provider-opentelekomcloud/opentelekomcloud/acceptance/common" ) @@ -20,11 +15,12 @@ const dataZoneName = "data.opentelekomcloud_dns_zone_v2.z1" func TestAccOpenStackDNSZoneV2DataSource_basic(t *testing.T) { zone := randomZoneName() randZoneTag := fmt.Sprintf("value-%s", acctest.RandString(5)) + dc := common.InitDataSourceCheck(dataZoneName) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheckRequiredEnvVars(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2ZoneDestroy, + CheckDestroy: dc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccOpenStackDNSZoneV2DataSourceZone(zone, randZoneTag), @@ -32,6 +28,7 @@ func TestAccOpenStackDNSZoneV2DataSource_basic(t *testing.T) { { Config: testAccOpenStackDNSZoneV2DataSourceBasic(zone, randZoneTag), Check: resource.ComposeTestCheckFunc( + dc.CheckResourceExists(), testAccCheckDNSZoneV2DataSourceID(dataZoneName), resource.TestCheckResourceAttr(dataZoneName, "name", zone), resource.TestCheckResourceAttr(dataZoneName, "ttl", "3000"), @@ -49,11 +46,12 @@ func TestAccOpenStackDNSZoneV2DataSource_byTag(t *testing.T) { zone1 := randomZoneName() zone2 := randomZoneName() randZoneTag := fmt.Sprintf("value-%s", acctest.RandString(5)) + dc := common.InitDataSourceCheck(dataZoneName) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheckRequiredEnvVars(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2ZoneDestroy, + CheckDestroy: dc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccOpenStackDNSZoneV2DataSourceZone2(zone1, zone2, randZoneTag), @@ -70,11 +68,12 @@ func TestAccOpenStackDNSZoneV2DataSource_byTag(t *testing.T) { func TestAccOpenStackDNSZoneV2DataSource_private(t *testing.T) { zone1 := randomZoneName() + dc := common.InitDataSourceCheck(dataZoneName) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheckRequiredEnvVars(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2ZoneDestroy, + CheckDestroy: dc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccDNSV2ZonePrivate(zone1), @@ -89,30 +88,6 @@ func TestAccOpenStackDNSZoneV2DataSource_private(t *testing.T) { }) } -func testAccCheckDNSV2ZoneDestroy(s *terraform.State) error { - config := common.TestAccProvider.Meta().(*cfg.Config) - client, err := config.DnsV2Client(env.OS_REGION_NAME) - if err != nil { - return fmt.Errorf("error creating OpenTelekomCloud DNS client: %s", err) - } - for _, rs := range s.RootModule().Resources { - if rs.Primary.Attributes["type"] == "public" && env.OS_REGION_NAME == "eu-nl" { - client.Endpoint = strings.Replace(client.Endpoint, "eu-nl", "eu-de", 1) - client.ResourceBase = strings.Replace(client.ResourceBase, "eu-nl", "eu-de", 1) - } - if rs.Type != "opentelekomcloud_dns_zone_v2" { - continue - } - - _, err := zones.Get(client, rs.Primary.ID).Extract() - if err == nil { - return fmt.Errorf("zone still exists") - } - } - - return nil -} - func testAccCheckDNSZoneV2DataSourceID(n string) resource.TestCheckFunc { return func(s *terraform.State) error { rs, ok := s.RootModule().Resources[n] diff --git a/opentelekomcloud/acceptance/dns/import_opentelekomcloud_dns_recordset_v2_test.go b/opentelekomcloud/acceptance/dns/import_opentelekomcloud_dns_recordset_v2_test.go deleted file mode 100644 index 70ff490eb..000000000 --- a/opentelekomcloud/acceptance/dns/import_opentelekomcloud_dns_recordset_v2_test.go +++ /dev/null @@ -1,29 +0,0 @@ -package acceptance - -import ( - "testing" - - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" - - "github.com/opentelekomcloud/terraform-provider-opentelekomcloud/opentelekomcloud/acceptance/common" -) - -func TestAccDNSV2RecordSet_importBasic(t *testing.T) { - zoneName := randomZoneName() - - resource.Test(t, resource.TestCase{ - PreCheck: func() { common.TestAccPreCheck(t) }, - ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2RecordSetDestroy, - Steps: []resource.TestStep{ - { - Config: testAccDNSV2RecordSetBasic(zoneName), - }, - { - ResourceName: resourceRecordSetName, - ImportState: true, - ImportStateVerify: true, - }, - }, - }) -} diff --git a/opentelekomcloud/acceptance/dns/resource_opentelekomcloud_dns_recordset_v2_test.go b/opentelekomcloud/acceptance/dns/resource_opentelekomcloud_dns_recordset_v2_test.go index 6ca9df98c..d5c334c1d 100644 --- a/opentelekomcloud/acceptance/dns/resource_opentelekomcloud_dns_recordset_v2_test.go +++ b/opentelekomcloud/acceptance/dns/resource_opentelekomcloud_dns_recordset_v2_test.go @@ -9,7 +9,6 @@ import ( "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" - "github.com/opentelekomcloud/gophertelekomcloud/openstack/dns/v2/recordsets" "github.com/opentelekomcloud/terraform-provider-opentelekomcloud/opentelekomcloud/acceptance/common" @@ -25,19 +24,48 @@ func randomZoneName() string { return fmt.Sprintf("acpttest-zone-%s.com.", acctest.RandString(5)) } +func getDnsRecordSetFunc(conf *cfg.Config, state *terraform.ResourceState) (interface{}, error) { + c, err := conf.DnsV2Client(env.OS_REGION_NAME) + if err != nil { + return nil, fmt.Errorf("error creating OpenTelekomCloud DNS v2 client: %s", err) + } + zoneID, recordsetID, err := dns.ParseDNSV2RecordSetID(state.Primary.ID) + if err != nil { + return nil, err + } + rs, err := recordsets.Get(c, zoneID, recordsetID).Extract() + if err != nil { + if env.OS_REGION_NAME == "eu-nl" { + c.Endpoint = strings.Replace(c.Endpoint, "eu-nl", "eu-de", 1) + c.ResourceBase = strings.Replace(c.ResourceBase, "eu-nl", "eu-de", 1) + rs, err = recordsets.Get(c, zoneID, recordsetID).Extract() + if err != nil { + return nil, err + } + } + } + return rs, err +} + func TestAccDNSV2RecordSet_basic(t *testing.T) { var recordset recordsets.RecordSet zoneName := randomZoneName() + rc := common.InitResourceCheck( + resourceRecordSetName, + &recordset, + getDnsRecordSetFunc, + ) + resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheck(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2RecordSetDestroy, + CheckDestroy: rc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccDNSV2RecordSetBasic(zoneName), Check: resource.ComposeTestCheckFunc( - testAccCheckDNSV2RecordSetExists(resourceRecordSetName, &recordset), + rc.CheckResourceExists(), resource.TestCheckResourceAttr(resourceRecordSetName, "name", zoneName), resource.TestCheckResourceAttr(resourceRecordSetName, "description", "a record set"), resource.TestCheckResourceAttr(resourceRecordSetName, "type", "A"), @@ -53,6 +81,11 @@ func TestAccDNSV2RecordSet_basic(t *testing.T) { resource.TestCheckResourceAttr(resourceRecordSetName, "description", "an updated record set"), ), }, + { + ResourceName: resourceRecordSetName, + ImportState: true, + ImportStateVerify: true, + }, }, }) } @@ -60,10 +93,16 @@ func TestAccDNSV2RecordSet_basic(t *testing.T) { func TestAccDNSV2RecordSet_unDotted(t *testing.T) { zoneName := randomZoneName() zoneName = strings.TrimSuffix(zoneName, ".") + var recordset recordsets.RecordSet + rc := common.InitResourceCheck( + resourceRecordSetName, + &recordset, + getDnsRecordSetFunc, + ) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheck(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2RecordSetDestroy, + CheckDestroy: rc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccDNSV2RecordSetBasic(zoneName), @@ -75,10 +114,16 @@ func TestAccDNSV2RecordSet_unDotted(t *testing.T) { // TestAccDNSV2RecordSet_childFirst covers #847 func TestAccDNSV2RecordSet_childFirst(t *testing.T) { zoneName := randomZoneName() + var recordset recordsets.RecordSet + rc := common.InitResourceCheck( + resourceRecordSetName, + &recordset, + getDnsRecordSetFunc, + ) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheck(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2RecordSetDestroy, + CheckDestroy: rc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccDNSV2RecordSetChildFirst1(zoneName), @@ -93,16 +138,20 @@ func TestAccDNSV2RecordSet_childFirst(t *testing.T) { func TestAccDNSV2RecordSet_readTTL(t *testing.T) { var recordset recordsets.RecordSet zoneName := randomZoneName() - + rc := common.InitResourceCheck( + resourceRecordSetName, + &recordset, + getDnsRecordSetFunc, + ) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheck(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2RecordSetDestroy, + CheckDestroy: rc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccDNSV2RecordSetReadTTL(zoneName), Check: resource.ComposeTestCheckFunc( - testAccCheckDNSV2RecordSetExists(resourceRecordSetName, &recordset), + rc.CheckResourceExists(), resource.TestMatchResourceAttr(resourceRecordSetName, "ttl", regexp.MustCompile("^[0-9]+$")), ), }, @@ -113,16 +162,20 @@ func TestAccDNSV2RecordSet_readTTL(t *testing.T) { func TestAccDNSV2RecordSet_timeout(t *testing.T) { var recordset recordsets.RecordSet zoneName := randomZoneName() - + rc := common.InitResourceCheck( + resourceRecordSetName, + &recordset, + getDnsRecordSetFunc, + ) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheck(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2RecordSetDestroy, + CheckDestroy: rc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccDNSV2RecordSetTimeout(zoneName), Check: resource.ComposeTestCheckFunc( - testAccCheckDNSV2RecordSetExists(resourceRecordSetName, &recordset), + rc.CheckResourceExists(), ), }, }, @@ -132,11 +185,16 @@ func TestAccDNSV2RecordSet_timeout(t *testing.T) { func TestAccDNSV2RecordSet_shared(t *testing.T) { zoneName := randomZoneName() resourceRecordSet2Name := "opentelekomcloud_dns_recordset_v2.recordset_2" - + var recordset recordsets.RecordSet + rc := common.InitResourceCheck( + resourceRecordSetName, + &recordset, + getDnsRecordSetFunc, + ) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheck(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2RecordSetDestroy, + CheckDestroy: rc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccDNSV2RecordSetBasic(zoneName), @@ -161,16 +219,20 @@ func TestAccDNSV2RecordSet_shared(t *testing.T) { func TestAccDNSV2RecordSet_txt(t *testing.T) { var recordset recordsets.RecordSet zoneName := randomZoneName() - + rc := common.InitResourceCheck( + resourceRecordSetName, + &recordset, + getDnsRecordSetFunc, + ) resource.Test(t, resource.TestCase{ PreCheck: func() { common.TestAccPreCheck(t) }, ProviderFactories: common.TestAccProviderFactories, - CheckDestroy: testAccCheckDNSV2RecordSetDestroy, + CheckDestroy: rc.CheckResourceDestroy(), Steps: []resource.TestStep{ { Config: testAccDNSV2RecordSetTxt(zoneName), Check: resource.ComposeTestCheckFunc( - testAccCheckDNSV2RecordSetExists(resourceRecordSetName, &recordset), + rc.CheckResourceExists(), resource.TestCheckResourceAttr(resourceRecordSetName, "name", zoneName), resource.TestCheckResourceAttr(resourceRecordSetName, "description", "a record set"), resource.TestCheckResourceAttr(resourceRecordSetName, "type", "TXT"), @@ -190,69 +252,6 @@ func TestAccDNSV2RecordSet_txt(t *testing.T) { }) } -func testAccCheckDNSV2RecordSetDestroy(s *terraform.State) error { - config := common.TestAccProvider.Meta().(*cfg.Config) - client, err := config.DnsV2Client(env.OS_REGION_NAME) - if err != nil { - return fmt.Errorf("error creating OpenTelekomCloud DNS client: %s", err) - } - - for _, rs := range s.RootModule().Resources { - if rs.Type != "opentelekomcloud_dns_recordset_v2" { - continue - } - - zoneID, recordsetID, err := dns.ParseDNSV2RecordSetID(rs.Primary.ID) - if err != nil { - return err - } - - _, err = recordsets.Get(client, zoneID, recordsetID).Extract() - if err == nil { - return fmt.Errorf("record set still exists") - } - } - - return nil -} - -func testAccCheckDNSV2RecordSetExists(n string, recordset *recordsets.RecordSet) 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") - } - - config := common.TestAccProvider.Meta().(*cfg.Config) - client, err := config.DnsV2Client(env.OS_REGION_NAME) - if err != nil { - return fmt.Errorf("error creating OpenTelekomCloud DNS client: %s", err) - } - - zoneID, recordsetID, err := dns.ParseDNSV2RecordSetID(rs.Primary.ID) - if err != nil { - return err - } - - found, err := recordsets.Get(client, zoneID, recordsetID).Extract() - if err != nil { - return err - } - - if found.ID != recordsetID { - return fmt.Errorf("record set not found") - } - - *recordset = *found - - return nil - } -} - func testAccDNSV2RecordSetBasic(zoneName string) string { return fmt.Sprintf(` resource "opentelekomcloud_dns_zone_v2" "zone_1" { diff --git a/opentelekomcloud/services/dns/data_source_opentelekomcloud_dns_nameservers_v2.go b/opentelekomcloud/services/dns/data_source_opentelekomcloud_dns_nameservers_v2.go index e92bd579b..abf6ddea0 100644 --- a/opentelekomcloud/services/dns/data_source_opentelekomcloud_dns_nameservers_v2.go +++ b/opentelekomcloud/services/dns/data_source_opentelekomcloud_dns_nameservers_v2.go @@ -2,10 +2,12 @@ package dns import ( "context" + "strings" "github.com/hashicorp/go-multierror" "github.com/hashicorp/terraform-plugin-sdk/v2/diag" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" + golangsdk "github.com/opentelekomcloud/gophertelekomcloud" "github.com/opentelekomcloud/gophertelekomcloud/openstack/dns/v2/nameservers" "github.com/opentelekomcloud/terraform-provider-opentelekomcloud/opentelekomcloud/common" "github.com/opentelekomcloud/terraform-provider-opentelekomcloud/opentelekomcloud/common/cfg" @@ -54,7 +56,17 @@ func dataSourceDNSNameserverRead(_ context.Context, d *schema.ResourceData, meta if v, ok := d.GetOk("zone_id"); ok { allNameservers, err = nameservers.List(client, v.(string)).Extract() if err != nil { - return fmterr.Errorf("Failed to extract nameservers: %s", err) + // Check if the region is "eu-nl" and retry with "eu-de" + if config.GetRegion(d) == "eu-nl" { + replaceNlEndpoint(client) + // Retry the request after updating the endpoint + allNameservers, err = nameservers.List(client, v.(string)).Extract() + if err != nil { + return fmterr.Errorf("unable to retrieve nameservers: %w", err) + } + } else { + return fmterr.Errorf("unable to retrieve nameservers: %w", err) + } } } @@ -83,3 +95,8 @@ func dataSourceDNSNameserverRead(_ context.Context, d *schema.ResourceData, meta return nil } + +func replaceNlEndpoint(client *golangsdk.ServiceClient) { + client.Endpoint = strings.Replace(client.Endpoint, "eu-nl", "eu-de", 1) + client.ResourceBase = strings.Replace(client.ResourceBase, "eu-nl", "eu-de", 1) +} diff --git a/opentelekomcloud/services/dns/data_source_opentelekomcloud_dns_zone_v2.go b/opentelekomcloud/services/dns/data_source_opentelekomcloud_dns_zone_v2.go index 7fd6daf9b..e1af03be5 100644 --- a/opentelekomcloud/services/dns/data_source_opentelekomcloud_dns_zone_v2.go +++ b/opentelekomcloud/services/dns/data_source_opentelekomcloud_dns_zone_v2.go @@ -122,6 +122,7 @@ func dataSourceDNSZoneV2Read(_ context.Context, d *schema.ResourceData, meta int listOpts.Tags = common.ExpandResourceTags(tags) } + // Initial attempt to retrieve zones pages, err := zones.List(client, listOpts).AllPages() if err != nil { return fmterr.Errorf("unable to retrieve zones: %w", err) @@ -131,6 +132,21 @@ func dataSourceDNSZoneV2Read(_ context.Context, d *schema.ResourceData, meta int if err != nil { return fmterr.Errorf("unable to extract zones: %w", err) } + if allZones == nil { + // Check if the region is "eu-nl" and retry with "eu-de" + if config.GetRegion(d) == "eu-nl" { + replaceNlEndpoint(client) + // Retry the request after updating the endpoint + pages, err = zones.List(client, listOpts).AllPages() + if err != nil { + return fmterr.Errorf("unable to retrieve zones: %w", err) + } + allZones, err = zones.ExtractZones(pages) + if err != nil { + return fmterr.Errorf("unable to extract zones: %w", err) + } + } + } if len(allZones) < 1 { return fmterr.Errorf("your query returned no results. " + diff --git a/opentelekomcloud/services/dns/resource_opentelekomcloud_dns_recordset_v2.go b/opentelekomcloud/services/dns/resource_opentelekomcloud_dns_recordset_v2.go index fd6d15363..ec284c4be 100644 --- a/opentelekomcloud/services/dns/resource_opentelekomcloud_dns_recordset_v2.go +++ b/opentelekomcloud/services/dns/resource_opentelekomcloud_dns_recordset_v2.go @@ -155,7 +155,17 @@ func resourceDNSRecordSetV2Create(ctx context.Context, d *schema.ResourceData, m log.Printf("[DEBUG] Create Options: %#v", createOpts) recordSet, err := recordsets.Create(client, zoneID, createOpts).Extract() if err != nil { - return fmterr.Errorf("error creating OpenTelekomCloud DNS record set: %s", err) + // Check if the region is "eu-nl" and retry with "eu-de" + if config.GetRegion(d) == "eu-nl" { + replaceNlEndpoint(client) + // Retry the request after updating the endpoint + recordSet, err = recordsets.Create(client, zoneID, createOpts).Extract() + if err != nil { + return fmterr.Errorf("error creating OpenTelekomCloud DNS record set: %s", err) + } + } else { + return fmterr.Errorf("error creating OpenTelekomCloud DNS record set: %s", err) + } } log.Printf("[DEBUG] Waiting for DNS record set (%s) to become available", recordSet.ID) @@ -215,7 +225,17 @@ func resourceDNSRecordSetV2Read(ctx context.Context, d *schema.ResourceData, met n, err := recordsets.Get(client, zoneID, recordsetID).Extract() if err != nil { - return common.CheckDeletedDiag(d, err, "record_set") + // Check if the region is "eu-nl" and retry with "eu-de" + if config.GetRegion(d) == "eu-nl" { + replaceNlEndpoint(client) + // Retry the request after updating the endpoint + n, err = recordsets.Get(client, zoneID, recordsetID).Extract() + if err != nil { + return common.CheckDeletedDiag(d, err, "record_set") + } + } else { + return common.CheckDeletedDiag(d, err, "record_set") + } } records := make([]string, len(n.Records)) @@ -303,7 +323,17 @@ func resourceDNSRecordSetV2Update(ctx context.Context, d *schema.ResourceData, m _, err = recordsets.Update(client, zoneID, recordsetID, updateOpts).Extract() if err != nil { - return fmterr.Errorf("error updating OpenTelekomCloud DNS record set: %s", err) + // Check if the region is "eu-nl" and retry with "eu-de" + if config.GetRegion(d) == "eu-nl" { + replaceNlEndpoint(client) + // Retry the request after updating the endpoint + _, err = recordsets.Update(client, zoneID, recordsetID, updateOpts).Extract() + if err != nil { + return fmterr.Errorf("error updating OpenTelekomCloud DNS record set: %s", err) + } + } else { + return fmterr.Errorf("error updating OpenTelekomCloud DNS record set: %s", err) + } } log.Printf("[DEBUG] Waiting for DNS record set (%s) to update", recordsetID) @@ -363,7 +393,17 @@ func resourceDNSRecordSetV2Delete(ctx context.Context, d *schema.ResourceData, m err = recordsets.Delete(client, zoneID, recordsetID).ExtractErr() if err != nil { - return fmterr.Errorf("error deleting OpenTelekomCloud DNS record set: %s", err) + // Check if the region is "eu-nl" and retry with "eu-de" + if config.GetRegion(d) == "eu-nl" { + replaceNlEndpoint(client) + // Retry the request after updating the endpoint + err = recordsets.Delete(client, zoneID, recordsetID).ExtractErr() + if err != nil { + return fmterr.Errorf("error deleting OpenTelekomCloud DNS record set: %s", err) + } + } else { + return fmterr.Errorf("error deleting OpenTelekomCloud DNS record set: %s", err) + } } log.Printf("[DEBUG] Waiting for DNS record set (%s) to be deleted", recordsetID) @@ -456,7 +496,17 @@ func getExistingRecordSetID(d cfg.SchemaOrDiff, meta interface{}) (id string, er allPages, err := recordsets.ListByZone(client, zoneID, listOpts).AllPages() if err != nil { - return "", fmt.Errorf("error listing record sets: %s", err) + // Check if the region is "eu-nl" and retry with "eu-de" + if config.GetRegion(d) == "eu-nl" { + replaceNlEndpoint(client) + // Retry the request after updating the endpoint + allPages, err = recordsets.ListByZone(client, zoneID, listOpts).AllPages() + if err != nil { + return "", fmt.Errorf("error listing record sets: %s", err) + } + } else { + return "", fmt.Errorf("error listing record sets: %s", err) + } } sets, err := recordsets.ExtractRecordSets(allPages) if err != nil {