Fixed k8s: Deleting\adding a node in some cases applies to all cluster worker groups. ViNS: Mechanism for connecting several virtual network segments has been improved. Changed the mechanism for assigning an IP address for connecting via SSH. Add examples for usage Vault

examples/basicservices.yaml

@@ -1,6 +1,6 @@
 ---
 #
-# DECORT vins module example
+# DECORT bservice module example
 #
 
 - hosts: localhost

examples/create-osimage.yaml

@@ -0,0 +1,27 @@
+---
+#
+# DECORT osimage module example
+#
+- hosts: localhost
+  tasks:
+  - name: create 
+    decort_osimage:
+      authenticator: oauth2
+      verify_ssl: False
+      controller_url: "https://ds1.digitalenergy.online"
+      state: present
+      image_name: "alpine_linux3.14.0"
+      account_Id: 12345
+      url: "https://dl-cdn.alpinelinux.org/alpine/v3.14/releases/x86_64/alpine-virt-3.14.0-x86_64.iso"
+      boottype: "uefi"
+      imagetype: "linux"
+      hotresize: False
+      image_username: "test"
+      image_password: "p@ssword"
+      usernameDL: "testDL"
+      passwordDL: "p@sswordDL"
+      architecture: "X86_64"
+      drivers: "KVM_X86"
+
+    delegate_to: localhost
+    register: simple_vm

examples/create-virtual-osimage.yaml

@@ -0,0 +1,15 @@
+---
+#
+# DECORT osimage module example
+#
+- hosts: localhost
+  tasks:
+  - name: create_virtual_osimage 
+    decort_osimage:
+      authenticator: oauth2
+      controller_url: "https://ds1.digitalenergy.online"
+      image_name: "alpine_linux_3.14.0"
+      virt_name: "alpine_last"
+    delegate_to: localhost
+    register: osimage
+

examples/get-osimage.yaml

@@ -0,0 +1,14 @@
+---
+#
+# DECORT osimage module example
+#
+- hosts: localhost
+  tasks:
+  - name: get_osimage 
+    decort_osimage:
+      authenticator: oauth2
+      controller_url: "https://ds1.digitalenergy.online"
+      image_name: "alpine_linux_3.14.0"
+      account_Id: 79349
+    delegate_to: localhost
+    register: simple_vm

examples/hashivault_create_engine.yaml

@@ -0,0 +1,14 @@
+---
+#
+# This playbook create engine "test".
+#
+- hosts: localhost
+  tasks:
+    - hashivault_secret_engine:
+        url: "https://vault.domain.local"
+        authtype: ldap
+        username: "user"
+        password: "p@ssword"
+        state: present
+        name: test
+        backend: generic

examples/hashivault_create_secret.yaml

@@ -0,0 +1,17 @@
+---
+#
+# This playbook create secret "secret" with data foo:foe. If secret "secret" exists - add data foo:foe.
+#
+- hosts: localhost
+  tasks:
+    - hashivault_secret:
+        url: "https://vault.domain.local"
+        authtype: ldap
+        username: "user"
+        password: "p@ssword"
+        mount_point: "kv"
+        state: present
+        permanent: true
+        secret: secret
+        data:
+            foo: foe

examples/hashivault_example.yaml

@@ -0,0 +1,35 @@
+---
+
+- hosts: localhost
+  tasks:
+  - hashivault_read:
+      url: "https://vault.domain.local"
+      authtype: ldap
+      username: "user"
+      password: "p@ssword"
+      mount_point: kv
+      secret: secrets/myaccount
+      key: app_secret
+      version: 2
+    register: key
+
+  - name: create a VM using app_secret from hashicorp vault
+    decort_kvmvm:
+      annotation: "VM managed by decort_kvmvm module"
+      authenticator: oauth2
+      app_id: ""                                          # Application id from SSO Digital Energy
+      app_secret: "{{ key }}"                             # API key from SSO Digital Energy
+      controller_url: "https://cloud.digitalenergy.online" 
+      name: hashivault_read_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: 99                                          #VINS id
+      tags: "Ansible hashivault_read example"
+      state: present
+      rg_id: 99                                           #Resource group id
+    delegate_to: localhost
+    register: simple_vm

examples/hashivault_plugin_example.yaml

@@ -0,0 +1,31 @@
+- hosts: localhost
+  tasks:
+   - name: Read a kv2 secret with kv mount point
+     vars:
+       ansible_hashi_vault_auth_method: ldap
+       ansible_hashi_vault_username: username
+       ansible_hashi_vault_password: pwd
+       ansible_hashi_vault_engine_mount_point: kv
+     ansible.builtin.set_fact:
+       response: "{{ lookup('community.hashi_vault.vault_kv2_get', 'secret', url='https://vault.domain.local') }}"
+
+  - name: create a VM using app_secret from hashicorp vault 
+    decort_kvmvm:
+      annotation: "VM managed by decort_kvmvm module"
+      authenticator: oauth2
+      app_id: ""                                          # Application id from SSO Digital Energy
+      app_secret: "{{ response.data.password }}"          # API key from SSO Digital Energy
+      controller_url: "https://cloud.digitalenergy.online" 
+      name: hashivault_read_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: 99                                          #VINS id
+      tags: "Ansible hashivault_read example"
+      state: present
+      rg_id: 99                                           #Resource group id
+    delegate_to: localhost
+    register: simple_vm

examples/hashivault_plugin_login.yaml

@@ -0,0 +1,16 @@
+- hosts: localhost
+  tasks:
+   - name: Get auth token from vault
+     set_fact:
+       login_data: "{{ lookup('community.hashi_vault.vault_login', url='https://vault.domain.local', auth_method='ldap', username='username', password='pwd') }}"
+
+   - name: Perform multiple kv2 reads with a single Vault login, showing the secrets
+     vars:
+       ansible_hashi_vault_auth_method: token
+       ansible_hashi_vault_token: '{{ login_data | community.hashi_vault.vault_login_token }}'
+       ansible_hashi_vault_engine_mount_point: kv
+       paths:
+         - secret
+         - secret2
+     ansible.builtin.debug:
+       msg: "{{ lookup('community.hashi_vault.vault_kv2_get', *paths, auth_method='token', url='https://vault.domain.local') }}"

examples/hashivault_plugin_read_secret.yaml

@@ -0,0 +1,18 @@
+- hosts: localhost
+  tasks:
+   - name: Read a kv2 secret with the default mount point
+     vars:
+       ansible_hashi_vault_auth_method: ldap
+       ansible_hashi_vault_username: username
+       ansible_hashi_vault_password: pwd
+       ansible_hashi_vault_engine_mount_point: kv
+     ansible.builtin.set_fact:
+       response: "{{ lookup('community.hashi_vault.vault_kv2_get', 'secret', url='https://vault.domain.local') }}"
+
+   - name: Display the results
+     ansible.builtin.debug:
+       msg:
+         - "Secret: {{ response.secret }}"
+         - "Data: {{ response.data }} (contains secret data & metadata in kv2)"
+         - "Metadata: {{ response.metadata }}"
+         - "Full response: {{ response.raw }}"

examples/hashivault_read_secret.yaml

@@ -0,0 +1,13 @@
+---
+- hosts: localhost
+  tasks:
+    - hashivault_read:
+        url: "https://vault.domain.local"
+        authtype: ldap
+        username: "uset"
+        password: "p@ssword"
+        mount_point: kv
+        secret: secret
+        key: foo
+        version: 2
+      register: key

examples/kubernetes.yaml

@@ -6,23 +6,23 @@
   tasks:
   - name: obtain JWT
     decort_jwt:
-      oauth2_url: ""                                     #"https://sso.digitalenergy.online"
+      oauth2_url: "https://sso.digitalenergy.online"
       validity: 1200
       verify_ssl: false
     register: token
     delegate_to: localhost
 
-  - name: create a VM named cloud-init_example
+  - name: create a VM named cluster-test
     decort_k8s:
       state: present
       started: True
       getConfig: True
       authenticator: jwt
       jwt: "{{ token.jwt }}"
-      controller_url: ""                                  #"https://mr4.digitalenergy.online"
+      controller_url: "https://ds1.digitalenergy.online"
       name: "cluster-test"
-      rg_id:                                              # Resource group id
-      k8ci_id:                                            # k8s ci id
+      rg_id:  125
+      k8ci_id: 18
       workers:
         - name: wg1
           ram: 1024

examples/rename-osimage.yaml

@@ -0,0 +1,15 @@
+---
+#
+# DECORT osimage module example
+#
+- hosts: localhost
+  tasks:
+  - name: rename_osimage 
+    decort_osimage:
+      authenticator: oauth2
+      controller_url: "https://ds1.digitalenergy.online"
+      image_name: "alpine_linux_3.14.0v2.0"
+      image_id: 54321
+    delegate_to: localhost
+    register: osimage
+

examples/vins_connect.yaml

@@ -0,0 +1,42 @@
+---
+#
+# DECORT vins module example
+#
+
+- hosts: localhost
+  tasks:
+  - name: obtain JWT
+    decort_jwt:
+      oauth2_url: "https://sso.digitalenergy.online"
+      validity: 1200
+    register: my_jwt
+    delegate_to: localhost
+
+  - name: print out JWT
+    debug:
+      var: my_jwt.jwt
+    delegate_to: localhost
+
+  - name: Manage ViNS at resource group level
+    decort_vins:
+      authenticator: jwt
+      jwt: "{{ my_jwt.jwt }}"
+      controller_url: "https://cloud.digitalenergy.online"
+      vins_name: "vins_connected_by_decort_vins_module"
+      state: present
+      rg_id: 98
+      connect_to:
+       - type: VINS
+         id: 864
+         ipaddr: 192.168.5.66
+         netmask: 24
+       - type: VINS
+         id: 196
+         ipaddr: 192.168.9.133
+         netmask: 24
+    register: managed_vins
+
+  - name: print VINS facter
+    debug:
+      msg: "{{managed_vins.facts.password}}"
+    when: managed_vins.facts.password is defined

library/decort_k8s.py

@@ -114,10 +114,10 @@ class decort_k8s(DecortController):
         return ret_dict
     
     def nop(self):
