add osimages, add ViNS management

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/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/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/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/kubernetes.yaml

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

examples/rename-osimage.yaml

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

examples/vins_connect.yaml

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

library/decort_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_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

@@ -80,7 +80,7 @@ class decort_k8s(DecortController):
             if self.k8s_id:
                 self.k8s_should_exist = True
                 self.acc_id = self.k8s_info['accountId']
-            # check workers and groups for add or remove
+            # check workers and groups for add or remove?
         
         return
 
@@ -147,17 +147,13 @@ class decort_k8s(DecortController):
 
     def create(self):
         self.k8s_provision(self.amodule.params['name'],
-                                    self.amodule.params['workers'][0]['name'],
                                     self.amodule.params['k8ci_id'],
                                     self.amodule.params['rg_id'],
                                     self.amodule.params['master_count'],
                                     self.amodule.params['master_cpu'],
                                     self.amodule.params['master_ram_mb'],
                                     self.amodule.params['master_disk_gb'],
-                                    self.amodule.params['workers'][0]['num'],
+                                    self.amodule.params['workers'][0],
-                                    self.amodule.params['workers'][0]['cpu'],
-                                    self.amodule.params['workers'][0]['ram'],
-                                    self.amodule.params['workers'][0]['disk'],
                                     self.amodule.params['extnet_id'],
                                     self.amodule.params['with_lb'],
                                     self.amodule.params['description'],)

library/decort_kvmvm.py

@@ -794,7 +794,7 @@ class decort_kvmvm(DecortController):
             affinity_label=dict(type='str', required=False),
             aff_rule=dict(type='list', required=False),
             aaff_rule=dict(type='list', required=False),
-            ci_user_data=dict(type='list', required=False),
+            ci_user_data=dict(type='list',elements='dict', required=False),
             state=dict(type='str',
                        default='present',
                        choices=['absent', 'paused', 'poweredoff', 'halted', 'poweredon', 'present', 'check']),

library/decort_osimage.py

@@ -22,8 +22,7 @@ description: >
      This module can be used to obtain image ID of an OS image in DECORT cloud to use with subsequent calls to
      decort_vm module for batch VM provisioning. It will speed up VM creation and save a bunch of extra calls to
      DECORT cloud controller on each VM creation act.
-     Note that this module is effectively an information provisioner. It is not designed to and does not manage 
+
-     nor change state of OS image (or any other) objects in DECORT cloud.
 version_added: "2.2"
 author:
      - Sergey Shubin <sergey.shubin@digitalenergy.online>
@@ -68,8 +67,8 @@ options:
     image_name:
         description:
         - Name of the OS image to use. Module will return the ID of this image.
-        - 'The specified image name will be looked up in the target DECORT controller and error will be generated if
+        - '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

@@ -242,6 +242,7 @@ facts:
 
 from ansible.module_utils.basic import AnsibleModule
 from ansible.module_utils.basic import env_fallback
+import paramiko
 
 from ansible.module_utils.decort_utils import *
 
@@ -316,6 +317,10 @@ def decort_vins_parameters():
         ext_net_id=dict(type='int', required=False, default=-1),
         ext_ip_addr=dict(type='str', required=False, default=''),
         ipcidr=dict(type='str', required=False, default=''),
+        mgmtaddr=dict(type='str',required=False, default=''),
+        custom_config=dict(type='bool',required=False, default=False),
+        config_save=dict(type='bool',required=False, default=False),
+        connect_to=dict(type='list', default=[], required=False),
         jwt=dict(type='str',
                  required=False,
                  fallback=(env_fallback, ['DECORT_JWT']),
@@ -387,6 +392,7 @@ def main():
         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"
@@ -443,7 +449,6 @@ def main():
             # 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
     #
@@ -457,7 +462,7 @@ def main():
     #
     # "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:
@@ -491,7 +496,17 @@ def main():
             elif amodule.params['state'] in ('present', 'enabled'):
                 # update ViNS
                 decon.vins_update(vins_facts,
-                                  amodule.params['ext_net_id'], amodule.params['ext_ip_addr'])
+                                  amodule.params['ext_net_id'], amodule.params['ext_ip_addr'],
+                                  
+                                  )
+                decon.vins_update_mgmt(
+                                        vins_facts,
+                                        amodule.params['mgmtaddr'],
+                                        )
+                decon.vins_update_ifaces(
+                                        vins_facts,
+                                        amodule.params['connect_to'],
+                )
             elif amodule.params['state'] == 'disabled':
                 # disable and update ViNS
                 decon.vins_state(vins_facts, 'disabled')
@@ -586,6 +601,10 @@ def main():
                 # be returned.
                 _, vins_facts = decon.vins_find(vins_id)
         decon.result['facts'] = decort_vins_package_facts(vins_facts, amodule.check_mode)
+        # add password to facts if mgmtaddr is present
+        # need reworking
+        if amodule.params['mgmtaddr'] != "":
+            decon.result['facts'].update({'password': vins_facts['VNFDev']['config']['mgmt']['password']})
         amodule.exit_json(**decon.result)
 
 

