Initial commit

plugins/modules/cloud/kubevirt/kubevirt_vm.py

@@ -0,0 +1,473 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Copyright: (c) 2019, 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',
+                    'status': ['preview'],
+                    'supported_by': 'community'}
+
+DOCUMENTATION = '''
+---
+module: kubevirt_vm
+
+short_description: Manage KubeVirt virtual machine
+
+description:
+    - Use Openshift Python SDK to manage the state of KubeVirt virtual machines.
+
+
+author: KubeVirt Team (@kubevirt)
+
+options:
+    state:
+        description:
+            - Set the virtual machine to either I(present), I(absent), I(running) or I(stopped).
+            - "I(present) - Create or update a virtual machine. (And run it if it's ephemeral.)"
+            - "I(absent) - Remove a virtual machine."
+            - "I(running) - Create or update a virtual machine and run it."
+            - "I(stopped) - Stop a virtual machine. (This deletes ephemeral VMs.)"
+        default: "present"
+        choices:
+            - present
+            - absent
+            - running
+            - stopped
+        type: str
+    name:
+        description:
+            - Name of the virtual machine.
+        required: true
+        type: str
+    namespace:
+        description:
+            - Namespace where the virtual machine exists.
+        required: true
+        type: str
+    ephemeral:
+        description:
+            - If (true) ephemeral virtual machine will be created. When destroyed it won't be accessible again.
+            - Works only with C(state) I(present) and I(absent).
+        type: bool
+        default: false
+    datavolumes:
+        description:
+            - "DataVolumes are a way to automate importing virtual machine disks onto pvcs during the virtual machine's
+               launch flow. Without using a DataVolume, users have to prepare a pvc with a disk image before assigning
+               it to a VM or VMI manifest. With a DataVolume, both the pvc creation and import is automated on behalf of the user."
+        type: list
+    template:
+        description:
+            - "Name of Template to be used in creation of a virtual machine."
+        type: str
+    template_parameters:
+        description:
+            - "New values of parameters from Template."
+        type: dict
+
+extends_documentation_fragment:
+- community.kubernetes.k8s_auth_options
+- community.general.kubevirt_vm_options
+- community.general.kubevirt_common_options
+
+
+requirements:
+  - python >= 2.7
+  - openshift >= 0.8.2
+'''
+
+EXAMPLES = '''
+- name: Start virtual machine 'myvm'
+  kubevirt_vm:
+      state: running
+      name: myvm
+      namespace: vms
+
+- name: Create virtual machine 'myvm' and start it
+  kubevirt_vm:
+      state: running
+      name: myvm
+      namespace: vms
+      memory: 64Mi
+      cpu_cores: 1
+      bootloader: efi
+      smbios_uuid: 5d307ca9-b3ef-428c-8861-06e72d69f223
+      cpu_model: Conroe
+      headless: true
+      hugepage_size: 2Mi
+      tablets:
+        - bus: virtio
+          name: tablet1
+      cpu_limit: 3
+      cpu_shares: 2
+      disks:
+        - name: containerdisk
+          volume:
+            containerDisk:
+              image: kubevirt/cirros-container-disk-demo:latest
+              path: /custom-disk/cirros.img
+          disk:
+            bus: virtio
+
+- name: Create virtual machine 'myvm' with multus network interface
+  kubevirt_vm:
+      name: myvm
+      namespace: vms
+      memory: 512M
+      interfaces:
+        - name: default
+          bridge: {}
+          network:
+            pod: {}
+        - name: mynet
+          bridge: {}
+          network:
+            multus:
+              networkName: mynetconf
+
+- name: Combine inline definition with Ansible parameters
+  kubevirt_vm:
+      # Kubernetes specification:
+      definition:
+        metadata:
+          labels:
+            app: galaxy
+            service: web
+            origin: vmware
+
+      # Ansible parameters:
+      state: running
+      name: myvm
+      namespace: vms
+      memory: 64M
+      disks:
+        - name: containerdisk
+          volume:
+            containerDisk:
+              image: kubevirt/cirros-container-disk-demo:latest
+              path: /custom-disk/cirros.img
+          disk:
+            bus: virtio
+
+- name: Start ephemeral virtual machine 'myvm' and wait to be running
+  kubevirt_vm:
+      ephemeral: true
+      state: running
+      wait: true
+      wait_timeout: 180
+      name: myvm
+      namespace: vms
+      memory: 64M
+      labels:
+        kubevirt.io/vm: myvm
+      disks:
+        - name: containerdisk
+          volume:
+            containerDisk:
+              image: kubevirt/cirros-container-disk-demo:latest
+              path: /custom-disk/cirros.img
+          disk:
+            bus: virtio
+
+- name: Start fedora vm with cloud init
+  kubevirt_vm:
+      state: running
+      wait: true
+      name: myvm
+      namespace: vms
+      memory: 1024M
+      cloud_init_nocloud:
+        userData: |-
+          #cloud-config
+          password: fedora
+          chpasswd: { expire: False }
+      disks:
+        - name: containerdisk
+          volume:
+            containerDisk:
+              image: kubevirt/fedora-cloud-container-disk-demo:latest
+              path: /disk/fedora.qcow2
+          disk:
+            bus: virtio
+      node_affinity:
+        soft:
+          - weight: 1
+            term:
+              match_expressions:
+                - key: security
+                  operator: In
+                  values:
+                    - S2
+
+- name: Create virtual machine with datavolume and specify node affinity
+  kubevirt_vm:
+    name: myvm
+    namespace: default
+    memory: 1024Mi
+    datavolumes:
+      - name: mydv
+        source:
+          http:
+            url: https://url/disk.qcow2
+        pvc:
+          accessModes:
+            - ReadWriteOnce
+          storage: 5Gi
+    node_affinity:
+      hard:
+        - term:
+            match_expressions:
+              - key: security
+                operator: In
+                values:
+                  - S1
+
+- name: Remove virtual machine 'myvm'
+  kubevirt_vm:
+      state: absent
+      name: myvm
+      namespace: vms
+'''
+
+RETURN = '''
+kubevirt_vm:
+  description:
+      - The virtual machine dictionary specification returned by the API.
+      - "This dictionary contains all values returned by the KubeVirt API all options
+         are described here U(https://kubevirt.io/api-reference/master/definitions.html#_v1_virtualmachine)"
+  returned: success
+  type: complex
+  contains: {}
+'''
+
+
+import copy
+import traceback
+
+from ansible_collections.community.kubernetes.plugins.module_utils.k8s.common import AUTH_ARG_SPEC
+from ansible_collections.community.general.plugins.module_utils.kubevirt import (
+    virtdict,
+    KubeVirtRawModule,
+    VM_COMMON_ARG_SPEC,
+    VM_SPEC_DEF_ARG_SPEC
+)
+
+VM_ARG_SPEC = {
+    'ephemeral': {'type': 'bool', 'default': False},
+    'state': {
+        'type': 'str',
+        'choices': [
+            'present', 'absent', 'running', 'stopped'
+        ],
+        'default': 'present'
+    },
+    'datavolumes': {'type': 'list'},
+    'template': {'type': 'str'},
+    'template_parameters': {'type': 'dict'},
+}
+
+# Which params (can) modify 'spec:' contents of a VM:
+VM_SPEC_PARAMS = list(VM_SPEC_DEF_ARG_SPEC.keys()) + ['datavolumes', 'template', 'template_parameters']
+
+
+class KubeVirtVM(KubeVirtRawModule):
+
+    @property
+    def argspec(self):
+        """ argspec property builder """
+        argument_spec = copy.deepcopy(AUTH_ARG_SPEC)
+        argument_spec.update(VM_COMMON_ARG_SPEC)
+        argument_spec.update(VM_ARG_SPEC)
+        return argument_spec
+
+    @staticmethod
+    def fix_serialization(obj):
+        if obj and hasattr(obj, 'to_dict'):
+            return obj.to_dict()
+        return obj
+
+    def _wait_for_vmi_running(self):
+        for event in self._kind_resource.watch(namespace=self.namespace, timeout=self.params.get('wait_timeout')):
+            entity = event['object']
+            if entity.metadata.name != self.name:
+                continue
+            status = entity.get('status', {})
+            phase = status.get('phase', None)
+            if phase == 'Running':
+                return entity
+
+        self.fail("Timeout occurred while waiting for virtual machine to start. Maybe try a higher wait_timeout value?")
+
+    def _wait_for_vm_state(self, new_state):
+        if new_state == 'running':
+            want_created = want_ready = True
+        else:
+            want_created = want_ready = False
+
+        for event in self._kind_resource.watch(namespace=self.namespace, timeout=self.params.get('wait_timeout')):
+            entity = event['object']
+            if entity.metadata.name != self.name:
+                continue
+            status = entity.get('status', {})
+            created = status.get('created', False)
+            ready = status.get('ready', False)
+            if (created, ready) == (want_created, want_ready):
+                return entity
+
+        self.fail("Timeout occurred while waiting for virtual machine to achieve '{0}' state. "
+                  "Maybe try a higher wait_timeout value?".format(new_state))
+
+    def manage_vm_state(self, new_state, already_changed):
+        new_running = True if new_state == 'running' else False
+        changed = False
+        k8s_obj = {}
+
+        if not already_changed:
+            k8s_obj = self.get_resource(self._kind_resource)
+            if not k8s_obj:
+                self.fail("VirtualMachine object disappeared during module operation, aborting.")
+            if k8s_obj.spec.get('running', False) == new_running:
+                return False, k8s_obj
+
+            newdef = dict(metadata=dict(name=self.name, namespace=self.namespace), spec=dict(running=new_running))
+            k8s_obj, err = self.patch_resource(self._kind_resource, newdef, k8s_obj,
+                                               self.name, self.namespace, merge_type='merge')
+            if err:
+                self.fail_json(**err)
+            else:
+                changed = True
+
+        if self.params.get('wait'):
+            k8s_obj = self._wait_for_vm_state(new_state)
+
+        return changed, k8s_obj
+
+    def _process_template_defaults(self, proccess_template, processedtemplate, defaults):
+        def set_template_default(default_name, default_name_index, definition_spec):
+            default_value = proccess_template['metadata']['annotations'][default_name]
+            if default_value:
+                values = definition_spec[default_name_index]
+                default_values = [d for d in values if d.get('name') == default_value]
+                defaults[default_name_index] = default_values
+                if definition_spec[default_name_index] is None:
+                    definition_spec[default_name_index] = []
+                definition_spec[default_name_index].extend([d for d in values if d.get('name') != default_value])
+
+        devices = processedtemplate['spec']['template']['spec']['domain']['devices']
+        spec = processedtemplate['spec']['template']['spec']
+
+        set_template_default('defaults.template.cnv.io/disk', 'disks', devices)
+        set_template_default('defaults.template.cnv.io/volume', 'volumes', spec)
+        set_template_default('defaults.template.cnv.io/nic', 'interfaces', devices)
+        set_template_default('defaults.template.cnv.io/network', 'networks', spec)
+
+    def construct_definition(self, kind, our_state, ephemeral):
+        definition = virtdict()
+        processedtemplate = {}
+
+        # Construct the API object definition:
+        defaults = {'disks': [], 'volumes': [], 'interfaces': [], 'networks': []}
+        vm_template = self.params.get('template')
+        if vm_template:
+            # Find the template the VM should be created from:
+            template_resource = self.client.resources.get(api_version='template.openshift.io/v1', kind='Template', name='templates')
+            proccess_template = template_resource.get(name=vm_template, namespace=self.params.get('namespace'))
+
+            # Set proper template values taken from module option 'template_parameters':
+            for k, v in self.params.get('template_parameters', {}).items():
+                for parameter in proccess_template.parameters:
+                    if parameter.name == k:
+                        parameter.value = v
+
+            # Proccess the template:
+            processedtemplates_res = self.client.resources.get(api_version='template.openshift.io/v1', kind='Template', name='processedtemplates')
+            processedtemplate = processedtemplates_res.create(proccess_template.to_dict()).to_dict()['objects'][0]
+
+            # Process defaults of the template:
+            self._process_template_defaults(proccess_template, processedtemplate, defaults)
+
+        if not ephemeral:
+            definition['spec']['running'] = our_state == 'running'
+        template = definition if ephemeral else definition['spec']['template']
+        template['metadata']['labels']['vm.cnv.io/name'] = self.params.get('name')
+        dummy, definition = self.construct_vm_definition(kind, definition, template, defaults)
+
+        return self.merge_dicts(definition, processedtemplate)
+
+    def execute_module(self):
+        # Parse parameters specific to this module:
+        ephemeral = self.params.get('ephemeral')
+        k8s_state = our_state = self.params.get('state')
+        kind = 'VirtualMachineInstance' if ephemeral else 'VirtualMachine'
+        _used_params = [name for name in self.params if self.params[name] is not None]
+        # Is 'spec:' getting changed?
+        vm_spec_change = True if set(VM_SPEC_PARAMS).intersection(_used_params) else False
+        changed = False
+        crud_executed = False
+        method = ''
+
+        # Underlying module_utils/k8s/* code knows only of state == present/absent; let's make sure not to confuse it
+        if ephemeral:
+            # Ephemerals don't actually support running/stopped; we treat those as aliases for present/absent instead
+            if our_state == 'running':
+                self.params['state'] = k8s_state = 'present'
+            elif our_state == 'stopped':
+                self.params['state'] = k8s_state = 'absent'
+        else:
+            if our_state != 'absent':
+                self.params['state'] = k8s_state = 'present'
+
+        # Start with fetching the current object to make sure it exists
+        # If it does, but we end up not performing any operations on it, at least we'll be able to return
+        # its current contents as part of the final json
+        self.client = self.get_api_client()
+        self._kind_resource = self.find_supported_resource(kind)
+        k8s_obj = self.get_resource(self._kind_resource)
+        if not self.check_mode and not vm_spec_change and k8s_state != 'absent' and not k8s_obj:
+            self.fail("It's impossible to create an empty VM or change state of a non-existent VM.")
+
+        # If there are (potential) changes to `spec:` or we want to delete the object, that warrants a full CRUD
+        # Also check_mode always warrants a CRUD, as that'll produce a sane result
+        if vm_spec_change or k8s_state == 'absent' or self.check_mode:
+            definition = self.construct_definition(kind, our_state, ephemeral)
+            result = self.execute_crud(kind, definition)
+            changed = result['changed']
+            k8s_obj = result['result']
+            method = result['method']
+            crud_executed = True
+
+        if ephemeral and self.params.get('wait') and k8s_state == 'present' and not self.check_mode:
+            # Waiting for k8s_state==absent is handled inside execute_crud()
+            k8s_obj = self._wait_for_vmi_running()
+
+        if not ephemeral and our_state in ['running', 'stopped'] and not self.check_mode:
+            # State==present/absent doesn't involve any additional VMI state management and is fully
+            # handled inside execute_crud() (including wait logic)
+            patched, k8s_obj = self.manage_vm_state(our_state, crud_executed)
+            changed = changed or patched
+            if changed:
+                method = method or 'patch'
+
+        # Return from the module:
+        self.exit_json(**{
+            'changed': changed,
+            'kubevirt_vm': self.fix_serialization(k8s_obj),
+            'method': method
+        })
+
+
+def main():
+    module = KubeVirtVM()
+    try:
+        module.execute_module()
+    except Exception as e:
+        module.fail_json(msg=str(e), exception=traceback.format_exc())
+
+
+if __name__ == '__main__':
+    main()