Add decort_lb management. decort_disk: Change limitIO, rename disk.

README.md

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

examples/VINS.yaml

@@ -0,0 +1,40 @@
+---
+#
+# 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://ds1.digitalenergy.online"
+      vins_name: "vins_created_by_decort_VINS_module"
+      state: present
+      rg_id: 198
+      ext_net_id: -1
+      ipcidr: "10.20.30.0/24"
+      mgmtaddr: "10.20.30.1"
+      custom_config: false
+      config_save: false 
+      verify_ssl: false
+
+    register: managed_vins
+
+  - name: print VINS facter
+    debug:
+      msg: "{{managed_vins.facts.password}}"
+    when: managed_vins.facts.password is defined

examples/affinity.yaml

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

examples/annotations.yaml

@@ -0,0 +1,40 @@
+---
+#
+# DECORT k8s module labels, taints, annotations 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: Create k8s cluster
+    decort_k8s:
+      authenticator: jwt
+      jwt: "{{ my_jwt.jwt }}"
+      controller_url: "https://mr4.digitalenergy.online"
+      name: "example_kubernetes"
+      rg_id: 199
+      k8ci_id: 4
+      state: present
+      workers:
+      - name: workgroup1
+        labels:
+        - disktype1=ssd1
+        - disktype2=ssd2
+        taints:
+        - key1=value1:NoSchedule 
+        - key2=value2:NoSchedule
+        annotations:
+        - node.deckhouse.io/group1=g1
+        - node.deckhouse.io/group2=g2
+    register: kube

examples/anti_affinity.yaml

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

examples/basicservices.yaml

@@ -0,0 +1,31 @@
+---
+#
+# DECORT bservice 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 bservice at RG
+    decort_bservice:
+      account_id: 98
+      verify_ssl: false
+      authenticator: jwt
+      jwt: "{{ my_jwt.jwt }}"
+      controller_url: "https://ds1.digitalenergy.online"
+      rg_id: 1629
+      state: present
+      name: databases
+      started: True
+    register: db_bservice

examples/cloud-init.yaml

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

examples/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

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

examples/main.yaml

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

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_bservice.py

@@ -0,0 +1,289 @@
+#!/usr/bin/python
+#
+# Digital Enegry Cloud Orchestration Technology (DECORT) modules for Ansible
+# Copyright: (c) 2018-2021 Digital Energy Cloud Solutions LLC
+#
+# Apache License 2.0 (see http://www.apache.org/licenses/LICENSE-2.0.txt)
+#
+
+#
+# Author: Alexey Dankov (alexey Dankov@digitalenergy.online)
+
+ANSIBLE_METADATA = {'metadata_version': '1.1',
+                    'status': ['preview'],
+                    'supported_by': 'community'}
+
+from ansible.module_utils.basic import AnsibleModule
+from ansible.module_utils.basic import env_fallback
+from ansible.module_utils.decort_utils import *
+
+class decort_bservice(DecortController):
+    def __init__(self,arg_amodule):
+        super(decort_bservice, self).__init__(arg_amodule)
+
+        validated_acc_id = 0
+        validated_rg_id = 0
+        validated_rg_facts = None
+        self.bservice_info = None
+        if arg_amodule.params['name'] == "" and arg_amodule.params['id'] == 0:
+            self.result['failed'] = True
+            self.result['changed'] = False
+            self.result['msg'] = "Cannot manage Basic Services when its ID is 0 and name is empty."
+            self.fail_json(**self.result)
+        if not arg_amodule.params['id']:
+            if not arg_amodule.params['rg_id']: # RG ID is not set -> locate RG by name -> need account ID
+                validated_acc_id, _ = self.account_find(arg_amodule.params['account_name'],
+                                                        arg_amodule.params['account_id'])
+                if not validated_acc_id:
+                    self.result['failed'] = True
+                    self.result['changed'] = False
+                    self.result['msg'] = ("Current user does not have access to the account ID {} / "
+                                          "name '{}' or non-existent account specified.").format(arg_amodule.params['account_id'],
+                                                                                                 arg_amodule.params['account_name'])
+                    self.fail_json(**self.result)
+                    # fail the module -> exit
+            # now validate RG
+            validated_rg_id, validated_rg_facts = self.rg_find(validated_acc_id,
+                                                               arg_amodule.params['rg_id'],)
+            if not validated_rg_id:
+                self.result['failed'] = True
+                self.result['changed'] = False
+                self.result['msg'] = "Cannot find RG ID {} / name '{}'.".format(arg_amodule.params['rg_id'],
+                                                                                arg_amodule.params['rg_name'])
+                self.fail_json(**self.result)
+        
+        arg_amodule.params['rg_id'] = validated_rg_id
+        arg_amodule.params['rg_name'] = validated_rg_facts['name']
+        self.acc_id = validated_rg_facts['accountId']
+        
+        self.bservice_id,self.bservice_info = self.bservice_find(
+            self.acc_id,
+            validated_rg_id,
+            arg_amodule.params['name'],
+            arg_amodule.params['id']
+        )
+
+        if self.bservice_id == 0:
+            self.bservice_should_exist = False
+        else:
+            self.bservice_should_exist = True
+
+    def nop(self):
+        """No operation (NOP) handler for B-service.
+        This function is intended to be called from the main switch construct of the module
+        when current state -> desired state change logic does not require any changes to
+        the actual Compute state.
+        """
+        self.result['failed'] = False
+        self.result['changed'] = False
+        if self.k8s_id:
+            self.result['msg'] = ("No state change required for B-service ID {} because of its "
+                                   "current status '{}'.").format(self.bservice_id, self.bservice_info['status'])
+        else:
+            self.result['msg'] = ("No state change to '{}' can be done for "
+                                  "non-existent B-service instance.").format(self.amodule.params['state'])
+        return                         
+
+    def error(self):
+        self.result['failed'] = True
+        self.result['changed'] = False
+        if self.bservice_id:
+            self.result['msg'] = ("Invalid target state '{}' requested for B-service ID {} in the "
+                                   "current status '{}'.").format(self.bservice_id,
+                                                                  self.amodule.params['state'],
+                                                                  self.bservice_info['status'])
+        else:
+            self.result['msg'] = ("Invalid target state '{}' requested for non-existent B-service name '{}' "
+                                   "in RG ID {} / name '{}'").format(self.amodule.params['state'],
+                                                                    self.amodule.params['name'],
+                                                                    self.amodule.params['rg_id'],
+                                                                    self.amodule.params['rg_name'])
+        return
+
+    def create(self):
+        self.bservice_id = self.bservice_id = self.bservice_provision(
+            self.amodule.params['name'],
+            self.amodule.params['rg_id'],
+            self.amodule.params['sshuser'],
+            self.amodule.params['sshkey']
+        )
+        if self.bservice_id:
+            _, self.bservice_info = self.bservice_get_by_id(self.bservice_id)
+        self.bservice_state(self.bservice_info,'enabled',self.amodule.params['started'])
+        return
+
+    def action(self,d_state,started=False):
+        self.bservice_state(self.bservice_info,d_state,started)
+        return
+
+    def restore(self):
+
+        self.result['failed'] = True
+        self.result['msg'] = "Restore B-Service ID {} manualy.".format(self.bservice_id)
+        pass
+
+    def destroy(self):
+        self.bservice_delete(self.bservice_id)
+        self.bservice_info['status'] = 'DELETED'
+        self.bservice_should_exist = False
+        return
+
+    def package_facts(self,check_mode=False):
+        
+        ret_dict = dict(
+            name="",
+            state="CHECK_MODE",
+            account_id=0,
+            rg_id=0,
+            config=None,
+        )
+
+        if check_mode:
+            # in check mode return immediately with the default values
+            return ret_dict
+
+        ret_dict['id'] = self.bservice_info['id']
+        ret_dict['name'] = self.bservice_info['name']
+        ret_dict['techStatus'] = self.bservice_info['techStatus']
+        ret_dict['state'] = self.bservice_info['status']
+        ret_dict['rg_id'] = self.bservice_info['rgId']
+        ret_dict['account_id'] = self.acc_id
+        ret_dict['groupsName'] = self.bservice_info['groupsName']
+        ret_dict['groupsIds'] = self.bservice_info['groups']
+        return ret_dict
+    @staticmethod
+    def build_parameters():
+        return dict(
+            account_id=dict(type='int', required=False),
+            account_name=dict(type='str', required=False, default=''),
+            annotation=dict(type='str', required=False, default=''),
+            app_id=dict(type='str',
+                        required=False,
+                        fallback=(env_fallback, ['DECORT_APP_ID'])),
+            app_secret=dict(type='str',
+                            required=False,
+                            fallback=(env_fallback, ['DECORT_APP_SECRET']),
+                            no_log=True),
+            authenticator=dict(type='str',
+                            required=True,
+                            choices=['legacy', 'oauth2', 'jwt']),
+            controller_url=dict(type='str', required=True),
+            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','check']),
+            started=dict(type='bool', required=False, default=True),
+            user=dict(type='str',
+                    required=False,
+                    fallback=(env_fallback, ['DECORT_USER'])),
+            name=dict(type='str', required=True),
+            sshuser=dict(type='str', required=False,default=None),
+            sshkey=dict(type='str', required=False,default=None),
+            id=dict(type='int', required=False, default=0),
+            rg_id=dict(type='int', default=0),
+            rg_name=dict(type='str',default=""),
+            description=dict(type='str', default="Created by decort ansible module"),
+            verify_ssl=dict(type='bool', required=False, default=True),
+            workflow_callback=dict(type='str', required=False),
+            workflow_context=dict(type='str', required=False),)
+def main():
+    module_parameters = decort_bservice.build_parameters()
+
+    amodule = AnsibleModule(argument_spec=module_parameters,
+                            supports_check_mode=True,
+                            mutually_exclusive=[
+                                ['oauth2', 'password'],
+                                ['password', 'jwt'],
+                                ['jwt', 'oauth2'],
+                            ],
+                            required_together=[
+                                ['app_id', 'app_secret'],
+                                ['user', 'password'],
+                            ],
+                            required_one_of=[
+                                ['id', 'name'],
+                                ['rg_id','rg_name']
+                            ],
+                            )
+
+    subj = decort_bservice(amodule)
+    
+    if amodule.params['state'] == 'check':
+        subj.result['changed'] = False
+        if subj.bservice_id:
+            subj.result['failed'] = False
+            subj.result['facts'] = subj.package_facts(amodule.check_mode)
+            amodule.exit_json(**subj.result)
+            # we exit the module at this point
+        else:
+            subj.result['failed'] = True
+            subj.result['msg'] = ("Cannot locate B-service name '{}'. Other arguments are: B-service ID {}, "
+                                  "RG name '{}', RG ID {}, Account '{}'.").format(amodule.params['name'],
+                                                                                amodule.params['id'],
+                                                                                amodule.params['rg_name'],
+                                                                                amodule.params['rg_id'],
+                                                                                amodule.params['account_name'])
+            amodule.fail_json(**subj.result)
+            pass
+    
+    
+    #MAIN MANAGE PART
+
+    if subj.bservice_id:
+        if subj.bservice_info['status'] in ("DELETING","DESTROYNG","RECONFIGURING","DESTROYING",
+                                         "ENABLING","DISABLING","RESTORING","MODELED"):
+            subj.error()
+        elif subj.bservice_info['status'] == "DELETED":
+            if amodule.params['state'] in ('disabled', 'enabled', 'present'):
+                subj.restore(subj.bservice_id)
+                subj.action(amodule.params['state'],amodule.params['started'])
+            if amodule.params['state'] == 'absent':
+                subj.nop()
+        elif subj.bservice_info['techStatus'] in ("STARTED","STOPPED"):
+            if amodule.params['state'] == 'disabled':
+                subj.action(amodule.params['state'],amodule.params['started'])
+            elif amodule.params['state'] == 'absent':
+                subj.destroy()
+            else:
+                subj.action(amodule.params['state'],amodule.params['started'])
+        elif subj.bservice_info['status'] == "DISABLED":
+            if amodule.params['state'] == 'absent':
+                subj.destroy()
+            elif amodule.params['state'] in ('present','enabled'):
+                subj.action(amodule.params['state'],amodule.params['started'])
+            else:
+                subj.nop()
+        elif subj.bservice_info['status'] == "DESTROED":
+            if amodule.params['state'] in ('present','enabled'):
+                subj.create()
+                subj.action(amodule.params['state'],amodule.params['started'])
+            if amodule.params['state'] == 'absent':    
+                subj.nop()
+    else:
+        if amodule.params['state'] == 'absent':
+            subj.nop()
+        if amodule.params['state'] in ('present','started'):
+            subj.create()
+        elif amodule.params['state'] in ('stopped', 'disabled','enabled'):
+            subj.error()
+    
+    if subj.result['failed']:
+        amodule.fail_json(**subj.result)
+    else:
+        if subj.bservice_should_exist:
+            subj.result['facts'] = subj.package_facts(amodule.check_mode)
+            amodule.exit_json(**subj.result)
+        else:
+            amodule.exit_json(**subj.result)
+if __name__ == "__main__":
+    main()