module_utils/decort_utils.py

@@ -1247,26 +1247,25 @@ class DecortController(object):
     def image_find(self, image_id, image_name, account_id, rg_id=0, sepid=0, pool=""):
         """Locates image specified by name and returns its facts as dictionary.
         Primary use of this function is to obtain the ID of the image identified by its name and,
-        optionally SEP ID and/or pool name. Also note that only images in status CREATED are 
+        optionally SEP ID and/or pool name. Also note that only images in status CREATED are
         returned.
 
         @param (string) image_id: ID of the OS image to find. If non-zero ID is specified, then
         image_name is ignored.
         @param (string) image_name: name of the OS image to find. This argument is ignored if non-zero
         image ID is passed.
-         @param (int) account_id: ID of the account for which the image will be looked up. If set to 0, 
+         @param (int) account_id: ID of the account for which the image will be looked up. If set to 0,
         the account ID will be obtained from the specified RG ID.
         @param (int) rg_id: ID of the RG to use as a reference when listing OS images. This argument is
         ignored if non-zero image id and/or non-zero account_id are specified.
-        @param (int) sepid: ID of the SEP where the image should be present. If set to 0, there will be no 
+        @param (int) sepid: ID of the SEP where the image should be present. If set to 0, there will be no
         filtering by SEP ID and the first matching image will be returned.
-        @param (string) pool: name of the pool where the image should be present. If set to empty string, there 
+        @param (string) pool: name of the pool where the image should be present. If set to empty string, there
         will be no filtering by pool name and first matching image will be returned.
 
-        @return: image ID and dictionary with image specs. If no matching image found, 0 for ID and None for 
+        @return: image ID and dictionary with image specs. If no matching image found, 0 for ID and None for
         dictionary are returned, and self.result['failed']=True.
         """
-
         self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "image_find")
 
         if image_id > 0:
@@ -1292,7 +1291,7 @@ class DecortController(object):
             for image_record in images_list:
                 if image_record['name'] == image_name and image_record['status'] == "CREATED":
                     if sepid == 0 and pool == "":
-                        # if no filtering by SEP ID or pool name is requested, return the first match 
+                        # if no filtering by SEP ID or pool name is requested, return the first match
                         return image_record['id'], image_record
                     # if positive SEP ID and/or non-emtpy pool name are passed, match by them
                     full_match = True
@@ -1302,6 +1301,7 @@ class DecortController(object):
                         full_match = False
                     if full_match:
                         return image_record['id'], image_record
+            self.result['failed'] = False
 
         self.result['failed'] = True
         self.result['msg'] = ("Failed to find OS image by name '{}', SEP ID {}, pool '{}' for "
@@ -1310,6 +1310,136 @@ class DecortController(object):
                                                          account_id)
         return 0, None
 
