VMware: refactor vmware_datacenter (#36214)

Signed-off-by: Abhijeet Kasurde <akasurde@redhat.com>

lib/ansible/modules/cloud/vmware/vmware_datacenter.py

@@ -1,55 +1,44 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
-
 # Copyright: (c) 2015, Joseph Callen <jcallen () csc.com>
+# Copyright: (c) 2018, Ansible Project
 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 from __future__ import absolute_import, division, print_function
 __metaclass__ = type
 
-ANSIBLE_METADATA = {'metadata_version': '1.1',
+ANSIBLE_METADATA = {
-                    'status': ['preview'],
+    'metadata_version': '1.1',
-                    'supported_by': 'community'}
+    'status': ['preview'],
+    'supported_by': 'community'
+}
+
 
 DOCUMENTATION = '''
 ---
 module: vmware_datacenter
 short_description: Manage VMware vSphere Datacenters
 description:
-    - Manage VMware vSphere Datacenters
+    - This module can be used to manage (create, delete) VMware vSphere Datacenters.
 version_added: 2.0
 author:
 - Joseph Callen (@jcpowermac)
 - Kamil Szczygiel (@kamsz)
 notes:
-    - Tested on vSphere 6.0
+    - Tested on vSphere 6.0, 6.5
 requirements:
     - "python >= 2.6"
     - PyVmomi
 options:
-    hostname:
-        description:
-            - The hostname or IP address of the vSphere vCenter API server
-        required: True
-    username:
-        description:
-            - The username of the vSphere vCenter
-        required: True
-        aliases: ['user', 'admin']
-    password:
-        description:
-            - The password of the vSphere vCenter
-        required: True
-        aliases: ['pass', 'pwd']
     datacenter_name:
-        description:
+      description:
-            - The name of the datacenter the cluster will be created in.
+      - The name of the datacenter the cluster will be created in.
-        required: True
+      required: True
     state:
-        description:
+      description:
-            - If the datacenter should be present or absent
+      - If the datacenter should be present or absent.
-        choices: ['present', 'absent']
+      choices: [ present, absent ]
-        default: present
+      default: present
 extends_documentation_fragment: vmware.documentation
 '''
 
@@ -63,77 +52,106 @@ EXAMPLES = '''
     password: vmware
     datacenter_name: "datacenter"
     state: present
+
+- name: Delete Datacenter
+  vmware_datacenter:
+    hostname: vcenter_hostname
+    username: root
+    password: pass
+    datacenter_name: DC2
+    state: absent
+  register: datacenter_delete_result
 '''
 
+RETURN = """#
+"""
+
 try:
     from pyVmomi import vim, vmodl
-    HAS_PYVMOMI = True
 except ImportError:
-    HAS_PYVMOMI = False
+    pass
 
 from ansible.module_utils.basic import AnsibleModule
-from ansible.module_utils.vmware import (HAS_PYVMOMI, connect_to_api, find_datacenter_by_name,
+from ansible.module_utils.vmware import PyVmomi, find_datacenter_by_name, vmware_argument_spec, wait_for_task
-                                         vmware_argument_spec, wait_for_task)
+from ansible.module_utils._text import to_native
 
 
-def get_datacenter(context, module):
+class VmwareDatacenterManager(PyVmomi):
-    try:
+    def __init__(self, module):
-        datacenter_name = module.params.get('datacenter_name')
+        super(VmwareDatacenterManager, self).__init__(module)
-        datacenter = find_datacenter_by_name(context, datacenter_name)
+        self.datacenter_name = self.params.get('datacenter_name')
-        return datacenter
+        self.datacenter_obj = self.get_datacenter()
-    except vmodl.RuntimeFault as runtime_fault:
-        module.fail_json(msg=runtime_fault.msg)
-    except vmodl.MethodFault as method_fault:
-        module.fail_json(msg=method_fault.msg)
 
+    def ensure(self):
+        state = self.module.params.get('state')
 
-def create_datacenter(context, module):
+        if state == 'present':
-    datacenter_name = module.params.get('datacenter_name')
+            self.create_datacenter()
-    folder = context.rootFolder
 
-    try:
+        if state == 'absent':
-        datacenter = get_datacenter(context, module)
+            self.destroy_datacenter()
+
+    def get_datacenter(self):
+        try:
+            datacenter_obj = find_datacenter_by_name(self.content, self.datacenter_name)
+            return datacenter_obj
+        except (vmodl.MethodFault, vmodl.RuntimeFault) as runtime_fault:
+            self.module.fail_json(msg="Failed to get datacenter '%s'"
+                                      " due to : %s" % (self.datacenter_name,
+                                                        to_native(runtime_fault.msg)))
+        except Exception as generic_exc:
+            self.module.fail_json(msg="Failed to get datacenter"
+                                      " '%s' due to generic error: %s" % (self.datacenter_name,
+                                                                          to_native(generic_exc)))
+
+    def create_datacenter(self):
+        folder = self.content.rootFolder
         changed = False
-        if not datacenter:
+        try:
-            changed = True
+            if not self.datacenter_obj and not self.module.check_mode:
-            if not module.check_mode:
+                changed = True
-                folder.CreateDatacenter(name=datacenter_name)
+                folder.CreateDatacenter(name=self.datacenter_name)
-        module.exit_json(changed=changed)
+            self.module.exit_json(changed=changed)
-    except vim.fault.DuplicateName:
+        except vim.fault.DuplicateName as duplicate_name:
-        module.fail_json(msg="A datacenter with the name %s already exists" % datacenter_name)
+            self.module.exit_json(changed=changed)
-    except vim.fault.InvalidName:
+        except vim.fault.InvalidName as invalid_name:
-        module.fail_json(msg="%s is an invalid name for a cluster" % datacenter_name)
+            self.module.fail_json(msg="Specified datacenter name '%s' is an"
-    except vmodl.fault.NotSupported:
+                                      " invalid name : %s" % (self.datacenter_name,
-        # This should never happen
+                                                              to_native(invalid_name.msg)))
-        module.fail_json(msg="Trying to create a datacenter on an incorrect folder object")
+        except vmodl.fault.NotSupported as not_supported:
-    except vmodl.RuntimeFault as runtime_fault:
+            # This should never happen
-        module.fail_json(msg=runtime_fault.msg)
+            self.module.fail_json(msg="Trying to create a datacenter '%s' on"
-    except vmodl.MethodFault as method_fault:
+                                      " an incorrect folder object : %s" % (self.datacenter_name,
-        module.fail_json(msg=method_fault.msg)
+                                                                            to_native(not_supported.msg)))
+        except (vmodl.RuntimeFault, vmodl.MethodFault) as runtime_fault:
+            self.module.fail_json(msg="Failed to create a datacenter"
+                                      " '%s' due to : %s" % (self.datacenter_name,
+                                                             to_native(runtime_fault.msg)))
+        except Exception as generic_exc:
+            self.module.fail_json(msg="Failed to create a datacenter"
+                                      " '%s' due to generic error: %s" % (self.datacenter_name,
+                                                                          to_native(generic_exc)))
 
-
+    def destroy_datacenter(self):
-def destroy_datacenter(context, module):
+        results = dict(changed=False)
-    result = None
+        try:
-
+            if self.datacenter_obj and not self.module.check_mode:
-    try:
+                task = self.datacenter_obj.Destroy_Task()
-        datacenter = get_datacenter(context, module)
-        changed = False
-        if datacenter:
-            changed = True
-            if not module.check_mode:
-                task = datacenter.Destroy_Task()
                 changed, result = wait_for_task(task)
-        module.exit_json(changed=changed, result=result)
+                results['changed'] = changed
-    except vim.fault.VimFault as vim_fault:
+                results['result'] = result
-        module.fail_json(msg=vim_fault.msg)
+            self.module.exit_json(**results)
-    except vmodl.RuntimeFault as runtime_fault:
+        except (vim.fault.VimFault, vmodl.RuntimeFault, vmodl.MethodFault) as runtime_fault:
-        module.fail_json(msg=runtime_fault.msg)
+            self.module.fail_json(msg="Failed to delete a datacenter"
-    except vmodl.MethodFault as method_fault:
+                                      " '%s' due to : %s" % (self.datacenter_name,
-        module.fail_json(msg=method_fault.msg)
+                                                             to_native(runtime_fault.msg)))
+        except Exception as generic_exc:
+            self.module.fail_json(msg="Failed to delete a datacenter"
+                                      " '%s' due to generic error: %s" % (self.datacenter_name,
+                                                                          to_native(generic_exc)))
 
 
 def main():
-
     argument_spec = vmware_argument_spec()
     argument_spec.update(
         dict(
@@ -143,17 +161,8 @@ def main():
     )
     module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True)
 
-    if not HAS_PYVMOMI:
+    vmware_datacenter_mgr = VmwareDatacenterManager(module)
-        module.fail_json(msg='pyvmomi is required for this module')
+    vmware_datacenter_mgr.ensure()
-
-    context = connect_to_api(module)
-    state = module.params.get('state')
-
-    if state == 'present':
-        create_datacenter(context, module)
-
-    if state == 'absent':
-        destroy_datacenter(context, module)
 
 
 if __name__ == '__main__':