-        """No operation (NOP) handler for Compute management by decort_kvmvm module.
+        """No operation (NOP) handler for k8s cluster management by decort_k8s 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.
+        the actual k8s cluster state.
         """
         self.result['failed'] = False
         self.result['changed'] = False
@@ -319,7 +319,7 @@ def main():
         if amodule.params['state'] == 'absent':
             subj.nop()
         if amodule.params['state'] in ('present','started'):
-            subj.create()
+            subj.create() 
         elif amodule.params['state'] in ('stopped', 'disabled','enabled'):
             subj.error()
             

library/decort_kvmvm.py

@@ -794,7 +794,7 @@ class decort_kvmvm(DecortController):
             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),
+            ci_user_data=dict(type='list',elements='dict', required=False),
             state=dict(type='str',
                        default='present',
                        choices=['absent', 'paused', 'poweredoff', 'halted', 'poweredon', 'present', 'check']),

library/decort_osimage.py

@@ -22,8 +22,7 @@ description: >
      This module can be used to obtain image ID of an OS image in DECORT cloud to use with subsequent calls to
      decort_vm module for batch VM provisioning. It will speed up VM creation and save a bunch of extra calls to
      DECORT cloud controller on each VM creation act.
-     Note that this module is effectively an information provisioner. It is not designed to and does not manage 
-     nor change state of OS image (or any other) objects in DECORT cloud.
+
 version_added: "2.2"
 author:
      - Sergey Shubin <sergey.shubin@digitalenergy.online>
@@ -68,8 +67,8 @@ options:
     image_name:
         description:
         - Name of the OS image to use. Module will return the ID of this image.
-        - 'The specified image name will be looked up in the target DECORT controller and error will be generated if
-          no matching image is found.'
+        - 'The specified image name will be looked up in the target DECORT controller and error will be generated
+        - if no matching image is found.'
         required: yes
     jwt:
         description:
@@ -109,10 +108,6 @@ options:
         - 'This parameter is required when I(authenticator=legacy) and ignored for other authentication modes.'
         - If not specified in the playbook, the value will be taken from DECORT_USER environment variable.
         required: no
-    vdc_id:
-        description:
-        - ID of the VDC to limit the search of the OS image to.
-        required: no
     verify_ssl:
         description:
         - 'Controls SSL verification mode when making API calls to DECORT controller. Set it to False if you
@@ -134,19 +129,143 @@ options:
         - 'This context data is expected to uniquely identify the task carried out by this module invocation so
            that up-level orchestrator could match returned information to the its internal entities.'
         required: no
+    account_name:
+        description:
+        - 'Account name. Used to get a unique integer account ID.'
+        required: no
+    virt_id:
+        description:
+        - 'A unique integer identifier for the virtual image.'
+        - 'Can be used to obtain information about a virtual image, as well as to create a virtual image and 
+        - bind another operating system image to it.'
+        required: no
+    virt_name:
+        description:
+        - 'Name of the virtual image. Used to get the `virt_id`, and later information about the virtual image, 
+        - as well as to create a virtual image and bind another operating system image to it.'
+        required: no
+    state:
+        description:
+        - 'The state of the images. If set to present, operating system images will be created to which 
+        - the account specified in `account_Id` or `account_name` is bound. If set to absent, they will be removed.
+        required: no
+    drivers:
+        description:
+        - 'A list of compute types (eg virtual servers) that are appropriate for the operating system image. 
+        - Note: `KVM_X86`. Used when creating an operating system image.'
+        required: no
+    architecture:
+        description:
+        - 'Binary architecture of the image. Note. `X86_64` or `PPC64_LE`. Used when creating 
+        -an operating system image.'
+        required: no
+    imagetype:
+        description:
+        - 'Image type. `linux`, `windows` or `other`. The default is `linux`. Used when creating
+        - an operating system image.'
+        required: no
+    boottype:
+        description:
+        - 'Image upload type. `bios` or `uefi`. The default is `uefi`. Used when creating an operating 
+        -system image.'
+        required: no
+    url:
+        description:
+        - 'Uniform resource locator (URL) pointing to the iso image of the operating system. Used when 
+        -creating an operating system image.'
+        required: no
+    sepId:
+        description:
+        - 'The unique integer ID of the storage provider endpoint. Specified in pair with `poolName`. 
+        - Used when creating an operating system image.'
+        required: no
+    poolName:
+        description:
+        - 'The pool in which the image will be created. Specified in pair with `sepId`. Used when creating
+        - an operating system image.'
+        required: no
+    hotresize:
+        description:
+        - 'Whether the image supports "hot" resizing. The default is `false`. Used when creating an operating
+        - system image.'
+        required: no
+    image_username:
+        description:
+        - 'An optional username for the image. Used when creating an operating system image.'
+        required: no
+    image_password:
+        description:
+        - 'An optional password for the image. Used when creating an operating system image. Used when creating
+        - an operating system image.'
+        required: no
+    usernameDL:
+        description:
+        - 'The username for loading the binary media. Used in conjunction with `passwordDL`. Used when creating
+        - an operating system image'
+        required: no
+    passwordDL:
+        description:
+        - 'The password for loading the binary media. Used in conjunction with `usernameDL`. Used when creating
+        - an operating system image.'
+        required: no
+    permanently:
+        description:
+        - 'Whether to permanently delete the image. Used when deleting an image. The default is false.'
+        required: no
+
 '''
 
 EXAMPLES = '''
-- name: locate OS image specified by its name, store result in image_to_use variable.
+  - name: create_osimage 
     decort_osimage:
       authenticator: oauth2
-      app_id: "{{ MY_APP_ID }}"
-      app_secret: "{{ MY_APP_SECRET }}"
+      verify_ssl: False
       controller_url: "https://ds1.digitalenergy.online"
-      image_name: "Ubuntu 18.04 v1.2.5"
-      account_name: "GreyseDevelopment"
+      state: present
+      image_name: "alpine_linux3.14.0"
+      account_Id: 12345
+      url: "https://dl-cdn.alpinelinux.org/alpine/v3.14/releases/x86_64/alpine-virt-3.14.0-x86_64.iso"
+      boottype: "uefi"
+      imagetype: "linux"
+      hotresize: False
+      image_username: "test"
+      image_password: "p@ssw0rd"
+      usernameDL: "testDL"
+      passwordDL: "p@ssw0rdDL"
+      architecture: "X86_64"
+      drivers: "KVM_X86"
     delegate_to: localhost
-    register: image_to_use
+    register: osimage
+
+  - name: get_osimage 
+    decort_osimage:
+      authenticator: oauth2
+      controller_url: "https://ds1.digitalenergy.online"
+      image_name: "alpine_linux_3.14.0"
+      account_Id: 12345
+    delegate_to: localhost
+    register: osimage
+
+  - name: create_virtual_osimage 
+    decort_osimage:
+      authenticator: oauth2
+      controller_url: "https://ds1.digitalenergy.online"
+      image_name: "alpine_linux_3.14.0"
+      virt_name: "alpine_last"
+    delegate_to: localhost
+    register: osimage
+
+  - name: rename_osimage 
+    decort_osimage:
+      authenticator: oauth2
+      controller_url: "https://ds1.digitalenergy.online"
+      image_name: "alpine_linux_3.14.0v2.0"
+      image_id: 54321
+    delegate_to: localhost
+    register: osimage
+
+
+
 '''
 
 RETURN = '''
@@ -157,6 +276,7 @@ facts:
     sample:
       facts:
         id: 100
+        linkto: 80
         name: "Ubuntu 16.04 v1.0"
         size: 3
         sep_id: 1
@@ -171,94 +291,205 @@ from ansible.module_utils.basic import env_fallback
 
 from ansible.module_utils.decort_utils import *
 
+class decort_osimage(DecortController):
+    def __init__(self,amodule):
+        super(decort_osimage, self).__init__(amodule)
 
-def decort_osimage_package_facts(arg_osimage_facts, arg_check_mode=False):
-    """Package a dictionary of OS image according to the decort_osimage module specification. This 
-    dictionary will be returned to the upstream Ansible engine at the completion of the module run.
+        self.validated_image_id = 0
+        self.validated_virt_image_id = 0
+        self.validated_image_name = amodule.params['image_name']
+        self.validated_virt_image_name = None
+        self.validated_virt_image_id = amodule.params['virt_id']
+        if amodule.params['account_name']:
+            self.validated_account_id, _ = self.account_find(amodule.params['account_name'])
+        else:
+            self.validated_account_id = amodule.params['account_Id']
+        
+        if self.validated_account_id == 0:
+            # we failed either to find or access the specified account - fail the module
+            self.result['failed'] = True
+            self.result['changed'] = False
+            self.result['msg'] = ("Cannot find account '{}'").format(amodule.params['account_name'])
+            amodule.fail_json(**self.result)
 
-    @param arg_osimage_facts: dictionary with OS image facts as returned by API call to .../images/list
-    @param arg_check_mode: boolean that tells if this Ansible module is run in check mode.
 