+    def virt_image_find(self, image_id, virt_name, account_id, rg_id=0, sepid=0, pool=""):
+        """Locates  virtual image specified by name and returns its facts as dictionary.
+        Primary use of this function is to obtain the ID of the image identified by its name and,
+        optionally SEP ID and/or pool name. Also note that only virtual images in status CREATED are
+        returned.
+
+        @param (string) image_id: ID of the OS image to find. If non-zero ID is specified, then
+        virt_name is ignored.
+        @param (string) virt_name: name of the OS image to find. This argument is ignored if non-zero
+        image ID is passed.
+         @param (int) account_id: ID of the account for which the image will be looked up. If set to 0,
+        the account ID will be obtained from the specified RG ID.
+        @param (int) rg_id: ID of the RG to use as a reference when listing OS images. This argument is
+        ignored if non-zero image id and/or non-zero account_id are specified.
+        @param (int) sepid: ID of the SEP where the image should be present. If set to 0, there will be no
+        filtering by SEP ID and the first matching image will be returned.
+        @param (string) pool: name of the pool where the image should be present. If set to empty string, there
+        will be no filtering by pool name and first matching image will be returned.
+
+        @return: image ID and dictionary with image specs. If no matching image found, 0 for ID and None for
+        dictionary are returned, and self.result['failed']=True.
+        """
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "virt_image_find")
+
+
+
+        if image_id > 0:
+            ret_image_id, ret_image_dict = self._image_get_by_id(image_id)
+            if (ret_image_id and
+                    (sepid == 0 or sepid == ret_image_dict['sepId']) and
+                    (pool == "" or pool == ret_image_dict['pool'])):
+                return ret_image_id, ret_image_dict
+        else:
+            validated_acc_id = account_id
+            if account_id == 0:
+                validated_rg_id, rg_facts = self._rg_get_by_id(rg_id)
+                if not validated_rg_id:
+                    self.result['failed'] = True
+                    self.result['msg'] = ("Failed to find RG ID {}, and account ID is zero.").format(rg_id)
+                    return 0, None
+                validated_acc_id = rg_facts['accountId']
+
+            api_params = dict(accountId=validated_acc_id)
+            api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/image/list", api_params)
+            # On success the above call will return here. On error it will abort execution by calling fail_json.
+            images_list = json.loads(api_resp.content.decode('utf8'))
+            for image_record in images_list:
+                if image_record['name'] == virt_name and image_record['status'] == "CREATED" and image_record['type'] == "virtual":
+                    if sepid == 0 and pool == "":
+                        # if no filtering by SEP ID or pool name is requested, return the first match
+                        return image_record['id'], image_record
+                    full_match = True
+                    if full_match:
+                        return image_record['id'], image_record
+
+        self.result['failed'] = True
+        self.result['msg'] = ("Failed to find virtual OS image by name '{}', SEP ID {}, pool '{}' for "
+                              "account ID '{}'.").format(virt_name,
+                                                         sepid, pool,
+                                                         account_id)
+
+        return 0, None
+
+    def virt_image_create(self, name, targetId):
+
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "virt_image_create")
+
+        api_params = dict(name=name, targetId=targetId,)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/image/createVirtual", api_params)
+        # On success the above call will return here. On error it will abort execution by calling fail_json.
+        virt_image_dict = json.loads(api_resp.content.decode('utf8'))
+
+        self.result['failed'] = False
+        self.result['changed'] = True
+        return 0, None
+
+    def image_delete(self, imageId, permanently):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "image_delete")
+
+        api_params = dict(imageId=imageId, permanently=permanently,)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/image/delete", api_params)
+        # On success the above call will return here. On error it will abort execution by calling fail_json.
+        image_dict = json.loads(api_resp.content.decode('utf8'))
+
+        self.result['changed'] = True
+        return 0, None
+
+
+    def image_create(self,img_name,url,gid,boottype,imagetype,architecture,drivers,hotresize,username,password,account_Id,usernameDL,passwordDL,sepId,poolName):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "image_create")
+
+        api_params = dict(name=img_name, url=url,
+                            gid=gid, boottype=boottype,
+                            imagetype=imagetype, architecture=architecture,
+                            drivers=drivers, accountId=account_Id,
+                            hotresize=hotresize, username=username,
+                            password=password, usernameDL=usernameDL,
+                            passwordDL=passwordDL, sepId=sepId,
+                            poolName=poolName,
+                            )
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/image/create", api_params)
+        # On success the above call will return here. On error it will abort execution by calling fail_json.
+        virt_image_dict = json.loads(api_resp.content.decode('utf8'))
+        self.result['failed'] = False
+        self.result['changed'] = True
+        return 0, None
+
+    def virt_image_link(self, imageId, targetId):
+
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "virt_image_link")
+
+        api_params = dict(imageId=imageId, targetId=targetId,)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/image/link", api_params)
+        # On success the above call will return here. On error it will abort execution by calling fail_json.
+        link_image_dict = json.loads(api_resp.content.decode('utf8'))
+        self.result['failed'] = False
+        self.result['changed'] = True
+
+
+        return 0, None
+
+    def image_rename(self, imageId, name):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "image_rename")
+        api_params = dict(imageId=imageId, name=name,)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/image/rename", api_params)
+        # On success the above call will return here. On error it will abort execution by calling fail_json.
+        link_image_dict = json.loads(api_resp.content.decode('utf8'))
+        self.result['failed'] = False
+        self.result['changed'] = True
+
     ###################################
     # Resource Group (RG) manipulation methods
     ###################################
@@ -2146,10 +2276,10 @@ class DecortController(object):
         expected_state = ""
 
         if vins_dict['status'] in ["CREATED", "ENABLED"] and desired_state == 'disabled':
-            rgstate_api = "/restmachine/cloudapi/vins/disable"
+            vinsstate_api = "/restmachine/cloudapi/vins/disable"
             expected_state = "DISABLED"
         elif vins_dict['status'] == "DISABLED" and desired_state == 'enabled':
-            rgstate_api = "/restmachine/cloudapi/vins/enable"
+            vinsstate_api = "/restmachine/cloudapi/vins/enable"
             expected_state = "ENABLED"
 
         if vinsstate_api != "":
