Add EIM other data_sources

outscale/data_source_outscale_entities_linked_to_policy.go

@@ -0,0 +1,164 @@
+package outscale
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	oscgo "github.com/outscale/osc-sdk-go/v2"
+	"github.com/outscale/terraform-provider-outscale/utils"
+)
+
+func DataSourceEntitiesLinkedToPolicy() *schema.Resource {
+	return &schema.Resource{
+		Read: DataSourceEntitiesLinkedToPoliciesRead,
+		Schema: map[string]*schema.Schema{
+			"policy_orn": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"entities_type": {
+				Type:     schema.TypeSet,
+				Optional: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
+			"policy_entities": {
+				Type:     schema.TypeSet,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"users": {
+							Type:     schema.TypeSet,
+							Computed: true,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"id": {
+										Type:     schema.TypeString,
+										Computed: true,
+									},
+									"name": {
+										Type:     schema.TypeString,
+										Computed: true,
+									},
+									"orn": {
+										Type:     schema.TypeString,
+										Computed: true,
+									},
+								},
+							},
+						},
+						"groups": {
+							Type:     schema.TypeSet,
+							Computed: true,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"id": {
+										Type:     schema.TypeString,
+										Computed: true,
+									},
+									"name": {
+										Type:     schema.TypeString,
+										Computed: true,
+									},
+									"orn": {
+										Type:     schema.TypeString,
+										Computed: true,
+									},
+								},
+							},
+						},
+						"accounts": {
+							Type:     schema.TypeSet,
+							Computed: true,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"id": {
+										Type:     schema.TypeString,
+										Computed: true,
+									},
+									"name": {
+										Type:     schema.TypeString,
+										Computed: true,
+									},
+									"orn": {
+										Type:     schema.TypeString,
+										Computed: true,
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func DataSourceEntitiesLinkedToPoliciesRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*OutscaleClient).OSCAPI
+	orn := d.Get("policy_orn").(string)
+	req := oscgo.ReadEntitiesLinkedToPolicyRequest{PolicyOrn: &orn}
+	if entities := utils.SetToStringSlice(d.Get("entities_type").(*schema.Set)); len(entities) > 0 {
+		req.SetEntitiesType(entities)
+	}
+
+	var resp oscgo.ReadEntitiesLinkedToPolicyResponse
+	err := resource.Retry(2*time.Minute, func() *resource.RetryError {
+		rp, httpResp, err := conn.PolicyApi.ReadEntitiesLinkedToPolicy(context.Background()).ReadEntitiesLinkedToPolicyRequest(req).Execute()
+		if err != nil {
+			return utils.CheckThrottling(httpResp, err)
+		}
+		resp = rp
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+	entities, ok := resp.GetPolicyEntitiesOk()
+	if !ok {
+		return fmt.Errorf("unable to find Entities linked to policy")
+	}
+	d.SetId(resource.UniqueId())
+
+	users := make([]map[string]interface{}, len(entities.GetUsers()))
+	groups := make([]map[string]interface{}, len(entities.GetGroups()))
+	accounts := make([]map[string]interface{}, len(entities.GetAccounts()))
+	if respUsers, ok := entities.GetUsersOk(); ok {
+		for i, v := range *respUsers {
+			user := make(map[string]interface{})
+			user["id"] = v.GetId()
+			user["name"] = v.GetName()
+			user["orn"] = v.GetOrn()
+			users[i] = user
+		}
+	}
+	if respGroups, ok := entities.GetGroupsOk(); ok {
+		for i, v := range *respGroups {
+			group := make(map[string]interface{})
+			group["name"] = v.GetName()
+			group["id"] = v.GetId()
+			group["orn"] = v.GetOrn()
+			groups[i] = group
+		}
+	}
+	if respAccounts, ok := entities.GetAccountsOk(); ok {
+		for i, v := range *respAccounts {
+			account := make(map[string]interface{})
+			account["name"] = v.GetName()
+			account["id"] = v.GetId()
+			account["orn"] = v.GetOrn()
+			accounts[i] = account
+		}
+	}
+
+	return d.Set("policy_entities", []map[string]interface{}{{
+		"users":    users,
+		"groups":   groups,
+		"accounts": accounts,
+	}})
+}

outscale/data_source_outscale_entities_linked_to_policy_test.go

@@ -0,0 +1,64 @@
+package outscale
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+)
+
+func TestAccOthers_entities_linked_to_policy_basic(t *testing.T) {
+	t.Parallel()
+	resourceName := "data.outscale_entities_linked_to_policy.entitiesLinked"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataEntitiesLinkedConfig,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttrSet(resourceName, "policy_entities.#"),
+				),
+			},
+		},
+	})
+}
+
+const testAccDataEntitiesLinkedConfig = `
+resource "outscale_user" "user_01" {
+    user_name = "userLedGroup"
+    path      = "/linkedUser/"
+    policy {
+	   policy_orn = outscale_policy.policyEntities_01.orn
+	}
+}
+resource "outscale_user_group" "uGroupLinked" {
+	user_group_name = "GLinkedTestACC"
+	path = "/"
+	user {
+        user_name = outscale_user.user_01.user_name
+        path      = "/linkedUser/"
+    }
+	policy {
+	   policy_orn = outscale_policy.policyEntities_01.orn
+	}
+	depends_on = [outscale_user.user_01]
+}
+resource "outscale_user_group" "GroupLinkedPolicy" {
+	user_group_name = "GroupPolicyTestAcc"
+	path = "/TestPath/"
+	policy {
+	   policy_orn = outscale_policy.policyEntities_01.orn
+	}
+}
+resource "outscale_policy" "policyEntities_01" {
+   description = "Example Entities Linked to policy"
+   document    = "{\"Statement\": [ {\"Effect\": \"Allow\", \"Action\": [\"*\"], \"Resource\": [\"*\"]} ]}"
+   path        = "/Okht_test/"
+   policy_name = "policyEntitiesLinked"
+}
+
+data "outscale_entities_linked_to_policy" "entitiesLinked" {
+	policy_orn = outscale_policy.policyEntities_01.orn
+	depends_on = [outscale_user_group.uGroupLinked, outscale_user_group.GroupLinkedPolicy, outscale_user.user_01]
+}`

