k8s: manipulate with workers, get k8s config. kvmvm: affinity/anti-affinity, cloud-init userdata. Add examples.

README.md

@@ -5,8 +5,8 @@ Note that this module may produce unreliable results when used with older DECORT
 
 Requirements:
 * Ansible 2.7 or higher
-* Python 2.6 or higher
+* Python 3.7 or higher
-* PyJWT 1.7.1 Python module
+* PyJWT 2.0.0 Python module or higher
 * requests Python module
 * netaddr Python module
 * DECORT cloud platform version 3.5.0 or higher

examples/affinity.yaml

@@ -0,0 +1,36 @@
+---
+#
+# DECORT kvmvm module example
+#
+- hosts: ansible_master
+  tasks:
+  - name: create a VM named cloud-init_example
+    decort_kvmvm:
+      name: affinity_example
+      annotation: "VM managed by decort_kvmvm module"
+      authenticator: oauth2
+      app_id: ""                                          # Application id from SSO Digital Energy
+      app_secret: ""                                      # API key from SSO Digital Energy
+      controller_url: ""                                  #"https://mr4.digitalenergy.online"
+      rg_id:                                              # Resource group id
+      cpu: 2
+      ram: 2048
+      boot_disk: 10
+      image_name: "DECS Ubuntu 18.04 v1.2.3"              # Name of OS image
+      networks:
+        - type: VINS
+          id:                                             # VINS id
+      tags: "Ansible cloud init example"
+      aff_lable: "Affinity lable"
+      tag:
+        - key: bd
+          value: main
+      aff_rule:
+        - key: app
+          value: main
+          topology: compute
+          policy: REQUIRED
+          mode: EQ
+      state: present
+    delegate_to: localhost
+    register: simple_vm

examples/anti_affinity.yaml

@@ -0,0 +1,36 @@
+---
+#
+# DECORT kvmvm module example
+#
+- hosts: ansible_master
+  tasks:
+  - name: create a VM named cloud-init_example
+    decort_kvmvm:
+      name: anti-affinity_example
+      annotation: "VM managed by decort_kvmvm module"
+      authenticator: oauth2
+      app_id: ""                                          # Application id from SSO Digital Energy
+      app_secret: ""                                      # API key from SSO Digital Energy
+      controller_url: ""                                  #"https://mr4.digitalenergy.online"
+      rg_id:                                              # Resource group id
+      cpu: 2
+      ram: 2048
+      boot_disk: 10
+      image_name: "DECS Ubuntu 18.04 v1.2.3"              #Name of OS image
+      networks:
+        - type: VINS
+          id:                                             #VINS id
+      tags: "Ansible cloud init example"
+      aff_lable: "Anti affinity lable"
+      tag:
+        - key: bd
+          value: main
+      aaff_rule:
+        - key: app
+          value: main
+          topology: compute
+          policy: REQUIRED
+          mode: ANY
+      state: present
+    delegate_to: localhost
+    register: simple_vm

examples/cloud-init.yaml

@@ -0,0 +1,38 @@
+#
+# DECORT kvmvm module example
+#
+- hosts: ansible_master
+  tasks:
+  - name: create a VM named cloud-init_example
+    decort_kvmvm:
+      annotation: "VM managed by decort_kvmvm module"
+      authenticator: oauth2
+      app_id: ""                                          # Application id from SSO Digital Energy
+      app_secret: ""                                      # API key from SSO Digital Energy
+      controller_url: ""                                  #"https://mr4.digitalenergy.online"
+      name: cloud-init_example
+      cpu: 2
+      ram: 2048
+      boot_disk: 10
+      image_name: "DECS Ubuntu 18.04 v1.2.3"              #Name of OS image
+      networks:
+        - type: VINS
+          id:                                             #VINS id
+      tags: "Ansible cloud init example"
+      state: present
+      rg_id:                                              #Resource group id
+      ci_user_data:
+        - packages:
+            - apache2
+        - write_files:
+            - content: |
+                <div>
+                Hello World!
+                </div>
+              owner: user:user
+              path: /var/www/html/index.html
+        - hostname: test-apache
+        - ssh_keys:
+            - rsa_public: ssh-rsa AAAAOasDmLxnD=  user@pc
+    delegate_to: localhost
+    register: simple_vm

examples/kubernetes.yaml