@@ -2241,8 +2371,172 @@ class DecortController(object):
                 self.result['warning'] = ("vins_update(): ViNS ID {} is already connected to ext net ID {}, "
                                           "no reconnection to default network will be done.").format(vins_dict['id'],
                                                                                                      gw_config[
-                                                                                                         'ext_net_id'])
+                                                                                                         'ext_net_id']) 
+        return
+    def vins_update_mgmt(self, vins_dict, mgmtaddr=""):
+        
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "vins_update_mgmt")
+        
+        if self.amodule.params['config_save'] and vins_dict['VNFDev']['customPrecfg']:
+            # only save config,no other modifictaion
+            self.result['changed'] = True
+            self._vins_vnf_config_save(vins_dict['VNFDev']['id'])
+            self.result['changed'] = True
+            self.result['failed'] = False
+            return
+        
+        for iface in vins_dict['VNFDev']['interfaces']:
+            if iface['ipAddress'] == mgmtaddr:
+                if  not iface['listenSsh']:
+                    self._vins_vnf_addmgmtaddr(vins_dict['VNFDev']['id'],mgmtaddr)
+                    self.result['changed'] = True
+                    self.result['failed'] = False
+            elif mgmtaddr =="":
+                if iface['listenSsh'] and iface['name'] != "ens9":
+                    self._vins_vnf_delmgmtaddr(vins_dict['VNFDev']['id'],iface['ipAddress'])
+                    self.result['changed'] = True
+                    self.result['failed'] = False
+        if self.amodule.params['custom_config']:
+            if not vins_dict['VNFDev']['customPrecfg']:
+                self._vins_vnf_config_save(vins_dict['VNFDev']['id'])
+                self._vins_vnf_customconfig_set(vins_dict['VNFDev']['id'])
+                self.result['changed'] = True
+                self.result['failed'] = False
+        else: 
+            if vins_dict['VNFDev']['customPrecfg']:
+                self._vins_vnf_customconfig_set(vins_dict['VNFDev']['id'],False)
+                self.result['changed'] = True
+                self.result['failed'] = False
+        return
+    
+    def vins_update_ifaces(self,vins_dict,vinses=""):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "vins_update_ifaces")
+        existed_conn_ip = []
+        #vnf_dict = self._get_vnf_by_id(vins_dict['VNFDev']['id'])
+        list_account_vins = self._get_all_account_vinses(vins_dict['VNFDev']['accountId'])
+        list_account_vinsid = [rec['id'] for rec in list_account_vins]
+        list_ifaces_ip = [rec['ipaddr'] for rec in vinses]
+        vins_inner = [rec['id'] for rec in vinses]
+        vins_outer = [rec['id'] for rec in list_account_vins]    
+        for iface in vins_dict['VNFDev']['interfaces']:
+            if iface['connType'] == "VXLAN" and iface['type'] == "CUSTOM":
+                if iface['ipAddress'] not in list_ifaces_ip:
+                    self._vnf_iface_remove(vins_dict['VNFDev']['id'],iface['name'])
+                    self.result['changed'] = True
+                    self.result['failed'] = False
+                else:
+                    existed_conn_ip.append(iface['ipAddress'])
 
+        for vins in vinses:
+            if vins['id'] in list_account_vinsid:
+                _,v_dict = self._vins_get_by_id(vins['id'])
+                if vins['ipaddr'] not in existed_conn_ip: 
+                    self._vnf_iface_add(vins_dict['VNFDev']['id'],v_dict['vxlanId'],vins['ipaddr'],vins['netmask'])
+                    self.result['changed'] = True
+                    self.result['failed'] = False  
+        return
+
+    def _vnf_iface_add(self,arg_devid,arg_vxlanid,arg_ipaddr,arg_netmask="24",arg_defgw=""):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "_vnf_iface_add")
+        api_params = dict(
+            devId=arg_devid,
+            ifType="CUSTOM",
+            connType="VXLAN",
+            connId=arg_vxlanid,
+            ipAddr=arg_ipaddr,
+            netMask=arg_netmask,
+            defGw=arg_defgw
+        )
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/ifaceAdd", api_params)
+        conn_dict = json.loads(api_resp.content.decode('utf8'))
+        return 
+
+    def _vnf_iface_remove(self,arg_devid,arg_iface_name):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "_vnf_iface_add")
+        api_params = dict(
+            devId=arg_devid,
+            name=arg_iface_name,
+
+        )
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/ifaceRemove", api_params)
+        return 
+
+    def _get_vnf_by_id(self,vnf_id):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "get_vnf_by_id")
+        api_params = dict(devId=vnf_id)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/get", api_params)
+        if api_resp.status_code == 200:
+            ret_vnf_dict = json.loads(api_resp.content.decode('utf8'))
+        else:
+            self.result['warning'] = ("get_all_account_vinses(): failed to configuration of the specified VNF device ID{}. HTTP code {}, "
+                                      "response {}.").format(vnf_id, api_resp.status_code, api_resp.reason)
+        return ret_vnf_dict
+
+    def _get_all_account_vinses(self,acc_id):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "get_all_account_vinses")
+        api_params = dict(accountId=acc_id)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/account/listVins", api_params)
+        if api_resp.status_code == 200:
+            ret_listvins_dict = json.loads(api_resp.content.decode('utf8'))
+        else:
+            self.result['warning'] = ("get_all_account_vinses(): failed to get list VINS in Account ID {}. HTTP code {}, "
+                                      "response {}.").format(acc_id, api_resp.status_code, api_resp.reason)
+        return ret_listvins_dict
+
+    def _vins_vnf_addmgmtaddr(self,dev_id,mgmtip):
+        
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "vins_vnf_addmgmtaddr")
+        api_params = dict(devId=dev_id,ip=mgmtip)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/addMgmtAddr", api_params)
+        if api_resp.status_code == 200:
+            self.result['changed'] = True
+            self.result['failed'] = False
+        else:
+            self.result['warning'] = ("_vins_vnf_addmgmtaddr(): failed to add MGMT addr VNFID {} iface ADDR {}. HTTP code {}, "
+                                      "response {}.").format(dev_id,mgmtip,api_resp.status_code, api_resp.reason)
+        return
+    
+    def _vins_vnf_delmgmtaddr(self,dev_id,mgmtip):
+        
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "vins_vnf_delmgmtaddr")
+        api_params = dict(devId=dev_id,ip=mgmtip)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/delMgmtAddr", api_params)
+        if api_resp.status_code == 200:
+            self.result['changed'] = True
+            self.result['failed'] = False
+        else:
+            self.result['warning'] = ("_vins_vnf_delmgmtaddr(): failed to delete MGMT addr VNFID {} iface ADDR {}. HTTP code {}, "
+                                      "response {}.").format(dev_id,mgmtip,api_resp.status_code, api_resp.reason)
+        return
+
+    def _vins_vnf_customconfig_set(self,dev_id,arg_mode=True):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "vins_vnf_customconfig_set")
+        api_params = dict(devId=dev_id,mode=arg_mode)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/customSet", api_params)
+        if api_resp.status_code == 200:
+            self.result['changed'] = True
+            self.result['failed'] = False
+        else:
+            self.result['warning'] = ("_vins_vnf_customconfig_set(): failed to enable or disable Custom pre-config mode on the VNF device. {}. HTTP code {}, "
+                                      "response {}.").format(dev_id,api_resp.status_code, api_resp.reason)
+        return
+    
+    def _vins_vnf_config_save(self,dev_id):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "vins_vnf_config_save")
+        api_params = dict(devId=dev_id)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudbroker/vnfdev/configSave", api_params)
+        if api_resp.status_code == 200:
+            self.result['changed'] = True
+            self.result['failed'] = False
+        else:
+            self.result['warning'] = ("_vins_vnf_config_set(): failed to Save configuration on the VNF device. {}. HTTP code {}, "
+                                      "response {}.").format(dev_id,api_resp.status_code, api_resp.reason)
+        return
+    
+    def vins_vnf_ifaceadd(self):
+        return
+    
+    def vins_vnf_ifaceremove(self):
         return
 
     ##############################
