Skip to content

Commit 01e1b81

Browse files
emichaeliemichaeli
authored
Merge pull request #248 from SumoLogic/emichaeli-add-policies-resource
Add Policies Resource
2 parents 5d2d8e1 + d18dfbf commit 01e1b81

File tree

6 files changed

+536
-0
lines changed

6 files changed

+536
-0
lines changed

‎CHANGELOG.md‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,10 @@
22

33
## 2.9.9 (August 12, 2021)
44

5+
FEATURES:
6+
7+
* **New Resource:** sumologic_policies (GH-248)
8+
59
BUG FIXES:
610

711
* resource/sumologic_monitor: Removed deprecation warning for `triggers`.

‎sumologic/provider.go‎

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

‎sumologic/resource_sumologic_policies.go‎

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

‎sumologic/resource_sumologic_policies_test.go‎

Lines changed: 173 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,173 @@
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_basic(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("tf_policies_import_test", &policies),
29+
},
30+
{
31+
ResourceName: "sumologic_policies.tf_policies_import_test",
32+
ImportState: true,
33+
ImportStateVerify: true,
34+
},
35+
},
36+
})
37+
}
38+
39+
func TestAccPolicies_create(t *testing.T) {
40+
policies := Policies{
41+
Audit: AuditPolicy{Enabled: true},
42+
DataAccessLevel: DataAccessLevelPolicy{Enabled: true},
43+
MaxUserSessionTimeout: MaxUserSessionTimeoutPolicy{MaxUserSessionTimeout: "1h"},
44+
SearchAudit: SearchAuditPolicy{Enabled: true},
45+
ShareDashboardsOutsideOrganization: ShareDashboardsOutsideOrganizationPolicy{Enabled: true},
46+
UserConcurrentSessionsLimit: UserConcurrentSessionsLimitPolicy{Enabled: true, MaxConcurrentSessions: 70},
47+
}
48+
49+
resource.Test(t, resource.TestCase{
50+
PreCheck: func() { testAccPreCheck(t) },
51+
Providers: testAccProviders,
52+
CheckDestroy: testAccCheckPoliciesDestroy(),
53+
Steps: []resource.TestStep{
54+
{
55+
Config: newPoliciesConfig("test_create", &policies),
56+
Check: resource.ComposeTestCheckFunc(
57+
testAccCheckPoliciesExists("sumologic_policies.test_create"),
58+
testPoliciesCheckResourceAttr("sumologic_policies.test_create", &policies),
59+
),
60+
},
61+
},
62+
})
63+
}
64+
65+
func TestAccPolicies_update(t *testing.T) {
66+
policies := Policies{
67+
Audit: AuditPolicy{Enabled: true},
68+
DataAccessLevel: DataAccessLevelPolicy{Enabled: true},
69+
MaxUserSessionTimeout: MaxUserSessionTimeoutPolicy{MaxUserSessionTimeout: "15m"},
70+
SearchAudit: SearchAuditPolicy{Enabled: true},
71+
ShareDashboardsOutsideOrganization: ShareDashboardsOutsideOrganizationPolicy{Enabled: true},
72+
UserConcurrentSessionsLimit: UserConcurrentSessionsLimitPolicy{Enabled: true, MaxConcurrentSessions: 80},
73+
}
74+
75+
updatedPolicies := Policies{
76+
Audit: AuditPolicy{Enabled: false},
77+
DataAccessLevel: DataAccessLevelPolicy{Enabled: false},
78+
MaxUserSessionTimeout: MaxUserSessionTimeoutPolicy{MaxUserSessionTimeout: "7d"},
79+
SearchAudit: SearchAuditPolicy{Enabled: false},
80+
ShareDashboardsOutsideOrganization: ShareDashboardsOutsideOrganizationPolicy{Enabled: false},
81+
UserConcurrentSessionsLimit: UserConcurrentSessionsLimitPolicy{Enabled: false, MaxConcurrentSessions: 100},
82+
}
83+
84+
resource.Test(t, resource.TestCase{
85+
PreCheck: func() { testAccPreCheck(t) },
86+
Providers: testAccProviders,
87+
CheckDestroy: testAccCheckPoliciesDestroy(),
88+
Steps: []resource.TestStep{
89+
{
90+
Config: newPoliciesConfig("test_update", &policies),
91+
Check: resource.ComposeTestCheckFunc(
92+
testAccCheckPoliciesExists("sumologic_policies.test_update"),
93+
testPoliciesCheckResourceAttr("sumologic_policies.test_update", &policies),
94+
),
95+
},
96+
{
97+
Config: newPoliciesConfig("test_update", &updatedPolicies),
98+
Check: resource.ComposeTestCheckFunc(
99+
testAccCheckPoliciesExists("sumologic_policies.test_update"),
100+
testPoliciesCheckResourceAttr("sumologic_policies.test_update", &updatedPolicies),
101+
),
102+
},
103+
},
104+
})
105+
}
106+
107+
func testAccCheckPoliciesDestroy() resource.TestCheckFunc {
108+
return func(s *terraform.State) error {
109+
client := testAccProvider.Meta().(*Client)
110+
for _, rs := range s.RootModule().Resources {
111+
if rs.Type != "sumologic_policies" {
112+
continue
113+
}
114+
115+
policies, err := client.GetPolicies()
116+
if err != nil {
117+
return fmt.Errorf("Encountered an error: " + err.Error())
118+
}
119+
120+
if (*policies) != DefaultPolicies {
121+
return fmt.Errorf("Policies weren't reset properly")
122+
}
123+
}
124+
return nil
125+
}
126+
}
127+
128+
func testAccCheckPoliciesExists(name string) resource.TestCheckFunc {
129+
return func(s *terraform.State) error {
130+
_, ok := s.RootModule().Resources[name]
131+
if !ok {
132+
return fmt.Errorf("Policies not found: %s", name)
133+
}
134+
return nil
135+
}
136+
}
137+
138+
func testPoliciesCheckResourceAttr(resourceName string, policies *Policies) resource.TestCheckFunc {
139+
return func(s *terraform.State) error {
140+
f := resource.ComposeTestCheckFunc(
141+
resource.TestCheckResourceAttr(resourceName, "audit", strconv.FormatBool(policies.Audit.Enabled)),
142+
resource.TestCheckResourceAttr(resourceName, "data_access_level", strconv.FormatBool(policies.DataAccessLevel.Enabled)),
143+
resource.TestCheckResourceAttr(resourceName, "max_user_session_timeout", policies.MaxUserSessionTimeout.MaxUserSessionTimeout),
144+
resource.TestCheckResourceAttr(resourceName, "search_audit", strconv.FormatBool(policies.SearchAudit.Enabled)),
145+
resource.TestCheckResourceAttr(resourceName, "share_dashboards_outside_organization", strconv.FormatBool(policies.ShareDashboardsOutsideOrganization.Enabled)),
146+
resource.TestCheckResourceAttr(resourceName, "user_concurrent_sessions_limit.0.enabled", strconv.FormatBool(policies.UserConcurrentSessionsLimit.Enabled)),
147+
resource.TestCheckResourceAttr(resourceName, "user_concurrent_sessions_limit.0.max_concurrent_sessions", strconv.Itoa(policies.UserConcurrentSessionsLimit.MaxConcurrentSessions)),
148+
)
149+
return f(s)
150+
}
151+
}
152+
153+
func newPoliciesConfig(label string, policies *Policies) string {
154+
return fmt.Sprintf(`
155+
resource "sumologic_policies" "%s" {
156+
audit = %t
157+
data_access_level = %t
158+
max_user_session_timeout = "%s"
159+
search_audit = %t
160+
share_dashboards_outside_organization = %t
161+
user_concurrent_sessions_limit {
162+
enabled = %t
163+
max_concurrent_sessions = %d
164+
}
165+
}`, label,
166+
policies.Audit.Enabled,
167+
policies.DataAccessLevel.Enabled,
168+
policies.MaxUserSessionTimeout.MaxUserSessionTimeout,
169+
policies.SearchAudit.Enabled,
170+
policies.ShareDashboardsOutsideOrganization.Enabled,
171+
policies.UserConcurrentSessionsLimit.Enabled,
172+
policies.UserConcurrentSessionsLimit.MaxConcurrentSessions)
173+
}

0 commit comments

Comments
 (0)