Debian Codegraph @

ansible_collections/netapp/storagegrid/plugins/modules/na_sg_grid_firewall.py

raw
1 #!/usr/bin/python
2
3 # (c) 2025, NetApp Inc
4 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
5
6 """NetApp StorageGRID - Manage Node Firewall"""
7
8 from __future__ import absolute_import, division, print_function
9
10 __metaclass__ = type
11
12
13 ANSIBLE_METADATA = {
14 "metadata_version": "1.0",
15 "status": ["preview"],
16 "supported_by": "community",
17 }
18
19
20 DOCUMENTATION = """
21 module: na_sg_grid_firewall
22 short_description: NetApp StorageGRID manage node firewall.
23 extends_documentation_fragment:
24 - netapp.storagegrid.netapp.sg
25 version_added: '21.16.0'
26 author: NetApp Ansible Team (@vinaykus) <[email protected]>
27 description:
28 - Create, update, or delete node firewall on NetApp StorageGRID.
29 options:
30 state:
31 description:
32 - Whether the firewall should be present or absent.
33 choices: ['present', 'absent']
34 default: 'present'
35 type: str
36 id:
37 description:
38 - The node UUID or the default list ID.
39 type: str
40 blocked_udp_ports:
41 description:
42 - List of UDP ports to block for external communication.
43 type: list
44 elements: int
45 blocked_tcp_ports:
46 description:
47 - List of TCP ports to block for external communication.
48 type: list
49 elements: int
50 privileged_ips:
51 description:
52 - A list of privileged IP addresses, or subnets in CIDR notation.
53 - Addresses in this list can access ports which are blocked for external communication.
54 type: list
55 elements: str
56 grid_internal_access:
57 description:
58 - Whether to allow internal port access to the grid.
59 type: bool
60 """
61
62 EXAMPLES = """
63 - name: create list of blocked ports
64 netapp.storagegrid.na_sg_grid_firewall:
65 api_url: "https://<storagegrid-endpoint-url>"
66 auth_token: "storagegrid-auth-token"
67 validate_certs: false
68 state: present
69 id: "00000000-0000-0000-0000-000000000000"
70 blocked_udp_ports: [68]
71 blocked_tcp_ports: [22, 80]
72
73 - name: create list of privileged IP
74 netapp.storagegrid.na_sg_grid_firewall:
75 api_url: "https://<storagegrid-endpoint-url>"
76 auth_token: "storagegrid-auth-token"
77 validate_certs: false
78 state: present
79 id: "00000000-0000-0000-0000-000000000000"
80 privileged_ips: ["192.168.1.1/32"]
81 grid_internal_access: true
82
83 - name: create a firewall
84 netapp.storagegrid.na_sg_grid_firewall:
85 api_url: "https://<storagegrid-endpoint-url>"
86 auth_token: "storagegrid-auth-token"
87 validate_certs: false
88 state: present
89 id: "00000000-0000-0000-0000-000000000000"
90 blocked_udp_ports: [68]
91 blocked_tcp_ports: [22, 80]
92 privileged_ips: ["192.168.1.1/32"]
93 grid_internal_access: true
94
95 - name: delete a firewall
96 netapp.storagegrid.na_sg_grid_firewall:
97 api_url: "https://<storagegrid-endpoint-url>"
98 auth_token: "storagegrid-auth-token"
99 validate_certs: false
100 state: absent
101 id: "00000000-0000-0000-0000-000000000000"
102 """
103
104 RETURN = """
105 resp:
106 description: Returns the response from the StorageGRID API for firewall.
107 returned: success
108 type: dict
109 sample: {
110 "privileged_ip_info": {
111 "id": "00000000-0000-0000-0000-000000000000",
112 "privilegedIps": ["192.168.10.10", "10.19.10.0/24"],
113 "gridInternalAccess": true
114 },
115 "blocked_port_info": {
116 "id": "00000000-0000-0000-0000-000000000000",
117 "tcpPorts": [2022, 22, 903],
118 "udpPorts": [68]
119 }
120 }
121 """
122
123 import ansible_collections.netapp.storagegrid.plugins.module_utils.netapp as netapp_utils
124 from ansible.module_utils.basic import AnsibleModule
125 from ansible_collections.netapp.storagegrid.plugins.module_utils.netapp_module import NetAppModule
126 from ansible_collections.netapp.storagegrid.plugins.module_utils.netapp import SGRestAPI
127
128
129 class SgFirewall(object):
130 """
131 Create, modify and delete Firewall for StorageGRID
132 """
133
134 def __init__(self):
135 """
136 Parse arguments, setup state variables,
137 check parameters and ensure request module is installed
138 """
139 self.argument_spec = netapp_utils.na_storagegrid_host_argument_spec()
140 self.argument_spec.update(
141 dict(
142 state=dict(type="str", choices=["present", "absent"], default="present"),
143 id=dict(type="str", required=False),
144 blocked_udp_ports=dict(type="list", elements="int", required=False),
145 blocked_tcp_ports=dict(type="list", elements="int", required=False),
146 privileged_ips=dict(type="list", elements="str", required=False),
147 grid_internal_access=dict(type="bool", required=False),
148 )
149 )
150 self.module = AnsibleModule(
151 argument_spec=self.argument_spec,
152 required_if=[
153 ("state", "present", ["id"]),
154 ("state", "present", ["blocked_udp_ports", "blocked_tcp_ports", "privileged_ips", "grid_internal_access"], True)
155 ],
156 supports_check_mode=True
157 )
158 self.na_helper = NetAppModule()
159
160 # set up state variables
161 self.parameters = self.na_helper.set_parameters(self.module.params)
162 # Calling generic SG rest_api class
163 self.rest_api = SGRestAPI(self.module)
164 # Get API version
165 self.rest_api.get_sg_product_version()
166
167 # Checking for the parameters passed and create new parameters list
168 self.blocked_port_info = {}
169 self.blocked_port_info["id"] = self.parameters["id"]
170 if self.parameters.get("blocked_udp_ports") is not None:
171 self.blocked_port_info["udpPorts"] = self.parameters["blocked_udp_ports"]
172 if self.parameters.get("blocked_tcp_ports") is not None:
173 self.blocked_port_info["tcpPorts"] = self.parameters["blocked_tcp_ports"]
174
175 self.privileged_ips_info = {}
176 self.privileged_ips_info["id"] = self.parameters["id"]
177 if self.parameters.get("privileged_ips") is not None:
178 self.privileged_ips_info["privilegedIps"] = self.parameters["privileged_ips"]
179 if self.parameters.get("grid_internal_access") is not None:
180 self.privileged_ips_info["gridInternalAccess"] = self.parameters["grid_internal_access"]
181
182 def get_blocked_ports(self):
183 ''' Get blocked ports list'''
184 api = "api/v4/private/firewall-blocked-ports"
185 response, error = self.rest_api.get(api)
186 if error:
187 self.module.fail_json(msg=error)
188 # if blocked ports exists, return it, else none
189 for blocked_port in response["data"]:
190 if blocked_port["id"] == self.parameters["id"]:
191 self.id = blocked_port["id"]
192 return blocked_port
193 return None
194
195 def get_all_external_ports(self):
196 ''' Get all external TCP and UDP ports '''
197 api = "api/v4/private/firewall-external-ports"
198 response, error = self.rest_api.get(api)
199 if error:
200 self.module.fail_json(msg=error)
201
202 return response["data"]
203
204 def create_blocked_port(self):
205 ''' Create blocked port '''
206 api = "api/v4/private/firewall-blocked-ports"
207 response, error = self.rest_api.post(api, self.blocked_port_info)
208 if error:
209 self.module.fail_json(msg=error)
210 else:
211 return response["data"]
212
213 def delete_blocked_port(self, blocked_id):
214 ''' Delete blocked port '''
215 api = "api/v4/private/firewall-blocked-ports/%s" % blocked_id
216 response, error = self.rest_api.delete(api, None)
217 if error:
218 self.module.fail_json(msg=error)
219
220 def update_blocked_port(self, blocked_id):
221 ''' Update blocked port '''
222 api = "api/v4/private/firewall-blocked-ports/%s" % blocked_id
223 response, error = self.rest_api.put(api, self.blocked_port_info)
224 if error:
225 self.module.fail_json(msg=error)
226 else:
227 return response["data"]
228
229 def get_privileged_ip(self):
230 ''' Get privileged IPs '''
231 api = "api/v4/private/firewall-privileged-ips"
232 response, error = self.rest_api.get(api)
233 if error:
234 self.module.fail_json(msg=error)
235 # if privileged IP exists, return it, else none
236 for privileged_ips_id in response["data"]:
237 if privileged_ips_id["id"] == self.parameters["id"]:
238 self.id = privileged_ips_id["id"]
239 return privileged_ips_id
240 return None
241
242 def create_privileged_ip(self):
243 ''' Create privileged IP '''
244 api = "api/v4/private/firewall-privileged-ips"
245 response, error = self.rest_api.post(api, self.privileged_ips_info)
246 if error:
247 self.module.fail_json(msg=error)
248 else:
249 return response["data"]
250
251 def update_privileged_ip(self, privileged_ips_id):
252 ''' Update privileged IP '''
253 api = "api/v4/private/firewall-privileged-ips/%s" % privileged_ips_id
254 response, error = self.rest_api.put(api, self.privileged_ips_info)
255 if error:
256 self.module.fail_json(msg=error)
257 else:
258 return response["data"]
259
260 def delete_privileged_ip(self, privileged_ips_id):
261 ''' Delete privileged IP '''
262 api = "api/v4/private/firewall-privileged-ips/%s" % privileged_ips_id
263 response, error = self.rest_api.delete(api, None)
264 if error:
265 self.module.fail_json(msg=error)
266
267 def check_if_tcp_udp_ports_present(self):
268 ''' Check if user passed tcp/udp ports are present in external ports '''
269 all_external_ports = self.get_all_external_ports()
270 if self.parameters.get("blocked_tcp_ports") is not None:
271 for port in self.parameters["blocked_tcp_ports"]:
272 if port not in all_external_ports["externalTcpPorts"]:
273 self.module.fail_json(msg="TCP port %s is not a valid external port." % port)
274 if self.parameters.get("blocked_udp_ports") is not None:
275 for port in self.parameters["blocked_udp_ports"]:
276 if port not in all_external_ports["externalUdpPorts"]:
277 self.module.fail_json(msg="UDP port %s is not a valid external port." % port)
278
279 def apply(self):
280 ''' Apply firewall changes '''
281
282 blocked_ports = self.get_blocked_ports()
283 privileged_ips = self.get_privileged_ip()
284
285 # check blocked_ports and privileged_ips and prepare firewall_info
286 if blocked_ports is None and privileged_ips is None:
287 firewall_info = None
288 elif blocked_ports is None:
289 firewall_info = privileged_ips.copy()
290 elif privileged_ips is None:
291 firewall_info = blocked_ports.copy()
292 else:
293 # If both exist, merge them
294 firewall_info = {**blocked_ports, **privileged_ips}
295
296 # case1: blocked_ports exists, privileged_ips does not, but user wants to add privileged_ips
297 # In this case, privileged_ips will be created and blocked_ports will be overridden (updated)
298 if blocked_ports and not privileged_ips and (self.parameters.get("privileged_ips") or self.parameters.get("grid_internal_access")):
299 firewall_info = None
300 # case2: privileged_ips exists, blocked_ports does not, but user wants to add blocked_ports
301 if privileged_ips and not blocked_ports and (self.parameters.get("blocked_tcp_ports") or self.parameters.get("blocked_udp_ports")):
302 firewall_info = None
303
304 cd_action = self.na_helper.get_cd_action(firewall_info, self.parameters)
305
306 if cd_action is None and self.parameters["state"] == "present":
307 # let's see if we need to update parameters
308 blocked_ports_modify = False
309 privileged_ips_modify = False
310
311 blocked_ports_modify = self.na_helper.get_modified_attributes(blocked_ports, self.blocked_port_info)
312 privileged_ips_modify = self.na_helper.get_modified_attributes(privileged_ips, self.privileged_ips_info)
313
314 result_message = ""
315 resp_data = {}
316 if self.na_helper.changed:
317 if self.module.check_mode:
318 pass
319 else:
320 if cd_action == "create":
321 created_privileged_ip = False
322 created_blocked_port = False
323 self.check_if_tcp_udp_ports_present()
324 # Check what needs to be created
325 if blocked_ports and not privileged_ips:
326 resp_data["privileged_ip_info"] = self.create_privileged_ip()
327 created_privileged_ip = True
328 if privileged_ips and not blocked_ports:
329 resp_data["blocked_port_info"] = self.create_blocked_port()
330 created_blocked_port = True
331
332 # If neither exists, create both
333 if not blocked_ports and not privileged_ips:
334 if self.parameters.get("privileged_ips") or self.parameters.get("grid_internal_access"):
335 resp_data["privileged_ip_info"] = self.create_privileged_ip()
336 created_privileged_ip = True
337 if self.parameters.get("blocked_tcp_ports") or self.parameters.get("blocked_udp_ports"):
338 resp_data["blocked_port_info"] = self.create_blocked_port()
339 created_blocked_port = True
340
341 # Handle updates for existing resources when creating new ones
342 # If privileged IPs exist and user provided new privileged IP params, update it
343 if privileged_ips and (self.parameters.get("privileged_ips") or self.parameters.get("grid_internal_access")):
344 resp_data["privileged_ip_info"] = self.update_privileged_ip(privileged_ips["id"])
345 created_privileged_ip = True
346 # If blocked ports exist and user provided new blocked port params, update it
347 if blocked_ports and (self.parameters.get("blocked_tcp_ports") or self.parameters.get("blocked_udp_ports")):
348 resp_data["blocked_port_info"] = self.update_blocked_port(blocked_ports["id"])
349 created_blocked_port = True
350 # Set result message based on what was created
351 if created_privileged_ip and created_blocked_port:
352 result_message = "Firewall created successfully."
353 elif created_privileged_ip:
354 result_message = "Privileged IP created successfully."
355 elif created_blocked_port:
356 result_message = "Blocked port created successfully."
357 if not created_privileged_ip and not created_blocked_port:
358 self.na_helper.changed = False
359 elif cd_action == "delete":
360 self.delete_blocked_port(self.id)
361 self.delete_privileged_ip(self.id)
362 result_message = "Firewall deleted successfully."
363 elif blocked_ports_modify and privileged_ips_modify:
364 self.check_if_tcp_udp_ports_present()
365 resp_data["privileged_ip_info"] = self.update_privileged_ip(self.id)
366 resp_data["blocked_port_info"] = self.update_blocked_port(self.id)
367 result_message = "Firewall updated successfully."
368 elif blocked_ports_modify:
369 self.check_if_tcp_udp_ports_present()
370 resp_data = self.update_blocked_port(self.id)
371 result_message = "Blocked port updated successfully."
372 elif privileged_ips_modify:
373 resp_data = self.update_privileged_ip(self.id)
374 result_message = "Privileged IP updated successfully."
375
376 self.module.exit_json(changed=self.na_helper.changed, msg=result_message, resp=resp_data)
377
378
379 def main():
380 """
381 Main function
382 """
383 na_sg_grid_firewall = SgFirewall()
384 na_sg_grid_firewall.apply()
385
386
387 if __name__ == "__main__":
388 main()