outscale/data_source_outscale_policies_linked_to_user.go

@@ -0,0 +1,90 @@
+package outscale
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	oscgo "github.com/outscale/osc-sdk-go/v2"
+	"github.com/outscale/terraform-provider-outscale/utils"
+)
+
+func DataSourcePoliciesLinkedToUser() *schema.Resource {
+	return &schema.Resource{
+		Read: DataSourcePoliciesLinkedToUserRead,
+		Schema: map[string]*schema.Schema{
+			"user_name": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"policies": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+
+						"policy_name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"policy_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"orn": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"creation_date": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"last_modification_date": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func DataSourcePoliciesLinkedToUserRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*OutscaleClient).OSCAPI
+	req := oscgo.NewReadLinkedPoliciesRequest(d.Get("user_name").(string))
+	var resp oscgo.ReadLinkedPoliciesResponse
+
+	err := resource.Retry(2*time.Minute, func() *resource.RetryError {
+		rp, httpResp, err := conn.PolicyApi.ReadLinkedPolicies(context.Background()).ReadLinkedPoliciesRequest(*req).Execute()
+		if err != nil {
+			return utils.CheckThrottling(httpResp, err)
+		}
+		resp = rp
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+	policiesList := resp.GetPolicies()
+	if len(policiesList) == 0 {
+		return fmt.Errorf("unable to find Policies linked to user: %v", d.Get("user_name").(string))
+	}
+	d.SetId(resource.UniqueId())
+
+	policies := make([]map[string]interface{}, len(policiesList))
+
+	for i, v := range policiesList {
+		policy := make(map[string]interface{})
+		policy["policy_name"] = v.GetPolicyName()
+		policy["policy_id"] = v.GetPolicyId()
+		policy["orn"] = v.GetOrn()
+		policy["creation_date"] = v.GetCreationDate()
+		policy["last_modification_date"] = v.GetLastModificationDate()
+		policies[i] = policy
+	}
+	return d.Set("policies", policies)
+}