From 11226f4f8901a2c35dc34550a009395d54f4f84a Mon Sep 17 00:00:00 2001 From: Deatcu Andrei-Cristian Date: Wed, 7 Feb 2024 20:50:13 +0200 Subject: [PATCH] Feature: add remaining IonosCloud resources (#1834) * doc: fix typo in documentation * doc: add template for PRs * fix: fix PR template * fead: add support for Certificate Manager * feat: implement Private CrossConnect * fix: use proper depth for API calls * feat: implement S3 keys * fix: rename a variable and fix a typo in a warning message (#12) * feat: add support for Container Registry (#11) * feat: add support for Data Platform (#13) * feat: add support for IONOSCLOUD shares (#14) * feat: add support for IONOSCLOUD users (#15) * feat: add support for CUBE and VCPU servers (#17) * feat: add support for Container Registry Tokens (#18) * feat: add support for ALB forwarding rules (#19) * feat: Add support for DBaaS Mongo Clusters (#22) * feat: add support for DNS Zones (#20) * feat: add support for DNS Zones * fix: Modify user agent and update documentation with info about mongo clusters * feat: add support for DNS Records (#23) * feat: add support for DBaaS Mongo Users (#24) * feat: add support for DBaaS PgSQL users (#25) * feat: add support for DBaaS PgSQL databases (#26) * feat: add support for Logging Pipelines (#28) * feat: add support for IP failover groups (#27) * refactor: fix linter errors (#29) --- docs/ionoscloud.md | 20 ++- go.mod | 9 +- go.sum | 18 ++- ...plication_load_balancer_forwarding_rule.go | 70 +++++++++ providers/ionoscloud/certificate.go | 44 ++++++ providers/ionoscloud/container_registry.go | 44 ++++++ .../ionoscloud/container_registry_token.go | 55 +++++++ providers/ionoscloud/dataplatform_cluster.go | 44 ++++++ .../ionoscloud/dataplatform_node_pool.go | 55 +++++++ providers/ionoscloud/dbaas_mongo_cluster.go | 43 ++++++ providers/ionoscloud/dbaas_mongo_user.go | 55 +++++++ ...baas_cluster.go => dbaas_pgsql_cluster.go} | 8 +- providers/ionoscloud/dbaas_pgsql_database.go | 54 +++++++ providers/ionoscloud/dbaas_pgsql_user.go | 54 +++++++ providers/ionoscloud/dns_record.go | 55 +++++++ providers/ionoscloud/dns_zone.go | 44 ++++++ providers/ionoscloud/helpers/constants.go | 6 + providers/ionoscloud/ionoscloud_provider.go | 58 +++++--- providers/ionoscloud/ionoscloud_service.go | 139 ++++++++++++++++-- providers/ionoscloud/ipfailover.go | 60 ++++++++ providers/ionoscloud/kubernetes_node_pool.go | 2 +- providers/ionoscloud/lan.go | 6 +- providers/ionoscloud/logging_pipeline.go | 44 ++++++ providers/ionoscloud/nic.go | 4 +- providers/ionoscloud/private_crossconnect.go | 44 ++++++ providers/ionoscloud/s3_key.go | 50 +++++++ providers/ionoscloud/server.go | 21 ++- providers/ionoscloud/share.go | 49 ++++++ providers/ionoscloud/user.go | 39 +++++ providers/ionoscloud/volume.go | 2 +- 30 files changed, 1151 insertions(+), 45 deletions(-) create mode 100644 providers/ionoscloud/application_load_balancer_forwarding_rule.go create mode 100644 providers/ionoscloud/certificate.go create mode 100644 providers/ionoscloud/container_registry.go create mode 100644 providers/ionoscloud/container_registry_token.go create mode 100644 providers/ionoscloud/dataplatform_cluster.go create mode 100644 providers/ionoscloud/dataplatform_node_pool.go create mode 100644 providers/ionoscloud/dbaas_mongo_cluster.go create mode 100644 providers/ionoscloud/dbaas_mongo_user.go rename providers/ionoscloud/{dbaas_cluster.go => dbaas_pgsql_cluster.go} (86%) create mode 100644 providers/ionoscloud/dbaas_pgsql_database.go create mode 100644 providers/ionoscloud/dbaas_pgsql_user.go create mode 100644 providers/ionoscloud/dns_record.go create mode 100644 providers/ionoscloud/dns_zone.go create mode 100644 providers/ionoscloud/ipfailover.go create mode 100644 providers/ionoscloud/logging_pipeline.go create mode 100644 providers/ionoscloud/private_crossconnect.go create mode 100644 providers/ionoscloud/s3_key.go create mode 100644 providers/ionoscloud/share.go create mode 100644 providers/ionoscloud/user.go diff --git a/docs/ionoscloud.md b/docs/ionoscloud.md index 8d2b03df50..b44eceb2cc 100644 --- a/docs/ionoscloud.md +++ b/docs/ionoscloud.md @@ -34,7 +34,25 @@ export IONOS_TOKEN="token" * [`application_loadbalancer`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/application_loadbalancer) * [`networkloadbalancer_forwardingrule`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/networkloadbalancer_forwardingrule) * [`loadbalancer`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/loadbalancer) -* [`dbaas_pgsql_cluster`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/dbaas_pgsql_cluster) +* [`pg_cluster`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/dbaas_pgsql_cluster) +* [`pg_user`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/dbaas_pgsql_user) +* [`pg_database`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/dbaas_pgsql_database) +* [`mongo_cluster`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/dbaas_mongo_cluster) +* [`mongo_user`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/dbaas_mongo_user) +* [`certificate`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/certificate) +* [`private_crossconnect`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/private_crossconnect) +* [`s3_key`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/s3_key) +* [`container_registry`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/container_registry) +* [`dataplatform_cluster`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/dataplatform_cluster) +* [`dataplatform_node_pool`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/dataplatform_node_pool) +* [`share`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/share) +* [`user`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/user) +* [`container_registry_token`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/container_registry_token) +* [`application_loadbalancer_forwardingrule`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/application_loadbalancer_forwardingrule) +* [`dns_zone`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/dns_zone) +* [`dns_record`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/dns_record) +* [`logging_pipeline`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/logging_pipeline) +* [`ipfailover`](https://registry.terraform.io/providers/ionos-cloud/ionoscloud/latest/docs/resources/ipfailover) We allow only resources that provide valid terraform plans to be imported. If you do not see your resource in the tf plan, please enable TF_LOG=debug and check logs diff --git a/go.mod b/go.mod index f6a480ee89..326d6e82de 100644 --- a/go.mod +++ b/go.mod @@ -136,7 +136,8 @@ require ( github.com/hokaccha/go-prettyjson v0.0.0-20210113012101-fb4e108d2519 // indirect github.com/honeycombio/terraform-provider-honeycombio v0.10.0 github.com/iancoleman/strcase v0.0.0-20191112232945-16388991a334 - github.com/ionos-cloud/sdk-go-dbaas-postgres v1.0.3 + github.com/ionos-cloud/sdk-go-dbaas-mongo v1.3.1 + github.com/ionos-cloud/sdk-go-dbaas-postgres v1.1.2 github.com/ionos-cloud/sdk-go/v6 v6.1.3 github.com/jefferai/jsonx v1.0.1 // indirect github.com/jmespath/go-jmespath v0.4.0 @@ -392,6 +393,12 @@ require ( ) require ( + github.com/gofrs/uuid/v3 v3.1.2 + github.com/ionos-cloud/sdk-go-cert-manager v1.0.0 + github.com/ionos-cloud/sdk-go-container-registry v1.0.0 + github.com/ionos-cloud/sdk-go-dataplatform v1.0.1 + github.com/ionos-cloud/sdk-go-dns v1.1.1 + github.com/ionos-cloud/sdk-go-logging v1.0.1 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/as v1.0.392 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cbs v1.0.392 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cdb v1.0.392 diff --git a/go.sum b/go.sum index 9c2aec131a..25b6427b0f 100644 --- a/go.sum +++ b/go.sum @@ -782,6 +782,8 @@ github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5x github.com/godbus/dbus/v5 v5.0.6/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/gofrs/uuid v3.2.0+incompatible h1:y12jRkkFxsd7GpqdSZ+/KCs/fJbqpEXSGd4+jfEaewE= github.com/gofrs/uuid v3.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= +github.com/gofrs/uuid/v3 v3.1.2 h1:V3IBv1oU82x6YIr5txe3azVHgmOKYdyKQTowm9moBlY= +github.com/gofrs/uuid/v3 v3.1.2/go.mod h1:xPwMqoocQ1L5G6pXX5BcE7N5jlzn2o19oqAKxwZW/kI= github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= @@ -1063,8 +1065,20 @@ github.com/imdario/mergo v0.3.13 h1:lFzP57bqS/wsqKssCGmtLAb8A0wKjLGrve2q3PPVcBk= github.com/imdario/mergo v0.3.13/go.mod h1:4lJ1jqUDcsbIECGy0RUJAXNIhg+6ocWgb1ALK2O4oXg= github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= -github.com/ionos-cloud/sdk-go-dbaas-postgres v1.0.3 h1:ahzztBNJ1IcQL+hdzhek6234P4ednkqdOgTsfB0nEfE= -github.com/ionos-cloud/sdk-go-dbaas-postgres v1.0.3/go.mod h1:87cFAQViqjorhuafmYIDCmCTr5GiaqDB7qr09K1gdOU= +github.com/ionos-cloud/sdk-go-cert-manager v1.0.0 h1:pPIhdjTB3rjP9x3Cf6B4j8NTZ1u2v/w7/0h7GtFs/Ig= +github.com/ionos-cloud/sdk-go-cert-manager v1.0.0/go.mod h1:nFzMT0UNtNiLIuDGYj8pulHFQiVVql43oEX/eQIyr5Q= +github.com/ionos-cloud/sdk-go-container-registry v1.0.0 h1:03FKtFfHdOPZdXxRAFWgivbhmkyY4xk+R79EffoFt/4= +github.com/ionos-cloud/sdk-go-container-registry v1.0.0/go.mod h1:AtjqGZWAvd5J1rRR0wHhZ8nMrR/yJm45z8KB3p8rrvs= +github.com/ionos-cloud/sdk-go-dataplatform v1.0.1 h1:3BeDDlHl9mQAYmgdg8EsgsXbPMDfL4pJhXzmTPHNpA0= +github.com/ionos-cloud/sdk-go-dataplatform v1.0.1/go.mod h1:YitNqq01IAbzMr1GpXIDW1+pvhiY9eUs7/+rB9UitXE= +github.com/ionos-cloud/sdk-go-dbaas-mongo v1.3.1 h1:+tDoZ8IEPxYwJd6fDIpWksNJs9Zzw7Pu5A39jTew058= +github.com/ionos-cloud/sdk-go-dbaas-mongo v1.3.1/go.mod h1:rxOAeyAU6BTfghJibSRDdRNrKm2cIXMpSMe7JIWewJ8= +github.com/ionos-cloud/sdk-go-dbaas-postgres v1.1.2 h1:AaKbci+kVS6/k43VwJwmXxCJ7pzj9jwuOPqO8Wd5560= +github.com/ionos-cloud/sdk-go-dbaas-postgres v1.1.2/go.mod h1:nmJEwuRX65A5/PxwvdFW0XrV+N6WFYnMV1TiIafAwz4= +github.com/ionos-cloud/sdk-go-dns v1.1.1 h1:Qdf5mXYt9ZeRl4zZQxGrvamFkKm1X9WeARyB9/WYhKg= +github.com/ionos-cloud/sdk-go-dns v1.1.1/go.mod h1:l9gYdwtUshlBOiIi4nHn3RCX81XlV3VoNvLJrO2VfHg= +github.com/ionos-cloud/sdk-go-logging v1.0.1 h1:MB9jPoBUL3mZ+ois7kXYy67x0FopAw2aihMGdr2wu1k= +github.com/ionos-cloud/sdk-go-logging v1.0.1/go.mod h1:P2JQJpUgH3ZyfyJmv6jMwcB1NJIVVZSL+/bllhWpwc8= github.com/ionos-cloud/sdk-go/v6 v6.1.3 h1:vb6yqdpiqaytvreM0bsn2pXw+1YDvEk2RKSmBAQvgDQ= github.com/ionos-cloud/sdk-go/v6 v6.1.3/go.mod h1:Ox3W0iiEz0GHnfY9e5LmAxwklsxguuNFEUSu0gVRTME= github.com/jefferai/jsonx v1.0.1 h1:GvWkLWihoLqDG0BSP45TUQJH9qsINX50PVrFULgpc/I= diff --git a/providers/ionoscloud/application_load_balancer_forwarding_rule.go b/providers/ionoscloud/application_load_balancer_forwarding_rule.go new file mode 100644 index 0000000000..6ea4e7d49a --- /dev/null +++ b/providers/ionoscloud/application_load_balancer_forwarding_rule.go @@ -0,0 +1,70 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type ALBForwardingRuleGenerator struct { + Service +} + +func (g *ALBForwardingRuleGenerator) InitResources() error { + client := g.generateClient() + cloudAPIClient := client.CloudAPIClient + resourceType := "ionoscloud_application_loadbalancer_forwardingrule" + datacenters, err := helpers.GetAllDatacenters(*cloudAPIClient) + if err != nil { + return err + } + for _, datacenter := range datacenters { + applicationLoadBalancerResponse, _, err := cloudAPIClient.ApplicationLoadBalancersApi.DatacentersApplicationloadbalancersGet(context.TODO(), *datacenter.Id).Depth(1).Execute() + if err != nil { + return err + } + if applicationLoadBalancerResponse.Items == nil { + log.Printf( + "[WARNING] expected a response containing application load balancers but received 'nil' instead, skipping search for datacenter with ID: %v", + *datacenter.Id) + continue + } + applicationLoadBalancers := *applicationLoadBalancerResponse.Items + for _, applicationLoadBalancer := range applicationLoadBalancers { + if applicationLoadBalancer.Properties == nil || applicationLoadBalancer.Properties.Name == nil { + log.Printf( + "[WARNING] 'nil' values in the response for application load balancer with ID %v, datacenter ID: %v, skipping this resource", + *applicationLoadBalancer.Id, + *datacenter.Id, + ) + continue + } + albForwardingRulesResponse, _, err := cloudAPIClient.ApplicationLoadBalancersApi.DatacentersApplicationloadbalancersForwardingrulesGet(context.TODO(), *datacenter.Id, *applicationLoadBalancer.Id).Depth(1).Execute() + if err != nil { + return err + } + if albForwardingRulesResponse.Items == nil { + log.Printf("[WARNING] expected a response containing ALB forwarding rules but received 'nil' instead, skipping search for ALB with ID: %v, datacenter ID: %v", *applicationLoadBalancer.Id, *datacenter.Id) + continue + } + albForwardingRules := *albForwardingRulesResponse.Items + for _, albForwardingRule := range albForwardingRules { + if albForwardingRule.Properties == nil || albForwardingRule.Properties.Name == nil { + log.Printf("[WARNING] 'nil' values in the response for ALB forwarding rule with ID: %v, ALB ID: %v, datacenter ID: %v, skipping this resource", *albForwardingRule.Id, *applicationLoadBalancer.Id, *datacenter.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *albForwardingRule.Id, + *albForwardingRule.Properties.Name+"-"+*albForwardingRule.Id, + resourceType, + helpers.Ionos, + map[string]string{"application_loadbalancer_id": *applicationLoadBalancer.Id, helpers.DcID: *datacenter.Id}, + []string{}, + map[string]interface{}{})) + } + } + } + return nil +} diff --git a/providers/ionoscloud/certificate.go b/providers/ionoscloud/certificate.go new file mode 100644 index 0000000000..1b9823f824 --- /dev/null +++ b/providers/ionoscloud/certificate.go @@ -0,0 +1,44 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type CertificateGenerator struct { + Service +} + +func (g *CertificateGenerator) InitResources() error { + client := g.generateClient() + certManagerAPIClient := client.CertificateManagerAPIClient + resourceType := "ionoscloud_certificate" + + response, _, err := certManagerAPIClient.CertificatesApi.CertificatesGet(context.TODO()).Execute() + if err != nil { + return err + } + if response.Items == nil { + log.Printf("[WARNING] expected a response containing certificates but received 'nil' instead.") + return nil + } + certificates := *response.Items + for _, certificate := range certificates { + if certificate.Properties == nil || certificate.Properties.Name == nil { + log.Printf("[WARNING] 'nil' values in the response for the certificate with ID %v, skipping this resource.", *certificate.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *certificate.Id, + *certificate.Properties.Name+"-"+*certificate.Id, + resourceType, + helpers.Ionos, + map[string]string{}, + []string{}, + map[string]interface{}{})) + } + return nil +} diff --git a/providers/ionoscloud/container_registry.go b/providers/ionoscloud/container_registry.go new file mode 100644 index 0000000000..253f38c7f4 --- /dev/null +++ b/providers/ionoscloud/container_registry.go @@ -0,0 +1,44 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type ContainerRegistryGenerator struct { + Service +} + +func (g *ContainerRegistryGenerator) InitResources() error { + client := g.generateClient() + containerRegistryAPIClient := client.ContainerRegistryAPIClient + resourceType := "ionoscloud_container_registry" + + response, _, err := containerRegistryAPIClient.RegistriesApi.RegistriesGet(context.TODO()).Execute() + if err != nil { + return err + } + if response.Items == nil { + log.Printf("[WARNING] expected a response containing registries but received 'nil' instead.") + return nil + } + registries := *response.Items + for _, registry := range registries { + if registry.Properties == nil || registry.Properties.Name == nil { + log.Printf("[WARNING] 'nil' values in the response for the registry with ID %v, skipping this resource.", *registry.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *registry.Id, + *registry.Properties.Name+"-"+*registry.Id, + resourceType, + helpers.Ionos, + map[string]string{}, + []string{}, + map[string]interface{}{})) + } + return nil +} diff --git a/providers/ionoscloud/container_registry_token.go b/providers/ionoscloud/container_registry_token.go new file mode 100644 index 0000000000..54d757ecd3 --- /dev/null +++ b/providers/ionoscloud/container_registry_token.go @@ -0,0 +1,55 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type ContainerRegistryTokenGenerator struct { + Service +} + +func (g *ContainerRegistryTokenGenerator) InitResources() error { + client := g.generateClient() + crClient := client.ContainerRegistryAPIClient + resourceType := "ionoscloud_container_registry_token" + + registriesResponse, _, err := crClient.RegistriesApi.RegistriesGet(context.TODO()).Execute() + if err != nil { + return err + } + if registriesResponse.Items == nil { + log.Printf("[WARNING] expected a response containing registries but received 'nil' instead") + return nil + } + registries := *registriesResponse.Items + for _, registry := range registries { + tokensResponse, _, err := crClient.TokensApi.RegistriesTokensGet(context.TODO(), *registry.Id).Execute() + if err != nil { + return err + } + if tokensResponse.Items == nil { + log.Printf("[WARNING] expected a response containing container registry tokens, but received 'nil' instead") + return nil + } + crTokens := *tokensResponse.Items + for _, crToken := range crTokens { + if crToken.Properties == nil || crToken.Properties.Name == nil { + log.Printf("[WARNING] 'nil' values in the response for the container registry token with ID: %v, skipping this resource", *crToken.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *crToken.Id, + *crToken.Properties.Name+"-"+*crToken.Id, + resourceType, + helpers.Ionos, + map[string]string{"registry_id": *registry.Id}, + []string{}, + map[string]interface{}{})) + } + } + return nil +} diff --git a/providers/ionoscloud/dataplatform_cluster.go b/providers/ionoscloud/dataplatform_cluster.go new file mode 100644 index 0000000000..cc9feb57e7 --- /dev/null +++ b/providers/ionoscloud/dataplatform_cluster.go @@ -0,0 +1,44 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type DataPlatformClusterGenerator struct { + Service +} + +func (g *DataPlatformClusterGenerator) InitResources() error { + client := g.generateClient() + dataPlatformClient := client.DataPlatformAPIClient + resourceType := "ionoscloud_dataplatform_cluster" + + response, _, err := dataPlatformClient.DataPlatformClusterApi.ClustersGet(context.TODO()).Execute() + if err != nil { + return err + } + if response.Items == nil { + log.Printf("[WARNING] expected a response containing data platform clusters, but received 'nil' instead.") + return nil + } + clusters := *response.Items + for _, cluster := range clusters { + if cluster.Properties == nil || cluster.Properties.Name == nil { + log.Printf("[WARNING] 'nil' values in the response for data platform cluster with ID %v, skipping this resource.", *cluster.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *cluster.Id, + *cluster.Properties.Name+"-"+*cluster.Id, + resourceType, + helpers.Ionos, + map[string]string{}, + []string{}, + map[string]interface{}{})) + } + return nil +} diff --git a/providers/ionoscloud/dataplatform_node_pool.go b/providers/ionoscloud/dataplatform_node_pool.go new file mode 100644 index 0000000000..fc2e23fa80 --- /dev/null +++ b/providers/ionoscloud/dataplatform_node_pool.go @@ -0,0 +1,55 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type DataPlatformNodePoolGenerator struct { + Service +} + +func (g *DataPlatformNodePoolGenerator) InitResources() error { + client := g.generateClient() + dataPlatformClient := client.DataPlatformAPIClient + resourceType := "ionoscloud_dataplatform_node_pool" + + dpClusters, _, err := dataPlatformClient.DataPlatformClusterApi.ClustersGet(context.TODO()).Execute() + if err != nil { + return err + } + if dpClusters.Items == nil { + log.Printf("[WARNING] expected a response containing data platform clusters but received 'nil' instead.") + return nil + } + for _, dpCluster := range *dpClusters.Items { + dpNodePools, _, err := dataPlatformClient.DataPlatformNodePoolApi.ClustersNodepoolsGet(context.TODO(), *dpCluster.Id).Execute() + if err != nil { + return err + } + if dpNodePools.Items == nil { + log.Printf("[WARNING] expected a response containing data platform node pools but received 'nil' instead, skipping search for data platform cluster with ID: %v", *dpCluster.Id) + continue + } + for _, dpNodePool := range *dpNodePools.Items { + if dpNodePool.Properties == nil || dpNodePool.Properties.Name == nil { + log.Printf("[WARNING] 'nil' values in the response for data platform node pool with ID %v, cluster ID: %v, skipping this resource", + *dpNodePool.Id, + *dpCluster.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *dpNodePool.Id, + *dpNodePool.Properties.Name+"-"+*dpNodePool.Id, + resourceType, + helpers.Ionos, + map[string]string{helpers.ClusterID: *dpCluster.Id}, + []string{}, + map[string]interface{}{})) + } + } + return nil +} diff --git a/providers/ionoscloud/dbaas_mongo_cluster.go b/providers/ionoscloud/dbaas_mongo_cluster.go new file mode 100644 index 0000000000..3d2cf01f9b --- /dev/null +++ b/providers/ionoscloud/dbaas_mongo_cluster.go @@ -0,0 +1,43 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type DBaaSMongoClusterGenerator struct { + Service +} + +func (g *DBaaSMongoClusterGenerator) InitResources() error { + client := g.generateClient() + dbaasMongoClient := client.DBaaSMongoAPIClient + resourceType := "ionoscloud_mongo_cluster" + + response, _, err := dbaasMongoClient.ClustersApi.ClustersGet(context.TODO()).Execute() + if err != nil { + return err + } + if response.Items == nil { + log.Printf("[WARNING] expected a response containing Mongo DB clusters but received 'nil' instead") + } + clusters := *response.Items + for _, cluster := range clusters { + if cluster.Properties == nil || cluster.Properties.DisplayName == nil { + log.Printf("[WARNING] 'nil' values in the response for Mongo DB cluster with ID: %v, skipping search for this resource", *cluster.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *cluster.Id, + *cluster.Properties.DisplayName+"-"+*cluster.Id, + resourceType, + helpers.Ionos, + map[string]string{}, + []string{}, + map[string]interface{}{})) + } + return nil +} diff --git a/providers/ionoscloud/dbaas_mongo_user.go b/providers/ionoscloud/dbaas_mongo_user.go new file mode 100644 index 0000000000..9853e6181b --- /dev/null +++ b/providers/ionoscloud/dbaas_mongo_user.go @@ -0,0 +1,55 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type DBaaSMongoUserGenerator struct { + Service +} + +func (g *DBaaSMongoUserGenerator) InitResources() error { + client := g.generateClient() + dbaasMongoClient := client.DBaaSMongoAPIClient + resourceType := "ionoscloud_mongo_user" + + response, _, err := dbaasMongoClient.ClustersApi.ClustersGet(context.TODO()).Execute() + if err != nil { + return err + } + if response.Items == nil { + log.Printf("[WARNING] expected a response containing Mongo DB clusters but received 'nil' instead") + } + clusters := *response.Items + for _, cluster := range clusters { + usersResponse, _, err := dbaasMongoClient.UsersApi.ClustersUsersGet(context.TODO(), *cluster.Id).Execute() + if err != nil { + return err + } + if usersResponse.Items == nil { + log.Printf("[WARNING] expected a response containing Mongo users but received 'nil' instead, skipping search for Mongo cluster with ID: %v", *cluster.Id) + continue + } + users := *usersResponse.Items + for _, user := range users { + if user.Properties == nil || user.Properties.Username == nil { + log.Printf("[WARNING] 'nil' values in the response for Mongo user, skipping this resource") + continue + } + userID := *cluster.Id + *user.Properties.Username + g.Resources = append(g.Resources, terraformutils.NewResource( + userID, + userID, + resourceType, + helpers.Ionos, + map[string]string{helpers.ClusterID: *cluster.Id, helpers.UsernameArg: *user.Properties.Username}, + []string{}, + map[string]interface{}{})) + } + } + return nil +} diff --git a/providers/ionoscloud/dbaas_cluster.go b/providers/ionoscloud/dbaas_pgsql_cluster.go similarity index 86% rename from providers/ionoscloud/dbaas_cluster.go rename to providers/ionoscloud/dbaas_pgsql_cluster.go index 84ae47b6f9..068f289186 100644 --- a/providers/ionoscloud/dbaas_cluster.go +++ b/providers/ionoscloud/dbaas_pgsql_cluster.go @@ -9,11 +9,11 @@ import ( dbaas "github.com/ionos-cloud/sdk-go-dbaas-postgres" ) -type DBaaSClusterGenerator struct { +type DBaaSPgSQLClusterGenerator struct { Service } -func (g DBaaSClusterGenerator) createResources( +func (g DBaaSPgSQLClusterGenerator) createResources( clustersList []dbaas.ClusterResponse, ) []terraformutils.Resource { var resources []terraformutils.Resource @@ -37,9 +37,9 @@ func (g DBaaSClusterGenerator) createResources( return resources } -func (g *DBaaSClusterGenerator) InitResources() error { +func (g *DBaaSPgSQLClusterGenerator) InitResources() error { client := g.generateClient() - dbaasAPIClient := client.DBaaSApiClient + dbaasAPIClient := client.DBaaSPgSQLApiClient output, _, err := dbaasAPIClient.ClustersApi.ClustersGet(context.TODO()).Execute() if err != nil { return err diff --git a/providers/ionoscloud/dbaas_pgsql_database.go b/providers/ionoscloud/dbaas_pgsql_database.go new file mode 100644 index 0000000000..504b468417 --- /dev/null +++ b/providers/ionoscloud/dbaas_pgsql_database.go @@ -0,0 +1,54 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type DBaaSPgSQLDatabaseGenerator struct { + Service +} + +func (g *DBaaSPgSQLDatabaseGenerator) InitResources() error { + client := g.generateClient() + dbaasPgSQLClient := client.DBaaSPgSQLApiClient + resourceType := "ionoscloud_pg_database" + + response, _, err := dbaasPgSQLClient.ClustersApi.ClustersGet(context.TODO()).Execute() + if err != nil { + return err + } + if response.Items == nil { + log.Printf("[WARNING] expected a response containing PgSQL DB clusters but received 'nil' instead") + } + clusters := *response.Items + for _, cluster := range clusters { + databasesResponse, _, err := dbaasPgSQLClient.DatabasesApi.DatabasesList(context.TODO(), *cluster.Id).Execute() + if err != nil { + return err + } + if databasesResponse.Items == nil { + log.Printf("[WARNING] expected a response containing PgSQL databases but received 'nil' instead, skipping search for PgSQL cluster with ID: %v", *cluster.Id) + continue + } + databases := *databasesResponse.Items + for _, database := range databases { + if database.Properties == nil || database.Properties.Name == nil { + log.Printf("[WARNING] 'nil' values in the response for PgSQL database with ID: %v, skipping this resource", *database.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *database.Id, + *database.Properties.Name+"-"+*database.Id, + resourceType, + helpers.Ionos, + map[string]string{helpers.ClusterID: *cluster.Id, helpers.NameArg: *database.Properties.Name}, + []string{}, + map[string]interface{}{})) + } + } + return nil +} diff --git a/providers/ionoscloud/dbaas_pgsql_user.go b/providers/ionoscloud/dbaas_pgsql_user.go new file mode 100644 index 0000000000..04effd08f1 --- /dev/null +++ b/providers/ionoscloud/dbaas_pgsql_user.go @@ -0,0 +1,54 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type DBaaSPgSQLUserGenerator struct { + Service +} + +func (g *DBaaSPgSQLUserGenerator) InitResources() error { + client := g.generateClient() + dbaasPgSQLClient := client.DBaaSPgSQLApiClient + resourceType := "ionoscloud_pg_user" + + response, _, err := dbaasPgSQLClient.ClustersApi.ClustersGet(context.TODO()).Execute() + if err != nil { + return err + } + if response.Items == nil { + log.Printf("[WARNING] expected a response containing PgSQL DB clusters but received 'nil' instead") + } + clusters := *response.Items + for _, cluster := range clusters { + usersResponse, _, err := dbaasPgSQLClient.UsersApi.UsersList(context.TODO(), *cluster.Id).Execute() + if err != nil { + return err + } + if usersResponse.Items == nil { + log.Printf("[WARNING] expected a response containing PgSQL users but received 'nil' instead, skipping search for PgSQL cluster with ID: %v", *cluster.Id) + continue + } + users := *usersResponse.Items + for _, user := range users { + if user.Properties == nil || user.Properties.Username == nil { + log.Printf("[WARNING] 'nil' values in the response for PgSQL user, skipping this resource") + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *user.Id, + *user.Properties.Username+"-"+*user.Id, + resourceType, + helpers.Ionos, + map[string]string{helpers.ClusterID: *cluster.Id, helpers.UsernameArg: *user.Properties.Username}, + []string{}, + map[string]interface{}{})) + } + } + return nil +} diff --git a/providers/ionoscloud/dns_record.go b/providers/ionoscloud/dns_record.go new file mode 100644 index 0000000000..345f9fcae0 --- /dev/null +++ b/providers/ionoscloud/dns_record.go @@ -0,0 +1,55 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type DNSRecordGenerator struct { + Service +} + +func (g *DNSRecordGenerator) InitResources() error { + client := g.generateClient() + dnsAPIClient := client.DNSAPIClient + resourceType := "ionoscloud_dns_record" + + zonesResponse, _, err := dnsAPIClient.ZonesApi.ZonesGet(context.TODO()).Execute() + if err != nil { + return err + } + if zonesResponse.Items == nil { + log.Printf("[WARNING] expected a response containing DNS Zones, but received 'nil' instead") + return nil + } + zones := *zonesResponse.Items + for _, zone := range zones { + recordsResponse, _, err := dnsAPIClient.RecordsApi.ZonesRecordsGet(context.TODO(), *zone.Id).Execute() + if err != nil { + return err + } + if recordsResponse.Items == nil { + log.Printf("[WARNING] expected a response containing DNS Records, but received 'nil' instead, skipping search for DNS Zone with ID: %v", *zone.Id) + continue + } + records := *recordsResponse.Items + for _, record := range records { + if record.Properties == nil || record.Properties.Name == nil { + log.Printf("[WARNING] 'nil' values in the response for DNS Record with ID: %v, Zone ID: %v, skipping this resource", *record.Id, *zone.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *record.Id, + *record.Properties.Name+"-"+*record.Id, + resourceType, + helpers.Ionos, + map[string]string{helpers.ZoneID: *zone.Id}, + []string{}, + map[string]interface{}{})) + } + } + return nil +} diff --git a/providers/ionoscloud/dns_zone.go b/providers/ionoscloud/dns_zone.go new file mode 100644 index 0000000000..d6228fc6db --- /dev/null +++ b/providers/ionoscloud/dns_zone.go @@ -0,0 +1,44 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type DNSZoneGenerator struct { + Service +} + +func (g *DNSZoneGenerator) InitResources() error { + client := g.generateClient() + dnsAPIClient := client.DNSAPIClient + resourceType := "ionoscloud_dns_zone" + + response, _, err := dnsAPIClient.ZonesApi.ZonesGet(context.TODO()).Execute() + if err != nil { + return err + } + if response.Items == nil { + log.Printf("[WARNING] expected a response containing DNS Zones, but received 'nil' instead") + return nil + } + zones := *response.Items + for _, zone := range zones { + if zone.Properties == nil || zone.Properties.ZoneName == nil { + log.Printf("[WARNING] 'nil' values in the response for the DNS Zone with ID: %v, skipping this resource", *zone.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *zone.Id, + *zone.Properties.ZoneName+"-"+*zone.Id, + resourceType, + helpers.Ionos, + map[string]string{}, + []string{}, + map[string]interface{}{})) + } + return nil +} diff --git a/providers/ionoscloud/helpers/constants.go b/providers/ionoscloud/helpers/constants.go index 5f08588593..9c521fe038 100644 --- a/providers/ionoscloud/helpers/constants.go +++ b/providers/ionoscloud/helpers/constants.go @@ -12,11 +12,17 @@ const ( IonosDebug = "IONOS_DEBUG" Ionos = "ionoscloud" DcID = "datacenter_id" + ClusterID = "cluster_id" ServerID = "server_id" NicID = "nic_id" K8sClusterID = "k8s_cluster_id" + UserID = "user_id" + GroupID = "group_id" + ResourceID = "resource_id" + ZoneID = "zone_id" UsernameArg = "username" + NameArg = "name" PasswordArg = "password" TokenArg = "token" URLArg = "url" diff --git a/providers/ionoscloud/ionoscloud_provider.go b/providers/ionoscloud/ionoscloud_provider.go index a6406ad669..445cc14d8a 100644 --- a/providers/ionoscloud/ionoscloud_provider.go +++ b/providers/ionoscloud/ionoscloud_provider.go @@ -32,7 +32,7 @@ type IonosCloudProvider struct { //nolint url string } -func (p *IonosCloudProvider) Init(args []string) error { +func (p *IonosCloudProvider) Init(_ []string) error { username := os.Getenv(ionoscloud.IonosUsernameEnvVar) password := os.Getenv(ionoscloud.IonosPasswordEnvVar) token := os.Getenv(ionoscloud.IonosTokenEnvVar) @@ -60,7 +60,7 @@ func (p *IonosCloudProvider) GetName() string { return helpers.ProviderName } -func (p *IonosCloudProvider) GetProviderData(arg ...string) map[string]interface{} { +func (p *IonosCloudProvider) GetProviderData(_ ...string) map[string]interface{} { return map[string]interface{}{} } @@ -106,30 +106,54 @@ func (IonosCloudProvider) GetResourceConnections() map[string]map[string][]strin "datacenter": []string{helpers.DcID, "id"}, "natgateway": []string{"natgateway_id", "id"}, }, + "s3_key": { + "user": []string{helpers.UserID, "id"}, + }, + "share": { + "group": []string{helpers.GroupID, "id"}, + }, } } func (p *IonosCloudProvider) GetSupportedService() map[string]terraformutils.ServiceGenerator { return map[string]terraformutils.ServiceGenerator{ - "datacenter": &DatacenterGenerator{}, - "lan": &LanGenerator{}, - "nic": &NicGenerator{}, - "server": &ServerGenerator{}, - "volume": &VolumeGenerator{}, - "pg_cluster": &DBaaSClusterGenerator{}, - "backup_unit": &BackupUnitGenerator{}, - "ipblock": &IPBlockGenerator{}, - "k8s_cluster": &KubernetesClusterGenerator{}, - "k8s_node_pool": &KubernetesNodePoolGenerator{}, - "target_group": &TargetGroupGenerator{}, - "networkloadbalancer": &NetworkLoadBalancerGenerator{}, - "natgateway": &NATGatewayGenerator{}, - "group": &GroupGenerator{}, - "application_loadbalancer": &ApplicationLoadBalancerGenerator{}, + "datacenter": &DatacenterGenerator{}, + "lan": &LanGenerator{}, + "nic": &NicGenerator{}, + "server": &ServerGenerator{}, + "volume": &VolumeGenerator{}, + "pg_cluster": &DBaaSPgSQLClusterGenerator{}, + "pg_user": &DBaaSPgSQLUserGenerator{}, + "pg_database": &DBaaSPgSQLDatabaseGenerator{}, + "mongo_cluster": &DBaaSMongoClusterGenerator{}, + "mongo_user": &DBaaSMongoUserGenerator{}, + "backup_unit": &BackupUnitGenerator{}, + "ipblock": &IPBlockGenerator{}, + "k8s_cluster": &KubernetesClusterGenerator{}, + "k8s_node_pool": &KubernetesNodePoolGenerator{}, + "target_group": &TargetGroupGenerator{}, + "networkloadbalancer": &NetworkLoadBalancerGenerator{}, + "natgateway": &NATGatewayGenerator{}, + "group": &GroupGenerator{}, + "application_loadbalancer": &ApplicationLoadBalancerGenerator{}, + "application_loadbalancer_forwardingrule": &ALBForwardingRuleGenerator{}, "firewall": &FirewallGenerator{}, "networkloadbalancer_forwardingrule": &NetworkLoadBalancerForwardingRuleGenerator{}, "loadbalancer": &LoadBalancerGenerator{}, "natgateway_rule": &NATGatewayRuleGenerator{}, + "certificate": &CertificateGenerator{}, + "private_crossconnect": &PrivateCrossConnectGenerator{}, + "s3_key": &S3KeyGenerator{}, + "container_registry": &ContainerRegistryGenerator{}, + "dataplatform_cluster": &DataPlatformClusterGenerator{}, + "dataplatform_node_pool": &DataPlatformNodePoolGenerator{}, + "share": &ShareGenerator{}, + "user": &UserGenerator{}, + "container_registry_token": &ContainerRegistryTokenGenerator{}, + "dns_zone": &DNSZoneGenerator{}, + "dns_record": &DNSRecordGenerator{}, + "logging_pipeline": &LoggingPipelineGenerator{}, + "ipfailover": &IPFailoverGenerator{}, } } diff --git a/providers/ionoscloud/ionoscloud_service.go b/providers/ionoscloud/ionoscloud_service.go index 103e0938b8..a887eeaf7c 100644 --- a/providers/ionoscloud/ionoscloud_service.go +++ b/providers/ionoscloud/ionoscloud_service.go @@ -25,7 +25,13 @@ import ( "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" "github.com/GoogleCloudPlatform/terraformer/terraformutils" - dbaas "github.com/ionos-cloud/sdk-go-dbaas-postgres" + certificateManager "github.com/ionos-cloud/sdk-go-cert-manager" + containerRegistry "github.com/ionos-cloud/sdk-go-container-registry" + dataPlatform "github.com/ionos-cloud/sdk-go-dataplatform" + dbaasMongo "github.com/ionos-cloud/sdk-go-dbaas-mongo" + dbaasPgSQL "github.com/ionos-cloud/sdk-go-dbaas-postgres" + dns "github.com/ionos-cloud/sdk-go-dns" + logging "github.com/ionos-cloud/sdk-go-logging" ionoscloud "github.com/ionos-cloud/sdk-go/v6" ) @@ -34,15 +40,27 @@ type Service struct { } type Bundle struct { - CloudAPIClient *ionoscloud.APIClient - DBaaSApiClient *dbaas.APIClient + CloudAPIClient *ionoscloud.APIClient + DBaaSPgSQLApiClient *dbaasPgSQL.APIClient + DBaaSMongoAPIClient *dbaasMongo.APIClient + CertificateManagerAPIClient *certificateManager.APIClient + ContainerRegistryAPIClient *containerRegistry.APIClient + DataPlatformAPIClient *dataPlatform.APIClient + DNSAPIClient *dns.APIClient + LoggingAPIClient *logging.APIClient } type clientType int const ( ionosClient clientType = iota - dbaasClient + dbaasPgSQLClient + dbaasMongoClient + certificateManagerClient + containerRegistryClient + dataPlatformClient + dnsClient + loggingClient ) func (s *Service) generateClient() *Bundle { @@ -63,12 +81,25 @@ func (s *Service) generateClient() *Bundle { newConfig.WaitTime = helpers.MaxWaitTime clients := map[clientType]interface{}{ - ionosClient: NewClientByType(username, password, token, cleanedURL, ionosClient), - dbaasClient: NewClientByType(username, password, token, cleanedURL, dbaasClient), + ionosClient: NewClientByType(username, password, token, cleanedURL, ionosClient), + dbaasPgSQLClient: NewClientByType(username, password, token, cleanedURL, dbaasPgSQLClient), + dbaasMongoClient: NewClientByType(username, password, token, cleanedURL, dbaasMongoClient), + certificateManagerClient: NewClientByType(username, password, token, cleanedURL, certificateManagerClient), + containerRegistryClient: NewClientByType(username, password, token, cleanedURL, containerRegistryClient), + dataPlatformClient: NewClientByType(username, password, token, cleanedURL, dataPlatformClient), + dnsClient: NewClientByType(username, password, token, cleanedURL, dnsClient), + loggingClient: NewClientByType(username, password, token, cleanedURL, loggingClient), } + return &Bundle{ - CloudAPIClient: clients[ionosClient].(*ionoscloud.APIClient), - DBaaSApiClient: clients[dbaasClient].(*dbaas.APIClient), + CloudAPIClient: clients[ionosClient].(*ionoscloud.APIClient), + DBaaSPgSQLApiClient: clients[dbaasPgSQLClient].(*dbaasPgSQL.APIClient), + DBaaSMongoAPIClient: clients[dbaasMongoClient].(*dbaasMongo.APIClient), + CertificateManagerAPIClient: clients[certificateManagerClient].(*certificateManager.APIClient), + ContainerRegistryAPIClient: clients[containerRegistryClient].(*containerRegistry.APIClient), + DataPlatformAPIClient: clients[dataPlatformClient].(*dataPlatform.APIClient), + DNSAPIClient: clients[dnsClient].(*dns.APIClient), + LoggingAPIClient: clients[loggingClient].(*logging.APIClient), } } @@ -88,9 +119,9 @@ func NewClientByType(username, password, token, url string, clientType clientTyp "terraformer_ionos-cloud-sdk-go/%s_os/%s_arch/%s", ionoscloud.Version, runtime.GOOS, runtime.GOARCH) return ionoscloud.NewAPIClient(newConfig) } - case dbaasClient: + case dbaasPgSQLClient: { - newConfig := dbaas.NewConfiguration(username, password, token, url) + newConfig := dbaasPgSQL.NewConfiguration(username, password, token, url) if os.Getenv(helpers.IonosDebug) != "" { newConfig.Debug = true @@ -99,8 +130,92 @@ func NewClientByType(username, password, token, url string, clientType clientTyp newConfig.WaitTime = helpers.MaxWaitTime newConfig.HTTPClient = &http.Client{Transport: CreateTransport()} newConfig.UserAgent = fmt.Sprintf( - "terraformer_ionos-cloud-sdk-go/%s_os/%s_arch/%s", ionoscloud.Version, runtime.GOOS, runtime.GOARCH) - return dbaas.NewAPIClient(newConfig) + "terraformer_ionos-cloud-sdk-go-dbaas-postgres/%s_os/%s_arch/%s", dbaasPgSQL.Version, runtime.GOOS, runtime.GOARCH) + return dbaasPgSQL.NewAPIClient(newConfig) + } + case dbaasMongoClient: + { + newConfig := dbaasMongo.NewConfiguration(username, password, token, url) + + if os.Getenv(helpers.IonosDebug) != "" { + newConfig.Debug = true + } + newConfig.MaxRetries = helpers.MaxRetries + newConfig.WaitTime = helpers.MaxWaitTime + newConfig.HTTPClient = &http.Client{Transport: CreateTransport()} + newConfig.UserAgent = fmt.Sprintf( + "terraformer_ionos-cloud-sdk-go-dbaas-mongo/%s_os/%s_arch/%s", dbaasMongo.Version, runtime.GOOS, runtime.GOARCH) + return dbaasMongo.NewAPIClient(newConfig) + } + case certificateManagerClient: + { + newConfig := certificateManager.NewConfiguration(username, password, token, url) + + if os.Getenv(helpers.IonosDebug) != "" { + newConfig.Debug = true + } + newConfig.MaxRetries = helpers.MaxRetries + newConfig.WaitTime = helpers.MaxWaitTime + newConfig.HTTPClient = &http.Client{Transport: CreateTransport()} + newConfig.UserAgent = fmt.Sprintf( + "terraformer_ionos-cloud-sdk-go-cert-manager/%s_os/%s_arch/%s", certificateManager.Version, runtime.GOOS, runtime.GOARCH) + return certificateManager.NewAPIClient(newConfig) + } + case containerRegistryClient: + { + newConfig := containerRegistry.NewConfiguration(username, password, token, url) + + if os.Getenv(helpers.IonosDebug) != "" { + newConfig.Debug = true + } + newConfig.MaxRetries = helpers.MaxRetries + newConfig.WaitTime = helpers.MaxWaitTime + newConfig.HTTPClient = &http.Client{Transport: CreateTransport()} + newConfig.UserAgent = fmt.Sprintf( + "terraformer_ionos-cloud-sdk-go-container-registry/%s_os/%s_arch/%s", containerRegistry.Version, runtime.GOOS, runtime.GOARCH) + return containerRegistry.NewAPIClient(newConfig) + } + case dataPlatformClient: + { + newConfig := dataPlatform.NewConfiguration(username, password, token, url) + + if os.Getenv(helpers.IonosDebug) != "" { + newConfig.Debug = true + } + newConfig.MaxRetries = helpers.MaxRetries + newConfig.WaitTime = helpers.MaxWaitTime + newConfig.HTTPClient = &http.Client{Transport: CreateTransport()} + newConfig.UserAgent = fmt.Sprintf( + "terraformer_ionos-cloud-sdk-go-dataplatform/%s_os/%s_arch/%s", dataPlatform.Version, runtime.GOOS, runtime.GOARCH) + return dataPlatform.NewAPIClient(newConfig) + } + case dnsClient: + { + newConfig := dns.NewConfiguration(username, password, token, url) + + if os.Getenv(helpers.IonosDebug) != "" { + newConfig.Debug = true + } + newConfig.MaxRetries = helpers.MaxRetries + newConfig.WaitTime = helpers.MaxWaitTime + newConfig.HTTPClient = &http.Client{Transport: CreateTransport()} + newConfig.UserAgent = fmt.Sprintf( + "terraformer_ionos-cloud-sdk-go-dns/%s_os/%s_arch/%s", dns.Version, runtime.GOOS, runtime.GOARCH) + return dns.NewAPIClient(newConfig) + } + case loggingClient: + { + newConfig := logging.NewConfiguration(username, password, token, url) + + if os.Getenv(helpers.IonosDebug) != "" { + newConfig.Debug = true + } + newConfig.MaxRetries = helpers.MaxRetries + newConfig.WaitTime = helpers.MaxWaitTime + newConfig.HTTPClient = &http.Client{Transport: CreateTransport()} + newConfig.UserAgent = fmt.Sprintf( + "terraformer_ionos-cloud-sdk-go-logging/%s_os/%s_arch/%s", logging.Version, runtime.GOOS, runtime.GOARCH) + return logging.NewAPIClient(newConfig) } default: log.Printf("[ERROR] unknown client type %d", clientType) diff --git a/providers/ionoscloud/ipfailover.go b/providers/ionoscloud/ipfailover.go new file mode 100644 index 0000000000..33ee57bc51 --- /dev/null +++ b/providers/ionoscloud/ipfailover.go @@ -0,0 +1,60 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/terraformutils" + uuid "github.com/gofrs/uuid/v3" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" +) + +type IPFailoverGenerator struct { + Service +} + +func (g *IPFailoverGenerator) InitResources() error { + client := g.generateClient() + cloudAPIClient := client.CloudAPIClient + datacenters, err := helpers.GetAllDatacenters(*cloudAPIClient) + resourceType := "ionoscloud_ipfailover" + if err != nil { + return err + } + for _, datacenter := range datacenters { + lans, _, err := cloudAPIClient.LANsApi.DatacentersLansGet(context.TODO(), *datacenter.Id).Depth(1).Execute() + if err != nil { + return err + } + if lans.Items == nil { + log.Printf( + "[WARNING] expected a response containing LANs but received 'nil' instead, skipping search for datacenter with ID: %v", + *datacenter.Id) + continue + } + for _, lan := range *lans.Items { + if lan.Properties == nil || lan.Properties.IpFailover == nil { + log.Printf( + "[WARNING] 'nil' values in the response for LAN with ID %v, datacenter ID: %v, skipping this resource", + *lan.Id, + *datacenter.Id, + ) + continue + } + for _, ipFailover := range *lan.Properties.IpFailover { + // Generate the ID of the resource using the IP + id := uuid.NewV5(uuid.NewV5(uuid.NamespaceURL, "https://github.com/ionos-cloud/terraform-provider-ionoscloud"), *ipFailover.Ip).String() + g.Resources = append(g.Resources, terraformutils.NewResource( + id, + id, + resourceType, + helpers.Ionos, + map[string]string{helpers.DcID: *datacenter.Id, "lan_id": *lan.Id, "ip": *ipFailover.Ip, "nicuuid": *ipFailover.NicUuid}, + []string{}, + map[string]interface{}{})) + } + } + } + return nil +} diff --git a/providers/ionoscloud/kubernetes_node_pool.go b/providers/ionoscloud/kubernetes_node_pool.go index dd7446b8b6..2674273c83 100644 --- a/providers/ionoscloud/kubernetes_node_pool.go +++ b/providers/ionoscloud/kubernetes_node_pool.go @@ -17,7 +17,7 @@ func (g *KubernetesNodePoolGenerator) InitResources() error { cloudAPIClient := client.CloudAPIClient resourceType := "ionoscloud_k8s_node_pool" - kubernetesClusters, _, err := cloudAPIClient.KubernetesApi.K8sGet(context.TODO()).Depth(1).Execute() + kubernetesClusters, _, err := cloudAPIClient.KubernetesApi.K8sGet(context.TODO()).Execute() if err != nil { return err } diff --git a/providers/ionoscloud/lan.go b/providers/ionoscloud/lan.go index f04d18512a..27000b8bb6 100644 --- a/providers/ionoscloud/lan.go +++ b/providers/ionoscloud/lan.go @@ -26,14 +26,14 @@ func (g *LanGenerator) InitResources() error { } if lans.Items == nil { log.Printf( - "[WARNING] expected a response containing LANs but received 'nil' instead, skipping search for datacenter with ID: %v.\n", + "[WARNING] expected a response containing LANs but received 'nil' instead, skipping search for datacenter with ID: %v", *datacenter.Id) continue } for _, lan := range *lans.Items { if lan.Properties == nil || lan.Properties.Name == nil { log.Printf( - "[WARNING] 'nil' values in the response for LAN with ID %v, datacenter ID: %v, skipping this resource.\n", + "[WARNING] 'nil' values in the response for LAN with ID %v, datacenter ID: %v, skipping this resource", *lan.Id, *datacenter.Id, ) @@ -44,7 +44,7 @@ func (g *LanGenerator) InitResources() error { *lan.Id, *lan.Properties.Name+"-"+*lan.Id, "ionoscloud_lan", - "ionoscloud", + helpers.Ionos, map[string]string{helpers.DcID: *datacenter.Id}, []string{}, map[string]interface{}{})) diff --git a/providers/ionoscloud/logging_pipeline.go b/providers/ionoscloud/logging_pipeline.go new file mode 100644 index 0000000000..2ebf3b35b7 --- /dev/null +++ b/providers/ionoscloud/logging_pipeline.go @@ -0,0 +1,44 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type LoggingPipelineGenerator struct { + Service +} + +func (g *LoggingPipelineGenerator) InitResources() error { + client := g.generateClient() + loggingAPIClient := client.LoggingAPIClient + resourceType := "ionoscloud_logging_pipeline" + + response, _, err := loggingAPIClient.PipelinesApi.PipelinesGet(context.TODO()).Execute() + if err != nil { + return err + } + if response.Items == nil { + log.Printf("[WARNING] expected a response containing pipelines, but received 'nil' instead") + return nil + } + pipelines := *response.Items + for _, pipeline := range pipelines { + if pipeline.Properties == nil || pipeline.Properties.Name == nil { + log.Printf("[WARNING] 'nil' values in the response for the pipeline with ID: %v, skipping this resource", *pipeline.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *pipeline.Id, + *pipeline.Properties.Name+"-"+*pipeline.Id, + resourceType, + helpers.Ionos, + map[string]string{}, + []string{}, + map[string]interface{}{})) + } + return nil +} diff --git a/providers/ionoscloud/nic.go b/providers/ionoscloud/nic.go index ed04ed042b..9aee05c8d2 100644 --- a/providers/ionoscloud/nic.go +++ b/providers/ionoscloud/nic.go @@ -20,7 +20,7 @@ func (g *NicGenerator) InitResources() error { return err } for _, datacenter := range datacenters { - servers, _, err := cloudAPIClient.ServersApi.DatacentersServersGet(context.TODO(), *datacenter.Id).Depth(1).Execute() + servers, _, err := cloudAPIClient.ServersApi.DatacentersServersGet(context.TODO(), *datacenter.Id).Execute() if err != nil { return err } @@ -31,7 +31,7 @@ func (g *NicGenerator) InitResources() error { continue } for _, server := range *servers.Items { - nics, _, err := cloudAPIClient.NetworkInterfacesApi.DatacentersServersNicsGet(context.TODO(), *datacenter.Id, *server.Id).Depth(2).Execute() + nics, _, err := cloudAPIClient.NetworkInterfacesApi.DatacentersServersNicsGet(context.TODO(), *datacenter.Id, *server.Id).Depth(1).Execute() if err != nil { return err } diff --git a/providers/ionoscloud/private_crossconnect.go b/providers/ionoscloud/private_crossconnect.go new file mode 100644 index 0000000000..5b8d9ea587 --- /dev/null +++ b/providers/ionoscloud/private_crossconnect.go @@ -0,0 +1,44 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type PrivateCrossConnectGenerator struct { + Service +} + +func (g *PrivateCrossConnectGenerator) InitResources() error { + client := g.generateClient() + cloudAPIClient := client.CloudAPIClient + resourceType := "ionoscloud_private_crossconnect" + + pccsResponse, _, err := cloudAPIClient.PrivateCrossConnectsApi.PccsGet(context.TODO()).Depth(1).Execute() + if err != nil { + return err + } + if pccsResponse.Items == nil { + log.Printf("[WARNING] expected a response containing PCCs but received 'nil' instead.\n") + return nil + } + pccs := *pccsResponse.Items + for _, pcc := range pccs { + if pcc.Properties == nil || pcc.Properties.Name == nil { + log.Printf("[WARNING] 'nil' values in the response for PCC with ID %v, skipping this resource.\n", *pcc.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( + *pcc.Id, + *pcc.Properties.Name+"-"+*pcc.Id, + resourceType, + helpers.Ionos, + map[string]string{}, + []string{}, + map[string]interface{}{})) + } + return nil +} diff --git a/providers/ionoscloud/s3_key.go b/providers/ionoscloud/s3_key.go new file mode 100644 index 0000000000..09a25eccac --- /dev/null +++ b/providers/ionoscloud/s3_key.go @@ -0,0 +1,50 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type S3KeyGenerator struct { + Service +} + +func (g *S3KeyGenerator) InitResources() error { + client := g.generateClient() + cloudAPIClient := client.CloudAPIClient + resourceType := "ionoscloud_s3_key" + + usersResponse, _, err := cloudAPIClient.UserManagementApi.UmUsersGet(context.TODO()).Execute() + if err != nil { + return err + } + if usersResponse.Items == nil { + log.Printf("[WARNING] expected a response containing users but received 'nil' instead") + return nil + } + for _, user := range *usersResponse.Items { + s3KeysResponse, _, err := cloudAPIClient.UserS3KeysApi.UmUsersS3keysGet(context.TODO(), *user.Id).Depth(1).Execute() + if err != nil { + return err + } + if s3KeysResponse.Items == nil { + log.Printf("[WARNING] expected a response containing S3 keys but received 'nil' instead, skipping search for user with ID: %v.\n", + *user.Id) + continue + } + for _, s3Key := range *s3KeysResponse.Items { + g.Resources = append(g.Resources, terraformutils.NewResource( + *s3Key.Id, + *s3Key.Id, + resourceType, + helpers.Ionos, + map[string]string{helpers.UserID: *user.Id}, + []string{}, + map[string]interface{}{})) + } + } + return nil +} diff --git a/providers/ionoscloud/server.go b/providers/ionoscloud/server.go index b6f28e312d..76574b807f 100644 --- a/providers/ionoscloud/server.go +++ b/providers/ionoscloud/server.go @@ -48,10 +48,16 @@ func (g *ServerGenerator) InitResources() error { continue } + resourceType := getServerResourceType(*server.Properties.Type) + if resourceType == "" { + log.Printf("[WARNING] unknown server type: %v for server with ID: %v, skipping this server", *server.Properties.Type, *server.Id) + continue + } + g.Resources = append(g.Resources, terraformutils.NewResource( *server.Id, *server.Properties.Name+"-"+*server.Id, - "ionoscloud_server", + resourceType, helpers.Ionos, map[string]string{helpers.DcID: *datacenter.Id}, []string{}, @@ -87,3 +93,16 @@ func isServerValid(server ionoscloud.Server, datacenterID string) bool { return true } + +func getServerResourceType(serverType string) string { + resourceType := "" + switch serverType { + case "ENTERPRISE": + resourceType = "ionoscloud_server" + case "CUBE": + resourceType = "ionoscloud_cube_server" + case "VCPU": + resourceType = "ionoscloud_vcpu_server" + } + return resourceType +} diff --git a/providers/ionoscloud/share.go b/providers/ionoscloud/share.go new file mode 100644 index 0000000000..15fadb9b58 --- /dev/null +++ b/providers/ionoscloud/share.go @@ -0,0 +1,49 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type ShareGenerator struct { + Service +} + +func (g *ShareGenerator) InitResources() error { + client := g.generateClient() + cloudAPIClient := client.CloudAPIClient + resourceType := "ionoscloud_share" + + groups, _, err := cloudAPIClient.UserManagementApi.UmGroupsGet(context.TODO()).Depth(1).Execute() + if err != nil { + return err + } + if groups.Items == nil { + log.Printf("[WARNING] expected a response containing groups but received 'nil' instead.") + return nil + } + for _, group := range *groups.Items { + shares, _, err := cloudAPIClient.UserManagementApi.UmGroupsSharesGet(context.TODO(), *group.Id).Execute() + if err != nil { + return err + } + if shares.Items == nil { + log.Printf("[WARNING] expected a response containing shares but received 'nil' instead, skipping search for group with ID: %s", *group.Id) + continue + } + for _, share := range *shares.Items { + g.Resources = append(g.Resources, terraformutils.NewResource( + *share.Id, + *share.Id, + resourceType, + helpers.Ionos, + map[string]string{helpers.GroupID: *group.Id, helpers.ResourceID: *share.Id}, + []string{}, + map[string]interface{}{})) + } + } + return nil +} diff --git a/providers/ionoscloud/user.go b/providers/ionoscloud/user.go new file mode 100644 index 0000000000..f5fad73256 --- /dev/null +++ b/providers/ionoscloud/user.go @@ -0,0 +1,39 @@ +package ionoscloud + +import ( + "context" + "log" + + "github.com/GoogleCloudPlatform/terraformer/providers/ionoscloud/helpers" + "github.com/GoogleCloudPlatform/terraformer/terraformutils" +) + +type UserGenerator struct { + Service +} + +func (g *UserGenerator) InitResources() error { + client := g.generateClient() + cloudAPIClient := client.CloudAPIClient + resourceType := "ionoscloud_user" + + usersResponse, _, err := cloudAPIClient.UserManagementApi.UmUsersGet(context.TODO()).Execute() + if err != nil { + return err + } + if usersResponse.Items == nil { + log.Printf("[WARNING] expected a response containing users but received 'nil' instead") + return nil + } + for _, user := range *usersResponse.Items { + g.Resources = append(g.Resources, terraformutils.NewResource( + *user.Id, + *user.Id, + resourceType, + helpers.Ionos, + map[string]string{}, + []string{}, + map[string]interface{}{})) + } + return nil +} diff --git a/providers/ionoscloud/volume.go b/providers/ionoscloud/volume.go index 57e6127deb..8837062184 100644 --- a/providers/ionoscloud/volume.go +++ b/providers/ionoscloud/volume.go @@ -31,7 +31,7 @@ func (g *VolumeGenerator) InitResources() error { continue } for _, server := range *servers.Items { - volumes, _, err := cloudAPIClient.ServersApi.DatacentersServersVolumesGet(context.TODO(), *datacenter.Id, *server.Id).Depth(2).Execute() + volumes, _, err := cloudAPIClient.ServersApi.DatacentersServersVolumesGet(context.TODO(), *datacenter.Id, *server.Id).Depth(1).Execute() if err != nil { return err }