Debian Codegraph @

ansible_collections/netapp/ontap/plugins/modules/na_ontap_vserver_peer.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 from __future__ import absolute_import, division, print_function
6 __metaclass__ = type
7
8
9 DOCUMENTATION = '''
10 author: NetApp Ansible Team (@carchi8py) <[email protected]>
11 description:
12 - Create/Delete vserver peer
13 extends_documentation_fragment:
14 - netapp.ontap.netapp.na_ontap
15 - netapp.ontap.netapp.na_ontap_peer
16 module: na_ontap_vserver_peer
17 options:
18 state:
19 choices: ['present', 'absent']
20 type: str
21 description:
22 - Whether the specified vserver peer should exist or not.
23 default: present
24 vserver:
25 description:
26 - Specifies name of the source Vserver in the relationship.
27 required: true
28 type: str
29 applications:
30 type: list
31 elements: str
32 description:
33 - List of applications which can make use of the peering relationship.
34 - FlexCache supported from ONTAP 9.5 onwards.
35 peer_vserver:
36 description:
37 - Specifies name of the peer Vserver in the relationship.
38 required: true
39 type: str
40 peer_cluster:
41 description:
42 - Specifies name of the peer Cluster.
43 - Required for creating the vserver peer relationship with a remote cluster
44 type: str
45 local_name_for_peer:
46 description:
47 - Specifies local name of the peer Vserver in the relationship.
48 - Use this if you see "Error creating vserver peer ... Vserver name conflicts with one of the following".
49 type: str
50 local_name_for_source:
51 description:
52 - Specifies local name of the source Vserver in the relationship.
53 - Use this if you see "Error accepting vserver peer ... System generated a name for the peer Vserver because of a naming conflict".
54 type: str
55 dest_hostname:
56 description:
57 - DEPRECATED - please use C(peer_options).
58 - Destination hostname or IP address.
59 - Required for creating the vserver peer relationship with a remote cluster.
60 type: str
61 dest_username:
62 description:
63 - DEPRECATED - please use C(peer_options).
64 - Destination username.
65 - Optional if this is same as source username.
66 type: str
67 dest_password:
68 description:
69 - DEPRECATED - please use C(peer_options).
70 - Destination password.
71 - Optional if this is same as source password.
72 type: str
73 lambda_config:
74 description:
75 - Configuration parameters for AWS Lambda proxy functionality.
76 - These option and suboptions are only supported with REST.
77 type: dict
78 version_added: 23.4.0
79 suboptions:
80 function_name:
81 description:
82 - The name of the AWS Lambda function to invoke.
83 type: str
84 required: true
85 aws_region:
86 description:
87 - The name of the AWS region.
88 type: str
89 required: true
90 aws_profile:
91 description:
92 - The name of the AWS profile to use for authentication.
93 type: str
94 short_description: NetApp ONTAP Vserver peering
95 version_added: 2.7.0
96
97 notes:
98 - Supports AWS Lambda proxy functionality when using REST. See the README file for example usage.
99 '''
100
101 EXAMPLES = """
102 - name: Source vserver peer create
103 netapp.ontap.na_ontap_vserver_peer:
104 state: present
105 peer_vserver: ansible2
106 peer_cluster: ansibleCluster
107 local_name_for_peer: peername
108 local_name_for_source: sourcename
109 vserver: ansible
110 applications: ['snapmirror']
111 hostname: "{{ netapp_hostname }}"
112 username: "{{ netapp_username }}"
113 password: "{{ netapp_password }}"
114 peer_options:
115 hostname: "{{ netapp_dest_hostname }}"
116
117 - name: vserver peer delete
118 netapp.ontap.na_ontap_vserver_peer:
119 state: absent
120 peer_vserver: ansible2
121 vserver: ansible
122 hostname: "{{ netapp_hostname }}"
123 username: "{{ netapp_username }}"
124 password: "{{ netapp_password }}"
125
126 - name: Source vserver peer create - different credentials
127 netapp.ontap.na_ontap_vserver_peer:
128 state: present
129 peer_vserver: ansible2
130 peer_cluster: ansibleCluster
131 local_name_for_peer: peername
132 local_name_for_source: sourcename
133 vserver: ansible
134 applications: ['snapmirror']
135 hostname: "{{ netapp_hostname }}"
136 username: "{{ netapp_username }}"
137 password: "{{ netapp_password }}"
138 peer_options:
139 hostname: "{{ netapp_dest_hostname }}"
140 cert_filepath: "{{ cert_filepath }}"
141 key_filepath: "{{ key_filepath }}"
142 """
143
144 RETURN = """
145 """
146
147 import traceback
148 from ansible.module_utils.basic import AnsibleModule
149 from ansible.module_utils._text import to_native
150 import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils
151 from ansible_collections.netapp.ontap.plugins.module_utils.netapp_module import NetAppModule
152 from ansible_collections.netapp.ontap.plugins.module_utils.netapp import OntapRestAPI
153 from ansible_collections.netapp.ontap.plugins.module_utils import rest_generic
154
155
156 class NetAppONTAPVserverPeer:
157 """
158 Class with vserver peer methods
159 """
160
161 def __init__(self):
162
163 self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
164 self.argument_spec.update(dict(
165 state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
166 vserver=dict(required=True, type='str'),
167 peer_vserver=dict(required=True, type='str'),
168 peer_cluster=dict(required=False, type='str'),
169 local_name_for_peer=dict(required=False, type='str'),
170 local_name_for_source=dict(required=False, type='str'),
171 applications=dict(required=False, type='list', elements='str'),
172 peer_options=dict(type='dict', options=netapp_utils.na_ontap_host_argument_spec_peer()),
173 dest_hostname=dict(required=False, type='str'),
174 dest_username=dict(required=False, type='str'),
175 dest_password=dict(required=False, type='str', no_log=True)
176 ))
177
178 self.argument_spec.update(netapp_utils.na_ontap_lambda_argument_spec())
179 # Add Lambda support to peer_options
180 self.argument_spec['peer_options']['options'].update(netapp_utils.na_ontap_lambda_argument_spec())
181
182 self.module = AnsibleModule(
183 argument_spec=self.argument_spec,
184 mutually_exclusive=[
185 ['peer_options', 'dest_hostname'],
186 ['peer_options', 'dest_username'],
187 ['peer_options', 'dest_password']
188 ],
189 required_if=[
190 ['use_lambda', True, ('lambda_config',)]
191 ],
192 supports_check_mode=True
193 )
194
195 self.na_helper = NetAppModule()
196 self.parameters = self.na_helper.set_parameters(self.module.params)
197 if self.parameters.get('dest_hostname') is None and self.parameters.get('peer_options') is None:
198 self.parameters['dest_hostname'] = self.parameters.get('hostname')
199 if self.parameters.get('dest_hostname') is not None:
200 # if dest_hostname is present, peer_options is absent
201 self.parameters['peer_options'] = dict(
202 hostname=self.parameters.get('dest_hostname'),
203 username=self.parameters.get('dest_username'),
204 password=self.parameters.get('dest_password'),
205 )
206 else:
207 self.parameters['dest_hostname'] = self.parameters['peer_options']['hostname']
208 netapp_utils.setup_host_options_from_module_params(
209 self.parameters['peer_options'], self.module,
210 netapp_utils.na_ontap_host_argument_spec_peer().keys())
211 # Rest API objects
212 self.use_rest = False
213 self.rest_api = OntapRestAPI(self.module)
214 self.src_use_rest = self.rest_api.is_rest()
215 self.dst_rest_api = OntapRestAPI(self.module, host_options=self.parameters['peer_options'])
216 self.dst_use_rest = self.dst_rest_api.is_rest()
217 self.use_rest = bool(self.src_use_rest and self.dst_use_rest)
218 if self.use_rest:
219 self.peer_relation_uuid = None
220 else:
221 if self.parameters.get('use_lambda'):
222 self.module.fail_json(msg="Error: AWS Lambda proxy for ONTAP APIs is only supported with REST.")
223 if not netapp_utils.has_netapp_lib():
224 self.module.fail_json(msg=netapp_utils.netapp_lib_is_required())
225 self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
226 self.dest_server = netapp_utils.setup_na_ontap_zapi(module=self.module, host_options=self.parameters['peer_options'])
227
228 def vserver_peer_get_iter(self, target):
229 """
230 Compose NaElement object to query current vserver using remote-vserver-name and vserver parameters.
231 :return: NaElement object for vserver-get-iter with query
232 """
233 vserver_peer_get = netapp_utils.zapi.NaElement('vserver-peer-get-iter')
234 query = netapp_utils.zapi.NaElement('query')
235 vserver_peer_info = netapp_utils.zapi.NaElement('vserver-peer-info')
236 vserver, remote_vserver = self.get_local_and_peer_vserver(target)
237 vserver_peer_info.add_new_child('remote-vserver-name', remote_vserver)
238 vserver_peer_info.add_new_child('vserver', vserver)
239 query.add_child_elem(vserver_peer_info)
240 vserver_peer_get.add_child_elem(query)
241 return vserver_peer_get
242
243 def get_local_and_peer_vserver(self, target):
244 if target == 'source':
245 return self.parameters['vserver'], self.parameters['peer_vserver']
246 # else for target peer.
247 return self.parameters['peer_vserver'], self.parameters['vserver']
248
249 def vserver_peer_get(self, target='source'):
250 """
251 Get current vserver peer info
252 :return: Dictionary of current vserver peer details if query successful, else return None
253 """
254 if self.use_rest:
255 return self.vserver_peer_get_rest(target)
256
257 vserver_peer_get_iter = self.vserver_peer_get_iter(target)
258 vserver_info = {}
259 try:
260 if target == 'source':
261 result = self.server.invoke_successfully(vserver_peer_get_iter, enable_tunneling=True)
262 elif target == 'peer':
263 result = self.dest_server.invoke_successfully(vserver_peer_get_iter, enable_tunneling=True)
264 except netapp_utils.zapi.NaApiError as error:
265 self.module.fail_json(msg='Error fetching vserver peer %s: %s'
266 % (self.parameters['vserver'], to_native(error)),
267 exception=traceback.format_exc())
268 # return vserver peer details
269 if result.get_child_by_name('num-records') and \
270 int(result.get_child_content('num-records')) > 0:
271 vserver_peer_info = result.get_child_by_name('attributes-list').get_child_by_name('vserver-peer-info')
272 vserver_info['peer_vserver'] = vserver_peer_info.get_child_content('remote-vserver-name')
273 vserver_info['vserver'] = vserver_peer_info.get_child_content('vserver')
274 vserver_info['local_peer_vserver'] = vserver_peer_info.get_child_content('peer-vserver') # required for delete and accept
275 vserver_info['peer_state'] = vserver_peer_info.get_child_content('peer-state')
276 return vserver_info
277 return None
278
279 def vserver_peer_delete(self, current):
280 """
281 Delete a vserver peer
282 """
283 if self.use_rest:
284 return self.vserver_peer_delete_rest(current)
285
286 vserver_peer_delete = netapp_utils.zapi.NaElement.create_node_with_children(
287 'vserver-peer-delete', **{'peer-vserver': current['local_peer_vserver'],
288 'vserver': self.parameters['vserver']})
289 try:
290 self.server.invoke_successfully(vserver_peer_delete,
291 enable_tunneling=True)
292 except netapp_utils.zapi.NaApiError as error:
293 self.module.fail_json(msg='Error deleting vserver peer %s: %s'
294 % (self.parameters['vserver'], to_native(error)),
295 exception=traceback.format_exc())
296
297 def get_peer_cluster_name(self):
298 """
299 Get local cluster name
300 :return: cluster name
301 """
302 if self.use_rest:
303 return self.get_peer_cluster_name_rest()
304
305 cluster_info = netapp_utils.zapi.NaElement('cluster-identity-get')
306 # if remote peer exist , get remote cluster name else local cluster name
307 server = self.dest_server if self.is_remote_peer() else self.server
308 try:
309 result = server.invoke_successfully(cluster_info, enable_tunneling=True)
310 return result.get_child_by_name('attributes').get_child_by_name(
311 'cluster-identity-info').get_child_content('cluster-name')
312 except netapp_utils.zapi.NaApiError as error:
313 self.module.fail_json(msg='Error fetching peer cluster name for peer vserver %s: %s'
314 % (self.parameters['peer_vserver'], to_native(error)),
315 exception=traceback.format_exc())
316
317 def vserver_peer_create(self):
318 """
319 Create a vserver peer
320 """
321 if self.parameters.get('applications') is None:
322 self.module.fail_json(msg='applications parameter is missing')
323 if self.parameters.get('peer_cluster') is None:
324 self.parameters['peer_cluster'] = self.get_peer_cluster_name()
325 if self.use_rest:
326 return self.vserver_peer_create_rest()
327
328 vserver_peer_create = netapp_utils.zapi.NaElement.create_node_with_children(
329 'vserver-peer-create', **{'peer-vserver': self.parameters['peer_vserver'],
330 'vserver': self.parameters['vserver'],
331 'peer-cluster': self.parameters['peer_cluster']})
332 if 'local_name_for_peer' in self.parameters:
333 vserver_peer_create.add_new_child('local-name', self.parameters['local_name_for_peer'])
334 applications = netapp_utils.zapi.NaElement('applications')
335 for application in self.parameters['applications']:
336 applications.add_new_child('vserver-peer-application', application)
337 vserver_peer_create.add_child_elem(applications)
338 try:
339 self.server.invoke_successfully(vserver_peer_create, enable_tunneling=True)
340 except netapp_utils.zapi.NaApiError as error:
341 self.module.fail_json(msg='Error creating vserver peer %s: %s'
342 % (self.parameters['vserver'], to_native(error)),
343 exception=traceback.format_exc())
344
345 def is_remote_peer(self):
346 return (
347 self.parameters.get('dest_hostname') is not None
348 and self.parameters['dest_hostname'] != self.parameters['hostname']
349 )
350
351 def vserver_peer_accept(self):
352 """
353 Accept a vserver peer at destination
354 """
355 # peer-vserver -> remote (source vserver is provided)
356 # vserver -> local (destination vserver is provided)
357 if self.use_rest:
358 return self.vserver_peer_accept_rest('peer')
359 vserver_peer_info = self.vserver_peer_get('peer')
360 if vserver_peer_info is None:
361 self.module.fail_json(msg='Error retrieving vserver peer information while accepting')
362 vserver_peer_accept = netapp_utils.zapi.NaElement.create_node_with_children(
363 'vserver-peer-accept', **{'peer-vserver': vserver_peer_info['local_peer_vserver'], 'vserver': self.parameters['peer_vserver']})
364 if 'local_name_for_source' in self.parameters:
365 vserver_peer_accept.add_new_child('local-name', self.parameters['local_name_for_source'])
366 try:
367 self.dest_server.invoke_successfully(vserver_peer_accept, enable_tunneling=True)
368 except netapp_utils.zapi.NaApiError as error:
369 self.module.fail_json(msg='Error accepting vserver peer %s: %s'
370 % (self.parameters['peer_vserver'], to_native(error)),
371 exception=traceback.format_exc())
372
373 def check_and_report_rest_error(self, error, action, where):
374 if error:
375 if "job reported error:" in error and "entry doesn't exist" in error:
376 # ignore RBAC issue with FSx - BURT1467620 (fixed in 9.11.0) - GitHub #45
377 self.module.warn('Ignoring job status, assuming success - Issue #45.')
378 return
379 self.module.fail_json(msg='Error %s vserver peer relationship on %s: %s' % (action, where, error))
380
381 def vserver_peer_accept_rest(self, target):
382 vserver_peer_info = self.vserver_peer_get_rest('peer')
383 if not vserver_peer_info:
384 self.module.fail_json(msg='Error reading vserver peer information on peer %s' % self.parameters['peer_vserver'])
385 api = 'svm/peers'
386 body = {"state": "peered"}
387 if 'local_name_for_source' in self.parameters:
388 body['name'] = self.parameters['local_name_for_source']
389 dummy, error = rest_generic.patch_async(self.dst_rest_api, api, vserver_peer_info['local_peer_vserver_uuid'], body)
390 self.check_and_report_rest_error(error, 'accepting', self.parameters['peer_vserver'])
391
392 def vserver_peer_get_rest(self, target):
393 """
394 Get current vserver peer info
395 :return: Dictionary of current vserver peer details if query successful, else return None
396 """
397 api = 'svm/peers'
398 vserver_info = {}
399 vserver, remote_vserver = self.get_local_and_peer_vserver(target)
400 restapi = self.rest_api if target == 'source' else self.dst_rest_api
401 options = {
402 'svm.name': vserver,
403 'peer.svm.name': remote_vserver,
404 'fields': 'name,svm.name,peer.svm.name,peer.cluster.name,state,uuid'
405 }
406 if target == 'peer':
407 if self.peer_relation_uuid is not None:
408 options['uuid'] = self.peer_relation_uuid
409 else:
410 if 'peer_cluster' in self.parameters:
411 options['peer.cluster.name'] = self.parameters['peer_cluster']
412 else:
413 self.module.fail_json(msg='The peer_cluster parameter is required for source vserver queries to find exact matching record in REST API mode.')
414
415 record, error = rest_generic.get_one_record(restapi, api, options)
416 if error:
417 self.module.fail_json(msg='Error fetching vserver peer %s: %s' % (self.parameters['vserver'], error))
418 if record is not None:
419 vserver_info['vserver'] = self.na_helper.safe_get(record, ['svm', 'name'])
420 vserver_info['peer_vserver'] = self.na_helper.safe_get(record, ['peer', 'svm', 'name'])
421 vserver_info['peer_state'] = record.get('state')
422 # required local_peer_vserver_uuid to delete the peer relationship
423 vserver_info['local_peer_vserver_uuid'] = record.get('uuid')
424 vserver_info['local_peer_vserver'] = record['name']
425 return vserver_info
426 return None
427
428 def vserver_peer_delete_rest(self, current):
429 """
430 Delete a vserver peer using rest.
431 """
432 dummy, error = rest_generic.delete_async(self.rest_api, 'svm/peers', current['local_peer_vserver_uuid'])
433 self.check_and_report_rest_error(error, 'deleting', self.parameters['vserver'])
434
435 def get_peer_cluster_name_rest(self):
436 """
437 Get local cluster name
438 :return: cluster name
439 """
440 api = 'cluster'
441 options = {'fields': 'name'}
442 # if remote peer exist , get remote cluster name else local cluster name
443 restapi = self.dst_rest_api if self.is_remote_peer() else self.rest_api
444 record, error = rest_generic.get_one_record(restapi, api, options)
445 if error:
446 self.module.fail_json(msg='Error fetching peer cluster name for peer vserver %s: %s'
447 % (self.parameters['peer_vserver'], error))
448 if record is not None:
449 return record.get('name')
450 return None
451
452 def vserver_peer_create_rest(self):
453 """
454 Create a vserver peer using rest
455 """
456 api = 'svm/peers'
457 query = {'return_records': 'true'}
458 body = {
459 'svm.name': self.parameters['vserver'],
460 'peer.cluster.name': self.parameters['peer_cluster'],
461 'peer.svm.name': self.parameters['peer_vserver'],
462 'applications': self.parameters['applications']
463 }
464 if 'local_name_for_peer' in self.parameters:
465 body['name'] = self.parameters['local_name_for_peer']
466 record, error = rest_generic.post_async(self.rest_api, api, body, query)
467 self.check_and_report_rest_error(error, 'creating', self.parameters['vserver'])
468 if record.get('records') is not None:
469 self.peer_relation_uuid = record['records'][0].get('uuid')
470
471 def apply(self):
472 """
473 Apply action to create/delete or accept vserver peer
474 """
475 current = self.vserver_peer_get()
476 cd_action = self.na_helper.get_cd_action(current, self.parameters)
477 if self.na_helper.changed and not self.module.check_mode:
478 if cd_action == 'create':
479 self.vserver_peer_create()
480 # accept only if the peer relationship is on a remote cluster
481 if self.is_remote_peer():
482 self.vserver_peer_accept()
483 elif cd_action == 'delete':
484 self.vserver_peer_delete(current)
485 result = netapp_utils.generate_result(self.na_helper.changed, cd_action)
486 self.module.exit_json(**result)
487
488
489 def main():
490 """Execute action"""
491 module_obj = NetAppONTAPVserverPeer()
492 module_obj.apply()
493
494
495 if __name__ == '__main__':
496 main()