563 lines
18 KiB
Python
563 lines
18 KiB
Python
# -*- coding:utf-8 -*-
|
|
# Copyright (c) 2020 Huawei Technologies Co.,Ltd.
|
|
#
|
|
# openGauss is licensed under Mulan PSL v2.
|
|
# You can use this software according to the terms
|
|
# and conditions of the Mulan PSL v2.
|
|
# You may obtain a copy of Mulan PSL v2 at:
|
|
#
|
|
# http://license.coscl.org.cn/MulanPSL2
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OF ANY KIND,
|
|
# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
# See the Mulan PSL v2 for more details.
|
|
# ----------------------------------------------------------------------------
|
|
""" The following platform framework is used to handle any differences between
|
|
the platform's we support. The GenericPlatform class is the base class
|
|
that a supported platform extends from and overrides any of the methods
|
|
as necessary.
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import subprocess
|
|
import pwd
|
|
import grp
|
|
|
|
sys.path.append(sys.path[0] + "/../../")
|
|
from gspylib.common.ErrorCode import ErrorCode
|
|
from gspylib.common.VersionInfo import VersionInfo
|
|
from gspylib.os.gsplatform import g_Platform, findCmdInPath
|
|
from gspylib.os.gsfile import g_file
|
|
|
|
sys.path.append(sys.path[0] + "/../../../lib")
|
|
import psutil
|
|
|
|
|
|
class PlatformCommand():
|
|
"""
|
|
Command for os
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
function : init function
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
pass
|
|
|
|
def getDate(self):
|
|
"""
|
|
function : Get current system time
|
|
input : NA
|
|
output: String
|
|
"""
|
|
dateCmd = g_Platform.getDateCmd() + " -R "
|
|
(status, output) = subprocess.getstatusoutput(dateCmd)
|
|
# if cmd failed, then exit
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50219"] % "date" +
|
|
"The cmd is %s" % dateCmd)
|
|
return output
|
|
|
|
def getAllCrontab(self):
|
|
"""
|
|
function : Get the crontab
|
|
input : NA
|
|
output: status, output
|
|
"""
|
|
cmd = g_Platform.getAllCrontabCmd()
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if output.find("no crontab for") >= 0:
|
|
output = ""
|
|
status = 0
|
|
# if cmd failed, then exit
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50219"] %
|
|
"crontab list" + " Error:%s." % output +
|
|
"The cmd is %s" % cmd)
|
|
return status, output
|
|
|
|
def execCrontab(self, path):
|
|
"""
|
|
function : Get the crontab
|
|
input : string
|
|
output: True or False
|
|
"""
|
|
if not os.path.exists(path):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % path)
|
|
filePath = os.path.dirname(path)
|
|
fileName = os.path.basename(path)
|
|
cmd = g_Platform.getCdCmd(filePath)
|
|
cmd += " && "
|
|
cmd += g_Platform.getCrontabCmd()
|
|
cmd += (" ./%s" % fileName)
|
|
cmd += " && %s" % g_Platform.getCdCmd("-")
|
|
# if cmd failed, then exit
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error:\n%s" % output)
|
|
return True
|
|
|
|
def source(self, path):
|
|
"""
|
|
function : Get the source
|
|
input : string
|
|
output: True or False
|
|
"""
|
|
cmd = g_Platform.getSourceCmd()
|
|
cmd += " %s" % path
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error:\n%s" % output)
|
|
return True
|
|
|
|
def getGrepValue(self, para="", value="", path=""):
|
|
"""
|
|
function : grep value
|
|
input : string,value,path
|
|
output: status, output
|
|
"""
|
|
if not os.path.exists(path):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % path)
|
|
cmd = g_Platform.getGrepCmd() + " %s '%s' '%s'" % (para, value, path)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error:\n%s" % output)
|
|
return status, output
|
|
|
|
def getHostName(self):
|
|
"""
|
|
function : Get host name
|
|
input : NA
|
|
output: string
|
|
"""
|
|
hostCmd = findCmdInPath("hostname")
|
|
(status, output) = subprocess.getstatusoutput(hostCmd)
|
|
# if cmd failed, then exit
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50219"] % "host name"
|
|
+ "The cmd is %s" % hostCmd)
|
|
return output
|
|
|
|
def getSysConfiguration(self):
|
|
"""
|
|
function : The size range of PAGE_SIZE obtained by getconf
|
|
input : NA
|
|
output: string
|
|
"""
|
|
configCmd = g_Platform.getGetConfValueCmd()
|
|
(status, output) = subprocess.getstatusoutput(configCmd)
|
|
# if cmd failed, then exit
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50219"] %
|
|
"system config pagesize" +
|
|
"The cmd is %s" % configCmd)
|
|
return output
|
|
|
|
def getUserLimits(self, limitType):
|
|
"""
|
|
function : Get current user process limits
|
|
input : string
|
|
output: string
|
|
"""
|
|
limit = g_Platform.getUlimitCmd()
|
|
limitCmd = "%s -a | %s -F '%s'" % (limit, g_Platform.getGrepCmd(),
|
|
limitType)
|
|
(status, output) = subprocess.getstatusoutput(limitCmd)
|
|
# if cmd failed, then exit
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % limitCmd +
|
|
" Error:\n%s" % output)
|
|
return output
|
|
|
|
def chageExpiryInformation(self, user):
|
|
"""
|
|
function : Query user password expiration time
|
|
input : user
|
|
output: True or False
|
|
"""
|
|
changeTemp = g_Platform.getPasswordExpiresCmd(user)
|
|
changeCmd = "%s | %s -i '^Password expires'" % \
|
|
(changeTemp, g_Platform.getGrepCmd())
|
|
(status, output) = subprocess.getstatusoutput(changeCmd)
|
|
# if cmd failed, then exit
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % changeCmd +
|
|
" Error:\n%s" % output)
|
|
|
|
expireTime = output.split(":")[1]
|
|
if expireTime.find("never") == 1:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def getIOStat(self):
|
|
"""
|
|
function : Get device IO information
|
|
input : NA
|
|
output: string
|
|
"""
|
|
ioStatCmd = g_Platform.getIOStatCmd()
|
|
(status, output) = subprocess.getstatusoutput(ioStatCmd)
|
|
# if cmd failed, then exit
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50219"] %
|
|
"IO information" + "The cmd is %s" % ioStatCmd)
|
|
return output
|
|
|
|
def scpFile(self, ip, sourcePath, targetPath, copyTo=True):
|
|
"""
|
|
function : if copyTo is True, scp files to remote host else,
|
|
scp files to local host
|
|
input : destination host ip
|
|
source path
|
|
target path
|
|
copyTo
|
|
output: NA
|
|
"""
|
|
scpCmd = ""
|
|
if os.path.isdir(sourcePath):
|
|
scpCmd = g_Platform.getRemoteCopyCmd(sourcePath, targetPath, ip,
|
|
copyTo, "directory")
|
|
elif os.path.exists(sourcePath):
|
|
scpCmd = g_Platform.getRemoteCopyCmd(sourcePath, targetPath, ip,
|
|
copyTo)
|
|
|
|
(status, output) = subprocess.getstatusoutput(scpCmd)
|
|
# if cmd failed, then exit
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % scpCmd +
|
|
" Error:\n%s" % output)
|
|
|
|
def getLocaleInfo(self, para):
|
|
"""
|
|
function : Get OS character set information
|
|
input : para
|
|
output: string
|
|
"""
|
|
localCmd = "%s | grep '^%s='" % (g_Platform.getLocaleCmd(), para)
|
|
(status, output) = subprocess.getstatusoutput(localCmd)
|
|
# if cmd failed, then exit
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % localCmd +
|
|
" Error:\n%s" % output)
|
|
return output.split("=")[1][1:-1]
|
|
|
|
def mangerSysMode(self, operateType, module):
|
|
"""
|
|
type: list --list system module
|
|
load --load system module
|
|
insert --insert system module by force
|
|
remove --remove system module
|
|
dep --generate modules.dep and map files
|
|
"""
|
|
modCmd = g_Platform.getSysModManagementCmd(operateType, module)
|
|
(status, output) = subprocess.getstatusoutput(modCmd)
|
|
# if cmd failed, then exit
|
|
if status != 0:
|
|
raise Exception(str(output) + " The cmd is %s" % modCmd)
|
|
|
|
def getSshCommand(self, ip, cmd):
|
|
"""
|
|
function : Get ssh command
|
|
input : null
|
|
output : exe_cmd
|
|
"""
|
|
exe_cmd = "%s \"%s\"" % (g_Platform.getSshCmd(ip), cmd)
|
|
return exe_cmd
|
|
|
|
def getProcess(self, processKeywords):
|
|
"""
|
|
function : Get process id by keywords
|
|
input : processKeywords
|
|
output : processId
|
|
"""
|
|
processId = []
|
|
cmd = g_Platform.getProcessIdByKeyWordsCmd(processKeywords)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status == 0 and str(output.strip()) != "":
|
|
# kill process
|
|
processId = output.strip().split("\n")
|
|
return processId
|
|
|
|
def getProcPidList(self, procName):
|
|
"""
|
|
function : Get process id by procName
|
|
input : procName
|
|
output : pidList
|
|
"""
|
|
pidList = []
|
|
for pid in psutil.pids():
|
|
try:
|
|
p = psutil.Process(pid)
|
|
if procName == p.name():
|
|
pidList.append(pid)
|
|
except psutil.NoSuchProcess:
|
|
pass
|
|
return pidList
|
|
|
|
def killProcessByProcName(self, procName, killType=2):
|
|
"""
|
|
function : Kill the process
|
|
input : int, int
|
|
output : boolean
|
|
"""
|
|
try:
|
|
pidList = self.getProcPidList(procName)
|
|
for pid in pidList:
|
|
os.kill(pid, killType)
|
|
return True
|
|
except Exception:
|
|
return False
|
|
|
|
def killallProcess(self, userName, procName, killType='2'):
|
|
"""
|
|
function : Kill all processes by userName and procName.
|
|
input : userName, procName, killType
|
|
output : boolean
|
|
"""
|
|
cmd = "%s >/dev/null 2>&1" % g_Platform.getKillallProcessCmd(killType,
|
|
userName,
|
|
procName)
|
|
status = subprocess.getstatusoutput(cmd)[0]
|
|
if status != 0:
|
|
return False
|
|
return True
|
|
|
|
def cleanCommunicationStatus(self, user):
|
|
"""
|
|
function : clean semaphore
|
|
input : user
|
|
output : Successful return True,otherwise return false
|
|
"""
|
|
cmd = g_Platform.getDeleteSemaphoreCmd(user)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status == 0:
|
|
return True
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_504["GAUSS_50407"] +
|
|
" Error: \n%s." % str(output) +
|
|
"The cmd is %s" % cmd)
|
|
|
|
def getUserInfo(self):
|
|
"""
|
|
function : Get user information
|
|
input : null
|
|
output : userInfo
|
|
"""
|
|
userInfo = {"uid": os.getuid(), "name": pwd.getpwuid(
|
|
os.getuid()).pw_name,
|
|
"gid": pwd.getpwuid(os.getuid()).pw_gid}
|
|
userInfo["g_name"] = grp.getgrgid(userInfo["gid"]).gr_name
|
|
|
|
return userInfo
|
|
|
|
def getDeviceIoctls(self, devName):
|
|
"""
|
|
function : Get device ioctls
|
|
input : devName device name
|
|
output : blockSize
|
|
"""
|
|
blockSize = 0
|
|
cmd = g_Platform.getBlockdevCmd(devName)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_504["GAUSS_50408"] % cmd +
|
|
" Error: \n%s" % str(output))
|
|
if str(output.strip()) != "" and output.isdigit():
|
|
blockSize = int(output)
|
|
return blockSize
|
|
|
|
def addUser(self, userName, groupName):
|
|
"""
|
|
function : Add the user
|
|
input : userName
|
|
: groupName
|
|
output : Successful return True,otherwise return false
|
|
"""
|
|
cmd = g_Platform.getUseraddCmd(userName, groupName)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status == 0:
|
|
return True
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_503["GAUSS_50318"] % userName +
|
|
" Error: \n%s." % str(output) +
|
|
"The cmd is %s" % cmd)
|
|
|
|
def delUser(self, userName):
|
|
"""
|
|
function : Delete the user
|
|
input : userName
|
|
output : Successful return True,otherwise return false
|
|
"""
|
|
cmd = g_Platform.getUserdelCmd(userName)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status == 0:
|
|
return True
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_503["GAUSS_50314"] % userName +
|
|
" Error: \n%s." % str(output) +
|
|
"The cmd is %s" % cmd)
|
|
|
|
def addGroup(self, groupName):
|
|
"""
|
|
function : Add the group
|
|
input : groupName
|
|
output : Successful return True,otherwise return false
|
|
"""
|
|
cmd = g_Platform.getGroupaddCmd(groupName)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status == 0:
|
|
return True
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_503["GAUSS_50319"] % groupName +
|
|
" Error: \n%s." % str(output) +
|
|
"The cmd is %s" % cmd)
|
|
|
|
def delGroup(self, groupName):
|
|
"""
|
|
function : delete the group
|
|
input : groupName
|
|
output : Successful return True,otherwise return false
|
|
"""
|
|
cmd = g_Platform.getGroupdelCmd(groupName)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status == 0:
|
|
return True
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_503["GAUSS_50313"] % groupName +
|
|
" Error:\n%s." % str(output) +
|
|
"The cmd is %s" % cmd)
|
|
|
|
def getPathOwner(self, pathName):
|
|
"""
|
|
function : Get the owner user of path.
|
|
input : pathName
|
|
output : user and group
|
|
"""
|
|
user = ""
|
|
group = ""
|
|
# check path
|
|
if not os.path.exists(pathName):
|
|
return user, group
|
|
# get use and group information
|
|
try:
|
|
user = pwd.getpwuid(os.stat(pathName).st_uid).pw_name
|
|
group = grp.getgrgid(os.stat(pathName).st_gid).gr_name
|
|
return user, group
|
|
except Exception:
|
|
return "", ""
|
|
|
|
def getPackageFile(self, fileType="tarFile"):
|
|
"""
|
|
function : Get the path of binary file version.
|
|
input : NA
|
|
output : String
|
|
"""
|
|
(distName, version) = g_Platform.getCurrentPlatForm()
|
|
return g_Platform.getPackageFile(distName, version,
|
|
VersionInfo.getPackageVersion(),
|
|
VersionInfo.PRODUCT_NAME_PACKAGE,
|
|
fileType)
|
|
|
|
def getTarFilePath(self):
|
|
"""
|
|
function : Get the path of binary file version.
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return self.getPackageFile("tarFile")
|
|
|
|
def getBz2FilePath(self):
|
|
"""
|
|
function : Get the path of binary file version.
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return self.getPackageFile("bz2File")
|
|
|
|
def getBinFilePath(self):
|
|
"""
|
|
function : Get the path of binary file version..
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return self.getPackageFile("binFile")
|
|
|
|
def getSHA256FilePath(self):
|
|
"""
|
|
function : Get the path of sha256 file version..
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return self.getPackageFile("sha256File")
|
|
|
|
def getFileSHA256Info(self):
|
|
"""
|
|
function: get file sha256 info
|
|
input: NA
|
|
output: str, str
|
|
"""
|
|
try:
|
|
bz2Path = self.getBz2FilePath()
|
|
sha256Path = self.getSHA256FilePath()
|
|
|
|
fileSHA256 = g_file.getFileSHA256(bz2Path)
|
|
valueList = g_file.readFile(sha256Path)
|
|
if len(valueList) != 1:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50204"] %
|
|
sha256Path)
|
|
sha256Value = valueList[0].strip()
|
|
return fileSHA256, sha256Value
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def checkLink(self, filePath):
|
|
"""
|
|
function:check if file is a link
|
|
input: filePath
|
|
output:NA
|
|
"""
|
|
if os.path.exists(filePath):
|
|
if os.path.islink(filePath):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50210"] % filePath)
|
|
|
|
def getGroupByUser(self, user):
|
|
"""
|
|
function : get group by user
|
|
input : user
|
|
output : group
|
|
"""
|
|
try:
|
|
group = grp.getgrgid(pwd.getpwnam(user).pw_gid).gr_name
|
|
except Exception as e:
|
|
raise Exception(ErrorCode.GAUSS_503["GAUSS_50300"] % user +
|
|
"Detail msg: %s" % str(e))
|
|
return group
|
|
|
|
def getPortProcessInfo(self, port):
|
|
"""
|
|
function : get port occupation process
|
|
input : port
|
|
output : process info
|
|
"""
|
|
try:
|
|
processInfo = ""
|
|
cmd = "netstat -an | grep -w %s" % port
|
|
output = subprocess.getstatusoutput(cmd)[1]
|
|
processInfo += "%s\n" % output
|
|
return processInfo
|
|
except Exception as e:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error:\n%s" % str(e))
|
|
|
|
|
|
g_OSlib = PlatformCommand()
|