-    @return: dictionary with OS image specs populated from arg_osimage_facts.
-    """
+        if amodule.params['image_id'] != 0 and amodule.params['image_name']:
+            self.validated_image_id = amodule.params['image_id']
+            if amodule.params['image_name']:
+                decort_osimage.decort_image_rename(self,amodule)
+                self.result['msg'] = ("Image renamed successfully")
 
-    ret_dict = dict(id=0,
-                    name="none",
-                    size=0,
-                    type="none",
-                    state="CHECK_MODE",
-                    )
 
-    if arg_check_mode:
-        # in check mode return immediately with the default values
-        return ret_dict
 
-    if arg_osimage_facts is None:
-        # if void facts provided - change state value to ABSENT and return
-        ret_dict['state'] = "ABSENT"
-        return ret_dict
+    def decort_image_find(self, amodule):
+        # function that finds the OS image
+        image_id, image_facts = self.image_find(image_id=amodule.params['image_id'], image_name=self.validated_image_name,
+                                                account_id=self.validated_account_id, rg_id=0,
+                                                sepid=amodule.params['sep_id'],
+                                                pool=amodule.params['pool'])
+        return image_id, image_facts
+
+    def decort_virt_image_find(self, amodule):
+        # function that finds a virtual image
+        image_id, image_facts = self.virt_image_find(image_id=amodule.params['virt_id'],
+                                                    account_id=self.validated_account_id, rg_id=0,
+                                                    sepid=amodule.params['sep_id'],
+                                                    virt_name=amodule.params['virt_name'],
+                                                    pool=amodule.params['pool'])
+        return image_id, image_facts
+
+
+
+    def decort_image_create(self,amodule):
+        # function that creates OS image
+        image_facts = self.image_create(img_name=self.validated_image_name, 
+                        url=amodule.params['url'], 
+                        gid=amodule.params['gid'], 
+                        boottype=amodule.params['boottype'],
+                        imagetype=amodule.params['imagetype'],
+                        hotresize=amodule.params['hotresize'],
+                        username=amodule.params['image_username'],
+                        password=amodule.params['image_password'],
+                        account_Id=amodule.params['account_Id'],
+                        usernameDL=amodule.params['usernameDL'],
+                        passwordDL=amodule.params['passwordDL'],
+                        sepId=amodule.params['sepId'],
+                        poolName=amodule.params['poolName'],
+                        architecture=amodule.params['architecture'],
+                        drivers=amodule.params['drivers'])
+        self.result['changed'] = True
+        return image_facts
+
+    def decort_virt_image_link(self,amodule):
+        # function that links an OS image to a virtual one
+        self.virt_image_link(imageId=self.validated_virt_image_id, targetId=self.validated_image_id)
+        image_id, image_facts = decort_osimage.decort_virt_image_find(self, amodule)
+        self.result['facts'] = decort_osimage.decort_osimage_package_facts(image_facts, amodule.check_mode)
+        self.result['msg'] = ("Image '{}' linked to virtual image '{}'").format(self.validated_image_id,
+                                                                                decort_osimage.decort_osimage_package_facts(image_facts)['id'],)
+        return image_id, image_facts
     
-    ret_dict['id'] = arg_osimage_facts['id']
-    ret_dict['name'] = arg_osimage_facts['name']
-    ret_dict['size'] = arg_osimage_facts['size']
-    ret_dict['type'] = arg_osimage_facts['type']
-    # ret_dict['arch'] = arg_osimage_facts['architecture']
-    ret_dict['sep_id'] = arg_osimage_facts['sepId']
-    ret_dict['pool'] = arg_osimage_facts['pool']
-    ret_dict['state'] = arg_osimage_facts['status']
+    def decort_image_delete(self,amodule):
+        # function that removes an image
+        self.image_delete(imageId=amodule.image_id_delete, permanently=amodule.params['permanently'])
+        self.result['changed'] = True
+        self.result['msg'] = ("Image '{}' deleted").format(amodule.image_id_delete)
 
-    return ret_dict
+    def decort_virt_image_create(self,amodule):
+        # function that creates a virtual image
+        image_facts = self.virt_image_create(name=amodule.params['virt_name'], targetId=self.validated_image_id)
+        image_id, image_facts = decort_osimage.decort_virt_image_find(self, amodule)
+        self.result['facts'] = decort_osimage.decort_osimage_package_facts(image_facts, amodule.check_mode)
+        return image_id, image_facts
+    
+    def decort_image_rename(self,amodule):
+        # image renaming function
+        image_facts = self.image_rename(imageId=self.validated_image_id, name=amodule.params['image_name'])
+        self.result['msg'] = ("Image renamed successfully")
+        image_id, image_facts = decort_osimage.decort_image_find(self, amodule)
+        return image_id, image_facts
 
-def decort_osimage_parameters():
-    """Build and return a dictionary of parameters expected by decort_osimage module in a form accepted
-    by AnsibleModule utility class."""
 
-    return dict(
-        app_id=dict(type='str',
-                    required=False,
-                    fallback=(env_fallback, ['DECORT_APP_ID'])),
-        app_secret=dict(type='str',
+    def decort_osimage_package_facts(arg_osimage_facts, arg_check_mode=False):
+        """Package a dictionary of OS image according to the decort_osimage module specification. This
+        dictionary will be returned to the upstream Ansible engine at the completion of the module run.
+
+        @param arg_osimage_facts: dictionary with OS image facts as returned by API call to .../images/list
+        @param arg_check_mode: boolean that tells if this Ansible module is run in check mode.
+
+        @return: dictionary with OS image specs populated from arg_osimage_facts.
+        """
+
+        ret_dict = dict(id=0,
+                        name="none",
+                        size=0,
+                        type="none",
+                        state="CHECK_MODE",                        )
+
+        if arg_check_mode:
+            # in check mode return immediately with the default values
+            return ret_dict
+
+        if arg_osimage_facts is None:
+            # if void facts provided - change state value to ABSENT and return
+            ret_dict['state'] = "ABSENT"
+            return ret_dict
+    
+        ret_dict['id'] = arg_osimage_facts['id']
+        ret_dict['name'] = arg_osimage_facts['name']
+        ret_dict['size'] = arg_osimage_facts['size']
+        ret_dict['type'] = arg_osimage_facts['type']
+        # ret_dict['arch'] = arg_osimage_facts['architecture']
+        ret_dict['sep_id'] = arg_osimage_facts['sepId']
+        ret_dict['pool'] = arg_osimage_facts['pool']
+        ret_dict['state'] = arg_osimage_facts['status']
+        ret_dict['linkto'] = arg_osimage_facts['linkTo']
+        return ret_dict
+
+
+    def decort_osimage_parameters():
+        """Build and return a dictionary of parameters expected by decort_osimage module in a form accepted
+        by AnsibleModule utility class."""
+
+        return dict(
+            app_id=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),
-        image_name=dict(type='str', required=True),
-        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',
+                        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),
+            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),
+            pool=dict(type='str', required=False, default=""),
+            sep_id=dict(type='int', required=False, default=0),
+            account_name=dict(type='str', required=False),
+            account_Id=dict(type='int', required=False),
+            user=dict(type='str',
                       required=False,
-                      fallback=(env_fallback, ['DECORT_PASSWORD']),
-                      no_log=True),
-        pool=dict(type='str', required=False, default=""),
-        sep_id=dict(type='int', required=False, default=0),
-        account_name=dict(type='str', required=True),
-        user=dict(type='str',
-                  required=False,
-                  fallback=(env_fallback, ['DECORT_USER'])),
-        vdc_id=dict(type='int', required=False, default=0),
-        verify_ssl=dict(type='bool', required=False, default=True),
-        workflow_callback=dict(type='str', required=False),
-        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) obtain a list of OS images accessible to the specified account (and optionally - within 
-#    the specified VDC)
-# 3) match specified OS image by its name - if image is not found abort the module
-# 5) report result to Ansible
+                      fallback=(env_fallback, ['DECORT_USER'])),
+            verify_ssl=dict(type='bool', required=False, default=True),
+            workflow_callback=dict(type='str', required=False),
+            workflow_context=dict(type='str', required=False),
+            image_name=dict(type='str', required=False),
+            image_id=dict(type='int', required=False,default=0),
+            virt_id=dict(type='int', required=False, default=0),
+            virt_name=dict(type='str', required=False),
+            state=dict(type='str',
+                   default='present',
+                   choices=['absent', 'present']),
+            drivers=dict(type='str', required=False, default="KVM_X86"),
+            architecture=dict(type='str', required=False, default="X86_64"),
+            imagetype=dict(type='str', required=False, default="linux"),
+            boottype=dict(type='str', required=False, default="uefi"),
+            url=dict(type='str', required=False),
+            gid=dict(type='int', required=False, default=0),
+            sepId=dict(type='int', required=False, default=0),
+            poolName=dict(type='str', required=False),
+            hotresize=dict(type='bool', required=False, default=False),
+            image_username=dict(type='str', required=False),
+            image_password=dict(type='str', required=False),
+            usernameDL=dict(type='str', required=False),
+            passwordDL=dict(type='str', required=False),
+            permanently=dict(type='bool', required=False, default=False),
+        )
+        
 
 def main():
-    module_parameters = decort_osimage_parameters()
+    module_parameters = decort_osimage.decort_osimage_parameters()
 
     amodule = AnsibleModule(argument_spec=module_parameters,
                             supports_check_mode=True,
@@ -273,30 +504,67 @@ def main():
                             ],
                             )
 
-    decon = DecortController(amodule)
+    decon = decort_osimage(amodule)
+
+    if amodule.params['image_name'] or amodule.params['image_id']:
+        image_id, image_facts = decort_osimage.decort_image_find(decon, amodule)
+        decon.validated_image_id = decort_osimage.decort_osimage_package_facts(image_facts)['id']
+        if decort_osimage.decort_osimage_package_facts(image_facts)['id'] > 0:
+            decon.result['facts'] = decort_osimage.decort_osimage_package_facts(image_facts, amodule.check_mode)
+
+    if amodule.params['state'] == "present" and decon.validated_image_id == 0 and amodule.params['image_name'] and amodule.params['url']:
+        decort_osimage.decort_image_create(decon,amodule)
+        decon.result['changed'] = True
+        image_id, image_facts = decort_osimage.decort_image_find(decon, amodule)
+        decon.result['msg'] = ("OS image '{}' created").format(decort_osimage.decort_osimage_package_facts(image_facts)['id'])
+        decon.result['facts'] = decort_osimage.decort_osimage_package_facts(image_facts, amodule.check_mode)
+        decon.validated_image_id = decort_osimage.decort_osimage_package_facts(image_facts)['id']
+
+    
+    elif amodule.params['state'] == "absent" and amodule.params['image_name'] or amodule.params['image_id'] and decort_osimage.decort_osimage_package_facts(image_facts)['accountId'] == amodule.params['account_Id']:
+        amodule.image_id_delete = decon.validated_image_id
+        decort_osimage.decort_image_delete(decon,amodule)
+    
+
+
+    if amodule.params['virt_name'] or amodule.params['virt_id']:
+
+        image_id, image_facts = decort_osimage.decort_virt_image_find(decon, amodule)
+        if decort_osimage.decort_osimage_package_facts(image_facts)['id'] > 0:
+            decon.result['facts'] = decort_osimage.decort_osimage_package_facts(image_facts, amodule.check_mode)
+        decon.validated_virt_image_id = decort_osimage.decort_osimage_package_facts(image_facts)['id']
+        decon.validated_virt_image_name = decort_osimage.decort_osimage_package_facts(image_facts)['name']
+
+
+        if decort_osimage.decort_osimage_package_facts(image_facts)['id'] == 0 and amodule.params['state'] == "present" and decon.validated_image_id > 0:
+            image_id, image_facts = decort_osimage.decort_virt_image_create(decon,amodule)
+            decon.result['msg'] = ("Virtual image '{}' created").format(decort_osimage.decort_osimage_package_facts(image_facts)['id'])
+            decon.result['changed'] = True
+        elif decort_osimage.decort_osimage_package_facts(image_facts)['id'] == 0 and amodule.params['state'] == "present" and decon.validated_image_id == 0:
+            decon.result['msg'] = ("Cannot find OS image")
+            amodule.fail_json(**decon.result)
+
+
+        if decon.validated_image_id:
+            if decort_osimage.decort_osimage_package_facts(image_facts)['linkto'] != decon.validated_image_id:
+                decort_osimage.decort_virt_image_link(decon,amodule)
+                decon.result['changed'] = True
+                amodule.exit_json(**decon.result)
+        
+
+        if decon.validated_virt_image_id > 0 and amodule.params['state'] == "absent":
+            decon.result['msg'] = ("Osimage module cannot delete virtual images.")
+            decon.result['failed'] = True
+            amodule.exit_json(**decon.result)
 
-    # we need account ID to locate OS images - find the account by the specified name and get its ID
-    validated_account_id, _ = decon.account_find(amodule.params['account_name'])
-    if validated_account_id == 0:
-        # we failed either to find or access the specified account - fail the module
-        decon.result['failed'] = True
-        decon.result['changed'] = False
-        decon.result['msg'] = ("Cannot find account '{}'").format(amodule.params['account_name'])
-        amodule.fail_json(**decon.result)
 
-    image_id, image_facts = decon.image_find(image_id=0, image_name=amodule.params['image_name'], 
-                                             account_id=validated_account_id, rg_id=0,
-                                             sepid=amodule.params['sep_id'],
-                                             pool=amodule.params['pool'])
     if decon.result['failed'] == True:
         # we failed to find the specified image - fail the module
         decon.result['changed'] = False
         amodule.fail_json(**decon.result)
 
-    decon.result['facts'] = decort_osimage_package_facts(image_facts, amodule.check_mode)
-    decon.result['changed'] = False # decort_osimage is a read-only module - make sure the 'changed' flag is set to False
     amodule.exit_json(**decon.result)
 
-
+    
 if __name__ == "__main__":
     main()

library/decort_vins.py

@@ -242,109 +242,289 @@ facts:
 
 from ansible.module_utils.basic import AnsibleModule
 from ansible.module_utils.basic import env_fallback
-import paramiko
 
 from ansible.module_utils.decort_utils import *
 
+class decort_vins(DecortController):
+    def __init__(self,arg_amodule):
+        super(decort_vins, self).__init__(arg_amodule)
 
-def decort_vins_package_facts(arg_vins_facts, arg_check_mode=False):
-    """Package a dictionary of ViNS facts according to the decort_vins module specification. 
-    This dictionary will be returned to the upstream Ansible engine at the completion of 
-    the module run.
+        vins_id = 0
+        vins_level = ""  # "ID" if specified by ID, "RG" - at resource group, "ACC" - at account level
+        vins_facts = None  # will hold ViNS facts
+        validated_rg_id = 0
+        rg_facts = None  # will hold RG facts
+        validated_acc_id = 0
+        acc_facts = None  # will hold Account facts
 
