1#!/usr/local/bin/python3.8
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
6from __future__ import absolute_import, division, print_function
7__metaclass__ = type
8
9DOCUMENTATION = """
10module: na_ontap_fpolicy_status
11short_description: NetApp ONTAP - Enables or disables the specified fPolicy policy
12extends_documentation_fragment:
13    - netapp.ontap.netapp.na_ontap
14version_added: '21.4.0'
15author: NetApp Ansible Team (@carchi8py) <ng-ansibleteam@netapp.com>
16description:
17- Enable or disable fPolicy policy.
18options:
19  state:
20    description:
21    - Whether the fPolicy policy is enabled or disabled.
22    choices: ['present', 'absent']
23    default: present
24    type: str
25
26  vserver:
27    description:
28    - Name of the vserver to enable fPolicy on.
29    type: str
30    required: true
31
32  policy_name:
33    description:
34    - Name of the policy.
35    type: str
36    required: true
37
38  sequence_number:
39    description:
40    - Policy Sequence Number.
41    type: int
42
43notes:
44- Not support check_mode.
45"""
46
47EXAMPLES = """
48    - name: Enable fPolicy policy
49      na_ontap_fpolicy_status:
50        state: present
51        vserver: svm1
52        policy_name: fpolicy_policy
53        sequence_number: 10
54        username: "{{ username }}"
55        password: "{{ password }}"
56        hostname: "{{ hostname }}"
57        https: true
58        validate_certs: false
59
60    - name: Disable fPolicy policy
61      na_ontap_fpolicy_status:
62        state: absent
63        vserver: svm1
64        policy_name: fpolicy_policy
65        username: "{{ username }}"
66        password: "{{ password }}"
67        hostname: "{{ hostname }}"
68        https: true
69        validate_certs: false
70
71"""
72
73RETURN = """ # """
74
75import traceback
76
77from ansible.module_utils.basic import AnsibleModule
78from ansible.module_utils._text import to_native
79import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils
80from ansible_collections.netapp.ontap.plugins.module_utils.netapp_module import NetAppModule
81from ansible_collections.netapp.ontap.plugins.module_utils.netapp import OntapRestAPI
82import ansible_collections.netapp.ontap.plugins.module_utils.rest_response_helpers as rrh
83
84HAS_NETAPP_LIB = netapp_utils.has_netapp_lib()
85
86
87class NetAppOntapFpolicyStatus(object):
88    """
89        Enables or disabled NetApp ONTAP fPolicy
90    """
91    def __init__(self):
92        """
93            Initialize the ONTAP fPolicy status class
94        """
95        self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
96        self.argument_spec.update(dict(
97            state=dict(required=False, choices=['present', 'absent'], default='present'),
98            vserver=dict(required=True, type='str'),
99            policy_name=dict(required=True, type='str'),
100            sequence_number=dict(required=False, type='int')
101        ))
102
103        self.module = AnsibleModule(
104            argument_spec=self.argument_spec,
105            required_if=[('state', 'present', ['sequence_number'])],
106            supports_check_mode=True
107        )
108
109        # set up variables
110        self.na_helper = NetAppModule()
111        self.parameters = self.na_helper.set_parameters(self.module.params)
112        if self.parameters['state'] == 'present':
113            self.parameters['status'] = True
114        else:
115            self.parameters['status'] = False
116
117        self.rest_api = OntapRestAPI(self.module)
118        self.use_rest = self.rest_api.is_rest()
119
120        if not self.use_rest:
121            if HAS_NETAPP_LIB is False:
122                self.module.fail_json(msg="the python NetApp-Lib module is required")
123            else:
124                self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
125
126    def get_fpolicy_policy_status(self):
127        """
128        Check to see the status of the fPolicy policy
129        :return: dict of status properties
130        """
131        return_value = None
132
133        if self.use_rest:
134            api = '/protocols/fpolicy'
135            query = {
136                'svm.name': self.parameters['vserver'],
137                'fields': 'policies'
138            }
139
140            message, error = self.rest_api.get(api, query)
141            if error:
142                self.module.fail_json(msg=error)
143            records, error = rrh.check_for_0_or_more_records(api, message, error)
144            if records is not None:
145                for policy in records[0]['policies']:
146                    if policy['name'] == self.parameters['policy_name']:
147                        return_value = {}
148                        return_value['vserver'] = records[0]['svm']['name']
149                        return_value['policy_name'] = policy['name']
150                        return_value['status'] = policy['enabled']
151                        break
152            if not return_value:
153                self.module.fail_json(msg='Error getting fPolicy policy %s for vserver %s as policy does not exist' %
154                                          (self.parameters['policy_name'], self.parameters['vserver']))
155            return return_value
156
157        else:
158
159            fpolicy_status_obj = netapp_utils.zapi.NaElement('fpolicy-policy-status-get-iter')
160            fpolicy_status_info = netapp_utils.zapi.NaElement('fpolicy-policy-status-info')
161            fpolicy_status_info.add_new_child('policy-name', self.parameters['policy_name'])
162            fpolicy_status_info.add_new_child('vserver', self.parameters['vserver'])
163            query = netapp_utils.zapi.NaElement('query')
164            query.add_child_elem(fpolicy_status_info)
165            fpolicy_status_obj.add_child_elem(query)
166
167            try:
168                result = self.server.invoke_successfully(fpolicy_status_obj, True)
169
170            except netapp_utils.zapi.NaApiError as error:
171                self.module.fail_json(msg='Error getting status for fPolicy policy %s for vserver %s: %s' %
172                                          (self.parameters['policy_name'], self.parameters['vserver'], to_native(error)),
173                                      exception=traceback.format_exc())
174
175            if result.get_child_by_name('attributes-list'):
176                fpolicy_status_attributes = result['attributes-list']['fpolicy-policy-status-info']
177
178                return_value = {
179                    'vserver': fpolicy_status_attributes.get_child_content('vserver'),
180                    'policy_name': fpolicy_status_attributes.get_child_content('policy-name'),
181                    'status': self.na_helper.get_value_for_bool(True, fpolicy_status_attributes.get_child_content('status')),
182                }
183            return return_value
184
185    def get_svm_uuid(self):
186        """
187        Gets SVM uuid based on name
188        :return: string of uuid
189        """
190        api = '/svm/svms'
191        query = {
192            'name': self.parameters['vserver']
193        }
194        message, error = self.rest_api.get(api, query)
195
196        if error:
197            self.module.fail_json(msg=error)
198
199        return message['records'][0]['uuid']
200
201    def enable_fpolicy_policy(self):
202        """
203        Enables fPolicy policy
204        :return: nothing
205        """
206
207        if self.use_rest:
208            api = '/protocols/fpolicy/%s/policies/%s' % (self.svm_uuid, self.parameters['policy_name'])
209            body = dict()
210            body = {
211                'enabled': self.parameters['status'],
212                'priority': self.parameters['sequence_number']
213            }
214
215            dummy, error = self.rest_api.patch(api, body)
216            if error:
217                self.module.fail_json(msg=error)
218
219        else:
220            fpolicy_enable_obj = netapp_utils.zapi.NaElement('fpolicy-enable-policy')
221            fpolicy_enable_obj.add_new_child('policy-name', self.parameters['policy_name'])
222            fpolicy_enable_obj.add_new_child('sequence-number', self.na_helper.get_value_for_int(False, self.parameters['sequence_number']))
223            try:
224                self.server.invoke_successfully(fpolicy_enable_obj, True)
225            except netapp_utils.zapi.NaApiError as error:
226                self.module.fail_json(msg='Error enabling fPolicy policy %s on vserver %s: %s' %
227                                          (self.parameters['policy_name'], self.parameters['vserver'], to_native(error)),
228                                      exception=traceback.format_exc())
229
230    def disable_fpolicy_policy(self):
231        """
232        Disables fPolicy policy
233        :return: nothing
234        """
235
236        if self.use_rest:
237            api = '/protocols/fpolicy/%s/policies/%s' % (self.svm_uuid, self.parameters['policy_name'])
238            body = dict()
239            body = {
240                'enabled': self.parameters['status']
241            }
242
243            dummy, error = self.rest_api.patch(api, body)
244            if error:
245                self.module.fail_json(msg=error)
246
247        else:
248
249            fpolicy_disable_obj = netapp_utils.zapi.NaElement('fpolicy-disable-policy')
250            fpolicy_disable_obj.add_new_child('policy-name', self.parameters['policy_name'])
251
252            try:
253                self.server.invoke_successfully(fpolicy_disable_obj, True)
254            except netapp_utils.zapi.NaApiError as error:
255                self.module.fail_json(msg='Error disabling fPolicy policy %s on vserver %s: %s' %
256                                          (self.parameters['policy_name'], self.parameters['vserver'], to_native(error)),
257                                      exception=traceback.format_exc())
258
259    def apply(self):
260
261        if self.use_rest:
262            self.svm_uuid = self.get_svm_uuid()
263        else:
264            netapp_utils.ems_log_event("na_ontap_fpolicy_status", self.server)
265
266        current = self.get_fpolicy_policy_status()
267        modify = self.na_helper.get_modified_attributes(current, self.parameters)
268
269        if self.na_helper.changed:
270            if not self.module.check_mode:
271                if modify['status']:
272                    self.enable_fpolicy_policy()
273                elif not modify['status']:
274                    self.disable_fpolicy_policy()
275
276        self.module.exit_json(changed=self.na_helper.changed)
277
278
279def main():
280    """
281    Enables or disables NetApp ONTAP fPolicy
282    """
283    command = NetAppOntapFpolicyStatus()
284    command.apply()
285
286
287if __name__ == '__main__':
288    main()
289