@@ -2573,8 +2867,8 @@ class DecortController(object):
                 iface_ipaddr = iface['ipAddress']
                 break
         else:
-            decon.result['failed'] = True
+            self.result['failed'] = True
-            decon.result['msg'] = "Compute ID {} is not connected to ViNS ID {}.".format(comp_facts['id'],
+            self.result['msg'] = "Compute ID {} is not connected to ViNS ID {}.".format(comp_facts['id'],
                                                                                          vins_facts['id'])
             return ret_rules
 
@@ -2891,12 +3185,9 @@ class DecortController(object):
         return
 
     def k8s_provision(self, k8s_name,
-                      wg_name, k8ci_id,
+                      k8ci_id,rg_id, master_count,
-                      rg_id, master_count,
                       master_cpu, master_ram,
-                      master_disk, worker_count,
+                      master_disk, default_worker, extnet_id,
-                      worker_cpu, worker_ram,
-                      worker_disk, extnet_id,
                       with_lb, annotation, ):
 
         self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "k8s_provision")
@@ -2906,20 +3197,31 @@ class DecortController(object):
             self.result['msg'] = ("k8s_provision() in check mode. Provision k8s '{}' in RG ID {} "
                                   "was requested.").format(k8s_name, rg_id)
             return 0
+        def_wg_name = default_worker['name']
+        def_wg_count = default_worker['num']
+        def_wg_cpu = default_worker['cpu']
+        def_wg_ram = default_worker['ram']
+        def_wg_disk = default_worker['disk']
+        def_wg_lab = default_worker['labels'] if "labels" in default_worker else None
+        def_wg_taints = default_worker['taints'] if "taints" in default_worker else None
+        def_wg_ann = default_worker['annotations'] if "annotations" in default_worker else None
 
         api_url = "/restmachine/cloudapi/k8s/create"
         api_params = dict(name=k8s_name,
                           rgId=rg_id,
                           k8ciId=k8ci_id,
-                          workerGroupName=wg_name,
+                          workerGroupName=def_wg_name,
                           masterNum=master_count,
                           masterCpu=master_cpu,
                           masterRam=master_ram,
                           masterDisk=master_disk,
-                          workerNum=worker_count,
+                          workerNum=def_wg_count,
-                          workerCpu=worker_cpu,
+                          workerCpu=def_wg_cpu,
-                          workerRam=worker_ram,
+                          workerRam=def_wg_ram,
-                          workerDisk=worker_disk,
+                          workerDisk=def_wg_disk,
+                          labels=def_wg_lab,
+                          taints=def_wg_taints,
+                          annotations=def_wg_ann,
                           extnetId=extnet_id,
                           withLB=with_lb,
                           desc=annotation,
@@ -2981,7 +3283,7 @@ class DecortController(object):
         
         for rec_inn in arg_k8swg['k8sGroups']['workers']:
             for rec_out in arg_modwg:
-                if rec_inn['num'] != rec_out['num']:
+                if rec_inn['num'] != rec_out['num'] and rec_out['num'] != 0:
                     count = rec_inn['num']-rec_out['num']
                     cmp_list = []
                     if count > 0:
@@ -3004,6 +3306,9 @@ class DecortController(object):
                                   workerCpu=wg['cpu'],
                                   workerRam=wg['ram'],
                                   workerDisk=wg['disk'],
+                                  labels=wg['labels'] if "labels" in wg else None,
+                                  taints=wg['taints'] if "taints" in wg else None,
+                                  annotations=wg['annotations'] if "annotations" in wg else None,
                                 )
                 api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/k8s/workersGroupAdd", api_params)
                 self.result['changed'] = True