@@ -0,0 +1,39 @@
+---
+#
+# DECORT k8s module example
+#
+- hosts: ansible_master
+  tasks:
+  - name: obtain JWT
+    decort_jwt:
+      oauth2_url: ""                                     #"https://sso.digitalenergy.online"
+      validity: 1200
+      verify_ssl: false
+    register: token
+    delegate_to: localhost
+
+  - name: create a VM named cloud-init_example
+    decort_k8s:
+      state: present
+      started: True
+      getConfig: True
+      authenticator: jwt
+      jwt: "{{ token.jwt }}"
+      controller_url: ""                                  #"https://mr4.digitalenergy.online"
+      name: "cluster-test"
+      rg_id:                                              # Resource group id
+      k8ci_id:                                            # k8s ci id
+      workers:
+        - name: wg1
+          ram: 1024
+          cpu: 10
+          disk: 10
+          num: 1
+        - name: wg2
+          ram: 1024
+          cpu: 10
+          disk: 10
+          num: 2
+      verify_ssl: false
+    delegate_to: localhost
+    register: kube

examples/main.yaml

@@ -188,3 +188,136 @@
        var: my_pfw.facts
     delegate_to: localhost
 
+  - name: Create k8s cluster with params
+    decort_k8s:
+      authenticator: jwt
+      jwt: "{{ token.jwt }}"
+      controller_url: "{{ decort_ctrl }}"
+      k8s_name: "k8s_cluster_name"
+      wg_name: "k8s_wg_name"
+      k8ci_id: "{{ k8ci_id }}"
+      rg_id: "{{ my_rg.facts.id }}"
+      master_count: 1
+      master_cpu: 2
+      master_ram_mb: 2048
+      master_disk_gb: 20
+      worker_count: 3
+      worker_cpu: 1
+      worker_ram_mb: 1024
+      worker_disk_gb: 20
+      extnet_id: "{{ target_ext_net_id }}"
+      with_lb: True
+      state: present
+    register: k8s
+    delegate_to: localhost
+
+  - name: print out the result
+    debug:
+       var: k8s
+    delegate_to: localhost
+
+  - name: Disable k8s cluster
+    decort_k8s:
+      authenticator: jwt
+      jwt: "{{ token.jwt }}"
+      controller_url: "{{ decort_ctrl }}"
+      k8s_name: "k8s_cluster_name"
+      wg_name: "k8s_wg_name"
+      k8ci_id: "{{ k8ci_id }}"
+      rg_id: "{{ my_rg.facts.id }}"
+      state: disabled
+    register: k8s
+    delegate_to: localhost
+
+  - name: print out the result
+    debug:
+       var: k8s
+    delegate_to: localhost
+
+  - name: Delete in trash k8s cluster
+    decort_k8s:
+      authenticator: jwt
+      jwt: "{{ token.jwt }}"
+      controller_url: "{{ decort_ctrl }}"
+      k8s_name: "k8s_cluster_name"
+      wg_name: "k8s_wg_name"
+      k8ci_id: "{{ k8ci_id }}"
+      rg_id: "{{ my_rg.facts.id }}"
+      state: absent
+      permanent: False
+    register: k8s
+    delegate_to: localhost
+
+  - name: print out the result
+    debug:
+       var: k8s
+    delegate_to: localhost
+
+  - name: Restore from trash deleted k8s cluster
+    decort_k8s:
+      authenticator: jwt
+      jwt: "{{ token.jwt }}"
+      controller_url: "{{ decort_ctrl }}"
+      k8s_name: "k8s_cluster_name"
+      wg_name: "k8s_wg_name"
+      k8ci_id: "{{ k8ci_id }}"
+      rg_id: "{{ my_rg.facts.id }}"
+      state: enabled
+    register: k8s
+    delegate_to: localhost
+
+  - name: print out the result
+    debug:
+       var: k8s
+    delegate_to: localhost
+
+  - name: Enable k8s cluster 
+    decort_k8s:
+      authenticator: jwt
+      jwt: "{{ token.jwt }}"
+      controller_url: "{{ decort_ctrl }}"
+      k8s_name: "k8s_cluster_name"
+      wg_name: "k8s_wg_name"
+      k8ci_id: "{{ k8ci_id }}"
+      rg_id: "{{ my_rg.facts.id }}"
+      state: enabled
+    register: k8s
+    delegate_to: localhost
+
+  - name: Enable k8s cluster
+    decort_k8s:
+      authenticator: jwt
+      jwt: "{{ token.jwt }}"
+      controller_url: "{{ decort_ctrl }}"
+      k8s_name: "k8s_cluster_name"
+      wg_name: "k8s_wg_name"
+      k8ci_id: "{{ k8ci_id }}"
+      rg_id: "{{ my_rg.facts.id }}"
+      state: enabled
+      started: True
+    register: k8s
+    delegate_to: localhost
+
+  - name: print out the result
+    debug:
+       var: k8s
+    delegate_to: localhost
+
+  - name: Destroy k8s cluster
+    decort_k8s:
+      authenticator: jwt
+      jwt: "{{ token.jwt }}"
+      controller_url: "{{ decort_ctrl }}"
+      k8s_name: "k8s_cluster_name"
+      wg_name: "k8s_wg_name"
+      k8ci_id: "{{ k8ci_id }}"
+      rg_id: "{{ my_rg.facts.id }}"
+      state: absent
+      permanent: True
+    register: k8s
+    delegate_to: localhost
+
+  - name: print out the result
+    debug:
+       var: k8s
+    delegate_to: localhost