-    @param arg_vins_facts: dictionary with viNS facts as returned by API call to .../vins/get
-    @param arg_check_mode: boolean that tells if this Ansible module is run in check mode
-    """
+        if arg_amodule.params['vins_id']:
+            # expect existing ViNS with the specified ID
+            # This call to vins_find will abort the module if no ViNS with such ID is present
+            self.vins_id, self.vins_facts = self.vins_find(arg_amodule.params['vins_id'])
+            if not vins_id:
+                self.result['failed'] = True
+                self.result['msg'] = "Specified ViNS ID {} not found.".format(arg_amodule.params['vins_id'])
+                self.fail_json(**self.result)
+            vins_level = "ID"
+            validated_acc_id = vins_facts['accountId']
+            validated_rg_id = vins_facts['rgId']
+    
+        elif arg_amodule.params['rg_id']:
+            # expect ViNS @ RG level in the RG with specified ID
+            vins_level = "RG"
+            # This call to rg_find will abort the module if no RG with such ID is present
+            validated_rg_id, rg_facts = self.rg_find(0,  # account ID set to 0 as we search for RG by RG ID
+                                                    arg_amodule.params['rg_id'], arg_rg_name="")
+            
+            # This call to vins_find may return vins_id=0 if no ViNS found
+            self.vins_id, self.vins_facts = self.vins_find(vins_id=0, vins_name=arg_amodule.params['vins_name'],
+                                                account_id=0,
+                                                rg_id=arg_amodule.params['rg_id'],
+                                                rg_facts=rg_facts,
+                                                check_state=False)
+            # TODO: add checks and setup ViNS presence flags accordingly
+            pass
+        elif arg_amodule.params['account_id'] or arg_amodule.params['account_name'] != "":
+            # Specified account must be present and accessible by the user, otherwise abort the module
+            validated_acc_id, acc_facts = self.account_find(arg_amodule.params['account_name'], arg_amodule.params['account_id'])
+            if not validated_acc_id:
+                self.result['failed'] = True
+                self.result['msg'] = ("Current user does not have access to the requested account "
+                                    "or non-existent account specified.")
+                self.fail_json(**self.result)
+            if arg_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
+                validated_rg_id, rg_facts = self.rg_find(validated_acc_id, 0, arg_amodule.params['rg_name'])
+                if (not validated_rg_id or
+                        rg_facts['status'] in ["DESTROYING", "DESTROYED", "DELETING", "DELETED", "DISABLING", "ENABLING"]):
+                    self.result['failed'] = True
+                    self.result['msg'] = "RG name '{}' not found or has invalid state.".format(arg_amodule.params['rg_name'])
+                    self.fail_json(**self.result)
+                # This call to vins_find may return vins_id=0 if no ViNS with this name found under specified RG
+                self.vins_id, self.vins_facts = self.vins_find(vins_id=0, vins_name=arg_amodule.params['vins_name'],
+                                                    account_id=0,  # set to 0, as we are looking for ViNS under RG
+                                                    rg_id=validated_rg_id,
+                                                    rg_facts=rg_facts,
+                                                    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
+                # So we expect ViNS @ account level
+                # This call to vins_find may return vins_id=0 if no ViNS found
+                self.vins_id, self.vins_facts = self.vins_find(vins_id=0, vins_name=arg_amodule.params['vins_name'],
+                                                    account_id=validated_acc_id,
+                                                    rg_id=0,
+                                                    rg_facts=rg_facts,
+                                                    check_state=False)
+                vins_level = "ACC"
+                # TODO: add checks and setup ViNS presence flags accordingly
+        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
+            self.result['failed'] = True
+            if arg_amodule.params['account_id'] == 0 and arg_amodule.params['account_name'] == "":
+                self.result['msg'] = "Cannot find ViNS by name when account name is empty and account ID is 0."
+            if arg_amodule.params['rg_name'] == "":
+                # rg_name without account specified
+                self.result['msg'] = "Cannot find ViNS by name when RG name is empty and RG ID is 0."
+            self.fail_json(**self.result)
 
-    ret_dict = dict(id=0,
-                    name="none",
-                    state="CHECK_MODE",
-                    )
+            return
+        self.rg_id = validated_rg_id
+        self.acc_id = validated_acc_id
+        return 
+    def create(self):
+        self.vins_id = self.vins_provision(self.amodule.params['vins_name'],
+                                    self.acc_id, self.rg_id,
+                                    self.amodule.params['ipcidr'],
+                                    self.amodule.params['ext_net_id'], self.amodule.params['ext_ip_addr'],
+                                    self.amodule.params['annotation'])
+        
+        if self.amodule.params['mgmtaddr'] or self.amodule.params['connect_to']:
+            _, self.vins_facts = self.vins_find(self.vins_id)                  
+        if self.amodule.params['connect_to']:
+            self.vins_update_ifaces(self.vins_facts,self.amodule.params['connect_to'],)
+        if self.amodule.params['mgmtaddr']:
+            self.vins_update_mgmt(self.vins_facts,self.amodule.params['mgmtaddr'])
+            
+        return
+    def action(self,d_state='',restore=False):
+        if restore == True:
+            self.vins_restore(arg_vins_id=self.vins_id)
+            self.vins_state(self.vins_facts, 'enabled')
+            self.vins_facts['status'] = "ENABLED"
+            self.vins_facts['VNFDev']['techStatus'] = "STARTED"    
+        
+        self.vins_update_extnet(self.vins_facts,
+                         self.amodule.params['ext_net_id'], 
+                         self.amodule.params['ext_ip_addr'],
+                        )
+        
+        if d_state == 'enabled' and self.vins_facts['status'] == "DISABLED":
+            self.vins_state(self.vins_facts, d_state)
+            self.vins_facts['status'] = "ENABLED"
+            self.vins_facts['VNFDev']['techStatus'] = "STARTED"
+            d_state = ''
+
+        if self.vins_facts['status'] == "ENABLED" and self.vins_facts['VNFDev']['techStatus'] == "STARTED":
+            self.vins_update_ifaces(self.vins_facts,
+                                    self.amodule.params['connect_to'],
+                                )
+            if self.result['changed']:
+                _, self.vins_facts = self.vins_find(self.vins_id)
+            self.vins_update_mgmt(self.vins_facts,
+                                self.amodule.params['mgmtaddr'],
+                                )
+        
+        if d_state != '':
+            self.vins_state(self.vins_facts, d_state)
+        return
+    def delete(self):
+        self.vins_delete(self.vins_id, permanently=True)
+        self.vins_facts['status'] = 'DESTROYED'
+        return
+    def nop(self):
+        """No operation (NOP) handler for ViNS management by decort_vins 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 ViNS state.
+        """
+        self.result['failed'] = False
+        self.result['changed'] = False
+        if self.vins_id:
+            self.result['msg'] = ("No state change required for ViNS  ID {} because of its "
+                                   "current status '{}'.").format(self.vins_id, self.vins_facts['status'])
+        else:
+            self.result['msg'] = ("No state change to '{}' can be done for "
+                                  "non-existent ViNS instance.").format(self.amodule.params['state'])
+        return
+    def error(self):
+        self.result['failed'] = True
+        self.result['changed'] = False
+        if self.vins_id:
+            self.result['failed'] = True
+            self.result['changed'] = False
+            self.result['msg'] = ("Invalid target state '{}' requested for ViNS ID {} in the "
+                                    "current status '{}'").format(self.vins_id,
+                                                                    self.amodule.params['state'],
+                                                                    self.vins_facts['status'])
+        else:
+            self.result['failed'] = True
+            self.result['changed'] = False
+            self.result['msg'] = ("Invalid target state '{}' requested for non-existent "
+                                   "ViNS name '{}'").format(self.amodule.params['state'],
+                                                            self.amodule.params['vins_name'])   
+        return
+    def package_facts(self, arg_check_mode=False):
+        """Package a dictionary of ViNS facts according to the decort_vins module specification. 
+        This dictionary will be returned to the upstream Ansible engine at the completion of 
+        the module run.
+
+        @param arg_check_mode: boolean that tells if this Ansible module is run in check mode
+        """
+
+        ret_dict = dict(id=0,
+                        name="none",
+                        state="CHECK_MODE",
+                        )
+
+        if arg_check_mode:
+            # in check mode return immediately with the default values
+            return ret_dict
+
+        if self.vins_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.vins_facts['id']
+        ret_dict['name'] = self.vins_facts['name']
+        ret_dict['state'] = self.vins_facts['status']
+        ret_dict['account_id'] = self.vins_facts['accountId']
+        ret_dict['rg_id'] = self.vins_facts['rgId']
+        ret_dict['int_net_addr'] = self.vins_facts['network']
+        ret_dict['gid'] = self.vins_facts['gid']
+        custom_interfaces = list(filter(lambda i: i['type']=="CUSTOM",self.vins_facts['VNFDev']['interfaces']))
+        if custom_interfaces:
+            ret_dict['custom_net_addr'] = []
+            for runner in custom_interfaces:
+                ret_dict['custom_net_addr'].append(runner['ipAddress'])
+        mgmt_interfaces = list(filter(lambda i: i['listenSsh'] and i['name']!="ens9",self.vins_facts['VNFDev']['interfaces']))
+        if mgmt_interfaces:
+            ret_dict['ssh_ipaddr'] = []
+            for runner in mgmt_interfaces:
+                ret_dict['ssh_ipaddr'].append(runner['ipAddress'])
+            ret_dict['ssh_password'] = self.vins_facts['VNFDev']['config']['mgmt']['password']
+            ret_dict['ssh_port'] = 9022
+        if self.vins_facts['vnfs'].get('GW'):
+            gw_config = self.vins_facts['vnfs']['GW']['config']
+            ret_dict['ext_ip_addr'] = gw_config['ext_net_ip']
+            ret_dict['ext_net_id'] = gw_config['ext_net_id']
+        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
 
-    if arg_check_mode:
-        # in check mode return immediately with the default values
         return ret_dict
 
-    if arg_vins_facts is None:
-        # if void facts provided - change state value to ABSENT and return
-        ret_dict['state'] = "ABSENT"
-        return ret_dict
+    @staticmethod
+    def build_parameters():
+        """Build and return a dictionary of parameters expected by decort_vins module in a form accepted
+        by AnsibleModule utility class."""
 
-    ret_dict['id'] = arg_vins_facts['id']
-    ret_dict['name'] = arg_vins_facts['name']
-    ret_dict['state'] = arg_vins_facts['status']
-    ret_dict['account_id'] = arg_vins_facts['accountId']
-    ret_dict['rg_id'] = arg_vins_facts['rgId']
-    ret_dict['int_net_addr'] = arg_vins_facts['network']
-    ret_dict['gid'] = arg_vins_facts['gid']
-
-    if arg_vins_facts['vnfs'].get('GW'):
-        gw_config = arg_vins_facts['vnfs']['GW']['config']
-        ret_dict['ext_ip_addr'] = gw_config['ext_net_ip']
-        ret_dict['ext_net_id'] = gw_config['ext_net_id']
-    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."""
-
-    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',
+        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=''),
+            ext_net_id=dict(type='int', required=False, default=-1),
+            ext_ip_addr=dict(type='str', required=False, default=''),
+            ipcidr=dict(type='str', required=False, default=''),
+            mgmtaddr=dict(type='list',required=False, default=[]),
+            custom_config=dict(type='bool',required=False, default=False),
+            config_save=dict(type='bool',required=False, default=False),
+            connect_to=dict(type='list', default=[], required=False),
+            jwt=dict(type='str',
                     required=False,
-                    fallback=(env_fallback, ['DECORT_APP_ID'])),
-        app_secret=dict(type='str',
+                    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_APP_SECRET']),
+                        fallback=(env_fallback, ['DECORT_PASSWORD']),
                         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=''),
