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