library/decort_k8s.py

@@ -0,0 +1,340 @@
+#!/usr/bin/python
+#
+# Digital Enegry Cloud Orchestration Technology (DECORT) modules for Ansible
+# Copyright: (c) 2018-2021 Digital Energy Cloud Solutions LLC
+#
+# Apache License 2.0 (see http://www.apache.org/licenses/LICENSE-2.0.txt)
+#
+
+#
+# Author: Aleksandr Malyavin (aleksandr.malyavin@digitalenergy.online)
+#
+
+ANSIBLE_METADATA = {'metadata_version': '1.1',
+                    'status': ['preview'],
+                    'supported_by': 'community'}
+
+from ansible.module_utils.basic import AnsibleModule
+from ansible.module_utils.basic import env_fallback
+from ansible.module_utils.decort_utils import *
+
+class decort_k8s(DecortController):
+    def __init__(self,arg_amodule):
+        super(decort_k8s, self).__init__(arg_amodule)
+
+        validated_acc_id = 0
+        validated_rg_id = 0
+        validated_rg_facts = None
+        validated_k8ci_id = 0
+
+        if arg_amodule.params['name'] == "" and arg_amodule.params['id'] == 0:
+            self.result['failed'] = True
+            self.result['changed'] = False
+            self.result['msg'] = "Cannot manage k8s cluster when its ID is 0 and name is empty."
+            self.fail_json(**self.result)
+
+
+        if not arg_amodule.params['id']:
+            if not arg_amodule.params['rg_id']: # RG ID is not set -> locate RG by name -> need account ID
+                validated_acc_id, _ = self.account_find(arg_amodule.params['account_name'],
+                                                        arg_amodule.params['account_id'])
+                if not validated_acc_id:
+                    self.result['failed'] = True
+                    self.result['changed'] = False
+                    self.result['msg'] = ("Current user does not have access to the account ID {} / "
+                                          "name '{}' or non-existent account specified.").format(arg_amodule.params['account_id'],
+                                                                                                 arg_amodule.params['account_name'])
+                    self.fail_json(**self.result)
+                    # fail the module -> exit
+            # now validate RG
+            validated_rg_id, validated_rg_facts = self.rg_find(validated_acc_id,
+                                                               arg_amodule.params['rg_id'],)
+            if not validated_rg_id:
+                self.result['failed'] = True
+                self.result['changed'] = False
+                self.result['msg'] = "Cannot find RG ID {} / name '{}'.".format(arg_amodule.params['rg_id'],
+                                                                                arg_amodule.params['rg_name'])
+                self.fail_json(**self.result)
+                # fail the module - exit
+            
+
+            #validate k8ci ID
+
+            validated_k8ci_id = self.k8s_k8ci_find(arg_amodule.params['k8ci_id'])  
+            if not validated_k8ci_id:
+                self.result['failed'] = True
+                self.result['changed'] = False
+                self.result['msg'] = "Cannot find K8CI ID {}.".format(arg_amodule.params['k8ci_id'])
+                self.fail_json(**self.result)
+
+            self.rg_id = validated_rg_id
+            arg_amodule.params['rg_id'] = validated_rg_id
+            arg_amodule.params['rg_name'] = validated_rg_facts['name']
+            self.acc_id = validated_rg_facts['accountId']
+            arg_amodule.params['k8ci_id'] = validated_k8ci_id
+
+            self.k8s_id,self.k8s_info = self.k8s_find(k8s_id=arg_amodule.params['id'],
+                                                      k8s_name=arg_amodule.params['name'],
+                                                      rg_id=validated_rg_id,
+                                                      check_state=False)
+            if self.k8s_id:
+                self.k8s_should_exist = True
+                self.acc_id = self.k8s_info['accountId']
+            # check workers and groups for add or remove
+        
+        return
+
+    def package_facts(self,check_mode=False):
+        
+        ret_dict = dict(
+            name="",
+            state="CHECK_MODE",
+            account_id=0,
+            rg_id=0,
+            config=None,
+        )
+
+        if check_mode:
+            # in check mode return immediately with the default values
+            return ret_dict
+
+        #if self.k8s_facts is None:
+        #    #if void facts provided - change state value to ABSENT and return
+        #    ret_dict['state'] = "ABSENT"
+        #    return ret_dict
+
+        ret_dict['id'] = self.k8s_info['id']
+        ret_dict['name'] = self.k8s_info['name']
+        ret_dict['techStatus'] = self.k8s_info['techStatus']
+        ret_dict['state'] = self.k8s_info['status']
+        ret_dict['rg_id'] = self.rg_id
+        ret_dict['account_id'] = self.acc_id
+        if self.amodule.params['getConfig'] and self.k8s_info['techStatus'] == "STARTED":
+            ret_dict['config'] = self.k8s_getConfig()
+        return ret_dict
+    
+    def nop(self):
+        """No operation (NOP) handler for Compute management by decort_kvmvm module.
+        This function is intended to be called from the main switch construct of the module
+        when current state -> desired state change logic does not require any changes to
+        the actual Compute state.
+        """
+        self.result['failed'] = False
+        self.result['changed'] = False
+        if self.k8s_id:
+            self.result['msg'] = ("No state change required for K8s  ID {} because of its "
+                                   "current status '{}'.").format(self.k8s_id, self.k8s_info['status'])
+        else:
+            self.result['msg'] = ("No state change to '{}' can be done for "
+                                  "non-existent K8s instance.").format(self.amodule.params['state'])
+        return                         
+
+    def error(self):
+        self.result['failed'] = True
+        self.result['changed'] = False
+        if self.k8s_id:
+            self.result['msg'] = ("Invalid target state '{}' requested for K8s cluster ID {} in the "
+                                   "current status '{}'.").format(self.k8s_id,
+                                                                  self.amodule.params['state'],
+                                                                  self.k8s_info['status'])
+        else:
+            self.result['msg'] = ("Invalid target state '{}' requested for non-existent K8s Cluster name '{}' "
+                                   "in RG ID {} / name '{}'").format(self.amodule.params['state'],
+                                                                    self.amodule.params['name'],
+                                                                    self.amodule.params['rg_id'],
+                                                                    self.amodule.params['rg_name'])
+        return
+
+    def create(self):
+        self.k8s_provision(self.amodule.params['name'],
+                                    self.amodule.params['workers'][0]['name'],
+                                    self.amodule.params['k8ci_id'],
+                                    self.amodule.params['rg_id'],
+                                    self.amodule.params['master_count'],
+                                    self.amodule.params['master_cpu'],
+                                    self.amodule.params['master_ram_mb'],
+                                    self.amodule.params['master_disk_gb'],
+                                    self.amodule.params['workers'][0]['num'],
+                                    self.amodule.params['workers'][0]['cpu'],
+                                    self.amodule.params['workers'][0]['ram'],
+                                    self.amodule.params['workers'][0]['disk'],
+                                    self.amodule.params['extnet_id'],
+                                    self.amodule.params['with_lb'],
+                                    self.amodule.params['description'],)
+        
+        self.k8s_id,self.k8s_info = self.k8s_find(k8s_id=self.amodule.params['id'],
+                                                      k8s_name=self.amodule.params['name'],
+                                                      rg_id=self.rg_id,
+                                                      check_state=False)
+        
+        if self.k8s_id:
+                self.k8s_should_exist = True
+        if self.k8s_id and self.amodule.params['workers'][1]:
+            self.k8s_workers_modify(self.k8s_info,self.amodule.params['workers'])
+        return
+    
+    def destroy(self):
+        self.k8s_delete(self.k8s_id)
+        self.k8s_info['status'] = 'DELETED'
+        self.k8s_should_exist = False
+        return    
+    
+    def action(self,disared_state,started=True):
+        
+        self.k8s_state(self.k8s_info, disared_state,started)
+        self.k8s_id,self.k8s_info = self.k8s_find(k8s_id=self.amodule.params['id'],
+                                                      k8s_name=self.amodule.params['name'],
+                                                      rg_id=self.rg_id,
+                                                      check_state=False)
+        if started == True and self.k8s_info['techStatus'] == "STOPPED":
+            self.k8s_state(self.k8s_info, disared_state,started)
+            self.k8s_info['techStatus'] == "STARTED"
+        self.k8s_workers_modify(self.k8s_info,self.amodule.params['workers'])
+
+        return
+    @staticmethod
+    def build_parameters():
+        return dict(
+            account_id=dict(type='int', required=False),
+            account_name=dict(type='str', required=False, default=''),
+            annotation=dict(type='str', required=False, default=''),
+            app_id=dict(type='str',
+                        required=False,
+                        fallback=(env_fallback, ['DECORT_APP_ID'])),
+            app_secret=dict(type='str',
+                            required=False,
+                            fallback=(env_fallback, ['DECORT_APP_SECRET']),
+                            no_log=True),
+            authenticator=dict(type='str',
+                            required=True,
+                            choices=['legacy', 'oauth2', 'jwt']),
+            controller_url=dict(type='str', required=True),
+            # datacenter=dict(type='str', required=False, default=''),
+            jwt=dict(type='str',
+                    required=False,
+                    fallback=(env_fallback, ['DECORT_JWT']),
+                    no_log=True),
+            oauth2_url=dict(type='str',
+                            required=False,
+                            fallback=(env_fallback, ['DECORT_OAUTH2_URL'])),
+            password=dict(type='str',
+                        required=False,
+                        fallback=(env_fallback, ['DECORT_PASSWORD']),
+                        no_log=True),
+            quotas=dict(type='dict', required=False),
+            state=dict(type='str',
+                    default='present',
+                    choices=['absent', 'disabled', 'enabled', 'present','check']),
+            permanent=dict(type='bool', default=False),
+            started=dict(type='bool', default=True),
+            user=dict(type='str',
+                    required=False,
+                    fallback=(env_fallback, ['DECORT_USER'])),
+            name=dict(type='str', required=True),
+            id=dict(type='int', required=False, default=0),
+            getConfig=dict(type='bool',required=False, default=False),
+            rg_id=dict(type='int', default=0),
+            rg_name=dict(type='str',default=""),
+            k8ci_id=dict(type='int', required=True),
+            wg_name=dict(type='str', required=False),
+            master_count=dict(type='int', default=1),
+            master_cpu=dict(type='int', default=2),
+            master_ram_mb=dict(type='int', default=2048),
+            master_disk_gb=dict(type='int', default=10),
+            worker_count=dict(type='int', default=1),
+            worker_cpu=dict(type='int', default=1),
+            worker_ram_mb=dict(type='int', default=1024),
+            worker_disk_gb=dict(type='int', default=10),
+            workers=dict(type='list'),
+            extnet_id=dict(type='int',  default=0),
+            description=dict(type='str', default="Created by decort ansible module"),
+            with_lb=dict(type='bool', default=True),
+            verify_ssl=dict(type='bool', required=False, default=True),
+            workflow_callback=dict(type='str', required=False),
+            workflow_context=dict(type='str', required=False),)
+
+def main():
+    module_parameters = decort_k8s.build_parameters()
+
+    amodule = AnsibleModule(argument_spec=module_parameters,
+                            supports_check_mode=True,
+                            mutually_exclusive=[
+                                ['oauth2', 'password'],
+                                ['password', 'jwt'],
+                                ['jwt', 'oauth2'],
+                            ],
+                            required_together=[
+                                ['app_id', 'app_secret'],
+                                ['user', 'password'],
+                            ],
+                            required_one_of=[
+                                ['id', 'name'],
+                                ['rg_id','rg_name']
+                            ],
+                            )
+
+    subj = decort_k8s(amodule)
+
+    if amodule.params['state'] == 'check':
+        subj.result['changed'] = False
+        if subj.k8s_id:
+            # cluster is found - package facts and report success to Ansible
+            subj.result['failed'] = False
+            subj.result['facts'] = subj.package_facts(amodule.check_mode)
+            amodule.exit_json(**subj.result)
+            # we exit the module at this point
+        else:
+            subj.result['failed'] = True
+            subj.result['msg'] = ("Cannot locate K8s cluster name '{}'. "
+                                  "RG ID {}").format(amodule.params['name'],
+                                                     amodule.params['rg_id'],)
+            amodule.fail_json(**subj.result)                          
+
+    if subj.k8s_id:
+        if subj.k8s_info['status'] in ("DELETING","DESTROYNG","CREATING","DESTROYING",
+                                         "ENABLING","DISABLING","RESTORING","MODELED"):
+            subj.error()
+        elif subj.k8s_info['status'] == "DELETED":
+            if amodule.params['state'] in ('disabled', 'enabled', 'present'):
+                subj.k8s_restore(subj.k8s_id)
+                subj.action(amodule.params['state'])
+            if amodule.params['state'] == 'absent':
+                subj.nop()
+        elif subj.k8s_info['techStatus'] in ("STARTED","STOPPED"):
+            if amodule.params['state'] == 'disabled':
+                subj.action(amodule.params['state'])
+            elif amodule.params['state'] == 'absent':
+                subj.destroy()
+            else:
+                subj.action(amodule.params['state'],amodule.params['started'])
+        elif subj.k8s_info['status'] == "DISABLED":
+            if amodule.params['state'] == 'absent':
+                subj.destroy()
+            elif amodule.params['state'] in ('present','enabled'):
+                subj.action(amodule.params['state'],amodule.params['started'])
+            else:
+                subj.nop()
+        elif subj.k8s_info['status'] == "DESTROED":
+            if amodule.params['state'] in ('present','enabled'):
+                subj.create()
+            if amodule.params['state'] == 'absent':    
+                subj.nop()
+    else:
+        if amodule.params['state'] == 'absent':
+            subj.nop()
+        if amodule.params['state'] in ('present','started'):
+            subj.create()
+        elif amodule.params['state'] in ('stopped', 'disabled','enabled'):
+            subj.error()
+            
+    if subj.result['failed']:
+        amodule.fail_json(**subj.result)
+    else:
+        if subj.k8s_should_exist:
+            subj.result['facts'] = subj.package_facts(amodule.check_mode)
+            amodule.exit_json(**subj.result)
+        else:
+            amodule.exit_json(**subj.result)
+
+if __name__ == "__main__":
+    main()

