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 update_env(self, node_id: int, env) -> None:
"""更新一个环境变量
:param node_id: node id
:param env: 新的环境变量字典
:return: None
:exception: ParameterTypeIsInvalidatedException
"""
if isinstance(env, dict):
temp_env = copy.deepcopy(env)
name, value = temp_env.popitem()
upd_env = self.query.filter(
self.__class__.name == name,
self.__class__.node_id == node_id).first()
mainLogger.debug("INFA_ENV: Old value is {0}".format(upd_env))
upd_env.value = value
db.session.commit()
mainLogger.debug("INFA_ENV: New value is {0}".format(upd_env))
elif isinstance(env, self.__class__):
upd_env = self.query.filter(
self.__class__.node_id == env.node_id,
self.__class__.name == env.name).first()
upd_env.value = env.value
db.session.commit()
else:
errmsg = "{0} should be dict or instance of {1}".format(
env, self.__class__)
mainLogger.error(errmsg)
raise ParameterTypeIsInvalidatedException(errmsg)
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 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 my_after_request(param):
endTime = datetime.now()
delta_time = endTime - g.startTime
total_seconds = delta_time.total_seconds()
mainLogger.debug(
"###### my_after_request is invoked, and total_seconds is {0}, and param is {1}"
.format(total_seconds, param))
return param
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 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 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 get_NodeRef_list(self) -> [ds.NodeRef]:
portals = self.get_NodeConfig().get_portals()
mainLogger.debug("portals is {0}".format(portals))
nodeRef_inst_list = list()
for portal in portals:
mainLogger.error(dir(portal))
nodeRefs = portal.NodeRef
for nodeRef in nodeRefs: # type: ds.NodeRef
nodeRef_inst_list.append(nodeRef)
return nodeRef_inst_list
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 get_envs(self, node_id: int) -> dict:
"""
获取节点所有环境变量设置
:param node_id: node id
:return: 环境变量字典
"""
my_envs = self.query.filter(self.__class__.node_id == node_id).all()
envs_dict = dict()
for env in my_envs: # type: self.__class__
envs_dict.setdefault(env.name, env.value)
mainLogger.debug(envs_dict)
return envs_dict
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 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 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 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 post(self):
args = self.parser.parse_args()
mainLogger.debug("## args = {0}".format(args))
if is_none(args.get("ServiceName")) or is_none(args.get("Application")) or is_none(args.get("Workflow")):
raise MissingRequiredParametersException(" ServiceName and Application and Workflow are/is requried")
# return serilization type
ret_type = args.get("RT")
if ret_type is None:
ret_type = "JSON"
# current_node_envs = infa_env.get_envs(current_node.id) # type: dict
current_node_envs = get_current_node_infa_envs()
os.environ.update(current_node_envs)
mainLogger.debug("environment variables is {0}".format(current_node_envs))
args.pop("RT")
res = startWorkflow(**args)
mainLogger.debug(res)
stdout = str(res.stdout)
if ret_type.upper() == "PROTOBUF":
proto_resp = infaCliResponse_pb2.InfaCliResponse()
proto_resp.retcode = res.retcode
proto_resp.stdout = stdout
res = proto_resp.SerializeToString()
mainLogger.debug("protobuf: the result is {0}".format(res))
content_type = Config.PREDEFINED_CONTENT_TYPES.get("PROTOBUF")
else:
output_dict = {"retcode": res.retcode,
"stdout": stdout
}
res = json.dumps(output_dict)
content_type = Config.PREDEFINED_CONTENT_TYPES.get("JSON")
response = make_response(res)
response.headers["Content-Type"] = content_type
return response
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 get_env(self, node_id: int, env_name: str) -> dict:
"""
获取一个环境变量值
:param node_id: node id
:param env: 环境变量名
:return: 环境变量字典|None
"""
my_env = self.query.filter(self.__class__.name == env_name,
self.__class__.node_id == node_id).first()
mainLogger.debug(my_env)
out_dict = dict()
if my_env is not None:
out_dict.setdefault(my_env.name, my_env.value)
return out_dict
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 post(self):
args = self.parser.parse_args()
mainLogger.debug("the AddInfaEnvs args is {0}".format(args))
mainLogger.debug("the AddInfaEnvs locals is {0}".format(locals()))
infa_envs_args = args.get("Envs") # type: str
infa_envs_dict = dict()
try:
envs_list = infa_envs_args.split(",")
for env in envs_list:
env_list = env.split("=", maxsplit=1)
if len(env_list) < 2:
raise WrongEnvrionmentFormatException(
"{0} is not right, the standard format is env_name=env_value"
.format(env))
infa_envs_dict.setdefault(env_list[0], env_list[1])
current_node = get_current_node()
infa_env_inst = INFA_ENV()
## upsert
for key, value in infa_envs_dict.items():
env_dict = {key: value}
try:
infa_env_inst.update_env(current_node.id, env_dict)
except Exception as e:
mainLogger.exception(
"Updating {0} with error: {1}, and now try to insert it"
.format(env_dict, str(e)))
infa_env_inst.insert_env(current_node.id, env_dict)
ret_message = {
"retcode": 0,
"stdout": infa_envs_dict,
"stderr": None
}
except Exception as e:
mainLogger.exception(str(e))
ret_message = ({
"retcode":
1,
"stdout":
None,
"stderr":
"Error {0} when upserting {1} into inner database.".format(
str(e.args), infa_envs_dict)
}, 404)
return ret_message
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 insert_envs(self, node_id: int, envs: dict) -> None:
"""插入多条环境变量信息
:param node_id: node id
:param envs: 环境变量字典
:return: None
:exception: ParameterTypeIsInvalidatedException
"""
if isinstance(envs, dict):
for name, value in envs.items():
db.session.add(
self.__class__(name=name, value=value, node_id=node_id))
db.session.commit()
mainLogger.debug("insert {0} into infa_env".format(envs))
else:
errmsg = "{0} should be dict".format(envs)
mainLogger.error(errmsg)
raise ParameterTypeIsInvalidatedException(errmsg)
def __parse(self):
tree = ET.parse(self.domains_infa)
root = tree.getroot()
mainLogger.debug("root.tag = {0}, root.text={1}, root.attrib={2}".format(root.tag, root.text, root.attrib))
vector_dict = dict()
vector_list = list()
for vectors in root:
for vector in vectors:
tag = vector.tag # type: str
text = vector.text # type: str
if tag.lower() == 'address':
for addr in vector:
tag = addr.tag
text = addr.text
vector_dict.setdefault(tag, text)
else:
vector_dict.setdefault(tag, text)
vector_list.append(vector_dict)
return vector_list
def delele_env(self, node_id: int, env) -> None:
"""
删除一个环境变量
:param node_id: node_id
:param env: 环境变量字典
:type env: str | dict
:return: None
:exception: ParameterTypeIsInvalidatedException
"""
if isinstance(env, dict):
temp_env = copy.deepcopy(env)
name, value = temp_env.popitem()
else:
name = env
del_env = self.query.filter(self.__class__.name == name,
self.__class__.node_id == node_id).first()
mainLogger.debug("{0} This will be deleted".format(del_env))
db.session.delete(del_env)
db.session.commit()
def insert_env(self, node_id: int, env: dict):
"""插入一条环境变量信息
:param node_id: node id
:param env: 环境变量字典
:return: 如果成功为None，否者，抛出异常
:rtype: None|ParameterTypeIsInvalidatedException
"""
if isinstance(env, dict):
tmp_env = copy.deepcopy(env)
name, value = tmp_env.popitem()
new_env = self.__class__(name=name, value=value, node_id=node_id)
db.session.add(new_env)
db.session.commit()
mainLogger.debug("Insert the {0} into infa_env".format(new_env))
return new_env
else:
errmsg = "{0} should be dict".format(env)
mainLogger.error(errmsg)
raise ParameterTypeIsInvalidatedException(errmsg)
def post(self):
args = self.parser.parse_args()
mainLogger.info("the pmpasswd args is {0}".format(args))
encrypt_type = args.get("EncryptType")
passwd = args.get("Passwd")
if encrypt_type is None or encrypt_type not in (
'CRYPT_DATA', 'CRYPT_SYSTEM') or passwd is None:
abort(401)
ret_type = args.get('RT') # type: str
if ret_type is None:
ret_type = "JSON"
# node = Node()
# current_node = node.get_current_node() # type: Node
#
# infa_env = INFA_ENV()
#
# set_task_envs = infa_env.get_envs(current_node.id)
set_task_envs = get_current_node_infa_envs()
print("############## os.environ is {0}".format(os.environ))
os.environ.update(set_task_envs)
commandResult = pmpasswd(
passwd,
encrypt_type=encrypt_type) # type: namedtuple("pmpasswdResult",
# ['retcode', 'stdout'])
content_type = None
if ret_type.upper() == "PROTOBUF":
pmpasswd_resp = infaCliResponse_pb2.InfaCliResponse()
pmpasswd_resp.retcode = commandResult.retcode
pmpasswd_resp.stdout = commandResult.stdout
commandResult = pmpasswd_resp.SerializeToString()
mainLogger.debug(
"protobuf: the result is {0}".format(commandResult))
content_type = Config.PREDEFINED_CONTENT_TYPES.get("PROTOBUF")
else:
commandResult = json.dumps(commandResult._asdict())
content_type = Config.PREDEFINED_CONTENT_TYPES.get("JSON")
response = make_response(commandResult)
response.headers["Content-Type"] = content_type
return response