-        ext_net_id=dict(type='int', required=False, default=-1),
-        ext_ip_addr=dict(type='str', required=False, default=''),
-        ipcidr=dict(type='str', required=False, default=''),
-        mgmtaddr=dict(type='str',required=False, default=''),
-        custom_config=dict(type='bool',required=False, default=False),
-        config_save=dict(type='bool',required=False, default=False),
-        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),
-        state=dict(type='str',
-                   default='present',
-                   choices=['absent', 'disabled', 'enabled', 'present']),
-        user=dict(type='str',
-                  required=False,
-                  fallback=(env_fallback, ['DECORT_USER'])),
-        rg_id=dict(type='int', required=False, default=0),
-        rg_name=dict(type='str', required=False, default=''),
-        verify_ssl=dict(type='bool', required=False, default=True),
-        vins_id=dict(type='int', required=False, default=0),
-        vins_name=dict(type='str', required=True),
-        workflow_callback=dict(type='str', required=False),
-        workflow_context=dict(type='str', required=False),
-    )
+            state=dict(type='str',
+                    default='present',
+                    choices=['absent', 'disabled', 'enabled', 'present']),
+            user=dict(type='str',
+                    required=False,
+                    fallback=(env_fallback, ['DECORT_USER'])),
+            rg_id=dict(type='int', required=False, default=0),
+            rg_name=dict(type='str', required=False, default=''),
+            verify_ssl=dict(type='bool', required=False, default=True),
+            vins_id=dict(type='int', required=False, default=0),
+            vins_name=dict(type='str', required=True),
+            workflow_callback=dict(type='str', required=False),
+            workflow_context=dict(type='str', required=False),
+        )
 
 
 # Workflow digest:
@@ -355,7 +535,7 @@ def decort_vins_parameters():
 # 5) report result to Ansible
 
 def main():
-    module_parameters = decort_vins_parameters()
+    module_parameters = decort_vins.build_parameters()
 
     amodule = AnsibleModule(argument_spec=module_parameters,
                             supports_check_mode=True,
@@ -370,84 +550,7 @@ def main():
                             ],
                             )
 
-    decon = DecortController(amodule)
-
-    vins_id = 0
-    vins_level = ""  # "ID" if specified by ID, "RG" - at resource group, "ACC" - at account level
-    vins_facts = None  # will hold ViNS facts
-    validated_rg_id = 0
-    rg_facts = None  # will hold RG facts
-    validated_acc_id = 0
-    acc_facts = None  # will hold Account facts
-
-    if amodule.params['vins_id']:
-        # expect existing ViNS with the specified ID
-        # This call to vins_find will abort the module if no ViNS with such ID is present
-        vins_id, vins_facts = decon.vins_find(amodule.params['vins_id'])
-        if not vins_id:
-            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"
-        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"
-        # 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
-                                                  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,
-                                              rg_id=amodule.params['rg_id'],
-                                              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
-        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.")
-            decon.fail_json(**decon.result)
-        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
-            validated_rg_id, rg_facts = decon.rg_find(validated_acc_id, 0, amodule.params['rg_name'])
-            if (not validated_rg_id or
-                    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
-                                                  rg_id=validated_rg_id,
-                                                  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
-            # 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,
-                                                  rg_id=0,
-                                                  check_state=False)
-            vins_level = "ACC"
-            # TODO: add checks and setup ViNS presence flags accordingly
-    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
-        if amodule.params['account_id'] == 0 and amodule.params['account_name'] == "":
-            decon.result['msg'] = "Cannot find ViNS by name when account name is empty and account ID is 0."
-        if amodule.params['rg_name'] == "":
-            # rg_name without account specified
-            decon.result['msg'] = "Cannot find ViNS by name when RG name is empty and RG ID is 0."
-        decon.fail_json(**decon.result)
+    decon = decort_vins(amodule)
     #
     # Initial validation of module arguments is complete
     #
@@ -464,119 +567,70 @@ def main():
     # if cconfig_save is true, only config save without other updates
     vins_should_exist = False
 
-    if vins_id:
+    if decon.vins_id:
         vins_should_exist = True
-        if vins_facts['status'] in ["MODELED", "DISABLING", "ENABLING", "DELETING", "DESTROYING"]:
+        if decon.vins_facts['status'] in ["MODELED", "DISABLING", "ENABLING", "DELETING", "DESTROYING"]:
             # error: nothing can be done to existing ViNS in the listed statii regardless of
             # the requested state
             decon.result['failed'] = True
             decon.result['changed'] = False
             decon.result['msg'] = ("No change can be done for existing ViNS ID {} because of its current "
-                                   "status '{}'").format(vins_id, vins_facts['status'])
-        elif vins_facts['status'] == "DISABLED":
+                                   "status '{}'").format(decon.vins_id, decon.vins_facts['status'])
+        elif decon.vins_facts['status'] == "DISABLED":
             if amodule.params['state'] == 'absent':
-                decon.vins_delete(vins_id, permanently=True)
-                vins_facts['status'] = 'DESTROYED'
+                decon.delete()
                 vins_should_exist = False
             elif amodule.params['state'] in ('present', 'disabled'):
                 # update ViNS, leave in disabled state
-                decon.vins_update(vins_facts,
-                                  amodule.params['ext_net_id'], amodule.params['ext_ip_addr'])
+                decon.action()
             elif amodule.params['state'] == 'enabled':
                 # update ViNS and enable
-                decon.vins_update(vins_facts,
-                                  amodule.params['ext_net_id'], amodule.params['ext_ip_addr'])
-                decon.vins_state(vins_facts, 'enabled')
-        elif vins_facts['status'] in ["CREATED", "ENABLED"]:
+                decon.action('enabled')
+        elif decon.vins_facts['status'] in ["CREATED", "ENABLED"]:
             if amodule.params['state'] == 'absent':
