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(
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 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 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(
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(
subsystem=dict(type='str', default='*ALL'),
user=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)
subsystem = module.params['subsystem'].strip().upper()
user = module.params['user'].strip().upper()
joblog = module.params['joblog']
if len(subsystem) > 10:
module.fail_json(rc=256, msg="Value of subsystem exceeds 10 characters")
if len(user) > 10:
module.fail_json(rc=256, msg="Value of user exceeds 10 characters")
if subsystem == '*JOBQ' or subsystem == '*OUTQ':
module.fail_json(rc=256, msg="Value of option subsystem can not be {subsystem_pattern}".format(subsystem_pattern=subsystem))
become_user = module.params['become_user']
become_user_password = module.params['become_user_password']
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 = []
if subsystem == '*ALL':
command = 'QSYS/WRKSBS'
rc, out, err, job_log = ibmi_module.itoolkit_run_command5250_once(command)
if rc:
result_failed = dict(
stdout=out,
stderr=err,
job_log=job_log,
rc=rc,
)
message = 'non-zero return code:{rc}'.format(
rc=rc)
module.fail_json(msg=message, **result_failed)
else:
result_success = dict(
subsystems=out.splitlines(),
job_log=job_log,
rc=rc,
)
if not joblog:
empty_list = []
result_success.update({'job_log': empty_list})
module.exit_json(**result_success)
else:
sql = "SELECT J.SUBSYSTEM FROM TABLE (QSYS2.ACTIVE_JOB_INFO()) J WHERE JOB_TYPE = 'SBS'"
ibmi_util.log_info("Command to run: " + sql, module._name)
rc, out, err, job_log = ibmi_module.itoolkit_run_sql_once(sql)
if rc:
result_failed = dict(
stdout=out,
stderr=err,
job_log=job_log,
rc=rc,
)
message = 'Failed to retrieve subsystem {subsystem_pattern} status, non-zero return code:{rc}'.format(
subsystem_pattern=subsystem, rc=rc)
module.fail_json(msg=message, **result_failed)
else:
is_active = False
for items in out:
if subsystem == items['SUBSYSTEM']:
is_active = True
if not is_active:
module.fail_json(rc=ibmi_util.IBMi_SUBSYSTEM_NOT_ACTIVE, msg="Subsystem {0} is not active".format(subsystem))
if user == '*ALL':
sql = "SELECT J.* FROM TABLE (QSYS2.ACTIVE_JOB_INFO(SUBSYSTEM_LIST_FILTER => '{subsystem_pattern}')) J \
WHERE JOB_TYPE NOT IN ('SBS', 'SYS')".format(subsystem_pattern=subsystem)
else:
sql = "SELECT J.* FROM TABLE (QSYS2.ACTIVE_JOB_INFO(\
SUBSYSTEM_LIST_FILTER => '{subsystem_pattern}', \
CURRENT_USER_LIST_FILTER => '{user_pattern}')) J WHERE JOB_TYPE NOT IN ('SBS', 'SYS')".format(
subsystem_pattern=subsystem, user_pattern=user)
ibmi_util.log_info("Command to run: " + sql, module._name)
rc, out, err, job_log = ibmi_module.itoolkit_run_sql_once(sql)
if rc:
result_failed = dict(
stdout=out,
stderr=err,
job_log=job_log,
rc=rc,
)
message = 'non-zero return code:{rc}'.format(
rc=rc)
module.fail_json(msg=message, **result_failed)
else:
result_success = dict(
active_jobs=out,
job_log=job_log,
rc=rc,
)
if not joblog:
empty_list = []
result_success.update({'job_log': empty_list})
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(
operation=dict(type='str',
choices=[
'grant', 'revoke', 'display', 'grant_autl',
'revoke_autl', 'grant_ref'
],
required=True),
object_name=dict(type='str', required=True),
object_library=dict(type='str', default='*LIBL'),
object_type=dict(
type='str',
choices=[
'*ALL', '*ALRTBL', '*BNDDIR', '*CFGL', '*CHTFMT', '*CLD',
'*CLS', '*CMD', '*CNNL', '*COSD', '*CRG', '*CRQD', '*CSI',
'*CSPMAP', '*CSPTBL', '*CTLD', '*DEVD', '*DTAARA',
'*DTADCT', '*DTAQ', '*EDTD', '*FCT', '*FILE', '*FNTRSC',
'*FNTTBL', '*FORMDF', '*FTR', '*GSS', '*IGCDCT', '*IGCSRT',
'*IGCTBL', '*IMGCLG', '*IPXD', '*JOBD', '*JOBQ', '*JOBSCD',
'*JRN', '*JRNRCV', '*LIB', '*LIND', '*LOCALE', '*M36',
'*M36CFG', '*MEDDFN', '*MENU', '*MGTCOL', '*MODD',
'*MODULE', '*MSGF', '*MSGQ', '*NODGRP', '*NODL', '*NTBD',
'*NWID', '*NWSCFG', '*NWSD', '*OUTQ', '*OVL', '*PAGDFN',
'*PAGSEG', '*PDFMAP', '*PDG', '*PGM', '*PNLGRP', '*PRDAVL',
'*PRDDFN', '*PRDLOD', '*PSFCFG', '*QMFORM', '*QMQRY',
'*QRYDFN', '*RCT', '*S36', '*SBSD', '*SCHIDX', '*SPADCT',
'*SQLPKG', '*SQLUDT', '*SQLXSR', '*SRVPGM', '*SSND',
'*SVRSTG', '*TBL', '*TIMZON', '*USRIDX', '*USRPRF',
'*USRQ', '*USRSPC', '*VLDL', '*WSCST'
],
required=True),
asp_device=dict(type='str', default='*'),
user=dict(type='list', default=[''], elements='str'),
authority=dict(type='list',
default=['*CHANGE'],
choices=[
'*CHANGE', '*ALL', '*USE', '*EXCLUDE', '*AUTL',
'*OBJALTER', '*OBJEXIST', '*OBJMGT', '*OBJOPR',
'*OBJREF', '*ADD', '*DLT', '*READ', '*UPD',
'*EXECUTE'
],
elements='str'),
replace_authority=dict(type='bool', default=False),
authorization_list=dict(type='str', default=''),
ref_object_name=dict(type='str', default=''),
ref_object_library=dict(type='str', default='*LIBL'),
ref_object_type=dict(
type='str',
choices=[
'*OBJTYPE', '*ALRTBL', '*AUTL', '*BNDDIR', '*CFGL',
'*CHTFMT', '*CLD', '*CLS', '*CMD',
'*CNNL', '*COSD', '*CRG', '*CRQD', '*CSI', '*CSPMAP',
'*CSPTBL', '*CTLD', '*DEVD', '*DTAARA', '*DTADCT', '*DTAQ',
'*EDTD', '*FCT', '*FILE', '*FNTRSC', '*FNTTBL', '*FORMDF',
'*FTR', '*GSS', '*IGCDCT', '*IGCSRT', '*IGCTBL', '*IMGCLG',
'*IPXD', '*JOBD', '*JOBQ', '*JOBSCD', '*JRN', '*JRNRCV',
'*LIB', '*LIND', '*LOCALE', '*M36', '*M36CFG', '*MEDDFN',
'*MENU', '*MGTCOL', '*MODD', '*MODULE', '*MSGF', '*MSGQ',
'*NODGRP', '*NODL', '*NTBD', '*NWID', '*NWSCFG', '*NWSD',
'*OUTQ', '*OVL', '*PAGDFN', '*PAGSEG', '*PDFMAP', '*PDG',
'*PGM', '*PNLGRP', '*PRDDFN', '*PRDLOD', '*PSFCFG',
'*QMFORM', '*QMQRY', '*QRYDFN', '*RCT', '*S36', '*SBSD',
'*SCHIDX', '*SPADCT', '*SQLPKG', '*SQLUDT', '*SQLXSR',
'*SRVPGM', '*SSND', '*SVRSTG', '*TBL', '*TIMZON',
'*USRIDX', '*USRPRF', '*USRQ', '*USRSPC', '*VLDL', '*WSCST'
],
default='*OBJTYPE'),
ref_asp_device=dict(type='str', default='*'),
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),
),
required_if=[
['operation', 'grant', ['object_name', 'user', 'authority']],
['operation', 'revoke', ['object_name', 'user', 'authority']],
['operation', 'display', ['object_name']],
['operation', 'grant_autl', ['object_name', 'authorization_list']],
[
'operation', 'revoke_autl',
['object_name', 'authorization_list']
], ['operation', 'grant_ref', ['object_name', 'ref_object_name']]
],
supports_check_mode=True,
)
ibmi_util.log_info("version: " + __ibmi_module_version__, module._name)
operation = module.params['operation'].strip().upper()
object_name = module.params['object_name'].strip().upper()
if len(object_name) > 10:
module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Value of object_name exceeds 10 characters")
object_library = module.params['object_library'].strip().upper()
if len(object_library) > 10:
module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Value of object_library exceeds 10 characters")
object_type = module.params['object_type'].strip().upper()
asp_device = module.params['asp_device'].strip().upper()
if len(asp_device) > 10:
module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Value of asp_device exceeds 10 characters")
user = module.params['user']
user = [item.strip().upper() for item in user]
for item in user:
if len(item) > 10:
module.fail_json(
rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Value of {p_item} in option user exceeds 10 characters".
format(p_item=item))
authority = module.params['authority']
authority = [item.strip().upper() for item in authority]
for item in authority:
if len(item) > 10:
module.fail_json(
rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Value of {p_item} in option authority exceeds 10 characters"
.format(p_item=item))
replace_authority = module.params['replace_authority']
authorization_list = module.params['authorization_list'].strip().upper()
if len(authorization_list) > 10:
module.fail_json(
rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Value of authorization_list exceeds 10 characters")
ref_object_name = module.params['ref_object_name'].strip().upper()
if len(ref_object_name) > 10:
module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Value of ref_object_name exceeds 10 characters")
ref_object_library = module.params['ref_object_library'].strip().upper()
if len(ref_object_library) > 10:
module.fail_json(
rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Value of ref_object_library exceeds 10 characters")
ref_object_type = module.params['ref_object_type'].strip().upper()
ref_asp_device = module.params['ref_asp_device'].strip().upper()
if len(ref_asp_device) > 10:
module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Value of ref_asp_device exceeds 10 characters")
asp_group = module.params['asp_group'].strip().upper()
if len(asp_group) > 10:
module.fail_json(rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Value of asp_group exceeds 10 characters")
joblog = module.params['joblog']
become_user = module.params['become_user']
become_user_password = module.params['become_user_password']
if operation == 'GRANT' or operation == 'REVOKE':
# handle single value for user
if isinstance(user, list) and len(user) > 1 and ('*PUBLIC' in user
or '*ALL' in user):
module.fail_json(
rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="*PUBLIC or *ALL must be only value for parameter user")
# handle single value or other values for authority
if isinstance(authority, list) and len(authority) > 1:
single_value = ['*CHANGE', '*ALL', '*USE', '*EXCLUDE', '*AUTL']
for item in single_value:
if item in authority:
module.fail_json(
rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="{p_item} must be only value for parameter authority"
.format(p_item=item))
# handle the relateionship of *PUBLIC and *AUTL
if isinstance(authority, list) and len(authority) == 1 and authority[
0] == '*AUTL' and user[0] != '*PUBLIC':
module.fail_json(
rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Authority of *AUTL is allowed only with user *PUBLIC")
# handle the REPLACE option
replace = '*NO'
if replace_authority:
replace = '*YES'
# handle parameter user
users = ''
for item in user:
users = users + ' ' + item
if users.strip() == '':
module.fail_json(
rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Specify user when the operation is grant or revoke")
# handle parameter authority
authorities = ''
for item in authority:
authorities = authorities + ' ' + item
if operation == 'GRANT_REF' and ref_object_type == '*OBJTYPE' and object_type == '*ALL':
module.fail_json(
rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg=
"ref_object_type(*OBJTYPE) and object_type(*ALL) cannot be used together"
)
if operation == 'GRANT_REF' and ref_object_name == '':
module.fail_json(
rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg="Specify ref_object_name when the operation is grant_ref")
if (operation == 'GRANT_AUTL'
or operation == 'REVOKE_AUTL') and authorization_list == '':
module.fail_json(
rc=ibmi_util.IBMi_PARAM_NOT_VALID,
msg=
"Specify authorization_list when the operation is grant_autl or revoke_autl"
)
if operation == 'GRANT':
command = 'QSYS/GRTOBJAUT OBJ({p_lib}/{p_obj}) \
OBJTYPE({p_type}) ASPDEV({p_asp}) USER({p_user}) \
AUT({p_aut}) REPLACE({p_rep})'.format(p_lib=object_library,
p_obj=object_name,
p_type=object_type,
p_asp=asp_device,
p_user=users,
p_aut=authorities,
p_rep=replace)
elif operation == 'REVOKE':
command = 'QSYS/RVKOBJAUT OBJ({p_lib}/{p_obj}) \
OBJTYPE({p_type}) ASPDEV({p_asp}) USER({p_user}) \
AUT({p_aut})'.format(p_lib=object_library,
p_obj=object_name,
p_type=object_type,
p_asp=asp_device,
p_user=users,
p_aut=authorities)
elif operation == 'GRANT_AUTL':
command = 'QSYS/GRTOBJAUT OBJ({p_lib}/{p_obj}) \
OBJTYPE({p_type}) ASPDEV({p_asp}) \
AUTL({p_autl})'.format(p_lib=object_library,
p_obj=object_name,
p_type=object_type,
p_asp=asp_device,
p_autl=authorization_list)
elif operation == 'REVOKE_AUTL':
command = 'QSYS/RVKOBJAUT OBJ({p_lib}/{p_obj}) \
OBJTYPE({p_type}) ASPDEV({p_asp}) \
AUTL({p_autl})'.format(p_lib=object_library,
p_obj=object_name,
p_type=object_type,
p_asp=asp_device,
p_autl=authorization_list)
elif operation == 'GRANT_REF':
command = 'QSYS/GRTOBJAUT OBJ({p_lib}/{p_obj}) \
OBJTYPE({p_type}) ASPDEV({p_asp}) \
REFOBJ({p_ref_lib}/{p_ref_obj}) REFOBJTYPE({p_ref_type}) \
REFASPDEV({p_ref_asp})'.format(p_lib=object_library,
p_obj=object_name,
p_type=object_type,
p_asp=asp_device,
p_ref_lib=ref_object_library,
p_ref_obj=ref_object_name,
p_ref_type=ref_object_type,
p_ref_asp=ref_asp_device)
else:
command = "SELECT * FROM QSYS2.OBJECT_PRIVILEGES WHERE SYSTEM_OBJECT_NAME = '{p_obj}'".format(
p_obj=object_name)
if (object_library != '') and (not object_library.startswith('*')):
command = command + ' ' + "AND SYSTEM_OBJECT_SCHEMA = '{p_lib}'".format(
p_lib=object_library)
if object_type != '*ALL':
command = command + ' ' + "AND OBJECT_TYPE = '{p_type}'".format(
p_type=object_type)
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)
if asp_group or operation == 'DISPLAY':
if operation != 'DISPLAY':
command = ' '.join(command.split(
)) # keep only one space between adjacent strings
rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(
command)
else:
command = ' '.join(command.split(
)) # keep only one space between adjacent strings
rc, out, err, job_log = ibmi_module.itoolkit_run_sql_once(command)
else:
rc, out, err, job_log = ibmi_module.itoolkit_run_command_once(command)
if operation == 'DISPLAY':
if rc:
result_failed = dict(
stdout=out,
stderr=err,
command=command,
job_log=job_log,
rc=rc,
)
message = 'non-zero return code:{rc}'.format(rc=rc)
module.fail_json(msg=message, **result_failed)
else:
result_success = dict(
object_authority_list=out,
command=command,
job_log=job_log,
rc=rc,
)
if not joblog:
empty_list = []
result_success.update({'job_log': empty_list})
module.exit_json(**result_success)
else:
if rc:
result_failed = 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_failed)
else:
result_success = dict(
command=command,
stdout=out,
rc=rc,
job_log=job_log,
changed=True,
)
if not joblog:
empty_list = []
result_success.update({'job_log': empty_list})
module.exit_json(**result_success)
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(
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(
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(
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(
age=dict(default=None, type='str'),
age_stamp=dict(default="ctime", choices=['ctime'], type='str'),
object_type_list=dict(type='str', default='*ALL'),
lib_name=dict(type='str', default='*ALLUSR'),
object_name=dict(type='str', default='*ALL'),
size=dict(default=None, type='str'),
iasp_name=dict(type='str', default='*SYSBAS'),
use_regex=dict(default=False, type='bool'),
joblog=dict(type='bool', default=False),
become_user=dict(type='str'),
become_user_password=dict(type='str', no_log=True),
),
supports_check_mode=True,
)
input_age = module.params['age']
input_age_stamp = module.params['age_stamp']
input_object_type = module.params['object_type_list']
input_iasp_name = module.params['iasp_name']
input_size = module.params['size']
input_lib = module.params['lib_name']
input_obj_name = module.params['object_name']
input_use_regex = module.params['use_regex']
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=input_iasp_name,
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)
db_conn = ibmi_module.get_connection()
# generate age where stmt
if input_age is None:
# age = None
sql_where_stmt_age = ''
else:
sql_where_stmt_age = age_where_stmt(input_age, input_age_stamp)
if sql_where_stmt_age is None:
module.fail_json(msg="failed to process age: " + input_age)
# generate size where stmt
if input_size is None:
sql_where_stmt_size = ''
else:
sql_where_stmt_size = size_where_stmt(input_size)
if sql_where_stmt_size is None:
module.fail_json(msg="failed to process size: " + input_size)
# get the version and release info
release_info, err = db2i_tools.get_ibmi_release(db_conn)
if release_info["version_release"] < 7.4:
lib_name_label = "(SELECT SYSTEM_SCHEMA_NAME FROM QSYS2.SYSSCHEMAS WHERE SCHEMA_NAME = OBJLONGSCHEMA)"
else:
lib_name_label = "OBJLIB"
if input_use_regex:
obj_stats_expression = " SELECT OBJNAME, OBJTYPE, OBJOWNER, OBJDEFINER, OBJCREATED," \
" TEXT, " + lib_name_label + " AS OBJLIB, IASP_NUMBER, LAST_USED_TIMESTAMP, " \
" LAST_RESET_TIMESTAMP," \
" BIGINT(OBJSIZE) AS OBJSIZE, OBJATTRIBUTE, OBJLONGSCHEMA " \
" FROM TABLE (QSYS2.OBJECT_STATISTICS('" + input_lib + "','" + \
input_object_type + "','*ALL')) X "
sql_where_stmt_regex = " AND REGEXP_LIKE(A.OBJNAME, '" + input_obj_name + "') "
else:
obj_stats_expression = " SELECT OBJNAME, OBJTYPE, OBJOWNER, OBJDEFINER, OBJCREATED," \
" TEXT, " + lib_name_label + " AS OBJLIB, IASP_NUMBER, LAST_USED_TIMESTAMP, " \
" LAST_RESET_TIMESTAMP," \
" BIGINT(OBJSIZE) AS OBJSIZE, OBJATTRIBUTE, OBJLONGSCHEMA " \
" FROM TABLE (QSYS2.OBJECT_STATISTICS('" + input_lib + "','" + \
input_object_type + "','" + input_obj_name + "')) X "
sql_where_stmt_regex = ""
sql = "select * from (" + obj_stats_expression + ") A WHERE 1 = 1 " + \
sql_where_stmt_age + \
sql_where_stmt_size + \
sql_where_stmt_regex
rc, out_result_set, err = ibmi_module.itoolkit_run_sql(sql)
if joblog or (rc != IBMi_COMMAND_RC_SUCCESS):
job_log = ibmi_module.itoolkit_get_job_log(startd)
else:
job_log = []
endd = datetime.datetime.now()
delta = endd - startd
if rc != IBMi_COMMAND_RC_SUCCESS:
result_failed = dict(
sql=sql,
# size=input_size,
# age=input_age,
job_log=job_log,
stderr=err,
rc=rc,
start=str(startd),
end=str(endd),
delta=str(delta),
# changed=True,
)
module.fail_json(msg='Non-zero return code. ', **result_failed)
else:
# out = []
# for result in out_result_set:
# result_map = {"OBJNAME": result[0], "OBJTYPE": result[1],
# "OBJOWNER": result[2], "OBJDEFINER": result[3],
# "OBJCREATED": result[4], "TEXT": result[5],
# "OBJLIB": result[6], "IASP_NUMBER": result[7],
# "LAST_USED_TIMESTAMP": result[8], "LAST_RESET_TIMESTAMP": result[9],
# "OBJSIZE": result[10], "OBJATTRIBUTE": result[11], "OBJLONGSCHEMA": result[12]
# }
# out.append(result_map)
result_success = dict(
sql=sql,
object_list=out_result_set,
rc=rc,
start=str(startd),
end=str(endd),
delta=str(delta),
job_log=job_log,
)
module.exit_json(**result_success)
def main():
module = AnsibleModule(
argument_spec=dict(
internet_address=dict(type='str', required=False),
line_description=dict(type='str', required=False),
vlan_id=dict(type='str', required=False),
subnet_mask=dict(type='str', required=False),
alias_name=dict(type='str', required=False),
associated_local_interface=dict(type='str', required=False),
type_of_service=dict(type='str',
required=False,
choices=[
"*NORMAL", "*MINDELAY", "*MAXTHRPUT",
"*MAXRLB", "*MINCOST"
]),
max_transmission_unit=dict(type='str', required=False),
auto_start=dict(type='str',
required=False,
choices=["*YES", "*NO"]),
preferred_interface=dict(type='list',
elements='str',
required=False),
text_description=dict(type='str', required=False),
sec_to_wait=dict(type='int', default=0),
extra_params=dict(type='str', required=False),
joblog=dict(type='bool', default=False),
become_user=dict(type='str'),
become_user_password=dict(type='str', no_log=True),
state=dict(type='str',
default='present',
choices=["present", "absent", "inactive", "active"])),
required_one_of=[["internet_address", "alias_name"]],
supports_check_mode=True,
)
internet_address = module.params['internet_address']
line_description = module.params['line_description']
vlan_id = module.params['vlan_id']
subnet_mask = module.params['subnet_mask']
alias_name = module.params['alias_name']
associated_local_interface = module.params['associated_local_interface']
type_of_service = module.params['type_of_service']
max_transmission_unit = module.params['max_transmission_unit']
auto_start = module.params['auto_start']
preferred_interface = module.params['preferred_interface']
text_description = module.params['text_description']
state = module.params['state']
extra_params = module.params['extra_params']
sec_to_wait = module.params['sec_to_wait']
joblog = module.params['joblog']
become_user = module.params['become_user']
become_user_password = module.params['become_user_password']
startd = datetime.datetime.now()
ibmi_module = imodule.IBMiModule(become_user_name=become_user,
become_user_password=become_user_password)
connection_id = ibmi_module.get_connection()
only_query = False
cl_command = ""
if state == "present":
# check options
opt_vlan_id = "" if vlan_id is None else vlan_id
opt_line_description = "" if line_description is None else "LIND(" + line_description + " " + opt_vlan_id + ") "
opt_subnet_mask = "" if subnet_mask is None else "SUBNETMASK('" + subnet_mask + "') "
opt_alias_name = "" if alias_name is None else "ALIASNAME(" + alias_name + ") "
opt_associate = "" if associated_local_interface is None else "LCLIFC(" + associated_local_interface + ") "
opt_type_of_service = "" if type_of_service is None else "TOS(" + type_of_service + ") "
opt_max_transmission_unit = "" if max_transmission_unit is None else "MTU(" + max_transmission_unit + ") "
opt_auto_start = "" if auto_start is None else "AUTOSTART(" + auto_start + ") "
opt_preferred_ifc = "" if preferred_interface is None else "PREFIFC('" + "' '".join(
preferred_interface) + "') "
opt_text_desc = "" if text_description is None else "TEXT('" + text_description + "') "
# options_without_alias_name = opt_line_description + opt_subnet_mask + \
# opt_associate + opt_type_of_service + \
# opt_max_transmission_unit + opt_auto_start + opt_preferred_ifc + opt_text_desc
options_without_alias_name = "{0}{1}{2}{3}{4}{5}{6}{7}".format(
opt_line_description, opt_subnet_mask, opt_associate,
opt_type_of_service, opt_max_transmission_unit, opt_auto_start,
opt_preferred_ifc, opt_text_desc)
options = options_without_alias_name + opt_alias_name
if (internet_address is not None) and (options == ""):
# nothing to add or change means to query
only_query = True
elif (opt_alias_name is not None) and (internet_address is None) and (
options_without_alias_name == ""):
only_query = True
else:
if internet_address is None:
module.fail_json(
msg="Parameter internet_address is not specified.")
# see if the ip address exists for present
rs, query_err = return_interface_information(
connection_id, internet_address, alias_name)
present_operation = "QSYS/ADDTCPIFC" if len(
rs) == 0 else "QSYS/CHGTCPIFC"
cl_command = present_operation + " INTNETADR('" + internet_address + "') " + options
elif state in ["absent", "active", "inactive"]:
interface_action_map = {
"absent": "QSYS/RMVTCPIFC",
"active": "QSYS/STRTCPIFC",
"inactive": "QSYS/ENDTCPIFC"
}
if internet_address is not None:
cl_command = interface_action_map[
state] + " INTNETADR('" + internet_address + "')"
elif (alias_name is not None) and (alias_name != '*NONE'):
cl_command = interface_action_map[
state] + " ALIASNAME(" + alias_name + ")"
else:
module.fail_json(
msg=
"internet_address or alias_name must be specified when state is"
" absent, active or inactive.")
check_rs, query_err = return_interface_information(
connection_id, internet_address, alias_name)
if len(check_rs) == 0:
if state == "absent":
# we are trying to remove a non-existing interface
only_query = True
else:
interface_status = check_rs[0]["INTERFACE_STATUS"]
if interface_status == state.upper():
# This means that the interface status is already what we want, skip the cl execution
only_query = True
else:
module.fail_json(msg="Value for option state is not valid.")
if extra_params is not None:
cl_command = cl_command + extra_params
is_changed = False
if only_query:
cl_command = ""
out = None
err = None
rc = IBMi_COMMAND_RC_SUCCESS
else:
rc, out, err = ibmi_module.itoolkit_run_command(cl_command)
if (rc == IBMi_COMMAND_RC_SUCCESS) and (state in ["present", "absent"
]):
is_changed = True
if sec_to_wait > 0:
time.sleep(sec_to_wait)
rs, query_err = return_interface_information(connection_id,
internet_address, alias_name)
if query_err is not None:
rc = IBMi_COMMAND_RC_ERROR
err = query_err
if joblog or (rc != IBMi_COMMAND_RC_SUCCESS):
job_log = ibmi_module.itoolkit_get_job_log(startd)
else:
job_log = []
endd = datetime.datetime.now()
delta = endd - startd
if rc != IBMi_COMMAND_RC_SUCCESS:
result_failed = dict(
job_log=job_log,
changed=is_changed,
stderr=err,
rc=rc,
start=str(startd),
end=str(endd),
delta=str(delta),
stdout=out,
cl_command=cl_command,
)
module.fail_json(msg='Non zero return code.', **result_failed)
else:
result_success = dict(
changed=is_changed,
stdout=out,
rc=rc,
start=str(startd),
end=str(endd),
delta=str(delta),
interface_info=rs,
cl_command=cl_command,
job_log=job_log,
)
module.exit_json(**result_success)
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)
def main():
module = AnsibleModule(
argument_spec=dict(
product_id=dict(type='str'),
fix_list=dict(type='list', elements='str', default=['*ALL']),
fix_omit_list=dict(type='list', elements='str'),
save_file_object=dict(type='str'),
save_file_lib=dict(type='str', default='QGPL'),
delayed_option=dict(type='str', default='*NO', choices=['*YES', '*NO', '*IMMDLY']),
temp_or_perm=dict(type='str', default='*TEMP', choices=['*TEMP', '*PERM']),
joblog=dict(type='bool', default=False),
operation=dict(type='str', default='load_and_apply', choices=['load_and_apply',
'load_only', 'apply_only',
'remove',
'query']),
become_user=dict(type='str'),
become_user_password=dict(type='str', no_log=True),
),
required_if=[
["operation", "apply_only", ["product_id"]],
["operation", "remove", ["product_id"]],
["operation", "load_and_apply", ["product_id", "save_file_object"]],
["operation", "load_only", ["product_id", "save_file_object"]]
],
supports_check_mode=True,
)
product_id = module.params['product_id']
ptf_list_to_select = module.params['fix_list']
ptf_list_to_omit = module.params['fix_omit_list']
save_file_object = module.params['save_file_object']
save_file_lib = module.params['save_file_lib']
delayed_option = module.params['delayed_option']
temp_or_perm = module.params['temp_or_perm']
operation = module.params['operation']
joblog = module.params['joblog']
become_user = module.params['become_user']
become_user_password = module.params['become_user_password']
if operation in ['load_and_apply', 'load_only', 'remove']:
if product_id == '*ALL':
module.fail_json(msg="product_id cannot be *ALL when operation is remove, load_and_apply and load_only.")
startd = datetime.datetime.now()
out = ''
ibmi_module = imodule.IBMiModule(become_user_name=become_user,
become_user_password=become_user_password)
db_conn = ibmi_module.get_connection()
if operation in ['load_and_apply', 'load_only', 'apply_only']:
operation_bool_map = {'load_and_apply': [False, False], 'load_only': [True, False], 'apply_only': [False, True]}
# install single or a list of PTFs
savf_obj = "" if operation == 'apply_only' else (save_file_lib + "/" + save_file_object)
rc, out, err = install_ptf(ibmi_module, module, product_id, ptf_list_to_select,
ptf_list_to_omit, "*SAVF", savf_obj, delayed_option, temp_or_perm,
operation_bool_map[operation][0], operation_bool_map[operation][1])
elif operation in ['remove']:
rc, out, err = remove_ptf(ibmi_module, module, product_id, ptf_list_to_select, ptf_list_to_omit,
temp_or_perm=temp_or_perm, delayed_option=delayed_option)
# return the status of the ptf
if ptf_list_to_select is not None:
ptf_list, query_err = return_fix_information(db_conn, product_id, ptf_list_to_select)
else:
module.fail_json(msg="PTF list contains no PTF.")
if operation == "query":
if query_err is not None:
rc = IBMi_COMMAND_RC_ERROR
err = query_err
else:
rc = IBMi_COMMAND_RC_SUCCESS
if joblog or (rc != IBMi_COMMAND_RC_SUCCESS):
job_log = ibmi_module.itoolkit_get_job_log(startd)
else:
job_log = []
endd = datetime.datetime.now()
delta = endd - startd
if rc > 0:
result_failed = dict(
start=str(startd),
end=str(endd),
delta=str(delta),
stdout=out,
stderr=err,
rc=rc,
job_log=job_log,
# changed=True,
)
module.fail_json(msg='non-zero return code', **result_failed)
else:
result_success = dict(
start=str(startd),
end=str(endd),
delta=str(delta),
ptf_list=ptf_list,
rc=rc,
job_log=job_log,
# changed=True,
)
module.exit_json(**result_success)
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=[
'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(
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(
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(
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(
job_number=dict(type='str', required=True),
job_name=dict(type='str', required=True),
job_user=dict(type='str', required=True),
become_user=dict(type='str'),
become_user_password=dict(type='str', no_log=True),
),
supports_check_mode=True,
)
job_number = module.params['job_number']
job_name = module.params['job_name']
job_user = module.params['job_user']
become_user = module.params['become_user']
become_user_password = module.params['become_user_password']
sql = "SELECT ORDINAL_POSITION, MESSAGE_ID, MESSAGE_TYPE, MESSAGE_SUBTYPE, SEVERITY, \
MESSAGE_TIMESTAMP, FROM_LIBRARY, FROM_PROGRAM, FROM_MODULE, FROM_PROCEDURE, FROM_INSTRUCTION, \
TO_LIBRARY, TO_PROGRAM, TO_MODULE, TO_PROCEDURE, TO_INSTRUCTION, FROM_USER, MESSAGE_FILE, \
MESSAGE_LIBRARY, MESSAGE_TEXT, MESSAGE_SECOND_LEVEL_TEXT \
FROM TABLE(QSYS2.JOBLOG_INFO('{p_job_number}/{p_job_user}/{p_job_name}')) A".format(
p_job_number=job_number, p_job_user=job_user, p_job_name=job_name)
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_sql_once(sql)
endd = datetime.datetime.now()
delta = endd - startd
if rc:
result_failed = dict(
sql=sql,
job_log=job_log,
stderr=err,
stdout=out,
rc=rc,
start=str(startd),
end=str(endd),
delta=str(delta),
)
message = 'non-zero return code {rc}'.format(rc=rc)
module.fail_json(msg=message, **result_failed)
result = dict(
sql=sql,
job_log=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)
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(
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(
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(
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(
name=dict(type='str', required=False),
status=dict(type='str',
default='*ALL',
choices=["*ALL", "*ACTIVE", "*JOBQ", "*OUTQ"]),
type=dict(type='str',
default="*ALL",
choices=["*ALL", "*BATCH", "*INTERACT"]),
subsystem=dict(type='str', default='*ALL'),
user=dict(type='str', default='*ALL'),
submitter=dict(type='str',
default='*ALL',
choices=["*ALL", "*JOB", "*USER", "*WRKSTN"]),
joblog=dict(type='bool', default=False),
become_user=dict(type='str'),
become_user_password=dict(type='str', no_log=True),
),
supports_check_mode=True,
)
job_name = module.params['name']
job_status = module.params['status']
job_type = module.params['type']
job_subsystem = module.params['subsystem']
job_user = module.params['user']
job_submitter = module.params['submitter']
joblog = module.params['joblog']
become_user = module.params['become_user']
become_user_password = module.params['become_user_password']
startd = datetime.datetime.now()
ibmi_module = imodule.IBMiModule(become_user_name=become_user,
become_user_password=become_user_password)
# connection_id = ibmi_module.get_connection()
sql_job_columns = "SELECT JOB_NAME, JOB_INFORMATION, JOB_STATUS, JOB_TYPE, JOB_TYPE_ENHANCED, JOB_SUBSYSTEM, " \
" JOB_DATE, JOB_DESCRIPTION_LIBRARY, JOB_DESCRIPTION, JOB_ACCOUNTING_CODE, SUBMITTER_JOB_NAME, " \
" SUBMITTER_MESSAGE_QUEUE_LIBRARY, SUBMITTER_MESSAGE_QUEUE, JOB_ENTERED_SYSTEM_TIME, " \
" JOB_SCHEDULED_TIME, JOB_ACTIVE_TIME, JOB_END_TIME, JOB_END_SEVERITY, COMPLETION_STATUS, " \
" JOB_END_REASON, JOB_QUEUE_LIBRARY, JOB_QUEUE_NAME, JOB_QUEUE_STATUS, JOB_QUEUE_PRIORITY, " \
" CCSID "
if (job_name is None) or (job_name == ""):
sql_where = ""
else:
sql_where = " AND UPPER(JOB_NAME) = '" + job_name.upper() + "'"
job_status = "*ALL"
job_type = "*ALL"
job_subsystem = "*ALL"
job_user = "******"
job_submitter = "*ALL"
sql_job_status_filter = " JOB_STATUS_FILTER => '" + job_status + "', "
sql_job_type_filter = " JOB_TYPE_FILTER => '" + job_type + "', "
sql_job_subsystem_filter = " JOB_SUBSYSTEM_FILTER => '" + job_subsystem.upper(
) + "', "
sql_job_user_filter = " JOB_USER_FILTER => '" + job_user.upper() + "', "
sql_job_submitter_filter = " JOB_SUBMITTER_FILTER => '" + job_submitter + "' "
sql_from = " FROM TABLE(QSYS2.JOB_INFO(" + sql_job_status_filter + sql_job_type_filter + \
sql_job_subsystem_filter + \
sql_job_user_filter + sql_job_submitter_filter + ")) X WHERE 1 = 1 "
sql_to_run = sql_job_columns + sql_from + sql_where
rc, out, err_msg, job_log = ibmi_module.itoolkit_run_sql_once(sql_to_run)
rt_job_log = []
if joblog or (rc != IBMi_COMMAND_RC_SUCCESS):
rt_job_log = job_log
endd = datetime.datetime.now()
delta = endd - startd
if rc != IBMi_COMMAND_RC_SUCCESS:
result_failed = dict(
stderr=err_msg,
rc=rc,
start=str(startd),
end=str(endd),
delta=str(delta),
job_log=rt_job_log,
)
module.fail_json(msg='Non-zero return code.', **result_failed)
else:
result_success = dict(
job_info=out,
rc=rc,
start=str(startd),
end=str(endd),
delta=str(delta),
job_log=rt_job_log,
)
module.exit_json(**result_success)