library/decort_disk.py

@@ -157,6 +157,16 @@ options:
         - `If specified for an existing disk, and it is greater than current disk size, platform will try to resize
           the disk on the fly. Downsizing disk is not allowed.`
         required: no
+    limitIO:
+        description:
+        - Disk input / output limit, used to limit the speed of interaction with the disk.
+        required: no
+    type:
+        description:
+        - Type of the disk. 
+        - `Disks can be of the following types: "D"-Data, "B"-Boot, "T"-Tmp.`
+        default: "D"
+        required: no
     state:
         description:
         - Specify the desired state of the disk at the exit of the module.
@@ -234,103 +244,277 @@ facts:
         gid: 1001
 '''
 
+
+
 from ansible.module_utils.basic import AnsibleModule
 from ansible.module_utils.basic import env_fallback
 
 from ansible.module_utils.decort_utils import *
 
+class decort_disk(DecortController):
+    def __init__(self,amodule):
+        super(decort_disk, self).__init__(amodule)
 
-def decort_disk_package_facts(disk_facts, check_mode=False):
+        self.validated_account_id = 0
-    """Package a dictionary of disk facts according to the decort_disk module specification. 
+        self.validated_disk_id = 0
-    This dictionary will be returned to the upstream Ansible engine at the completion of 
+        self.disk_facts = None # will hold Disk facts
-    the module run.
+        self.acc_facts = None # will hold Account facts
 
-    @param (dict) disk_facts: dictionary with Disk facts as returned by API call to .../disks/get
+        # limitIO check for exclusive parameters
-    @param (bool) check_mode: boolean that tells if this Ansible module is run in check mode
+        if amodule.params['limitIO']:
-    """
+            limit = amodule.params['limitIO']
+            if limit['total_bytes_sec'] > 0 and limit['read_bytes_sec'] > 0 or \
+                    limit['total_bytes_sec'] > 0 and limit['write_bytes_sec'] > 0:
+                self.result['failed'] = True
+                self.result['msg'] = ("total and read/write of bytes_sec cannot be set at the same time.")
+                amodule.fail_json(**self.result)
+            elif limit['total_iops_sec'] > 0 and limit['read_iops_sec'] > 0 or \
+                    limit['total_iops_sec'] > 0 and limit['write_iops_sec'] > 0:
+                self.result['failed'] = True
+                self.result['msg'] = ("total and read/write of iops_sec cannot be set at the same time.")
+                amodule.fail_json(**self.result)
+            elif limit['total_bytes_sec_max'] > 0 and limit['read_bytes_sec_max'] > 0 or \
+                    limit['total_bytes_sec_max'] > 0 and limit['write_bytes_sec_max'] > 0:
+                self.result['failed'] = True
+                self.result['msg'] = ("total and read/write of bytes_sec_max cannot be set at the same time.")
+                amodule.fail_json(**self.result)
+            elif limit['total_iops_sec_max'] > 0 and limit['read_iops_sec_max'] > 0 or \
+                    limit['total_iops_sec_max'] > 0 and limit['write_iops_sec_max'] > 0:
+                self.result['failed'] = True
+                self.result['msg'] = ("total and read/write of iops_sec_max cannot be set at the same time.")
+                amodule.fail_json(**self.result)
 
-    ret_dict = dict(id=0,
-                    name="none",
-                    state="CHECK_MODE",
-                    size=0,
-                    account_id=0,
-                    sep_id=0,
-                    pool="none",
-                    attached_to=0,
-                    gid=0
-                    )
 
-    if check_mode:
+        if amodule.params['account_id']:
-        # in check mode return immediately with the default values
+            self.validated_account_id = amodule.params['account_id']
+        elif amodule.params['account_name']:
+            self.validated_account_id, _ = self.account_find(amodule.params['account_name'])
+        elif not amodule.params['id'] and not amodule.params['account_name']:
+            self.result['failed'] = True
+            self.result['msg'] = ("Cannot found disk without account id or name.")
+            amodule.fail_json(**self.result)
+
+        if self.validated_account_id == 0 and not amodule.params['id']:
+            # we failed either to find or access the specified account - fail the module
+            self.result['failed'] = True
+            self.result['msg'] = ("Cannot find account '{}'").format(amodule.params['account_name'])
+            amodule.fail_json(**self.result)
+
+        if amodule.params['id'] or amodule.params['name']:
+            self.validated_disk_id, self.disk_facts = self.decort_disk_find(amodule)
+
+        else:
+            self.result['failed'] = True
+            self.result['msg'] = ("Cannot find or create disk without disk name or disk id")
+            amodule.fail_json(**self.result)
+        
+        if amodule.params['place_with'] > 0:
+            image_id, image_facts = self.image_find(amodule.params['place_with'], "", 0)
+            amodule.params['sep_id']= image_facts['sepId']
+
+
+
+
+    def decort_disk_create(self, amodule):
+        if not self.disk_facts:
+            self.disk_id = self.disk_create(accountId=self.validated_account_id, gid=amodule.params['gid'], 
+                                            name=amodule.params['name'], description=amodule.params['description'], 
+                                            size=amodule.params['size'], type=amodule.params['type'], 
+                                            iops=amodule.params['iops'], 
+                                            sep_id=amodule.params['sep_id'], pool=amodule.params['pool'])
+            self.result['msg'] = ("Disk with id '{}' successfully created.").format(self.disk_id)
+
+        elif self.disk_facts['status'] in ["DESTROYED", "PURGED"]:
+            if not amodule.params['limitIO']:
+                amodule.params['limitIO'] = self.disk_facts['iotune']
+            if amodule.params['sep_id'] == 0:
+                validated_sep_id = self.disk_facts['sepId']
+            else:
+                validated_sep_id = amodule.params['sep_id']
+
+            if amodule.params['pool'] == 0:
+                validated_pool = self.disk_facts['pool']
+            else:
+                validated_pool = amodule.params['pool']
+
+            if amodule.params['size'] == 0:
+                validated_size = self.disk_facts['sizeMax']
+            else:
+                validated_size = amodule.params['size']
+
+            if amodule.params['gid'] == 0:
+                validated_gid = self.disk_facts['gid']
+            else:
+                validated_gid = amodule.params['gid']
+
+            self.disk_id = self.disk_create(accountId=self.validated_account_id, gid=validated_gid, 
+                                            name=self.disk_facts['name'], description=amodule.params['description'], 
+                                            size=validated_size, type=self.disk_facts['type'], 
+                                            iops=self.disk_facts['iotune']['total_iops_sec'], 
+                                            sep_id=validated_sep_id, pool=validated_pool)
+            if not amodule.params['limitIO']:
+                amodule.params['limitIO'] = self.disk_facts['iotune']
+            self.result['msg'] = ("Disk with id '{}' successfully recreated.").format(self.disk_id)
+
+        self.result['failed'] = False
+        self.result['changed'] = True
+        return self.disk_id
+
+    def decort_disk_delete(self, amodule):
+        self.disk_id = self.disk_delete(disk_id=self.validated_disk_id,
+                                        detach=amodule.params['force_detach'],
+                                        permanently=amodule.params['permanently'],
+                                        reason=amodule.params['reason'])
+        return
+
+
+    def decort_disk_find(self, amodule):
+        if amodule.params['name'] and not amodule.params['id']:
+            self.disk_id, self.disk_facts = self.disk_find(disk_id=self.validated_disk_id,
+                                                name=amodule.params['name'], 
+                                                account_id=self.validated_account_id)
+        elif self.validated_disk_id > 0:
+            self.disk_id, self.disk_facts = self.disk_find(disk_id=self.validated_disk_id,
+                                                            name=self.disk_facts['name'],
+                                                            account_id=0)
+        elif amodule.params['id']:
+            self.disk_id, self.disk_facts = self.disk_find(disk_id=amodule.params['id'],
+                                                            name=amodule.params['name'],
+                                                            account_id=0)
+
+        if not self.disk_id and not amodule.params['name']:
+                    self.result['failed'] = True
+                    self.result['msg'] = "Specified Disk ID {} not found.".format(amodule.params['id'])
+                    amodule.fail_json(**self.result)
+        self.result['facts'] = decort_disk.decort_disk_package_facts(self.disk_facts)
+        return self.disk_id, self.disk_facts                                              
+
+    def decort_disk_limitIO(self, amodule):
+        self.limits = amodule.params['limitIO']
+
+        self.disk_limitIO(limits = self.limits,
+                        diskId = self.validated_disk_id)
+        self.disk_facts['iotune'] = amodule.params['limitIO']
+        self.result['facts'] = decort_disk.decort_disk_package_facts(self.disk_facts)
+        return
+    
+    def decort_disk_rename(self, amodule):
+        self.disk_rename(diskId = self.validated_disk_id,
+                        name = amodule.params['name'])
+        self.disk_facts['name'] = amodule.params['name']
+        self.result['facts'] = decort_disk.decort_disk_package_facts(self.disk_facts)
+        self.result['msg'] = ("Disk with id '{}',successfully renamed to '{}'.").format(self.validated_disk_id, amodule.params['name'])
+        return
+
+    def decort_disk_package_facts(disk_facts, check_mode=False):
+        ret_dict = dict(id=0,
+                        name="none",
+                        state="CHECK_MODE",
+                        size=0,
+                        account_id=0,
+                        sep_id=0,
+                        pool="none",
+                        attached_to=0,
+                        gid=0
+                        )
+
+        if check_mode:
+            # in check mode return immediately with the default values
+            return ret_dict
+
+        if disk_facts is None:
+            # if void facts provided - change state value to ABSENT and return
+            ret_dict['state'] = "ABSENT"
+            return ret_dict
+
+        ret_dict['id'] = disk_facts['id']
+        ret_dict['name'] = disk_facts['name']
+        ret_dict['size'] = disk_facts['sizeMax']
+        ret_dict['state'] = disk_facts['status']
+        ret_dict['account_id'] = disk_facts['accountId']
+        ret_dict['sep_id'] = disk_facts['sepId']
+        ret_dict['pool'] = disk_facts['pool']
+        ret_dict['attached_to'] = disk_facts['vmid']
+        ret_dict['gid'] = disk_facts['gid']
+        ret_dict['iotune'] = disk_facts['iotune']
+
         return ret_dict
 
-    if disk_facts is None:
+    def decort_disk_parameters():
-        # if void facts provided - change state value to ABSENT and return
+        """Build and return a dictionary of parameters expected by decort_disk module in a form accepted
-        ret_dict['state'] = "ABSENT"
+        by AnsibleModule utility class."""
-        return ret_dict
 
-    ret_dict['id'] = disk_facts['id']
+        return dict(
-    ret_dict['name'] = disk_facts['name']
+            account_id=dict(type='int', required=False, default=0),
-    ret_dict['size'] = disk_facts['sizeMax']
+            account_name=dict(type='str', required=False, default=''),
-    ret_dict['state'] = disk_facts['status']
+            annotation=dict(type='str', required=False, default='Disk by decort_disk'),
-    ret_dict['account_id'] = disk_facts['accountId']
+            app_id=dict(type='str',
-    ret_dict['sep_id'] = disk_facts['sepId']
-    ret_dict['pool'] = disk_facts['pool']
-    ret_dict['attached_to'] = disk_facts['vmid']
-    ret_dict['gid'] = disk_facts['gid']
-
-    return ret_dict
-
-def decort_disk_parameters():
-    """Build and return a dictionary of parameters expected by decort_disk module in a form accepted
-    by AnsibleModule utility class."""
-
-    return dict(
-        account_id=dict(type='int', required=False, default=0),
-        account_name=dict(type='str', required=False, default=''),
-        annotation=dict(type='str', required=False, default='Disk by decort_disk'),
-        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']),
+                        fallback=(env_fallback, ['DECORT_APP_ID'])),
-                        no_log=True),
+            app_secret=dict(type='str',
-        authenticator=dict(type='str',
+                            required=False,
-                           required=True,
+                            fallback=(env_fallback, ['DECORT_APP_SECRET']),
-                           choices=['legacy', 'oauth2', 'jwt']),
+                            no_log=True),
-        controller_url=dict(type='str', required=True),
+            authenticator=dict(type='str',
-        id=dict(type='int', required=False, default=0),
+                               required=True,
-        name=dict(type='str', required=False),
+                               choices=['legacy', 'oauth2', 'jwt']),
-        force_detach=dict(type='bool', required=False, default=False),
+            controller_url=dict(type='str', required=True),
-        jwt=dict(type='str',
+            id=dict(type='int', required=False, default=0),
-                 required=False,
+            name=dict(type='str', required=False),
-                 fallback=(env_fallback, ['DECORT_JWT']),
+            force_detach=dict(type='bool', required=False, default=False),
-                 no_log=True),
+            jwt=dict(type='str',
-        oauth2_url=dict(type='str',
+                     required=False,
-                        required=False,
+                     fallback=(env_fallback, ['DECORT_JWT']),
-                        fallback=(env_fallback, ['DECORT_OAUTH2_URL'])),
+                     no_log=True),
-        password=dict(type='str',
+            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),
+            place_with=dict(type='int', default=0),
+            pool=dict(type='str', default=''),
+            sep_id=dict(type='int', default=0),
+            gid=dict(type='int', default=0),
+            size=dict(type='int', default=0),
+            type=dict(type='str', 
+                      required=False, 
+                      default="D",
+                      choices=['B', 'D', 'T']),
+            iops=dict(type='int', default=2000),
+            limitIO=dict(type='dict',
+                options=dict(
+                    total_bytes_sec=dict(default=0,type='int'),
+                    read_bytes_sec=dict(default=0,type='int'),
+                    write_bytes_sec=dict(default=0,type='int'),
+                    total_iops_sec=dict(default=0,type='int'),
+                    read_iops_sec=dict(default=0,type='int'),
+                    write_iops_sec=dict(default=0,type='int'),
+                    total_bytes_sec_max=dict(default=0,type='int'),
+                    read_bytes_sec_max=dict(default=0,type='int'),
+                    write_bytes_sec_max=dict(default=0,type='int'),
+                    total_iops_sec_max=dict(default=0,type='int'),
+                    read_iops_sec_max=dict(default=0,type='int'),
+                    write_iops_sec_max=dict(default=0,type='int'),
+                    size_iops_sec=dict(default=0,type='int'),)),
+            permanently=dict(type='bool', required=False, default=False),
+            reason=dict(type='int', required=False),
+            description=dict(type='str', required=False,
+                             default="Disk created with Ansible Decort_disk module."),
+            state=dict(type='str',
+                       default='present',
+                       choices=['absent', 'present']),
+            user=dict(type='str',
                       required=False,
-                      fallback=(env_fallback, ['DECORT_PASSWORD']),
+                      fallback=(env_fallback, ['DECORT_USER'])),
-                      no_log=True),
+            verify_ssl=dict(type='bool', required=False, default=True),
-        place_with=dict(type='int', required=False, default=0),
+            workflow_callback=dict(type='str', required=False),
-        pool=dict(type='str', required=False, default=''),
+            workflow_context=dict(type='str', required=False),
-        sep_id=dict(type='int', required=False, default=0),
+        )
-        size=dict(type='int', required=False),
-        state=dict(type='str',
-                   default='present',
-                   choices=['absent', 'present']),
-        user=dict(type='str',
-                  required=False,
-                  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),
-    )
 
 def main():
-    module_parameters = decort_disk_parameters()
+    module_parameters = decort_disk.decort_disk_parameters()
 
     amodule = AnsibleModule(argument_spec=module_parameters,
                             supports_check_mode=True,
@@ -345,197 +529,106 @@ def main():
                             ],
                             )
 
-    decon = DecortController(amodule)
+    decon = decort_disk(amodule)
 
-    disk_id = 0
+    if decon.validated_disk_id == 0 and amodule.params['state'] == 'present':
-    disk_facts = None # will hold Disk facts
+        # if sep_id or place_with not specified, then exit with error
-    validated_acc_id = 0
+        if amodule.params['sep_id'] == 0 and amodule.params['place_with'] == 0:
-    acc_facts = None # will hold Account facts
+            decon.result['msg'] = ("To create a disk, you must specify sep_id or place_with.")\
-
+            .format(decon.validated_disk_id)
-    if amodule.params['id']:
-        # expect existing Disk with the specified ID
-        # This call to disk_find will abort the module if no Disk with such ID is present
-        disk_id, disk_facts = decon.disk_find(amodule.params['id'])
-        if not disk_id:
-            decon.result['failed'] = True
-            decon.result['msg'] = "Specified Disk ID {} not found.".format(amodule.params['id'])
             amodule.fail_json(**decon.result)
-        validated_acc_id =disk_facts['accountId']
+    # if id cannot cannot be found and have a state 'present', then create a new disk 
-    elif amodule.params['account_id'] > 0 or amodule.params['account_name'] != "":
+        decon.validated_disk_id = decon.decort_disk_create(amodule)
-        # Make sure disk name is specified, if not - fail the module
+        _, decon.disk_facts = decon.decort_disk_find(amodule)
-        if amodule.params['name'] == "":
+        decon.result['changed'] = True
-            decon.result['failed'] = True
+        decon.result['msg'] = ("Disk with id '{}' successfully created.").format(decon.validated_disk_id)
-            decon.result['msg'] = ("Cannot manage disk if both ID is 0 and disk name is empty.")
-            amodule.fail_json(**decon.result)
-        # 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.")
-            amodule.fail_json(**decon.result)
-        # This call to disk_find may return disk_id=0 if no Disk with this name found in 
-        disk_id, disk_facts = decon.disk_find(disk_id=0, disk_name=amodule.params['name'],
-                                                account_id=validated_acc_id,
-                                                check_state=False)
-    else: 
-        # this is "invalid arguments combination" sink
-        # if we end up here, it means that module was invoked with disk_id=0 and undefined account
-        decon.result['failed'] = True
-        if amodule.params['account_id'] == 0 and amodule.params['account_name'] == "":
-            decon.result['msg'] = "Cannot find Disk by name when account name is empty and account ID is 0."
-        if amodule.params['name'] == "":
-            decon.result['msg'] = "Cannot find Disk by empty name."
-        amodule.fail_json(**decon.result)
-
-    #
-    # Initial validation of module arguments is complete
-    #
-    # At this point non-zero disk_id means that we will be managing pre-existing Disk
-    # Otherwise we are about to create a new disk
-    #
-    # Valid Disk model statii are as follows:
-    # 
-    # "CREATED", "ASSIGNED", DELETED", "DESTROYED", "PURGED"
-    # 
-
-    disk_should_exist = False
-    target_sep_id = 0
-    # target_pool = ""
     
-    if disk_id:
+    elif decon.validated_disk_id == 0 and amodule.params['state'] == 'absent' and amodule.params['name']:
-        disk_should_exist = True
+    # if disk with specified name cannot be found and have a state 'absent', then nothing to do, 
-        if disk_facts['status'] in ["MODELED", "CREATING" ]:
+    # specified disk already deleted
-            # error: nothing can be done to existing Disk in the listed statii regardless of
+        decon.result['msg'] = ("Disk with name '{}' has already been deleted or your account does not have"
-            # the requested state
+        " access to it.")\
-            decon.result['failed'] = True
+            .format(amodule.params['name'])
-            decon.result['changed'] = False
-            decon.result['msg'] = ("No change can be done for existing Disk ID {} because of its current "
-                                   "status '{}'").format(disk_id, disk_facts['status'])
-        elif disk_facts['status'] in ["CREATED", "ASSIGNED"]:
-            if amodule.params['state'] == 'absent':
-                decon.disk_delete(disk_id, True, amodule.params['force_detach']) # delete permanently
-                disk_facts['status'] = 'DESTROYED'
-                disk_should_exist = False
-            elif amodule.params['state'] == 'present':
-                # resize Disk as necessary & if possible
-                if decon.check_amodule_argument('size', False):
-                    decon.disk_resize(disk_facts, amodule.params['size'])
-        elif disk_facts['status'] == "DELETED":
-            if amodule.params['state'] == 'present':
-                # restore
-                decon.disk_restore(disk_id)
-                _, disk_facts = decon.disk_find(disk_id)
-                decon.disk_resize(disk_facts, amodule.params['size'])
-                disk_should_exist = True
-            elif amodule.params['state'] == 'absent':
-                # destroy permanently
-                decon.disk_delete(disk_id, permanently=True)
-                disk_facts['status'] = 'DESTROYED'
-                disk_should_exist = False
-        elif disk_facts['status'] in ["DESTROYED", "PURGED"]:
-            if amodule.params['state'] == 'present':
-                # Need to re-provision this Disk.
-                # Some attributes may change, some must stay the same:
-                # - disk name  - stays, take from disk_facts
-                # - account ID - stays, take from validated account ID
-                # - size       - may change, take from module arguments
-                # - SEP ID     - may change, build based on module arguments
-                # - pool       - may change, take from module arguments
-                # - annotation - may change, take from module arguments
-                #
-                # First validate required parameters:
-                decon.check_amodule_argument('size') # this will fail the module if size is not specified
-                target_sep_id = 0
-                if decon.check_amodule_argument('sep_id', False) and amodule.params['sep_id'] > 0:
-                    # non-zero sep_id is explicitly passed in module arguments
-                    target_sep_id = amodule.params['sep_id']
-                elif decon.check_amodule_argument('place_with', False) and amodule.params['place_with'] > 0:
-                    # request to place this disk on the same SEP as the specified OS image
-                    # validate specified OS image and assign SEP ID accordingly
-                    image_id, image_facts = decon.image_find(amodule.params['place_with'], "", 0)
-                    target_sep_id = image_facts['sepId']
-                else:
-                    # no new SEP ID is explicitly specified, and no place_with option - use sepId from the disk_facts
-                    target_sep_id = disk_facts['sepId']
-                disk_id = decon.disk_provision(disk_name=disk_facts['name'], # as this disk was found, its name is in the facts
-                                               size=amodule.params['size'],
-                                               account_id=validated_acc_id, 
-                                               sep_id=target_sep_id,
-                                               pool=amodule.params['pool'],
-                                               desc=amodule.params['annotation'],
-                                               location="")
-                disk_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 Disk ID {} because of its "
-                                       "current status '{}'").format(disk_id,
-                                                                     disk_facts['status'])
-                disk_should_exist = False
-    else:
-        # disk_id =0 -> pre-existing Disk was not found.
-        disk_should_exist = False  # we will change it back to True if Disk is created successfully
-        # 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 Disk name '{}'").format(amodule.params['name'])
-        elif amodule.params['state'] == 'present':
-            decon.check_amodule_argument('name') # if disk name not specified, fail the module 
-            decon.check_amodule_argument('size') # if disk size not specified, fail the module
-
-            # as we already have account ID, we can create Disk and get disk id on success
-            if decon.check_amodule_argument('sep_id', False) and amodule.params['sep_id'] > 0:
-                # non-zero sep_id is explicitly passed in module arguments
-                target_sep_id = amodule.params['sep_id']
-            elif decon.check_amodule_argument('place_with', False) and amodule.params['place_with'] > 0:
-                # request to place this disk on the same SEP as the specified OS image
-                # validate specified OS image and assign SEP ID accordingly
-                image_id, image_facts = decon.image_find(amodule.params['place_with'], "", 0)
-                target_sep_id = image_facts['sepId']
-            else:
-                # no SEP ID is explicitly specified, and no place_with option - we do not know where
-                # to place the new disk - fail the module
-                decon.result['failed'] = True
-                decon.result['msg'] = ("Cannot create new Disk name '{}': no SEP ID specified and "
-                                       "no 'place_with' option used.").format(amodule.params['name'])
-                amodule.fail_json(**decon.result)
-            
-            disk_id = decon.disk_provision(disk_name=amodule.params['name'],
-                                            size=amodule.params['size'],
-                                            account_id=validated_acc_id, 
-                                            sep_id=target_sep_id,
-                                            pool_name=amodule.params['pool'],
-                                            desc=amodule.params['annotation'],
-                                            location="")
-            disk_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 "
-                                   "Disk name '{}'").format(amodule.params['state'],
-                                                            amodule.params['name'])
-    
-    #
-    # conditional switch end - complete module run
-    #
-    if decon.result['failed']:
-        amodule.fail_json(**decon.result)
-    else:
-        # prepare Disk facts to be returned as part of decon.result and then call exit_json(...)
-        if disk_should_exist:
-            if decon.result['changed']:
-                # If we arrive here, there is a good chance that the Disk is present - get fresh Disk
-                # facts by Disk ID.
-                # Otherwise, Disk facts from previous call (when the Disk was still in existence) will
-                # be returned.
-                _, disk_facts = decon.disk_find(disk_id)
-        decon.result['facts'] = decort_disk_package_facts(disk_facts, amodule.check_mode)
         amodule.exit_json(**decon.result)
 
+    elif decon.validated_disk_id == 0 and amodule.params['state'] == 'absent' and amodule.params['id']:
+    # if disk with specified id cannot be found and have a state 'absent', then nothing to do, 
+    # specified disk already deleted
+        decon.result['msg'] = ("Disk with name '{}' has already been deleted or your account does not have"
+                                " access to it.")\
+            .format(decon.validated_disk_id)
+        amodule.exit_json(**decon.result)
+
+    elif decon.disk_facts['status'] == "CREATED":
+        if amodule.params['state'] == 'present':
+        # if disk status in condition "CREATED" and state "present", nothing to do,
+        # specified disk already created
+            decon.result['msg'] = "Specified Disk ID {} already created.".format(decon.validated_disk_id)
+
+        if amodule.params['state'] == 'absent':
+        # if disk status in condition "CREATED" and state "absent", delete the disk
+            decon.validated_disk_id = decon.decort_disk_delete(amodule)
+            decon.disk_facts['status'] = "DESTROYED"
+            decon.result['msg'] = ("Disk with id '{}' successfully deleted.").format(decon.disk_facts['id'])
+            decon.result['facts'] = decon.decort_disk_package_facts(decon.disk_facts)
+            amodule.exit_json(**decon.result)
+
+    elif decon.disk_facts['status'] in ["MODELED", "CREATING" ]:
+        # if disk in status "MODELED" or "CREATING", 
+        # then we cannot do anything, while disk in this status
+        decon.result['changed'] = False
+        decon.result['msg'] = ("Cannot do anything with disk id '{}',please wait until disk will be created.")\
+            .format(decon.validated_disk_id)
+        amodule.fail_json(**decon.result)
+
+    elif decon.disk_facts['status'] == "DELETED":
+        if amodule.params['state'] == 'present':
+            # if disk in "DELETED" status and "present" state, restore
+            decon.disk_restore(decon.validated_disk_id)
+            _, decon.disk_facts = decon.decort_disk_find(amodule)
+            decon.result['changed'] = True
+            decon.result['msg'] = ("Disk with id '{}',restored successfully.").format(decon.validated_disk_id)
+
+        elif amodule.params['state'] == 'absent':
+            # if disk in "DELETED" status and "absent" state, nothing to do
+            decon.result['msg'] = "Specified Disk ID {} already destroyed.".format(decon.validated_disk_id)
+            amodule.exit_json(**decon.result)
+    
+    elif decon.disk_facts['status'] in ["DESTROYED", "PURGED"]:
+        if amodule.params['state'] == 'present':
+            decon.validated_disk_id = decon.decort_disk_create(amodule)
+            _, decon.disk_facts = decon.decort_disk_find(amodule)
+
+        elif amodule.params['state'] == 'absent':
+            decon.result['msg'] = "Specified Disk ID {} already destroyed.".format(decon.validated_disk_id)
+            amodule.exit_json(**decon.result)
+
+    if amodule.params['state'] == "present":
+        if decon.disk_facts['sizeMax'] != amodule.params['size']:
+            if decon.disk_facts['sizeMax'] > amodule.params['size'] and amodule.params['size'] != 0:
+                decon.result['failed'] = True
+                decon.result['msg'] = ("Disk id '{}', cannot reduce disk size.").format(decon.validated_disk_id)
+                amodule.fail_json(**decon.result)
+            elif decon.disk_facts['sizeMax'] < amodule.params['size']:
+                decon.disk_resize(disk_facts=decon.disk_facts,
+                                    new_size=amodule.params['size'])
+                decon.result['changed'] = True
+                decon.disk_facts['size'] = amodule.params['size']
+                decon.result['msg'] = ("Disk with id '{}',resized successfully.").format(decon.validated_disk_id)
+
+        if amodule.params['limitIO'] and amodule.params['limitIO'] != decon.disk_facts['iotune']:
+            decon.decort_disk_limitIO(amodule)
+            decon.result['changed'] = True
+            decon.result['msg'] = ("Disk with id '{}',limited successfully.").format(decon.validated_disk_id)
+    
+    if amodule.params['name'] and amodule.params['id']:
+        if amodule.params['name'] != decon.disk_facts['name']:
+            decon.decort_disk_rename(amodule)
+            decon.result['changed'] = True
+            decon.result['msg'] = ("Disk with id '{}',renamed successfully from '{}' to '{}'.")\
+                .format(decon.validated_disk_id, decon.disk_facts['name'], amodule.params['name'])
+
+    amodule.exit_json(**decon.result)
 
 if __name__ == "__main__":
     main()

library/decort_group.py

@@ -0,0 +1,285 @@
+#!/usr/bin/python
+#
+# Digital Enegry Cloud Orchestration Technology (DECORT) modules for Ansible
+# Copyright: (c) 2018-2021 Digital Energy Cloud Solutions LLC
+#
+# Apache License 2.0 (see http://www.apache.org/licenses/LICENSE-2.0.txt)
+#
+
+#
+# Author: Alexey Dankov (alexey.dankov@digitalenergy.online)
+
+ANSIBLE_METADATA = {'metadata_version': '1.1',
+                    'status': ['preview'],
+                    'supported_by': 'community'}
+
+from ansible.module_utils.basic import AnsibleModule
+from ansible.module_utils.basic import env_fallback
+from ansible.module_utils.decort_utils import *
+
+class decort_group(DecortController):
+    def __init__(self,arg_amodule):
+        super(decort_group, self).__init__(arg_amodule)
+        self.group_should_exist = False
+        validated_bservice_id = None
+        #find and validate B-Service
+
+        validated_bservice_id, bservice_info = self.bservice_get_by_id(arg_amodule.params['bservice_id'])
+        if not validated_bservice_id:
+            self.result['failed'] = True
+            self.result['changed'] = False
+            self.result['msg'] = ("Cannot find B-service ID {}.").format(arg_amodule.params['bservice_id'])
+            self.fail_json(**self.result)
+        #find group
+        self.bservice_id = validated_bservice_id
+        self.bservice_info = bservice_info
+        self.group_id,self.group_info = self.group_find(
+            bs_id=validated_bservice_id,
+            bs_info=bservice_info,
+            group_id=arg_amodule.params['id'],
+            group_name=arg_amodule.params['name'],
+            )
+
+        if self.group_id:
+            self.group_should_exist = True
+        
+        return
+    def nop(self):
+        """No operation (NOP) handler for B-service.
+        This function is intended to be called from the main switch construct of the module
+        when current state -> desired state change logic does not require any changes to
+        the actual Compute state.
+        """
+        self.result['failed'] = False
+        self.result['changed'] = False
+        if self.group_id:
+            self.result['msg'] = ("No state change required for B-service ID {} because of its "
+                                   "current status '{}'.").format(self.group_id, self.group_info['status'])
+        else:
+            self.result['msg'] = ("No state change to '{}' can be done for "
+                                  "non-existent B-service instance.").format(self.amodule.params['state'])
+        return                         
+
+    def error(self):
+        self.result['failed'] = True
+        self.result['changed'] = False
+        if self.group_id:
+            self.result['msg'] = ("Invalid target state '{}' requested for Group ID {} in the "
+                                   "current status '{}'.").format(self.group_id,
+                                                                  self.amodule.params['state'],
+                                                                  self.group_info['status'])
+        else:
+            self.result['msg'] = ("Invalid target state '{}' requested for non-existent Group name '{}' "
+                                   "in B-service {}").format(self.amodule.params['state'],
+                                                                    self.amodule.params['name'],
+                                                                    self.amodule.params['bservice_id'],
+                                )
+        return
+
+    def create(self):
+
+        if self.amodule.params['driver'] not in ["KVM_X86","KVM_PPC"]:
+            self.result['failed'] = True
+            self.result['msg'] = ("Unsupported driver '{}' is specified for "
+                                  "Group.").format(self.amodule.params['driver'])
+            self.amodule.fail_json(**self.result)
+
+        self.group_id=self.group_provision(
+           self.bservice_id,
+           self.amodule.params['name'],
+           self.amodule.params['count'],
+           self.amodule.params['cpu'],
+           self.amodule.params['ram'],
+           self.amodule.params['boot_disk'],
+           self.amodule.params['image_id'],
+           self.amodule.params['driver'],
+           self.amodule.params['role'],
+           self.amodule.params['networks'],
+           self.amodule.params['timeoutStart'], 
+        )
+        
+        if self.amodule.params['state'] in ('started','present'):
+            self.group_state(self.bservice_id,self.group_id,self.amodule.params['state'])
+        return
+
+    def action(self):
+        #change desired state
+        if (
+            self.group_info['techStatus'] == 'STARTED' and self.amodule.params['state'] == 'stopped') or (
+            self.group_info['techStatus'] == 'STOPPED' and self.amodule.params['state'] in ('started','present')
+            ):
+            self.group_state(self.bservice_id,self.group_id,self.amodule.params['state'])
+        self.group_resize_count(self.bservice_id,self.group_info,self.amodule.params['count'])
+        self.group_update_hw(
+            self.bservice_id,
+            self.group_info,
+            self.amodule.params['cpu'],
+            self.amodule.params['boot_disk'],
+            self.amodule.params['name'],
+            self.amodule.params['role'],
+            self.amodule.params['ram'],
+        )
+        self.group_update_net(
+            self.bservice_id,
+            self.group_info,
+            self.amodule.params['networks']
+        )
+        return
+
+    def destroy(self):
+
+        self.group_delete(
+            self.bservice_id,
+            self.group_id
+        )
+
+        return
+
+    def package_facts(self,check_mode=False):
+        
+        ret_dict = dict(
+            name="",
+            state="CHECK_MODE",
+            account_id=0,
+            rg_id=0,
+            config=None,
+        )
+
+        if check_mode:
+            # in check mode return immediately with the default values
+            return ret_dict
+        if self.result['changed'] == True:
+            self.group_id,self.group_info = self.group_find(
+                self.bservice_id,
+                self.bservice_info,
+                self.group_id
+            )
+
+        ret_dict['account_id'] = self.group_info['accountId']
+        ret_dict['rg_id'] = self.group_info['rgId']
+        ret_dict['id'] = self.group_info['id']
+        ret_dict['name'] = self.group_info['name']
+        ret_dict['techStatus'] = self.group_info['techStatus']
+        ret_dict['state'] = self.group_info['status']
+        ret_dict['Computes'] = self.group_info['computes']
+        return ret_dict
+    @staticmethod
+    def build_parameters():
+        return dict(
+            account_id=dict(type='int', required=False),
+            account_name=dict(type='str', required=False, default=''),
+            annotation=dict(type='str', required=False, default=''),
+            app_id=dict(type='str',
+                        required=False,
+                        fallback=(env_fallback, ['DECORT_APP_ID'])),
+            app_secret=dict(type='str',
+                            required=False,
+                            fallback=(env_fallback, ['DECORT_APP_SECRET']),
+                            no_log=True),
+            authenticator=dict(type='str',
+                            required=True,
+                            choices=['legacy', 'oauth2', 'jwt']),
+            controller_url=dict(type='str', required=True),
+            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', 'started', 'stopped', 'present','check']),
+            user=dict(type='str',
+                    required=False,
+                    fallback=(env_fallback, ['DECORT_USER'])),
+            name=dict(type='str', required=True),
+            id=dict(type='int', required=False, default=0),
+            image_id=dict(type='int', required=False),
+            image_name=dict(type='str', required=False),
+            driver=dict(type='str', required=False,default="KVM_X86"),
+            boot_disk=dict(type='int', required=False),
+            bservice_id=dict(type='int', required=True),
+            count=dict(type='int', required=True),
+            timeoutStart=dict(type='int', required=False),
+            role=dict(type='str', required=False),
+            cpu=dict(type='int', required=False),
+            ram=dict(type='int', required=False),
+            networks=dict(type='list', default=[], required=False),
+            description=dict(type='str', default="Created by decort ansible module"),
+            verify_ssl=dict(type='bool', required=False, default=True),
+            workflow_callback=dict(type='str', required=False),
+            workflow_context=dict(type='str', required=False),)
+def main():
+    module_parameters = decort_group.build_parameters()
+
+    amodule = AnsibleModule(argument_spec=module_parameters,
+                            supports_check_mode=True,
+                            mutually_exclusive=[
+                                ['oauth2', 'password'],
+                                ['password', 'jwt'],
+                                ['jwt', 'oauth2'],
+                            ],
+                            required_together=[
+                                ['app_id', 'app_secret'],
+                                ['user', 'password'],
+                            ],
+                            required_one_of=[
+                                ['id', 'name'],
+                            ],
+                            )
+
+    subj = decort_group(amodule)
+    
+    if amodule.params['state'] == 'check':
+        subj.result['changed'] = False
+        if subj.group_id:
+            # cluster is found - package facts and report success to Ansible
+            subj.result['failed'] = False
+            subj.result['facts'] = subj.package_facts(amodule.check_mode)
+            amodule.exit_json(**subj.result)
+            # we exit the module at this point
+        else:
+            subj.result['failed'] = True
+            subj.result['msg'] = ("Cannot locate Group name '{}'. "
+                                  "B-service ID {}").format(amodule.params['name'],
+                                                     amodule.params['bservice_id'],)
+            amodule.fail_json(**subj.result)       
+
+    if subj.group_id:
+        if subj.group_info['status'] in ("DELETING","DESTROYNG","CREATING","DESTROYING",
+                                         "ENABLING","DISABLING","RESTORING","MODELED",
+                                         "DISABLED","DESTROYED"):
+            subj.error()
+        elif subj.group_info['status'] in ("DELETED","DESTROYED"):
+            if amodule.params['state'] == 'absent':
+                subj.nop()
+            if amodule.params['state'] in ('present','started','stopped'):
+                subj.create()
+        elif subj.group_info['techStatus'] in ("STARTED","STOPPED"):
+            if amodule.params['state'] == 'absent':
+                subj.destroy()
+            else:
+                subj.action()
+
+    else:
+        if amodule.params['state'] == 'absent':
+            subj.nop()
+        if amodule.params['state'] in ('present','started','stopped'):
+            subj.create()
+    
+    if subj.result['failed']:
+        amodule.fail_json(**subj.result)
+    else:
+        if subj.group_should_exist:
+            subj.result['facts'] = subj.package_facts(amodule.check_mode)
+            amodule.exit_json(**subj.result)
+        else:
+            amodule.exit_json(**subj.result)
+
+if __name__ == "__main__":
+    main()

library/decort_k8s.py

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

library/decort_kvmvm.py

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

library/decort_lb.py

@@ -0,0 +1,328 @@
+#!/usr/bin/python
+#
+# Digital Enegry Cloud Orchestration Technology (DECORT) modules for Ansible
+# Copyright: (c) 2018-2022 Digital Energy Cloud Solutions LLC
+#
+# Apache License 2.0 (see http://www.apache.org/licenses/LICENSE-2.0.txt)
+#
+
+ANSIBLE_METADATA = {'metadata_version': '1.1',
+                    'status': ['preview'],
+                    'supported_by': 'community'}
+
+DOCUMENTATION = '''
+    TODO
+'''
+
+EXAMPLES = '''
+    TODO
+'''
+
+
+from ansible.module_utils.basic import AnsibleModule
+from ansible.module_utils.basic import env_fallback
+
+from ansible.module_utils.decort_utils import *
+
+class decort_lb(DecortController):
+    def __init__(self,arg_amodule) -> None:
+        super(decort_lb,self).__init__(arg_amodule)    
+
+        self.lb_id = 0
+        self.lb_facts = None
+        self.vins_id = 0
+        self.vins_facts = None
+        self.rg_id = 0
+        self.rg_facts = None
+        self.acc_id = 0
+        self.acc_facts = None
+        self.default_server_check = "enabled"
+        self.default_alg = "roundrobin"
+        self.default_settings = {
+                "downinter": 10000,
+                "fall": 2,
+                "inter": 5000,
+                "maxconn": 250,
+                "maxqueue": 256,
+                "rise": 2,
+                "slowstart": 60000,
+                "weight": 100,
+        }        
+        if arg_amodule.params['lb_id']:
+            self.lb_id, self.lb_facts = self.lb_find(arg_amodule.params['lb_id'])
+            if not self.lb_id:
+                self.result['failed'] = True
+                self.result['msg'] = "Specified LB ID {} not found."\
+                .format(arg_amodule.params['lb _id'])
+                self.fail_json(**self.result)
+            self.acc_id = self.lb_facts['accountId']
+            self.rg_id = self.lb_facts['rgId']
+            self.vins_id = self.lb_facts['vinsId']
+            return
+                
+        if arg_amodule.params['rg_id']:
+            self.rg_id, self.rg_facts = self.rg_find(0,arg_amodule.params['rg_id'], arg_rg_name="")
+            if not self.rg_id:
+                self.result['failed'] = True
+                self.result['msg'] = "Specified RG ID {} not found.".format(arg_amodule.params['vins_id'])
+                self.fail_json(**self.result)
+
+        if arg_amodule.params['vins_id']:
+            self.vins_id, self.vins_facts = self.vins_find(arg_amodule.params['vins_id'])
+            if not self.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)
+
+        elif arg_amodule.params['account_id'] or arg_amodule.params['account_name'] != "":
+            
+            if arg_amodule.params['rg_name']:
+                self.result['failed'] = True
+                self.result['msg'] = ("RG name must be specified with account present")
+                self.fail_json(**self.result)
+            self.acc_id, self.acc_facts = self.account_find(arg_amodule.params['account_name'], 
+                                                            arg_amodule.params['account_id'])
+            if not self.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)
+            self.rg_id, self.rg_facts = self.rg_find(self._acc_id,0, arg_rg_name=arg_amodule.params['rg_name'])
+        
+        if self.rg_id and self.vins_id:
+            self.lb_id, self.lb_facts = self.lb_find(0,arg_amodule.params['lb_name'],self.rg_id)
+        return
+    
+    def create(self):
+        self.lb_id = self.lb_provision(self.amodule.params['lb_name'],
+                                    self.rg_id,self.vins_id,
+                                    self.amodule.params['ext_net_id'],
+                                    self.amodule.params['annotation'])
+        if self.amodule.params['backends'] or self.amodule.params['frontends']:
+            self.lb_id, self.lb_facts = self.lb_find(0,self.amodule.params['lb_name'],self.rg_id)
+            self.lb_update(
+                self.lb_facts['backends'],
+                self.lb_facts['frontends'],
+                self.amodule.params['backends'],
+                self.amodule.params['servers'],
+                self.amodule.params['frontends']
+            )        
+        return
+    
+    def action(self,d_state='',restore=False):
+        if restore == True:
+            self.lb_restore(arg_vins_id=self.lb_id)
+            self.lb_state(self.vins_facts, 'enabled')
+            self.lb_facts['status'] = "ENABLED"
+            self.lb_facts['techStatus'] = "STARTED"    
+        
+        self.lb_update(
+            self.lb_facts['backends'],
+            self.lb_facts['frontends'],
+            self.amodule.params['backends'],
+            self.amodule.params['servers'],
+            self.amodule.params['frontends']
+        )
+
+        if d_state != '':
+            self.lb_state(self.lb_facts, d_state)
+        return
+
+    def delete(self):
+        self.lb_delete(self.lb_id, self.amodule.params['permanently'])
+        self.lb_facts['status'] = 'DESTROYED'
+        return
+    def nop(self):
+        """No operation (NOP) handler for LB management by decort_lb 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 LB state.
+        """
+        self.result['failed'] = False
+        self.result['changed'] = False
+        if self.lb_id:
+            self.result['msg'] = ("No state change required for LB  ID {} because of its "
+                                   "current status '{}'.").format(self.lb_id, self.vins_facts['status'])
+        else:
+            self.result['msg'] = ("No state change to '{}' can be done for "
+                                  "non-existent LB 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 LB ID {} in the "
+                                    "current status '{}'").format(self.lb_id,
+                                                                    self.amodule.params['state'],
+                                                                    self.lb_facts['status'])
+        else:
+            self.result['failed'] = True
+            self.result['changed'] = False
+            self.result['msg'] = ("Invalid target state '{}' requested for non-existent "
+                                   "LB name '{}'").format(self.amodule.params['state'],
+                                                            self.amodule.params['lb_name'])   
+        return
+    def package_facts(self, arg_check_mode=False):
+        """Package a dictionary of LB facts according to the decort_lb 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.lb_facts['id']
+        ret_dict['name'] = self.lb_facts['name']
+        ret_dict['state'] = self.lb_facts['status']
+        #ret_dict['account_id'] = self.lb_facts['accountId']
+        ret_dict['rg_id'] = self.lb_facts['rgId']
+        ret_dict['gid'] = self.lb_facts['gid']
+        if self.amodule.params['state']!="absent":
+            ret_dict['backends'] = self.lb_facts['backends']
+            ret_dict['frontends'] = self.lb_facts['frontends']
+        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."""
+
+        return dict(
+            account_id=dict(type='int', required=False),
+            account_name=dict(type='str', required=False, default=''),
+            annotation=dict(type='str', required=False, default='Managed by Ansible module decort_lb'),
+            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=''),
+            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','restart']),
+            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=''),
+            vins_name=dict(type='str', required=False, default=''),
+            vins_id=dict(type='int', required=False, default=0),
+            verify_ssl=dict(type='bool', required=False, default=True),
+            lb_id=dict(type='int', required=False, default=0),
+            lb_name=dict(type='str', required=True),
+            backends=dict(type='list',required=False,default=[]),
+            frontends=dict(type='list',required=False,default=[]),
+            servers=dict(type='list',required=False,default=[]),
+            permanently=dict(type='bool', required=False, default=False),
+            workflow_callback=dict(type='str', required=False),
+            workflow_context=dict(type='str', required=False),
+        )
+
+def main():
+    module_parameters = decort_lb.build_parameters()
+
+    amodule = AnsibleModule(argument_spec=module_parameters,
+                            supports_check_mode=True,
+                            mutually_exclusive=[
+                                ['oauth2', 'password'],
+                                ['password', 'jwt'],
+                                ['jwt', 'oauth2'],
+                            ],
+                            required_together=[
+                                ['app_id', 'app_secret'],
+                                ['user', 'password']
+                            ],
+                            required_one_of=[
+                                ['rg_id','rg_name'],
+                                ['lb_id','lb_name'],
+                                ['vins_id','vins_name']
+                            ]
+                            )
+    decon = decort_lb(amodule)
+    if decon.lb_id:
+        if decon.lb_facts['status'] in ["MODELED", "DISABLING", "ENABLING", "DELETING","DESTROYING","RESTORING"]:
+            decon.result['failed'] = True
+            decon.result['changed'] = False
+            decon.result['msg'] = ("No change can be done for existing LB ID {} because of its current "
+                                "status '{}'").format(decon.lb_id, decon.lb_facts['status'])
+        elif decon.lb_facts['status'] == "DISABLED":
+                if amodule.params['state'] == 'absent':
+                    decon.delete()
+                elif amodule.params['state'] in ('present', 'disabled'):
+                    decon.action()
+                elif amodule.params['state'] == 'enabled':
+                    decon.action('enabled')
+        elif decon.lb_facts['status'] in ["CREATED", "ENABLED"]:
+                if amodule.params['state'] == 'absent':
+                    decon.delete()
+                elif amodule.params['state'] in ('present', 'enabled'):
+                    decon.action()
+                elif amodule.params['state'] == 'disabled':
+                    decon.action('disabled')
+                elif amodule.params['state'] in ('stopped', 'started','restart'):
+                    decon.action(amodule.params['state'])
+        elif decon.lb_facts['status'] == "DELETED":
+            if amodule.params['state'] in ['present', 'enabled']:
+                decon.action(restore=True)
+            elif amodule.params['state'] == 'absent':
+                decon.delete()
+            elif amodule.params['state'] == 'disabled':
+                decon.error()
+        elif decon.lb_facts['status'] == "DESTROYED":
+            if amodule.params['state'] in ('present', 'enabled'):
+                decon.create()
+            elif amodule.params['state'] == 'absent':
+                decon.nop()
+            elif amodule.params['state'] == 'disabled':
+                decon.error()
+    else:
+        if amodule.params['state'] == 'absent':
+            decon.nop()
+        elif amodule.params['state'] in ('present', 'enabled'):
+            decon.create()
+        elif amodule.params['state'] == 'disabled':
+            decon.error()
+
+    if decon.result['failed']:
+        amodule.fail_json(**decon.result)
+    else:
+        if decon.result['changed'] and amodule.params['state'] != 'absent':
+            _, decon.lb_facts = decon.lb_find(decon.lb_id)
+        if decon.lb_id:
+            decon.result['facts'] = decon.package_facts(amodule.check_mode)
+        amodule.exit_json(**decon.result)
+if __name__ == "__main__":
+    main()

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
+        - 'The specified image name will be looked up in the target DECORT controller and error will be generated
-          no matching image is found.'
+        - 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 }}"
+      verify_ssl: False
-      app_secret: "{{ MY_APP_SECRET }}"
       controller_url: "https://ds1.digitalenergy.online"
-      image_name: "Ubuntu 18.04 v1.2.5"
+      state: present
-      account_name: "GreyseDevelopment"
+      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):
+        self.validated_image_id = 0
-    """Package a dictionary of OS image according to the decort_osimage module specification. This 
+        self.validated_virt_image_id = 0
-    dictionary will be returned to the upstream Ansible engine at the completion of the module run.
+        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:
+    def decort_image_find(self, amodule):
-        # if void facts provided - change state value to ABSENT and return
+        # function that finds the OS image
-        ret_dict['state'] = "ABSENT"
+        image_id, image_facts = self.image_find(image_id=amodule.params['image_id'], image_name=self.validated_image_name,
-        return ret_dict
+                                                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']
+    def decort_image_delete(self,amodule):
-    ret_dict['name'] = arg_osimage_facts['name']
+        # function that removes an image
-    ret_dict['size'] = arg_osimage_facts['size']
+        self.image_delete(imageId=amodule.image_id_delete, permanently=amodule.params['permanently'])
-    ret_dict['type'] = arg_osimage_facts['type']
+        self.result['changed'] = True
-    # ret_dict['arch'] = arg_osimage_facts['architecture']
+        self.result['msg'] = ("Image '{}' deleted").format(amodule.image_id_delete)
-    ret_dict['sep_id'] = arg_osimage_facts['sepId']
-    ret_dict['pool'] = arg_osimage_facts['pool']
-    ret_dict['state'] = arg_osimage_facts['status']
 
-    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(
+    def decort_osimage_package_facts(arg_osimage_facts, arg_check_mode=False):
-        app_id=dict(type='str',
+        """Package a dictionary of OS image according to the decort_osimage module specification. This
-                    required=False,
+        dictionary will be returned to the upstream Ansible engine at the completion of the module run.
-                    fallback=(env_fallback, ['DECORT_APP_ID'])),
+
-        app_secret=dict(type='str',
+        @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']),
+                        fallback=(env_fallback, ['DECORT_APP_ID'])),
-                        no_log=True),
+            app_secret=dict(type='str',
-        authenticator=dict(type='str',
+                            required=False,
-                           required=True,
+                            fallback=(env_fallback, ['DECORT_APP_SECRET']),
-                           choices=['legacy', 'oauth2', 'jwt']),
+                            no_log=True),
-        controller_url=dict(type='str', required=True),
+            authenticator=dict(type='str',
-        image_name=dict(type='str', required=True),
+                               required=True,
-        jwt=dict(type='str',
+                               choices=['legacy', 'oauth2', 'jwt']),
-                 required=False,
+            controller_url=dict(type='str', required=True),
-                 fallback=(env_fallback, ['DECORT_JWT']),
+            jwt=dict(type='str',
-                 no_log=True),
+                     required=False,
-        oauth2_url=dict(type='str',
+                     fallback=(env_fallback, ['DECORT_JWT']),
-                        required=False,
+                     no_log=True),
-                        fallback=(env_fallback, ['DECORT_OAUTH2_URL'])),
+            oauth2_url=dict(type='str',
-        password=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']),
+                      fallback=(env_fallback, ['DECORT_USER'])),
-                      no_log=True),
+            verify_ssl=dict(type='bool', required=False, default=True),
-        pool=dict(type='str', required=False, default=""),
+            workflow_callback=dict(type='str', required=False),
-        sep_id=dict(type='int', required=False, default=0),
+            workflow_context=dict(type='str', required=False),
-        account_name=dict(type='str', required=True),
+            image_name=dict(type='str', required=False),
-        user=dict(type='str',
+            image_id=dict(type='int', required=False,default=0),
-                  required=False,
+            virt_id=dict(type='int', required=False, default=0),
-                  fallback=(env_fallback, ['DECORT_USER'])),
+            virt_name=dict(type='str', required=False),
-        vdc_id=dict(type='int', required=False, default=0),
+            state=dict(type='str',
-        verify_ssl=dict(type='bool', required=False, default=True),
+                   default='present',
-        workflow_callback=dict(type='str', required=False),
+                   choices=['absent', 'present']),
-        workflow_context=dict(type='str', required=False),
+            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"),
-# Workflow digest:
+            boottype=dict(type='str', required=False, default="uefi"),
-# 1) authenticate to DECORT controller & validate authentication by issuing API call - done when 
+            url=dict(type='str', required=False),
-#    creating DecortController
+            gid=dict(type='int', required=False, default=0),
-# 2) obtain a list of OS images accessible to the specified account (and optionally - within 
+            sepId=dict(type='int', required=False, default=0),
-#    the specified VDC)
+            poolName=dict(type='str', required=False),
-# 3) match specified OS image by its name - if image is not found abort the module
+            hotresize=dict(type='bool', required=False, default=False),
-# 5) report result to Ansible
+            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

@@ -245,102 +245,287 @@ from ansible.module_utils.basic import env_fallback
 
 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):
+        self.vins_id = 0
-    """Package a dictionary of ViNS facts according to the decort_vins module specification. 
+        self.vins_level = ""  # "ID" if specified by ID, "RG" - at resource group, "ACC" - at account level
-    This dictionary will be returned to the upstream Ansible engine at the completion of 
+        vins_facts = None  # will hold ViNS facts
-    the module run.
+        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
+        if arg_amodule.params['vins_id']:
-    @param arg_check_mode: boolean that tells if this Ansible module is run in check mode
+            # 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'])
-    ret_dict = dict(id=0,
+            if not self.vins_id:
-                    name="none",
+                self.result['failed'] = True
-                    state="CHECK_MODE",
+                self.result['msg'] = "Specified ViNS ID {} not found.".format(arg_amodule.params['vins_id'])
-                    )
+                self.fail_json(**self.result)
-
+            self.vins_level = "ID"
-    if arg_check_mode:
+            validated_acc_id = vins_facts['accountId']
-        # in check mode return immediately with the default values
+            validated_rg_id = vins_facts['rgId']
-        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
-
-    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']
+        elif arg_amodule.params['rg_id']:
-    #   ext_ip_addr -> ext_net_ip
+            # expect ViNS @ RG level in the RG with specified ID
-    #   ???         -> ext_net_id
+            self.vins_level = "RG"
-    # tech_status   -> techStatus
+            # 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)
+                self.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)
+                self.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)
 
+            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 = ''
 
-    return ret_dict
+        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.
 
-def decort_vins_parameters():
+        @param arg_check_mode: boolean that tells if this Ansible module is run in check mode
-    """Build and return a dictionary of parameters expected by decort_vins module in a form accepted
+        """
-    by AnsibleModule utility class."""
 
-    return dict(
+        ret_dict = dict(id=0,
-        account_id=dict(type='int', required=False),
+                        name="none",
-        account_name=dict(type='str', required=False, default=''),
+                        state="CHECK_MODE",
-        annotation=dict(type='str', required=False, default=''),
+                        )
-        app_id=dict(type='str',
+
+        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
+
+        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."""
+
+        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'])),
+                    fallback=(env_fallback, ['DECORT_JWT']),
-        app_secret=dict(type='str',
+                    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',
+            state=dict(type='str',
-                           required=True,
+                    default='present',
-                           choices=['legacy', 'oauth2', 'jwt']),
+                    choices=['absent', 'disabled', 'enabled', 'present']),
-        controller_url=dict(type='str', required=True),
+            user=dict(type='str',
-        # datacenter=dict(type='str', required=False, default=''),
+                    required=False,
-        ext_net_id=dict(type='int', required=False, default=-1),
+                    fallback=(env_fallback, ['DECORT_USER'])),
-        ext_ip_addr=dict(type='str', required=False, default=''),
+            rg_id=dict(type='int', required=False, default=0),
-        ipcidr=dict(type='str', required=False, default=''),
+            rg_name=dict(type='str', required=False, default=''),
-        jwt=dict(type='str',
+            verify_ssl=dict(type='bool', required=False, default=True),
-                 required=False,
+            vins_id=dict(type='int', required=False, default=0),
-                 fallback=(env_fallback, ['DECORT_JWT']),
+            vins_name=dict(type='str', required=True),
-                 no_log=True),
+            workflow_callback=dict(type='str', required=False),
-        oauth2_url=dict(type='str',
+            workflow_context=dict(type='str', required=False),
-                        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),
-    )
 
 # Workflow digest:
 # 1) authenticate to DECORT controller & validate authentication by issuing API call - done when creating DECORTController
@@ -350,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,
@@ -365,84 +550,7 @@ def main():
                             ],
                             )
 
-    decon = DecortController(amodule)
+    decon = decort_vins(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)
-
     #
     # Initial validation of module arguments is complete
     #
@@ -453,124 +561,76 @@ def main():
     #
     # When managing existing ViNS we need to account for both "static" and "transient"
     # status. Full range of ViNS statii is as follows:
-    # 
+    #
     # "MODELED", "CREATED", "ENABLED", "ENABLING", "DISABLED", "DISABLING", "DELETED", "DELETING", "DESTROYED", "DESTROYING"
-    # 
+    #
-
+    # 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'])
+                                   "status '{}'").format(decon.vins_id, decon.vins_facts['status'])
-        elif vins_facts['status'] == "DISABLED":
+        elif decon.vins_facts['status'] == "DISABLED":
             if amodule.params['state'] == 'absent':
-                decon.vins_delete(vins_id, permanently=True)
+                decon.delete()
-                vins_facts['status'] = 'DESTROYED'
                 vins_should_exist = False
             elif amodule.params['state'] in ('present', 'disabled'):
                 # update ViNS, leave in disabled state
-                decon.vins_update(vins_facts,
+                decon.action()
-                                  amodule.params['ext_net_id'], amodule.params['ext_ip_addr'])
             elif amodule.params['state'] == 'enabled':
                 # update ViNS and enable
-                decon.vins_update(vins_facts,
+                decon.action('enabled')
-                                  amodule.params['ext_net_id'], amodule.params['ext_ip_addr'])
+        elif decon.vins_facts['status'] in ["CREATED", "ENABLED"]:
-                decon.vins_state(vins_facts, 'enabled')
-        elif vins_facts['status'] in ["CREATED", "ENABLED"]:
             if amodule.params['state'] == 'absent':
-                decon.vins_delete(vins_id, permanently=True)
+                decon.delete()
-                vins_facts['status'] = 'DESTROYED'
                 vins_should_exist = False
             elif amodule.params['state'] in ('present', 'enabled'):
                 # update ViNS
-                decon.vins_update(vins_facts,
+                decon.action()
-                                  amodule.params['ext_net_id'], amodule.params['ext_ip_addr'])
             elif amodule.params['state'] == 'disabled':
                 # disable and update ViNS
-                decon.vins_state(vins_facts, 'disabled')
+                decon.action('disabled')
-                decon.vins_update(vins_facts,
+        elif decon.vins_facts['status'] == "DELETED":
-                                  amodule.params['ext_net_id'], amodule.params['ext_ip_addr'])
-        elif vins_facts['status'] == "DELETED":
             if amodule.params['state'] in ['present', 'enabled']:
                 # restore and enable
-                decon.vins_restore(arg_vins_id=vins_id)
+                decon.action(restore=True)
-                decon.vins_state(vins_facts, 'enabled')
                 vins_should_exist = True
             elif amodule.params['state'] == 'absent':
                 # destroy permanently
-                decon.vins_delete(vins_id, permanently=True)
+                decon.delete()
-                vins_facts['status'] = 'DESTROYED'
                 vins_should_exist = False
             elif amodule.params['state'] == 'disabled':
-                # error
+                decon.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'])
                 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.
+                # need to re-provision ViNS;
-                # account and RG - stays the same
+                decon.create()
-                # 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'])
                 vins_should_exist = True
             elif amodule.params['state'] == 'absent':
-                # nop
+                decon.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'])
                 vins_should_exist = False
             elif amodule.params['state'] == 'disabled':
-                # error
+                decon.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'])
     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.nop()
-            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'])
         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'],
+            decon.create()
-                                            validated_acc_id, validated_rg_id,
+            vins_should_exist = True
-                                            amodule.params['ipcidr'], 
-                                            amodule.params['ext_net_id'], amodule.params['ext_ip_addr'],
-                                            amodule.params['annotation'])
-            vins_should_exist = True            
         elif amodule.params['state'] == 'disabled':
-            decon.result['failed'] = True
+            decon.error()
-            decon.result['changed'] = False
-            decon.result['msg'] = ("Invalid target state '{}' requested for non-existent "
-                                   "ViNS name '{}'").format(amodule.params['state'],
-                                                            amodule.params['vins_name'])
-    
     #
     # conditional switch end - complete module run
     #
@@ -578,14 +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 decon.result['changed']:
+            _, decon.vins_facts = decon.vins_find(decon.vins_id)
-                # If we arrive here, there is a good chance that the ViNS is present - get fresh ViNS
+        decon.result['facts'] = decon.package_facts(amodule.check_mode)
-                # 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)
         amodule.exit_json(**decon.result)