def main(): argument_spec = ecs_argument_spec() argument_spec.update( dict(db_instance_id=dict(type='str', aliases=['instance_id'], required=True), name_prefix=dict(type='str'))) module = AnsibleModule(argument_spec=argument_spec) if HAS_FOOTMARK is False: module.fail_json("Package 'footmark' required for this module.") # Get values of variable db_instance_id = module.params['db_instance_id'] name_prefix = module.params['name_prefix'] result = [] try: rds = rds_connect(module) for account in rds.describe_accounts(db_instance_id=db_instance_id): if name_prefix and not account.name.startswith(name_prefix): continue result.append(account.read()) module.exit_json(changed=False, rds_accounts=result) except Exception as e: module.fail_json( msg="Unable to describe rds accounts, and got an error: {0}.". format(e))
def main(): argument_spec = ecs_argument_spec() argument_spec.update( dict(db_instance_id=dict(type='str', aliases=['instance_id'], required=True), name_prefix=dict(type='str'), db_status=dict(type='str', aliases=['status']))) module = AnsibleModule(argument_spec=argument_spec) rds = rds_connect(module) name_prefix = module.params['name_prefix'] db_status = module.params['db_status'] if HAS_FOOTMARK is False: module.fail_json(msg="Package 'footmark' required for this module.") result = [] try: for db in rds.describe_databases(**module.params): if name_prefix and not db.dbname.startswith(name_prefix): continue if db_status and db.dbstatus.lower() != db_status.lower(): continue result.append(db.read()) module.exit_json(changed=False, databases=result) except Exception as e: module.fail_json( msg="Unable to describe rds database, and got an error: {0}.". format(e))
def main(): argument_spec = ecs_argument_spec() argument_spec.update( dict(db_instance_id=dict(type='str', aliases=['instance_id'], required=True), backup_id=dict(type='str'), backup_status=dict(type='str', choice=['Success', 'Failed']), backup_mode=dict(type='str', choice=['Automated', 'Manual']))) module = AnsibleModule(argument_spec=argument_spec) if HAS_FOOTMARK is False: module.fail_json(msg="Package 'footmark' required for this module.") result = [] backup_status = module.params['backup_status'] backup_mode = module.params['backup_mode'] try: rds = rds_connect(module) for backup in rds.describe_backups(**module.params): if backup_status and backup.status.lower() != backup_status.lower( ): continue if backup_mode and backup.mode.lower() != backup_status.lower(): continue result.append(backup.read()) except Exception as e: module.fail_json( msg="Unable to describe rds backup, and got an error: {0}.".format( e)) module.exit_json(changed=True, backups=result)
def main(): argument_spec = ecs_argument_spec() argument_spec.update(dict( name_prefix=dict(type='str'), db_instance_ids=dict(type='list', elements='str'), tags=dict(type='dict') )) module = AnsibleModule(argument_spec=argument_spec) rds = rds_connect(module) name_prefix = module.params['name_prefix'] db_instance_ids = module.params['db_instance_ids'] if HAS_FOOTMARK is False: module.fail_json(msg="Package 'footmark' required for this module.") result = [] try: for rds_instance in rds.describe_db_instances(**module.params): if name_prefix and not rds_instance.read()['name'].startswith(name_prefix): continue if db_instance_ids and rds_instance.read()['id'] not in db_instance_ids: continue result.append(rds_instance.get().read()) module.exit_json(changed=False, instances=result) except Exception as e: module.fail_json(msg="Unable to describe rds db instance, and got an error: {0}.".format(e))
def main(): argument_spec = ecs_argument_spec() argument_spec.update( dict(instance_ids=dict(type='list', aliases=['db_instance_ids']), engine=dict(type='str'), dbinstance_type=dict(type='str'), instance_network_type=dict(type='str'), connection_mode=dict(type='str'), tags=dict(type='dict'))) module = AnsibleModule(argument_spec=argument_spec) if HAS_FOOTMARK is False: module.fail_json(msg="Package 'footmark' required for this module.") result = [] ids = [] instance_ids = module.params['instance_ids'] engine = module.params['engine'] dbinstance_type = module.params['dbinstance_type'] instance_network_type = module.params['instance_network_type'] connection_mode = module.params['connection_mode'] tags = module.params['tags'] if instance_ids and (not isinstance(instance_ids, list) or len(instance_ids)) < 1: module.fail_json( msg='instance_ids should be a list of db_instance id, aborting') try: rds = rds_connect(module) # list rds db_instance by instance ids if instance_ids: instance_id = ",".join(instance_ids) for rds_instance in rds.get_rds_instances( instance_id=instance_id, engine=engine, dbinstance_type=dbinstance_type, instance_network_type=instance_network_type, connection_mode=connection_mode, tags=tags): result.append(get_info(rds_instance)) ids.append(rds_instance.dbinstance_id) # list all db_instance available in specified region else: for rds_instance in rds.get_rds_instances(): result.append(get_info(rds_instance)) ids.append(rds_instance.dbinstance_id) except Exception as e: module.fail_json( msg="Unable to describe rds db instance, and got an error: {0}.". format(e)) module.exit_json(changed=False, db_instance_ids=ids, rds_db_instances=result, total=len(result))
def main(): argument_spec = ecs_argument_spec() argument_spec.update( dict(db_instance_id=dict(type='str', required=True), account_names=dict(type='list', aliases=['names']))) module = AnsibleModule(argument_spec=argument_spec) if HAS_FOOTMARK is False: module.fail_json("Package 'footmark' required for this module.") # Get values of variable db_instance_id = module.params['db_instance_id'] names = module.params['account_names'] result = [] try: rds = rds_connect(module) if names and (not isinstance(names, list) or len(names)) < 1: module.fail_json( msg='account_name should be a list of account name, aborting') # fetch rds accounts by name if names: for name in names: rds_accounts = rds.list_account(db_instance_id=db_instance_id, account_name=name) if rds_accounts and len(rds_accounts) == 1: result.append(get_info(rds_accounts[0])) # fetch all rds accounts else: names = [] for account in rds.list_account(db_instance_id=db_instance_id): names.append(account.account_name) result.append(get_info(account)) module.exit_json(changed=False, account_names=names, rds_accounts=result, total=len(result)) except Exception as e: module.fail_json( msg="Unable to describe rds accounts, and got an error: {0}.". format(e))
def main(): argument_spec = ecs_argument_spec() argument_spec.update( dict(state=dict(default='present', choices=['present', 'absent']), db_instance_id=dict(type='str', aliases=['instance_id'], required=True), db_name=dict(type='list', elements='str'), backup_id=dict(type='list', elements='str'), backup_method=dict(type='str', default='Physical'), backup_strategy=dict(type='str'), backup_type=dict(type='str', default='Auto'))) module = AnsibleModule(argument_spec=argument_spec) rds = rds_connect(module) if HAS_FOOTMARK is False: module.fail_json(msg="Footmark required for this module") # Get values of variable state = module.params['state'] backup_id = module.params['backup_id'] db_name = module.params['db_name'] if backup_id: module.params['backup_id'] = ','.join(backup_id) if db_name: module.params['db_name'] = ','.join(db_name) if state == 'absent': try: changed = rds.delete_backup(**module.params) module.exit_json(changed=changed, backup={}) except Exception as e: module.fail_json( msg=str("Unable to delete backup error:{0}".format(e))) if state == 'present': try: create_backup = rds.create_backup(**module.params) module.exit_json(changed=True, backup=create_backup.read()) except Exception as e: module.fail_json( msg=str("Unable to create backup error:{0}".format(e)))
def main(): argument_spec = ecs_argument_spec() argument_spec.update(dict( state=dict(default='present', choices=['present', 'absent']), db_name=dict(type='str'), db_instance_id=dict(type='str', required=True), account_name=dict(type='str', aliases=['name'], required=True), account_password=dict(type='str', aliases=['password']), account_privilege=dict(aliases=['privilege'], choices=['ReadOnly', 'ReadWrite']), description=dict(type='str'), account_type=dict(default='Normal', type='str', choices=['Normal', 'Super']), )) module = AnsibleModule(argument_spec=argument_spec) rds = rds_connect(module) if HAS_FOOTMARK is False: module.fail_json("Footmark required for this module") # Get values of variable state = module.params['state'] db_instance_id = module.params['db_instance_id'] account_name = module.params['account_name'] account_password = module.params['account_password'] account_privilege = module.params['account_privilege'] description = module.params['description'] account_type = module.params['account_type'] db_name = module.params['db_name'] account_list = [] current_account = None changed = False try: current_account_list = rds.list_account(db_instance_id, account_name) if len(current_account_list) == 1: current_account = current_account_list[0] except Exception as e: module.fail_json(msg=str("Unable to describe accounts, error:{0}".format(e))) if state == "absent": if current_account: if db_name: try: changed = current_account.revoke_privilege(db_instance_id, db_name) current_account = rds.list_account(db_instance_id, account_name)[0] module.exit_json(changed=True, account_name=account_name, account=get_info(current_account)) except Exception as e: module.fail_json(msg=str("Unable to revoke privilege error:{0}".format(e))) try: changed = current_account.delete(db_instance_id) module.exit_json(changed=True, account_name=account_name, account=get_info(current_account)) except Exception as e: module.fail_json(msg=str("Unable to delete account error:{0}".format(e))) module.fail_json(msg="There is no account to revoke database privilege or delete. Please specify an account using 'account_name', and try again.") if account_password and current_account: try: changed = current_account.reset(db_instance_id, account_password) except Exception as e: module.fail_json(msg=str("Unable to reset account password error:{0}".format(e))) if not current_account: try: current_account = rds.create_account(db_instance_id, account_name, account_password, description, account_type) except Exception as e: module.fail_json(msg=str("Unable to create account error:{0}".format(e))) if description and description != current_account.account_description: try: changed = current_account.modify_description(db_instance_id, description) current_account.account_description = description except Exception as e: module.fail_json(msg=str("Unable to modify account description error:{0}".format(e))) if db_name: if account_privilege: try: changed = current_account.grant_privilege(db_instance_id, db_name, account_privilege) current_account = current_account_list[0] except Exception as e: module.fail_json(msg=str("Unable to grant privilege error:{0}".format(e))) else: module.fail_json(msg="grant privilege failed. Please check your account_privilege and try again.") module.exit_json(changed=changed, account_name=account_name, account=get_info(current_account))
def main(): argument_spec = ecs_argument_spec() argument_spec.update(dict( state=dict(default="present", choices=["present", "absent", "restart"]), zone_id=dict(type='str', aliases=['alicloud_zone']), engine=dict(type='str', choices=['MySQL', 'SQLServer', 'PostgreSQL', 'PPAS', 'MariaDB']), engine_version=dict(type='str'), db_instance_net_type=dict(type='str', choices=["Internet", "Intranet"], aliases=['instance_net_type']), db_instance_name=dict(type='str', aliases=['description', 'name']), db_instance_id=dict(type='str', aliases=['id']), security_ip_list=dict(type='str', aliases=['security_ips']), pay_type=dict(type='str', choices=["PostPaid", "PrePaid"]), period=dict(type='int', choices=[1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 24, 36], default=1), connection_mode=dict(type='str', choices=["Standard", "Safe"]), vswitch_id=dict(type='str'), private_ip_address=dict(type='str'), tags=dict(type='dict'), purge_tags=dict(type='bool', default=False), auto_pay=dict(type='bool', aliases=['auto_renew']), connection_string_prefix=dict(type='str'), port=dict(type='str'), current_connection_string=dict(type='str'), db_instance_class=dict(type='str', aliases=['instance_class']), db_instance_storage=dict(type='int', aliases=['instance_storage']) )) modules = AnsibleModule(argument_spec=argument_spec) if HAS_FOOTMARK is False: modules.fail_json(msg="Package 'footmark' required for the module ali_rds_instance.") rds = rds_connect(modules) vpc = vpc_connect(modules) state = modules.params['state'] vswitch_id = modules.params['vswitch_id'] connection_string_prefix = modules.params['connection_string_prefix'] port = modules.params['port'] tags = modules.params['tags'] current_connection_string = modules.params['current_connection_string'] db_instance_description = modules.params['db_instance_name'] modules.params['db_instance_description'] = db_instance_description db_instance_class = modules.params['db_instance_class'] db_instance_storage = modules.params['db_instance_storage'] db_instance_id = modules.params['db_instance_id'] pay_type = modules.params['pay_type'] used_time = modules.params['period'] modules.params['period'] = 'Month' modules.params['used_time'] = str(used_time) if used_time > 9: modules.params['period'] = 'Year' if used_time == 12: modules.params['used_time'] = '1' elif used_time == 24: modules.params['used_time'] = '2' else: modules.params['used_time'] = '3' if pay_type: modules.params['pay_type'] = pay_type.capitalize() current_instance = None changed = False if vswitch_id: modules.params['instance_network_type'] = 'VPC' try: vswitch_obj = vpc.describe_vswitch_attributes(vswitch_id=vswitch_id) if vswitch_obj: modules.params['vpc_id'] = vswitch_obj.vpc_id except Exception as e: modules.fail_json(msg=str("Unable to get vswitch, error:{0}".format(e))) try: current_instance = get_instance(db_instance_id, db_instance_description, modules, rds) except Exception as e: modules.fail_json(msg=str("Unable to describe instance, error:{0}".format(e))) if state == 'absent': if current_instance: if current_connection_string: try: changed = rds.release_instance_public_connection(current_connection_string=current_connection_string, db_instance_id=current_instance.id) modules.exit_json(changed=changed, instances=current_instance.get().read()) except Exception as e: modules.fail_json(msg=str("Unable to release public connection string error: {0}".format(e))) try: current_instance.delete() modules.exit_json(changed=True, instances={}) except Exception as e: modules.fail_json(msg=str("Unable to release instance error: {0}".format(e))) modules.fail_json(msg=str("Unable to operate your instance, please check your instance_id and try again!")) if state == 'restart': if current_instance: try: changed = current_instance.restart() modules.exit_json(changed=changed, instances=current_instance.get().read()) except Exception as e: modules.fail_json(msg=str("Unable to restart instance error: {0}".format(e))) modules.fail_json(msg=str("Unable to restart your instance, please check your instance_id and try again!")) if not current_instance: try: modules.params['client_token'] = "Ansible-Alicloud-%s-%s" % (hash(str(modules.params)), str(time.time())) current_instance = rds.create_db_instance(**modules.params) modules.exit_json(changed=True, instances=current_instance.get().read()) except Exception as e: modules.fail_json(msg=str("Unable to create rds instance error: {0}".format(e))) if connection_string_prefix and port: if current_connection_string: try: changed = current_instance.modify_db_instance_connection_string(current_connection_string=current_connection_string, connection_string_prefix=connection_string_prefix, port=port) modules.exit_json(changed=changed, instances=current_instance.get().read()) except Exception as e: modules.fail_json(msg=str("Unable to modify current string error: {0}".format(e))) else: try: changed = current_instance.allocate_public_connection_string(connection_string_prefix=connection_string_prefix, port=port) modules.exit_json(changed=changed, instances=current_instance.get().read()) except Exception as e: modules.fail_json(msg=str("Unable to allocate public connection error: {0}".format(e))) if db_instance_class or db_instance_storage: try: changed = current_instance.modify_instance_spec(db_instance_class=db_instance_class, db_instance_storage=db_instance_storage) except Exception as e: modules.fail_json(msg=str("Unable to modify instance spec: {0}".format(e))) if modules.params['purge_tags']: if not tags: tags = current_instance.tags try: if current_instance.remove_tags(tags): changed = True modules.exit_json(changed=changed, instances=current_instance.get().read()) except Exception as e: modules.fail_json(msg="{0}".format(e)) if tags: try: if current_instance.add_tags(tags): changed = True except Exception as e: modules.fail_json(msg="{0}".format(e)) modules.exit_json(changed=changed, instances=current_instance.get().read())
def main(): argument_spec = ecs_argument_spec() argument_spec.update( dict(state=dict(default="present", choices=["present", "absent", "restart"], alias=['status']), alicloud_zone=dict(type='str', aliases=['zone_id', 'zone']), engine=dict(type='str', choices=["MySQL", "SQLServer", "PostgreSQL", "PPAS"]), engine_version=dict(type='str'), instance_net_type=dict(type='str', choices=["Internet", "Intranet"], aliases=['db_instance_net_type']), description=dict(type='str', aliases=['db_instance_description']), security_ips=dict(type='str'), instance_charge_type=dict(type='str', choices=["Postpaid", "Prepaid"]), period=dict(type='int', choices=range(1, 10).extend([12, 24, 36])), connection_mode=dict(type='str', choices=["Performance", "Safty"]), vpc_id=dict(type='str'), vswitch_id=dict(type='str'), private_ip_address=dict(type='str'), instance_id=dict(type='str', aliases=['db_instance_id']), tags=dict(type='str', aliases=['instance_tags']), page_size=dict(type='int', default=30, choices=[30, 50, 100]), page_number=dict(type='int', default=1), auto_renew_period=dict(type='int', choices=[1, 2, 3, 6, 12]), auto_renew=dict(type='bool'), public_connection_string_prefix=dict(type='str'), private_connection_string_prefix=dict(type='str'), dest_connection_string_prefix=dict(type='str'), dest_port=dict(type='str'), public_port=dict(type='str'), private_port=dict(type='int', choices=range(3001, 4000)), current_connection_string=dict(type='str'), instance_type=dict(type='str', aliases=['db_instance_class']), instance_storage=dict(type='int', aliases=['db_instance_storage']))) modules = AnsibleModule(argument_spec=argument_spec) if HAS_FOOTMARK is False: modules.fail_json( msg= "Package 'footmark' required for the module alicloud_rds_instance." ) rds = rds_connect(modules) vpc = vpc_connect(modules) state = modules.params['state'] alicloud_zone = modules.params['alicloud_zone'] engine = modules.params['engine'] engine_version = modules.params['engine_version'] instance_net_type = modules.params['instance_net_type'] description = modules.params['description'] security_ips = modules.params['security_ips'] instance_charge_type = modules.params['instance_charge_type'] period = modules.params['period'] connection_mode = modules.params['connection_mode'] vswitch_id = modules.params['vswitch_id'] private_ip_address = modules.params['private_ip_address'] instance_id = modules.params['instance_id'] tags = modules.params['tags'] page_size = modules.params['page_size'] page_number = modules.params['page_number'] auto_renew_period = modules.params['auto_renew_period'] auto_renew = modules.params['auto_renew'] public_connection_string_prefix = modules.params[ 'public_connection_string_prefix'] private_connection_string_prefix = modules.params[ 'private_connection_string_prefix'] public_port = modules.params['public_port'] private_port = modules.params['private_port'] current_connection_string = modules.params['current_connection_string'] dest_connection_string_prefix = modules.params[ 'dest_connection_string_prefix'] dest_port = modules.params['dest_port'] instance_type = modules.params['instance_type'] instance_storage = modules.params['instance_storage'] vpc_id = None instance_network_type = 'Classic' current_instance = None changed = False if vswitch_id: instance_network_type = 'VPC' try: vswitch_obj = vpc.get_vswitch_attribute(vswitch_id) if vswitch_obj: vpc_id = vswitch_obj.vpc_id except Exception as e: modules.fail_json( msg=str("Unable to get vswitch, error:{0}".format(e))) if instance_id: try: current_instance = rds.describe_db_instance_attribute(instance_id) except Exception as e: modules.fail_json( msg=str("Unable to describe instance, error:{0}".format(e))) if state == 'absent': if current_instance: if current_connection_string: try: changed = current_instance.release_public_connection_string( current_connection_string) modules.exit_json(changed=changed, instance=get_info(current_instance)) except Exception as e: modules.fail_json(msg=str( "Unable to release public connection string error: {0}" .format(e))) try: changed = current_instance.terminate() modules.exit_json(changed=changed, instance=get_info(current_instance)) except Exception as e: modules.fail_json( msg=str("Unable to release instance error: {0}".format(e))) modules.fail_json(msg=str( "Unable to operate your instance, please check your instance_id and try again!" )) if state == 'restart': if current_instance: try: changed = current_instance.restart() modules.exit_json(changed=changed, instance=get_info(current_instance)) except Exception as e: modules.fail_json( msg=str("Unable to restart instance error: {0}".format(e))) modules.fail_json(msg=str( "Unable to restart your instance, please check your instance_id and try again!" )) if not current_instance: try: client_token = "Ansible-Alicloud-%s-%s" % (hash(str( module.params)), str(time.time())) current_instance = rds.create_rds_instance( engine=engine, engine_version=engine_version, db_instance_class=instance_type, db_instance_storage=instance_storage, db_instance_net_type=instance_net_type, security_ip_list=security_ips, pay_type=instance_charge_type, client_token=client_token, instance_network_type=instance_network_type, period='Month', used_time=period, alicloud_zone=alicloud_zone, db_instance_description=description, connection_mode=connection_mode, vpc_id=vpc_id, vswitch_id=vswitch_id, private_ip_address=private_ip_address) instance_id = current_instance.dbinstance_id except Exception as e: modules.fail_json( msg=str("Unable to create rds instance error: {0}".format(e))) if auto_renew: try: changed = current_instance.modify_auto_renewal_attribute( duration=auto_renew_period, auto_renew=auto_renew) except Exception as e: modules.fail_json(msg=str( "Unable to modify rds instance auto renewal attribute error: {0}" .format(e))) if public_connection_string_prefix and public_port: try: changed = current_instance.allocate_public_connection_string( public_connection_string_prefix, public_port) except Exception as e: modules.fail_json(msg=str( "Unable to allocate public connection error: {0}".format(e))) if private_connection_string_prefix: try: changed = current_instance.allocate_private_connection_string( private_connection_string_prefix, private_port) except Exception as e: modules.fail_json(msg=str( "Unable to allocate private connection string error: {0}". format(e))) if current_connection_string: try: changed = current_instance.modify_connection_string( current_connection_string, dest_connection_string_prefix, dest_port) except Exception as e: modules.fail_json( msg=str("Unable to modify current connection string error: {0}" .format(e))) # get newest instance try: current_instance = rds.describe_db_instance_attribute(instance_id) except Exception as e: modules.fail_json( msg=str("Unable to describe instance error: {0}".format(e))) modules.exit_json(changed=changed, instance=get_info(current_instance))
def main(): argument_spec = ecs_argument_spec() argument_spec.update( dict(state=dict(default="present", choices=["present", "absent"]), db_instance_id=dict(type='str', aliases=['instance_id'], required=True), db_name=dict(type='str', aliases=['name'], required=True), character_set_name=dict(type='str', aliases=['character']), db_description=dict(type='str', aliases=['description']), target_db_instance_id=dict(type='str', aliases=['target_instance_id']), target_db_name=dict(type='str'), backup_id=dict(type='str'), restore_time=dict(type='str'), sync_user_privilege=dict(type='bool', default=False))) modules = AnsibleModule(argument_spec=argument_spec) if HAS_FOOTMARK is False: modules.fail_json(msg="Package 'footmark' required for this module") rds = rds_connect(modules) state = modules.params['state'] db_description = modules.params['db_description'] target_db_instance_id = modules.params['target_db_instance_id'] target_db_name = modules.params['target_db_name'] db_name = modules.params['db_name'] sync_user_privilege = modules.params['sync_user_privilege'] modules.params['sync_user_privilege'] = 'NO' if sync_user_privilege: modules.params['sync_user_privilege'] = 'YES' db = '' try: db = database_exists(modules, rds) except Exception as e: modules.fail_json( msg=str("Unable to describe database, error:{0}".format(e))) if state == 'absent': if not db: modules.exit_json(changed=False, database={}) try: db.delete() modules.exit_json(changed=True, database={}) except Exception as e: modules.fail_json( msg=str("Unable to delete database error: {0}".format(e))) if not db: try: modules.params['client_token'] = "Ansible-Alicloud-%s-%s" % (hash( str(modules.params)), str(time.time())) db = rds.create_database(**modules.params) modules.exit_json(changed=True, database=db.read()) except Exception as e: modules.fail_json( msg=str("Unable to create database error: {0}".format(e))) if db_description: try: res = db.modify_db_description(description=db_description) modules.exit_json(changed=res, database=db.read()) except Exception as e: modules.fail_json(msg=str( "Unable to modify db description error: {0}".format(e))) if target_db_instance_id and target_db_name: try: modules.params['db_names'] = str({db_name: target_db_name}) res = db.copy_database_between_instances(**modules.params) modules.exit_json(changed=res, database=db.read()) except Exception as e: modules.fail_json( msg=str("Unable to copy db instance id error: {0}".format(e)))