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.
331 lines
13 KiB
331 lines
13 KiB
#!/usr/bin/python
|
|
|
|
DOCUMENTATION = r'''
|
|
---
|
|
module: decort_bservice
|
|
|
|
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_bservice(DecortController):
|
|
def __init__(self):
|
|
super(decort_bservice, self).__init__(AnsibleModule(**self.amodule_init_args))
|
|
arg_amodule = self.amodule
|
|
|
|
validated_acc_id = 0
|
|
validated_rg_id = 0
|
|
self.bservice_info = None
|
|
self.is_bservice_stopped_or_will_be_stopped: None | bool = 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.acc_info = 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(
|
|
arg_account_id=validated_acc_id,
|
|
arg_rg_id=arg_amodule.params['rg_id'],
|
|
arg_rg_name=arg_amodule.params['rg_name']
|
|
)
|
|
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']
|
|
validated_acc_id = validated_rg_facts['accountId']
|
|
|
|
self.bservice_id, self.bservice_info = self.bservice_find(
|
|
validated_acc_id,
|
|
validated_rg_id,
|
|
arg_amodule.params['name'],
|
|
arg_amodule.params['id']
|
|
)
|
|
|
|
self.acc_id = validated_acc_id or self.bservice_info['accountId']
|
|
|
|
if self.bservice_id and self.bservice_info['status'] != 'DESTROYED':
|
|
self.bservice_should_exist = True
|
|
self.check_amodule_args_for_change()
|
|
else:
|
|
self.bservice_should_exist = False
|
|
self.check_amodule_args_for_create()
|
|
|
|
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.bservice_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'],
|
|
zone_id=self.aparams['zone_id'],
|
|
)
|
|
if self.bservice_id:
|
|
_, self.bservice_info = self.bservice_get_by_id(self.bservice_id)
|
|
self.bservice_state(self.bservice_info,'enabled')
|
|
return
|
|
|
|
def action(self,d_state):
|
|
self.bservice_state(self.bservice_info,d_state)
|
|
|
|
aparam_zone_id = self.aparams['zone_id']
|
|
if aparam_zone_id is not None and aparam_zone_id != self.bservice_info['zoneId']:
|
|
self.bservice_migrate_to_zone(
|
|
bs_id=self.bservice_id,
|
|
zone_id=aparam_zone_id,
|
|
)
|
|
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.bservice_info['accountId']
|
|
ret_dict['groups'] = self.bservice_info['groups']
|
|
ret_dict['zone_id'] = self.bservice_info['zoneId']
|
|
return ret_dict
|
|
|
|
@property
|
|
def amodule_init_args(self) -> dict:
|
|
return self.pack_amodule_init_args(
|
|
argument_spec=dict(
|
|
account_id=dict(
|
|
type='int',
|
|
),
|
|
account_name=dict(
|
|
type='str',
|
|
default='',
|
|
),
|
|
state=dict(
|
|
type='str',
|
|
default='present',
|
|
choices=[
|
|
'absent',
|
|
'disabled',
|
|
'enabled',
|
|
'present',
|
|
'started',
|
|
'stopped',
|
|
],
|
|
),
|
|
name=dict(
|
|
type='str',
|
|
default='',
|
|
),
|
|
sshuser=dict(
|
|
type='str',
|
|
),
|
|
sshkey=dict(
|
|
type='str',
|
|
),
|
|
id=dict(
|
|
type='int',
|
|
default=0,
|
|
),
|
|
rg_id=dict(
|
|
type='int',
|
|
default=0,
|
|
),
|
|
rg_name=dict(
|
|
type='str',
|
|
default='',
|
|
),
|
|
zone_id=dict(
|
|
type='int',
|
|
),
|
|
),
|
|
supports_check_mode=True,
|
|
required_one_of=[
|
|
('id', 'name'),
|
|
('rg_id', 'rg_name'),
|
|
],
|
|
)
|
|
|
|
def check_amodule_args_for_change(self):
|
|
check_errors = False
|
|
|
|
self.is_bservice_stopped_or_will_be_stopped = (
|
|
(
|
|
self.bservice_info['techStatus'] == 'STOPPED'
|
|
and (
|
|
self.aparams['state'] is None
|
|
or self.aparams['state'] in ('present', 'stopped')
|
|
)
|
|
)
|
|
or (
|
|
self.bservice_info['techStatus'] != 'STOPPED'
|
|
and self.aparams['state'] == 'stopped'
|
|
)
|
|
)
|
|
|
|
if self.check_aparam_zone_id() is False:
|
|
check_errors = True
|
|
if (
|
|
self.aparams['zone_id'] is not None
|
|
and self.aparams['zone_id'] != self.bservice_info['zoneId']
|
|
and not self.is_bservice_stopped_or_will_be_stopped
|
|
):
|
|
check_errors = True
|
|
self.message(
|
|
'Check for parameter "zone_id" failed: '
|
|
'Basic Service must be stopped to migrate to a zone.'
|
|
)
|
|
|
|
if check_errors:
|
|
self.exit(fail=True)
|
|
|
|
def check_amodule_args_for_create(self):
|
|
check_errors = False
|
|
if self.check_aparam_zone_id() is False:
|
|
check_errors = True
|
|
|
|
if check_errors:
|
|
self.exit(fail=True)
|
|
|
|
|
|
def main():
|
|
subj = decort_bservice()
|
|
amodule = subj.amodule
|
|
|
|
if subj.amodule.check_mode:
|
|
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', 'started', 'stopped'
|
|
):
|
|
subj.restore(subj.bservice_id)
|
|
subj.action(amodule.params['state'])
|
|
if amodule.params['state'] == 'absent':
|
|
subj.nop()
|
|
elif subj.bservice_info['status'] in ('ENABLED', 'DISABLED'):
|
|
if amodule.params['state'] == 'absent':
|
|
subj.destroy()
|
|
else:
|
|
subj.action(amodule.params['state'])
|
|
elif subj.bservice_info['status'] == "DESTROED":
|
|
if amodule.params['state'] in ('present','enabled'):
|
|
subj.create()
|
|
subj.action(amodule.params['state'])
|
|
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.bservice_info = subj.bservice_get_by_id(subj.bservice_id)
|
|
subj.result['facts'] = subj.package_facts(amodule.check_mode)
|
|
amodule.exit_json(**subj.result)
|
|
else:
|
|
amodule.exit_json(**subj.result)
|
|
if __name__ == "__main__":
|
|
main()
|