Debian Codegraph @

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

raw
1 #!/usr/bin/python
2
3 # (c) 2018 Piotr Olczak <[email protected]>
4 # (c) 2018-2022, NetApp, Inc
5 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
6
7 '''
8 na_ontap_info
9 '''
10
11 from __future__ import absolute_import, division, print_function
12 __metaclass__ = type
13
14 DOCUMENTATION = '''
15 module: na_ontap_info
16 author: Piotr Olczak (@dprts) <[email protected]>
17 extends_documentation_fragment:
18 - netapp.ontap.netapp.na_ontap_zapi
19 short_description: NetApp information gatherer
20 description:
21 - This module allows you to gather various information about ONTAP configuration
22 version_added: 2.9.0
23 requirements:
24 - netapp_lib
25 options:
26 state:
27 type: str
28 description:
29 - deprecated as of 21.1.0.
30 - this option was ignored and continues to be ignored.
31 vserver:
32 type: str
33 description:
34 - If present, 'vserver tunneling' will limit the output to the vserver scope.
35 - Note that not all subsets are supported on a vserver, and 'all' will trigger an error.
36 version_added: '19.11.0'
37 gather_subset:
38 type: list
39 elements: str
40 description:
41 - When supplied, this argument will restrict the information collected to a given subset. Possible values for this argument include
42 - "active_directory_account_info"
43 - "aggregate_info"
44 - "aggr_efficiency_info"
45 - "autosupport_check_info"
46 - "cifs_options_info"
47 - "cifs_server_info"
48 - "cifs_share_info"
49 - "cifs_vserver_security_info"
50 - "cluster_identity_info"
51 - "cluster_image_info"
52 - "cluster_log_forwarding_info"
53 - "cluster_node_info"
54 - "cluster_peer_info"
55 - "cluster_switch_info"
56 - "clock_info"
57 - "disk_info"
58 - "env_sensors_info"
59 - "event_notification_destination_info"
60 - "event_notification_info"
61 - "export_policy_info"
62 - "export_rule_info"
63 - "fcp_adapter_info"
64 - "fcp_alias_info"
65 - "fcp_service_info"
66 - "igroup_info"
67 - "iscsi_service_info"
68 - "job_schedule_cron_info"
69 - "kerberos_realm_info"
70 - "ldap_client"
71 - "ldap_config"
72 - "license_info"
73 - "lun_info"
74 - "lun_map_info"
75 - "metrocluster_check_info"
76 - "metrocluster_info"
77 - "metrocluster_node_info"
78 - "net_dev_discovery_info"
79 - "net_dns_info"
80 - "net_failover_group_info"
81 - "net_firewall_info"
82 - "net_ifgrp_info"
83 - "net_interface_info"
84 - "net_interface_service_policy_info"
85 - "net_ipspaces_info"
86 - "net_port_info"
87 - "net_port_broadcast_domain_info"
88 - "net_routes_info"
89 - "net_vlan_info"
90 - "nfs_info"
91 - "ntfs_dacl_info"
92 - "ntfs_sd_info"
93 - "ntp_server_info"
94 - "nvme_info"
95 - "nvme_interface_info"
96 - "nvme_namespace_info"
97 - "nvme_subsystem_info"
98 - "ontap_system_version"
99 - "ontap_version"
100 - "ontapi_version"
101 - "qos_adaptive_policy_info"
102 - "qos_policy_info"
103 - "qtree_info"
104 - "quota_policy_info"
105 - "quota_report_info"
106 - "role_info"
107 - "security_key_manager_key_info"
108 - "security_login_account_info"
109 - "security_login_role_config_info"
110 - "security_login_role_info"
111 - "service_processor_info"
112 - "service_processor_network_info"
113 - "shelf_info"
114 - "sis_info"
115 - "sis_policy_info"
116 - "snapmirror_info"
117 - "snapmirror_destination_info"
118 - "snapmirror_policy_info"
119 - "snapshot_info"
120 - "snapshot_policy_info"
121 - "storage_failover_info"
122 - "storage_bridge_info"
123 - "subsys_health_info"
124 - "sysconfig_info"
125 - "sys_cluster_alerts"
126 - "volume_info"
127 - "volume_space_info"
128 - "vscan_info"
129 - "vscan_status_info"
130 - "vscan_scanner_pool_info"
131 - "vscan_connection_status_all_info"
132 - "vscan_connection_extended_stats_info"
133 - "vserver_info"
134 - "vserver_login_banner_info"
135 - "vserver_motd_info"
136 - "vserver_nfs_info"
137 - "vserver_peer_info"
138 - Can specify a list of values to include a larger subset.
139 - Values can also be used with an initial C(!) to specify that a specific subset should not be collected.
140 - nvme is supported with ONTAP 9.4 onwards.
141 - use "help" to get a list of supported information for your system.
142 - with lun_info, serial_hex and naa_id are computed when serial_number is present.
143 default: "all"
144 max_records:
145 type: int
146 description:
147 - Maximum number of records returned in a single ZAPI call. Valid range is [1..2^32-1].
148 This parameter controls internal behavior of this module.
149 default: 1024
150 version_added: '20.2.0'
151 summary:
152 description:
153 - Boolean flag to control return all attributes of the module info or only the names.
154 - If true, only names are returned.
155 default: false
156 type: bool
157 version_added: '20.4.0'
158 volume_move_target_aggr_info:
159 description:
160 - Required options for volume_move_target_aggr_info
161 type: dict
162 version_added: '20.5.0'
163 suboptions:
164 volume_name:
165 description:
166 - Volume name to get target aggr info for
167 required: true
168 type: str
169 version_added: '20.5.0'
170 vserver:
171 description:
172 - vserver the Volume lives on
173 required: true
174 type: str
175 version_added: '20.5.0'
176 desired_attributes:
177 description:
178 - Advanced feature requiring to understand ZAPI internals.
179 - Allows to request a specific attribute that is not returned by default, or to limit the returned attributes.
180 - A dictionary for the zapi desired-attributes element.
181 - An XML tag I(<tag>value</tag>) is a dictionary with tag as the key.
182 - Value can be another dictionary, a list of dictionaries, a string, or nothing.
183 - eg I(<tag/>) is represented as I(tag:)
184 - Only a single subset can be called at a time if this option is set.
185 - It is the caller responsibity to make sure key attributes are present in the right position.
186 - The module will error out if any key attribute is missing.
187 type: dict
188 version_added: '20.6.0'
189 query:
190 description:
191 - Advanced feature requiring to understand ZAPI internals.
192 - Allows to specify which objects to return.
193 - A dictionary for the zapi query element.
194 - An XML tag I(<tag>value</tag>) is a dictionary with tag as the key.
195 - Value can be another dictionary, a list of dictionaries, a string, or nothing.
196 - eg I(<tag/>) is represented as I(tag:)
197 - Only a single subset can be called at a time if this option is set.
198 type: dict
199 version_added: '20.7.0'
200 use_native_zapi_tags:
201 description:
202 - By default, I(-) in the returned dictionary keys are translated to I(_).
203 - If set to true, the translation is disabled.
204 type: bool
205 default: false
206 version_added: '20.6.0'
207 continue_on_error:
208 description:
209 - By default, this module fails on the first error.
210 - This option allows to provide a list of errors that are not failing the module.
211 - Errors in the list are reported in the output, under the related info element, as an "error" entry.
212 - Possible values are always, never, missing_vserver_api_error, rpc_error, other_error.
213 - missing_vserver_api_error - most likely the API is available at cluster level but not vserver level.
214 - rpc_error - some queries are failing because the node cannot reach another node in the cluster.
215 - key_error - a query is failing because the returned data does not contain an expected key.
216 - for key errors, make sure to report this in Discord. It may be a change in a new ONTAP version.
217 - other_error - anything not in the above list.
218 - always will continue on any error, never will fail on any error, they cannot be used with any other keyword.
219 type: list
220 elements: str
221 default: never
222 '''
223
224 EXAMPLES = '''
225 - name: Get NetApp info as Cluster Admin (Password Authentication)
226 netapp.ontap.na_ontap_info:
227 hostname: "na-vsim"
228 username: "admin"
229 password: "admins_password"
230 register: ontap_info
231 - debug:
232 msg: "{{ ontap_info.ontap_info }}"
233
234 - name: Get NetApp version as Vserver admin
235 netapp.ontap.na_ontap_info:
236 hostname: "na-vsim"
237 username: "vsadmin"
238 vserver: trident_svm
239 password: "vsadmins_password"
240
241 - name: run ontap info module using vserver tunneling and ignoring errors
242 netapp.ontap.na_ontap_info:
243 hostname: "na-vsim"
244 username: "admin"
245 password: "admins_password"
246 vserver: trident_svm
247 summary: true
248 continue_on_error:
249 - missing_vserver_api_error
250 - rpc_error
251
252 - name: Limit Info Gathering to Aggregate Information as Cluster Admin
253 netapp.ontap.na_ontap_info:
254 hostname: "na-vsim"
255 username: "admin"
256 password: "admins_password"
257 gather_subset: "aggregate_info"
258 register: ontap_info
259
260 - name: Limit Info Gathering to Volume and Lun Information as Cluster Admin
261 netapp.ontap.na_ontap_info:
262 hostname: "na-vsim"
263 username: "admin"
264 password: "admins_password"
265 gather_subset:
266 - volume_info
267 - lun_info
268 register: ontap_info
269
270 - name: Gather all info except for volume and lun information as Cluster Admin
271 netapp.ontap.na_ontap_info:
272 hostname: "na-vsim"
273 username: "admin"
274 password: "admins_password"
275 gather_subset:
276 - "!volume_info"
277 - "!lun_info"
278 register: ontap_info
279
280 - name: Gather Volume move information for a specific volume
281 netapp.ontap.na_ontap_info:
282 hostname: "na-vsim"
283 username: "admin"
284 password: "admins_password"
285 gather_subset: volume_move_target_aggr_info
286 volume_move_target_aggr_info:
287 volume_name: carchitest
288 vserver: ansible
289
290 - name: run ontap info module for aggregate module, requesting specific fields
291 netapp.ontap.na_ontap_info:
292 # <<: *login
293 gather_subset: aggregate_info
294 desired_attributes:
295 aggr-attributes:
296 aggr-inode-attributes:
297 files-private-used:
298 aggr-raid-attributes:
299 aggregate-type:
300 use_native_zapi_tags: true
301 register: ontap
302 - debug: var=ontap
303
304 - name: run ontap info to get offline volumes with dp in the name
305 netapp.ontap.na_ontap_info:
306 # <<: *cert_login
307 gather_subset: volume_info
308 query:
309 volume-attributes:
310 volume-id-attributes:
311 name: '*dp*'
312 volume-state-attributes:
313 state: offline
314 desired_attributes:
315 volume-attributes:
316 volume-id-attributes:
317 name:
318 volume-state-attributes:
319 state:
320 register: ontap
321 - debug: var=ontap
322 '''
323
324 RETURN = '''
325 ontap_info:
326 description: Returns various information about NetApp cluster configuration
327 returned: always
328 type: dict
329 sample: '{
330 "ontap_info": {
331 "active_directory_account_info": {...},
332 "aggregate_info": {...},
333 "autosupport_check_info": {...},
334 "cluster_identity_info": {...},
335 "cluster_image_info": {...},
336 "cluster_node_info": {...},
337 "igroup_info": {...},
338 "iscsi_service_info": {...},
339 "license_info": {...},
340 "lun_info": {...},
341 "metrocluster_check_info": {...},
342 "metrocluster_info": {...},
343 "metrocluster_node_info": {...},
344 "net_dns_info": {...},
345 "net_ifgrp_info": {...},
346 "net_interface_info": {...},
347 "net_interface_service_policy_info": {...},
348 "net_port_info": {...},
349 "ontap_system_version": {...},
350 "ontap_version": {...},
351 "ontapi_version": {...},
352 "qos_policy_info": {...},
353 "qos_adaptive_policy_info": {...},
354 "qtree_info": {...},
355 "quota_policy_info": {..},
356 "quota_report_info": {...},
357 "security_key_manager_key_info": {...},
358 "security_login_account_info": {...},
359 "snapmirror_info": {...}
360 "snapmirror_destination_info": {...}
361 "storage_bridge_info": {...}
362 "storage_failover_info": {...},
363 "volume_info": {...},
364 "vserver_login_banner_info": {...},
365 "vserver_motd_info": {...},
366 "vserver_info": {...},
367 "vserver_nfs_info": {...},
368 "vscan_status_info": {...},
369 "vscan_scanner_pool_info": {...},
370 "vscan_connection_status_all_info": {...},
371 "vscan_connection_extended_stats_info": {...}
372 }'
373 '''
374
375 import codecs
376 import copy
377 import traceback
378 from ansible.module_utils.basic import AnsibleModule
379 from ansible.module_utils._text import to_bytes, to_native, to_text
380 import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils
381
382 IMPORT_ERRORS = []
383 try:
384 import xmltodict
385 HAS_XMLTODICT = True
386 except ImportError as exc:
387 HAS_XMLTODICT = False
388 IMPORT_ERRORS.append(str(exc))
389
390 try:
391 import json
392 HAS_JSON = True
393 except ImportError as exc:
394 HAS_JSON = False
395 IMPORT_ERRORS.append(str(exc))
396
397 HAS_NETAPP_LIB = netapp_utils.has_netapp_lib()
398
399
400 class NetAppONTAPGatherInfo:
401 '''Class with gather info methods'''
402
403 def __init__(self):
404 ''' create module, set up context'''
405 argument_spec = netapp_utils.na_ontap_zapi_only_spec()
406 argument_spec.update(dict(
407 state=dict(type='str'),
408 gather_subset=dict(default=['all'], type='list', elements='str'),
409 vserver=dict(type='str', required=False),
410 max_records=dict(type='int', default=1024, required=False),
411 summary=dict(type='bool', default=False, required=False),
412 volume_move_target_aggr_info=dict(
413 type="dict",
414 required=False,
415 options=dict(
416 volume_name=dict(type='str', required=True),
417 vserver=dict(type='str', required=True)
418 )
419 ),
420 desired_attributes=dict(type='dict', required=False),
421 use_native_zapi_tags=dict(type='bool', required=False, default=False),
422 continue_on_error=dict(type='list', required=False, elements='str', default=['never']),
423 query=dict(type='dict', required=False),
424 ))
425
426 self.module = AnsibleModule(
427 argument_spec=argument_spec,
428 supports_check_mode=True
429 )
430
431 if not HAS_NETAPP_LIB:
432 self.module.fail_json(msg=netapp_utils.netapp_lib_is_required())
433 if not HAS_XMLTODICT:
434 self.module.fail_json(msg="the python xmltodict module is required. Import error: %s" % str(IMPORT_ERRORS))
435 if not HAS_JSON:
436 self.module.fail_json(msg="the python json module is required. Import error: %s" % str(IMPORT_ERRORS))
437
438 self.max_records = str(self.module.params['max_records'])
439 volume_move_target_aggr_info = self.module.params.get('volume_move_target_aggr_info', dict())
440 if volume_move_target_aggr_info is None:
441 volume_move_target_aggr_info = {}
442 self.netapp_info = {}
443 self.desired_attributes = self.module.params['desired_attributes']
444 self.query = self.module.params['query']
445 self.translate_keys = not self.module.params['use_native_zapi_tags']
446 self.warnings = [] # warnings will be added to the info results, if any
447 self.set_error_flags()
448 self.module.warn('The module only supports ZAPI; refer to netapp.ontap.na_ontap_rest_info module for RESTful equivalent.')
449
450 # thanks to coreywan (https://github.com/ansible/ansible/pull/47016)
451 # for starting this
452 # min_version identifies the ontapi version which supports this ZAPI
453 # use 0 if it is supported since 9.1
454 self.info_subsets = {
455 'cluster_identity_info': {
456 'method': self.get_generic_get_iter,
457 'kwargs': {
458 'call': 'cluster-identity-get',
459 'attributes_list_tag': 'attributes',
460 'attribute': 'cluster-identity-info',
461 'key_fields': 'cluster-name',
462 },
463 'min_version': '0',
464 },
465 'cluster_image_info': {
466 'method': self.get_generic_get_iter,
467 'kwargs': {
468 'call': 'cluster-image-get-iter',
469 'attribute': 'cluster-image-info',
470 'key_fields': 'node-id',
471 'query': {'max-records': self.max_records},
472 },
473 'min_version': '0',
474 },
475 'cluster_log_forwarding_info': {
476 'method': self.get_generic_get_iter,
477 'kwargs': {
478 'call': 'cluster-log-forward-get-iter',
479 'attribute': 'cluster-log-forward-info',
480 'key_fields': ('destination', 'port'),
481 'query': {'max-records': self.max_records},
482 },
483 'min_version': '0',
484 },
485 'cluster_node_info': {
486 'method': self.get_generic_get_iter,
487 'kwargs': {
488 'call': 'cluster-node-get-iter',
489 'attribute': 'cluster-node-info',
490 'key_fields': 'node-name',
491 'query': {'max-records': self.max_records},
492 },
493 'min_version': '0',
494 },
495 'security_login_account_info': {
496 'method': self.get_generic_get_iter,
497 'kwargs': {
498 'call': 'security-login-get-iter',
499 'attribute': 'security-login-account-info',
500 'key_fields': ('vserver', 'user-name', 'application', 'authentication-method'),
501 'query': {'max-records': self.max_records},
502 },
503 'min_version': '0',
504 },
505 'security_login_role_config_info': {
506 'method': self.get_generic_get_iter,
507 'kwargs': {
508 'call': 'security-login-role-config-get-iter',
509 'attribute': 'security-login-role-config-info',
510 'key_fields': ('vserver', 'role-name'),
511 'query': {'max-records': self.max_records},
512 },
513 'min_version': '0',
514 },
515 'security_login_role_info': {
516 'method': self.get_generic_get_iter,
517 'kwargs': {
518 'call': 'security-login-role-get-iter',
519 'attribute': 'security-login-role-info',
520 'key_fields': ('vserver', 'role-name', 'command-directory-name'),
521 'query': {'max-records': self.max_records},
522 },
523 'min_version': '0',
524 },
525 'active_directory_account_info': {
526 'method': self.get_generic_get_iter,
527 'kwargs': {
528 'call': 'active-directory-account-get-iter',
529 'attribute': 'active-directory-account-config',
530 'key_fields': ('vserver', 'account-name'),
531 'query': {'max-records': self.max_records},
532 },
533 'min_version': '0',
534 },
535 'aggregate_info': {
536 'method': self.get_generic_get_iter,
537 'kwargs': {
538 'call': 'aggr-get-iter',
539 'attribute': 'aggr-attributes',
540 'key_fields': 'aggregate-name',
541 'query': {'max-records': self.max_records},
542 },
543 'min_version': '0',
544 },
545 'volume_info': {
546 'method': self.get_generic_get_iter,
547 'kwargs': {
548 'call': 'volume-get-iter',
549 'attribute': 'volume-attributes',
550 'key_fields': ('name', 'owning-vserver-name'),
551 'query': {'max-records': self.max_records},
552 },
553 'min_version': '0',
554 },
555 'license_info': {
556 'method': self.get_generic_get_iter,
557 'kwargs': {
558 'call': 'license-v2-list-info',
559 'attributes_list_tag': None,
560 'attribute': 'licenses',
561 },
562 'min_version': '0',
563 },
564 'lun_info': {
565 'method': self.get_generic_get_iter,
566 'kwargs': {
567 'call': 'lun-get-iter',
568 'attribute': 'lun-info',
569 'key_fields': ('vserver', 'path'),
570 'query': {'max-records': self.max_records},
571 },
572 'min_version': '0',
573 },
574 'metrocluster_check_info': {
575 'method': self.get_generic_get_iter,
576 'kwargs': {
577 'call': 'metrocluster-check-get-iter',
578 'attribute': 'metrocluster-check-info',
579 'fail_on_error': False,
580 },
581 'min_version': '0',
582 },
583 'metrocluster_info': {
584 'method': self.get_generic_get_iter,
585 'kwargs': {
586 'call': 'metrocluster-get',
587 'attribute': 'metrocluster-info',
588 'attributes_list_tag': 'attributes',
589 },
590 'min_version': '0',
591 },
592 'metrocluster_node_info': {
593 'method': self.get_generic_get_iter,
594 'kwargs': {
595 'call': 'metrocluster-node-get-iter',
596 'attribute': 'metrocluster-node-info',
597 'key_fields': ('cluster-name', 'node-name'),
598 },
599 'min_version': '0',
600 },
601 'net_dns_info': {
602 'method': self.get_generic_get_iter,
603 'kwargs': {
604 'call': 'net-dns-get-iter',
605 'attribute': 'net-dns-info',
606 'key_fields': 'vserver-name',
607 'query': {'max-records': self.max_records},
608 },
609 'min_version': '0',
610 },
611 'net_interface_info': {
612 'method': self.get_generic_get_iter,
613 'kwargs': {
614 'call': 'net-interface-get-iter',
615 'attribute': 'net-interface-info',
616 'key_fields': ('interface-name', 'vserver'),
617 'query': {'max-records': self.max_records},
618 },
619 'min_version': '0',
620 },
621 'net_interface_service_policy_info': {
622 'method': self.get_generic_get_iter,
623 'kwargs': {
624 'call': 'net-interface-service-policy-get-iter',
625 'attribute': 'net-interface-service-policy-info',
626 'key_fields': ('vserver', 'policy'),
627 'query': {'max-records': self.max_records},
628 },
629 'min_version': '150',
630 },
631 'net_port_info': {
632 'method': self.get_generic_get_iter,
633 'kwargs': {
634 'call': 'net-port-get-iter',
635 'attribute': 'net-port-info',
636 'key_fields': ('node', 'port'),
637 'query': {'max-records': self.max_records},
638 },
639 'min_version': '0',
640 },
641 'security_key_manager_key_info': {
642 'method': self.get_generic_get_iter,
643 'kwargs': {
644 'call': 'security-key-manager-key-get-iter',
645 'attribute': 'security-key-manager-key-info',
646 'key_fields': ('node', 'key-id'),
647 'query': {'max-records': self.max_records},
648 },
649 'min_version': '0',
650 },
651 'storage_failover_info': {
652 'method': self.get_generic_get_iter,
653 'kwargs': {
654 'call': 'cf-get-iter',
655 'attribute': 'storage-failover-info',
656 'key_fields': 'node',
657 'query': {'max-records': self.max_records},
658 },
659 'min_version': '0',
660 },
661 'vserver_motd_info': {
662 'method': self.get_generic_get_iter,
663 'kwargs': {
664 'call': 'vserver-motd-get-iter',
665 'attribute': 'vserver-motd-info',
666 'key_fields': 'vserver',
667 'query': {'max-records': self.max_records},
668 },
669 'min_version': '0',
670 },
671 'vserver_login_banner_info': {
672 'method': self.get_generic_get_iter,
673 'kwargs': {
674 'call': 'vserver-login-banner-get-iter',
675 'attribute': 'vserver-login-banner-info',
676 'key_fields': 'vserver',
677 'query': {'max-records': self.max_records},
678 },
679 'min_version': '0',
680 },
681 'vserver_info': {
682 'method': self.get_generic_get_iter,
683 'kwargs': {
684 'call': 'vserver-get-iter',
685 'attribute': 'vserver-info',
686 'key_fields': 'vserver-name',
687 'query': {'max-records': self.max_records},
688 },
689 'min_version': '0',
690 },
691 'vserver_nfs_info': {
692 'method': self.get_generic_get_iter,
693 'kwargs': {
694 'call': 'nfs-service-get-iter',
695 'attribute': 'nfs-info',
696 'key_fields': 'vserver',
697 'query': {'max-records': self.max_records},
698 },
699 'min_version': '0',
700 },
701 'net_ifgrp_info': {
702 'method': self.get_ifgrp_info,
703 'kwargs': {},
704 'min_version': '0',
705 },
706 'ontap_system_version': {
707 'method': self.get_generic_get_iter,
708 'kwargs': {
709 'call': 'system-get-version',
710 'attributes_list_tag': None,
711 },
712 'min_version': '0',
713 },
714 'ontap_version': {
715 'method': self.ontapi,
716 'kwargs': {},
717 'min_version': '0',
718 },
719 'ontapi_version': {
720 'method': self.ontapi,
721 'kwargs': {},
722 'min_version': '0',
723 },
724 'clock_info': {
725 'method': self.get_generic_get_iter,
726 'kwargs': {
727 'call': 'clock-get-clock',
728 'attributes_list_tag': None,
729 },
730 'min_version': '0'
731 },
732 'system_node_info': {
733 'method': self.get_generic_get_iter,
734 'kwargs': {
735 'call': 'system-node-get-iter',
736 'attribute': 'node-details-info',
737 'key_fields': 'node',
738 'query': {'max-records': self.max_records},
739 },
740 'min_version': '0',
741 },
742 'igroup_info': {
743 'method': self.get_generic_get_iter,
744 'kwargs': {
745 'call': 'igroup-get-iter',
746 'attribute': 'initiator-group-info',
747 'key_fields': ('vserver', 'initiator-group-name'),
748 'query': {'max-records': self.max_records},
749 },
750 'min_version': '0',
751 },
752 'iscsi_service_info': {
753 'method': self.get_generic_get_iter,
754 'kwargs': {
755 'call': 'iscsi-service-get-iter',
756 'attribute': 'iscsi-service-info',
757 'key_fields': 'vserver',
758 'query': {'max-records': self.max_records},
759 },
760 'min_version': '0',
761 },
762 'qos_policy_info': {
763 'method': self.get_generic_get_iter,
764 'kwargs': {
765 'call': 'qos-policy-group-get-iter',
766 'attribute': 'qos-policy-group-info',
767 'key_fields': 'policy-group',
768 'query': {'max-records': self.max_records},
769 },
770 'min_version': '0',
771 },
772 'qtree_info': {
773 'method': self.get_generic_get_iter,
774 'kwargs': {
775 'call': 'qtree-list-iter',
776 'attribute': 'qtree-info',
777 'key_fields': ('vserver', 'volume', 'id'),
778 'query': {'max-records': self.max_records},
779 },
780 'min_version': '0',
781 },
782 'quota_policy_info': {
783 'method': self.get_generic_get_iter,
784 'kwargs': {
785 'call': 'quota-policy-get-iter',
786 'attribute': 'quota-policy-info',
787 'key_fields': ('vserver', 'policy-name'),
788 'query': {'max-records': self.max_records},
789 },
790 'min_version': '0',
791 },
792 'quota_report_info': {
793 'method': self.get_generic_get_iter,
794 'kwargs': {
795 'call': 'quota-report-iter',
796 'attribute': 'quota',
797 'key_fields': ('vserver', 'volume', 'tree', 'quota-type', 'quota-target'),
798 'query': {'max-records': self.max_records},
799 },
800 'min_version': '0',
801 },
802 'vscan_status_info': {
803 'method': self.get_generic_get_iter,
804 'kwargs': {
805 'call': 'vscan-status-get-iter',
806 'attribute': 'vscan-status-info',
807 'key_fields': 'vserver',
808 'query': {'max-records': self.max_records},
809 },
810 'min_version': '0',
811 },
812 'vscan_scanner_pool_info': {
813 'method': self.get_generic_get_iter,
814 'kwargs': {
815 'call': 'vscan-scanner-pool-get-iter',
816 'attribute': 'vscan-scanner-pool-info',
817 'key_fields': 'vserver',
818 'query': {'max-records': self.max_records},
819 },
820 'min_version': '0',
821 },
822 'vscan_connection_status_all_info': {
823 'method': self.get_generic_get_iter,
824 'kwargs': {
825 'call': 'vscan-connection-status-all-get-iter',
826 'attribute': 'vscan-connection-status-all-info',
827 'key_fields': 'vserver',
828 'query': {'max-records': self.max_records},
829 },
830 'min_version': '0',
831 },
832 'vscan_connection_extended_stats_info': {
833 'method': self.get_generic_get_iter,
834 'kwargs': {
835 'call': 'vscan-connection-extended-stats-get-iter',
836 'attribute': 'vscan-connection-extended-stats-info',
837 'key_fields': 'vserver',
838 'query': {'max-records': self.max_records},
839 },
840 'min_version': '0',
841 },
842 'snapshot_info': {
843 'method': self.get_generic_get_iter,
844 'kwargs': {
845 'call': 'snapshot-get-iter',
846 'attribute': 'snapshot-info',
847 'key_fields': ('vserver', 'volume', 'name'),
848 'query': {'max-records': self.max_records},
849 },
850 'min_version': '0',
851 },
852 'storage_bridge_info': {
853 'method': self.get_generic_get_iter,
854 'kwargs': {
855 'call': 'storage-bridge-get-iter',
856 'attribute': 'storage-bridge-info',
857 'key_fields': 'name',
858 'query': {'max-records': self.max_records},
859 },
860 'min_version': '0',
861 },
862 # supported in ONTAP 9.3 and onwards
863 'qos_adaptive_policy_info': {
864 'method': self.get_generic_get_iter,
865 'kwargs': {
866 'call': 'qos-adaptive-policy-group-get-iter',
867 'attribute': 'qos-adaptive-policy-group-info',
868 'key_fields': 'policy-group',
869 'query': {'max-records': self.max_records},
870 },
871 'min_version': '130',
872 },
873 # supported in ONTAP 9.4 and onwards
874 'nvme_info': {
875 'method': self.get_generic_get_iter,
876 'kwargs': {
877 'call': 'nvme-get-iter',
878 'attribute': 'nvme-target-service-info',
879 'key_fields': 'vserver',
880 'query': {'max-records': self.max_records},
881 },
882 'min_version': '140',
883 },
884 'nvme_interface_info': {
885 'method': self.get_generic_get_iter,
886 'kwargs': {
887 'call': 'nvme-interface-get-iter',
888 'attribute': 'nvme-interface-info',
889 'key_fields': 'vserver',
890 'query': {'max-records': self.max_records},
891 },
892 'min_version': '140',
893 },
894 'nvme_subsystem_info': {
895 'method': self.get_generic_get_iter,
896 'kwargs': {
897 'call': 'nvme-subsystem-get-iter',
898 'attribute': 'nvme-subsystem-info',
899 'key_fields': 'subsystem',
900 'query': {'max-records': self.max_records},
901 },
902 'min_version': '140',
903 },
904 'nvme_namespace_info': {
905 'method': self.get_generic_get_iter,
906 'kwargs': {
907 'call': 'nvme-namespace-get-iter',
908 'attribute': 'nvme-namespace-info',
909 'key_fields': 'path',
910 'query': {'max-records': self.max_records},
911 },
912 'min_version': '140',
913 },
914
915 # Alpha Order
916
917 'aggr_efficiency_info': {
918 'method': self.get_generic_get_iter,
919 'kwargs': {
920 'call': 'aggr-efficiency-get-iter',
921 'attribute': 'aggr-efficiency-info',
922 # the preferred key is node_name:aggregate_name
923 # but node is not present with MCC
924 'key_fields': (('node', None), 'aggregate'),
925 'query': {'max-records': self.max_records},
926 },
927 'min_version': '140',
928 },
929 'autosupport_check_info': {
930 'method': self.get_generic_get_iter,
931 'kwargs': {
932 'call': 'autosupport-check-iter',
933 'attribute': 'autosupport-check-info',
934 'key_fields': ('node-name', 'check-type', 'error-detail'),
935 'query': {'max-records': self.max_records},
936 },
937 'min_version': '0',
938 },
939 'cifs_options_info': {
940 'method': self.get_generic_get_iter,
941 'kwargs': {
942 'call': 'cifs-options-get-iter',
943 'attribute': 'cifs-options',
944 'key_fields': ('vserver'),
945 'query': {'max-records': self.max_records},
946 },
947 'min_version': '0',
948 },
949 'cifs_server_info': {
950 'method': self.get_generic_get_iter,
951 'kwargs': {
952 'call': 'cifs-server-get-iter',
953 'attribute': 'cifs-server-config',
954 # preferred key is <vserver>:<domain>:<cifs-server>
955 # alternate key is <vserver>:<domain-workgroup>:<cifs-server>
956 'key_fields': ('vserver', ('domain', 'domain-workgroup'), 'cifs-server'),
957 'query': {'max-records': self.max_records},
958 },
959 'min_version': '0',
960 },
961 'cifs_share_info': {
962 'method': self.get_generic_get_iter,
963 'kwargs': {
964 'call': 'cifs-share-get-iter',
965 'attribute': 'cifs-share',
966 'key_fields': ('share-name', 'path', 'cifs-server'),
967 'query': {'max-records': self.max_records},
968 },
969 'min_version': '0',
970 },
971 'cifs_vserver_security_info': {
972 'method': self.get_generic_get_iter,
973 'kwargs': {
974 'call': 'cifs-security-get-iter',
975 'attribute': 'cifs-security',
976 'key_fields': ('vserver'),
977 'query': {'max-records': self.max_records},
978 },
979 'min_version': '0',
980 },
981 'cluster_peer_info': {
982 'method': self.get_generic_get_iter,
983 'kwargs': {
984 'call': 'cluster-peer-get-iter',
985 'attribute': 'cluster-peer-info',
986 'key_fields': ('cluster-name', 'remote-cluster-name'),
987 'query': {'max-records': self.max_records},
988 },
989 'min_version': '0',
990 },
991 'cluster_switch_info': {
992 'method': self.get_generic_get_iter,
993 'kwargs': {
994 'call': 'cluster-switch-get-iter',
995 'attribute': 'cluster-switch-info',
996 'key_fields': ('device', 'model', 'serial-number'),
997 'query': {'max-records': self.max_records},
998 },
999 'min_version': '160',
1000 },
1001 'disk_info': {
1002 'method': self.get_generic_get_iter,
1003 'kwargs': {
1004 'call': 'storage-disk-get-iter',
1005 'attribute': 'storage-disk-info',
1006 'key_fields': ('disk-name'),
1007 'query': {'max-records': self.max_records},
1008 },
1009 'min_version': '0',
1010 },
1011 'env_sensors_info': {
1012 'method': self.get_generic_get_iter,
1013 'kwargs': {
1014 'call': 'environment-sensors-get-iter',
1015 'attribute': 'environment-sensors-info',
1016 'key_fields': ('node-name', 'sensor-name'),
1017 'query': {'max-records': self.max_records},
1018 'fail_on_error': False,
1019 },
1020 'min_version': '0',
1021 },
1022 'event_notification_destination_info': {
1023 'method': self.get_generic_get_iter,
1024 'kwargs': {
1025 'call': 'ems-event-notification-destination-get-iter',
1026 'attribute': 'event-notification-destination-info',
1027 'key_fields': ('name', 'type'),
1028 'query': {'max-records': self.max_records},
1029 },
1030 'min_version': '0',
1031 },
1032 'event_notification_info': {
1033 'method': self.get_generic_get_iter,
1034 'kwargs': {
1035 'call': 'ems-event-notification-get-iter',
1036 'attribute': 'event-notification',
1037 'key_fields': ('id'),
1038 'query': {'max-records': self.max_records},
1039 },
1040 'min_version': '0',
1041 },
1042 'export_policy_info': {
1043 'method': self.get_generic_get_iter,
1044 'kwargs': {
1045 'call': 'export-policy-get-iter',
1046 'attribute': 'export-policy-info',
1047 'key_fields': ('vserver', 'policy-name'),
1048 'query': {'max-records': self.max_records},
1049 },
1050 'min_version': '0',
1051 },
1052 'export_rule_info': {
1053 'method': self.get_generic_get_iter,
1054 'kwargs': {
1055 'call': 'export-rule-get-iter',
1056 'attribute': 'export-rule-info',
1057 'key_fields': ('vserver-name', 'policy-name', 'rule-index'),
1058 'query': {'max-records': self.max_records},
1059 },
1060 'min_version': '0',
1061 },
1062 'fcp_adapter_info': {
1063 'method': self.get_generic_get_iter,
1064 'kwargs': {
1065 'call': 'ucm-adapter-get-iter',
1066 'attribute': 'uc-adapter-info',
1067 'key_fields': ('adapter-name', 'node-name'),
1068 'query': {'max-records': self.max_records},
1069 },
1070 'min_version': '0',
1071 },
1072 'fcp_alias_info': {
1073 'method': self.get_generic_get_iter,
1074 'kwargs': {
1075 'call': 'fcp-wwpnalias-get-iter',
1076 'attribute': 'aliases-info',
1077 'key_fields': ('aliases-alias', 'vserver'),
1078 'query': {'max-records': self.max_records},
1079 },
1080 'min_version': '0',
1081 },
1082 'fcp_service_info': {
1083 'method': self.get_generic_get_iter,
1084 'kwargs': {
1085 'call': 'fcp-service-get-iter',
1086 'attribute': 'fcp-service-info',
1087 'key_fields': ('vserver'),
1088 'query': {'max-records': self.max_records},
1089 },
1090 'min_version': '0',
1091 },
1092 'job_schedule_cron_info': {
1093 'method': self.get_generic_get_iter,
1094 'kwargs': {
1095 'call': 'job-schedule-cron-get-iter',
1096 'attribute': 'job-schedule-cron-info',
1097 'key_fields': ('job-schedule-name', ('job-schedule-cluster', None)),
1098 'query': {'max-records': self.max_records},
1099 },
1100 'min_version': '0',
1101 },
1102 'kerberos_realm_info': {
1103 'method': self.get_generic_get_iter,
1104 'kwargs': {
1105 'call': 'kerberos-realm-get-iter',
1106 'attribute': 'kerberos-realm',
1107 'key_fields': ('vserver-name', 'realm'),
1108 'query': {'max-records': self.max_records},
1109 },
1110 'min_version': '0',
1111 },
1112 'ldap_client': {
1113 'method': self.get_generic_get_iter,
1114 'kwargs': {
1115 'call': 'ldap-client-get-iter',
1116 'attribute': 'ldap-client',
1117 'key_fields': ('vserver'),
1118 'query': {'max-records': self.max_records},
1119 },
1120 'min_version': '0',
1121 },
1122 'ldap_config': {
1123 'method': self.get_generic_get_iter,
1124 'kwargs': {
1125 'call': 'ldap-config-get-iter',
1126 'attribute': 'ldap-config',
1127 'key_fields': ('vserver'),
1128 'query': {'max-records': self.max_records},
1129 },
1130 'min_version': '0',
1131 },
1132 'lun_map_info': {
1133 'method': self.get_generic_get_iter,
1134 'kwargs': {
1135 'call': 'lun-map-get-iter',
1136 'attribute': 'lun-map-info',
1137 'key_fields': ('initiator-group', 'lun-id', 'node', 'path', 'vserver'),
1138 'query': {'max-records': self.max_records},
1139 },
1140 'min_version': '0',
1141 },
1142 'net_dev_discovery_info': {
1143 'method': self.get_generic_get_iter,
1144 'kwargs': {
1145 'call': 'net-device-discovery-get-iter',
1146 'attribute': 'net-device-discovery-info',
1147 'key_fields': ('port'),
1148 'query': {'max-records': self.max_records},
1149 },
1150 'min_version': '0',
1151 },
1152 'net_failover_group_info': {
1153 'method': self.get_generic_get_iter,
1154 'kwargs': {
1155 'call': 'net-failover-group-get-iter',
1156 'attribute': 'net-failover-group-info',
1157 'key_fields': ('vserver', 'failover-group'),
1158 'query': {'max-records': self.max_records},
1159 },
1160 'min_version': '0',
1161 },
1162 'net_firewall_info': {
1163 'method': self.get_generic_get_iter,
1164 'kwargs': {
1165 'call': 'net-firewall-policy-get-iter',
1166 'attribute': 'net-firewall-policy-info',
1167 'key_fields': ('policy', 'vserver', 'service'),
1168 'query': {'max-records': self.max_records},
1169 },
1170 'min_version': '0',
1171 },
1172 'net_ipspaces_info': {
1173 'method': self.get_generic_get_iter,
1174 'kwargs': {
1175 'call': 'net-ipspaces-get-iter',
1176 'attribute': 'net-ipspaces-info',
1177 'key_fields': ('ipspace'),
1178 'query': {'max-records': self.max_records},
1179 },
1180 'min_version': '0',
1181 },
1182 'net_port_broadcast_domain_info': {
1183 'method': self.get_generic_get_iter,
1184 'kwargs': {
1185 'call': 'net-port-broadcast-domain-get-iter',
1186 'attribute': 'net-port-broadcast-domain-info',
1187 'key_fields': ('broadcast-domain', 'ipspace'),
1188 'query': {'max-records': self.max_records},
1189 },
1190 'min_version': '0',
1191 },
1192 'net_routes_info': {
1193 'method': self.get_generic_get_iter,
1194 'kwargs': {
1195 'call': 'net-routes-get-iter',
1196 'attribute': 'net-vs-routes-info',
1197 'key_fields': ('vserver', 'destination', 'gateway'),
1198 'query': {'max-records': self.max_records},
1199 },
1200 'min_version': '0',
1201 },
1202 'net_vlan_info': {
1203 'method': self.get_generic_get_iter,
1204 'kwargs': {
1205 'call': 'net-vlan-get-iter',
1206 'attribute': 'vlan-info',
1207 'key_fields': ('interface-name', 'node'),
1208 'query': {'max-records': self.max_records},
1209 },
1210 'min_version': '0',
1211 },
1212 'nfs_info': {
1213 'method': self.get_generic_get_iter,
1214 'kwargs': {
1215 'call': 'nfs-service-get-iter',
1216 'attribute': 'nfs-info',
1217 'key_fields': ('vserver'),
1218 'query': {'max-records': self.max_records},
1219 },
1220 'min_version': '0',
1221 },
1222 'ntfs_dacl_info': {
1223 'method': self.get_generic_get_iter,
1224 'kwargs': {
1225 'call': 'file-directory-security-ntfs-dacl-get-iter',
1226 'attribute': 'file-directory-security-ntfs-dacl',
1227 'key_fields': ('vserver', 'ntfs-sd', 'account', 'access-type'),
1228 'query': {'max-records': self.max_records},
1229 },
1230 'min_version': '0',
1231 },
1232 'ntfs_sd_info': {
1233 'method': self.get_generic_get_iter,
1234 'kwargs': {
1235 'call': 'file-directory-security-ntfs-get-iter',
1236 'attribute': 'file-directory-security-ntfs',
1237 'key_fields': ('vserver', 'ntfs-sd'),
1238 'query': {'max-records': self.max_records},
1239 },
1240 'min_version': '0',
1241 },
1242 'ntp_server_info': {
1243 'method': self.get_generic_get_iter,
1244 'kwargs': {
1245 'call': 'ntp-server-get-iter',
1246 'attribute': 'ntp-server-info',
1247 'key_fields': ('server-name'),
1248 'query': {'max-records': self.max_records},
1249 },
1250 'min_version': '0',
1251 },
1252 'role_info': {
1253 'method': self.get_generic_get_iter,
1254 'kwargs': {
1255 'call': 'security-login-role-get-iter',
1256 'attribute': 'security-login-role-info',
1257 'key_fields': ('vserver', 'role-name', 'access-level', 'command-directory-name'),
1258 'query': {'max-records': self.max_records},
1259 },
1260 'min_version': '0',
1261 },
1262 'service_processor_info': {
1263 'method': self.get_generic_get_iter,
1264 'kwargs': {
1265 'call': 'service-processor-get-iter',
1266 'attribute': 'service-processor-info',
1267 'key_fields': ('node'),
1268 'query': {'max-records': self.max_records},
1269 },
1270 'min_version': '0',
1271 },
1272 'service_processor_network_info': {
1273 'method': self.get_generic_get_iter,
1274 'kwargs': {
1275 'call': 'service-processor-network-get-iter',
1276 'attribute': 'service-processor-network-info',
1277 # don't use key_fieldss, as we cannot build a key with optional key_fieldss
1278 # without a key, we'll get a list of dictionaries
1279 'query': {'max-records': self.max_records},
1280 },
1281 'min_version': '0',
1282 },
1283 'shelf_info': {
1284 'method': self.get_generic_get_iter,
1285 'kwargs': {
1286 'call': 'storage-shelf-info-get-iter',
1287 'attribute': 'storage-shelf-info',
1288 'key_fields': ('shelf-id', 'serial-number'),
1289 'query': {'max-records': self.max_records},
1290 },
1291 'min_version': '0',
1292 },
1293 'sis_info': {
1294 'method': self.get_generic_get_iter,
1295 'kwargs': {
1296 'call': 'sis-get-iter',
1297 'attribute': 'sis-status-info',
1298 'key_fields': 'path',
1299 'query': {'max-records': self.max_records},
1300 },
1301 'min_version': '0',
1302 },
1303 'sis_policy_info': {
1304 'method': self.get_generic_get_iter,
1305 'kwargs': {
1306 'call': 'sis-policy-get-iter',
1307 'attribute': 'sis-policy-info',
1308 'key_fields': ('vserver', 'policy-name'),
1309 'query': {'max-records': self.max_records},
1310 },
1311 'min_version': '0',
1312 },
1313 'snapmirror_info': {
1314 'method': self.get_generic_get_iter,
1315 'kwargs': {
1316 'call': 'snapmirror-get-iter',
1317 'attribute': 'snapmirror-info',
1318 'key_fields': 'destination-location',
1319 'query': {'max-records': self.max_records},
1320 },
1321 'min_version': '140',
1322 },
1323 'snapmirror_destination_info': {
1324 'method': self.get_generic_get_iter,
1325 'kwargs': {
1326 'call': 'snapmirror-get-destination-iter',
1327 'attribute': 'snapmirror-destination-info',
1328 'key_fields': 'destination-location',
1329 'query': {'max-records': self.max_records},
1330 },
1331 'min_version': '140',
1332 },
1333 'snapmirror_policy_info': {
1334 'method': self.get_generic_get_iter,
1335 'kwargs': {
1336 'call': 'snapmirror-policy-get-iter',
1337 'attribute': 'snapmirror-policy-info',
1338 'key_fields': ('vserver-name', 'policy-name'),
1339 'query': {'max-records': self.max_records},
1340 },
1341 'min_version': '0',
1342 },
1343 'snapshot_policy_info': {
1344 'method': self.get_generic_get_iter,
1345 'kwargs': {
1346 'call': 'snapshot-policy-get-iter',
1347 'attribute': 'snapshot-policy-info',
1348 'key_fields': ('vserver-name', 'policy'),
1349 'query': {'max-records': self.max_records},
1350 },
1351 'min_version': '0',
1352 },
1353 'subsys_health_info': {
1354 'method': self.get_generic_get_iter,
1355 'kwargs': {
1356 'call': 'diagnosis-subsystem-config-get-iter',
1357 'attribute': 'diagnosis-subsystem-config-info',
1358 'key_fields': 'subsystem',
1359 'query': {'max-records': self.max_records},
1360 },
1361 'min_version': '0',
1362 },
1363 'sys_cluster_alerts': {
1364 'method': self.get_generic_get_iter,
1365 'kwargs': {
1366 'call': 'diagnosis-alert-get-iter',
1367 'attribute': 'diagnosis-alert-info',
1368 'key_fields': ('node', 'alerting-resource'),
1369 'query': {'max-records': self.max_records},
1370 },
1371 'min_version': '0',
1372 },
1373 'sysconfig_info': {
1374 'method': self.get_generic_get_iter,
1375 'kwargs': {
1376 'call': 'system-get-node-info-iter',
1377 'attribute': 'system-info',
1378 'key_fields': ('system-name'),
1379 'query': {'max-records': self.max_records},
1380 },
1381 'min_version': '0',
1382 },
1383 'volume_move_target_aggr_info': {
1384 'method': self.get_generic_get_iter,
1385 'kwargs': {
1386 'call': 'volume-move-target-aggr-get-iter',
1387 'attribute': 'volume-move-target-aggr-info',
1388 'query': {'max-records': self.max_records,
1389 'volume-name': volume_move_target_aggr_info.get('volume_name', None),
1390 'vserver': volume_move_target_aggr_info.get('vserver', None)},
1391 'fail_on_error': False,
1392 },
1393 'min_version': '0',
1394 },
1395 'volume_space_info': {
1396 'method': self.get_generic_get_iter,
1397 'kwargs': {
1398 'call': 'volume-space-get-iter',
1399 'attribute': 'space-info',
1400 'key_fields': ('vserver', 'volume'),
1401 'query': {'max-records': self.max_records},
1402 },
1403 'min_version': '0',
1404 },
1405 'vscan_info': {
1406 'method': self.get_generic_get_iter,
1407 'kwargs': {
1408 'call': 'vscan-status-get-iter',
1409 'attribute': 'vscan-status-info',
1410 'key_fields': ('vserver'),
1411 'query': {'max-records': self.max_records},
1412 },
1413 'min_version': '0',
1414 },
1415 'vserver_peer_info': {
1416 'method': self.get_generic_get_iter,
1417 'kwargs': {
1418 'call': 'vserver-peer-get-iter',
1419 'attribute': 'vserver-peer-info',
1420 'key_fields': ('vserver', 'remote-vserver-name'),
1421 'query': {'max-records': self.max_records},
1422 },
1423 'min_version': '0',
1424 },
1425 }
1426
1427 # use vserver tunneling if vserver is present (not None)
1428 self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.module.params['vserver'])
1429
1430 def ontapi(self):
1431 '''Method to get ontapi version'''
1432
1433 api = 'system-get-ontapi-version'
1434 api_call = netapp_utils.zapi.NaElement(api)
1435 try:
1436 results = self.server.invoke_successfully(api_call, enable_tunneling=True)
1437 ontapi_version = results.get_child_content('minor-version')
1438 return ontapi_version if ontapi_version is not None else '0'
1439 except netapp_utils.zapi.NaApiError as error:
1440 self.module.fail_json(msg="Error calling API %s: %s" %
1441 (api, to_native(error)), exception=traceback.format_exc())
1442
1443 def call_api(self, call, attributes_list_tag='attributes-list', query=None, fail_on_error=True):
1444 '''Main method to run an API call'''
1445
1446 api_call = netapp_utils.zapi.NaElement(call)
1447 initial_result = None
1448 result = None
1449
1450 if query:
1451 for key, val in query.items():
1452 # Can val be nested?
1453 api_call.add_new_child(key, val)
1454
1455 if self.desired_attributes is not None:
1456 api_call.translate_struct(self.desired_attributes)
1457 if self.query is not None:
1458 api_call.translate_struct(self.query)
1459 try:
1460 initial_result = self.server.invoke_successfully(api_call, enable_tunneling=True)
1461 next_tag = initial_result.get_child_by_name('next-tag')
1462 result = copy.copy(initial_result)
1463
1464 while next_tag:
1465 next_tag_call = netapp_utils.zapi.NaElement(call)
1466 if query:
1467 for key, val in query.items():
1468 next_tag_call.add_new_child(key, val)
1469
1470 next_tag_call.add_new_child("tag", next_tag.get_content(), True)
1471 next_result = self.server.invoke_successfully(next_tag_call, enable_tunneling=True)
1472
1473 next_tag = next_result.get_child_by_name('next-tag')
1474 if attributes_list_tag is None:
1475 self.module.fail_json(msg="Error calling API %s: %s" %
1476 (api_call.to_string(), "'next-tag' is not expected for this API"))
1477
1478 result_attr = result.get_child_by_name(attributes_list_tag)
1479 new_records = next_result.get_child_by_name(attributes_list_tag)
1480 if new_records:
1481 for record in new_records.get_children():
1482 result_attr.add_child_elem(record)
1483
1484 return result, None
1485
1486 except netapp_utils.zapi.NaApiError as error:
1487 if call in ['security-key-manager-key-get-iter']:
1488 return result, None
1489 kind, error_message = netapp_utils.classify_zapi_exception(error)
1490 if kind == 'missing_vserver_api_error':
1491 # for missing_vserver_api_error, the API is already in error_message
1492 error_message = "Error invalid API. %s" % error_message
1493 else:
1494 error_message = "Error calling API %s: %s" % (call, error_message)
1495 if self.error_flags[kind] and fail_on_error:
1496 self.module.fail_json(msg=error_message, exception=traceback.format_exc())
1497 return None, error_message
1498
1499 def get_ifgrp_info(self):
1500 '''Method to get network port ifgroups info'''
1501
1502 try:
1503 net_port_info = self.netapp_info['net_port_info']
1504 except KeyError:
1505 net_port_info_calls = self.info_subsets['net_port_info']
1506 net_port_info = net_port_info_calls['method'](**net_port_info_calls['kwargs'])
1507 interfaces = net_port_info.keys()
1508
1509 ifgrps = []
1510 for ifn in interfaces:
1511 if net_port_info[ifn]['port_type'] == 'if_group':
1512 ifgrps.append(ifn)
1513
1514 net_ifgrp_info = dict()
1515 for ifgrp in ifgrps:
1516 query = dict()
1517 query['node'], query['ifgrp-name'] = ifgrp.split(':')
1518
1519 tmp = self.get_generic_get_iter('net-port-ifgrp-get', key_fields=('node', 'ifgrp-name'),
1520 attribute='net-ifgrp-info', query=query,
1521 attributes_list_tag='attributes')
1522 net_ifgrp_info = net_ifgrp_info.copy()
1523 net_ifgrp_info.update(tmp)
1524 return net_ifgrp_info
1525
1526 def get_generic_get_iter(self, call, attribute=None, key_fields=None, query=None, attributes_list_tag='attributes-list', fail_on_error=True):
1527 '''Method to run a generic get-iter call'''
1528
1529 generic_call, error = self.call_api(call, attributes_list_tag, query, fail_on_error=fail_on_error)
1530
1531 if error is not None:
1532 return {'error': error}
1533
1534 if generic_call is None:
1535 return None
1536
1537 if attributes_list_tag is None:
1538 attributes_list = generic_call
1539 else:
1540 attributes_list = generic_call.get_child_by_name(attributes_list_tag)
1541
1542 if attributes_list is None:
1543 return None
1544
1545 if key_fields is None:
1546 out = []
1547 else:
1548 out = {}
1549
1550 iteration = 0
1551 for child in attributes_list.get_children():
1552 iteration += 1
1553 dic = xmltodict.parse(child.to_string(), xml_attribs=False)
1554
1555 if attribute is not None:
1556 try:
1557 dic = dic[attribute]
1558 except KeyError as exc:
1559 error_message = 'Error: attribute %s not found for %s, got: %s' % (str(exc), call, dic)
1560 self.module.fail_json(msg=error_message, exception=traceback.format_exc())
1561
1562 info = json.loads(json.dumps(dic))
1563 if self.translate_keys:
1564 info = convert_keys(info)
1565 if isinstance(key_fields, str):
1566 try:
1567 unique_key = _finditem(dic, key_fields)
1568 except KeyError as exc:
1569 error_message = 'Error: key %s not found for %s, got: %s' % (str(exc), call, repr(info))
1570 if self.error_flags['key_error']:
1571 self.module.fail_json(msg=error_message, exception=traceback.format_exc())
1572 unique_key = 'Error_%d_key_not_found_%s' % (iteration, exc.args[0])
1573 elif isinstance(key_fields, tuple):
1574 try:
1575 unique_key = ':'.join([_finditem(dic, el) for el in key_fields])
1576 except KeyError as exc:
1577 error_message = 'Error: key %s not found for %s, got: %s' % (str(exc), call, repr(info))
1578 if self.error_flags['key_error']:
1579 self.module.fail_json(msg=error_message, exception=traceback.format_exc())
1580 unique_key = 'Error_%d_key_not_found_%s' % (iteration, exc.args[0])
1581 else:
1582 unique_key = None
1583 if unique_key is not None:
1584 out = out.copy()
1585 out.update({unique_key: info})
1586 else:
1587 out.append(info)
1588
1589 if attributes_list_tag is None and key_fields is None:
1590 if len(out) == 1:
1591 # flatten the list as only 1 element is expected
1592 out = out[0]
1593 elif len(out) > 1:
1594 # aggregate a list of dictionaries into a single dict
1595 # make sure we only have dicts and no key duplication
1596 dic = dict()
1597 key_count = 0
1598 for item in out:
1599 if not isinstance(item, dict):
1600 # abort if we don't see a dict - not sure this can happen with ZAPI
1601 key_count = -1
1602 break
1603 dic.update(item)
1604 key_count += len(item)
1605 if key_count == len(dic):
1606 # no duplicates!
1607 out = dic
1608
1609 return out
1610
1611 def augment_subset(self, subset, info):
1612 if subset == 'lun_info' and info:
1613 for lun_info in info.values():
1614 # the keys may have been converted, or not
1615 serial = lun_info.get('serial_number') or lun_info.get('serial-number')
1616 if serial:
1617 hexlify = codecs.getencoder('hex')
1618 # dictionaries are mutable
1619 lun_info['serial_hex'] = to_text(hexlify(to_bytes(lun_info['serial_number']))[0])
1620 lun_info['naa_id'] = 'naa.600a0980' + lun_info['serial_hex']
1621 return info
1622
1623 def get_all(self, gather_subset):
1624 '''Method to get all subsets'''
1625
1626 self.netapp_info['ontapi_version'] = self.ontapi()
1627 self.netapp_info['ontap_version'] = self.netapp_info['ontapi_version']
1628
1629 run_subset = self.get_subset(gather_subset, self.netapp_info['ontapi_version'])
1630 if 'ontap_version' in gather_subset:
1631 if netapp_utils.has_feature(self.module, 'deprecation_warning'):
1632 self.netapp_info['deprecation_warning'] = 'ontap_version is deprecated, please use ontapi_version'
1633 if 'help' in gather_subset:
1634 self.netapp_info['help'] = sorted(run_subset)
1635 else:
1636 if self.desired_attributes is not None:
1637 if len(run_subset) > 1:
1638 self.module.fail_json(msg="desired_attributes option is only supported with a single subset")
1639 self.sanitize_desired_attributes()
1640 if self.query is not None:
1641 if len(run_subset) > 1:
1642 self.module.fail_json(msg="query option is only supported with a single subset")
1643 self.sanitize_query()
1644 for subset in run_subset:
1645 call = self.info_subsets[subset]
1646 self.netapp_info[subset] = call['method'](**call['kwargs'])
1647 self.augment_subset(subset, self.netapp_info[subset])
1648
1649 if self.warnings:
1650 self.netapp_info['module_warnings'] = self.warnings
1651
1652 return self.netapp_info
1653
1654 def get_subset(self, gather_subset, version):
1655 '''Method to get a single subset'''
1656
1657 runable_subsets = set()
1658 exclude_subsets = set()
1659 usable_subsets = [key for key in self.info_subsets if version >= self.info_subsets[key]['min_version']]
1660 if 'help' in gather_subset:
1661 return usable_subsets
1662 for subset in gather_subset:
1663 if subset == 'all':
1664 runable_subsets.update(usable_subsets)
1665 return runable_subsets
1666 if subset.startswith('!'):
1667 subset = subset[1:]
1668 if subset == 'all':
1669 return set()
1670 exclude = True
1671 else:
1672 exclude = False
1673
1674 if subset not in usable_subsets:
1675 if subset not in self.info_subsets.keys():
1676 self.module.fail_json(msg='Bad subset: %s' % subset)
1677 self.module.fail_json(msg='Remote system at version %s does not support %s' %
1678 (version, subset))
1679
1680 if exclude:
1681 exclude_subsets.add(subset)
1682 else:
1683 runable_subsets.add(subset)
1684
1685 if not runable_subsets:
1686 runable_subsets.update(usable_subsets)
1687
1688 runable_subsets.difference_update(exclude_subsets)
1689
1690 return runable_subsets
1691
1692 def get_summary(self, ontap_info):
1693 for info in ontap_info:
1694 if '_info' in info and ontap_info[info] is not None and isinstance(ontap_info[info], dict):
1695 # don't summarize errors
1696 if 'error' not in ontap_info[info]:
1697 ontap_info[info] = ontap_info[info].keys()
1698 return ontap_info
1699
1700 def sanitize_desired_attributes(self):
1701 ''' add top 'desired-attributes' if absent
1702 check for _ as more likely ZAPI does not take them
1703 '''
1704 da_key = 'desired-attributes'
1705 if da_key not in self.desired_attributes:
1706 desired_attributes = dict()
1707 desired_attributes[da_key] = self.desired_attributes
1708 self.desired_attributes = desired_attributes
1709 self.check_for___in_keys(self.desired_attributes)
1710
1711 def sanitize_query(self):
1712 ''' add top 'query' if absent
1713 check for _ as more likely ZAPI does not take them
1714 '''
1715 key = 'query'
1716 if key not in self.query:
1717 query = dict()
1718 query[key] = self.query
1719 self.query = query
1720 self.check_for___in_keys(self.query)
1721
1722 def check_for___in_keys(self, d_param):
1723 '''Method to warn on underscore in a ZAPI tag'''
1724 if isinstance(d_param, dict):
1725 for key, val in d_param.items():
1726 self.check_for___in_keys(val)
1727 if '_' in key:
1728 self.warnings.append("Underscore in ZAPI tag: %s, do you mean '-'?" % key)
1729 elif isinstance(d_param, list):
1730 for val in d_param:
1731 self.check_for___in_keys(val)
1732
1733 def set_error_flags(self):
1734 error_flags = self.module.params['continue_on_error']
1735 generic_flags = ('always', 'never')
1736 if len(error_flags) > 1:
1737 for key in generic_flags:
1738 if key in error_flags:
1739 self.module.fail_json(msg="%s needs to be the only keyword in 'continue_on_error' option." % key)
1740 specific_flags = ('rpc_error', 'missing_vserver_api_error', 'key_error', 'other_error')
1741 for key in error_flags:
1742 if key not in generic_flags and key not in specific_flags:
1743 self.module.fail_json(msg="%s is not a valid keyword in 'continue_on_error' option." % key)
1744 self.error_flags = dict()
1745 for flag in specific_flags:
1746 self.error_flags[flag] = True
1747 for key in error_flags:
1748 if key == 'always' or key == flag:
1749 self.error_flags[flag] = False
1750
1751 def apply(self):
1752 gather_subset = self.module.params['gather_subset']
1753 if gather_subset is None:
1754 gather_subset = ['all']
1755 gf_all = self.get_all(gather_subset)
1756 if self.module.params['summary']:
1757 gf_all = self.get_summary(gf_all)
1758 results = {'changed': False, 'ontap_info': gf_all}
1759 if self.module.params['state'] is not None:
1760 results['state'] = self.module.params['state']
1761 results['warnings'] = "option 'state' is deprecated."
1762 self.module.warn("option 'state' is deprecated.")
1763 self.module.exit_json(**results)
1764
1765
1766 # https://stackoverflow.com/questions/14962485/finding-a-key-recursively-in-a-dictionary
1767 def __finditem(obj, key):
1768
1769 if key is None:
1770 # allows for a key not to be present
1771 return "key_not_present"
1772 if key in obj:
1773 if obj[key] is None:
1774 return "None"
1775 return obj[key]
1776 for dummy, val in obj.items():
1777 if isinstance(val, dict):
1778 item = __finditem(val, key)
1779 if item is not None:
1780 return item
1781 return None
1782
1783
1784 def _finditem(obj, keys):
1785 ''' if keys is a string, use it as a key
1786 if keys is a tuple, stop on the first valid key
1787 if no valid key is found, raise a KeyError '''
1788
1789 value = None
1790 if isinstance(keys, str):
1791 value = __finditem(obj, keys)
1792 elif isinstance(keys, tuple):
1793 for key in keys:
1794 value = __finditem(obj, key)
1795 if value is not None:
1796 break
1797 if value is not None:
1798 return value
1799 raise KeyError(str(keys))
1800
1801
1802 def convert_keys(d_param):
1803 '''Method to convert hyphen to underscore'''
1804
1805 if isinstance(d_param, dict):
1806 out = {}
1807 for key, val in d_param.items():
1808 val = convert_keys(val)
1809 out[key.replace('-', '_')] = val
1810 return out
1811 elif isinstance(d_param, list):
1812 return [convert_keys(val) for val in d_param]
1813 return d_param
1814
1815
1816 def main():
1817 '''Execute action'''
1818 gf_obj = NetAppONTAPGatherInfo()
1819 gf_obj.apply()
1820
1821
1822 if __name__ == '__main__':
1823 main()