Debian Codegraph @

ansible_collections/netapp/ontap/plugins/modules/na_ontap_vscan_scanner_pool.py

raw
1 #!/usr/bin/python
2
3 # (c) 2018-2024, NetApp, Inc
4 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
5
6 '''
7 na_ontap_vscan_scanner_pool
8 '''
9
10 from __future__ import absolute_import, division, print_function
11
12 __metaclass__ = type
13
14 ANSIBLE_METADATA = {'metadata_version': '1.1',
15 'status': ['preview'],
16 'supported_by': 'community'}
17
18 DOCUMENTATION = '''
19 module: na_ontap_vscan_scanner_pool
20 short_description: NetApp ONTAP Vscan Scanner Pools Configuration.
21 extends_documentation_fragment:
22 - netapp.ontap.netapp.na_ontap
23 version_added: 2.8.0
24 author: NetApp Ansible Team (@carchi8py) <[email protected]>
25 description:
26 - Create/Modify/Delete a Vscan Scanner Pool
27 options:
28 state:
29 description:
30 - Whether a Vscan Scanner pool is present or not
31 choices: ['present', 'absent']
32 type: str
33 default: present
34
35 vserver:
36 description:
37 - the name of the data vserver to use.
38 required: true
39 type: str
40
41 hostnames:
42 description:
43 - List of hostnames of Vscan servers which are allowed to connect to Data ONTAP
44 type: list
45 elements: str
46
47 privileged_users:
48 description:
49 - List of privileged usernames. Username must be in the form "domain-name\\user-name"
50 type: list
51 elements: str
52
53 scanner_pool:
54 description:
55 - the name of the virus scanner pool
56 required: true
57 type: str
58
59 scanner_policy:
60 description:
61 - The name of the Virus scanner Policy
62 choices: ['primary', 'secondary', 'idle']
63 type: str
64 '''
65
66 EXAMPLES = """
67 - name: Create and enable Scanner pool
68 netapp.ontap.na_ontap_vscan_scanner_pool:
69 state: present
70 username: '{{ netapp_username }}'
71 password: '{{ netapp_password }}'
72 hostname: '{{ netapp_hostname }}'
73 vserver: carchi-vsim2
74 hostnames: ['name', 'name2']
75 privileged_users: ['sim.rtp.openeng.netapp.com\\admin', 'sim.rtp.openeng.netapp.com\\carchi']
76 scanner_pool: Scanner1
77 scanner_policy: primary
78
79 - name: Modify scanner pool
80 netapp.ontap.na_ontap_vscan_scanner_pool:
81 state: present
82 username: '{{ netapp_username }}'
83 password: '{{ netapp_password }}'
84 hostname: '{{ netapp_hostname }}'
85 vserver: carchi-vsim2
86 hostnames: ['name', 'name2', 'name3']
87 privileged_users: ['sim.rtp.openeng.netapp.com\\admin', 'sim.rtp.openeng.netapp.com\\carchi', 'sim.rtp.openeng.netapp.com\\chuyic']
88 scanner_pool: Scanner1
89
90 - name: Delete a scanner pool
91 netapp.ontap.na_ontap_vscan_scanner_pool:
92 state: absent
93 username: '{{ netapp_username }}'
94 password: '{{ netapp_password }}'
95 hostname: '{{ netapp_hostname }}'
96 vserver: carchi-vsim2
97 scanner_pool: Scanner1
98 """
99
100 RETURN = """
101
102 """
103
104 import traceback
105
106 from ansible.module_utils.basic import AnsibleModule
107 from ansible.module_utils._text import to_native
108 import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils
109 from ansible_collections.netapp.ontap.plugins.module_utils.netapp import OntapRestAPI
110 from ansible_collections.netapp.ontap.plugins.module_utils.netapp_module import NetAppModule
111 from ansible_collections.netapp.ontap.plugins.module_utils import rest_generic
112 from ansible_collections.netapp.ontap.plugins.module_utils import rest_vserver
113
114 HAS_NETAPP_LIB = netapp_utils.has_netapp_lib()
115
116
117 class NetAppOntapVscanScannerPool(object):
118 ''' create, modify, delete vscan scanner pool '''
119 def __init__(self):
120 self.use_rest = False
121 self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
122 self.argument_spec.update(dict(
123 state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
124 vserver=dict(required=True, type='str'),
125 hostnames=dict(required=False, type='list', elements='str'),
126 privileged_users=dict(required=False, type='list', elements='str'),
127 scanner_pool=dict(required=True, type='str'),
128 scanner_policy=dict(required=False, type='str', choices=['primary', 'secondary', 'idle'])
129 ))
130 self.module = AnsibleModule(
131 argument_spec=self.argument_spec,
132 supports_check_mode=True
133 )
134 self.svm_uuid = None
135 self.na_helper = NetAppModule()
136 self.parameters = self.na_helper.set_parameters(self.module.params)
137
138 self.rest_api = OntapRestAPI(self.module)
139 self.use_rest = self.rest_api.is_rest()
140 if self.use_rest and not self.rest_api.meets_rest_minimum_version(self.use_rest, 9, 6):
141 msg = 'REST requires ONTAP 9.6 or later for /protocols/vscan/{{svm.uuid}}/scanner-pools APIs'
142 self.use_rest = self.na_helper.fall_back_to_zapi(self.module, msg, self.parameters)
143 if not self.use_rest:
144 if HAS_NETAPP_LIB is False:
145 self.module.fail_json(msg=netapp_utils.netapp_lib_is_required())
146 self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
147
148 def create_scanner_pool(self):
149 """
150 Create a Vscan Scanner Pool
151 :return: nothing
152 """
153 if self.use_rest:
154 return self.create_scanner_pool_rest()
155 scanner_pool_obj = netapp_utils.zapi.NaElement('vscan-scanner-pool-create')
156 if self.parameters['hostnames']:
157 string_obj = netapp_utils.zapi.NaElement('hostnames')
158 scanner_pool_obj.add_child_elem(string_obj)
159 for hostname in self.parameters['hostnames']:
160 string_obj.add_new_child('string', hostname)
161 if self.parameters['privileged_users']:
162 users_obj = netapp_utils.zapi.NaElement('privileged-users')
163 scanner_pool_obj.add_child_elem(users_obj)
164 for user in self.parameters['privileged_users']:
165 users_obj.add_new_child('privileged-user', user)
166 scanner_pool_obj.add_new_child('scanner-pool', self.parameters['scanner_pool'])
167 try:
168 self.server.invoke_successfully(scanner_pool_obj, True)
169 except netapp_utils.zapi.NaApiError as error:
170 self.module.fail_json(msg='Error creating Vscan Scanner Pool %s: %s' %
171 (self.parameters['scanner_policy'], to_native(error)),
172 exception=traceback.format_exc())
173
174 def apply_policy(self):
175 """
176 Apply a Scanner policy to a Scanner pool
177 :return: nothing
178 """
179 apply_policy_obj = netapp_utils.zapi.NaElement('vscan-scanner-pool-apply-policy')
180 apply_policy_obj.add_new_child('scanner-policy', self.parameters['scanner_policy'])
181 apply_policy_obj.add_new_child('scanner-pool', self.parameters['scanner_pool'])
182 try:
183 self.server.invoke_successfully(apply_policy_obj, True)
184 except netapp_utils.zapi.NaApiError as error:
185 self.module.fail_json(msg='Error appling policy %s to pool %s: %s' %
186 (self.parameters['scanner_policy'], self.parameters['scanner_policy'], to_native(error)),
187 exception=traceback.format_exc())
188
189 def get_scanner_pool(self):
190 """
191 Check to see if a scanner pool exist or not
192 :return: True if it exist, False if it does not
193 """
194 if self.use_rest:
195 return self.get_scanner_pool_rest()
196 return_value = None
197 scanner_pool_obj = netapp_utils.zapi.NaElement('vscan-scanner-pool-get-iter')
198 scanner_pool_info = netapp_utils.zapi.NaElement('vscan-scanner-pool-info')
199 scanner_pool_info.add_new_child('scanner-pool', self.parameters['scanner_pool'])
200 scanner_pool_info.add_new_child('vserver', self.parameters['vserver'])
201 query = netapp_utils.zapi.NaElement('query')
202 query.add_child_elem(scanner_pool_info)
203 scanner_pool_obj.add_child_elem(query)
204 try:
205 result = self.server.invoke_successfully(scanner_pool_obj, True)
206 except netapp_utils.zapi.NaApiError as error:
207 self.module.fail_json(msg='Error searching for Vscan Scanner Pool %s: %s' %
208 (self.parameters['scanner_pool'], to_native(error)), exception=traceback.format_exc())
209 if result.get_child_by_name('num-records') and int(result.get_child_content('num-records')) >= 1:
210 if result.get_child_by_name('attributes-list').get_child_by_name('vscan-scanner-pool-info').get_child_content(
211 'scanner-pool') == self.parameters['scanner_pool']:
212 scanner_pool_obj = result.get_child_by_name('attributes-list').get_child_by_name('vscan-scanner-pool-info')
213 hostname = [host.get_content() for host in
214 scanner_pool_obj.get_child_by_name('hostnames').get_children()]
215 privileged_users = [user.get_content() for user in
216 scanner_pool_obj.get_child_by_name('privileged-users').get_children()]
217 return_value = {
218 'hostnames': hostname,
219 'enable': scanner_pool_obj.get_child_content('is-currently-active'),
220 'privileged_users': privileged_users,
221 'scanner_pool': scanner_pool_obj.get_child_content('scanner-pool'),
222 'scanner_policy': scanner_pool_obj.get_child_content('scanner-policy')
223 }
224 return return_value
225
226 def delete_scanner_pool(self):
227 """
228 Delete a Scanner pool
229 :return: nothing
230 """
231 if self.use_rest:
232 return self.delete_scanner_pool_rest()
233 scanner_pool_obj = netapp_utils.zapi.NaElement('vscan-scanner-pool-delete')
234 scanner_pool_obj.add_new_child('scanner-pool', self.parameters['scanner_pool'])
235 try:
236 self.server.invoke_successfully(scanner_pool_obj, True)
237 except netapp_utils.zapi.NaApiError as error:
238 self.module.fail_json(msg='Error deleting Vscan Scanner Pool %s: %s' %
239 (self.parameters['scanner_pool'], to_native(error)),
240 exception=traceback.format_exc())
241
242 def modify_scanner_pool(self, modify):
243 """
244 Modify a scanner pool
245 :return: nothing
246 """
247 if self.use_rest:
248 return self.modify_scanner_pool_rest(modify)
249 vscan_pool_modify = netapp_utils.zapi.NaElement('vscan-scanner-pool-modify')
250 vscan_pool_modify.add_new_child('scanner-pool', self.parameters['scanner_pool'])
251 for key in modify:
252 if key == 'privileged_users':
253 users_obj = netapp_utils.zapi.NaElement('privileged-users')
254 vscan_pool_modify.add_child_elem(users_obj)
255 for user in modify['privileged_users']:
256 users_obj.add_new_child('privileged-user', user)
257 elif key == 'hostnames':
258 string_obj = netapp_utils.zapi.NaElement('hostnames')
259 vscan_pool_modify.add_child_elem(string_obj)
260 for hostname in modify['hostnames']:
261 string_obj.add_new_child('string', hostname)
262 elif key != 'scanner_policy':
263 vscan_pool_modify.add_new_child(self.attribute_to_name(key), str(modify[key]))
264
265 try:
266 self.server.invoke_successfully(vscan_pool_modify, True)
267 except netapp_utils.zapi.NaApiError as error:
268 self.module.fail_json(msg='Error modifying Vscan Scanner Pool %s: %s' %
269 (self.parameters['scanner_pool'], to_native(error)),
270 exception=traceback.format_exc())
271
272 @staticmethod
273 def attribute_to_name(attribute):
274 return str.replace(attribute, '_', '-')
275
276 def get_svm_uuid(self):
277 """
278 Get a vserver's uuid
279 :return: nothing
280 """
281 record, error = rest_vserver.get_vserver_uuid(self.rest_api, self.parameters['vserver'])
282 if error is not None:
283 self.module.fail_json(msg="Error fetching vserver %s: %s" % (self.parameters['vserver'], to_native(error)),
284 exception=traceback.format_exc())
285 if record is None:
286 self.module.fail_json(msg="Error fetching vserver %s. Please make sure vserver name is correct."
287 % self.parameters['vserver'], exception=traceback.format_exc())
288 self.svm_uuid = record
289
290 def get_scanner_pool_rest(self):
291 """
292 Check to see if a scanner pool exist or not using REST
293 :return: record if it exist, None if it does not
294 """
295 self.get_svm_uuid()
296 api = 'protocols/vscan/%s/scanner-pools' % self.svm_uuid
297 query = {'name': self.parameters.get('scanner_pool'),
298 'fields': 'servers,'
299 'privileged_users,'}
300 if self.parameters.get('scanner_policy') is not None:
301 query['fields'] += 'role,'
302
303 record, error = rest_generic.get_one_record(self.rest_api, api, query)
304 if error:
305 self.module.fail_json(msg='Error searching for Vscan Scanner Pool %s: %s' %
306 (self.parameters['scanner_pool'], to_native(error)),
307 exception=traceback.format_exc())
308 if record:
309 return {
310 'scanner_pool': record.get('name'),
311 'hostnames': record.get('servers'),
312 'privileged_users': record.get('privileged_users'),
313 'scanner_policy': record.get('role'),
314 }
315 return None
316
317 def create_scanner_pool_rest(self):
318 """
319 Create a Vscan Scanner Pool using REST
320 :return: nothing
321 """
322 api = 'protocols/vscan/%s/scanner-pools' % self.svm_uuid
323 body = {
324 'name': self.parameters['scanner_pool'],
325 'servers': self.parameters['hostnames'],
326 'privileged_users': self.parameters['privileged_users'],
327 }
328 if 'scanner_policy' in self.parameters:
329 body['role'] = self.parameters['scanner_policy']
330
331 dummy, error = rest_generic.post_async(self.rest_api, api, body)
332 if error is not None:
333 self.module.fail_json(msg='Error creating Vscan Scanner Pool %s: %s' %
334 (self.parameters['scanner_pool'], to_native(error)),
335 exception=traceback.format_exc())
336
337 def delete_scanner_pool_rest(self):
338 """
339 Delete a Scanner pool using REST
340 :return: nothing
341 """
342 api = 'protocols/vscan/%s/scanner-pools/%s' % (self.svm_uuid, self.parameters['scanner_pool'])
343 dummy, error = rest_generic.delete_async(self.rest_api, api, uuid=None)
344 if error is not None:
345 self.module.fail_json(msg='Error deleting Vscan Scanner Pool %s: %s' %
346 (self.parameters['scanner_pool'], to_native(error)),
347 exception=traceback.format_exc())
348
349 def modify_scanner_pool_rest(self, modify):
350 """
351 Modify a scanner pool using REST
352 :return: nothing
353 """
354 api = 'protocols/vscan/%s/scanner-pools/%s' % (self.svm_uuid, self.parameters['scanner_pool'])
355 body = {}
356 for key, option in [
357 ('servers', 'hostnames'),
358 ('privileged_users', 'privileged_users'),
359 ('role', 'scanner_policy'),
360 ]:
361 if modify.get(option) is not None:
362 body[key] = modify[option]
363
364 dummy, error = rest_generic.patch_async(self.rest_api, api, uuid_or_name=None, body=body)
365 if error:
366 self.module.fail_json(msg='Error modifying Vscan Scanner Pool %s: %s.' %
367 (self.parameters['scanner_pool'], to_native(error)),
368 exception=traceback.format_exc())
369
370 def apply(self):
371 current = self.get_scanner_pool()
372 cd_action = self.na_helper.get_cd_action(current, self.parameters)
373 modify = None
374 if self.parameters['state'] == 'present' and cd_action is None:
375 modify = self.na_helper.get_modified_attributes(current, self.parameters)
376 if self.na_helper.changed and not self.module.check_mode:
377 if cd_action == 'create':
378 self.create_scanner_pool()
379 if not self.use_rest and self.parameters.get('scanner_policy') is not None:
380 self.apply_policy()
381 elif cd_action == 'delete':
382 self.delete_scanner_pool()
383 elif modify:
384 self.modify_scanner_pool(modify)
385 if not self.use_rest and self.parameters.get('scanner_policy') is not None:
386 self.apply_policy()
387 result = netapp_utils.generate_result(self.na_helper.changed, cd_action, modify)
388 self.module.exit_json(**result)
389
390
391 def main():
392 """
393 Execute action from playbook
394 """
395 scanner_pool = NetAppOntapVscanScannerPool()
396 scanner_pool.apply()
397
398
399 if __name__ == '__main__':
400 main()