Debian Codegraph @

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

raw
1 #!/usr/bin/python
2
3 # (c) 2018-2026, 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_dns
8 '''
9
10 from __future__ import absolute_import, division, print_function
11 __metaclass__ = type
12
13 DOCUMENTATION = '''
14 module: na_ontap_dns
15 short_description: NetApp ONTAP Create, delete, modify DNS servers.
16 extends_documentation_fragment:
17 - netapp.ontap.netapp.na_ontap
18 version_added: 2.7.0
19 author: NetApp Ansible Team (@carchi8py) <[email protected]>
20 description:
21 - Create, delete, modify DNS servers.
22 - With REST, the module is currently limited to data vservers for delete or modify operations.
23 options:
24 state:
25 description:
26 - Whether the DNS servers should be enabled for the given vserver.
27 choices: ['present', 'absent']
28 type: str
29 default: present
30
31 vserver:
32 description:
33 - The name of the vserver to use.
34 - With REST, for cluster scoped DNS, omit this option or set it to NULL for ONTAP 9.13.1 or later and
35 provide cluster vserver as its value for ONTAP 9.12.1 or earlier.
36 - With ZAPI or REST, for cluster scoped DNS, this can also be set to the cluster vserver name.
37 type: str
38
39 domains:
40 description:
41 - List of DNS domains such as 'sales.bar.com'. The first domain is the one that the Vserver belongs to.
42 type: list
43 elements: str
44
45 nameservers:
46 description:
47 - List of IPv4 addresses of name servers such as '123.123.123.123'.
48 type: list
49 elements: str
50
51 skip_validation:
52 type: bool
53 description:
54 - By default, all nameservers are checked to validate they are available to resolve.
55 - If you DNS servers are not yet installed or momentarily not available, you can set this option to 'true'
56 - to bypass the check for all servers specified in nameservers field.
57 - With REST, requires ONTAP 9.9.1 or later and ignored for cluster DNS operations.
58 version_added: 2.8.0
59
60 lambda_config:
61 description:
62 - Configuration parameters for AWS Lambda proxy functionality.
63 - These option and suboptions are only supported with REST.
64 type: dict
65 version_added: 23.5.0
66 suboptions:
67 function_name:
68 description:
69 - The name of the AWS Lambda function to invoke.
70 type: str
71 required: true
72 aws_region:
73 description:
74 - The name of the AWS region.
75 type: str
76 required: true
77 aws_profile:
78 description:
79 - The name of the AWS profile to use for authentication.
80 type: str
81
82 notes:
83 - Supports AWS Lambda proxy functionality when using REST. See README for example usage.
84 '''
85
86 EXAMPLES = """
87 - name: Create or modify DNS
88 netapp.ontap.na_ontap_dns:
89 state: present
90 username: "{{ netapp_username }}"
91 password: "{{ netapp_password }}"
92 hostname: "{{ netapp_hostname }}"
93 vserver: "{{ vservername }}"
94 domains: sales.bar.com
95 nameservers: 10.193.0.250,10.192.0.250
96 skip_validation: true
97
98 - name: Create or modify cluster DNS with REST
99 netapp.ontap.na_ontap_dns:
100 state: present
101 username: "{{ netapp_username }}"
102 password: "{{ netapp_password }}"
103 hostname: "{{ netapp_hostname }}"
104 domains: sales.bar.com
105 nameservers: 10.193.0.250,10.192.0.250
106 """
107
108 RETURN = """
109
110 """
111 import traceback
112 from ansible.module_utils.basic import AnsibleModule
113 from ansible.module_utils._text import to_native
114 import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils
115 from ansible_collections.netapp.ontap.plugins.module_utils import rest_generic
116 from ansible_collections.netapp.ontap.plugins.module_utils.netapp_module import NetAppModule
117
118
119 class NetAppOntapDns:
120 """
121 Enable and Disable dns
122 """
123
124 def __init__(self):
125 self.use_rest = False
126 self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
127 self.argument_spec.update(dict(
128 state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
129 vserver=dict(required=False, type='str'),
130 domains=dict(required=False, type='list', elements='str'),
131 nameservers=dict(required=False, type='list', elements='str'),
132 skip_validation=dict(required=False, type='bool')
133 ))
134 self.argument_spec.update(netapp_utils.na_ontap_lambda_argument_spec())
135
136 self.module = AnsibleModule(
137 argument_spec=self.argument_spec,
138 required_if=[
139 ('state', 'present', ['domains', 'nameservers']),
140 ('use_lambda', True, ['lambda_config']),
141 ],
142 supports_check_mode=True
143 )
144
145 self.na_helper = NetAppModule()
146 self.parameters = self.na_helper.set_parameters(self.module.params)
147 # Cluster vserver and data vserver use different REST API.
148 self.is_cluster = False
149
150 # REST API should be used for ONTAP 9.6 or higher, ZAPI for lower version
151 self.rest_api = netapp_utils.OntapRestAPI(self.module)
152 self.use_rest = self.rest_api.is_rest_supported_properties(self.parameters, None, [['skip_validation', (9, 9, 1)]])
153 if not self.use_rest:
154 if self.parameters.get('use_lambda'):
155 self.module.fail_json(msg="Error: AWS Lambda proxy for ONTAP APIs is only supported with REST.")
156 if not netapp_utils.has_netapp_lib():
157 self.module.fail_json(msg=netapp_utils.netapp_lib_is_required())
158 if not self.parameters.get('vserver'):
159 self.module.fail_json(msg="Error: vserver is a required parameter with ZAPI.")
160 self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
161 return
162
163 def patch_cluster_dns(self):
164 api = 'cluster'
165 body = {
166 'dns_domains': self.parameters['domains'],
167 'name_servers': self.parameters['nameservers']
168 }
169 if self.parameters.get('skip_validation'):
170 self.module.warn("skip_validation is ignored for cluster DNS operations in REST.")
171 dummy, error = rest_generic.patch_async(self.rest_api, api, None, body)
172 if error:
173 self.module.fail_json(msg="Error updating cluster DNS options: %s" % error)
174
175 def create_dns_rest(self):
176 """
177 Create DNS server
178 :return: none
179 """
180 if self.is_cluster or not self.parameters.get('vserver'):
181 # with 9.13, using scope=cluster with POST on 'name-services/dns' does not work:
182 # "svm.uuid" is a required field
183 return self.patch_cluster_dns()
184
185 api = 'name-services/dns'
186 body = {
187 'domains': self.parameters['domains'],
188 'servers': self.parameters['nameservers'],
189 'svm': {
190 'name': self.parameters['vserver']
191 }
192 }
193 if 'skip_validation' in self.parameters:
194 body['skip_config_validation'] = self.parameters['skip_validation']
195 dummy, error = rest_generic.post_async(self.rest_api, api, body)
196 if error:
197 self.module.fail_json(msg="Error creating DNS service: %s" % error)
198
199 def create_dns(self):
200 """
201 Create DNS server
202 :return: none
203 """
204 if self.use_rest:
205 return self.create_dns_rest()
206
207 dns = netapp_utils.zapi.NaElement('net-dns-create')
208 nameservers = netapp_utils.zapi.NaElement('name-servers')
209 domains = netapp_utils.zapi.NaElement('domains')
210 for each in self.parameters['nameservers']:
211 ip_address = netapp_utils.zapi.NaElement('ip-address')
212 ip_address.set_content(each)
213 nameservers.add_child_elem(ip_address)
214 dns.add_child_elem(nameservers)
215 for each in self.parameters['domains']:
216 domain = netapp_utils.zapi.NaElement('string')
217 domain.set_content(each)
218 domains.add_child_elem(domain)
219 dns.add_child_elem(domains)
220 if self.parameters.get('skip_validation'):
221 validation = netapp_utils.zapi.NaElement('skip-config-validation')
222 validation.set_content(str(self.parameters['skip_validation']))
223 dns.add_child_elem(validation)
224 try:
225 self.server.invoke_successfully(dns, True)
226 except netapp_utils.zapi.NaApiError as error:
227 self.module.fail_json(msg='Error creating dns: %s' % to_native(error),
228 exception=traceback.format_exc())
229
230 def destroy_dns_rest(self, dns_attrs):
231 """
232 Destroys an already created dns
233 :return:
234 """
235 if self.is_cluster:
236 error = 'Error: cluster scope when deleting DNS with REST requires ONTAP 9.9.1 or later.'
237 self.module.fail_json(msg=error)
238 api = 'name-services/dns'
239 dummy, error = rest_generic.delete_async(self.rest_api, api, dns_attrs['uuid'])
240 if error:
241 self.module.fail_json(msg="Error deleting DNS service: %s" % error)
242
243 def destroy_dns(self, dns_attrs):
244 """
245 Destroys an already created dns
246 :return:
247 """
248 if self.use_rest:
249 return self.destroy_dns_rest(dns_attrs)
250
251 try:
252 self.server.invoke_successfully(netapp_utils.zapi.NaElement('net-dns-destroy'), True)
253 except netapp_utils.zapi.NaApiError as error:
254 self.module.fail_json(msg='Error destroying dns: %s' % to_native(error),
255 exception=traceback.format_exc())
256
257 def get_cluster(self):
258 api = "cluster"
259 record, error = rest_generic.get_one_record(self.rest_api, api)
260 if error:
261 self.module.fail_json(msg="Error getting cluster info: %s" % error)
262 return record
263
264 def get_cluster_dns(self):
265 cluster_attrs = self.get_cluster()
266 dns_attrs = None
267 if not self.parameters.get('vserver') or self.parameters['vserver'] == cluster_attrs['name']:
268 dns_attrs = {
269 'domains': cluster_attrs.get('dns_domains'),
270 'nameservers': cluster_attrs.get('name_servers'),
271 'uuid': cluster_attrs['uuid'],
272 }
273 self.is_cluster = True
274 if dns_attrs['domains'] is None and dns_attrs['nameservers'] is None:
275 dns_attrs = None
276 return dns_attrs
277
278 def get_dns_rest(self):
279 if not self.parameters.get('vserver') and not self.rest_api.meets_rest_minimum_version(self.use_rest, 9, 9, 1):
280 # scope requires 9.9, so revert to cluster API
281 return self.get_cluster_dns()
282
283 api = "name-services/dns"
284 params = {'fields': 'domains,servers,svm'}
285 if self.parameters.get('vserver'):
286 # omit scope as vserver may be a cluster vserver
287 params['svm.name'] = self.parameters['vserver']
288 else:
289 params['scope'] = 'cluster'
290 record, error = rest_generic.get_one_record(self.rest_api, api, params)
291 if error:
292 self.module.fail_json(msg="Error getting DNS service: %s" % error)
293 if record:
294 if params.get('scope') == 'cluster' or not self.na_helper.safe_get(record, ['svm', 'uuid']):
295 uuid = record.get('uuid')
296 else:
297 uuid = self.na_helper.safe_get(record, ['svm', 'uuid'])
298 if uuid is None:
299 self.module.fail_json(msg="Error getting DNS service: could not retrieve UUID of the DNS object")
300 return {
301 'domains': record.get('domains'),
302 'nameservers': record.get('servers'),
303 'uuid': uuid
304 }
305 if self.parameters.get('vserver') and not self.rest_api.meets_rest_minimum_version(self.use_rest, 9, 9, 1):
306 # There is a chance we are working at the cluster level
307 return self.get_cluster_dns()
308 return None
309
310 def get_dns(self):
311 if self.use_rest:
312 return self.get_dns_rest()
313
314 dns_obj = netapp_utils.zapi.NaElement('net-dns-get')
315 try:
316 result = self.server.invoke_successfully(dns_obj, True)
317 except netapp_utils.zapi.NaApiError as error:
318 if to_native(error.code) == "15661":
319 # 15661 is object not found
320 return None
321 else:
322 self.module.fail_json(msg="Error getting DNS info: %s." % to_native(error), exception=traceback.format_exc())
323
324 attributes = result.get_child_by_name('attributes')
325 if attributes is None:
326 return
327 dns_info = attributes.get_child_by_name('net-dns-info')
328 nameservers = dns_info.get_child_by_name('name-servers')
329 attrs = {
330 'nameservers': [
331 each.get_content() for each in nameservers.get_children()
332 ]
333 }
334 domains = dns_info.get_child_by_name('domains')
335 attrs['domains'] = [each.get_content() for each in domains.get_children()]
336 return attrs
337
338 def modify_dns_rest(self, dns_attrs):
339 if self.is_cluster:
340 return self.patch_cluster_dns()
341 body = {}
342 if dns_attrs['nameservers'] != self.parameters['nameservers']:
343 body['servers'] = self.parameters['nameservers']
344 if dns_attrs['domains'] != self.parameters['domains']:
345 body['domains'] = self.parameters['domains']
346 if 'skip_validation' in self.parameters:
347 body['skip_config_validation'] = self.parameters['skip_validation']
348 api = "name-services/dns"
349 dummy, error = rest_generic.patch_async(self.rest_api, api, dns_attrs['uuid'], body)
350 if error:
351 self.module.fail_json(msg="Error modifying DNS configuration: %s" % error)
352
353 def modify_dns(self, dns_attrs):
354 if self.use_rest:
355 return self.modify_dns_rest(dns_attrs)
356 dns = netapp_utils.zapi.NaElement('net-dns-modify')
357 if dns_attrs['nameservers'] != self.parameters['nameservers']:
358 nameservers = netapp_utils.zapi.NaElement('name-servers')
359 for each in self.parameters['nameservers']:
360 ip_address = netapp_utils.zapi.NaElement('ip-address')
361 ip_address.set_content(each)
362 nameservers.add_child_elem(ip_address)
363 dns.add_child_elem(nameservers)
364 if dns_attrs['domains'] != self.parameters['domains']:
365 domains = netapp_utils.zapi.NaElement('domains')
366 for each in self.parameters['domains']:
367 domain = netapp_utils.zapi.NaElement('string')
368 domain.set_content(each)
369 domains.add_child_elem(domain)
370 dns.add_child_elem(domains)
371 if self.parameters.get('skip_validation'):
372 validation = netapp_utils.zapi.NaElement('skip-config-validation')
373 validation.set_content(str(self.parameters['skip_validation']))
374 dns.add_child_elem(validation)
375 try:
376 self.server.invoke_successfully(dns, True)
377 except netapp_utils.zapi.NaApiError as error:
378 self.module.fail_json(msg='Error modifying dns: %s' % to_native(error), exception=traceback.format_exc())
379
380 def apply(self):
381 dns_attrs = self.get_dns()
382 cd_action = self.na_helper.get_cd_action(dns_attrs, self.parameters)
383 modify = None
384 if cd_action is None:
385 modify = self.na_helper.get_modified_attributes(dns_attrs, self.parameters)
386 if self.na_helper.changed and not self.module.check_mode:
387 if cd_action == 'create':
388 self.create_dns()
389 elif cd_action == 'delete':
390 self.destroy_dns(dns_attrs)
391 else:
392 self.modify_dns(dns_attrs)
393 result = netapp_utils.generate_result(self.na_helper.changed, cd_action, modify)
394 self.module.exit_json(**result)
395
396
397 def main():
398 """
399 Create, Delete, Modify DNS servers.
400 """
401 obj = NetAppOntapDns()
402 obj.apply()
403
404
405 if __name__ == '__main__':
406 main()