library/decort_kvmvm.py

@@ -192,6 +192,9 @@ options:
         - If I(ssh_key) is not specified, this parameter is ignored and a warning is generated.
         - This parameter is valid at VM creation time only and ignored for any operation on existing VMs.
         required: no
+    user_data:
+        description:
+        - Cloud-init User-Data, exept ssh module
     state:
         description:
         - Specify the desired state of the virtual machine at the exit of the module.
@@ -548,15 +551,18 @@ class decort_kvmvm(DecortController):
         if self.amodule.params['state'] in ('halted', 'poweredoff'):
             start_compute = False
         
-        if self.amodule.params['ssh_key'] and self.amodule.params['ssh_key_user']:
+        if self.amodule.params['ssh_key'] and self.amodule.params['ssh_key_user'] and not self.amodule.params['ci_user_data']:
             cloud_init_params = {'users': [
                 {"name": self.amodule.params['ssh_key_user'],
                     "ssh-authorized-keys": [self.amodule.params['ssh_key']],
                     "shell": '/bin/bash'}
                 ]}
+        elif self.amodule.params['ci_user_data']:
+            cloud_init_params = {}
+            for ci_param in self.amodule.params['ci_user_data']:
+                cloud_init_params.update(ci_param)
         else:
             cloud_init_params = None
