Skip to content

Commit 87ee36d

Browse files
emichaeliemichaeli
committed
Add Policies resource
1 parent 05eb2f7 commit 87ee36d

File tree

4 files changed

+438
-0
lines changed

4 files changed

+438
-0
lines changed

‎sumologic/provider.go‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -75,6 +75,7 @@ func Provider() terraform.ResourceProvider {
7575
"sumologic_saml_configuration": resourceSumologicSamlConfiguration(),
7676
"sumologic_kinesis_metrics_source": resourceSumologicKinesisMetricsSource(),
7777
"sumologic_token": resourceSumologicToken(),
78+
"sumologic_policies": resourceSumologicPolicies(),
7879
},
7980
DataSourcesMap: map[string]*schema.Resource{
8081
"sumologic_admin_recommended_folder": dataSourceSumologicAdminRecommendedFolder(),

‎sumologic/resource_sumologic_policies.go‎

Lines changed: 153 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,153 @@
1+
package sumologic
2+
3+
import (
4+
"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
5+
)
6+
7+
var DefaultPolicies = Policies{
8+
Audit: AuditPolicy{Enabled: false},
9+
DataAccessLevel: DataAccessLevelPolicy{Enabled: false},
10+
MaxUserSessionTimeout: MaxUserSessionTimeoutPolicy{MaxUserSessionTimeout: "7d"},
11+
SearchAudit: SearchAuditPolicy{Enabled: false},
12+
ShareDashboardsOutsideOrganization: ShareDashboardsOutsideOrganizationPolicy{Enabled: false},
13+
UserConcurrentSessionsLimit: UserConcurrentSessionsLimitPolicy{Enabled: false, MaxConcurrentSessions: 100},
14+
}
15+
16+
func resourceSumologicPolicies() *schema.Resource {
17+
return &schema.Resource{
18+
Create: resourceSumologicPoliciesCreate,
19+
Read: resourceSumologicPoliciesRead,
20+
Update: resourceSumologicPoliciesUpdate,
21+
Delete: resourceSumologicPoliciesDelete,
22+
23+
Schema: map[string]*schema.Schema{
24+
"audit": {
25+
Type: schema.TypeBool,
26+
Optional: true,
27+
Default: DefaultPolicies.Audit.Enabled,
28+
},
29+
"data_access_level": {
30+
Type: schema.TypeBool,
31+
Optional: true,
32+
Default: DefaultPolicies.DataAccessLevel.Enabled,
33+
},
34+
"max_user_session_timeout": {
35+
Type: schema.TypeString,
36+
Optional: true,
37+
Default: DefaultPolicies.MaxUserSessionTimeout.MaxUserSessionTimeout,
38+
},
39+
"search_audit": {
40+
Type: schema.TypeBool,
41+
Optional: true,
42+
Default: DefaultPolicies.SearchAudit.Enabled,
43+
},
44+
"share_dashboards_outside_organization": {
45+
Type: schema.TypeBool,
46+
Optional: true,
47+
Default: DefaultPolicies.ShareDashboardsOutsideOrganization.Enabled,
48+
},
49+
"user_concurrent_sessions_limit": {
50+
Type: schema.TypeList,
51+
Optional: true,
52+
MaxItems: 1,
53+
Elem: &schema.Resource{
54+
Schema: map[string]*schema.Schema{
55+
"enabled": {
56+
Type: schema.TypeBool,
57+
Optional: true,
58+
Default: DefaultPolicies.UserConcurrentSessionsLimit.Enabled,
59+
},
60+
"max_concurrent_sessions": {
61+
Type: schema.TypeInt,
62+
Optional: true,
63+
Default: DefaultPolicies.UserConcurrentSessionsLimit.MaxConcurrentSessions,
64+
},
65+
},
66+
},
67+
},
68+
},
69+
}
70+
}
71+
72+
func resourceSumologicPoliciesRead(d *schema.ResourceData, meta interface{}) error {
73+
c := meta.(*Client)
74+
75+
policies, err := c.GetPolicies()
76+
if err != nil {
77+
return err
78+
}
79+
80+
setPoliciesResource(d, policies)
81+
return nil
82+
}
83+
84+
func resourceSumologicPoliciesCreate(d *schema.ResourceData, meta interface{}) error {
85+
// Since policies can only be set and not created, we just update the policies with the given fields.
86+
err := resourceSumologicPoliciesUpdate(d, meta)
87+
if err != nil {
88+
return err
89+
}
90+
91+
d.SetId("policies")
92+
return nil
93+
}
94+
95+
func resourceSumologicPoliciesDelete(d *schema.ResourceData, meta interface{}) error {
96+
// Since policies cannot be deleted, we just reset to the default policies configuration.
97+
c := meta.(*Client)
98+
99+
_, err := c.UpdatePolicies(DefaultPolicies)
100+
return err
101+
}
102+
103+
func resourceSumologicPoliciesUpdate(d *schema.ResourceData, meta interface{}) error {
104+
policies := resourceToPolicies(d)
105+
106+
c := meta.(*Client)
107+
updatedPolicies, err := c.UpdatePolicies(policies)
108+
if err != nil {
109+
return err
110+
}
111+
112+
setPoliciesResource(d, updatedPolicies)
113+
return nil
114+
}
115+
116+
func setPoliciesResource(d *schema.ResourceData, policies *Policies) {
117+
d.Set("audit", policies.Audit.Enabled)
118+
d.Set("data_access_level", policies.DataAccessLevel.Enabled)
119+
d.Set("max_user_session_timeout", policies.MaxUserSessionTimeout.MaxUserSessionTimeout)
120+
d.Set("search_audit", policies.SearchAudit.Enabled)
121+
d.Set("share_dashboards_outside_organization", policies.ShareDashboardsOutsideOrganization.Enabled)
122+
setUserConcurrentSessionsLimitPolicy(d, &policies.UserConcurrentSessionsLimit)
123+
}
124+
125+
func resourceToPolicies(d *schema.ResourceData) Policies {
126+
var policies Policies
127+
policies.Audit = AuditPolicy{d.Get("audit").(bool)}
128+
policies.DataAccessLevel = DataAccessLevelPolicy{d.Get("data_access_level").(bool)}
129+
policies.MaxUserSessionTimeout = MaxUserSessionTimeoutPolicy{d.Get("max_user_session_timeout").(string)}
130+
policies.SearchAudit = SearchAuditPolicy{d.Get("search_audit").(bool)}
131+
policies.ShareDashboardsOutsideOrganization = ShareDashboardsOutsideOrganizationPolicy{d.Get("share_dashboards_outside_organization").(bool)}
132+
policies.UserConcurrentSessionsLimit = getUserConcurrentSessionsLimitPolicy(d)
133+
return policies
134+
}
135+
136+
func setUserConcurrentSessionsLimitPolicy(d *schema.ResourceData, policy *UserConcurrentSessionsLimitPolicy) {
137+
userConcurrentSessionsLimitPolicyMap := make(map[string]interface{})
138+
userConcurrentSessionsLimitPolicyMap["enabled"] = policy.Enabled
139+
userConcurrentSessionsLimitPolicyMap["max_concurrent_sessions"] = policy.MaxConcurrentSessions
140+
141+
userConcurrentSessionsLimitPolicy := make([]map[string]interface{}, 1)
142+
userConcurrentSessionsLimitPolicy[0] = userConcurrentSessionsLimitPolicyMap
143+
144+
d.Set("user_concurrent_sessions_limit", userConcurrentSessionsLimitPolicy)
145+
}
146+
147+
func getUserConcurrentSessionsLimitPolicy(d *schema.ResourceData) UserConcurrentSessionsLimitPolicy {
148+
resourceAsMap := d.Get("user_concurrent_sessions_limit").([]interface{})[0].(map[string]interface{})
149+
var userConcurrentSessionsLimitPolicy UserConcurrentSessionsLimitPolicy
150+
userConcurrentSessionsLimitPolicy.Enabled = resourceAsMap["enabled"].(bool)
151+
userConcurrentSessionsLimitPolicy.MaxConcurrentSessions = resourceAsMap["max_concurrent_sessions"].(int)
152+
return userConcurrentSessionsLimitPolicy
153+
}

‎sumologic/resource_sumologic_policies_test.go‎

Lines changed: 146 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,146 @@
1+
package sumologic
2+
3+
import (
4+
"fmt"
5+
"strconv"
6+
"testing"
7+
8+
"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
9+
"github.com/hashicorp/terraform-plugin-sdk/terraform"
10+
)
11+
12+
func TestAccPolicies_create(t *testing.T) {
13+
policies := Policies{
14+
Audit: AuditPolicy{Enabled: true},
15+
DataAccessLevel: DataAccessLevelPolicy{Enabled: true},
16+
MaxUserSessionTimeout: MaxUserSessionTimeoutPolicy{MaxUserSessionTimeout: "1h"},
17+
SearchAudit: SearchAuditPolicy{Enabled: true},
18+
ShareDashboardsOutsideOrganization: ShareDashboardsOutsideOrganizationPolicy{Enabled: true},
19+
UserConcurrentSessionsLimit: UserConcurrentSessionsLimitPolicy{Enabled: true, MaxConcurrentSessions: 70},
20+
}
21+
22+
resource.Test(t, resource.TestCase{
23+
PreCheck: func() { testAccPreCheck(t) },
24+
Providers: testAccProviders,
25+
CheckDestroy: testAccCheckPoliciesDestroy(),
26+
Steps: []resource.TestStep{
27+
{
28+
Config: newPoliciesConfig("test_create", &policies),
29+
Check: resource.ComposeTestCheckFunc(
30+
testAccCheckPoliciesExists("sumologic_policies.test_create"),
31+
testPoliciesCheckResourceAttr("sumologic_policies.test_create", &policies),
32+
),
33+
},
34+
},
35+
})
36+
}
37+
38+
func TestAccPolicies_update(t *testing.T) {
39+
policies := Policies{
40+
Audit: AuditPolicy{Enabled: true},
41+
DataAccessLevel: DataAccessLevelPolicy{Enabled: true},
42+
MaxUserSessionTimeout: MaxUserSessionTimeoutPolicy{MaxUserSessionTimeout: "15m"},
43+
SearchAudit: SearchAuditPolicy{Enabled: true},
44+
ShareDashboardsOutsideOrganization: ShareDashboardsOutsideOrganizationPolicy{Enabled: true},
45+
UserConcurrentSessionsLimit: UserConcurrentSessionsLimitPolicy{Enabled: true, MaxConcurrentSessions: 80},
46+
}
47+
48+
updatedPolicies := Policies{
49+
Audit: AuditPolicy{Enabled: false},
50+
DataAccessLevel: DataAccessLevelPolicy{Enabled: false},
51+
MaxUserSessionTimeout: MaxUserSessionTimeoutPolicy{MaxUserSessionTimeout: "7d"},
52+
SearchAudit: SearchAuditPolicy{Enabled: false},
53+
ShareDashboardsOutsideOrganization: ShareDashboardsOutsideOrganizationPolicy{Enabled: false},
54+
UserConcurrentSessionsLimit: UserConcurrentSessionsLimitPolicy{Enabled: false, MaxConcurrentSessions: 100},
55+
}
56+
57+
resource.Test(t, resource.TestCase{
58+
PreCheck: func() { testAccPreCheck(t) },
59+
Providers: testAccProviders,
60+
CheckDestroy: testAccCheckPoliciesDestroy(),
61+
Steps: []resource.TestStep{
62+
{
63+
Config: newPoliciesConfig("test_update", &policies),
64+
Check: resource.ComposeTestCheckFunc(
65+
testAccCheckPoliciesExists("sumologic_policies.test_update"),
66+
testPoliciesCheckResourceAttr("sumologic_policies.test_update", &policies),
67+
),
68+
},
69+
{
70+
Config: newPoliciesConfig("test_update", &updatedPolicies),
71+
Check: resource.ComposeTestCheckFunc(
72+
testAccCheckPoliciesExists("sumologic_policies.test_update"),
73+
testPoliciesCheckResourceAttr("sumologic_policies.test_update", &updatedPolicies),
74+
),
75+
},
76+
},
77+
})
78+
}
79+
80+
func testAccCheckPoliciesDestroy() resource.TestCheckFunc {
81+
return func(s *terraform.State) error {
82+
client := testAccProvider.Meta().(*Client)
83+
for _, rs := range s.RootModule().Resources {
84+
if rs.Type != "sumologic_policies" {
85+
continue
86+
}
87+
88+
policies, err := client.GetPolicies()
89+
if err != nil {
90+
return fmt.Errorf("Encountered an error: " + err.Error())
91+
}
92+
93+
if (*policies) != DefaultPolicies {
94+
return fmt.Errorf("Policies weren't reset properly")
95+
}
96+
}
97+
return nil
98+
}
99+
}
100+
101+
func testAccCheckPoliciesExists(name string) resource.TestCheckFunc {
102+
return func(s *terraform.State) error {
103+
_, ok := s.RootModule().Resources[name]
104+
if !ok {
105+
return fmt.Errorf("Policies not found: %s", name)
106+
}
107+
return nil
108+
}
109+
}
110+
111+
func testPoliciesCheckResourceAttr(resourceName string, policies *Policies) resource.TestCheckFunc {
112+
return func(s *terraform.State) error {
113+
f := resource.ComposeTestCheckFunc(
114+
resource.TestCheckResourceAttr(resourceName, "audit", strconv.FormatBool(policies.Audit.Enabled)),
115+
resource.TestCheckResourceAttr(resourceName, "data_access_level", strconv.FormatBool(policies.DataAccessLevel.Enabled)),
116+
resource.TestCheckResourceAttr(resourceName, "max_user_session_timeout", policies.MaxUserSessionTimeout.MaxUserSessionTimeout),
117+
resource.TestCheckResourceAttr(resourceName, "search_audit", strconv.FormatBool(policies.SearchAudit.Enabled)),
118+
resource.TestCheckResourceAttr(resourceName, "share_dashboards_outside_organization", strconv.FormatBool(policies.ShareDashboardsOutsideOrganization.Enabled)),
119+
resource.TestCheckResourceAttr(resourceName, "user_concurrent_sessions_limit.0.enabled", strconv.FormatBool(policies.UserConcurrentSessionsLimit.Enabled)),
120+
resource.TestCheckResourceAttr(resourceName, "user_concurrent_sessions_limit.0.max_concurrent_sessions", strconv.Itoa(policies.UserConcurrentSessionsLimit.MaxConcurrentSessions)),
121+
)
122+
return f(s)
123+
}
124+
}
125+
126+
func newPoliciesConfig(label string, policies *Policies) string {
127+
return fmt.Sprintf(`
128+
resource "sumologic_policies" "%s" {
129+
audit = %t
130+
data_access_level = %t
131+
max_user_session_timeout = "%s"
132+
search_audit = %t
133+
share_dashboards_outside_organization = %t
134+
user_concurrent_sessions_limit {
135+
enabled = %t
136+
max_concurrent_sessions = %d
137+
}
138+
}`, label,
139+
policies.Audit.Enabled,
140+
policies.DataAccessLevel.Enabled,
141+
policies.MaxUserSessionTimeout.MaxUserSessionTimeout,
142+
policies.SearchAudit.Enabled,
143+
policies.ShareDashboardsOutsideOrganization.Enabled,
144+
policies.UserConcurrentSessionsLimit.Enabled,
145+
policies.UserConcurrentSessionsLimit.MaxConcurrentSessions)
146+
}

0 commit comments

Comments
 (0)