978 lines
36 KiB
Python
978 lines
36 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.
|
|
# ----------------------------------------------------------------------------
|
|
|
|
import sys
|
|
import subprocess
|
|
import os
|
|
import pwd
|
|
import grp
|
|
import shutil
|
|
import _thread as thread
|
|
import time
|
|
import stat
|
|
|
|
localDirPath = os.path.dirname(os.path.realpath(__file__))
|
|
sys.path.insert(0, localDirPath + "/../../../lib")
|
|
try:
|
|
import psutil
|
|
except ImportError as e:
|
|
# mv psutil mode .so file by python version
|
|
pythonVer = sys.version[:3]
|
|
psutilLinux = os.path.join(localDirPath,
|
|
"./../../../lib/psutil/_psutil_linux.so")
|
|
psutilPosix = os.path.join(localDirPath,
|
|
"./../../../lib/psutil/_psutil_posix.so")
|
|
psutilLinuxBak = "%s_%s" % (psutilLinux, pythonVer)
|
|
psutilPosixBak = "%s_%s" % (psutilPosix, pythonVer)
|
|
|
|
glo_cmd = "rm -rf '%s' && cp -r '%s' '%s' " % (psutilLinux,
|
|
psutilLinuxBak,
|
|
psutilLinux)
|
|
glo_cmd += " && rm -rf '%s' && cp -r '%s' '%s' " % (psutilPosix,
|
|
psutilPosixBak,
|
|
psutilPosix)
|
|
psutilFlag = True
|
|
for psutilnum in range(3):
|
|
(status_mvPsutil, output_mvPsutil) = subprocess.getstatusoutput(
|
|
glo_cmd)
|
|
if status_mvPsutil != 0:
|
|
psutilFlag = False
|
|
time.sleep(1)
|
|
else:
|
|
psutilFlag = True
|
|
break
|
|
if not psutilFlag:
|
|
print("Failed to execute cmd: %s. Error:\n%s" % (glo_cmd,
|
|
output_mvPsutil))
|
|
sys.exit(1)
|
|
# del error import and reload psutil
|
|
del sys.modules['psutil._common']
|
|
del sys.modules['psutil._psposix']
|
|
import psutil
|
|
sys.path.append(sys.path[0] + "/../../")
|
|
from gspylib.common.ErrorCode import ErrorCode
|
|
from gspylib.os.gsplatform import g_Platform, findCmdInPath
|
|
|
|
|
|
class fileManage():
|
|
"""
|
|
Class to handle OS file operations
|
|
"""
|
|
SHELL_CMD_DICT = {
|
|
"deleteFile": "(if [ -f '%s' ];"
|
|
"then rm -f '%s';fi)",
|
|
"deleteLibFile": "cd %s && ls | grep -E '%s'|"
|
|
"xargs rm -f",
|
|
"cleanDir": "(if [ -d '%s' ];then rm -rf "
|
|
"'%s'/* && cd '%s' && ls -A | "
|
|
"xargs rm -rf ; fi)",
|
|
"execShellFile": "sh %s",
|
|
"getFullPathForShellCmd": "which %s",
|
|
"deleteDir": "(if [ -d '%s' ];then rm "
|
|
"-rf '%s';fi)",
|
|
"deleteLib": "(if [ -e '%s' ];then rm "
|
|
"-rf '%s';fi)",
|
|
"createDir": "(if [ ! -d '%s' ]; "
|
|
"then mkdir -p '%s' -m %s;fi)",
|
|
"createFile": "touch '%s' && chmod %s '%s'",
|
|
"deleteBatchFiles": "rm -f %s*",
|
|
"compressTarFile": "cd '%s' && tar -cf "
|
|
"'%s' %s && chmod %s '%s'",
|
|
"decompressTarFile": "cd '%s' && tar -xf '%s' ",
|
|
"copyFile": " cp -rf %s %s ",
|
|
"sshCmd": "pssh -s -H %s 'source %s;%s'",
|
|
"renameFile": "(if [ -f '%s' ];then mv '%s' "
|
|
"'%s';fi)",
|
|
"cleanFile": "if [ -f %s ]; then echo '' > "
|
|
"%s; fi",
|
|
"exeRemoteShellCMD": "pssh -s -H %s 'source %s;%s'",
|
|
"exeRemoteShellCMD1": "pssh -s -H %s \"%s\"",
|
|
"userExeRemoteShellCmd": "su - %s -c \"pssh -s -H %s "
|
|
"'%s'\"",
|
|
"checkUserPermission": "su - %s -c \"cd '%s'\"",
|
|
"getFileTime": "echo $[`date +%%s`-`stat -c "
|
|
"%%Y %s`]",
|
|
"scpFileToRemote": "pscp -H '%s' '%s' '%s'",
|
|
"scpFileFromRemote": "pssh -s -H '%s' \"pscp -H "
|
|
"'%s' '%s' '%s' \"",
|
|
"findfiles": "cd %s && find . "
|
|
"-type l -print",
|
|
"copyFile1": "(if [ -f '%s' ];then cp "
|
|
"'%s' '%s';fi)",
|
|
"copyFile2": "(if [ -f '%s' ] && [ ! -f "
|
|
"'%s' ];then cp '%s' '%s';fi)",
|
|
"copyRemoteFile": "(if [ -d '%s' ];then pssh "
|
|
"-s -H '%s' \"pscp -H '%s' "
|
|
"'%s' '%s' \";fi)",
|
|
"cleanDir1": "(if [ -d '%s' ]; then cd "
|
|
"'%s' && rm -rf '%s' && "
|
|
"rm -rf '%s' && cd -; fi)",
|
|
"cleanDir2": "(if [ -d '%s' ]; then "
|
|
"rm -rf '%s'/* && cd '%s' && "
|
|
"ls -A | xargs rm -rf && "
|
|
"cd -; fi)",
|
|
"cleanDir3": "rm -rf '%s'/* && cd '%s' && "
|
|
"ls -A | xargs rm -rf && "
|
|
"cd - ",
|
|
"cleanDir4": "rm -rf %s/*",
|
|
"checkNodeConnection": "ping %s -i 1 -c 3 |grep ttl |"
|
|
"wc -l",
|
|
"overWriteFile": "echo '%s' > '%s'",
|
|
"physicMemory": "cat /proc/meminfo | "
|
|
"grep MemTotal",
|
|
"findFile": "(if [ -d '%s' ]; then "
|
|
"find '%s' -type f;fi)",
|
|
"unzipForce": "unzip -o '%s' -d '%s'",
|
|
"killAll": findCmdInPath("killall") + " %s",
|
|
"sleep": "sleep %s",
|
|
"softLink": "ln -s '%s' '%s'",
|
|
"findwithcd": "cd %s && find ./ -name %s",
|
|
"installRpm": "rpm -ivh --nofiledigest %s "
|
|
"--nodeps --force --prefix=%s",
|
|
"changeMode": "chmod %s %s",
|
|
"checkPassword": "export LC_ALL=C; "
|
|
"chage -l %s | "
|
|
"grep -i %s"
|
|
}
|
|
|
|
def __init__(self):
|
|
"""
|
|
constructor
|
|
"""
|
|
pass
|
|
|
|
def createFile(self, path, overwrite=True, mode=None):
|
|
"""
|
|
function: create file and set the permission
|
|
input:
|
|
path: the file path.
|
|
overwrite: if file already exists and this parameter is true,
|
|
we can overwrtie it.
|
|
mode: Specify file permissions, type is int and start with 0.
|
|
ex: 0700
|
|
output:
|
|
return true or false.
|
|
"""
|
|
try:
|
|
if overwrite:
|
|
cmd = g_Platform.getCreateFileCmd(path)
|
|
if mode:
|
|
cmd += "; %s" % g_Platform.getChmodCmd(str(mode), path)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(output + " The cmd is %s" % cmd)
|
|
else:
|
|
# create file by python API
|
|
if mode:
|
|
os.mknod(path, mode)
|
|
else:
|
|
os.mknod(path)
|
|
except Exception as e:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50206"] % path +
|
|
" Error:\n%s" % str(e))
|
|
|
|
return True
|
|
|
|
def createFileInSafeMode(self, filePath, mode=stat.S_IWUSR | stat.S_IRUSR):
|
|
"""
|
|
Call this method before open(filePath) functions,
|
|
if it may create a new file.
|
|
This method guarantees a 0o600 file is created
|
|
instead of an arbitrary one.
|
|
"""
|
|
if os.path.exists(filePath):
|
|
return
|
|
try:
|
|
os.mknod(filePath, mode)
|
|
except IOError as e:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50206"] % filePath +
|
|
" Error:\n%s." % str(e))
|
|
|
|
def removeFile(self, path, cmdType="shell"):
|
|
"""
|
|
function: remove a file
|
|
input: the path of file(include file name)
|
|
output: return true or false
|
|
"""
|
|
if cmdType == "python":
|
|
# no file need remove.
|
|
if not os.path.exists(path):
|
|
return True
|
|
# check if is a file.
|
|
if not os.path.isfile(path):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50210"] % path)
|
|
try:
|
|
# remove file.
|
|
os.remove(path)
|
|
except Exception:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50207"] % path)
|
|
else:
|
|
# Support* for fuzzy matching
|
|
if "*" in path:
|
|
path = self.withAsteriskPath(path)
|
|
cmd = g_Platform.getRemoveCmd('file') + path
|
|
else:
|
|
cmd = g_Platform.getRemoveCmd('file') + "'" + path + "'"
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50207"] % path
|
|
+ " Error:\n%s" % output
|
|
+ " The cmd is %s" % cmd)
|
|
return True
|
|
|
|
def moveFile(self, src, dest, overwrite=True):
|
|
"""
|
|
function: move a file
|
|
input:
|
|
src: the dir of file
|
|
dest: the dir which want to move
|
|
output:
|
|
return true or false
|
|
"""
|
|
# check if can overwrite
|
|
if os.path.exists(dest) and not overwrite:
|
|
raise Exception(ErrorCode.GAUSS_501["GAUSS_50102"] % (
|
|
"parameter overwrite", dest))
|
|
try:
|
|
if overwrite:
|
|
cmd = g_Platform.getMoveFileCmd(src, dest)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(output + "The cmd is %s" % cmd)
|
|
else:
|
|
# move file
|
|
shutil.move(src, dest)
|
|
except Exception as e:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50232"] % (src, dest) +
|
|
" Error:\n%s" % str(e))
|
|
|
|
return True
|
|
|
|
def readFile(self, filename, keyword="", rows=0):
|
|
"""
|
|
function: read the content of a file
|
|
input:
|
|
filename: the name and path of the file
|
|
keyword: read line include keyword
|
|
rows: the row number, which want to read
|
|
offset: keep the parameter, but do nothing
|
|
output:list
|
|
"""
|
|
listKey = []
|
|
strRows = ""
|
|
allLines = []
|
|
# check if file exists.
|
|
if not os.path.exists(filename):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % filename)
|
|
try:
|
|
with open(filename, 'rb') as fp:
|
|
for line in fp:
|
|
allLines.append(line.decode("utf-8"))
|
|
except Exception:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50204"] % filename)
|
|
# get keyword lines
|
|
if keyword != "":
|
|
for line in allLines:
|
|
flag = line.find(keyword)
|
|
if flag >= 0:
|
|
listKey.append(line)
|
|
# get content of row
|
|
if rows:
|
|
if not str(rows).isdigit():
|
|
raise Exception
|
|
if rows > 0:
|
|
row_num = rows - 1
|
|
else:
|
|
row_num = rows
|
|
try:
|
|
if row_num < (len(allLines)):
|
|
strRows = allLines[row_num]
|
|
except Exception:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50204"] % (
|
|
"the %s line of the file [%s]" % (rows, filename)))
|
|
# check which needs return
|
|
if keyword != "" and rows != 0:
|
|
return [strRows]
|
|
if keyword != "" and rows == 0:
|
|
return listKey
|
|
if keyword == "" and rows != 0:
|
|
return [strRows]
|
|
if keyword == "" and rows == 0:
|
|
return allLines
|
|
|
|
def writeFile(self, path, context=None, mode="a+"):
|
|
"""
|
|
function: write content in a file
|
|
input:
|
|
path: the name and path of the file
|
|
context: the content, which want to write
|
|
mode: the write mode
|
|
output:
|
|
"""
|
|
lock = thread.allocate_lock()
|
|
if context is None:
|
|
context = []
|
|
# check if not exists.
|
|
if not os.path.exists(path):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % path)
|
|
# check if is a file.
|
|
if not os.path.isfile(path):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50210"] % path)
|
|
# if no context, return
|
|
if not context:
|
|
return False
|
|
self.createFileInSafeMode(path)
|
|
with open(path, mode) as fp:
|
|
fp.writelines(line + os.linesep for line in context)
|
|
lock.acquire()
|
|
try:
|
|
# write context.
|
|
fp.flush()
|
|
except Exception as e:
|
|
lock.release()
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50205"] % path +
|
|
"Error:\n%s" % str(e))
|
|
lock.release()
|
|
return True
|
|
|
|
def withAsteriskPath(self, path):
|
|
"""
|
|
function: deal with the path with *
|
|
input: the path to deal with
|
|
output: cmd
|
|
"""
|
|
path_dirList = os.path.realpath(path).split(os.path.sep)[1:]
|
|
path = "'"
|
|
for dirName in path_dirList:
|
|
if "*" in dirName:
|
|
dirPath = "'" + os.path.sep + dirName + "'"
|
|
else:
|
|
dirPath = os.path.sep + dirName
|
|
path += dirPath
|
|
if path[-1] == "'":
|
|
path = path[:-1]
|
|
else:
|
|
path += "'"
|
|
return path
|
|
|
|
def changeMode(self, mode, path, recursive=False, cmdType="shell",
|
|
retryFlag=False, retryTime=15, waiteTime=1):
|
|
"""
|
|
function: change permission of file
|
|
input:
|
|
cmdType: user shell or python
|
|
mode:permission value, Type is int and start with 0. ex: 0700
|
|
path:file path
|
|
recursive: recursive or not
|
|
output:
|
|
"""
|
|
try:
|
|
# do with shell command.
|
|
if cmdType == "shell":
|
|
if "*" in path:
|
|
path = self.withAsteriskPath(path)
|
|
else:
|
|
path = "'" + path + "'"
|
|
cmd = g_Platform.getChmodCmd(str(mode), path, recursive)
|
|
if retryFlag:
|
|
self.retryGetstatusoutput(cmd, retryTime, waiteTime)
|
|
else:
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_501[
|
|
"GAUSS_50107"] % path +
|
|
" Error:\n%s." % output +
|
|
"The cmd is %s" % cmd)
|
|
# do with python API. If the name has special characters.
|
|
else:
|
|
os.chmod(path, mode)
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
return True
|
|
|
|
def changeOwner(self, user, path, recursive=False, cmdType="shell",
|
|
retryFlag=False, retryTime=15, waiteTime=1):
|
|
"""
|
|
function: change the owner of file
|
|
input: cmdType, user, path, recursive
|
|
output: return true
|
|
"""
|
|
try:
|
|
# get uid and gid by username.
|
|
userInfo = pwd.getpwnam(user)
|
|
uid = userInfo.pw_uid
|
|
gid = userInfo.pw_gid
|
|
group = grp.getgrgid(gid).gr_name
|
|
except Exception as e:
|
|
raise Exception(ErrorCode.GAUSS_503["GAUSS_50308"] +
|
|
" Error:\n%s" % str(e))
|
|
try:
|
|
# do with shell command.
|
|
if cmdType == "shell":
|
|
if "*" in path:
|
|
path = self.withAsteriskPath(path)
|
|
else:
|
|
path = "'" + path + "'"
|
|
cmd = g_Platform.getChownCmd(user, group, path, recursive)
|
|
if retryFlag:
|
|
self.retryGetstatusoutput(cmd, retryTime, waiteTime)
|
|
else:
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(output + " The cmd is %s" % cmd)
|
|
# do with python API. If the name has special characters.
|
|
else:
|
|
os.chown(path, uid, gid)
|
|
except Exception as e:
|
|
raise Exception(ErrorCode.GAUSS_501["GAUSS_50106"] % path +
|
|
" Error:\n%s." % str(e))
|
|
return True
|
|
|
|
def retryGetstatusoutput(self, cmd, retryTime, sleepTime):
|
|
"""
|
|
function : exectue commands, if fail ,then retry it.
|
|
input : cmd, waitTimes, retryTimes
|
|
output: NA
|
|
"""
|
|
countNum = 0
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
while countNum < retryTime:
|
|
if status != 0:
|
|
sleepCmd = "sleep %s" % sleepTime
|
|
subprocess.getstatusoutput(sleepCmd)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
countNum = countNum + 1
|
|
else:
|
|
break
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_501["GAUSS_51400"] % cmd +
|
|
" Error:\n%s" % output)
|
|
|
|
def createDirectory(self, path, overwrite=True, mode=None):
|
|
"""
|
|
function: create a directory
|
|
input: path, overwrite
|
|
output: true
|
|
"""
|
|
try:
|
|
if os.path.exists(path) and not overwrite:
|
|
raise Exception(ErrorCode.GAUSS_501["GAUSS_50102"] % (
|
|
"parameter overwrite", path))
|
|
if overwrite:
|
|
cmd = g_Platform.getMakeDirCmd(path, overwrite)
|
|
if mode:
|
|
cmd += "; %s" % g_Platform.getChmodCmd(str(mode), path)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(output + " The cmd is %s" % cmd)
|
|
if not overwrite:
|
|
if mode:
|
|
os.mkdir(path, mode)
|
|
else:
|
|
os.mkdir(path)
|
|
except Exception as e:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50208"] % path +
|
|
" Error:\n%s" % str(e))
|
|
return True
|
|
|
|
def cleanDirectoryContent(self, path):
|
|
"""
|
|
function: clean the content in a directory,
|
|
but do not remove directory.
|
|
input:path
|
|
output:true
|
|
"""
|
|
rm_Dirfile = "cd %s && ls | xargs -n 100000" % (path)
|
|
if not os.path.exists(path):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % path)
|
|
cmd = "%s %s && %s '%s'/.[^.]*" % (rm_Dirfile, g_Platform.getRemoveCmd(
|
|
"directory"), g_Platform.getRemoveCmd("directory"), path)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50209"] % (
|
|
"content in the directory %s " % path) +
|
|
" Error:\n%s." % output + "The cmd is %s" % cmd)
|
|
return True
|
|
|
|
def removeDirectory(self, path):
|
|
"""
|
|
function: remove the content in a directory
|
|
input:path
|
|
output:true
|
|
"""
|
|
if "*" in path:
|
|
path = self.withAsteriskPath(path)
|
|
cmd = "%s %s" % (g_Platform.getRemoveCmd("directory"), path)
|
|
else:
|
|
cmd = "%s '%s'" % (g_Platform.getRemoveCmd("directory"), path)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50209"] % path +
|
|
" Error:\n%s." % output + "The cmd is %s" % cmd)
|
|
return True
|
|
|
|
def moveDirectory(self, src, dest):
|
|
"""
|
|
function:move the content in a directory
|
|
input:src, dest
|
|
output:true
|
|
"""
|
|
if not os.path.exists(src):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % src)
|
|
if not os.path.exists(dest):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % dest)
|
|
cmd = g_Platform.getMoveCmd(src, dest)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error:\n%s" % output)
|
|
return True
|
|
|
|
def getDirectoryList(self, path, keywords="", recursive=False):
|
|
"""
|
|
function:give the list of file in the directory
|
|
input:path, keywords, recursive
|
|
output:list
|
|
"""
|
|
list_Dir = []
|
|
try:
|
|
if keywords == "":
|
|
if recursive:
|
|
cmd = "%s -R '%s'" % (g_Platform.getListCmd(), path)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(output + "\nThe cmd is %s" % cmd)
|
|
list_Dir = output.split('\n')
|
|
else:
|
|
list_Dir = os.listdir(path)
|
|
else:
|
|
if recursive:
|
|
cmd = "%s -R '%s' |%s -E '%s'" % (
|
|
g_Platform.getListCmd(), path,
|
|
g_Platform.getGrepCmd(), keywords)
|
|
else:
|
|
cmd = "%s '%s' |%s -E '%s'" % (
|
|
g_Platform.getListCmd(), path,
|
|
g_Platform.getGrepCmd(), keywords)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0 and output != "":
|
|
raise Exception(output + "\nThe cmd is %s" % cmd)
|
|
else:
|
|
list_Dir = output.split('\n')
|
|
except Exception as e:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50219"] % (
|
|
"the list of %s" % path) + " Error:\n%s" % str(e))
|
|
while '' in list_Dir:
|
|
list_Dir.remove('')
|
|
return list_Dir
|
|
|
|
def cpFile(self, src, dest, cmdType="shell", skipCheck=False):
|
|
"""
|
|
function: copy a file
|
|
input:src, dest, cmdType
|
|
output:true
|
|
"""
|
|
if skipCheck:
|
|
if not os.path.exists(src):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % src)
|
|
if not os.path.exists(os.path.dirname(dest)):
|
|
raise Exception(ErrorCode.GAUSS_502[
|
|
"GAUSS_50201"] % os.path.dirname(dest))
|
|
try:
|
|
if cmdType != "shell":
|
|
shutil.copy(src, dest)
|
|
else:
|
|
cmd = g_Platform.getCopyCmd(src, dest, "directory")
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(output + "\nThe cmd is %s" % cmd)
|
|
except Exception as e:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50214"] % src +
|
|
" Error:\n%s" % str(e))
|
|
return True
|
|
|
|
def findFile(self, path, keyword, choice='name'):
|
|
"""
|
|
function:find a file by name or size or user
|
|
input:path, keyword, choice, type
|
|
output:NA
|
|
"""
|
|
if not os.path.exists(path):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % path)
|
|
cmd = "%s '%s' -%s %s " % (g_Platform.getFindCmd(), path,
|
|
choice, keyword)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50219"] % (
|
|
"the files of path %s" % path) + " Error:\n%s" % output
|
|
+ "\nThe cmd is %s" % cmd)
|
|
list_File = output.split('\n')
|
|
while '' in list_File:
|
|
list_File.remove('')
|
|
return list_File
|
|
|
|
def compressFiles(self, tarName, dirPath):
|
|
"""
|
|
function:compress directory to a package
|
|
input:tarName, directory
|
|
output:NA
|
|
"""
|
|
cmd = g_Platform.getCompressFilesCmd(tarName, dirPath)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50227"] % cmd +
|
|
" Error:\n%s" % output)
|
|
|
|
def decompressFiles(self, srcPackage, dest):
|
|
"""
|
|
function:decompress package to files
|
|
input:srcPackage, dest
|
|
output:NA
|
|
"""
|
|
if not os.path.exists(srcPackage):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % srcPackage)
|
|
if not os.path.exists(dest):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % dest)
|
|
cmd = g_Platform.getDecompressFilesCmd(srcPackage, dest)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50231"] % srcPackage +
|
|
" Error:\n%s" % output + "\nThe cmd is %s" % cmd)
|
|
|
|
def compressZipFiles(self, zipName, dirPath):
|
|
"""
|
|
function:compress directory to a package
|
|
input:zipName, directory
|
|
output:NA
|
|
"""
|
|
if not os.path.exists(dirPath):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % dirPath)
|
|
cmd = g_Platform.getCompressZipFilesCmd(zipName, dirPath)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50227"] % cmd +
|
|
" Error:\n%s" % output)
|
|
|
|
def decompressZipFiles(self, srcPackage, dest):
|
|
"""
|
|
function:decompress package to files
|
|
input:srcPackage, dest
|
|
output:NA
|
|
"""
|
|
if not os.path.exists(srcPackage):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % srcPackage)
|
|
if not os.path.exists(dest):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % dest)
|
|
cmd = g_Platform.getDecompressZipFilesCmd(srcPackage, dest)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50231"] % srcPackage +
|
|
" Error:\n%s" % output + "\nThe cmd is %s" % cmd)
|
|
|
|
def getfileUser(self, path):
|
|
"""
|
|
function: get the info(username group) of a file
|
|
input:path
|
|
output:list of info
|
|
"""
|
|
if not os.path.exists(path):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % path)
|
|
|
|
user = pwd.getpwuid(os.stat(path).st_uid).pw_name
|
|
group = grp.getgrgid(os.stat(path).st_gid).gr_name
|
|
return user, group
|
|
|
|
def replaceFileLineContent(self, oldLine, newLine, path):
|
|
"""
|
|
function: replace the line in a file to a new line
|
|
input:
|
|
oldLine : Need to replace content
|
|
newLine : Replaced content
|
|
path
|
|
output:NA
|
|
"""
|
|
if not os.path.exists(path):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % path)
|
|
|
|
cmd = g_Platform.getReplaceFileLineContentCmd(oldLine, newLine, path)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50223"] % path +
|
|
" Error:\n%s" % output + "\nThe cmd is %s" % cmd)
|
|
|
|
def checkIsInDirectory(self, fileName, directoryList):
|
|
"""
|
|
function : Check if the file is in directoryList.
|
|
input : String,[]
|
|
output : []
|
|
"""
|
|
try:
|
|
isExist = False
|
|
for onePath in directoryList:
|
|
dirName = os.path.normpath(fileName)
|
|
isExist = False
|
|
|
|
while dirName != "/":
|
|
if dirName == onePath:
|
|
isExist = True
|
|
break
|
|
dirName = os.path.dirname(dirName)
|
|
|
|
if isExist:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50229"] % (
|
|
fileName, onePath))
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
return isExist
|
|
|
|
def checkDirWriteable(self, dirPath):
|
|
"""
|
|
function : Check if target directory is writeable for execute user.
|
|
input : String,String
|
|
output : boolean
|
|
"""
|
|
# if we can touch a tmp file under the path, it is true;
|
|
return os.access(dirPath, os.W_OK)
|
|
|
|
def checkFilePermission(self, filename, isread=False, iswrite=False,
|
|
isexecute=False):
|
|
"""
|
|
Function : check file: 1.exist 2. isfile 3. permission
|
|
Note : 1.You must check that the file exist and is a file.
|
|
2.You can choose whether to check the file's
|
|
permission:readable/writable/executable.
|
|
input : filename, isread, iswrite, isexecute
|
|
output : True
|
|
"""
|
|
if not os.path.exists(filename):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % filename)
|
|
if not os.path.isfile(filename):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50210"] % filename)
|
|
if isread:
|
|
if not os.access(filename, os.R_OK):
|
|
raise Exception(ErrorCode.GAUSS_501["GAUSS_50100"] % (
|
|
filename, "the user") +
|
|
" Error:\n%s: Permission denied." % filename)
|
|
if iswrite:
|
|
if not os.access(filename, os.W_OK):
|
|
raise Exception(ErrorCode.GAUSS_501["GAUSS_50102"] % (
|
|
filename, "the user") +
|
|
" Error:\n%s: Permission denied." % filename)
|
|
if isexecute:
|
|
if not os.access(filename, os.X_OK):
|
|
raise Exception(ErrorCode.GAUSS_501[
|
|
"GAUSS_50101"] % (filename, "the user") +
|
|
" Error:\n%s: Permission denied." % filename)
|
|
return True
|
|
|
|
def getFileSHA256(self, filename):
|
|
"""
|
|
function : Get the ssh file by SHA256
|
|
input : String
|
|
output : String
|
|
"""
|
|
if not os.path.exists(filename):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % filename)
|
|
if not os.path.isfile(filename):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50210"] % filename)
|
|
|
|
strSHA256 = ""
|
|
cmd = g_Platform.getFileSHA256Cmd(filename)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
return strSHA256
|
|
strSHA256 = output.strip()
|
|
|
|
return strSHA256
|
|
|
|
def getDirSize(self, path, unit=""):
|
|
"""
|
|
function : Get the directory or file size
|
|
input : String, String
|
|
output : String
|
|
"""
|
|
sizeInfo = ""
|
|
cmd = g_Platform.getDirSizeCmd(path, unit)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
return sizeInfo
|
|
return output.split()[0]
|
|
|
|
def getTopPath(self, path):
|
|
"""
|
|
function: find the top path of the specified path
|
|
input : NA
|
|
output: tmpDir
|
|
"""
|
|
tmpDir = path
|
|
while True:
|
|
# find the top path to be created
|
|
(tmpDir, topDirName) = os.path.split(tmpDir)
|
|
if os.path.exists(tmpDir) or topDirName == "":
|
|
tmpDir = os.path.join(tmpDir, topDirName)
|
|
break
|
|
return tmpDir
|
|
|
|
def getFilesType(self, givenPath):
|
|
"""
|
|
function : get the file and subdirectory type of the given path
|
|
input : String
|
|
output : String
|
|
"""
|
|
if not os.path.exists(givenPath):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % givenPath)
|
|
# obtain the file type
|
|
tmpFile = "/tmp/fileList_%d" % os.getpid()
|
|
cmd = "%s '%s' ! -iname '.*' | %s file -F '::' > %s 2>/dev/null" % (
|
|
g_Platform.getFindCmd(), givenPath,
|
|
g_Platform.getXargsCmd(), tmpFile)
|
|
subprocess.getstatusoutput(cmd)
|
|
# Return code is not equal to zero when file a non-existent
|
|
# file in SLES SP4
|
|
# But it is equal to zero in SLES SP1/SP2/SP3 and
|
|
# RHEL 6.4/6.5/6.6 platform, skip check status and output
|
|
resDict = {}
|
|
try:
|
|
with open(tmpFile, 'r') as fp:
|
|
fileNameTypeList = fp.readlines()
|
|
os.remove(tmpFile)
|
|
for oneItem in fileNameTypeList:
|
|
res = oneItem.split("::")
|
|
if len(res) != 2:
|
|
continue
|
|
else:
|
|
resDict[res[0]] = res[1]
|
|
return resDict
|
|
except Exception as e:
|
|
if os.path.exists(tmpFile):
|
|
g_file.removeFile(tmpFile)
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50221"] +
|
|
" Error: \n%s" % str(e))
|
|
|
|
# delete a line in file match with re
|
|
def deleteLine(self, filePath, lineInfo):
|
|
"""
|
|
function : delete line in a file
|
|
input : filePath ,lineInfo
|
|
output : NA
|
|
"""
|
|
cmd = g_Platform.getSedCmd()
|
|
cmd += " -i '/%s/d' %s" % (lineInfo, filePath)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50205"] % filePath +
|
|
" Error:\n%s" % output + "\nThe cmd is %s" % cmd)
|
|
|
|
def deleteLineByRowNum(self, filePath, lineNum):
|
|
"""
|
|
function : delete line in a file by row num
|
|
input : filePath ,lineInfo
|
|
output : NA
|
|
"""
|
|
cmd = g_Platform.getSedCmd()
|
|
cmd += " -i '%sd' %s" % (lineNum, filePath)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50205"] % filePath +
|
|
" Error:\n%s" % output + "\nThe cmd is %s" % cmd)
|
|
|
|
def rename(self, oldFilePath, newFilePath):
|
|
"""
|
|
function : rename a file name to new name
|
|
input : oldFilePath, newFilePath
|
|
output : NA
|
|
"""
|
|
cmd = g_Platform.getMoveCmd(oldFilePath, newFilePath)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50218"] % oldFilePath +
|
|
" Error:\n%s" % output + "\nThe cmd is %s" % cmd)
|
|
|
|
def echoLineToFile(self, line, filePath):
|
|
"""
|
|
function : write line in file
|
|
input : line, file
|
|
output : use 2>/dev/null, no return.
|
|
Notice: maye the line has '$'
|
|
"""
|
|
cmd = g_Platform.echoCmdWithNoReturn(line, filePath)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50205"] % filePath +
|
|
" Command:%s. Error:\n%s" % (cmd, output))
|
|
|
|
def checkClusterPath(self, path_name):
|
|
"""
|
|
Check the path
|
|
:param path_name:
|
|
:return:
|
|
"""
|
|
if not path_name:
|
|
return False
|
|
|
|
a_ascii = ord('a')
|
|
z_ascii = ord('z')
|
|
A_ascii = ord('A')
|
|
Z_ascii = ord('Z')
|
|
num0_ascii = ord('0')
|
|
num9_ascii = ord('9')
|
|
blank_ascii = ord(' ')
|
|
sep1_ascii = ord('/')
|
|
sep2_ascii = ord('_')
|
|
sep3_ascii = ord('-')
|
|
sep4_ascii = ord(':')
|
|
sep5_ascii = ord('.')
|
|
sep6_ascii = ord(',')
|
|
for path_char in path_name:
|
|
char_check = ord(path_char)
|
|
if (not (a_ascii <= char_check <= z_ascii or A_ascii <=
|
|
char_check <= Z_ascii or
|
|
num0_ascii <= char_check <= num9_ascii or
|
|
char_check == blank_ascii or
|
|
char_check == sep1_ascii or
|
|
char_check == sep2_ascii or
|
|
char_check == sep3_ascii or
|
|
char_check == sep4_ascii or
|
|
char_check == sep5_ascii or
|
|
char_check == sep6_ascii)):
|
|
return False
|
|
return True
|
|
|
|
def checkPathIsLegal(self, path_name):
|
|
"""
|
|
check if the path is legal
|
|
:param file name:
|
|
:return:
|
|
"""
|
|
if not self.checkClusterPath(path_name):
|
|
raise Exception(ErrorCode.GAUSS_512["GAUSS_51250"] % path_name)
|
|
|
|
def cdDirectory(self, dirPath, user=""):
|
|
"""
|
|
"""
|
|
if (user != "") and (os.getuid() == 0):
|
|
cmd = "su - %s 'cd \'%s\' '" % (user, dirPath)
|
|
else:
|
|
cmd = "cd '%s'" % dirPath
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error: \n%s " % output)
|
|
|
|
|
|
g_file = fileManage()
|