def main(): module = AnsibleModule( argument_spec=dict( cmd=dict(type='str', required=True), char_vars=dict(type='list', elements='str'), number_vars=dict(type='list', elements='str'), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) command = module.params['cmd'].strip().upper() char_vars = module.params['char_vars'] args_dict = dict() if char_vars: char_vars = [item.strip().upper() for item in char_vars] for item in char_vars: args_dict.update({item: 'chars'}) number_vars = module.params['number_vars'] if number_vars: number_vars = [item.strip().upper() for item in number_vars] for item in number_vars: args_dict.update({item: 'number'}) joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] out = dict() if (not char_vars) and (not number_vars): module.fail_json(msg='At least one of the option char_vars or number_vars must contain value') try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) job_log = [] rc, out, err, job_log = ibmi_module.itoolkit_run_rtv_command_once(command, args_dict) result = dict( rc=rc, output=out, args_dict=args_dict, job_log=job_log ) if rc: message = 'non-zero return code:{rc}, error: {err}'.format(rc=rc, err=err) module.fail_json(msg=message, **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(msg='Success', **result)
def main(): module = AnsibleModule( argument_spec=dict(groups=dict(type='list', elements='str', default=['*ALL']), validate_certs=dict(type='bool', default=True)), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) result = dict(rc=0, count=0, group_info=[], stderr='') groups_num = module.params['groups'] validate_certs = module.params['validate_certs'] # psp_groups = get_psp_group_info(validate_certs) startd = datetime.datetime.now() psp_groups = get_group_info_from_web(groups_num, validate_certs) result.update({'group_info': psp_groups}) result.update({'count': len(psp_groups)}) endd = datetime.datetime.now() delta = endd - startd result.update({'start': str(startd)}) result.update({'end': str(endd)}) result.update({'elapsed_time': str(delta)}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( subsystem=dict(type='str', required=True), library=dict(type='str', default='*LIBL'), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) subsystem = module.params['subsystem'].strip().upper() library = module.params['library'].strip().upper() joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] if len(subsystem) > 10: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of subsystem exceeds 10 characters") if len(library) > 10: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of library exceeds 10 characters") command = 'QSYS/STRSBS SBSD({library}/{subsystem})'.format( library=library, subsystem=subsystem) try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) result = dict( command=command, stdout=out, stderr=err, rc=rc, job_log=job_log, changed=True, ) if rc != 0: message = 'non-zero return code:{rc}'.format(rc=rc) module.fail_json(msg=message, **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( sysvalue=dict(type='list', elements='dict', required=True), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) sysvalue = module.params['sysvalue'] joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] if len(sysvalue) == 0: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Not found input system value name") result = dict(sysval=[], rc=0, message='') rc = 0 try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: module.fail_json(rc=999, msg='Exception occurred: {0}'.format(str(inst))) for value in sysvalue: rc, sysval, message = get_system_value(ibmi_module, value.get('name'), value.get('expect'), value.get('check')) result['sysval'].append(sysval) if rc: result.update({'rc': rc}) result.update({'stderr': message}) message = 'non-zero return code when get system value:{rc}'.format( rc=rc) module.fail_json(msg=message, **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) else: result.update({'job_log': message}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( sql=dict(type='str', required=True), database=dict(type='str', default='*SYSBAS'), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) sql = module.params['sql'].strip().upper() database = module.params['database'].strip().upper() joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] startd = datetime.datetime.now() try: ibmi_module = imodule.IBMiModule( db_name=database, become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) rc, out, err, job_log = ibmi_module.itoolkit_sql_callproc_once(sql) endd = datetime.datetime.now() delta = endd - startd result = dict( sql=sql, stdout=out, stderr=err, rc=rc, start=str(startd), end=str(endd), delta=str(delta), job_log=job_log, ) if rc: message = 'non-zero return code:{rc}'.format(rc=rc) module.fail_json(msg=message, **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] startd = datetime.datetime.now() try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) disk_list, job_log = getNonconfigureDisk(ibmi_module, startd) if not disk_list: rc_msg = "Here is no un-configure disk." rc = 0 else: rc_msg = "Success to get all un-configure disks." rc = 0 endd = datetime.datetime.now() delta = endd - startd result = dict( disks=disk_list, rc=rc, out=rc_msg, start=str(startd), job_log=job_log, end=str(endd), delta=str(delta), ) if rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS: module.fail_json(msg='non-zero return code', **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(**result)
def qwtsetp(self): itransport = DatabaseTransport(self.conn) itool = iToolKit() itool.add( iPgm('qwtsetp', 'QWTSETP') .addParm(iData('handle', '12A', self.handle, {'hex': 'on'})) .addParm( iDS('ERRC0100_t', {'len': 'errlen'}) .addData(iData('errRet', '10i0', '')) .addData(iData('errAvl', '10i0', '')) .addData(iData('errExp', '7A', '', {'setlen': 'errlen'})) .addData(iData('errRsv', '1A', '')) ) ) itool.call(itransport) qwtsetp = itool.dict_out('qwtsetp') ibmi_util.log_info(str(qwtsetp), 'qwtsetp') if 'success' in qwtsetp: return True else: return False
def main(): module = AnsibleModule( argument_spec=dict( operation=dict(type='str', choices=['display'], default='display'), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] rc = SUCCESS ethernet_ports = [] result = '' try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) rc, ethernet_ports, result = list_ethernet_ports_info(ibmi_module) ibmi_util.log_debug( "list_ethernet_ports_info result is: {0}".format(result), module._name) ibmi_util.log_debug( "list_ethernet_ports_info resources information are: {0}".format( ethernet_ports), module._name) if rc: module.fail_json( rc=rc, msg="Error when getting ethernet ports information: {0}".format( result)) module.exit_json(rc=SUCCESS, msg="Success to get ethernet ports information", ethernet_ports=ethernet_ports)
def __init__(self, db_name=ibmi_util.SYSBAS, become_user_name=None, become_user_password=None): self.ibmi_logon = None self.conn = None self.startd = datetime.datetime.now() if not HAS_ITOOLKIT: raise ImportError("itoolkit package is required.") if not HAS_IBM_DB: raise ImportError("ibm_db package is required.") re_raise = False # workaround to pass the raise-missing-from pylint issue exp_msg = '' try: if db_name != ibmi_util.SYSBAS: self.conn = dbi.connect(database='{db_pattern}'.format(db_pattern=db_name)) else: self.conn = dbi.connect() job_name_info = self.get_current_job_name() ibmi_util.log_info("Job of the connection to execute the task: {0}".format( job_name_info), "Connection Initialization") except Exception as inst: self.close_db_connection() re_raise = True exp_msg = "Fail to connect to database {0}: {1}.".format( db_name, str(inst)) if db_name != ibmi_util.SYSBAS: exp_msg = exp_msg + " Check if IASP {0} is exist and varied on.".format(db_name) else: exp_msg = exp_msg + " Check if *LOCAL Relational Database Directory Entry(RDBDIRE) is exist." if re_raise: raise Exception(exp_msg) if become_user_name and self.conn: self.ibmi_logon = IBMiLogon( self.conn, become_user_name, "*NOPWD" if (become_user_password is None) else become_user_password) become_result = self.ibmi_logon.switch() if not become_result: exp_msg = "Failed to become user {0} to excute the task. Invaild user or password or user is disabled".format(become_user_name) raise Exception(exp_msg)
def release_profile_handle(self): if not self.handle: return True itransport = DatabaseTransport(self.conn) itool = iToolKit() itool.add( iPgm('qsyrlsph', 'QSYRLSPH') .addParm(iData('handle', '12A', self.handle, {'hex': 'on'})) .addParm( iDS('ERRC0100_t', {'len': 'errlen'}) .addData(iData('errRet', '10i0', '')) .addData(iData('errAvl', '10i0', '')) .addData(iData('errExp', '7A', '', {'setlen': 'errlen'})) .addData(iData('errRsv', '1A', '')) ) ) itool.call(itransport) qsyrlsph = itool.dict_out('qsyrlsph') ibmi_util.log_info(str(qsyrlsph), 'qsyrlsph') if 'success' in qsyrlsph: return True else: return False
def main(): module = AnsibleModule( argument_spec=dict( operation=dict(type='str', choices=[ 'add', 'remove'], required=True), nrg_name=dict(type='str', choices=['*MIRROR', 'MIRROR_DATABASE', 'MIRROR_ENGINE', 'MIRROR_IFS', 'MIRROR_OTHER', 'MIRROR_RESYNC'], default='*MIRROR'), source_address=dict(type='str', required=True), target_address=dict(type='str'), link_priority=dict(type='str'), change_load_balance_link_count=dict(type='bool', default=True), line_description=dict(type='str', default=''), virtual_lan_id=dict(type='str', default=''), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, required_if=[ ['operation', 'add', ['target_address', 'link_priority']], ], ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) operation = module.params['operation'] nrg_name = module.params['nrg_name'] source_address = module.params['source_address'] target_address = module.params['target_address'] link_priority = module.params['link_priority'] change_load_balance_link_count = module.params['change_load_balance_link_count'] line_description = module.params['line_description'] virtual_lan_id = module.params['virtual_lan_id'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] if change_load_balance_link_count: change_load_balance_link_count_str = 'YES' else: change_load_balance_link_count_str = 'NO' try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) if operation == 'add': try: link_priority_int = int(link_priority) if link_priority_int < 1 or link_priority_int > 16: module.fail_json( rc=255, msg="The value of argument link_priority is {0} which out of range from 1 to 16".format(link_priority_int)) except (TypeError, ValueError): module.fail_json( rc=255, msg="The value of argument link_priority is {0} which can't be converted to int".format(link_priority)) if source_address == '*ALL': module.fail_json( rc=255, msg="The value of argument source_address can not be '*ALL' when the operation is 'add'") sql = "CALL QSYS2.ADD_NRG_LINK(NRG_NAME => '{p_name}', SOURCE_ADDRESS => '{s_addr}', TARGET_ADDRESS => '{t_addr}', \ LINK_PRIORITY => {p_linkp}, INCREMENT_LOAD_BALANCE_LINK_COUNT => '{p_load}'".format( p_name=nrg_name, s_addr=source_address, t_addr=target_address, p_linkp=link_priority_int, p_load=change_load_balance_link_count_str) if line_description: sql = sql + \ ", LINE_DESCRIPTION => '{p_lined}'".format( p_lined=line_description) if virtual_lan_id: sql = sql + \ ", VIRTUAL_LAN_ID => '{p_vlan_id}'".format( p_vlan_id=virtual_lan_id) sql = sql + ")" ibmi_util.log_info("Run sql statement: " + sql, module._name) rc, out, err, job_log = ibmi_module.itoolkit_sql_callproc_once(sql) ibmi_util.log_debug("out={0}, err={1} ".format(str(out), str(err)), module._name) if rc: if (rc == ibmi_util.IBMi_PACKAGES_NOT_FOUND) or (rc == ibmi_util.IBMi_DB_CONNECTION_ERROR): msg = "Error occurred when add NRG link: {0}".format(err) else: msg = "Error occurred when add NRG link, see job log for detail" module.fail_json( rc=rc, msg=msg, job_log=job_log) sql = "CALL QSYS2.CHANGE_NRG(NRG_NAME => '{p_name}', NRG_DESCRIPTION => 'DB2MIRROR GROUP')".format(p_name=nrg_name) ibmi_util.log_info("Run sql statement: " + sql, module._name) rc, out, err, job_log = ibmi_module.itoolkit_sql_callproc_once(sql) ibmi_util.log_debug("out={0}, err={1} ".format(str(out), str(err)), module._name) if rc: module.fail_json( rc=rc, msg="Error occurred when change NRG deescription, see job log for detail", job_log=job_log) module.exit_json( rc=0, msg="Success to add NRG link") else: sql = "CALL QSYS2.REMOVE_NRG_LINK(NRG_NAME => '{p_name}', SOURCE_ADDRESS => '{s_addr}', \ DECREMENT_LOAD_BALANCE_LINK_COUNT => '{p_load}'".format( p_name=nrg_name, s_addr=source_address, p_load=change_load_balance_link_count_str) if line_description: sql = sql + \ ", LINE_DESCRIPTION => '{p_lined}'".format( p_lined=line_description) if virtual_lan_id: sql = sql + \ ", VIRTUAL_LAN_ID => '{p_vlan_id}'".format( p_vlan_id=virtual_lan_id) sql = sql + ")" ibmi_util.log_info("Run sql statement: " + sql, module._name) rc, out, err, job_log = ibmi_module.itoolkit_sql_callproc_once(sql) ibmi_util.log_debug("out={0}, err={1} ".format(str(out), str(err)), module._name) if rc: module.fail_json( rc=rc, msg="Error occurred when remove NRG link, see job log for detail", job_log=job_log) module.exit_json( rc=0, msg="Success to remove NRG link")
def main(): module = AnsibleModule( argument_spec=dict( product=dict(type='str', default='*ONLY'), ptf=dict(type='str', required=True), release=dict(type='str', default='*ALL'), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) product = module.params['product'].strip().upper() ptf = module.params['ptf'].strip().upper() release = module.params['release'].strip().upper() if release: release = release.strip().upper() joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] if len(product) > 7: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of product exceeds 7 characters") if len(ptf) > 7: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of ptf exceeds 7 characters") if (release != '*ALL') and (not (len(release) == 6)): module.fail_json( rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of release is not a correct format(VxRyMz or vvrrmm") result = dict(rc=0, ptf_info=[], requisite_ptf_info=[], job_log=[], stderr='') try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) sql = "SELECT * FROM QSYS2.PTF_INFO WHERE PTF_IDENTIFIER = '{0}' ".format( ptf) if product != '*ONLY': sql = sql + "and PTF_PRODUCT_ID = '{0}' ".format(product) if release != '*ALL': sql = sql + "and PTF_PRODUCT_RELEASE_LEVEL = '{0}' ".format(release) ibmi_util.log_debug("SQL to run: {0}".format(sql), module._name) rc, out, err, job_log = ibmi_module.itoolkit_run_sql_once(sql) result.update({'job_log': job_log}) if rc: result.update({'rc': rc}) result.update({'stderr': err}) message = 'non-zero return code when get PTF information:{rc}'.format( rc=rc) module.fail_json(msg=message, **result) result.update({'ptf_info': out}) if len(out) > 0: if product == '*ONLY': product = out[0]['PTF_PRODUCT_ID'] if release == '*ALL': release = out[0]['PTF_RELEASE_LEVEL'] ibmi_util.log_debug( "PTF release level: {0}, product id: {1}, ptf id: {2}".format( release, product, ptf), module._name) rc, pre_req_list, api_result = get_ptf_info(ibmi_module, ptf, product, release) ibmi_util.log_debug("Requisite PTFs info: " + str(pre_req_list), module._name) if rc: result.update({'rc': rc}) result.update({'stderr': str(api_result)}) message = 'non-zero return code when get requisite PTFs infomation:{rc}'.format( rc=rc) module.fail_json(msg=message, **result) result.update({'requisite_ptf_info': pre_req_list}) else: ibmi_util.log_info("No PTF information returned", module._name) message = 'No PTF information returned, check if the inputs are correct or if the PTF is loaded status' result.update({'rc': ibmi_util.IBMi_PTF_NOT_FOUND}) module.fail_json(msg=message, **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( ptf_id=dict(type='str', required=True), product=dict(type='str', default='*ONLYPRD'), release=dict(type='str', default='*ONLYRLS'), delivery_format=dict(type='str', default='*SAVF', choices=['*SAVF', '*IMAGE']), order=dict(type='str', default='*REQUIRED', choices=['*REQUIRED', '*PTFID']), reorder=dict(type='str', default='*YES', choices=['*NO', '*YES']), check_PTF=dict(type='str', default='*NO', choices=['*NO', '*YES']), image_directory=dict(type='str', default='*DFT'), joblog=dict(type='bool', default=False), parameters=dict(type='str', default=' '), time_out=dict(type='str', default='15m'), wait=dict(type='bool', default=True), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) ptf_id = module.params['ptf_id'] product = module.params['product'] release = module.params['release'] delivery_format = module.params['delivery_format'] order = module.params['order'] reorder = module.params['reorder'] check_PTF = module.params['check_PTF'] image_directory = module.params['image_directory'] joblog = module.params['joblog'] parameters = module.params['parameters'] time_out = module.params['time_out'] wait = module.params['wait'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] result = dict(stdout='', stderr='', rc=0, delta='', command='', download_list=[], job_log=[], msg='', order_id=0, job_info='') error = '' out = '' returned_job_status = '' job_log = [] download_list = [] time_up = False success = False job_submitted = '' job_submitted_split = '' order_id = 0 order_start_time = 0 order_end_time = 0 file_path = '' try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) conn = ibmi_module.get_connection() if image_directory != "*DFT": image_directory = "'{p_image_directory}'".format( p_image_directory=image_directory) command = 'SNDPTFORD PTFID(({p_ptf_id} {p_product} {p_release})) DLVRYFMT({p_delivery_format}) ORDER({p_order}) \ REORDER({p_reorder}) CHKPTF({p_check_PTF}) IMGDIR({p_image_directory}) {p_parameters}'.format( p_ptf_id=ptf_id, p_product=product, p_release=release, p_delivery_format=delivery_format, p_order=order, p_reorder=reorder, p_check_PTF=check_PTF, p_image_directory=image_directory, p_parameters=parameters) cl_sbmjob = "QSYS/SBMJOB CMD(" + ' '.join(command.split( )) + ") " + 'LOG(4 *JOBD *SECLVL) ' + 'LOGOUTPUT(*PND) ' + parameters startd = datetime.datetime.now() message_description = '' rc, out, error = ibmi_module.itoolkit_run_command(cl_sbmjob) current_job_log = ibmi_module.itoolkit_get_job_log(startd) for i in current_job_log: if i["MESSAGE_ID"] == "CPC1221": message_description = i["MESSAGE_TEXT"] break if rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS: return_error(module, conn, message_description, out, 'Submit job failed.', current_job_log, ibmi_util.IBMi_COMMAND_RC_ERROR, job_submitted_split, wait, delivery_format, result) submitted_job = re.search(r'\d{6}/[A-Za-z0-9#_]{1,10}/[A-Za-z0-9#_]{1,10}', message_description) job_submitted = submitted_job.group() job_submitted_split = job_submitted.split("/") sql_get_job_info = "SELECT V_JOB_STATUS as \"job_status\", " \ "V_ACTIVE_JOB_STATUS as \"active_job_status\"" \ " FROM TABLE(QSYS2.GET_JOB_INFO('" + job_submitted + "')) A" try: time_out_in_seconds = convert_wait_time_to_seconds(time_out) if wait or delivery_format == '*IMAGE': rc, out, error = ibmi_module.itoolkit_run_sql(sql_get_job_info) if isinstance(out, list) and len(out) == 1: returned_job_status = out[0]['job_status'].strip() while returned_job_status != '*UNKNOWN' and returned_job_status != '*OUTQ': wait_for_certain_time('1s') current_time = datetime.datetime.now() running_time = (current_time - startd).seconds if running_time > time_out_in_seconds: time_up = True break rc, out, error = ibmi_module.itoolkit_run_sql(sql_get_job_info) returned_job_status = '' if isinstance(out, list) and len(out) == 1: returned_job_status = out[0]['job_status'].strip() ibmi_util.log_debug("job_status: " + returned_job_status, module._name) if rc == ibmi_util.IBMi_COMMAND_RC_SUCCESS: job_log = db2i_tools.get_job_log(conn, job_submitted, startd) else: return_error(module, conn, error, out, 'itoolkit_run_sql failed', [], ibmi_util.IBMi_COMMAND_RC_ERROR, job_submitted_split, wait, delivery_format, result) if time_up is True: return_error(module, conn, error, '', 'Time up when waiting for SNDPTFORD complete.', job_log, ibmi_util.IBMi_COMMAND_RC_ERROR, job_submitted_split, wait, delivery_format, result) if delivery_format == '*SAVF': j = 0 while order_id == 0: for i in range(len(job_log) - 1, -1, -1): if job_log[i]['MESSAGE_ID'] == 'CPF8C07': return_error(module, conn, '', '', job_log[i]['MESSAGE_TEXT'], job_log, ibmi_util.IBMi_COMMAND_RC_ERROR, job_submitted_split, wait, delivery_format, result) elif job_log[i]['MESSAGE_ID'] == 'CPZ8C38': order_id = job_log[i]['MESSAGE_TEXT'][18:28] order_start_time = job_log[i]['MESSAGE_TIMESTAMP'] elif job_log[i]['MESSAGE_ID'] == 'CPZ8C12': download_list.append({}) download_list[j]['product'] = ( job_log[i]['MESSAGE_TEXT'])[4:11] download_list[j]['ptf_id'] = job_log[i][ 'MESSAGE_TEXT'][12:19] download_list[j]['release'] = job_log[i][ 'MESSAGE_TEXT'][20:26] download_list[j]['download_time'] = job_log[i][ 'MESSAGE_TIMESTAMP'] download_list[j][ 'file_name'] = 'Q' + download_list[j]['ptf_id'] download_list[j][ 'file_path'] = '/qsys.lib/qgpl.lib/' + download_list[ j]['file_name'] + '.FILE' download_list[j]['order_id'] = order_id j = j + 1 success = True elif job_log[i]['MESSAGE_ID'] == 'CPF1164': order_end_time = job_log[i]['MESSAGE_TIMESTAMP'] elif job_log[i]['MESSAGE_ID'] == 'CPI8C02': return_error(module, conn, '', '', job_log[i]['MESSAGE_TEXT'], job_log, ibmi_util.IBMi_COMMAND_RC_ERROR, job_submitted_split, wait, delivery_format, result) elif job_log[i]['MESSAGE_ID'] == 'CPF8C32': return_error( module, conn, '', '', 'PTF order cannot be processed. See joblog', job_log, ibmi_util.IBMi_COMMAND_RC_ERROR, job_submitted_split, wait, delivery_format, result) job_log = db2i_tools.get_job_log(conn, job_submitted, startd) elif delivery_format == '*IMAGE': if job_log: for i in range(len(job_log)): if job_log[i]['MESSAGE_ID'] == 'CPZ8C38': order_id = job_log[i]['MESSAGE_TEXT'][18:28] order_start_time = job_log[i]['MESSAGE_TIMESTAMP'] success = True elif job_log[i]['MESSAGE_ID'] == 'CPF8C32': return_error( module, conn, '', '', 'PTF order cannot be processed. See joblog', job_log, ibmi_util.IBMi_COMMAND_RC_ERROR, job_submitted_split, wait, delivery_format, result) else: return_error(module, conn, error, out, 'No joblog returned.', job_log, ibmi_util.IBMi_COMMAND_RC_ERROR, job_submitted_split, wait, delivery_format, result) if wait is True or delivery_format == '*IMAGE': ret, message = remove_pending_joblog(conn, job_submitted_split[2], job_submitted_split[1], job_submitted_split[0]) if ret != 0: error = error + '/n remove pending joblog fail.' + message endd = datetime.datetime.now() delta = endd - startd if delivery_format == '*IMAGE': if image_directory == '*DFT': file_path = '/QIBM/UserData/OS/Service/ECS/PTF/' + str( order_id) else: file_path = image_directory.strip("'") result.update({ 'job_log': job_log if joblog or rc or success is False else [], 'stdout': '', 'stderr': error, 'download_list': download_list, 'rc': rc, 'delta': str(delta), 'order_id': order_id, 'msg': 'SNDPTFORD successfully ended.', 'job_info': job_submitted, 'command': cl_sbmjob, 'order_start_time': order_start_time, 'order_end_time': order_end_time, 'file_path': file_path }) module.exit_json(**result) except ImportError as e_import: return_error(module, conn, str(e_import), '', '', '', ibmi_util.IBMi_PACKAGES_NOT_FOUND, job_submitted_split, wait, delivery_format, result) except Exception as e_db_connect: return_error(module, conn, str(e_db_connect), '', '', '', ibmi_util.IBMi_DB_CONNECTION_ERROR, job_submitted_split, wait, delivery_format, result)
def main(): module = AnsibleModule( argument_spec=dict(src=dict(type='str', required=True), dest=dict(type='str', default=''), remote_user=dict(type='str', required=True), remote_host=dict(type='str', required=True), private_key=dict(type='path', default='~/.ssh/id_rsa')), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) result = dict( stdout='', stderr='', rc=0, delta='', ) try: if HAS_PARAMIKO is False: module.fail_json(msg="paramiko package is required", rc=ibmi_util.IBMi_COMMAND_RC_ERROR) src = module.params['src'] dest = module.params['dest'] remote_user = module.params['remote_user'] remote_host = module.params['remote_host'] private_key = module.params['private_key'] startd = datetime.datetime.now() if os.path.splitext(os.path.basename(src))[-1].upper() != '.FILE': return_error( module, "src {p_src} is not a save file. src must be end with '.FILE'." .format(p_src=src), result) if src[0:9].upper() != '/QSYS.LIB': return_error( module, "src {p_src} path should be absolute, start with /QSYS.LIB.". format(p_src=src), result) if dest == '': dest = src if dest[0:9].upper() != '/QSYS.LIB': return_error( module, "dest {p_dest} path should be absolute, start with /QSYS.LIB.". format(p_dest=dest), result) # Check if the savefile exists if not os.path.isfile(src): return_error(module, "src doesn't exist. {p_src}".format(p_src=src), result) ibmi_util.log_debug("mkdir " + ifs_dir, module._name) rc, out, err = module.run_command(['mkdir', ifs_dir], use_unsafe_shell=False) if rc == 0 or 'File exists' in err: ibmi_util.log_debug("cp " + src + " " + ifs_dir, module._name) rc, out, err = module.run_command(['cp', src, ifs_dir], use_unsafe_shell=False) if rc == 0: src_basename = os.path.basename(src) ifs_name = ifs_dir + src_basename private_key = to_bytes(private_key, errors='surrogate_or_strict') p_key = paramiko.RSAKey.from_private_key_file(private_key) ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect(hostname=remote_host, port=22, username=remote_user, pkey=p_key) transport = paramiko.Transport((remote_host, 22)) transport.connect(username=remote_user, pkey=p_key) sftp = paramiko.SFTPClient.from_transport(transport) stdin, stdout, stderr = ssh.exec_command( 'mkdir {p_ifs_dir}'.format(p_ifs_dir=ifs_dir)) line = stderr.readlines() if line != [] and 'File exists' not in "".join(line): return_error( module, "Failed to mkdir on remote host, dir = {p_ifs_dir}. {p_line}" .format(p_ifs_dir=ifs_dir, p_line=line), result) try: ibmi_util.log_debug( "sftp: put " + ifs_name + " " + ifs_name, module._name) sftp.put(ifs_name, ifs_name) except Exception as e: return_error( module, "Put {p_to_text} to remote host exception. Use -vvv for more information." .format(p_to_text=to_text(e)), result) ibmi_util.log_debug("mv " + ifs_name + " " + dest, module._name) stdin, stdout, stderr = ssh.exec_command( 'mv {p_ifs_name} {p_dest}'.format(p_ifs_name=ifs_name, p_dest=dest)) line = stderr.readlines() if line != []: return_error( module, "Failed to mv file to qsys. qsys dir = {p_dest}. {p_line}" .format(p_dest=dest, p_line=line), result) else: return_error( module, "Copy file to current host tmp dir failed. cp {p_src} {p_ifs_dir}. {p_err}" .format(p_src=src, p_ifs_dir=ifs_dir, p_err=err), result) else: return_error( module, "mkdir on current host failed. dir = {p_ifs_dir}. {p_err}". format(p_ifs_dir=ifs_dir, p_err=err), result) endd = datetime.datetime.now() delta = endd - startd result[ 'stdout'] = "Successfully synchronize file {p_src} to remote host {p_remote_host}:{p_dest}".format( p_src=src, p_remote_host=remote_host, p_dest=dest) result.update({'stderr': err, 'rc': rc, 'delta': str(delta)}) module.exit_json(**result) except Exception as e: return_error( module, "Unexpected exception happens. error: {p_to_text}. Use -vvv for more information." .format(p_to_text=to_text(e)), result) finally: if 'ssh' in vars(): ssh.close() if 'sftp' in vars(): sftp.close()
def main(): module = AnsibleModule( argument_spec=dict( object_names=dict(type='str', default='*ALL'), object_lib=dict(type='str', required=True), object_types=dict(type='str', default='*ALL'), savefile_name=dict(type='str', required=True), savefile_lib=dict(type='str', required=True), format=dict(type='str', default='*SAVF', choices=['*SAVF']), force_save=dict(type='bool', default=False), target_release=dict(type='str', default='*CURRENT'), joblog=dict(type='bool', default=False), asp_group=dict(type='str', default='*SYSBAS'), parameters=dict(type='str', default=' '), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) try: object_names = module.params['object_names'] object_lib = module.params['object_lib'] object_types = module.params['object_types'] savefile_name = module.params['savefile_name'] savefile_lib = module.params['savefile_lib'] format = module.params['format'] force_save = module.params['force_save'] target_release = module.params['target_release'] joblog = module.params['joblog'] asp_group = module.params['asp_group'].strip().upper() parameters = module.params['parameters'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] startd = datetime.datetime.now() try: ibmi_module = imodule.IBMiModule( db_name=asp_group, become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) # crtsavf command = 'QSYS/CRTSAVF FILE({p_savefile_lib}/{p_savefile_name})'.format( p_savefile_lib=savefile_lib, p_savefile_name=savefile_name) rc, out, error = ibmi_module.itoolkit_run_command(command) job_log = ibmi_module.itoolkit_get_job_log(startd) ibmi_util.log_debug("CRTSAVF: " + command, module._name) if rc == ibmi_util.IBMi_COMMAND_RC_SUCCESS: # SAVOBJ command = 'QSYS/SAVOBJ OBJ({p_object_names}) LIB({p_object_lib}) DEV({p_format}) OBJTYPE({p_object_types}) \ SAVF({p_savefile_lib}/{p_savefile_name}) TGTRLS({p_target_release}) {p_parameters}'.format( p_object_names=object_names, p_object_lib=object_lib, p_format=format, p_object_types=object_types, p_savefile_lib=savefile_lib, p_savefile_name=savefile_name, p_target_release=target_release, p_parameters=parameters) rc, out, error = ibmi_module.itoolkit_run_command(' '.join(command.split())) else: if 'CPF5813' in str(job_log): ibmi_util.log_debug("SAVF " + savefile_name + " already exists", module._name) if force_save is True: # CLRSAVF command = 'QSYS/CLRSAVF FILE({p_savefile_lib}/{p_savefile_name})'.format( p_savefile_lib=savefile_lib, p_savefile_name=savefile_name) rc, out, error = ibmi_module.itoolkit_run_command(command) ibmi_util.log_debug("CLRSAVF: " + command, module._name) if rc == ibmi_util.IBMi_COMMAND_RC_SUCCESS: command = 'QSYS/SAVOBJ OBJ({p_object_names}) LIB({p_object_lib}) DEV({p_format}) OBJTYPE({p_object_types}) \ SAVF({p_savefile_lib}/{p_savefile_name}) TGTRLS({p_target_release}) {p_parameters}'.format( p_object_names=object_names, p_object_lib=object_lib, p_format=format, p_object_types=object_types, p_savefile_lib=savefile_lib, p_savefile_name=savefile_name, p_target_release=target_release, p_parameters=parameters) rc, out, error = ibmi_module.itoolkit_run_command(' '.join(command.split())) else: out = 'File {p_savefile_name} in library {p_savefile_lib} already exists. Set force_save to force save.'.format( p_savefile_name=savefile_name, p_savefile_lib=savefile_lib) endd = datetime.datetime.now() delta = endd - startd job_log = ibmi_module.itoolkit_get_job_log(startd) result = dict( object_names=object_names, object_lib=object_lib, object_types=object_types, savefile_name=savefile_name, savefile_lib=savefile_lib, joblog=joblog, format=format, force_save=force_save, target_release=target_release, command=' '.join(command.split()), job_log=job_log if joblog or rc else [], stdout=out, stderr=error, rc=rc, start=str(startd), end=str(endd), delta=str(delta), ) if rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS: module.fail_json(msg='non-zero return code', **result) module.exit_json(**result) except Exception as e: module.fail_json(rc=ibmi_util.IBMi_COMMAND_RC_UNEXPECTED, msg=str(e))
def main(): module = AnsibleModule( argument_spec=dict( cmd=dict(type='str', required=True), time_out=dict(type='str', default='1m'), status=dict(type='list', default=["*NONE"], elements='str'), check_interval=dict(type='str', default='1m'), parameters=dict(type='str', default=''), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) command = module.params['cmd'] time_out = module.params['time_out'] check_interval = module.params['check_interval'] wait_for_job_status = module.params['status'] parameters = module.params['parameters'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] ibmi_module = imodule.IBMiModule(become_user_name=become_user, become_user_password=become_user_password) cl_sbmjob = "QSYS/SBMJOB CMD(" + command + ") " + parameters if set(wait_for_job_status) < set(IBMi_JOB_STATUS_LIST): # this is expected pass else: rc = IBMi_PARAM_NOT_VALID result_failed_parameter_check = dict( # size=input_size, # age=input_age, # age_stamp=input_age_stamp, stderr="Parameter passed is not valid. ", rc=rc, sbmjob_cmd=cl_sbmjob, # changed=True, ) module.fail_json( msg= 'Value specified for status option is not valid. Valid values are ' '*NONE, *ACTIVE, *COMPLETE, *JOBQ, *OUTQ', **result_failed_parameter_check) startd = datetime.datetime.now() # args = ['system', cl_sbmjob] # rc, out, err = module.run_command(args, use_unsafe_shell=False) rc, out, err = ibmi_module.itoolkit_run_command(cl_sbmjob) current_job_log = ibmi_module.itoolkit_get_job_log(startd) message_description = '' for i in current_job_log: if i["MESSAGE_ID"] == "CPC1221": message_description = i["MESSAGE_TEXT"] break if rc != IBMi_COMMAND_RC_SUCCESS: result_failed = dict( # size=input_size, # age=input_age, # age_stamp=input_age_stamp, stderr=err, rc=rc, sbmjob_cmd=cl_sbmjob, # changed=True, ) module.fail_json(msg='Submit job failed. ', **result_failed) elif '*NONE' in wait_for_job_status: submitted_job = re.search( r'\d{6}/[A-Za-z0-9#_]{1,10}/[A-Za-z0-9#_]{1,10}', message_description) job_submitted = submitted_job.group() result_success = dict( rc=rc, job_submitted=job_submitted, sbmjob_cmd=cl_sbmjob, # changed=True, ) module.exit_json(**result_success) submitted_job = re.search(r'\d{6}/[A-Za-z0-9#_]{1,10}/[A-Za-z0-9#_]{1,10}', message_description) job_submitted = submitted_job.group() ibmi_util.log_debug("job_submitted: " + job_submitted, module._name) sql_get_job_info = "SELECT V_JOB_STATUS as \"job_status\", " \ "V_ACTIVE_JOB_STATUS as \"active_job_status\", " \ "V_RUN_PRIORITY as \"run_priority\", " \ "V_SBS_NAME as \"sbs_name\", " \ "V_CLIENT_IP_ADDRESS as \"ip_address\"" \ " FROM TABLE(QSYS2.GET_JOB_INFO('" + job_submitted + "')) A" rc, out, err_msg = ibmi_module.itoolkit_run_sql(sql_get_job_info) time_out_in_seconds = convert_wait_time_to_seconds(time_out) returned_job_status = '' if isinstance(out, list) and len(out) == 1: returned_job_status = out[0]['job_status'].strip() ibmi_util.log_debug("job_status: " + returned_job_status, module._name) while returned_job_status not in wait_for_job_status: rc, out, err_msg = ibmi_module.itoolkit_run_sql(sql_get_job_info) returned_job_status = '' if isinstance(out, list) and len(out) == 1: returned_job_status = out[0]['job_status'].strip() ibmi_util.log_debug("job_status: " + returned_job_status, module._name) wait_for_certain_time(check_interval) current_time = datetime.datetime.now() running_time = (current_time - startd).seconds if running_time > time_out_in_seconds: break ibmi_util.log_debug("job_status: " + returned_job_status, module._name) if returned_job_status not in wait_for_job_status: rc = IBMi_JOB_STATUS_NOT_EXPECTED endd = datetime.datetime.now() delta = endd - startd rc_msg = interpret_return_code(rc) if rc != IBMi_COMMAND_RC_SUCCESS: result_failed = dict( # size=input_size, # age=input_age, # age_stamp=input_age_stamp, job_info=out, stderr=err, rc=rc, start=str(startd), end=str(endd), delta=str(delta), job_submitted=job_submitted, sbmjob_cmd=cl_sbmjob, # changed=True, ) module.fail_json(msg='non-zero return code: ' + rc_msg, **result_failed) else: result_success = dict( job_info=out, rc=rc, start=str(startd), end=str(endd), delta=str(delta), job_submitted=job_submitted, sbmjob_cmd=cl_sbmjob, # changed=True, ) module.exit_json(**result_success)
def main(): module = AnsibleModule( argument_spec=dict( job_name=dict(type='str', required=True), cmd=dict(type='str', required=True), frequency=dict(type='str', required=True, choices=['*ONCE', '*WEEKLY', '*MONTHLY']), scddate=dict(type='str', default='*CURRENT'), scdday=dict(type='list', elements='str', default='*NONE'), schtime=dict(type='str', default='*CURRENT'), text=dict(type='str', default='*BLANK'), parameters=dict(type='str', default=''), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) job_name = module.params['job_name'] cmd = module.params['cmd'] frequency = module.params['frequency'] scddate = module.params['scddate'] scdday = module.params['scdday'] schtime = module.params['schtime'] text = module.params['text'] parameters = module.params['parameters'] joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] if scddate not in ["*CURRENT", "*MONTHSTR", "*MONTHEND", "*NONE"]: scddate = "'{p_scddate}'".format(p_scddate=scddate) if schtime != "*CURRENT": schtime = "'{p_schtime}'".format(p_schtime=schtime) if text != "*BLANK": text = "'{p_text}'".format(p_text=text) result = dict(command='', stdout='', stderr='', rc='', delta='', msg='', job_log=[]) if set(scdday) < set(scdday_list): pass else: result.update({ 'msg': 'Value specified for scdday is not valid. Valid values are {p_scdday_list}' .format(p_scdday_list=", ".join(scdday_list)), 'stderr': 'Parameter passed is not valid.', 'rc': ibmi_util.IBMi_PARAM_NOT_VALID }) module.fail_json(**result) scdday = " ".join(scdday) if scddate != '*NONE' and scdday != '*NONE': result['msg'] = 'Either scddate or scdday need to be *NONE.' if scddate == '*NONE' and scdday == '*NONE': result['msg'] = 'scddate and scdday cannot be *NONE at the sametime.' if result.get('msg'): module.fail_json(**result) startd = datetime.datetime.now() command = 'QSYS/ADDJOBSCDE JOB({p_job_name}) CMD({p_cmd}) FRQ({p_frequency}) SCDDATE({p_scddate}) SCDDAY({p_scdday}) \ SCDTIME({p_schtime}) TEXT({p_text}) {p_parameters}'.format( p_job_name=job_name, p_cmd=cmd, p_frequency=frequency, p_scddate=scddate, p_scdday=scdday, p_schtime=schtime, p_text=text, p_parameters=parameters) try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) rc, out, error, job_log = ibmi_module.itoolkit_run_command_once(command) endd = datetime.datetime.now() delta = endd - startd if rc: result.update({ 'msg': 'Failed to add Job schedule entry {p_job_name}. Please double check the input.' .format(p_job_name=job_name), 'command': ' '.join(command.split()), 'stdout': out, 'stderr': error, 'rc': rc, 'delta': str(delta), 'job_log': job_log }) module.fail_json(**result) elif joblog: result.update({ 'msg': 'Job schedule entry {p_job_name} is successfully added.'.format( p_job_name=job_name), 'command': ' '.join(command.split()), 'stdout': out, 'stderr': error, 'rc': rc, 'delta': str(delta), 'job_log': job_log }) module.exit_json(**result) else: result.update({ 'msg': 'Job schedule entry {p_job_name} is successfully added.'.format( p_job_name=job_name), 'command': ' '.join(command.split()), 'stdout': out, 'stderr': error, 'rc': rc, 'delta': str(delta) }) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( message_key=dict(type='str', required=True), message_queue=dict(type='str', required=True), message_lib=dict(type='str', default='*LIB'), reply=dict(type='str', default='*DFT'), remove_message=dict(type='str', choices=['*YES', '*NO'], default='*YES'), reject_default_reply=dict(type='str', choices=['*NOALWRJT', '*ALWRJT'], default='*NOALWRJT'), ccsid=dict(type='str', default='*JOB'), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) message_key = module.params['message_key'] message_queue = module.params['message_queue'] message_lib = module.params['message_lib'] reply = module.params['reply'] remove_message = module.params['remove_message'] reject_default_reply = module.params['reject_default_reply'] ccsid = module.params['ccsid'] joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] # handle the message key which more than 4 characters if len(message_key) > 4: message_key = "x'{0}'".format(message_key) command = "QSYS/SNDRPY MSGKEY({p_message_key}) MSGQ({p_message_lib}/{p_message_queue}) \ RPY({p_reply}) RMV({p_remove_message}) RJTDFTRPY({p_reject_default_reply}) CCSID({p_ccsid})".format( p_message_key=message_key, p_message_queue=message_queue, p_message_lib=message_lib, p_reply=reply, p_remove_message=remove_message, p_reject_default_reply=reject_default_reply, p_ccsid=ccsid) startd = datetime.datetime.now() try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) job_log = [] rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) endd = datetime.datetime.now() delta = endd - startd result = dict( cmd=command, job_log=job_log, stdout=out, stderr=err, rc=rc, start=str(startd), end=str(endd), delta=str(delta), ) if rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS: module.fail_json(msg='non-zero return code', **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( cmd=dict(type='str', required=True), asp_group=dict(type='str', default='*SYSBAS'), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) command = module.params['cmd'].strip().upper() asp_group = module.params['asp_group'].strip().upper() joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] startd = datetime.datetime.now() is_cmd5250 = False if command.startswith('DSP'): is_cmd5250 = True if command.startswith('QSYS/DSP'): is_cmd5250 = True if command.startswith('WRK'): is_cmd5250 = True if command.startswith('QSYS/WRK'): is_cmd5250 = True if 'OUTPUT(*)' in command: is_cmd5250 = True if is_cmd5250: ibmi_util.log_info( "Command {0} starts with 'WRK' or 'DSP' or contains 'OUTPUT' keyword, call system utility to run" .format(command), module._name) # rc, out, err, job_log = ibmi_module.itoolkit_run_command5250_once(command) args = ['system', command] rc, out, err = module.run_command(args, use_unsafe_shell=False) job_log = [] else: try: ibmi_module = imodule.IBMiModule( db_name=asp_group, become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) endd = datetime.datetime.now() delta = endd - startd result = dict( cmd=command, joblog=joblog, rc=rc, stdout=out, stderr=err, job_log=job_log, start=str(startd), end=str(endd), delta=str(delta), ) if rc: message = 'non-zero return code:{rc}'.format(rc=rc) module.fail_json(msg=message, **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( product=dict(type='str', required=True), option=dict(type='str', default='*BASE'), object_type=dict(type='str', default='*ALL', choices=['*ALL', '*PGM', '*LNG']), language=dict(type='str', default='*PRIMARY'), release=dict(type='str', default='*FIRST'), replace_release=dict(type='str', default='*ONLY'), savf_name=dict(type='str', required=True), savf_library=dict(type='str', required=True), parameters=dict(type='str', default=' '), acceptance_cmd=dict(type='str', default=' '), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) product = module.params['product'].upper() option = module.params['option'].upper() object_type = module.params['object_type'].upper() language = module.params['language'].upper() release = module.params['release'].upper() replace_release = module.params['replace_release'].upper() savf_name = module.params['savf_name'].upper() savf_library = module.params['savf_library'].upper() parameters = module.params['parameters'].upper() acceptance_cmd = module.params['acceptance_cmd'].upper() joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] if len(product) > 7: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of product exceeds 7 characters") if len(option) > 5: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of option exceeds 5 characters") if len(release) > 6: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of release exceeds 6 characters") if len(replace_release) > 6: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of replace_release exceeds 6 characters") if len(language) > 8: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of language exceeds 8 characters") if len(savf_name) > 10: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of savf_name exceeds 10 characters") if len(savf_library) > 10: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of savf_library exceeds 10 characters") try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) command = 'QSYS/CHKOBJ OBJ({pattern_savf_library}/{pattern_savf_name}) OBJTYPE(*FILE)'.format( pattern_savf_name=savf_name.strip(), pattern_savf_library=savf_library.strip()) # Check to see if the savf is existed ibmi_util.log_info("Command to run: " + command, module._name) rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) if rc != 0: result = dict( command=command, stderr=err, rc=rc, job_log=job_log, ) module.fail_json( msg= "File {pattern_savf_name} in library {pattern_savf_library} not found" .format(pattern_savf_name=savf_name.strip(), pattern_savf_library=savf_library.strip()), **result) # Call the The Accept Software Agreement command if acceptance_cmd.strip(): command = acceptance_cmd.strip() ibmi_util.log_info("Acceptance command to run: " + command, module._name) rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) if rc != 0: result = dict( command=command, stderr=err, rc=rc, job_log=job_log, ) module.fail_json( msg= "The Accept Software Agreement command {acceptance_cmd} failed" .format(acceptance_cmd=acceptance_cmd), **result) # run the RSTLICPGM command to install the product command = 'QSYS/RSTLICPGM LICPGM({pattern_product}) DEV(*SAVF) OPTION({pattern_option}) RSTOBJ({pattern_object_type}) \ LNG({pattern_language}) RLS({pattern_release}) REPLACERLS({pattern_replace_release}) \ SAVF({pattern_savf_library}/{pattern_savf_name}) {pattern_parameters}'.format( pattern_product=product, pattern_option=option, pattern_object_type=object_type, pattern_language=language, pattern_release=release, pattern_replace_release=replace_release, pattern_savf_library=savf_library.strip(), pattern_savf_name=savf_name.strip(), pattern_parameters=parameters) command = ' '.join( command.split()) # keep only one space between adjacent strings rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) if rc: result = dict( command=command, stderr=err, rc=rc, job_log=job_log, ) message = 'non-zero return code:{rc}'.format(rc=rc) module.fail_json(msg=message, **result) result = dict( command=command, stdout=out, rc=rc, job_log=job_log, changed=True, ) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( users=dict(type='list', elements='str', required=True), fields=dict(type='list', elements='dict', required=True), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) # get input value users = module.params['users'] fields = module.params['fields'] joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] # initialize variables check_special_authorities = False check_user_action_audit_level = False check_user_option = False check_supplemental_group_list = False check_locale_job_attributes = False check_home_directory = False out1 = [] out2 = [] # check input value for field in fields: if field.get('name') is None: module.fail_json( rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="There is no element 'name' in the dictionary 'field'.") if field.get('expect') is None: module.fail_json( rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="There is no element 'expect' in the dictionary 'field'.") if not isinstance(field['name'], str): module.fail_json( rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg= "The type of element 'name' of dictionary 'field' must be string." ) if isinstance(field['expect'], list): for expect_value in field['expect']: if not isinstance(expect_value, str): module.fail_json( rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg= "The type of element 'expect' of dictionary 'field' must be a list comprised by string." ) else: module.fail_json( rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg= "The type of element 'expect' of dictionary 'field' must be a list comprised by string." ) if (field['name'].upper() not in parmname_array): module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Input attribute name is not available") if field['name'].upper() == 'SPECIAL_AUTHORITIES': check_special_authorities = True special_authorities_expect = list(filter(None, field['expect'])) elif field['name'].upper() == 'USER_ACTION_AUDIT_LEVEL': check_user_action_audit_level = True user_action_audit_level_expect = list(filter( None, field['expect'])) elif field['name'].upper() == 'USER_OPTIONS': check_user_option = True user_option_expect = list(filter(None, field['expect'])) elif field['name'].upper() == 'SUPPLEMENTAL_GROUP_LIST': check_supplemental_group_list = True supplemental_group_list_expect = list(filter( None, field['expect'])) elif field['name'].upper() == 'LOCALE_JOB_ATTRIBUTES': check_locale_job_attributes = True locale_job_attributes_expect = list(filter(None, field['expect'])) elif field['name'].upper() == 'HOME_DIRECTORY': check_home_directory = True home_directory_expect = list(filter(None, field['expect'])) elif (field['name'].upper() == 'SIGN_ON_ATTEMPTS_NOT_VALID' or field['name'].upper() == 'PASSWORD_EXPIRATION_INTERVAL' or field['name'].upper() == 'DAYS_UNTIL_PASSWORD_EXPIRES' or field['name'].upper() == 'SUPPLEMENTAL_GROUP_COUNT' or field['name'].upper() == 'MAXIMUM_ALLOWED_STORAGE' or field['name'].upper() == 'STORAGE_USED' or field['name'].upper() == 'MESSAGE_QUEUE_SEVERITY' or field['name'].upper() == 'USER_ID_NUMBER' or field['name'].upper() == 'GROUP_ID_NUMBER' or field['name'].upper() == 'USER_EXPIRATION_INTERVAL' or field['name'].upper() == 'DAYS_USED_COUNT' or field['name'].upper() == 'SIZE'): if len(field['expect']) > 1: module.fail_json( rc=256, msg="Field {p_name} should be only one value".format( p_name=field['name'].upper())) if field['expect'][0].strip() != '' and not is_number( field['expect'][0]): module.fail_json( rc=256, msg="Field {p_name} should be numerical".format( p_name=field['name'].upper())) try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) # Check to see if the user exists User_not_existed = [] for user in users: chkobj_cmd = 'QSYS/CHKOBJ OBJ(QSYS/{p_user}) OBJTYPE(*USRPRF)'.format( p_user=user) ibmi_util.log_info("Command to run: " + chkobj_cmd, module._name) rc, out, err, job_log = ibmi_module.itoolkit_run_command_once( chkobj_cmd) if rc != 0: User_not_existed.append(user) sql1, sql2 = build_sql(fields, users) if sql1 != "": startd = datetime.datetime.now() rc, out1, err = ibmi_module.itoolkit_run_sql(sql1) if joblog or (rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS): job_log = ibmi_module.itoolkit_get_job_log(startd) else: job_log = [] if rc: result_failed = dict( stderr=err, sql1=sql1, sql2=sql2, rc=rc, job_log=job_log, ) message = 'non-zero return code:{rc}'.format(rc=rc) module.fail_json(msg=message, **result_failed) if sql2 != "": # fetch records of all users information specified by user startd = datetime.datetime.now() rc, out2, err = ibmi_module.itoolkit_run_sql(sql2) if joblog or (rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS): job_log = ibmi_module.itoolkit_get_job_log(startd) else: job_log = [] if rc: result_failed = dict( stderr=err, sql1=sql1, sql2=sql2, rc=rc, job_log=job_log, ) message = 'non-zero return code:{rc}'.format(rc=rc) module.fail_json(msg=message, **result_failed) if out2: real_out2 = [] for item in out2: # compare the column SPECIAL_AUTHORITIES if check_special_authorities: special_authorities_list = item[ 'SPECIAL_AUTHORITIES'].split() not_expected_value = False if (len(special_authorities_list) == len( special_authorities_expect)): for special_authorities_value in special_authorities_list: if special_authorities_value not in special_authorities_expect: not_expected_value = True break else: not_expected_value = True if not_expected_value: real_out2.append(item) continue # compare the column USER_ACTION_AUDIT_LEVEL if check_user_action_audit_level: user_action_audit_level_list = item[ 'USER_ACTION_AUDIT_LEVEL'].split() not_expected_value = False if (len(user_action_audit_level_list) == len( user_action_audit_level_expect)): for user_action_audit_level_value in user_action_audit_level_list: if user_action_audit_level_value not in user_action_audit_level_expect: not_expected_value = True break else: not_expected_value = True if not_expected_value: real_out2.append(item) continue # compare the column USER_OPTIONS if check_user_option: user_option_list = item['USER_OPTIONS'].split() not_expected_value = False if (len(user_option_list) == len(user_option_expect)): for user_option_value in user_option_list: if user_option_value not in user_option_expect: not_expected_value = True break else: not_expected_value = True if not_expected_value: real_out2.append(item) continue # compare the column SUPPLEMENTAL_GROUP_LIST if check_supplemental_group_list: supplemental_group_list = item[ 'SUPPLEMENTAL_GROUP_LIST'].split() not_expected_value = False if (len(supplemental_group_list) == len( supplemental_group_list_expect)): for supplemeental_group_value in supplemental_group_list: if supplemeental_group_value not in supplemental_group_list_expect: not_expected_value = True break else: not_expected_value = True if not_expected_value: real_out2.append(item) continue # compare the column LOCALE_JOB_ATTRIBUTES if check_locale_job_attributes: locale_job_attributes_list = item[ 'LOCALE_JOB_ATTRIBUTES'].split() not_expected_value = False if (len(locale_job_attributes_list) == len( locale_job_attributes_expect)): for locale_job_attributes_value in locale_job_attributes_list: if locale_job_attributes_value not in locale_job_attributes_expect: not_expected_value = True break else: not_expected_value = True if not_expected_value: real_out2.append(item) continue if check_home_directory: home_directory = item['HOME_DIRECTORY'] if len(home_directory_expect) == 0: if home_directory.strip() != '': real_out2.append(item) continue else: if home_directory_expect[0].upper( ) != home_directory.upper(): real_out2.append(item) continue if out1: out1_name_list = [] for item in out1: out1_name_list.append(item['AUTHORIZATION_NAME'].upper()) out = out1 for item in real_out2: if item['AUTHORIZATION_NAME'].upper( ) not in out1_name_list: out.append(item) else: out = real_out2 else: out = out1 else: out = out1 if len(User_not_existed) == 0: result_success = dict( result_set=out, sql1=sql1, sql2=sql2, rc=rc, job_log=job_log, ) else: result_success = dict( result_set=out, user_not_existed=User_not_existed, sql1=sql1, sql2=sql2, rc=rc, job_log=job_log, ) module.exit_json(**result_success)
def main(): module = AnsibleModule( argument_spec=dict( operation=dict(type='str', choices=["find"], required=True), message_type=dict(type='str', choices=[ "INFORMATIONAL", "COMPLETION", "DIAGNOSTIC", "ESCAPE", "INQUIRY", "REPLY", "NOTIFY", "REQUEST", "SENDER", "NO_REPLY" ], required=True), message_lib=dict(type='str', required=True), message_queue=dict(type='list', elements='str'), message_id=dict(type='list', elements='str'), message_text=dict(type='str'), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) operation = module.params['operation'] message_type = module.params['message_type'].upper() message_queue = module.params['message_queue'] message_lib = module.params['message_lib'].upper() message_id = module.params['message_id'] message_text = module.params['message_text'] joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] startd = datetime.datetime.now() try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) if operation == "find": sql = "SELECT MESSAGE_QUEUE_LIBRARY, MESSAGE_QUEUE_NAME, MESSAGE_ID, MESSAGE_TYPE, " + \ "MESSAGE_SUBTYPE, MESSAGE_TEXT, SEVERITY, MESSAGE_TIMESTAMP, MESSAGE_KEY, ASSOCIATED_MESSAGE_KEY, " + \ "FROM_USER, FROM_JOB, FROM_PROGRAM, MESSAGE_FILE_LIBRARY, MESSAGE_FILE_NAME, MESSAGE_SECOND_LEVEL_TEXT " + \ "FROM QSYS2.MESSAGE_QUEUE_INFO WHERE MESSAGE_QUEUE_LIBRARY = '" + message_lib + "' AND " sql = handle_list_to_sql(sql, message_queue, "MESSAGE_QUEUE_NAME") sql = handle_list_to_sql(sql, message_id, "MESSAGE_ID") if message_text: sql = sql + "(MESSAGE_TEXT LIKE UPPER('%" + message_text + "%') " + \ "OR MESSAGE_TEXT LIKE LOWER('%" + message_text + "%') " + \ "OR MESSAGE_SECOND_LEVEL_TEXT LIKE UPPER('%" + message_text + "%') " + \ "OR MESSAGE_SECOND_LEVEL_TEXT LIKE LOWER('%" + message_text + "%')) AND " if message_type == "NO_REPLY": sql = sql + "MESSAGE_TYPE = 'INQUIRY' AND MESSAGE_KEY NOT IN " + \ "(SELECT ASSOCIATED_MESSAGE_KEY FROM QSYS2.MESSAGE_QUEUE_INFO WHERE MESSAGE_TYPE = 'REPLY' " + \ "AND MESSAGE_QUEUE_LIBRARY = '" + message_lib + "')" else: sql = sql + "MESSAGE_TYPE = '" + message_type + "'" hex_convert_columns = ['MESSAGE_KEY', 'ASSOCIATED_MESSAGE_KEY'] rc, out, error, job_log = ibmi_module.itoolkit_run_sql_once( sql, hex_convert_columns) endd = datetime.datetime.now() delta = endd - startd result = dict( sql=sql, stderr=error, message_info=out, rc=rc, job_log=job_log, start=str(startd), end=str(endd), delta=str(delta), ) if rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS: module.fail_json(msg='non-zero return code', **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( name=dict(type='str', required=True), operation=dict( type='str', required=True, choices=['create', 'add_disks', 'delete', 'display']), disks=dict(type='list', elements='str'), asp_type=dict(type='str', default="*PRIMARY", choices=['*PRIMARY', '*SECONDARY', '*UDFS']), primary_asp=dict(type='str'), extra_parameters=dict(type='str', default=' '), synchronous=dict(type='bool', default=True), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), required_if=[["operation", "create", ["disks", "asp_type"]], ["operation", "add_disks", ["disks"]], ["asp_type", "*SECONDARY", ["primary_asp"]]], supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) name = module.params['name'] operation = module.params['operation'] disks = module.params['disks'] asp_type = module.params['asp_type'] primary_asp = module.params['primary_asp'] extra_parameters = module.params['extra_parameters'] synchronous = module.params['synchronous'] joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] startd = datetime.datetime.now() try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) command = '' rc = '' rc_msg = '' out = '' state = '' asp_number = '000' asp_info = '' job_log = [] sql = "SELECT * FROM QSYS2.ASP_INFO WHERE RESOURCE_NAME = '" + name.upper( ) + "'" rc, asp_info, error, job_log = ibmi_module.itoolkit_run_sql_once(sql) if asp_info: state = asp_info[0]['ASP_STATE'] asp_number = asp_info[0]['ASP_NUMBER'] error = '' if operation == "create": if not state: command = "QSYS/CFGDEVASP ASPDEV(" + name + ") ACTION(*CREATE) TYPE(" + asp_type + ") " if asp_type == "*SECONDARY": command = command + "PRIASPDEV(" + primary_asp + ") " command = command + "UNITS(" + " ".join( disks) + ") CONFIRM(*NO) " + extra_parameters else: rc = ibmi_util.IBMi_COMMAND_RC_ERROR out = "ASP " + name + " already exsit." error = out elif operation == "add_disks": if not state: rc = ibmi_util.IBMi_COMMAND_RC_ERROR out = "ASP " + name + " does not exsit" error = out else: command = "CALL PGM(QSYS/QAENGADDDU) PARM('{p_name}' '{p_asp_number}' '0' ".format( p_name=ibmi_util.fmtTo10(name), p_asp_number=asp_number) for disk in disks: command = command + "'" + ibmi_util.fmtTo10(disk) + "' " command = command + ")" elif operation == "delete": if state: command = "QSYS/CFGDEVASP ASPDEV(" + name + ") ACTION(*DELETE) CONFIRM(*NO)" else: rc = ibmi_util.IBMi_COMMAND_RC_ERROR out = "ASP " + name + " already deleted." elif operation == 'display': if state: rc = ibmi_util.IBMi_COMMAND_RC_SUCCESS out = rc_msg else: rc = ibmi_util.IBMi_COMMAND_RC_ERROR out = "ASP " + name + " does not exsit." error = out if command: if not synchronous: command = "SBMJOB CMD(" + command + ")" rc, out, error, job_log = ibmi_module.itoolkit_run_command_once( command) endd = datetime.datetime.now() delta = endd - startd result = dict( cmd=command, stdout=out, stderr=error, asp_info=asp_info, rc=rc, start=str(startd), end=str(endd), delta=str(delta), job_log=job_log, ) if rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS: module.fail_json(msg='non-zero return code', **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( product=dict(type='str', required=True), option=dict(type='str', default='*ALL'), release=dict(type='str', default='*ONLY'), language=dict(type='str', default='*ALL'), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) product = module.params['product'].upper() option = module.params['option'].upper() release = module.params['release'].upper() language = module.params['language'].upper() joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] if len(product) > 7: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of product exceeds 7 characters") if len(option) > 4: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of option exceeds 4 characters") if len(release) > 6: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of release exceeds 6 characters") if len(language) > 4: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of language exceeds 4 characters") try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) command = 'QSYS/DLTLICPGM LICPGM({pattern_product}) \ OPTION({pattern_option}) RLS({pattern_release}) LNG({pattern_language})'.format( pattern_product=product, pattern_option=option, pattern_release=release, pattern_language=language) command = ' '.join(command.split()) # keep only one space between adjacent strings rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) result = dict( command=command, stdout=out, stderr=err, rc=rc, job_log=job_log, changed=True, ) if rc != 0: message = 'non-zero return code:{rc}'.format(rc=rc) module.fail_json(msg=message, **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( src=dict(type='path', required=True), asp_group=dict(type='str', default='*SYSBAS'), severity_level=dict(type='int', default=10), type=dict(type='str', required=True, choices=['CL', 'SQL']), parameters=dict(type='str', default=' '), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) result = dict( stdout='', stderr='', rc=0, delta='', job_log=[] ) try: src = module.params['src'] type = module.params['type'] severity_level = module.params['severity_level'] asp_group = module.params['asp_group'].strip().upper() parameters = module.params['parameters'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] startd = datetime.datetime.now() try: ibmi_module = imodule.IBMiModule( db_name=asp_group, become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) src = os.path.realpath(src) if not os.path.isfile(src): return_error(module, ibmi_module, "src {p_src} doesn't exist.".format(p_src=src), '', startd, result) f = open(src, "r") if not f: return_error(module, ibmi_module, "Can't open src {p_src}.".format(p_src=src), '', startd, result) command = '' if type == 'CL': for line in f: line_command = line.strip() if line_command != '': if not line_command.endswith(":"): command = command + line_command + ' ' else: if line_command.endswith(":"): command = command + line_command[:-1] else: command = command + line_command rc, out, error = ibmi_module.itoolkit_run_command(command) if rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS: break command = '' elif command != '': rc, out, error = ibmi_module.itoolkit_run_command(command) if rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS: break command = '' if command != '': rc, out, error = ibmi_module.itoolkit_run_command(command) ibmi_util.log_debug("run command: " + command, module._name) else: command = "QSYS/RUNSQLSTM SRCSTMF('{p_src}') ERRLVL({p_severity_level}) {p_parameters}".format( p_src=src, p_severity_level=severity_level, p_parameters=parameters) rc, out, error = ibmi_module.itoolkit_run_command(command) ibmi_util.log_debug("RUNSQLSTM: " + command, module._name) if rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS: return_error(module, ibmi_module, "Execute sql statement file {p_command} failed. err: \n {p_err}".format( p_command=command, p_err=error), out, startd, result) endd = datetime.datetime.now() delta = endd - startd if rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS: return_error(module, ibmi_module, "Execute command {p_command} failed. err: {p_err}".format( p_command=command, p_err=error), out, startd, result) result['stdout'] = "Successfully execute script file." result.update({'rc': rc, 'delta': str(delta)}) module.exit_json(**result) except Exception as e: result.update({'rc': ibmi_util.IBMi_COMMAND_RC_ERROR, 'stderr': "Unexpected exception happens. error: {p_to_text}. Use -vvv for more information.".format( p_to_text=to_text(e))}) module.fail_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( product=dict(type='str', required=True), option=dict(type='str', default='*BASE'), object_type=dict(type='str', default='*ALL', choices=['*ALL', '*PGM', '*LNG']), language=dict(type='str', default='*PRIMARY'), release=dict(type='str', default='*ONLY'), target_release=dict(type='str', default='*CURRENT'), savf_name=dict(type='str', required=True), savf_library=dict(type='str', required=True), check_signature=dict(type='str', default='*SIGNED', choices=['*SIGNED', '*ALL', '*NONE']), joblog=dict(type='bool', default=False), parameters=dict(type='str', default=' '), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) product = module.params['product'].upper() option = module.params['option'].upper() object_type = module.params['object_type'].upper() language = module.params['language'].upper() release = module.params['release'].upper() target_release = module.params['target_release'].upper() savf_name = module.params['savf_name'].upper() savf_library = module.params['savf_library'].upper() parameters = module.params['parameters'].upper() check_signature = module.params['check_signature'].upper() joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] if len(product) > 7: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of product exceeds 7 characters") if len(option) > 5: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of option exceeds 5 characters") if len(release) > 6: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of release exceeds 6 characters") if len(target_release) > 8: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of target_release exceeds 8 characters") if len(language) > 8: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of language exceeds 8 characters") if len(savf_name) > 10: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of savf_name exceeds 10 characters") if len(savf_library) > 10: module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID, msg="Value of savf_library exceeds 10 characters") try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) # Check if the library of savf is existed command = 'QSYS/CHKOBJ OBJ(QSYS/{pattern_savf_library}) OBJTYPE(*LIB)'.format( pattern_savf_library=savf_library.strip()) ibmi_util.log_info("Command to run: " + command, module._name) rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) if rc != 0: # library not exist, create it command = "QSYS/CRTLIB LIB({pattern_savf_library}) TEXT('Create by Ansible')".format( pattern_savf_library=savf_library.strip()) ibmi_util.log_info("Command to run: " + command, module._name) rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) if rc != 0: # fail to create library result = dict( command=command, stdout=out, stderr=err, rc=rc, job_log=job_log, ) module.fail_json( msg="Fail to create library: {pattern_savf_library}".format( pattern_savf_library=savf_library.strip()), **result) # library exist, now check if the savf is existed command = 'QSYS/CHKOBJ OBJ({pattern_savf_library}/{pattern_savf_name}) OBJTYPE(*FILE)'.format( pattern_savf_name=savf_name.strip(), pattern_savf_library=savf_library.strip()) # Check if the savf is existed ibmi_util.log_info("Command to run: " + command, module._name) rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) if rc != 0: # savf not existed command = "QSYS/CRTSAVF FILE({pattern_savf_library}/{pattern_savf_name}) TEXT('Create by Ansible')".format( pattern_savf_name=savf_name.strip(), pattern_savf_library=savf_library.strip()) ibmi_util.log_info("Command to run: " + command, module._name) rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) if rc != 0: # fail to create savf result = dict( command=command, stdout=out, stderr=err, rc=rc, job_log=job_log, ) module.fail_json( msg= "Fail to create savf {pattern_savf_name} in library {pattern_savf_library}" .format(pattern_savf_name=savf_name.strip(), pattern_savf_library=savf_library.strip()), **result) # run the SAVLICPGM command to save the product objects to the savf command = 'QSYS/SAVLICPGM LICPGM({pattern_product}) DEV(*SAVF) OPTION({pattern_option}) RLS({pattern_release}) \ LNG({pattern_language}) OBJTYPE({pattern_object_type}) SAVF({pattern_savf_library}/{pattern_savf_name}) \ TGTRLS({pattern_target_release}) CHKSIG({pattern_check_signature}) CLEAR(*ALL) {pattern_parameters}'.format( pattern_product=product, pattern_option=option, pattern_release=release, pattern_language=language, pattern_object_type=object_type, pattern_savf_library=savf_library.strip(), pattern_savf_name=savf_name.strip(), pattern_check_signature=check_signature, pattern_target_release=target_release, pattern_parameters=parameters) command = ' '.join( command.split()) # keep only one space between adjacent strings rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) result = dict( command=command, stdout=out, stderr=err, rc=rc, job_log=job_log, changed=True, ) if rc != 0: result = dict( command=command, stderr=err, job_log=job_log, rc=rc, ) message = 'non-zero return code:{rc}'.format(rc=rc) module.fail_json(msg=message, **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict(sql=dict(type='str', required=True), database=dict(type='str', default='/tmp/testdb.sqlite3'), parameters=dict(type='list', elements='dict')), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) sql = module.params['sql'].strip() database = module.params['database'].strip() parameters = module.params['parameters'] result = dict( sql=sql, database=database, sqlite3Version=sqlite3.version, sqlite3Runtime=sqlite3.sqlite_version, ) if parameters is not None: result['parameters'] = parameters startd = datetime.datetime.now() try: conn = sqlite3.connect(database) except sqlite3.Error as e: module.fail_json(msg=e.args[0], **result) if (conn is not None): c = conn.cursor() try: # multiple input parameters provided. if isinstance(parameters, list): if len(parameters) > 1: # for better performance c.executemany(sql, parameters) elif len( parameters ) == 1: # cannot execute SELECT statements in executemany() c.execute(sql, parameters[0]) else: # no input parameters provided. c.execute(sql) except sqlite3.Error as e: module.fail_json(msg=e.args[0], **result) else: result['row_changed'] = c.rowcount rows = c.fetchall() if len(rows) > 0: result['rows'] = rows conn.commit() finally: conn.close() endd = datetime.datetime.now() delta = endd - startd result['start'] = str(startd) result['end'] = str(endd) result['delta'] = str(delta) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( name_list=dict(type='list', elements='str', required=True), state=dict(type='str', choices=['started', 'stopped'], required=True), extra_parameters=dict(type='str', default=' '), joblog=dict(type='bool', default=False), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) name_list = module.params['name_list'] state = module.params['state'] extra_parameters = module.params['extra_parameters'] joblog = module.params['joblog'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] startd = datetime.datetime.now() if state == 'started': command = IBMi_STRSVR + " SERVER(" + " ".join( i for i in name_list) + ") " + extra_parameters if state == 'stopped': command = IBMi_ENDSVR + " SERVER(" + " ".join( i for i in name_list) + ") " + extra_parameters if set(name_list) < set(IBMi_TCP_SERVER_LIST): # this is expected pass else: rc = ibmi_util.IBMi_PARAM_NOT_VALID result_failed_parameter_check = dict( # size=input_size, # age=input_age, # age_stamp=input_age_stamp, stderr="Parameter passed is not valid. ", rc=rc, command=command, # changed=True, ) module.fail_json( msg='Value specified for name_list is not valid. Valid values are ' + ", ".join(i for i in IBMi_TCP_SERVER_LIST), **result_failed_parameter_check) try: ibmi_module = imodule.IBMiModule( become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) job_log = [] rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command) endd = datetime.datetime.now() delta = endd - startd result = dict( cmd=command, job_log=job_log, stdout=out, stderr=err, rc=rc, start=str(startd), end=str(endd), delta=str(delta), ) if rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS: module.fail_json(msg='non-zero return code', **result) if not joblog: empty_list = [] result.update({'job_log': empty_list}) module.exit_json(**result)
def main(): module = AnsibleModule( argument_spec=dict( section=dict(type='str', required=True, choices=['log_config', 'dump']), config_dir=dict(type='str', default='home', choices=['etc', 'home']), log_level=dict( type='str', default='info', choices=['debug', 'info', 'warning', 'error', 'critical']), no_log=dict(type='bool', default=False), log_file=dict(type='str', default='ibmi_ansible_modules.log'), log_dir=dict(type='str', default='/var/log'), max_log_size_mb=dict(type='int', default=5), ), supports_check_mode=True, ) # Do not log the version since there may be no log configurations # ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) section = module.params['section'] config_dir = module.params['config_dir'] log_level = module.params['log_level'] no_log = module.params['no_log'] log_file = module.params['log_file'] log_dir = module.params['log_dir'] max_log_size_mb = module.params['max_log_size_mb'] # When this module supports another section, update the default settings dict default_settings = dict( time='notset', log_config=dict( no_log=False, log_dir=ibmi_util.IBMi_DEFAULT_LOG_DIR, log_file=ibmi_util.IBMi_DEFAULT_LOG_FILE, log_level=ibmi_util.IBMi_DEFAULT_LOG_LEVEL_STR, max_log_size_mb=int(ibmi_util.IBMi_DEFAULT_MAX_LOG_SIZE / float(1024 * 1024)))) if section == 'dump': try: home_log_config_dir = os.getenv('HOME', '') home_log_config_file_path = home_log_config_dir + \ "/" + ibmi_util.IBMi_ANSIBLE_CONFIG_FILE etc_log_config_dir = '/etc/ansible' etc_log_config_file_path = etc_log_config_dir + \ "/" + ibmi_util.IBMi_ANSIBLE_CONFIG_FILE if os.path.exists(home_log_config_file_path): with open(home_log_config_file_path, 'r') as load_f: load_dict = json.load(load_f) config_path = home_log_config_file_path elif os.path.exists(etc_log_config_file_path): with open(etc_log_config_file_path, 'r') as load_f: load_dict = json.load(load_f) config_path = etc_log_config_file_path else: config_path = '*** There is no configuration file either in home or /etc/ansible directory, using default settings ***' load_dict = default_settings module.exit_json( rc=0, version=__ibmi_module_version__, settings=load_dict, msg= "Success to dump IBMi Ansible module settings, config file = {0}" .format(config_path)) except Exception as e: module.fail_json( rc=255, version=__ibmi_module_version__, msg="Error occurred when dump IBMi Ansible module settings: {0}" .format(str(e))) try: mode = 0o0755 ibmi_util.ensure_dir(log_dir, mode) except Exception as e: module.fail_json( rc=255, version=__ibmi_module_version__, msg="Error occurred when create IBMi Ansible log directory: {0}, {1}" .format(log_dir, str(e))) if not os.access(log_dir, os.W_OK): module.fail_json( rc=255, version=__ibmi_module_version__, msg= "Current user write permission denied for IBMi Ansible log directory: {0}" .format(log_dir)) if config_dir == 'home': log_config_dir = os.getenv('HOME', ibmi_util.IBMi_DEFAULT_CONFIG_DIR) else: log_config_dir = ibmi_util.IBMi_DEFAULT_CONFIG_DIR try: mode = 0o0755 ibmi_util.ensure_dir(log_config_dir, mode) except Exception as e: module.fail_json( rc=255, version=__ibmi_module_version__, msg= "Error occurred when create IBMi Ansible configuration directory: {0}, {1}" .format(log_config_dir, str(e))) if not os.access(log_config_dir, os.W_OK): module.fail_json( rc=255, version=__ibmi_module_version__, msg= "Current user write permission denied for IBMi Ansible configuration directory: {0}" .format(log_config_dir)) config_dict = default_settings config_dict['time'] = str(datetime.datetime.now()) config_dict[section]['no_log'] = no_log config_dict[section]['log_dir'] = log_dir config_dict[section]['log_file'] = log_file config_dict[section]['log_level'] = log_level.upper() config_dict[section]['max_log_size_mb'] = max_log_size_mb try: log_config_file_path = os.path.join(log_config_dir, ibmi_util.IBMi_ANSIBLE_CONFIG_FILE) with open(log_config_file_path, 'w') as dump_f: json.dump(config_dict, dump_f) mode = 0o0644 os.chmod(log_config_file_path, mode) except Exception as e: module.fail_json( rc=255, version=__ibmi_module_version__, msg= "Error occurred when create IBMi Ansible configuration file: {0}, {1}" .format(log_config_file_path, str(e))) if log_config_dir == ibmi_util.IBMi_DEFAULT_CONFIG_DIR: try: os.chown(log_config_dir, pwd.getpwnam('QSYS').pw_uid, -1) os.chown(log_config_file_path, pwd.getpwnam('QSYS').pw_uid, -1) except Exception as e: ibmi_util.log_info("chown to QSYS error: " + str(e), module._name) module.exit_json(rc=0, version=__ibmi_module_version__, msg="Success to configure IBMi Ansible module settings")
def main(): module = AnsibleModule( argument_spec=dict( saved_lib=dict(type='str', required=True), savefile_name=dict(type='str', required=True), savefile_lib=dict(type='str', required=True), format=dict(type='str', default='*SAVF', choices=['*SAVF']), joblog=dict(type='bool', default=False), asp_group=dict(type='str', default='*SYSBAS'), parameters=dict(type='str', default=' '), become_user=dict(type='str'), become_user_password=dict(type='str', no_log=True), ), supports_check_mode=True, ) ibmi_util.log_info("version: " + __ibmi_module_version__, module._name) saved_lib = module.params['saved_lib'] savefile_name = module.params['savefile_name'] savefile_lib = module.params['savefile_lib'] format = module.params['format'] joblog = module.params['joblog'] asp_group = module.params['asp_group'].strip().upper() parameters = module.params['parameters'] become_user = module.params['become_user'] become_user_password = module.params['become_user_password'] startd = datetime.datetime.now() # RSTLIB command = 'QSYS/RSTLIB SAVLIB({p_saved_lib}) DEV({p_format}) SAVF({p_savefile_lib}/{p_savefile_name}) \ {p_parameters}'.format(p_saved_lib=saved_lib, p_format=format, p_savefile_lib=savefile_lib, p_savefile_name=savefile_name, p_parameters=parameters) try: ibmi_module = imodule.IBMiModule( db_name=asp_group, become_user_name=become_user, become_user_password=become_user_password) except Exception as inst: message = 'Exception occurred: {0}'.format(str(inst)) module.fail_json(rc=999, msg=message) rc, out, error, job_log = ibmi_module.itoolkit_run_command_once(' '.join( command.split())) endd = datetime.datetime.now() delta = endd - startd result = dict( saved_lib=saved_lib, savefile_name=savefile_name, savefile_lib=savefile_lib, format=format, command=' '.join(command.split()), job_log=job_log if joblog or rc else [], stdout=out, stderr=error, rc=rc, start=str(startd), end=str(endd), delta=str(delta), ) if rc != ibmi_util.IBMi_COMMAND_RC_SUCCESS: module.fail_json(msg='non-zero return code', **result) module.exit_json(**result)