Debian Codegraph @

ansible_collections/netapp/cloudmanager/plugins/modules/na_cloudmanager_aggregate.py

raw
1 #!/usr/bin/python
2
3 # (c) 2021, 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_cloudmanager_aggregate
8 '''
9
10 from __future__ import absolute_import, division, print_function
11
12 __metaclass__ = type
13
14 DOCUMENTATION = '''
15
16 module: na_cloudmanager_aggregate
17 short_description: NetApp Cloud Manager Aggregate
18 extends_documentation_fragment:
19 - netapp.cloudmanager.netapp.cloudmanager
20 version_added: '21.3.0'
21 author: NetApp Ansible Team (@carchi8py) <[email protected]>
22
23 description:
24 - Create, Modify or Delete Aggregate on Cloud Manager.
25
26 options:
27 state:
28 description:
29 - Whether the specified aggregate should exist or not.
30 choices: ['present', 'absent']
31 required: true
32 type: str
33
34 name:
35 description:
36 - The name of the new aggregate.
37 required: true
38 type: str
39
40 working_environment_name:
41 description:
42 - The working environment name where the aggregate will be created.
43 type: str
44
45 working_environment_id:
46 description:
47 - The public ID of the working environment where the aggregate will be created.
48 type: str
49
50 client_id:
51 description:
52 - The connector ID of the Cloud Manager Connector.
53 required: true
54 type: str
55
56 number_of_disks:
57 description:
58 - The required number of disks in the new aggregate.
59 type: int
60
61 disk_size_size:
62 description:
63 - The required size of the disks.
64 type: int
65
66 disk_size_unit:
67 description:
68 - The disk size unit ['GB' or 'TB']. The default is 'TB'.
69 choices: ['GB', 'TB']
70 default: 'TB'
71 type: str
72
73 home_node:
74 description:
75 - The home node that the new aggregate should belong to.
76 type: str
77
78 provider_volume_type:
79 description:
80 - The cloud provider volume type.
81 type: str
82
83 capacity_tier:
84 description:
85 - The aggregate's capacity tier for tiering cold data to object storage.
86 - If the value is NONE, the capacity_tier will not be set on aggregate creation.
87 choices: [ 'NONE', 'S3', 'Blob', 'cloudStorage']
88 type: str
89
90 iops:
91 description:
92 - Provisioned IOPS. Needed only when providerVolumeType is "io1".
93 type: int
94
95 throughput:
96 description:
97 - Unit is Mb/s. Valid range 125-1000.
98 - Required only when provider_volume_type is 'gp3'.
99 type: int
100
101 notes:
102 - Support check_mode.
103 '''
104
105 EXAMPLES = '''
106 - name: Create Aggregate
107 netapp.cloudmanager.na_cloudmanager_aggregate:
108 state: present
109 name: AnsibleAggregate
110 working_environment_name: testAWS
111 client_id: "{{ client_id }}"
112 number_of_disks: 2
113 refresh_token: xxx
114
115 - name: Delete Volume
116 netapp.cloudmanager.na_cloudmanager_aggregate:
117 state: absent
118 name: AnsibleAggregate
119 working_environment_name: testAWS
120 client_id: "{{ client_id }}"
121 refresh_token: xxx
122 '''
123
124 RETURN = '''
125 msg:
126 description: Success message.
127 returned: success
128 type: str
129 sample: "Aggregate Created"
130 '''
131
132 from ansible.module_utils.basic import AnsibleModule
133 import ansible_collections.netapp.cloudmanager.plugins.module_utils.netapp as netapp_utils
134 from ansible_collections.netapp.cloudmanager.plugins.module_utils.netapp_module import NetAppModule
135 from ansible_collections.netapp.cloudmanager.plugins.module_utils.netapp import CloudManagerRestAPI
136
137
138 class NetAppCloudmanagerAggregate(object):
139 '''
140 Contains methods to parse arguments,
141 derive details of CloudmanagerAggregate objects
142 and send requests to CloudmanagerAggregate via
143 the restApi
144 '''
145
146 def __init__(self):
147 '''
148 Parse arguments, setup state variables,
149 check parameters and ensure request module is installed
150 '''
151 self.argument_spec = netapp_utils.cloudmanager_host_argument_spec()
152 self.argument_spec.update(dict(
153 state=dict(required=True, choices=['present', 'absent']),
154 name=dict(required=True, type='str'),
155 working_environment_id=dict(required=False, type='str'),
156 working_environment_name=dict(required=False, type='str'),
157 client_id=dict(required=True, type='str'),
158 number_of_disks=dict(required=False, type='int'),
159 disk_size_size=dict(required=False, type='int'),
160 disk_size_unit=dict(required=False, choices=['GB', 'TB'], default='TB'),
161 home_node=dict(required=False, type='str'),
162 provider_volume_type=dict(required=False, type='str'),
163 capacity_tier=dict(required=False, choices=['NONE', 'S3', 'Blob', 'cloudStorage'], type='str'),
164 iops=dict(required=False, type='int'),
165 throughput=dict(required=False, type='int'),
166 ))
167
168 self.module = AnsibleModule(
169 argument_spec=self.argument_spec,
170 required_one_of=[
171 ['refresh_token', 'sa_client_id'],
172 ['working_environment_name', 'working_environment_id'],
173 ],
174 required_together=[['sa_client_id', 'sa_secret_key']],
175 required_if=[
176 ['provider_volume_type', 'gp3', ['iops', 'throughput']],
177 ['provider_volume_type', 'io1', ['iops']],
178 ],
179 supports_check_mode=True
180 )
181
182 self.na_helper = NetAppModule()
183 # set up state variables
184 self.parameters = self.na_helper.set_parameters(self.module.params)
185 # Calling generic rest_api class
186 self.rest_api = CloudManagerRestAPI(self.module)
187 self.rest_api.url += self.rest_api.environment_data['CLOUD_MANAGER_HOST']
188 self.rest_api.api_root_path = None
189 self.headers = {
190 'X-Agent-Id': self.rest_api.format_client_id(self.parameters['client_id'])
191 }
192
193 def get_aggregate(self):
194 '''
195 Get aggregate details
196 '''
197 working_environment_detail = None
198 if 'working_environment_id' in self.parameters:
199 working_environment_detail, error = self.na_helper.get_working_environment_details(self.rest_api, self.headers)
200 if error is not None:
201 self.module.fail_json(msg="Error: Cannot find working environment: %s" % str(error))
202 elif 'working_environment_name' in self.parameters:
203 working_environment_detail, error = self.na_helper.get_working_environment_details_by_name(self.rest_api,
204 self.headers,
205 self.parameters['working_environment_name'])
206 if error is not None:
207 self.module.fail_json(msg="Error: Cannot find working environment: %s" % str(error))
208 else:
209 self.module.fail_json(msg="Error: Missing working environment information")
210 if working_environment_detail is not None:
211 self.parameters['working_environment_id'] = working_environment_detail['publicId']
212 self.na_helper.set_api_root_path(working_environment_detail, self.rest_api)
213 api_root_path = self.rest_api.api_root_path
214
215 if working_environment_detail['cloudProviderName'] != "Amazon":
216 api = '%s/aggregates/%s' % (api_root_path, working_environment_detail['publicId'])
217 else:
218 api = '%s/aggregates?workingEnvironmentId=%s' % (api_root_path, working_environment_detail['publicId'])
219 response, error, dummy = self.rest_api.get(api, header=self.headers)
220 if error:
221 self.module.fail_json(msg="Error: Failed to get aggregate list: %s, %s" % (str(error), str(response)))
222 for aggr in response:
223 if aggr['name'] == self.parameters['name']:
224 return aggr
225 return None
226
227 def create_aggregate(self):
228 '''
229 Create aggregate
230 '''
231 api = '%s/aggregates' % self.rest_api.api_root_path
232 # check if all the required parameters exist
233 body = {
234 'name': self.parameters['name'],
235 'workingEnvironmentId': self.parameters['working_environment_id'],
236 'numberOfDisks': self.parameters['number_of_disks'],
237 'diskSize': {'size': self.parameters['disk_size_size'],
238 'unit': self.parameters['disk_size_unit']},
239 }
240 # optional parameters
241 if 'home_node' in self.parameters:
242 body['homeNode'] = self.parameters['home_node']
243 if 'provider_volume_type' in self.parameters:
244 body['providerVolumeType'] = self.parameters['provider_volume_type']
245 if 'capacity_tier' in self.parameters and self.parameters['capacity_tier'] != "NONE":
246 body['capacityTier'] = self.parameters['capacity_tier']
247 if 'iops' in self.parameters:
248 body['iops'] = self.parameters['iops']
249 if 'throughput' in self.parameters:
250 body['throughput'] = self.parameters['throughput']
251 response, error, dummy = self.rest_api.post(api, body, header=self.headers)
252 if error is not None:
253 self.module.fail_json(msg="Error: unexpected response on aggregate creation: %s, %s" % (str(error), str(response)))
254
255 def update_aggregate(self, add_number_of_disks):
256 '''
257 Update aggregate with aggregate name and the parameters number_of_disks will be added
258 '''
259 api = '%s/aggregates/%s/%s/disks' % (self.rest_api.api_root_path, self.parameters['working_environment_id'],
260 self.parameters['name'])
261 body = {
262 'aggregateName': self.parameters['name'],
263 'workingEnvironmentId': self.parameters['working_environment_id'],
264 'numberOfDisks': add_number_of_disks
265 }
266 response, error, dummy = self.rest_api.post(api, body, header=self.headers)
267 if error is not None:
268 self.module.fail_json(msg="Error: unexpected response on aggregate adding disks: %s, %s" % (str(error), str(response)))
269
270 def delete_aggregate(self):
271 '''
272 Delete aggregate with aggregate name
273 '''
274 api = '%s/aggregates/%s/%s' % (self.rest_api.api_root_path, self.parameters['working_environment_id'],
275 self.parameters['name'])
276 body = {
277 'aggregateName': self.parameters['name'],
278 'workingEnvironmentId': self.parameters['working_environment_id'],
279 }
280 response, error, dummy = self.rest_api.delete(api, body, header=self.headers)
281 if error is not None:
282 self.module.fail_json(msg="Error: unexpected response on aggregate deletion: %s, %s" % (str(error), str(response)))
283
284 def apply(self):
285 '''
286 Check, process and initiate aggregate operation
287 '''
288 # check if aggregate exists
289 current = self.get_aggregate()
290 # check the action
291 cd_action = self.na_helper.get_cd_action(current, self.parameters)
292 if self.na_helper.changed:
293 action = cd_action + "_aggregate"
294 have_all_required, missed_params = self.na_helper.have_required_parameters(action)
295 if not have_all_required:
296 self.module.fail_json(msg="Error: Missing required parameters (%s) on %s" % (str(missed_params), action))
297 add_disks = 0
298 if current and self.parameters['state'] != 'absent':
299 have_all_required, missed_params = self.na_helper.have_required_parameters("update_aggregate")
300 if not have_all_required:
301 self.module.fail_json(msg="Error: Missing required parameters (%s) on update_aggregate" % str(missed_params))
302 if len(current['disks']) < self.parameters['number_of_disks']:
303 add_disks = self.parameters['number_of_disks'] - len(current['disks'])
304 self.na_helper.changed = True
305 elif len(current['disks']) > self.parameters['number_of_disks']:
306 self.module.fail_json(msg="Error: Only add disk support. number_of_disks cannot be reduced")
307
308 result_message = ""
309 if self.na_helper.changed and not self.module.check_mode:
310 if cd_action == "create":
311 self.create_aggregate()
312 result_message = "Aggregate Created"
313 elif cd_action == "delete":
314 self.delete_aggregate()
315 result_message = "Aggregate Deleted"
316 else: # modify
317 self.update_aggregate(add_disks)
318 result_message = "Aggregate Updated"
319 self.module.exit_json(changed=self.na_helper.changed, msg=result_message)
320
321
322 def main():
323 '''
324 Create NetAppCloudmanagerAggregate class instance and invoke apply
325 :return: None
326 '''
327 na_cloudmanager_aggregate = NetAppCloudmanagerAggregate()
328 na_cloudmanager_aggregate.apply()
329
330
331 if __name__ == '__main__':
332 main()