-                decon.vins_delete(vins_id, permanently=True)
-                vins_facts['status'] = 'DESTROYED'
+                decon.delete()
                 vins_should_exist = False
             elif amodule.params['state'] in ('present', 'enabled'):
                 # update ViNS
-                decon.vins_update(vins_facts,
-                                  amodule.params['ext_net_id'], amodule.params['ext_ip_addr'],
-                                  amodule.params['mgmtaddr'],
-                                  )
+                decon.action()
             elif amodule.params['state'] == 'disabled':
                 # disable and update ViNS
-                decon.vins_state(vins_facts, 'disabled')
-                decon.vins_update(vins_facts,
-                                  amodule.params['ext_net_id'], amodule.params['ext_ip_addr'])
-        elif vins_facts['status'] == "DELETED":
+                decon.action('disabled')
+        elif decon.vins_facts['status'] == "DELETED":
             if amodule.params['state'] in ['present', 'enabled']:
                 # restore and enable
-                decon.vins_restore(arg_vins_id=vins_id)
-                decon.vins_state(vins_facts, 'enabled')
+                decon.action(restore=True)
                 vins_should_exist = True
             elif amodule.params['state'] == 'absent':
                 # destroy permanently
-                decon.vins_delete(vins_id, permanently=True)
-                vins_facts['status'] = 'DESTROYED'
+                decon.delete()
                 vins_should_exist = False
             elif amodule.params['state'] == 'disabled':
-                # error
-                decon.result['failed'] = True
-                decon.result['changed'] = False
-                decon.result['msg'] = ("Invalid target state '{}' requested for ViNS ID {} in the "
-                                       "current status '{}'").format(vins_id,
-                                                                     amodule.params['state'],
-                                                                     vins_facts['status'])
+                decon.error()
                 vins_should_exist = False
-        elif vins_facts['status'] == "DESTROYED":
+        elif decon.vins_facts['status'] == "DESTROYED":
             if amodule.params['state'] in ('present', 'enabled'):
-                # need to re-provision ViNS; some attributes may be changed, some stay the same.
-                # account and RG - stays the same
-                # vins_name - stays the same
-                # IPcidr - take from module arguments
-                # ext IP address - take from module arguments
-                # annotation - take from module arguments
-                vins_id = decon.vins_provision(vins_facts['name'],
-                                               validated_acc_id, validated_rg_id,
-                                               amodule.params['ipcidr'],
-                                               amodule.params['ext_net_id'], amodule.params['ext_ip_addr'],
-                                               amodule.params['annotation'])
+                # need to re-provision ViNS;
+                decon.create()
                 vins_should_exist = True
             elif amodule.params['state'] == 'absent':
-                # nop
-                decon.result['failed'] = False
-                decon.result['changed'] = False
-                decon.result['msg'] = ("No state change required for ViNS ID {} because of its "
-                                       "current status '{}'").format(vins_id,
-                                                                     vins_facts['status'])
+                decon.nop()
                 vins_should_exist = False
             elif amodule.params['state'] == 'disabled':
-                # error
-                decon.result['failed'] = True
-                decon.result['changed'] = False
-                decon.result['msg'] = ("Invalid target state '{}' requested for ViNS ID {} in the "
-                                       "current status '{}'").format(vins_id,
-                                                                     amodule.params['state'],
-                                                                     vins_facts['status'])
+                decon.error()
     else:
         # Preexisting ViNS was not found.
         vins_should_exist = False  # we will change it back to True if ViNS is created or restored
         # If requested state is 'absent' - nothing to do
         if amodule.params['state'] == 'absent':
-            decon.result['failed'] = False
-            decon.result['changed'] = False
-            decon.result['msg'] = ("Nothing to do as target state 'absent' was requested for "
-                                   "non-existent ViNS name '{}'").format(amodule.params['vins_name'])
+            decon.nop()
         elif amodule.params['state'] in ('present', 'enabled'):
             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,
-                                           amodule.params['ipcidr'],
-                                           amodule.params['ext_net_id'], amodule.params['ext_ip_addr'],
-                                           amodule.params['annotation'])
+            decon.create()
             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'])
+            decon.error()
     #
     # conditional switch end - complete module run
     #
@@ -584,18 +638,9 @@ def main():
         amodule.fail_json(**decon.result)
     else:
         # prepare ViNS facts to be returned as part of decon.result and then call exit_json(...)
-        if vins_should_exist:
-            if decon.result['changed']:
-                # If we arrive here, there is a good chance that the ViNS is present - get fresh ViNS
-                # facts from # the cloud by ViNS ID.
-                # Otherwise, ViNS facts from previous call (when the ViNS was still in existence) will
-                # be returned.
-                _, vins_facts = decon.vins_find(vins_id)
-        decon.result['facts'] = decort_vins_package_facts(vins_facts, amodule.check_mode)
-        # add password to facts if mgmtaddr is present
-        # need reworking
-        if amodule.params['mgmtaddr'] != "":
-            decon.result['facts'].update({'password': vins_facts['VNFDev']['config']['mgmt']['password']})
+        if decon.result['changed']:
+            _, decon.vins_facts = decon.vins_find(decon.vins_id)
+        decon.result['facts'] = decon.package_facts(amodule.check_mode)
         amodule.exit_json(**decon.result)
 
 

module_utils/decort_utils.py

@@ -1247,26 +1247,25 @@ class DecortController(object):
     def image_find(self, image_id, image_name, account_id, rg_id=0, sepid=0, pool=""):
         """Locates image specified by name and returns its facts as dictionary.
         Primary use of this function is to obtain the ID of the image identified by its name and,
-        optionally SEP ID and/or pool name. Also note that only images in status CREATED are 
+        optionally SEP ID and/or pool name. Also note that only images in status CREATED are
         returned.
 
         @param (string) image_id: ID of the OS image to find. If non-zero ID is specified, then
         image_name is ignored.
         @param (string) image_name: name of the OS image to find. This argument is ignored if non-zero
         image ID is passed.
-         @param (int) account_id: ID of the account for which the image will be looked up. If set to 0, 
+         @param (int) account_id: ID of the account for which the image will be looked up. If set to 0,
         the account ID will be obtained from the specified RG ID.
         @param (int) rg_id: ID of the RG to use as a reference when listing OS images. This argument is
         ignored if non-zero image id and/or non-zero account_id are specified.
-        @param (int) sepid: ID of the SEP where the image should be present. If set to 0, there will be no 
+        @param (int) sepid: ID of the SEP where the image should be present. If set to 0, there will be no
         filtering by SEP ID and the first matching image will be returned.
-        @param (string) pool: name of the pool where the image should be present. If set to empty string, there 
+        @param (string) pool: name of the pool where the image should be present. If set to empty string, there
         will be no filtering by pool name and first matching image will be returned.
 
-        @return: image ID and dictionary with image specs. If no matching image found, 0 for ID and None for 
+        @return: image ID and dictionary with image specs. If no matching image found, 0 for ID and None for
         dictionary are returned, and self.result['failed']=True.
         """
-
         self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "image_find")
 
         if image_id > 0:
@@ -1292,7 +1291,7 @@ class DecortController(object):
             for image_record in images_list:
                 if image_record['name'] == image_name and image_record['status'] == "CREATED":
                     if sepid == 0 and pool == "":
-                        # if no filtering by SEP ID or pool name is requested, return the first match 
+                        # if no filtering by SEP ID or pool name is requested, return the first match
                         return image_record['id'], image_record
                     # if positive SEP ID and/or non-emtpy pool name are passed, match by them
                     full_match = True
@@ -1302,6 +1301,7 @@ class DecortController(object):
                         full_match = False
                     if full_match:
                         return image_record['id'], image_record
+            self.result['failed'] = False
 
         self.result['failed'] = True
         self.result['msg'] = ("Failed to find OS image by name '{}', SEP ID {}, pool '{}' for "
@@ -1310,6 +1310,136 @@ class DecortController(object):
                                                          account_id)
         return 0, None
 