-
         # if we get through here, all parameters required to create new Compute instance should be at hand
 
         # NOTE: KVM VM is created in HALTED state and must be explicitly started
@@ -595,6 +601,11 @@ class decort_kvmvm(DecortController):
         # Next manage data disks
         self.compute_data_disks(self.comp_info, self.amodule.params['data_disks'])
 
+        self.compute_affinity(self.comp_info,
+                              self.amodule.params['tag'],
+                              self.amodule.params['aff_rule'],
+                              self.amodule.params['aaff_rule'],
+                              label=self.amodule.params['affinity_label'],)
         # NOTE: see NOTE above regarding libvirt "feature" and new VMs created in HALTED state
         if self.amodule.params['state'] not in ('halted', 'poweredoff'):
             self.compute_powerstate(self.comp_info, 'started')
@@ -641,6 +652,11 @@ class decort_kvmvm(DecortController):
         self.compute_resize(self.comp_info,
                             self.amodule.params['cpu'], self.amodule.params['ram'],
                             wait_for_state_change=arg_wait_cycles)
+        self.compute_affinity(self.comp_info,
+                              self.amodule.params['tag'],
+                              self.amodule.params['aff_rule'],
+                              self.amodule.params['aaff_rule'],
+                              label=self.amodule.params['affinity_label'],)
         return
 
     def package_facts(self, check_mode=False):
