You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
556 lines
22 KiB
556 lines
22 KiB
#!/usr/bin/python
|
|
|
|
DOCUMENTATION = r'''
|
|
---
|
|
module: decort_osimage
|
|
|
|
description: See L(Module Documentation,https://repository.basistech.ru/BASIS/decort-ansible/wiki/Home).
|
|
'''
|
|
|
|
from ansible.module_utils.basic import AnsibleModule
|
|
from ansible.module_utils.basic import env_fallback
|
|
|
|
from ansible.module_utils.decort_utils import *
|
|
|
|
|
|
class decort_osimage(DecortController):
|
|
def __init__(self):
|
|
super(decort_osimage, self).__init__(AnsibleModule(**self.amodule_init_args))
|
|
amodule = self.amodule
|
|
|
|
self.validated_image_id = 0
|
|
self.validated_virt_image_id = 0
|
|
self.validated_image_name = amodule.params['image_name']
|
|
self.validated_virt_image_name = None
|
|
self.image_info: dict
|
|
self.virt_image_info: dict
|
|
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)
|
|
self.acc_id = self.validated_account_id
|
|
|
|
if (
|
|
self.aparams['virt_id'] != 0
|
|
or self.aparams['virt_name'] is not None
|
|
):
|
|
self.validated_virt_image_id, self.virt_image_info = (
|
|
self.decort_virt_image_find(amodule)
|
|
)
|
|
if self.virt_image_info:
|
|
_, linked_image_info = self._image_get_by_id(
|
|
image_id=self.virt_image_info['linkTo']
|
|
)
|
|
self.acc_id = linked_image_info['accountId']
|
|
if (
|
|
self.aparams['virt_name'] is not None
|
|
and self.aparams['virt_name']
|
|
!= self.virt_image_info['name']
|
|
):
|
|
self.decort_virt_image_rename(amodule)
|
|
self.result['msg'] = 'Virtual image renamed successfully'
|
|
elif (
|
|
self.aparams['image_id'] != 0
|
|
or self.aparams['image_name'] is not None
|
|
):
|
|
self.validated_image_id, self.image_info = (
|
|
self.decort_image_find(amodule)
|
|
)
|
|
if self.image_info:
|
|
self.acc_id = self.image_info['accountId']
|
|
if (
|
|
amodule.params['image_name']
|
|
and amodule.params['image_name'] != self.image_info['name']
|
|
):
|
|
decort_osimage.decort_image_rename(self,amodule)
|
|
self.result['msg'] = ("Image renamed successfully")
|
|
|
|
if self.validated_image_id:
|
|
self.check_amodule_args_for_change()
|
|
elif self.validated_virt_image_id:
|
|
self.check_amodule_args_for_change_virt_image()
|
|
elif self.aparams['virt_name']:
|
|
self.check_amodule_args_for_create_virt_image()
|
|
else:
|
|
self.check_amodule_args_for_create_image()
|
|
|
|
def decort_image_find(self, amodule):
|
|
# function that finds the OS image
|
|
image_id, image_facts = self.image_find(image_id=amodule.params['image_id'], image_name=self.validated_image_name,
|
|
account_id=self.validated_account_id, rg_id=0,
|
|
sepid=amodule.params['sep_id'],
|
|
pool=amodule.params['pool'])
|
|
return image_id, image_facts
|
|
|
|
def decort_virt_image_find(self, amodule):
|
|
# function that finds a virtual image
|
|
image_id, image_facts = self.virt_image_find(image_id=amodule.params['virt_id'],
|
|
account_id=self.validated_account_id, rg_id=0,
|
|
sepid=amodule.params['sep_id'],
|
|
virt_name=amodule.params['virt_name'],
|
|
pool=amodule.params['pool'])
|
|
return image_id, image_facts
|
|
|
|
|
|
|
|
def decort_image_create(self,amodule):
|
|
aparam_boot = self.aparams['boot']
|
|
boot_mode = 'bios'
|
|
loader_type = 'unknown'
|
|
if aparam_boot is not None:
|
|
if aparam_boot['mode'] is None:
|
|
self.message(
|
|
msg=self.MESSAGES.default_value_used(
|
|
param_name='boot.mode',
|
|
default_value=boot_mode
|
|
),
|
|
warning=True,
|
|
)
|
|
else:
|
|
boot_mode = aparam_boot['mode']
|
|
|
|
if aparam_boot['loader_type'] is None:
|
|
self.message(
|
|
msg=self.MESSAGES.default_value_used(
|
|
param_name='boot.loader_type',
|
|
default_value=loader_type
|
|
),
|
|
warning=True,
|
|
)
|
|
else:
|
|
loader_type = aparam_boot['loader_type']
|
|
|
|
network_interface_naming = self.aparams['network_interface_naming']
|
|
if network_interface_naming is None:
|
|
network_interface_naming = 'ens'
|
|
self.message(
|
|
msg=self.MESSAGES.default_value_used(
|
|
param_name='network_interface_naming',
|
|
default_value=network_interface_naming
|
|
),
|
|
warning=True,
|
|
)
|
|
|
|
hot_resize = self.aparams['hot_resize']
|
|
if hot_resize is None:
|
|
hot_resize = False
|
|
self.message(
|
|
msg=self.MESSAGES.default_value_used(
|
|
param_name='hot_resize',
|
|
default_value=hot_resize
|
|
),
|
|
warning=True,
|
|
)
|
|
|
|
# function that creates OS image
|
|
image_facts = self.image_create(
|
|
img_name=self.validated_image_name,
|
|
url=amodule.params['url'],
|
|
boot_mode=boot_mode,
|
|
boot_loader_type=loader_type,
|
|
hot_resize=hot_resize,
|
|
username=amodule.params['image_username'],
|
|
password=amodule.params['image_password'],
|
|
account_id=self.validated_account_id,
|
|
usernameDL=amodule.params['usernameDL'],
|
|
passwordDL=amodule.params['passwordDL'],
|
|
sepId=amodule.params['sepId'],
|
|
poolName=amodule.params['poolName'],
|
|
network_interface_naming=network_interface_naming,
|
|
storage_policy_id=amodule.params['storage_policy_id'],
|
|
)
|
|
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.target_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.target_image_id,
|
|
decort_osimage.decort_osimage_package_facts(image_facts)['id'],)
|
|
return image_id, image_facts
|
|
|
|
def decort_image_delete(self,amodule):
|
|
# function that removes an image
|
|
self.image_delete(imageId=amodule.image_id_delete)
|
|
_, image_facts = decort_osimage._image_get_by_id(self, amodule.image_id_delete)
|
|
self.result['facts'] = decort_osimage.decort_osimage_package_facts(image_facts, amodule.check_mode)
|
|
return
|
|
|
|
def decort_virt_image_create(self,amodule):
|
|
# function that creates a virtual image
|
|
image_facts = self.virt_image_create(
|
|
name=amodule.params['virt_name'],
|
|
target_id=self.target_image_id,
|
|
account_id=self.aparams['account_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_virt_image_rename(self, amodule):
|
|
image_facts = self.image_rename(imageId=self.validated_virt_image_id,
|
|
name=amodule.params['virt_name'])
|
|
self.result['msg'] = ("Virtual image renamed successfully")
|
|
image_id, image_facts = self.decort_virt_image_find(amodule)
|
|
return image_id, image_facts
|
|
|
|
@staticmethod
|
|
def decort_osimage_package_facts(
|
|
arg_osimage_facts: dict | None,
|
|
arg_check_mode=False,
|
|
):
|
|
"""Package a dictionary of OS image according to the decort_osimage module specification. This
|
|
dictionary will be returned to the upstream Ansible engine at the completion of the module run.
|
|
|
|
@param arg_osimage_facts: dictionary with OS image facts as returned by API call to .../images/list
|
|
@param arg_check_mode: boolean that tells if this Ansible module is run in check mode.
|
|
|
|
@return: dictionary with OS image specs populated from arg_osimage_facts.
|
|
"""
|
|
|
|
ret_dict = dict(id=0,
|
|
name="none",
|
|
size=0,
|
|
type="none",
|
|
state="CHECK_MODE", )
|
|
|
|
if arg_check_mode:
|
|
# in check mode return immediately with the default values
|
|
return ret_dict
|
|
|
|
if arg_osimage_facts is None:
|
|
# if void facts provided - change state value to ABSENT and return
|
|
ret_dict['state'] = "ABSENT"
|
|
return ret_dict
|
|
|
|
ret_dict['id'] = arg_osimage_facts['id']
|
|
ret_dict['name'] = arg_osimage_facts['name']
|
|
ret_dict['size'] = arg_osimage_facts['size']
|
|
# ret_dict['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']
|
|
ret_dict['accountId'] = arg_osimage_facts['accountId']
|
|
ret_dict['boot_mode'] = arg_osimage_facts['bootType']
|
|
|
|
ret_dict['boot_loader_type'] = ''
|
|
match arg_osimage_facts['type']:
|
|
case 'cdrom' | 'virtual' as type:
|
|
ret_dict['type'] = type
|
|
case _ as boot_loader_type:
|
|
ret_dict['type'] = 'template'
|
|
ret_dict['boot_loader_type'] = boot_loader_type
|
|
|
|
ret_dict['network_interface_naming'] = arg_osimage_facts[
|
|
'networkInterfaceNaming'
|
|
]
|
|
ret_dict['hot_resize'] = arg_osimage_facts['hotResize']
|
|
ret_dict['storage_policy_id'] = arg_osimage_facts['storage_policy_id']
|
|
ret_dict['to_clean'] = arg_osimage_facts['to_clean']
|
|
return ret_dict
|
|
|
|
@property
|
|
def amodule_init_args(self) -> dict:
|
|
return self.pack_amodule_init_args(
|
|
argument_spec=dict(
|
|
pool=dict(
|
|
type='str',
|
|
default='',
|
|
),
|
|
sep_id=dict(
|
|
type='int',
|
|
default=0,
|
|
),
|
|
account_name=dict(
|
|
type='str',
|
|
),
|
|
account_id=dict(
|
|
type='int',
|
|
),
|
|
image_name=dict(
|
|
type='str',
|
|
),
|
|
image_id=dict(
|
|
type='int',
|
|
default=0,
|
|
),
|
|
virt_id=dict(
|
|
type='int',
|
|
default=0,
|
|
),
|
|
virt_name=dict(
|
|
type='str',
|
|
),
|
|
state=dict(
|
|
type='str',
|
|
default='present',
|
|
choices=[
|
|
'absent',
|
|
'present',
|
|
],
|
|
),
|
|
url=dict(
|
|
type='str',
|
|
),
|
|
sepId=dict(
|
|
type='int',
|
|
default=0,
|
|
),
|
|
poolName=dict(
|
|
type='str',
|
|
),
|
|
hot_resize=dict(
|
|
type='bool',
|
|
),
|
|
image_username=dict(
|
|
type='str',
|
|
),
|
|
image_password=dict(
|
|
type='str',
|
|
),
|
|
usernameDL=dict(
|
|
type='str',
|
|
),
|
|
passwordDL=dict(
|
|
type='str',
|
|
),
|
|
boot=dict(
|
|
type='dict',
|
|
options=dict(
|
|
mode=dict(
|
|
type='str',
|
|
choices=[
|
|
'bios',
|
|
'uefi',
|
|
],
|
|
),
|
|
loader_type=dict(
|
|
type='str',
|
|
choices=[
|
|
'windows',
|
|
'linux',
|
|
'unknown',
|
|
],
|
|
),
|
|
),
|
|
),
|
|
network_interface_naming=dict(
|
|
type='str',
|
|
choices=[
|
|
'ens',
|
|
'eth',
|
|
],
|
|
),
|
|
storage_policy_id=dict(
|
|
type='int',
|
|
),
|
|
),
|
|
supports_check_mode=True,
|
|
)
|
|
|
|
def check_amodule_args_for_change(self):
|
|
check_errors = False
|
|
|
|
aparam_storage_policy_id = self.aparams['storage_policy_id']
|
|
if (
|
|
aparam_storage_policy_id is not None
|
|
and aparam_storage_policy_id
|
|
not in self.acc_info['storage_policy_ids']
|
|
):
|
|
check_errors = True
|
|
self.message(
|
|
msg='Check for parameter "storage_policy_id" failed: '
|
|
f'Account ID {self.acc_id} does not have access to '
|
|
f'storage_policy_id {aparam_storage_policy_id}'
|
|
)
|
|
|
|
if check_errors:
|
|
self.exit(fail=True)
|
|
|
|
def check_amodule_args_for_change_virt_image(self):
|
|
check_errors = False
|
|
|
|
aparam_storage_policy_id = self.aparams['storage_policy_id']
|
|
if (
|
|
aparam_storage_policy_id is not None
|
|
and (
|
|
aparam_storage_policy_id
|
|
!= self.virt_image_info['storage_policy_id']
|
|
)
|
|
):
|
|
check_errors = True
|
|
self.message(
|
|
msg='Check for parameter "storage_policy_id" failed: '
|
|
'storage_policy_id can not be changed in virtual image'
|
|
)
|
|
|
|
if check_errors:
|
|
self.exit(fail=True)
|
|
|
|
def check_amodule_args_for_create_image(self):
|
|
check_errors = False
|
|
|
|
aparam_account_id = self.aparams['account_id']
|
|
if aparam_account_id is None:
|
|
check_errors = True
|
|
self.message(
|
|
msg='Check for parameter "account_id" failed: '
|
|
'account_id must be specified when creating '
|
|
'a new image'
|
|
)
|
|
|
|
aparam_storage_policy_id = self.aparams['storage_policy_id']
|
|
if aparam_storage_policy_id is None:
|
|
check_errors = True
|
|
self.message(
|
|
msg='Check for parameter "storage_policy_id" failed: '
|
|
'storage_policy_id must be specified when creating '
|
|
'a new image'
|
|
)
|
|
elif (
|
|
aparam_storage_policy_id
|
|
not in self.acc_info['storage_policy_ids']
|
|
):
|
|
check_errors = True
|
|
self.message(
|
|
msg='Check for parameter "storage_policy_id" failed: '
|
|
f'Account ID {self.acc_id} does not have access to '
|
|
f'storage_policy_id {aparam_storage_policy_id}'
|
|
)
|
|
|
|
if check_errors:
|
|
self.exit(fail=True)
|
|
|
|
def check_amodule_args_for_create_virt_image(self):
|
|
check_errors = False
|
|
|
|
aparam_storage_policy_id = self.aparams['storage_policy_id']
|
|
if aparam_storage_policy_id is not None:
|
|
check_errors = True
|
|
self.message(
|
|
msg='Check for parameter "storage_policy_id" failed: '
|
|
'storage_policy_id can not be specified when creating '
|
|
'virtual image'
|
|
)
|
|
|
|
if check_errors:
|
|
self.exit(fail=True)
|
|
|
|
|
|
def main():
|
|
decon = decort_osimage()
|
|
amodule = 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 amodule.params['image_name'] or amodule.params['image_id']:
|
|
decon.target_image_id, _ = decort_osimage.decort_image_find(decon, amodule)
|
|
else:
|
|
decon.target_image_id = 0
|
|
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.target_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.target_image_id == 0:
|
|
decon.result['msg'] = ("Cannot find OS image")
|
|
amodule.fail_json(**decon.result)
|
|
|
|
if decon.validated_virt_image_id:
|
|
if (
|
|
decon.target_image_id
|
|
and decort_osimage.decort_osimage_package_facts(image_facts)[
|
|
'linkto'
|
|
] != decon.target_image_id
|
|
):
|
|
decort_osimage.decort_virt_image_link(decon,amodule)
|
|
decon.result['changed'] = True
|
|
amodule.exit_json(**decon.result)
|
|
if (
|
|
amodule.params['storage_policy_id'] is not None
|
|
and amodule.params['storage_policy_id']
|
|
!= image_facts['storage_policy_id']
|
|
):
|
|
decon.image_change_storage_policy(
|
|
image_id=decon.validated_virt_image_id,
|
|
storage_policy_id=amodule.params['storage_policy_id'],
|
|
)
|
|
|
|
if amodule.params['state'] == "absent" and decon.validated_virt_image_id:
|
|
amodule.image_id_delete = decon.validated_virt_image_id
|
|
image_id, image_facts = decort_osimage.decort_virt_image_find(decon, amodule)
|
|
if image_facts['status'] != 'PURGED':
|
|
decort_osimage.decort_image_delete(decon,amodule)
|
|
|
|
elif 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 decon.validated_image_id:
|
|
amodule.image_id_delete = decon.validated_image_id
|
|
image_id, image_facts = decort_osimage.decort_image_find(decon, amodule)
|
|
if image_facts['status'] != 'DESTROYED':
|
|
decort_osimage.decort_image_delete(decon,amodule)
|
|
|
|
if decon.validated_image_id:
|
|
if (
|
|
amodule.params['storage_policy_id'] is not None
|
|
and amodule.params['storage_policy_id']
|
|
!= image_facts['storage_policy_id']
|
|
):
|
|
decon.image_change_storage_policy(
|
|
image_id=decon.validated_image_id,
|
|
storage_policy_id=amodule.params['storage_policy_id'],
|
|
)
|
|
|
|
if decon.result['failed'] == True:
|
|
# we failed to find the specified image - fail the module
|
|
decon.result['changed'] = False
|
|
amodule.fail_json(**decon.result)
|
|
else:
|
|
if decon.validated_image_id:
|
|
_, image_facts = decon.decort_image_find(amodule=amodule)
|
|
elif decon.validated_virt_image_id:
|
|
_, image_facts = decon.decort_virt_image_find(amodule=amodule)
|
|
decon.result['facts'] = decort_osimage.decort_osimage_package_facts(
|
|
arg_osimage_facts=image_facts,
|
|
arg_check_mode=amodule.check_mode,
|
|
)
|
|
|
|
amodule.exit_json(**decon.result)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|