+    def virt_image_find(self, image_id, virt_name, account_id, rg_id=0, sepid=0, pool=""):
+        """Locates  virtual image specified by name and returns its facts as dictionary.
+        Primary use of this function is to obtain the ID of the image identified by its name and,
+        optionally SEP ID and/or pool name. Also note that only virtual images in status CREATED are
+        returned.
+
+        @param (string) image_id: ID of the OS image to find. If non-zero ID is specified, then
+        virt_name is ignored.
+        @param (string) virt_name: name of the OS image to find. This argument is ignored if non-zero
+        image ID is passed.
+         @param (int) account_id: ID of the account for which the image will be looked up. If set to 0,
+        the account ID will be obtained from the specified RG ID.
+        @param (int) rg_id: ID of the RG to use as a reference when listing OS images. This argument is
+        ignored if non-zero image id and/or non-zero account_id are specified.
+        @param (int) sepid: ID of the SEP where the image should be present. If set to 0, there will be no
+        filtering by SEP ID and the first matching image will be returned.
+        @param (string) pool: name of the pool where the image should be present. If set to empty string, there
+        will be no filtering by pool name and first matching image will be returned.
+
+        @return: image ID and dictionary with image specs. If no matching image found, 0 for ID and None for
+        dictionary are returned, and self.result['failed']=True.
+        """
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "virt_image_find")
+
+
+
+        if image_id > 0:
+            ret_image_id, ret_image_dict = self._image_get_by_id(image_id)
+            if (ret_image_id and
+                    (sepid == 0 or sepid == ret_image_dict['sepId']) and
+                    (pool == "" or pool == ret_image_dict['pool'])):
+                return ret_image_id, ret_image_dict
+        else:
+            validated_acc_id = account_id
+            if account_id == 0:
+                validated_rg_id, rg_facts = self._rg_get_by_id(rg_id)
+                if not validated_rg_id:
+                    self.result['failed'] = True
+                    self.result['msg'] = ("Failed to find RG ID {}, and account ID is zero.").format(rg_id)
+                    return 0, None
+                validated_acc_id = rg_facts['accountId']
+
+            api_params = dict(accountId=validated_acc_id)
+            api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/image/list", api_params)
+            # On success the above call will return here. On error it will abort execution by calling fail_json.
+            images_list = json.loads(api_resp.content.decode('utf8'))
+            for image_record in images_list:
+                if image_record['name'] == virt_name and image_record['status'] == "CREATED" and image_record['type'] == "virtual":
+                    if sepid == 0 and pool == "":
+                        # if no filtering by SEP ID or pool name is requested, return the first match
+                        return image_record['id'], image_record
+                    full_match = True
+                    if full_match:
+                        return image_record['id'], image_record
+
+        self.result['failed'] = True
+        self.result['msg'] = ("Failed to find virtual OS image by name '{}', SEP ID {}, pool '{}' for "
+                              "account ID '{}'.").format(virt_name,
+                                                         sepid, pool,
+                                                         account_id)
+
+        return 0, None
+
+    def virt_image_create(self, name, targetId):
+
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "virt_image_create")
+
+        api_params = dict(name=name, targetId=targetId,)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/image/createVirtual", api_params)
+        # On success the above call will return here. On error it will abort execution by calling fail_json.
+        virt_image_dict = json.loads(api_resp.content.decode('utf8'))
+
+        self.result['failed'] = False
+        self.result['changed'] = True
+        return 0, None
+
+    def image_delete(self, imageId, permanently):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "image_delete")
+
+        api_params = dict(imageId=imageId, permanently=permanently,)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/image/delete", api_params)
+        # On success the above call will return here. On error it will abort execution by calling fail_json.
+        image_dict = json.loads(api_resp.content.decode('utf8'))
+
+        self.result['changed'] = True
+        return 0, None
+
+
+    def image_create(self,img_name,url,gid,boottype,imagetype,architecture,drivers,hotresize,username,password,account_Id,usernameDL,passwordDL,sepId,poolName):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "image_create")
+
+        api_params = dict(name=img_name, url=url,
+                            gid=gid, boottype=boottype,
+                            imagetype=imagetype, architecture=architecture,
+                            drivers=drivers, accountId=account_Id,
+                            hotresize=hotresize, username=username,
+                            password=password, usernameDL=usernameDL,
+                            passwordDL=passwordDL, sepId=sepId,
+                            poolName=poolName,
+                            )
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/image/create", api_params)
+        # On success the above call will return here. On error it will abort execution by calling fail_json.
+        virt_image_dict = json.loads(api_resp.content.decode('utf8'))
+        self.result['failed'] = False
+        self.result['changed'] = True
+        return 0, None
+
+    def virt_image_link(self, imageId, targetId):
+
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "virt_image_link")
+
+        api_params = dict(imageId=imageId, targetId=targetId,)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/image/link", api_params)
+        # On success the above call will return here. On error it will abort execution by calling fail_json.
+        link_image_dict = json.loads(api_resp.content.decode('utf8'))
+        self.result['failed'] = False
+        self.result['changed'] = True
+
+
+        return 0, None
+
+    def image_rename(self, imageId, name):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "image_rename")
+        api_params = dict(imageId=imageId, name=name,)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/image/rename", api_params)
+        # On success the above call will return here. On error it will abort execution by calling fail_json.
+        link_image_dict = json.loads(api_resp.content.decode('utf8'))
+        self.result['failed'] = False
+        self.result['changed'] = True
+
     ###################################
     # Resource Group (RG) manipulation methods
     ###################################
@@ -1921,8 +2051,27 @@ class DecortController(object):
                                       "response {}.").format(vins_id, api_resp.status_code, api_resp.reason)
 
         return ret_vins_id, ret_vins_dict
+    def _rg_listvins(self,rg_id):
+        """List all ViNS in the resource group
+            @param (int) rg_id: id onr resource group
+        """
+        if not rg_id:
+            self.result['failed'] = True
+            self.result['msg'] = "_rg_listvins(): zero RG ID specified."
+            self.amodule.fail_json(**self.result)
 
-    def vins_find(self, vins_id, vins_name="", account_id=0, rg_id=0, check_state=True):
+        api_params = dict(rgId=rg_id, )
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/rg/listVins", api_params)
+        if api_resp.status_code == 200:
+            ret_rg_vins_list = json.loads(api_resp.content.decode('utf8'))
+        else:
+            self.result['warning'] = ("rg_listvins(): failed to get RG by ID {}. HTTP code {}, "
+                                      "response {}.").format(rg_id, api_resp.status_code, api_resp.reason)
+            return []
+
+        return ret_rg_vins_list
+    
+    def vins_find(self, vins_id, vins_name="", account_id=0, rg_id=0, rg_facts="", check_state=True):
         """Find specified ViNS. 
        
         @param (int) vins_id: ID of the ViNS. If non-zero vins_id is specified, all other arguments 
@@ -1963,29 +2112,29 @@ class DecortController(object):
         elif vins_name != "":
             if rg_id > 0:
                 # search for ViNS at RG level
-                validated_id, validated_facts = self._rg_get_by_id(rg_id)
-                if not validated_id:
-                    self.result['failed'] = True
-                    self.result['msg'] = "vins_find(): cannot find RG ID {}.".format(rg_id)
-                    self.amodule.fail_json(**self.result)
-                # NOTE: RG's 'vins' attribute does not list destroyed ViNSes! 
-                for runner in validated_facts['vins']:
-                    # api_params['vinsId'] = runner
-                    ret_vins_id, ret_vins_facts = self._vins_get_by_id(runner)
-                    if ret_vins_id and ret_vins_facts['name'] == vins_name:
+                # validated_id, validated_facts = self._rg_get_by_id(rg_id)
+                # if not validated_id:
+                #     self.result['failed'] = True
+                #     self.result['msg'] = "vins_find(): cannot find RG ID {}.".format(rg_id)
+                #     self.amodule.fail_json(**self.result)
+                # # NOTE: RG's 'vins' attribute does not list destroyed ViNSes! 
+                list_vins = self._rg_listvins(rg_id)
+                for vins in list_vins:
+                    if vins['name'] == vins_name:
+                        ret_vins_id, ret_vins_facts = self._vins_get_by_id(vins['id'])
                         if not check_state or ret_vins_facts['status'] not in VINS_INVALID_STATES:
                             return ret_vins_id, ret_vins_facts
                         else:
                             return 0, None
             elif account_id > 0:
                 # search for ViNS at account level
-                validated_id, validated_facts = self.account_find("", account_id)
-                if not validated_id:
-                    self.result['failed'] = True
-                    self.result['msg'] = "vins_find(): cannot find Account ID {}.".format(account_id)
-                    self.amodule.fail_json(**self.result)
+                # validated_id, validated_facts = self.account_find("", account_id)
+                # if not validated_id:
+                #     self.result['failed'] = True
+                #     self.result['msg'] = "vins_find(): cannot find Account ID {}.".format(account_id)
+                #     self.amodule.fail_json(**self.result)
                 # NOTE: account's 'vins' attribute does not list destroyed ViNSes! 
-                for runner in validated_facts['vins']:
+                for runner in rg_facts['vins']:
                     # api_params['vinsId'] = runner
                     ret_vins_id, ret_vins_facts = self._vins_get_by_id(runner)
                     if ret_vins_id and ret_vins_facts['name'] == vins_name:
@@ -2166,7 +2315,7 @@ class DecortController(object):
                                                                               desired_state)
         return
 
-    def vins_update(self, vins_dict, ext_net_id, ext_ip_addr="", mgmtaddr=""):
+    def vins_update_extnet(self, vins_dict, ext_net_id, ext_ip_addr=""):
         """Update ViNS. Currently only updates to the external network connection settings and
         external IP address assignment are implemented.
         Note that as ViNS created at account level cannot have external connections, attempt 
@@ -2188,14 +2337,9 @@ class DecortController(object):
 
         if self.amodule.check_mode:
             self.result['failed'] = False
-            self.result['msg'] = ("vins_update() in check mode: updating ViNS ID {}, name '{}' "
+            self.result['msg'] = ("vins_update_extnet() in check mode: updating ViNS ID {}, name '{}' "
                                   "was requested.").format(vins_dict['id'], vins_dict['name'])
             return
-        if self.amodule.params['config_save'] and vins_dict['VNFDev']['customPrecfg']:
-            # only save config,no other modifictaion
-            self.result['changed'] = True
-            self._vins_vnf_config_save(vins_dict['VNFDev']['id'])
-            return
 
         if not vins_dict['rgId']:
             # this ViNS exists at account level - no updates are possible
@@ -2246,28 +2390,136 @@ class DecortController(object):
                 self.result['warning'] = ("vins_update(): ViNS ID {} is already connected to ext net ID {}, "
                                           "no reconnection to default network will be done.").format(vins_dict['id'],
                                                                                                      gw_config[
-                                                                                                         'ext_net_id'])
-        for iface in vins_dict['VNFDev']['interfaces']:
-            if iface['ipAddress'] == mgmtaddr:
-                if  not iface['listenSsh']:
-                    self._vins_vnf_addmgmtaddr(vins_dict['VNFDev']['id'],mgmtaddr)
-            elif mgmtaddr =="":
-                if iface['listenSsh'] and iface['name'] != "ens9":
-                    self._vins_vnf_delmgmtaddr(vins_dict['VNFDev']['id'],iface['ipAddress'])
+                                                                                                         'ext_net_id']) 
+        return
+    def vins_update_mgmt(self, vins_dict, mgmtaddr=[]):
         
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "vins_update_mgmt")
+        
+        if self.amodule.check_mode:
+            self.result['failed'] = False
+            self.result['msg'] = ("vins_update_mgmt() in check mode: updating ViNS ID {}, name '{}' "
+                                  "was requested.").format(vins_dict['id'], vins_dict['name'])
+            return
+
+        if self.amodule.params['config_save'] and vins_dict['VNFDev']['customPrecfg']:
+            # only save config,no other modifictaion
+            self.result['changed'] = True
+            self._vins_vnf_config_save(vins_dict['VNFDev']['id'])
+            self.result['changed'] = True
+            self.result['failed'] = False
+            return
+        
+        for iface in vins_dict['VNFDev']['interfaces']:
+            if iface['ipAddress'] in mgmtaddr and not iface['listenSsh']:
+                self._vins_vnf_addmgmtaddr(vins_dict['VNFDev']['id'],iface['ipAddress'])
+                self.result['changed'] = True
+                self.result['failed'] = False
+            elif iface['ipAddress'] not in mgmtaddr and iface['listenSsh']:
+                if iface['name'] != "ens9":
+                    self._vins_vnf_delmgmtaddr(vins_dict['VNFDev']['id'],iface['ipAddress'])
+                    self.result['changed'] = True
+                    self.result['failed'] = False
         if self.amodule.params['custom_config']:
             if not vins_dict['VNFDev']['customPrecfg']:
                 self._vins_vnf_config_save(vins_dict['VNFDev']['id'])
                 self._vins_vnf_customconfig_set(vins_dict['VNFDev']['id'])