@@ -774,6 +790,11 @@ class decort_kvmvm(DecortController):
             rg_name=dict(type='str', default=""),
             ssh_key=dict(type='str', required=False),
             ssh_key_user=dict(type='str', required=False),
+            tag=dict(type='list', required=False),
+            affinity_label=dict(type='str', required=False),
+            aff_rule=dict(type='list', required=False),
+            aaff_rule=dict(type='list', required=False),
+            ci_user_data=dict(type='list', required=False),
             state=dict(type='str',
                        default='present',
                        choices=['absent', 'paused', 'poweredoff', 'halted', 'poweredon', 'present', 'check']),

library/decort_vins.py

@@ -284,15 +284,15 @@ def decort_vins_package_facts(arg_vins_facts, arg_check_mode=False):
     else:
         ret_dict['ext_ip_addr'] = ""
         ret_dict['ext_net_id'] = -1
-    
+
     # arg_vins_facts['vnfs']['GW']['config']
     #   ext_ip_addr -> ext_net_ip
     #   ???         -> ext_net_id
     # tech_status   -> techStatus
 
-
     return ret_dict
 
+
 def decort_vins_parameters():
     """Build and return a dictionary of parameters expected by decort_vins module in a form accepted
     by AnsibleModule utility class."""
@@ -342,6 +342,7 @@ def decort_vins_parameters():
         workflow_context=dict(type='str', required=False),
     )
 
