def startWorkflow(
DomainName: str,
ServiceName: str,
Application: str,
Workflow: str,
Wait: bool = False,
ParameterFile: str = None,
ParameterSet: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
ResilienceTimeout: int = None,
OsProfile: str = None
) -> namedtuple("CmdResult", ['retcode', "stdout", "stderr"]):
options = [
"DomainName", "ServiceName", "UserName", "Password", "SecurityDomain",
"ResilienceTimeout", "Application", "Workflow", "Wait",
"ParameterFile", "ParameterSet", "OsProfile"
]
subcmd = "startWorkflow"
cmd = _checking_infacmd_env_and_ret_base_cmd(DomainName, UserName,
Password, base_cmd, subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
stdout = res.stdout
stderr = res.stderr
ret = namedtuple("CommandResult", ['retcode', "stdout", "stderr"])
return ret(res.retcode, stdout, stderr)
def listWorkflows(
DomainName: str,
ServiceName: str,
Application: str,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
ResilienceTimeout: int = None
) -> namedtuple("CmdResult", ['retcode', "stdout", "stderr"]):
subcmd = "listWorkflows"
options = [
"DomainName", "ServiceName", "UserName", "Password", "SecurityDomain",
"ResilienceTimeout", "Application"
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
stdout = res.stdout
stderr = res.stderr
if res.retcode == 0:
stdout_formated = stdout.split("\n")
stdout = stdout_formated[:-1]
ret = namedtuple("CmdResult", ['retcode', "stdout", "stderr"])
return ret(res.retcode, stdout, stderr)
def listMappings(
ServiceName: str,
Application: str,
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
ResilienceTimeout: int = None
) -> namedtuple("listMappingsResult", ["retcode", 'stdout', 'stderr']):
""" list all mappings under the application
if retcode equals 0, then stdout returns a list of mappings
else: stderr will return the error message
:param ServiceName: Data Integration Service
:param Application:
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param ResilienceTimeout:
:return: namedtuple("listMappingsResult", ["retcode", 'stdout', 'stderr'])
"""
subcmd = "ListMappings"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"ResilienceTimeout",
"ServiceName",
"Application",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode == 0:
# format the stdout
stdout = strip_ignored_cmd_messages(stdout)
stdout = stdout.split("\n")[:-1]
else:
stderr += stdout
ret = namedtuple("ListMappingsResult", ["retcode", 'stdout', 'stderr'])
return ret(res.retcode, stdout, stderr)
def getServiceStatus(
ServiceName: str,
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None
) -> namedtuple("GetServiceStatusResult", ['retcode', 'stdout', 'stderr']):
"""Get the service's Status
True stands for it's enabled
False stands for it's disabled
:param ServiceName:
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param Gateway:
:param ResilienceTimeout:
:return:
"""
subcmd = "GetServiceStatus"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
"ServiceName",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout
stderr = res.stderr
if res.retcode == 0:
stdout = True if stdout.upper().startswith("ENABLED") else False
else:
stderr += stdout
getServiceStatusResult = namedtuple("GetServiceStatusResult",
['retcode', 'stdout', 'stderr'])
return getServiceStatusResult(res.retcode, stdout, stderr)
def listNodes(
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
NodeRole: str = "Service_compute",
) -> namedtuple("ListNodesResult", ['retcode', 'stdout', 'stderr']):
""" list nodes of specified NodeRole
retcode is int, 0 represents success, otherwise failure
if retcode requals 0, the stdout will a list of nodes, and it must have one node, like [node1, node2].
otherwise, the stderr will show the details of error
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param Gateway:
:param ResilienceTimeout:
:param NodeRole: (Service_compute|Service|Compute) default is Service_compute
:return: namedtuple("ListNodesResult", ['retcode', 'stdout', 'stderr'])
"""
subcmd = "ListNodes "
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
"NodeRole",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout
stderr = res.stderr
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
stdout = stdout.splitlines()
else:
stderr += stdout
listNodesResult = namedtuple("ListNodesResult",
['retcode', 'stdout', 'stderr'])
return listNodesResult(res.retcode, stdout, stderr)
def stopBlazeService(
ServiceName: str,
HadoopConnection: str,
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
ResilienceTimeout: int = None,
) -> namedtuple("stopBlazeServiceResult", ['retcode', 'stdout', 'stderr']):
""" stop the Blaze Service
if retcode equals 0, then it stops the Blaze Service successfully.
otherwise, it fails to stop the Blaze Service.
:param ServiceName: Data Integration Service
:param HadoopConnection: HADOOP [or using connectiontype_namedtupe.HADOOP]
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param ResilienceTimeout:
:return: namedtuple("stopBlazeServiceResult", ['retcode', 'stdout', 'stderr'])
"""
subcmd = "stopBlazeService"
options = [
"DomainName",
"ServiceName",
"UserName",
"Password",
"SecurityDomain",
"ResilienceTimeout",
"HadoopConnection",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode == 0:
pass
else:
stderr += stdout
stopBlazeServiceResult = namedtuple("stopBlazeServiceResult",
['retcode', 'stdout', 'stderr'])
return stopBlazeServiceResult(res.retcode, stdout, stderr)
def enableService(
ServiceName: str,
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None
) -> namedtuple("EnableServiceResult", ['retcode', 'stdout', 'stderr']):
""" enable the service
if retcode is 0, then it enables the service, otherwise, it will raise stderr.
:param ServiceName:
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param Gateway:
:param ResilienceTimeout:
:return:
"""
subcmd = "EnableService"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
"ServiceName",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
stderr = res.stderr
stdout = res.stdout
if res.retcode != 0:
stderr += stdout
mainLogger.info(res)
enableServiceResult = namedtuple("EnableServiceResult",
['retcode', 'stdout', 'stderr'])
return enableServiceResult(res.retcode, stdout, stderr)
def deployApplication(
RepositoryService: str,
OutputDirectory: str,
ApplicationPath: str,
DomainName: str = None,
UserName: str = None,
Password: str = None,
) -> namedtuple("DeployApplicationResult", ['retcode', 'stdout', 'stderr']):
""" deploy the application to .iar file
if retcode equals 0, then the stdout returns the .iar file
otherwise, the stderr returns the error message.
:param RepositoryService: Model Repository Service
:param OutputDirectory:
:param ApplicationPath: "Project/Folder/application"
:param DomainName:
:param UserName:
:param Password:
:return: namedtuple("DeployApplicationResult", ['retcode', 'stdout', 'stderr'])
"""
subcmd = "DeployApplication"
options = [
"DomainName",
"UserName",
"Password",
"RepositoryService",
"OutputDirectory",
"ApplicationPath",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode == 0:
stdout = stdout[stdout.index("File [") +
6:stdout.index("] has been generate")]
else:
stderr += stdout
deployApplicationResult = namedtuple("DeployApplicationResult",
['retcode', 'stdout', 'stderr'])
return deployApplicationResult(res.retcode, stdout, stderr)
def startApplication(
ServiceName: str,
Application: str,
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
ResilienceTimeout: int = None
) -> namedtuple("StartApplicationResult", ['retcode', 'stdout', 'stderr']):
"""
if retcode equals 0, then it stops the application successfully
otherwise, it fails to stop it.
:param ServiceName: Data Integration Service
:param Application:
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param ResilienceTimeout:
:return: namedtuple("StartApplicationResult", ['retcode', 'stdout', 'stderr'])
"""
subcmd = "StartApplication"
options = [
"DomainName",
"ServiceName",
"UserName",
"Password",
"SecurityDomain",
"ResilienceTimeout",
"Application",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode != 0:
stderr += stdout
startApplicationResult = namedtuple("StartApplicationResult",
['retcode', 'stdout', 'stderr'])
return startApplicationResult(res.retcode, stdout, stderr)
def listServiceLevels(
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
) -> namedtuple("ListServiceLevelsResult", ['retcode', 'stdout', 'stderr']):
subcmd = "ListServiceLevels"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout
stderr = res.stderr
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
serviceLevels = stdout.split("\n\n")
listServiceLevels_list = list()
for serviceLevel in serviceLevels:
stdout = serviceLevel.split("\n")
listServiceLevels_dict = dict()
for item in stdout: # type: str
a = re.split("[:=]", item, maxsplit=1)
listServiceLevels_dict.setdefault(
a[0].lstrip().rstrip(), a[1].lstrip().rstrip().rstrip(":"))
listServiceLevels_list.append(listServiceLevels_dict)
stdout = listServiceLevels_list
else:
stderr += stdout
listServiceLevelsResult = namedtuple("ListServiceLevelsResult",
['retcode', 'stdout', 'stderr'])
return listServiceLevelsResult(res.retcode, stdout, stderr)
def listConnectionOptions(
ConnectionName: str,
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
ResilienceTimeout: int = None,
) -> namedtuple("ListConnectionOptionsResult", ['retcode', 'stdout', 'stderr'
]):
subcmd = "ListConnectionOptions"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"ResilienceTimeout",
"ConnectionName",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
conn_options = stdout.split("\n") # type: list
stdout = dict()
for option in conn_options: # type: str
option_name_value = option.split(":", maxsplit=1)
option_name = option_name_value[0]
option_value = option_name_value[1].lstrip().rstrip()
if option_value.startswith("[") and option_value.endswith("]"):
option_value = option_value[1:-1]
stdout.setdefault(option_name, option_value)
else:
stderr += stdout
listConnectionOptionsResult = namedtuple("ListConnectionOptionsResult",
['retcode', 'stdout', 'stderr'])
return listConnectionOptionsResult(res.retcode, stdout, stderr)
def resetPassword(
ResetUserName: str,
ResetUserPassword: str,
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
) -> namedtuple("ResetPasswordResult", ['retcode', 'stdout', 'stderr']):
subcmd = "ResetPassword"
options = [
"DomainName", "UserName", "Password", "SecurityDomain", "Gateway",
"ResilienceTimeout", "ResetUserName"
]
# for security reason, the ResetUserPassword will be set by the INFA_PASSWORD environment
# options = ["DomainName", "UserName", "Password", "SecurityDomain", "Gateway", "ResilienceTimeout", "ResetUserName",
# "ResetUserPassword", ]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
encrypted_password_Result = pmpasswd(passwd=ResetUserPassword)
resetPasswordResult = namedtuple("ResetPasswordResult",
['retcode', 'stdout', 'stderr'])
if encrypted_password_Result.retcode == 0:
os.environ.setdefault("INFA_PASSWORD",
encrypted_password_Result.stdout)
else:
return resetPasswordResult(
encrypted_password_Result.retcode, "",
"Couldn't to generate the encrypted password. for {0}".format(
encrypted_password_Result.stdout))
mainLogger.debug(os.environ)
res = run_cmd(cmd, env=os.environ)
os.environ.pop("INFA_PASSWORD")
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode != 0:
stderr += stdout
return resetPasswordResult(res.retcode, stdout, stderr)
def listLicenses(
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
) -> namedtuple("ListLicensesResult", ['retcode', 'stdout', 'stderr']):
subcmd = "ListLicenses"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout
stderr = res.stderr
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
mainLogger.info(stdout)
licenses = stdout.split("\n")
stdout = list()
for license in licenses:
name_sid = license.split(" ")
licenseResult = namedtuple("LicenseResult",
["Name", "SerialNumber"])
stdout.append(
licenseResult(name_sid[0],
name_sid[1].lstrip("(").rstrip(")")))
else:
stderr += stdout
listLicensesResult = namedtuple("ListLicensesResult",
['retcode', 'stdout', 'stderr'])
return listLicensesResult(res.retcode, stdout, stderr)
def disableService(
ServiceName: str,
Mode: str = "Complete",
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
) -> namedtuple("DisableServiceResult", ['retcode', 'stdout', 'stderr']):
""" disable the Service
if retcode is 0, then it's disabled successfully, otherwise it will raise stderr
:param ServiceName:
:param Mode: (Complete|Abort|Stop) default is Complete
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param Gateway:
:param ResilienceTimeout:
:return:
"""
subcmd = "DisableService"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
"ServiceName",
"Mode",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
return res
def ping(
ServiceName: str,
NodeName: str = None,
DomainName: str = None,
GatewayAddress: str = None,
ResilienceTimeout: int = None,
) -> namedtuple("PingResult", ['retcode', 'stdout', 'stderr']):
"""
:param ServiceName:
:param NodeName:
:param DomainName:
:param GatewayAddress:
:param ResilienceTimeout:
:return:
"""
subcmd = "Ping"
options = [
"DomainName",
"ServiceName",
"GatewayAddress",
"NodeName",
"ResilienceTimeout",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(
domainname=DomainName,
username=None,
password=None,
cmd=base_cmd,
subcmd=subcmd,
verify_username_password=False)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout
stderr = res.stderr
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
else:
stderr += stdout
pingResult = namedtuple("PingResult", ['retcode', 'stdout', 'stderr'])
return pingResult(res.retcode, stdout, stderr)
def backupContents(
ServiceName: str,
OutputFileName: str,
DomainName: str = None,
SecurityDomain: str = "Native",
UserName: str = None,
Password: str = None,
OverwriteFile: False = None,
Description: str = None,
BackupSearchIndices: str = None,
ResilienceTimeout: int = None,
) -> namedtuple("BackupContentsResult", ['retcode', 'stdout', 'stderr']):
subcmd = "BackupContents"
options = [
"DomainName",
"SecurityDomain",
"UserName",
"Password",
"ServiceName",
"OutputFileName",
"OverwriteFile",
"Description",
"BackupSearchIndices",
"ResilienceTimeout",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
else:
stderr += stdout
backupContentsResult = namedtuple("BackupContentsResult",
['retcode', 'stdout', 'stderr'])
return backupContentsResult(res.retcode, stdout, stderr)
def listUserPrivileges(
ServiceName: str,
ExistingUserName: str,
ExistingUserSecurityDomain: str = "Native",
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
) -> namedtuple("ListUserPrivilegesResult", ['retcode', 'stdout', 'stderr']):
subcmd = "ListUserPrivileges"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
"ExistingUserName",
"ExistingUserSecurityDomain",
"ServiceName",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
stdout = stdout.splitlines()
else:
stderr += stdout
listUserPrivilegesResult = namedtuple("ListUserPrivilegesResult",
['retcode', 'stdout', 'stderr'])
return listUserPrivilegesResult(res.retcode, stdout, stderr)
def listTasks(
DomainName: str,
ServiceName: str,
UserName: str = None,
Password: str = None,
MaxTasks: int = None,
FilterByOwner: str = None,
FilterByStatus: str = None,
FilterByCreationDate: str = None,
FilterByType: str = None,
FilterByDueDate: str = None,
FilterByID: str = None,
FilterByName: str = None,
FilterByNameLike: str = None,
TasksOffset: str = None,
Role: str = "ALL",
SecurityDomain: str = None,
ResilienceTimeout: str = None,
) -> namedtuple("CmdResult", ['retcode', "stdout", "stderr"]):
options = [
"DomainName", "ServiceName", "UserName", "Password", "MaxTasks",
"FilterByOwner", "FilterByStatus", "FilterByCreationDate",
"FilterByType", "FilterByDueDate", "FilterByID", "FilterByName",
"FilterByNameLike", "TasksOffset", "Role", "SecurityDomain",
"ResilienceTimeout"
]
subcmd = "listTasks"
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
stdout = res.stdout
stderr = res.stderr
if res.retcode == 0:
stdout_formated = stdout.split("\n")
stdout = stdout_formated[:-1]
ret = namedtuple("CmdResult", ['retcode', "stdout", "stderr"])
return ret(res.retcode, stdout, stderr)
def listApplications(
servicename: str,
domainname: str = None,
username: str = None,
password: str = None,
securitydomain: str = "Native",
resiliencetimeout: int = None
) -> namedtuple("ListApplicationsResult", ['retcode', "stdout", "stderr"]):
sub_cmd = "listapplications"
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname, username,
password, base_cmd, sub_cmd)
options = [
"domainname", "servicename", "username", "password", "securitydomain",
"resiliencetimeout"
]
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode == 0 and not is_none(res.stdout):
# format the stdout
stdout_formated = stdout.split("\n") # type: list
stdout = stdout_formated[:-1]
else:
stderr += stdout
ret = namedtuple("ListApplicationsResult", ['retcode', "stdout", "stderr"])
return ret(res.retcode, stdout, stderr)
def enableServiceProcess(
ServiceName: str,
NodeName: str,
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
) -> namedtuple("EnableServiceProcessResult", ['retcode', 'stdout', 'stderr']):
subcmd = "EnableServiceProcess"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
"ServiceName",
"NodeName",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
return res
def listServices(
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
ServiceType: str = None,
) -> namedtuple("ListServicesResult", ['retcode', 'stdout', 'stderr']):
""" list all services or services of specified Service Type
retcode: 0 stands for success, otherwise failure
stdout: list(str) like [service_name1, service_name2, .....] if retcode equals 0
stderr: str
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param Gateway:
:param ResilienceTimeout:
:param ServiceType: refer to the octopus.infa.infacmd.servicetype_namedtupe
:return: namedtuple("ListServicesResult", ['retcode', 'stdout', 'stderr'])
"""
subcmd = "ListServices"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
"ServiceType",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
stdout = stdout.split("\n")
else:
stderr += stdout
listServicesResult = namedtuple("ListServicesResult",
['retcode', 'stdout', 'stderr'])
return listServicesResult(res.retcode, stdout, stderr)
def listConnections(
DomainName: str = None,
UserName: str = None,
Password: str = None,
ConnectionType: str = None,
SecurityDomain: str = "Native",
ResilienceTimeout: int = None,
) -> namedtuple("ListConnectionsResult", ['retcode', 'stdout', 'stderr']):
""" list all connections (Administrator Console)
if retcode requals 0, then stdout returns a dict which contains Connection_Type and its list of connection(id: name)
like, {CONN_TYPE_1: [{id: CONN_1_ID, name: CONN_1_NAME}, {id: CONN_2_ID, name: CONN_2_NAME}, ....], CONN_TYPE_2: [], .....}
:param DomainName:
:param UserName:
:param Password:
:param ConnectionType: refer to the octopus.infa.infacmd.connectiontype_namedtupe
:param SecurityDomain:
:param ResilienceTimeout:
:return: namedtuple("ListConnectionsResult", ['retcode', 'stdout', 'stderr'])
"""
subcmd = "ListConnections "
options = [
"DomainName",
"UserName",
"Password",
"ConnectionType",
"SecurityDomain",
"ResilienceTimeout",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
stdout = stdout.split("\n") # type: list
stdout.reverse()
conns_dict = dict()
conns_list = list()
for conn_val in stdout:
if not conn_val.startswith("\t"):
if len(conns_list) > 0:
conns_dict.setdefault(conn_val, conns_list)
conns_list = list()
else:
# '\tINFA_102_DIS_PWD_210 - [ID: INFA_102_DIS_PWD_210
conn_val = conn_val.lstrip("\t").rstrip("]").split(" - [ID: ")
conns_list.append({"id": conn_val[1], "name": conn_val[0]})
continue
stdout = conns_dict
else:
stderr += stdout
listConnectionsResult = namedtuple("ListConnectionsResult",
['retcode', 'stdout', 'stderr'])
return listConnectionsResult(res.retcode, stdout, stderr)
def listAllUsers(
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
) -> namedtuple("ListAllUsersResult", ['retcode', 'stdout', 'stderr']):
"""
list all users
if retcode is 0, then stdout returns a list of users' dict,
like [{securityDomain: securityDomainName_1, userName: userName_1}, ....]
for example: [{'securityDomain': 'Native', 'userName': '******'}]
else: return the stderr
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param Gateway:
:param ResilienceTimeout:
:return: namedtuple("ListAllUsersResult", ['retcode', 'stdout', 'stderr'])
"""
subcmd = "ListAllUsers "
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout
stderr = res.stderr
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
usersList = stdout.split("\n")
stdout = list()
for user in usersList:
userinfo = user.split("/")
user_dict = dict()
user_dict.setdefault("securityDomain", userinfo[0])
user_dict.setdefault("userName", userinfo[1])
stdout.append(user_dict)
else:
stderr += stdout
listAllUsersResult = namedtuple("ListAllUsersResult",
['retcode', 'stdout', 'stderr'])
return listAllUsersResult(res.retcode, stdout, stderr)
def listApplicationObjects(
servicename: str,
application: str,
domainname: str = None,
domainaddress: str = None,
username: str = None,
password: str = None,
securitydomain: str = "Native",
resiliencetimeout: int = None,
objecttype: str = None,
listobjecttype: bool = False,
pagesize: int = None,
pageindex: int = None
) -> namedtuple("ListApplicationObjectsResult",
['retcode', "stdout", "stderr"]):
""" list the objects under this application.
if retcode equals 0, then stdout returns the a list of tuples which is formated with (objectName, type )
for example;
[('ConnectInfoProject/HADOOP_cuttlefish', '.GenericSDKConnectInfo'),
('ConnectInfoProject/HIVE_cuttlefish', 'Hiveconnectionmodel'),
('PRJ_DEV/FF_dual', 'FlatFileDataObject'),
('PRJ_DEV/dual', 'RelationalDataObject'),
('PRJ_DEV/dual1', 'RelationalDataObject'),
('PRJ_DEV/m_cuttlefish_single_triple_20180116', 'Mapping'),
('PRJ_DEV/m_ff2ff_parameter_20180309', 'Mapping'),
('PRJ_DEV/m_hive2hive_dual_20171019', 'Mapping'),
('PRJ_DEV/tgt_single1', 'RelationalDataObject'),
('PRJ_DEV/triple2', 'RelationalDataObject'),
('PRJ_DEV/wf_cuttlefish_hive2hive_failure', 'Workflow'),
('PRJ_DEV/wf_cuttlefish_single_triple_20180116', 'Workflow'),
('app_wf_cuttlefish_hive2hive_failure/app_wf_cuttlefish_hive2hive_failure', 'Application')
:param servicename: dis
:param application:
:param domainname: domainname and domainaddress are alternative
:param domainaddress: host:port
:param username:
:param password:
:param securitydomain: Default is Native
:param resiliencetimeout: INFA_CLIENT_RESILIENCE_TIMEOUT
:param objecttype: (Hiveconnectionmodel|RelationalDataObject|Mapping|Workflow|Application|...)
:param listobjecttype: true|false
:param pagesize: pagesize and pageindex are together
:param pageindex:
:return: namedtuple("ListApplicationObjectsResult", ['retcode', "stdout", "stderr"])
"""
subcmd = "listApplicationObjects"
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname, username,
password, base_cmd, subcmd)
options = [
"domainname", "domainaddress", "servicename", "username", "password",
"securitydomain", "resiliencetimeout", "application", "objecttype",
"listobjecttype", "pagesize", "pageindex"
]
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
ret = namedtuple("ListApplicationObjectsResult",
['retcode', "stdout", "stderr"])
stdout = res.stdout
stderr = res.stderr
if res.retcode == 0:
formated_stdout = stdout.split("\n")
stdout = formated_stdout[:-1]
if listobjecttype:
stdout_temp = list()
for item in stdout:
item_formated = item.split("\t")
stdout_temp.append(tuple(item_formated))
stdout = stdout_temp
else:
stderr += stdout
return ret(res.retcode, stdout, stderr)
def purgeLog(
BeforeDate: str,
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
) -> namedtuple("PurgeLogResult", ['retcode', 'stdout', 'stderr']):
"""
purge log events for a domain or for application services, such as the PowerCenter Integration Service,
the Data Integration Service, and the Web Services Hub.
:param BeforeDate: (MM/dd/yyyy|yyyy-MM-dd)
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param Gateway:
:param ResilienceTimeout:
:return: namedtuple("PurgeLogResult", ['retcode', 'stdout', 'stderr'])
"""
subcmd = "PurgeLog"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
"BeforeDate",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
try:
datetime.strptime(BeforeDate, "%Y-%m-%d")
except Exception as e:
mainLogger.exception(str(e))
try:
datetime.strptime(BeforeDate, "%m/%d/%Y")
except Exception as e:
mainLogger.exception(str(e))
raise Exception(
"The format of the BeforeDate is not right, should be yyyy/MM/dd or MM/dd/yyyy"
)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode == 0:
pass
else:
stderr += stdout
purgeLogResult = namedtuple("PurgeLogResult",
['retcode', 'stdout', 'stderr'])
return purgeLogResult(res.retcode, stdout, stderr)
def listGroupsForUser(
ExistingUserName: str,
ExistingUserSecurityDomain: str = "Native",
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
) -> namedtuple("ListGroupsForUserResult", ['retcode', 'stdout', 'stderr']):
""" list group for the user
if retcode equals 0, then stdout returns a list of dict which contains securityDomain and groupName
else: stderr will show error messages
for instance:
[{'securityDomain': 'Native', 'groupName': 'Administrator'}, {'securityDomain': 'Native', 'groupName': 'Everyone'}]
:param ExistingUserName:
:param ExistingUserSecurityDomain:
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param Gateway:
:param ResilienceTimeout:
:return: namedtuple("ListGroupsForUserResult", ['retcode', 'stdout', 'stderr'])
"""
subcmd = "ListGroupsForUser"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
"ExistingUserName",
"ExistingUserSecurityDomain",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
groups_list = stdout.splitlines()
stdout = list()
for group in groups_list:
temp_dict = dict()
group_info = group.split("/")
temp_dict.setdefault("securityDomain", group_info[0])
temp_dict.setdefault("groupName", group_info[1])
stdout.append(temp_dict)
else:
stderr += stdout
listGroupsForUserResult = namedtuple("ListGroupsForUserResult",
['retcode', 'stdout', 'stderr'])
return listGroupsForUserResult(res.retcode, stdout, stderr)
def listNodeResources(
NodeName: str,
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
ResourceCategory: str = "PCIS",
) -> namedtuple("ListNodeResourcesResult", ['retcode', 'stdout', 'stderr']):
""" list the resources of the node
if
:param NodeName:
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param Gateway:
:param ResilienceTimeout:
:param ResourceCategory:
:return:
"""
subcmd = "ListNodeResources"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
"NodeName",
"ResourceCategory",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout
stderr = res.stderr
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
entrys = stdout.splitlines()
stdout = list()
for entry in entrys: # type: str
entry_dict = dict()
entry_list = entry.split(";")
name = entry_list[0]
name = name[name.index("[") + 1:-1]
entry_dict.setdefault("name", name)
type = entry_list[1]
type = type[type.index("[") + 1:-1]
entry_dict.setdefault("type", type)
available = entry_list[2]
available = available[available.index("[") + 1:-2]
entry_dict.setdefault(
"available", True if available.upper() == "TRUE" else False)
stdout.append(entry_dict)
else:
stderr += stdout
listNodeResourcesResult = namedtuple("ListNodeResourcesResult",
['retcode', 'stdout', 'stderr'])
return listNodeResourcesResult(res.retcode, stdout, stderr)
def disableServiceProcess(
ServiceName: str,
NodeName: str,
Mode: str = "Complete",
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None
) -> namedtuple("DisableServiceProcessResult", ['retcode', 'stdout', 'stderr'
]):
"""
Disable the Service process on a specified node
:param ServiceName:
:param NodeName:
:param Mode: default is Complete, (Complete|Abort|Stop)
:param DomainName: optional
:param UserName: optional
:param Password: optional
:param SecurityDomain: default is Native
:param Gateway: optional
:param ResilienceTimeout: optional
:return: namedtuple("DisableServiceProcessResult", ['retcode', 'stdout', 'stderr'])
"""
subcmd = "DisableServiceProcess"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
"ServiceName",
"NodeName",
"Mode",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode == 0:
pass
else:
stderr += stdout
disableServiceProcessResult = namedtuple("DisableServiceProcessResult",
['retcode', 'stdout', 'stderr'])
return disableServiceProcessResult(res.retcode, stdout, stderr)
def listUserPermissions(
ExistingUserName: str,
ExistingUserSecurityDomain: str = "Native",
ObjectType: str = None,
DomainName: str = None,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
Gateway: str = None,
ResilienceTimeout: int = None,
) -> namedtuple("ListUserPermissionsResult", ['retcode', 'stdout', 'stderr']):
""" list user's permissions on these Object types
if retcode equals 0, then stdout returns a dict with Object Types and its list of values. dict(list)
otherwise, stderr will show the error messages.
here is a sample of success:
{
'Folder': ['/System_Services',
'/'],
'Grid': ['INFA210_GRID'],
'License': ['dd',
'EndApr1'],
'Node': ['ND_NoExisting',
'ND_INFA210'],
'OS Profile': ['BDM_OS_Profile'],
'Service': [
'Scheduler_Service',
'Email_Service',
'Resource_Manager_Service',
'IS_ASCII',
'D102_INFA210',
'M102_INFA210',
'R102_PRD_INFA210',
'IS_UNICODE',
'R102_INFA210']
}
:param ExistingUserName:
:param ExistingUserSecurityDomain:
:param ObjectType: (Service|License|Node|Grid|Folder|OSProfile) default is None which represents all
:param DomainName:
:param UserName:
:param Password:
:param SecurityDomain:
:param Gateway:
:param ResilienceTimeout:
:return:
"""
subcmd = "ListUserPermissions"
options = [
"DomainName",
"UserName",
"Password",
"SecurityDomain",
"Gateway",
"ResilienceTimeout",
"ExistingUserName",
"ExistingUserSecurityDomain",
"ObjectType",
]
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=os.environ)
mainLogger.info(res)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode == 0:
stdout = strip_ignored_cmd_messages(stdout)
userPermissionsList = stdout.splitlines()
userPermissionsList.reverse()
stdout = dict()
everyPermissionList = list()
for entry in userPermissionsList: # type: str
if not entry.endswith(":"):
entry = entry.strip(" ")
if entry:
everyPermissionList.append(entry)
continue
else:
stdout.setdefault(
entry.rstrip(":").rstrip(" "), everyPermissionList)
everyPermissionList = list()
else:
stderr += stdout
listUserPermissionsResult = namedtuple("ListUserPermissionsResult",
['retcode', 'stdout', 'stderr'])
return listUserPermissionsResult(res.retcode, stdout, stderr)
def listActiveWorkflowInstances(
DomainName: str,
ServiceName: str,
UserName: str = None,
Password: str = None,
SecurityDomain: str = "Native",
ResilienceTimeout: int = None
) -> namedtuple("ListActiveWorkflowInstancesResult",
['retcode', "stdout", "stderr"]):
"""
:param DomainName:
:param ServiceName:
:param UserName:
:param Password:
:param SecurityDomain: default is Native
:param ResilienceTimeout:
:return: namedtuple("CmdResult",['retcode', "stdout", "stderr"])
if stdout is existing, then it will return namedtuple('activeWorkflowInst', ['Workflow_Instance_State',
'Workflow_Instance_ID', 'Workflow_Name', 'Application_Name']
"""
envs = os.environ
options = [
"DomainName", "ServiceName", "UserName", "Password", "SecurityDomain",
"ResilienceTimeout"
]
subcmd = "listActiveWorkflowInstances"
cmd = _checking_infacmd_env_and_ret_base_cmd(domainname=DomainName,
username=UserName,
password=Password,
cmd=base_cmd,
subcmd=subcmd)
options_value_dict = locals()
for option in options:
cmd = _assemble_command_options(cmd, option,
options_value_dict.get(option))
mainLogger.debug(cmd)
res = run_cmd(cmd, env=envs)
stdout = res.stdout # type: str
stderr = res.stderr # type: str
if res.retcode == 0:
if stdout.startswith("Cannot find an active workflow instance"):
stderr += stdout
stdout = None
else:
stdout_formated = stdout.split("\n")
# as the output has \n\n
head = stdout_formated[1:2][0] # type: str
head = head.rstrip().replace(" ", "_")
head = re.split("_{2,}", head)
item_namedtuple = namedtuple("activeWorkflowInst", head)
mainLogger.debug(head)
stdout_formated = stdout_formated[2:-2]
"""
['Workflow instances that are running or that are canceled and enabled for recovery:',
'Workflow Instance State Workflow Instance ID Workflow Name Application Name ',
'Running Ub_rShwwEei_oNrsW-zrpQ wf_cuttlefish_single_triple_20180116 app_wf_cuttlefish_single2triple_test ']
"""
stdout = list() # type: list
for item in stdout_formated:
stdout.append(
item_namedtuple(*tuple(re.split(r" *", item.rstrip()))))
else:
stderr += stdout
ret = namedtuple("ListActiveWorkflowInstancesResult",
['retcode', "stdout", "stderr"])
return ret(res.retcode, stdout, stderr)
