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 pmpasswd( passwd: str, encrypt_type: str = None ) -> namedtuple("pmpasswdResult", ['retcode', 'stdout']): """ You can encrypt passwords to create an environment variable to use with infacmd, infasetup, pmcmd, and pmrep or to define a password in a parameter file. For example, you can encrypt the repository and database passwords for pmrep to maintain security when using pmrep in scripts. Then you can create an environment variable to store the encrypted password. Or, you can define a password for a relational database connection object in a parameter file. :param passwd: to be encrypted password :param encrypt_type: CRYPT_DATA | CRYPT_SYSTEM :return: encrypted password """ infa_home_key = Config.PREDEFINED_ENV_VARIABLES_ATTRIBUTE.INFA_HOME infa_home = os.environ.get(infa_home_key) if is_none(infa_home): raise MissingEnvironmentVariable( "the {0} is not set".format(infa_home_key)) ld_lib_path_name = get_LIBRARY_PATH_NAME() if ld_lib_path_name: existing_ld_lib_path_value = os.environ.get(ld_lib_path_name) infa_ld_lib_path = "{0}/server/bin:{1}/services/shared/bin".format( infa_home, infa_home) os.environ.update({ ld_lib_path_name: "{0}:{1}".format(infa_ld_lib_path, existing_ld_lib_path_value) }) if is_none(encrypt_type): command = "{infa_home}/server/bin/pmpasswd {passwd} ".format( infa_home=infa_home, passwd=passwd) elif encrypt_type is not None and encrypt_type.upper() in ('CRYPT_DATA', 'CRYPT_SYSTEM'): command = "{infa_home}/server/bin/pmpasswd {passwd} -e {encrypt_type}".format( infa_home=infa_home, passwd=passwd, encrypt_type=encrypt_type.upper()) else: errmsg = "{0} is not supported in pmpasswd command".format( encrypt_type) mainLogger.error(errmsg) raise UnsupportedEncryptionType(errmsg) mainLogger.debug(os.environ) mainLogger.info(command) cmd_result = run_cmd(command, env=os.environ) mainLogger.debug(cmd_result) stdout = cmd_result.stdout # type: str stderr = cmd_result.stderr # type: str msg = None if cmd_result.retcode == 0: msg = stdout[stdout.index("-->") + 3:stdout.index("<--")] else: msg = stderr + " " + stdout[stdout.index("usage:"):] pmpasswdResult = namedtuple("pmpasswdResult", ['retcode', 'stdout']) return pmpasswdResult(cmd_result.retcode, msg)
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)