@@ -3055,3 +3360,347 @@ class DecortController(object):
         ret_conf = api_resp.content.decode('utf8')
         return ret_conf
 
+    ##############################
+    #
+    # Bservice management
+    #
+    ##############################
+    def bservice_get_by_id(self,bs_id):
+        
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "bservice_get_by_id")
+
+        ret_bs_id = 0
+        ret_bs_dict = dict()
+
+        if not bs_id:
+            self.result['failed'] = True
+            self.result['msg'] = "bservice_get_by_id(): zero B-Service ID specified."
+            self.amodule.fail_json(**self.result)
+
+        api_params = dict(serviceId=bs_id, )
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/bservice/get", api_params)
+        if api_resp.status_code == 200:
+            ret_bs_id = bs_id
+            ret_bs_dict = json.loads(api_resp.content.decode('utf8'))
+        else:
+            self.result['warning'] = ("bservice_get_by_id(): failed to get B-service by ID {}. HTTP code {}, "
+                                      "response {}.").format(bs_id, api_resp.status_code, api_resp.reason)
+
+        return ret_bs_id, ret_bs_dict
+    def _bservice_rg_list(self,acc_id,rg_id):
+        ret_bs_dict=dict()
+        api_params = dict(accountId=acc_id,rgId=rg_id )
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/bservice/list", api_params)
+        if api_resp.status_code == 200:
+            ret_bs_dict = json.loads(api_resp.content.decode('utf8'))
+        else:
+            self.result['warning'] = ("bservice_rg_list(): failed to get B-service list. HTTP code {}, "
+                                      "response {}.").format(api_resp.status_code, api_resp.reason)
+        return ret_bs_dict
+    
+    def bservice_find(self,account_id,rg_id,bservice_name="",bservice_id = 0,check_state=True):
+        
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "bservice_find")
+
+        if bservice_id == 0:
+            bs_rg_list = self._bservice_rg_list(account_id,rg_id)
+            for srv in bs_rg_list:
+                if bservice_name == srv['name']:
+                    bservice_id = int(srv['id'])
+
+        if  bservice_id > 0:
+            ret_bs_id,ret_bs_dict = self.bservice_get_by_id(bservice_id)
+            return ret_bs_id,ret_bs_dict
+        else:
+            return bservice_id,None
+    
+    def bservice_provision(self,bs_name,rgid,sshuser=None,sshkey=None):
+        
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "bservice_provision")
+
+        api_url = "/restmachine/cloudapi/bservice/create"
+        api_params = dict(
+            name = bs_name,
+            rgId = rgid,
+            sshUser = sshuser,
+            sshKey = sshkey,
+        )   
+        api_resp = self.decort_api_call(requests.post, api_url, api_params)
+        self.result['failed'] = False
+        self.result['changed'] = True
+        ret_bservice_id = int(api_resp.content.decode('utf8'))
+        return ret_bservice_id
+    
+    def bservice_state(self,bs_dict,desired_state,started=True):
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "bservice_state")
+        
+        if desired_state == "present":
+            desired_state = "enabled"
+        
+        NOP_STATES_FOR_BS_CHANGE = ["MODELED", "DISABLING", "ENABLING", "DELETING", "DELETED", "DESTROYING",
+                                      "DESTROYED","RESTORYNG","RECONFIGURING"]
+        VALID_TARGET_STATES = ["enabled", "disabled"]
+
+        if bs_dict['status'] in NOP_STATES_FOR_BS_CHANGE:
+            self.result['failed'] = False
+            self.result['msg'] = ("bservice_state(): no state change possible for ViNS ID {} "
+                                  "in its current state '{}'.").format(bs_dict['id'], bs_dict['status'])
+            return
+
+        if desired_state not in VALID_TARGET_STATES:
+            self.result['failed'] = False
+            self.result['warning'] = ("bservice_state(): unrecognized desired state '{}' requested "
+                                      "for B-service ID {}. No B-service state change will be done.").format(desired_state,
+                                                                                                   bs_dict['id'])
+            return
+
+        if self.amodule.check_mode:
+            self.result['failed'] = False
+            self.result['msg'] = ("bservice_state() in check mode: setting state of B-service ID {}, name '{}' to "
+                                  "'{}' was requested.").format(bs_dict['id'], bs_dict['name'],
+                                                                desired_state)
+            return
+
+        bsstate_api = ""  # this string will also be used as a flag to indicate that API call is necessary
+        api_params = dict(serviceId=bs_dict['id'])
+        expected_state = ""
+
+        if bs_dict['status'] in ["CREATED", "ENABLED"] and desired_state == 'disabled':
+            bsstate_api = "/restmachine/cloudapi/bservice/disable"
+            expected_state = "DISABLED"
+        elif bs_dict['status'] in ["CREATED", "DISABLED"] and desired_state == 'enabled':
+            bsstate_api = "/restmachine/cloudapi/bservice/enable"
+            expected_state = "ENABLED"
+
+        if bsstate_api != "":
+            self.decort_api_call(requests.post, bsstate_api, api_params)
+            # On success the above call will return here. On error it will abort execution by calling fail_json.
+            self.result['failed'] = False
+            self.result['changed'] = True
+            bs_dict['status'] = expected_state
+        else:
+            self.result['failed'] = False
+            self.result['msg'] = ("bservice_state(): no state change required for B-service ID {} from current "
+                                  "state '{}' to desired state '{}'.").format(bs_dict['id'],
+                                                                              bs_dict['status'],
+                                                                              desired_state)
+        
+        start_api = ""
+
+        if bs_dict['status'] in ["ENABLED","enabled"]: 
+            if started == True and bs_dict['techStatus'] == "STOPPED":
+                start_api = "/restmachine/cloudapi/bservice/start"
+                t_state_expected = "STARTED"
+            if started == False and bs_dict['techStatus'] == "STARTED":
+                start_api = "/restmachine/cloudapi/bservice/stop"
+                t_state_expected = "STOPPED"
+        
+        if start_api != "":
+            self.decort_api_call(requests.post, start_api, api_params)
+            # On success the above call will return here. On error it will abort execution by calling fail_json.
+            self.result['failed'] = False
+            self.result['changed'] = True
+            bs_dict['techStatus'] = t_state_expected
+        else:
+            self.result['failed'] = False
+            self.result['msg'] = ("bservice_state(): no start/stop action required for B-service ID {} from current "
+                                  "techStatus '{}' to desired started = '{}'.").format(bs_dict['id'],
+                                                                              bs_dict['techStatus'],
+                                                                              started)
+        return
+
+    def bservice_delete(self,bs_id,permanently=True):
+
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "bservice_delete")
+        
+        if self.amodule.check_mode:
+            self.result['failed'] = False
+            self.result['msg'] = "bservice_delete() in check mode: delete B-Service ID {} was requested.".format(bs_id)
+            return
+
+        api_params = dict(serviceId=bs_id,permanently=permanently)
+        self.decort_api_call(requests.post, "/restmachine/cloudapi/bservice/delete", api_params)
+        # On success the above call will return here. On error it will abort execution by calling fail_json.
+        self.result['failed'] = False
+        self.result['msg'] = "bservice_delete() B-Service ID {} was deleted.".format(bs_id)
+        self.result['changed'] = True
+
+        return
+
+#
+# GROUP MANAGE
+#
+    def _group_get_by_id(self,bs_id,g_id):
+        
+        api_params = dict(serviceId=bs_id,compgroupId=g_id)
+        api_resp = self.decort_api_call(requests.post, "/restmachine/cloudapi/bservice/groupGet", api_params)
+        if api_resp.status_code == 200:
+            ret_gr_id = g_id
+            ret_gr_dict = json.loads(api_resp.content.decode('utf8'))
+        else:
+            self.result['warning'] = ("group_get_by_id(): failed to get Group by ID {}. HTTP code {}, "
+                                      "response {}.").format(g_id, api_resp.status_code, api_resp.reason)
+        return ret_gr_id,ret_gr_dict
+    
+    def group_find(self,bs_id,bs_info,group_id=0,group_name=""):
+        
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "group_find")
+        
+        if group_id == 0:
+            try:
+                i = bs_info['groupsName'].index(group_name)
+            except:
+                return 0,None
+            group_id = int(bs_info['groups'][i])
+        return self._group_get_by_id(bs_id,group_id)
+    
+    def group_state(self,bs_id,gr_id,desired_state):
+
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "group_state")
+
+        group_api=""
+        if desired_state == 'stopped':
+            group_api = "/restmachine/cloudapi/bservice/groupStop"
+            state_expected = "STOPPED"
+        else:
+            group_api = "/restmachine/cloudapi/bservice/groupStart"
+            state_expected = "STARTED"
+        api_params = dict(
+            serviceId=bs_id,
+            compgroupId=gr_id
+        )
+        if group_api != "":
+            self.decort_api_call(requests.post, group_api, api_params)
+            # On success the above call will return here. On error it will abort execution by calling fail_json.
+            self.result['failed'] = False
+            self.result['changed'] = True
+        else:
+            self.result['failed'] = False
+            self.result['msg'] = ("group_state(): no start/stop action required for B-service ID {} "
+                                  "to desired state '{}'.").format(bs_id,desired_state)
+        return
+    def group_resize_count(self,bs_id,gr_dict,desired_count):
+
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "group_resize_count")
+
+        count = len(gr_dict['computes'])
+        if desired_count != count:
+            api_params=dict(
+                serviceId=bs_id,
+                compgroupId=gr_dict['id'],
+                count=desired_count,
+                mode="ABSOLUTE"
+            )
+            api_url = "/restmachine/cloudapi/bservice/groupResize"
+            self.decort_api_call(requests.post, api_url, api_params)
+            self.result['failed'] = False
+            self.result['changed'] = True
+            self.need_update_group_info = True
+        else:
+            self.result['failed'] = False
+            self.result['msg'] = ("group_resize_count(): no need resize  Group ID {}.").format(gr_dict['id'])
+        return                  
+    def group_update_hw(self,bs_id,gr_dict,arg_cpu,arg_disk,arg_name,arg_role,arg_ram):
+
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "group_update_hw")
+
+        api_params=dict(
+            serviceId=bs_id,
+            compgroupId=gr_dict['id'],
+            force=True,
+        )
+
+        if gr_dict['cpu'] != arg_cpu:
+            api_params.update({'cpu': arg_cpu})
+        if gr_dict['ram'] != arg_ram:
+            api_params.update({'ram': arg_ram})
+        if gr_dict['role'] != arg_role:
+            api_params.update({'role': arg_role})
+        if gr_dict['disk'] != arg_disk:
+            api_params.update({'disk': arg_disk})
+        if gr_dict['name'] != arg_name:
+            api_params.update({'name': arg_name})
+
+        api_url = "/restmachine/cloudapi/bservice/groupUpdate"
+        if len(api_params) > 3:
+            # 
+            self.decort_api_call(requests.post, api_url, api_params)
+            self.result['failed'] = False
+            self.result['changed'] = True
+            self.need_update_group_info = True
+        else:
+            self.result['failed'] = False
+            self.result['msg'] = ("group_update_hw(): no need update Group ID {}.").format(gr_dict['id'])
+        return
+    
+    def group_update_net(self,bs_id,gr_dict,arg_net):
+
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "group_update_net")
+
+        list_vins= list()
+        list_extnet= list()
+        for net in arg_net:
+            if net['type'] == 'VINS':
+                list_vins.append(net['id'])
+            else:
+                list_extnet.append(net['id'])
+
+        if gr_dict['vinses'] != list_vins:
+            api_url = "/restmachine/cloudapi/bservice/groupUpdateVins"
+            api_params = dict(
+                serviceId=bs_id,
+                compgroupId=gr_dict['id'],
+                vinses=list_vins
+            )
+            self.decort_api_call(requests.post, api_url, api_params)
+            self.result['failed'] = False
+            self.result['changed'] = True
+        
+        #extnet connection need stoped status of group
+        #rly need connect group to extnet ?
+        return
+    def group_provision(
+        self,bs_id,arg_name,arg_count=1,arg_cpu=1,arg_ram=1024,
+        arg_boot_disk=10,arg_image_id=0,arg_driver="KVM_X86",arg_role="",
+        arg_network=None,arg_timeout=0
+        ):
+        
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "group_provision")
+        
+        list_vins= list()
+        for net in arg_network:
+            if net['type'] == 'VINS':
+                list_vins.append(net['id'])
+        api_url = "/restmachine/cloudapi/bservice/groupAdd"
+        api_params = dict(
+            serviceId = bs_id,
+            name = arg_name,
+            count = arg_count,
+            cpu = arg_cpu,
+            ram = arg_ram,
+            disk = arg_boot_disk,
+            imageId = arg_image_id,
+            driver = arg_driver,
+            role = arg_role,
+            vinses = list_vins,
+            timeoutStart = arg_timeout
+        )
+        self.decort_api_call(requests.post, api_url, api_params)
+        self.result['failed'] = False
+        self.result['changed'] = True
+        return
+    
+    def group_delete(self,bs_id,gr_id):
+        
+        self.result['waypoints'] = "{} -> {}".format(self.result['waypoints'], "group_delete")
+        
+        api_url = "/restmachine/cloudapi/bservice/groupRemove"
+        api_params=dict(
+            serviceId = bs_id,
+            compgroupId = gr_id
+        )
+        self.decort_api_call(requests.post, api_url, api_params)
+        self.result['failed'] = False
+        self.result['msg'] = "group_delete() Group ID {} was deleted.".format(gr_id)
+        self.result['changed'] = True
+        return