Debian Codegraph @

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

raw
1 #!/usr/bin/python
2 """
3 this is ipspace module
4
5 # (c) 2018, NTT Europe Ltd.
6 # (c) 2020-2025, NetApp, Inc
7 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
8 """
9
10 from __future__ import absolute_import, division, print_function
11 __metaclass__ = type
12
13
14 DOCUMENTATION = '''
15 ---
16 module: na_ontap_ipspace
17
18 short_description: NetApp ONTAP Manage an ipspace
19
20 version_added: 2.9.0
21
22 author:
23 - NTTE Storage Engineering (@vicmunoz) <[email protected]>
24
25 description:
26 - Manage an ipspace for an Ontap Cluster
27
28 extends_documentation_fragment:
29 - netapp.ontap.netapp.na_ontap
30
31 options:
32 state:
33 description:
34 - Whether the specified ipspace should exist or not
35 choices: ['present', 'absent']
36 type: str
37 default: present
38 name:
39 description:
40 - The name of the ipspace to manage
41 required: true
42 type: str
43 from_name:
44 description:
45 - Name of the existing ipspace to be renamed to name
46 type: str
47 '''
48
49 EXAMPLES = """
50 - name: Create ipspace
51 netapp.ontap.na_ontap_ipspace:
52 state: present
53 name: ansibleIpspace
54 hostname: "{{ netapp_hostname }}"
55 username: "{{ netapp_username }}"
56 password: "{{ netapp_password }}"
57
58 - name: Delete ipspace
59 netapp.ontap.na_ontap_ipspace:
60 state: absent
61 name: ansibleIpspace
62 hostname: "{{ netapp_hostname }}"
63 username: "{{ netapp_username }}"
64 password: "{{ netapp_password }}"
65
66 - name: Rename ipspace
67 netapp.ontap.na_ontap_ipspace:
68 state: present
69 name: ansibleIpspace_newname
70 from_name: ansibleIpspace
71 hostname: "{{ netapp_hostname }}"
72 username: "{{ netapp_username }}"
73 password: "{{ netapp_password }}"
74 """
75
76 RETURN = """
77 """
78
79 import traceback
80
81 from ansible.module_utils.basic import AnsibleModule
82 from ansible.module_utils._text import to_native
83 import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils
84 from ansible_collections.netapp.ontap.plugins.module_utils.netapp_module import NetAppModule
85 from ansible_collections.netapp.ontap.plugins.module_utils import rest_generic
86
87
88 class NetAppOntapIpspace(object):
89 '''Class with ipspace operations'''
90
91 def __init__(self):
92 self.use_rest = False
93 self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
94 self.argument_spec.update(dict(
95 state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
96 name=dict(required=True, type='str'),
97 from_name=dict(required=False, type='str'),
98 ))
99 self.module = AnsibleModule(
100 argument_spec=self.argument_spec,
101 supports_check_mode=True
102 )
103 self.uuid = None
104 self.na_helper = NetAppModule()
105 self.parameters = self.na_helper.set_parameters(self.module.params)
106
107 self.rest_api = netapp_utils.OntapRestAPI(self.module)
108 self.use_rest = self.rest_api.is_rest()
109 if not self.use_rest:
110 if not netapp_utils.has_netapp_lib():
111 self.module.fail_json(msg=netapp_utils.netapp_lib_is_required())
112 self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
113
114 def ipspace_get_iter(self, name):
115 """
116 Return net-ipspaces-get-iter query results
117 :param name: Name of the ipspace
118 :return: NaElement if ipspace found, None otherwise
119 """
120 ipspace_get_iter = netapp_utils.zapi.NaElement('net-ipspaces-get-iter')
121 query_details = netapp_utils.zapi.NaElement.create_node_with_children(
122 'net-ipspaces-info', **{'ipspace': name})
123 query = netapp_utils.zapi.NaElement('query')
124 query.add_child_elem(query_details)
125 ipspace_get_iter.add_child_elem(query)
126 try:
127 result = self.server.invoke_successfully(
128 ipspace_get_iter, enable_tunneling=False)
129 except netapp_utils.zapi.NaApiError as error:
130 # Error 14636 denotes an ipspace does not exist
131 # Error 13073 denotes an ipspace not found
132 if to_native(error.code) == "14636" or to_native(error.code) == "13073":
133 return None
134 self.module.fail_json(
135 msg="Error getting ipspace %s: %s" % (name, to_native(error)),
136 exception=traceback.format_exc())
137 return result
138
139 def get_ipspace(self, name=None):
140 """
141 Fetch details if ipspace exists
142 :param name: Name of the ipspace to be fetched
143 :return:
144 Dictionary of current details if ipspace found
145 None if ipspace is not found
146 """
147 if name is None:
148 name = self.parameters['name']
149 if self.use_rest:
150 api = 'network/ipspaces'
151 query = {'name': name, 'fields': 'uuid'}
152 record, error = rest_generic.get_one_record(self.rest_api, api, query)
153 if error:
154 self.module.fail_json(msg="Error getting ipspace %s: %s" % (name, error))
155 if record:
156 self.uuid = record['uuid']
157 return record
158 return None
159 else:
160 ipspace_get = self.ipspace_get_iter(name)
161 if (ipspace_get and ipspace_get.get_child_by_name('num-records') and
162 int(ipspace_get.get_child_content('num-records')) >= 1):
163 current_ipspace = dict()
164 attr_list = ipspace_get.get_child_by_name('attributes-list')
165 attr = attr_list.get_child_by_name('net-ipspaces-info')
166 current_ipspace['name'] = attr.get_child_content('ipspace')
167 return current_ipspace
168 return None
169
170 def create_ipspace(self):
171 """
172 Create ipspace
173 :return: None
174 """
175 if self.use_rest:
176 api = 'network/ipspaces'
177 body = {'name': self.parameters['name']}
178 dummy, error = rest_generic.post_async(self.rest_api, api, body)
179 if error:
180 self.module.fail_json(msg="Error provisioning ipspace %s: %s" % (self.parameters['name'], error))
181 else:
182 ipspace_create = netapp_utils.zapi.NaElement.create_node_with_children(
183 'net-ipspaces-create', **{'ipspace': self.parameters['name']})
184 try:
185 self.server.invoke_successfully(ipspace_create,
186 enable_tunneling=False)
187 except netapp_utils.zapi.NaApiError as error:
188 self.module.fail_json(
189 msg="Error provisioning ipspace %s: %s" % (
190 self.parameters['name'],
191 to_native(error)),
192 exception=traceback.format_exc())
193
194 def delete_ipspace(self):
195 """
196 Destroy ipspace
197 :return: None
198 """
199 if self.use_rest:
200 api = 'network/ipspaces'
201 dummy, error = rest_generic.delete_async(self.rest_api, api, self.uuid)
202 if error:
203 self.module.fail_json(msg="Error removing ipspace %s: %s" % (self.parameters['name'], error))
204 else:
205 ipspace_destroy = netapp_utils.zapi.NaElement.create_node_with_children(
206 'net-ipspaces-destroy',
207 **{'ipspace': self.parameters['name']})
208 try:
209 self.server.invoke_successfully(
210 ipspace_destroy, enable_tunneling=False)
211 except netapp_utils.zapi.NaApiError as error:
212 self.module.fail_json(
213 msg="Error removing ipspace %s: %s" % (
214 self.parameters['name'],
215 to_native(error)),
216 exception=traceback.format_exc())
217
218 def rename_ipspace(self):
219 """
220 Rename an ipspace
221 :return: Nothing
222 """
223 if self.use_rest:
224 api = 'network/ipspaces'
225 body = {'name': self.parameters['name']}
226 dummy, error = rest_generic.patch_async(self.rest_api, api, self.uuid, body)
227 if error:
228 self.module.fail_json(msg="Error renaming ipspace %s: %s" % (self.parameters['from_name'], error))
229 else:
230 ipspace_rename = netapp_utils.zapi.NaElement.create_node_with_children(
231 'net-ipspaces-rename',
232 **{'ipspace': self.parameters['from_name'],
233 'new-name': self.parameters['name']})
234 try:
235 self.server.invoke_successfully(ipspace_rename,
236 enable_tunneling=False)
237 except netapp_utils.zapi.NaApiError as error:
238 self.module.fail_json(
239 msg="Error renaming ipspace %s: %s" % (
240 self.parameters['from_name'],
241 to_native(error)),
242 exception=traceback.format_exc())
243
244 def apply(self):
245 """
246 Apply action to the ipspace
247 :return: Nothing
248 """
249 current = self.get_ipspace()
250 # rename and create are mutually exclusive
251 rename, modify = None, None
252 cd_action = self.na_helper.get_cd_action(current, self.parameters)
253 if cd_action == 'create' and self.parameters.get('from_name'):
254 rename = self.na_helper.is_rename_action(
255 self.get_ipspace(self.parameters['from_name']),
256 current)
257 if rename is None:
258 self.module.fail_json(
259 msg="Error renaming: ipspace %s does not exist" %
260 self.parameters['from_name'])
261 # reset cd_action to None and add name to modify to indicate rename.
262 cd_action = None
263 modify = {'name': self.parameters['name']}
264
265 if self.na_helper.changed and not self.module.check_mode:
266 if rename:
267 self.rename_ipspace()
268 elif cd_action == 'create':
269 self.create_ipspace()
270 elif cd_action == 'delete':
271 self.delete_ipspace()
272 result = netapp_utils.generate_result(self.na_helper.changed, cd_action, modify)
273 self.module.exit_json(**result)
274
275
276 def main():
277 """
278 Execute action
279 :return: nothing
280 """
281 obj = NetAppOntapIpspace()
282 obj.apply()
283
284
285 if __name__ == '__main__':
286 main()