+
 # Workflow digest:
 # 1) authenticate to DECORT controller & validate authentication by issuing API call - done when creating DECORTController
 # 2) check if the ViNS with this id or name exists under specified account / resource group
@@ -368,12 +369,12 @@ def main():
     decon = DecortController(amodule)
 
     vins_id = 0
-    vins_level = "" # "ID" if specified by ID, "RG" - at resource group, "ACC" - at account level
+    vins_level = ""  # "ID" if specified by ID, "RG" - at resource group, "ACC" - at account level
-    vins_facts = None # will hold ViNS facts
+    vins_facts = None  # will hold ViNS facts
     validated_rg_id = 0
-    rg_facts = None # will hold RG facts
+    rg_facts = None  # will hold RG facts
     validated_acc_id = 0
-    acc_facts = None # will hold Account facts
+    acc_facts = None  # will hold Account facts
 
     if amodule.params['vins_id']:
         # expect existing ViNS with the specified ID
@@ -383,56 +384,56 @@ def main():
             decon.result['failed'] = True
             decon.result['msg'] = "Specified ViNS ID {} not found.".format(amodule.params['vins_id'])
             decon.fail_json(**decon.result)
-        vins_level="ID"
+        vins_level = "ID"
         validated_acc_id = vins_facts['accountId']
         validated_rg_id = vins_facts['rgId']
     elif amodule.params['rg_id']:
         # expect ViNS @ RG level in the RG with specified ID
-        vins_level="RG"
+        vins_level = "RG"
-        # This call to rg_find will abort the module if no RG with such ID is present 
+        # This call to rg_find will abort the module if no RG with such ID is present
-        validated_rg_id, rg_facts = decon.rg_find(0, # account ID set to 0 as we search for RG by RG ID
+        validated_rg_id, rg_facts = decon.rg_find(0,  # account ID set to 0 as we search for RG by RG ID
-                                    amodule.params['rg_id'], arg_rg_name="")
+                                                  amodule.params['rg_id'], arg_rg_name="")
         # This call to vins_find may return vins_id=0 if no ViNS found
         vins_id, vins_facts = decon.vins_find(vins_id=0, vins_name=amodule.params['vins_name'],
-                                                account_id=0, 
+                                              account_id=0,
-                                                rg_id=amodule.params['rg_id'],
+                                              rg_id=amodule.params['rg_id'],
-                                                check_state=False)
+                                              check_state=False)
         # TODO: add checks and setup ViNS presence flags accordingly
         pass
     elif amodule.params['account_id'] or amodule.params['account_name'] != "":
-        # Specified account must be present and accessible by the user, otherwise abort the module 
+        # Specified account must be present and accessible by the user, otherwise abort the module
         validated_acc_id, acc_facts = decon.account_find(amodule.params['account_name'], amodule.params['account_id'])
         if not validated_acc_id:
             decon.result['failed'] = True
             decon.result['msg'] = ("Current user does not have access to the requested account "
-                                    "or non-existent account specified.")
+                                   "or non-existent account specified.")
             decon.fail_json(**decon.result)
-        if amodule.params['rg_name'] != "": # at this point we know that rg_id=0
+        if amodule.params['rg_name'] != "":  # at this point we know that rg_id=0
             # expect ViNS @ RG level in the RG with specified name under specified account