+                self.result['changed'] = True
+                self.result['failed'] = False
         else: 
             if vins_dict['VNFDev']['customPrecfg']:
                 self._vins_vnf_customconfig_set(vins_dict['VNFDev']['id'],False)
- 
+                self.result['changed'] = True
+                self.result['failed'] = False
+        return
+    
+    def vins_update_ifaces(self,vins_dict,vinses=""):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "vins_update_ifaces")
+        
+        if self.amodule.check_mode:
+            self.result['failed'] = False
+            self.result['msg'] = ("vins_update_iface() in check mode: updating ViNS ID {}, name '{}' "
+                                  "was requested.").format(vins_dict['id'], vins_dict['name'])
+            return
+        
+        list_ifaces_ip = [rec['ipaddr'] for rec in vinses]   
+        vinsid_not_existed = []
+        for iface in vins_dict['VNFDev']['interfaces']:
+            if iface['connType'] == "VXLAN" and iface['type'] == "CUSTOM":
+                if iface['ipAddress'] not in list_ifaces_ip:
+                    self._vnf_iface_remove(vins_dict['VNFDev']['id'],iface['name'])
+                    self.result['changed'] = True
+                    self.result['failed'] = False
+                else:
+                    #existed_conn_ip.append(iface['ipAddress'])
+                    vinses = list(filter(lambda i: i['ipaddr']!=iface['ipAddress'],vinses))
+
+        if not vinses:
+            return
+        list_account_vins = self._get_all_account_vinses(vins_dict['VNFDev']['accountId'])
+        list_account_vinsid = [rec['id'] for rec in list_account_vins]
+        for vins in vinses:
+            if vins['id'] in list_account_vinsid:
+                _,v_dict = self._vins_get_by_id(vins['id'])
+                    #TODO: vins reservation
+                self._vnf_iface_add(vins_dict['VNFDev']['id'],v_dict['vxlanId'],vins['ipaddr'],vins['netmask'])
+                self.result['changed'] = True
+                self.result['failed'] = False
+            else:
+                vinsid_not_existed.append(vins['id'])
+        if vinsid_not_existed:   
+            self.result['warning'] = ("List ViNS id: {} that not created on account id: {}").format(
+                                    vinsid_not_existed,
+                                    vins_dict['VNFDev']['accountId']
+                                    )
         return
 
+    def _vnf_iface_add(self,arg_devid,arg_vxlanid,arg_ipaddr,arg_netmask="24",arg_defgw=""):
+        api_params = dict(
+            devId=arg_devid,
+            ifType="CUSTOM",
+            connType="VXLAN",
+            connId=arg_vxlanid,
+            ipAddr=arg_ipaddr,
+            netMask=arg_netmask,
+            defGw=arg_defgw
+        )
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/ifaceAdd", api_params)
+        conn_dict = json.loads(api_resp.content.decode('utf8'))
+        return 
+
+    def _vnf_iface_remove(self,arg_devid,arg_iface_name):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "_vnf_iface_add")
+        api_params = dict(
+            devId=arg_devid,
+            name=arg_iface_name,
+
+        )
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/ifaceRemove", api_params)
+        return 
+
+    def _get_vnf_by_id(self,vnf_id):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "get_vnf_by_id")
+        api_params = dict(devId=vnf_id)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/get", api_params)
+        if api_resp.status_code == 200:
+            ret_vnf_dict = json.loads(api_resp.content.decode('utf8'))
+        else:
+            self.result['warning'] = ("get_all_account_vinses(): failed to configuration of the specified VNF device ID{}. HTTP code {}, "
+                                      "response {}.").format(vnf_id, api_resp.status_code, api_resp.reason)
+        return ret_vnf_dict
+
+    def _get_all_account_vinses(self,acc_id):
+        api_params = dict(accountId=acc_id)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/account/listVins", api_params)
+        if api_resp.status_code == 200:
+            ret_listvins_dict = json.loads(api_resp.content.decode('utf8'))
+        else:
+            self.result['warning'] = ("get_all_account_vinses(): failed to get list VINS in Account ID {}. HTTP code {}, "
+                                      "response {}.").format(acc_id, api_resp.status_code, api_resp.reason)
+        return ret_listvins_dict
+
     def _vins_vnf_addmgmtaddr(self,dev_id,mgmtip):
-        
-        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "vins_vnf_addmgmtaddr")
         api_params = dict(devId=dev_id,ip=mgmtip)
         api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/addMgmtAddr", api_params)
         if api_resp.status_code == 200:
@@ -2279,8 +2531,6 @@ class DecortController(object):
         return
     
     def _vins_vnf_delmgmtaddr(self,dev_id,mgmtip):
-        
-        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "vins_vnf_delmgmtaddr")
         api_params = dict(devId=dev_id,ip=mgmtip)
         api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/delMgmtAddr", api_params)
         if api_resp.status_code == 200:
@@ -2292,7 +2542,6 @@ class DecortController(object):
         return
 
     def _vins_vnf_customconfig_set(self,dev_id,arg_mode=True):
-        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "vins_vnf_customconfig_set")
         api_params = dict(devId=dev_id,mode=arg_mode)
         api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/customSet", api_params)
         if api_resp.status_code == 200:
@@ -2304,7 +2553,6 @@ class DecortController(object):
         return
     
     def _vins_vnf_config_save(self,dev_id):
-        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "vins_vnf_config_save")
         api_params = dict(devId=dev_id)
         api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/configSave", api_params)
         if api_resp.status_code == 200:
@@ -2314,12 +2562,6 @@ class DecortController(object):
             self.result['warning'] = ("_vins_vnf_config_set(): failed to Save configuration on the VNF device. {}. HTTP code {}, "
                                       "response {}.").format(dev_id,api_resp.status_code, api_resp.reason)
         return
-    
-    def vins_vnf_ifaceadd(self):
-        return
-    
-    def vins_vnf_ifaceremove(self):
-        return
 
     ##############################
     #
@@ -2649,8 +2891,8 @@ class DecortController(object):
                 iface_ipaddr = iface['ipAddress']
                 break
         else:
-            decon.result['failed'] = True
-            decon.result['msg'] = "Compute ID {} is not connected to ViNS ID {}.".format(comp_facts['id'],
+            self.result['failed'] = True
+            self.result['msg'] = "Compute ID {} is not connected to ViNS ID {}.".format(comp_facts['id'],
                                                                                          vins_facts['id'])
             return ret_rules
 
@@ -2928,7 +3170,7 @@ class DecortController(object):
             return
 
         api_params = dict(k8sId=k8s_id,
-                          permanently=False,
+                          permanently=permanently,
                           )
         self.decort_api_call(requests.post, "/restmachine/cloudapi/k8s/delete", api_params)
         # On success the above call will return here. On error it will abort execution by calling fail_json.
@@ -3020,9 +3262,11 @@ class DecortController(object):
                 ret_info = json.loads(api_get_resp.content.decode('utf8'))
                 if api_get_resp.status_code == 200:
                     if ret_info['status'] in ["PROCESSING", "SCHEDULED"]:
+                        self.result['msg'] = ("k8s_provision(): Can't create cluster")
                         self.result['failed'] = False
                         time.sleep(30)
                     elif ret_info['status'] == "ERROR":
+                        self.result['msg'] = ("k8s_provision(): Can't create cluster")
                         self.result['failed'] = True
                         return
                     elif ret_info['status'] == "OK":
@@ -3032,10 +3276,13 @@ class DecortController(object):
                     else:
                         k8s_id = ret_info['status']
                 else:
+                    self.result['msg'] = ("k8s_provision(): Can't create cluster")
                     self.result['failed'] = True
             # Timeout
+            self.result['msg'] = ("k8s_provision(): Can't create cluster")
             self.result['failed'] = True
         else:
+            self.result['msg'] = ("k8s_provision(): Can't create cluster")
             self.result['failed'] = True
         return
 
@@ -3065,15 +3312,16 @@ class DecortController(object):
         
         for rec_inn in arg_k8swg['k8sGroups']['workers']:
             for rec_out in arg_modwg:
-                if rec_inn['num'] != rec_out['num'] and rec_out['num'] != 0:
-                    count = rec_inn['num']-rec_out['num']
-                    cmp_list = []
-                    if count > 0:
-                        for cmp in rec_inn['detailedInfo'][:count]:
-                            cmp_list.append(cmp['id'])
-                        wg_moddel_list.append({rec_inn['id']:cmp_list})
-                    if count < 0:
-                        wg_modadd_list.append({rec_inn['id']:abs(count)})
+                if rec_inn['name'] == rec_out['name']:
+                    if rec_inn['num'] != rec_out['num'] and rec_out['num'] != 0:
+                        count = rec_inn['num']-rec_out['num']
+                        cmp_list = []
+                        if count > 0:
+                            for cmp in rec_inn['detailedInfo'][-count:]:
+                                cmp_list.append(cmp['id'])
+                            wg_moddel_list.append({rec_inn['id']:cmp_list})
+                        if count < 0:
+                            wg_modadd_list.append({rec_inn['id']:abs(count)})
 
         if wg_del_list:
             for wgid in wg_del_list: 
@@ -3117,15 +3365,17 @@ class DecortController(object):
         api_params = dict(includeDisabled=False)
 
         api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/k8ci/list", api_params)
-        
+        k8ci_id_present = False
         if api_resp.status_code == 200:
             ret_k8ci_list = json.loads(api_resp.content.decode('utf8'))
             for k8ci_item in ret_k8ci_list:
                 if k8ci_item['id'] == arg_k8ci_id:
+                    k8ci_id_present = True
                     break
-                else:
+                
+            if k8ci_id_present == False:
                     self.result['failed'] = True
-                    self.result['msg'] = "k8s_k8ci_find(): cannot find ID."
+                    self.result['msg'] = ("Cannot find k8ci id: {}.").format(arg_k8ci_id)
                     self.amodule.fail_json(**self.result)  
         else:
             self.result['failed'] = True