-            # RG with the specified name must be present under the account, otherwise abort the module    
+            # RG with the specified name must be present under the account, otherwise abort the module
             validated_rg_id, rg_facts = decon.rg_find(validated_acc_id, 0, amodule.params['rg_name'])
-            if (not validated_rg_id or 
+            if (not validated_rg_id or
-                rg_facts['status'] in ["DESTROYING", "DESTROYED", "DELETING", "DELETED", "DISABLING", "ENABLING"]):
+                    rg_facts['status'] in ["DESTROYING", "DESTROYED", "DELETING", "DELETED", "DISABLING", "ENABLING"]):
                 decon.result['failed'] = True
                 decon.result['msg'] = "RG name '{}' not found or has invalid state.".format(amodule.params['rg_name'])
                 decon.fail_json(**decon.result)
             # This call to vins_find may return vins_id=0 if no ViNS with this name found under specified RG
             vins_id, vins_facts = decon.vins_find(vins_id=0, vins_name=amodule.params['vins_name'],
-                                                    account_id=0, # set to 0, as we are looking for ViNS under RG 
+                                                  account_id=0,  # set to 0, as we are looking for ViNS under RG
-                                                    rg_id=validated_rg_id,
+                                                  rg_id=validated_rg_id,
-                                                    check_state=False)
+                                                  check_state=False)
             vins_level = "RG"
             # TODO: add checks and setup ViNS presence flags accordingly
-        else: # At this point we know for sure that rg_name="" and rg_id=0
+        else:  # At this point we know for sure that rg_name="" and rg_id=0
             # So we expect ViNS @ account level
             # This call to vins_find may return vins_id=0 if no ViNS found
             vins_id, vins_facts = decon.vins_find(vins_id=0, vins_name=amodule.params['vins_name'],
-                                                    account_id=validated_acc_id, 
+                                                  account_id=validated_acc_id,
-                                                    rg_id=0,
+                                                  rg_id=0,
-                                                    check_state=False)
+                                                  check_state=False)
             vins_level = "ACC"
             # TODO: add checks and setup ViNS presence flags accordingly
-    else: 
+    else:
         # this is "invalid arguments combination" sink
         # if we end up here, it means that module was invoked with vins_id=0 and rg_id=0
         decon.result['failed'] = True
@@ -453,12 +454,12 @@ def main():
     #
     # When managing existing ViNS we need to account for both "static" and "transient"
     # status. Full range of ViNS statii is as follows:
-    # 
+    #
     # "MODELED", "CREATED", "ENABLED", "ENABLING", "DISABLED", "DISABLING", "DELETED", "DELETING", "DESTROYED", "DESTROYING"
-    # 
+    #
 
     vins_should_exist = False
-    
+
     if vins_id:
         vins_should_exist = True
         if vins_facts['status'] in ["MODELED", "DISABLING", "ENABLING", "DELETING", "DESTROYING"]:
@@ -526,7 +527,7 @@ def main():
                 # annotation - take from module arguments
                 vins_id = decon.vins_provision(vins_facts['name'],
                                                validated_acc_id, validated_rg_id,
-                                               amodule.params['ipcidr'], 
+                                               amodule.params['ipcidr'],
                                                amodule.params['ext_net_id'], amodule.params['ext_ip_addr'],
                                                amodule.params['annotation'])
                 vins_should_exist = True
@@ -559,18 +560,17 @@ def main():
             decon.check_amodule_argument('vins_name')
             # as we already have account ID and RG ID we can create ViNS and get vins_id on success
             vins_id = decon.vins_provision(amodule.params['vins_name'],
-                                            validated_acc_id, validated_rg_id,
+                                           validated_acc_id, validated_rg_id,
-                                            amodule.params['ipcidr'], 
+                                           amodule.params['ipcidr'],
-                                            amodule.params['ext_net_id'], amodule.params['ext_ip_addr'],
+                                           amodule.params['ext_net_id'], amodule.params['ext_ip_addr'],
-                                            amodule.params['annotation'])
+                                           amodule.params['annotation'])
-            vins_should_exist = True            
+            vins_should_exist = True
         elif amodule.params['state'] == 'disabled':
             decon.result['failed'] = True
             decon.result['changed'] = False
             decon.result['msg'] = ("Invalid target state '{}' requested for non-existent "
                                    "ViNS name '{}'").format(amodule.params['state'],
                                                             amodule.params['vins_name'])
-    
     #
     # conditional switch end - complete module run
     #