832 lines
26 KiB
Python
832 lines
26 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 time
|
|
import re
|
|
from gspylib.common.Common import DefaultValue
|
|
from gspylib.common.ErrorCode import ErrorCode
|
|
from os_platform.UserPlatform import g_Platform
|
|
from gspylib.inspection.common.Exception import ShellCommandException,\
|
|
SshCommandException, SQLCommandException
|
|
from base_utils.os.file_util import FileUtil
|
|
from domain_utils.cluster_file.version_info import VersionInfo
|
|
from domain_utils.sql_handler.sql_file import SqlFile
|
|
from base_utils.os.net_util import NetUtil
|
|
from os_platform.linux_distro import LinuxDistro
|
|
from base_diff.sql_commands import SqlCommands
|
|
|
|
localPath = os.path.dirname(__file__)
|
|
sys.path.insert(0, localPath + "/../lib")
|
|
|
|
FILE_MODE = 640
|
|
DIRECTORY_MODE = 750
|
|
KEY_FILE_MODE = 600
|
|
KEY_DIRECTORY_MODE = 700
|
|
INIT_FILE_SUSE = "/etc/init.d/boot.local"
|
|
INIT_FILE_REDHAT = "/etc/rc.d/rc.local"
|
|
|
|
|
|
def runShellCmd(cmd, user=None, mpprcFile=""):
|
|
"""
|
|
function: run shell cmd
|
|
input : md, user, mpprcFile
|
|
output : str
|
|
"""
|
|
if (mpprcFile):
|
|
cmd = "source '%s'; %s" % (mpprcFile, cmd)
|
|
# Set the output LANG to English
|
|
cmd = "export LC_ALL=C; %s" % cmd
|
|
# change user but can not be root user
|
|
if (user and user != getCurrentUser()):
|
|
cmd = "su - %s -c \"source /etc/profile 2>/dev/null; %s\"" % (
|
|
user, cmd)
|
|
cmd = cmd.replace("$", "\$")
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if (status != 0 and DefaultValue.checkDockerEnv()):
|
|
return output
|
|
if (status != 0):
|
|
raise ShellCommandException(cmd, output)
|
|
return output
|
|
|
|
|
|
def runSshCmd(cmd, host, user="", mpprcFile="", timeout=""):
|
|
"""
|
|
function: run ssh cmd
|
|
input : cmd, host, user, mpprcFile, timeout
|
|
output : str
|
|
"""
|
|
if (timeout):
|
|
timeout = "-o ConnectTimeout=%s" % timeout
|
|
if (mpprcFile):
|
|
cmd = "source '%s'; %s" % (mpprcFile, cmd)
|
|
# Set the output LANG to English
|
|
cmd = "export LC_ALL=C; %s" % cmd
|
|
# RedHat does not automatically source /etc/profile
|
|
# but SuSE executes when using ssh to remotely execute commands
|
|
# Some environment variables are written in /etc/profile
|
|
# when there is no separation of environment variables
|
|
if (host == NetUtil.GetHostIpOrName() or host in NetUtil.getIpAddressList()):
|
|
sshCmd = cmd
|
|
else:
|
|
sshCmd = "pssh -s -H %s %s 'source /etc/profile 2>/dev/null;%s'" % (
|
|
host, timeout, cmd)
|
|
if (user and user != getCurrentUser()):
|
|
sshCmd = "su - %s -c \"%s\"" % (user, sshCmd)
|
|
(status, output) = subprocess.getstatusoutput(sshCmd)
|
|
if (status != 0):
|
|
raise SshCommandException(host, sshCmd, output)
|
|
return output
|
|
|
|
|
|
def runSshCmdWithPwd(cmd, host, user="", passwd="", mpprcFile=""):
|
|
"""
|
|
function: run ssh cmd with password
|
|
input : cmd, host, user, passwd, mpprcFile
|
|
output : str
|
|
"""
|
|
# Environment variables separation
|
|
if (mpprcFile):
|
|
cmd = "source '%s'; %s" % (mpprcFile, cmd)
|
|
ssh = None
|
|
try:
|
|
if (passwd):
|
|
import paramiko
|
|
cmd = "export LC_ALL=C; source /etc/profile 2>/dev/null; %s" % cmd
|
|
ssh = paramiko.SSHClient()
|
|
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
|
|
# Remote Connection
|
|
ssh.connect(host, 22, user, passwd)
|
|
stdout, stderr = ssh.exec_command(cmd)[1:3]
|
|
output = stdout.read()
|
|
error = stderr.read()
|
|
if error:
|
|
raise SshCommandException(host, cmd, error)
|
|
return output.decode()
|
|
else:
|
|
cmd = \
|
|
"pssh -s -H %s \"export LC_ALL=C; " \
|
|
"source /etc/profile 2>/dev/null; %s\"" % (
|
|
host, cmd)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if (status != 0):
|
|
raise SshCommandException(host, cmd, output)
|
|
return output
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
finally:
|
|
if (ssh):
|
|
ssh.close()
|
|
|
|
|
|
def runRootCmd(cmd, rootuser, passwd, mpprcFile=''):
|
|
"""
|
|
function: run root cmd
|
|
input : cmd, rootuser, passwd, mpprcFile
|
|
output : str
|
|
"""
|
|
if (mpprcFile):
|
|
cmd = "source '%s'; %s" % (mpprcFile, cmd)
|
|
ssh = None
|
|
try:
|
|
import paramiko
|
|
cmd = "export LC_ALL=C;source /etc/profile 2>/dev/null;export PYTHONIOENCODING=utf-8; %s" % cmd
|
|
ssh = paramiko.SSHClient()
|
|
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
|
|
ssh.connect('localhost', 22, rootuser, passwd)
|
|
stdout, stderr = ssh.exec_command(cmd, get_pty=True)[1:3]
|
|
output = stdout.read()
|
|
error = stderr.read()
|
|
if error:
|
|
raise SshCommandException(cmd, "localhost", error)
|
|
return output
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
finally:
|
|
if ssh:
|
|
ssh.close()
|
|
|
|
|
|
def verifyPasswd(host, user, pswd=None):
|
|
"""
|
|
function: verify password
|
|
Connect to the remote node
|
|
input : host, user, pswd
|
|
output : bool
|
|
"""
|
|
import paramiko
|
|
ssh = paramiko.Transport((host, 22))
|
|
try:
|
|
ssh.connect(username=user, password=pswd)
|
|
return True
|
|
except paramiko.AuthenticationException:
|
|
return False
|
|
finally:
|
|
ssh.close()
|
|
|
|
|
|
def runSqlCmd(sql, user, host, port, tmpPath, database="postgres",
|
|
mpprcFile="", maintenance=False):
|
|
"""
|
|
function : Execute sql command
|
|
input : String,String,String,int
|
|
output : String
|
|
"""
|
|
database = database.replace('$', '\$')
|
|
# Get the current time
|
|
currentTime = time.strftime("%Y-%m-%d_%H%M%S")
|
|
# Get the process ID
|
|
pid = os.getpid()
|
|
# init SQL query file
|
|
sqlFile = os.path.join(tmpPath,
|
|
"check_query.sql_%s_%s_%s" % (
|
|
str(port), str(currentTime), str(pid)))
|
|
# init SQL result file
|
|
queryResultFile = os.path.join(tmpPath,
|
|
"check_result.sql_%s_%s_%s" % (
|
|
str(port), str(currentTime), str(pid)))
|
|
# Clean up the file
|
|
cleanFile("%s,%s" % (queryResultFile, sqlFile))
|
|
|
|
# create an empty sql query file
|
|
try:
|
|
cmd = "touch %s && chmod %s %s" % \
|
|
(sqlFile, DefaultValue.KEY_FILE_MODE, sqlFile)
|
|
runShellCmd(cmd, user, mpprcFile)
|
|
except ShellCommandException as e:
|
|
raise SQLCommandException(sql,
|
|
"create sql query file failed." + e.output)
|
|
|
|
# write the SQL command into sql query file
|
|
try:
|
|
with open(sqlFile, 'w') as fp:
|
|
fp.writelines(sql)
|
|
except Exception as e:
|
|
# Clean up the file
|
|
cleanFile(sqlFile)
|
|
raise SQLCommandException(sql,
|
|
"write into sql query file failed. " + str(
|
|
e))
|
|
|
|
# read the content of query result file.
|
|
try:
|
|
# init host
|
|
hostPara = (
|
|
"-h %s" % host) \
|
|
if host != "" and host != "localhost" \
|
|
and host != NetUtil.GetHostIpOrName() else ""
|
|
# build shell command
|
|
gsql_cmd = SqlCommands.getSQLCommand(port, database)
|
|
gsql_cmd += " %s" % hostPara
|
|
cmd = "%s -f %s --output %s -t -A -X" % (gsql_cmd, sqlFile, queryResultFile)
|
|
if (maintenance):
|
|
cmd += ' -m'
|
|
# Environment variables separation
|
|
if mpprcFile != "":
|
|
cmd = "source '%s' && " % mpprcFile + cmd
|
|
# Execute the shell command
|
|
output = runShellCmd(cmd, user)
|
|
if SqlFile.findErrorInSqlFile(sqlFile, output):
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd
|
|
+ "Error:\n%s" % output)
|
|
|
|
# Reading documents
|
|
fp = None
|
|
with open(queryResultFile, 'r') as fp:
|
|
rowList = fp.readlines()
|
|
except Exception as e:
|
|
cleanFile("%s,%s" % (queryResultFile, sqlFile))
|
|
if isinstance(e, ShellCommandException):
|
|
output = e.output
|
|
else:
|
|
output = str(e)
|
|
raise SQLCommandException(sql, output)
|
|
|
|
# remove local sqlFile
|
|
cleanFile("%s,%s" % (queryResultFile, sqlFile))
|
|
|
|
return "".join(rowList)[:-1]
|
|
|
|
|
|
def runSqlSimplely(sql, user, host, port, tmpPath, database="postgres",
|
|
mpprcFile="", needmpara=False):
|
|
"""
|
|
function : Execute sql command
|
|
input : String,String,String,int
|
|
output : String
|
|
"""
|
|
# Get the current time
|
|
currentTime = time.strftime("%Y-%m-%d_%H%M%S")
|
|
# Get the process ID
|
|
pid = os.getpid()
|
|
# init SQL query file
|
|
sqlFile = os.path.join(tmpPath,
|
|
"check_query.sql_%s_%s_%s" % (
|
|
str(port), str(currentTime), str(pid)))
|
|
|
|
# Clean up the file
|
|
if (os.path.exists(sqlFile)):
|
|
cleanFile("%s" % (sqlFile))
|
|
|
|
# create an empty sql query file
|
|
try:
|
|
cmd = "touch %s && chmod %s %s" % \
|
|
(sqlFile, DefaultValue.KEY_FILE_MODE, sqlFile)
|
|
runShellCmd(cmd, user, mpprcFile)
|
|
except ShellCommandException as e:
|
|
raise SQLCommandException(sql, "create sql query file failed.")
|
|
|
|
# write the SQL command into sql query file
|
|
try:
|
|
with open(sqlFile, 'w') as fp:
|
|
fp.writelines(sql)
|
|
except Exception as e:
|
|
# Clean up the file
|
|
cleanFile(sqlFile)
|
|
raise SQLCommandException(sql,
|
|
"write into sql query file failed. " + str(
|
|
e))
|
|
|
|
# read the content of query result file.
|
|
try:
|
|
# init host
|
|
hostPara = (
|
|
"-h %s" % host) \
|
|
if host != "" and host != "localhost" else ""
|
|
# build shell command
|
|
if (needmpara):
|
|
cmd = "gsql %s -p %s -d %s -f %s -m" % (
|
|
hostPara, port, database, sqlFile)
|
|
else:
|
|
cmd = "gsql %s -p %s -d %s -f %s" % (
|
|
hostPara, port, database, sqlFile)
|
|
# Environment variables separation
|
|
if mpprcFile != "":
|
|
cmd = "source '%s' && " % mpprcFile + cmd
|
|
# Execute the shell command
|
|
output = runShellCmd(cmd, user)
|
|
if SqlFile.findErrorInSqlFile(sqlFile, output):
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd
|
|
+ "Error:\n%s" % output)
|
|
|
|
# Reading documents
|
|
except Exception as e:
|
|
cleanFile("%s" % (sqlFile))
|
|
if isinstance(e, ShellCommandException):
|
|
output = e.output
|
|
else:
|
|
output = str(e)
|
|
raise SQLCommandException(sql, output)
|
|
|
|
# remove local sqlFile
|
|
cleanFile("%s" % (sqlFile))
|
|
|
|
return output
|
|
|
|
|
|
def cleanFile(fileName, hostname=""):
|
|
"""
|
|
function : remove file
|
|
input : String,hostname
|
|
output : NA
|
|
"""
|
|
fileList = fileName.split(",")
|
|
cmd = ""
|
|
for fileStr in fileList:
|
|
if cmd != "":
|
|
cmd += ';(if [ -f %s ];then rm -f %s;fi)' % (fileStr, fileStr)
|
|
else:
|
|
cmd = '(if [ -f %s ];then rm -f %s;fi)' % (fileStr, fileStr)
|
|
if hostname == "":
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if (status != 0):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50207"] % "file"
|
|
+ " Error: \n%s." % output
|
|
+ "The cmd is %s " % cmd)
|
|
else:
|
|
sshCmd = "pssh -s -H %s '%s'" % (hostname, cmd)
|
|
(status, output) = subprocess.getstatusoutput(sshCmd)
|
|
if (status != 0):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50207"] % "file"
|
|
+ " Error: \n%s." % output
|
|
+ "The cmd is %s " % sshCmd)
|
|
|
|
|
|
def checkComplete(checkId, host, hostname, user, tmpPath, passwd=None):
|
|
"""
|
|
function: check whether has completed or not
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
cmd = "cd %s && ls -l |grep %s_%s.out|wc -l" % (tmpPath, hostname, checkId)
|
|
if (is_local_node(host)):
|
|
output = runShellCmd(cmd, user)
|
|
elif (passwd):
|
|
output = runSshCmdWithPwd(cmd, host, user, passwd)
|
|
else:
|
|
output = runSshCmd(cmd, host, user)
|
|
if (len(output.splitlines()) > 1):
|
|
output = output.splitlines()[-1]
|
|
return output
|
|
|
|
|
|
def getVersion():
|
|
"""
|
|
Get current file version by VersionInfo
|
|
|
|
"""
|
|
return ("%s %s" % (sys.argv[0].split("/")[-1], VersionInfo.COMMON_VERSION))
|
|
|
|
|
|
def createFile(fileName, path, permission=FILE_MODE, user=""):
|
|
# file path
|
|
fileName = os.path.join(path, fileName)
|
|
# Create a file
|
|
FileUtil.createFile(fileName, True, permission)
|
|
# change owner
|
|
if (user):
|
|
FileUtil.changeOwner(user, fileName)
|
|
return fileName
|
|
|
|
|
|
def chmodFile(fileName, permission=FILE_MODE, user=""):
|
|
# Modify the file permissions
|
|
FileUtil.changeMode(permission, fileName)
|
|
if (user):
|
|
FileUtil.changeOwner(user, fileName)
|
|
|
|
|
|
def writeFile(fileName, content, path, permission=FILE_MODE, user=""):
|
|
"""
|
|
function: write file
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
filePath = os.path.join(path, fileName)
|
|
# Create a file
|
|
FileUtil.createFile(filePath, True, permission)
|
|
# Modify the file permissions
|
|
if (user):
|
|
FileUtil.changeOwner(user, filePath)
|
|
FileUtil.writeFile(filePath, [content])
|
|
|
|
|
|
def readFile(fileName):
|
|
# Get the contents of the file
|
|
text = FileUtil.readFile(fileName)
|
|
return "\n".join(text)
|
|
|
|
|
|
def sendFile(fileName, host, user, path, passwd=None):
|
|
# Copy files remotely
|
|
t = None
|
|
if (passwd):
|
|
try:
|
|
import paramiko
|
|
t = paramiko.Transport((host, 22))
|
|
t.connect(username=user, password=passwd)
|
|
sftp = paramiko.SFTPClient.from_transport(t)
|
|
sftp.put(fileName, os.path.join(path, os.path.basename(fileName)))
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
finally:
|
|
if (t):
|
|
t.close()
|
|
else:
|
|
if "HOST_IP" not in list(os.environ.keys()):
|
|
host = "%s@%s" % (user, host)
|
|
cmd = "pscp -H %s '%s' %s" % (host, fileName, path)
|
|
if (os.getuid() == 0):
|
|
cmd = "su - %s -c \"%s\"" % (user, cmd)
|
|
runShellCmd(cmd)
|
|
|
|
|
|
def receiveFile(fileName, host, user, path, passwd=None):
|
|
# Receive remote files
|
|
t = None
|
|
if (passwd):
|
|
try:
|
|
import paramiko
|
|
t = paramiko.Transport((host, 22))
|
|
t.connect(username=user, password=passwd)
|
|
sftp = paramiko.SFTPClient.from_transport(t)
|
|
if (type(fileName) == list):
|
|
for fname in fileName:
|
|
sftp.get(fname,
|
|
os.path.join(path, os.path.basename(fname)))
|
|
else:
|
|
sftp.get(fileName, os.path.join(path, fileName))
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
finally:
|
|
if (t):
|
|
t.close()
|
|
else:
|
|
if "HOST_IP" not in list(os.environ.keys()):
|
|
host = "%s@%s" % (user, host)
|
|
cmd = "pssh -s -H %s 'pscp -H %s %s %s' " % (
|
|
host, NetUtil.GetHostIpOrName(), fileName, path)
|
|
if (os.getuid() == 0):
|
|
cmd = "su - %s -c \"%s\"" % (user, cmd)
|
|
runShellCmd(cmd)
|
|
|
|
|
|
def getCurrentUser():
|
|
return pwd.getpwuid(os.getuid())[0]
|
|
|
|
|
|
def checkAuthentication(host, user):
|
|
"""
|
|
function: check authentication
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
cmd = 'pssh -s -H %s true' % host
|
|
try:
|
|
runSshCmd(cmd, host, user)
|
|
except Exception:
|
|
return (False, host)
|
|
return (True, host)
|
|
|
|
|
|
def checkClusterUser(username, mpprcFile=''):
|
|
"""
|
|
function: check cluster user
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
try:
|
|
pwd.getpwnam(username).pw_gid
|
|
except Exception:
|
|
return False
|
|
mpprc = mpprcFile if mpprcFile else '~/.bashrc'
|
|
cmd = "echo \"%s$GAUSS_ENV\" 2>/dev/null" % (
|
|
"\\" if (username and username != getCurrentUser()) else "")
|
|
try:
|
|
output = runShellCmd(cmd, username, mpprc)
|
|
gaussEnv = output.split("\n")[0]
|
|
if not gaussEnv:
|
|
return False
|
|
except Exception:
|
|
return False
|
|
return True
|
|
|
|
|
|
def getMasterDnNum(user, mpprcFile):
|
|
"""
|
|
function : get cluster master DB number
|
|
input : string, string
|
|
output : List
|
|
"""
|
|
masterDnList = []
|
|
cmd = "gs_om -t query |grep Primary"
|
|
output = runShellCmd(cmd, user, mpprcFile)
|
|
line = output.splitlines()[0]
|
|
instanceinfo = line.split()
|
|
for idx in range(len(instanceinfo)):
|
|
if (instanceinfo[idx] == "Primary"):
|
|
if (idx > 2 and instanceinfo[idx - 2].isdigit()):
|
|
masterDnList.append(int(instanceinfo[idx - 2]))
|
|
return masterDnList
|
|
|
|
|
|
def checkBondMode(bondingConfFile):
|
|
"""
|
|
function : Check Bond mode
|
|
input : String, bool
|
|
output : List
|
|
"""
|
|
|
|
netNameList = []
|
|
cmd = "grep -w 'Bonding Mode' %s | awk -F ':' '{print $NF}'" \
|
|
% bondingConfFile
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if (status != 0 or output.strip() == ""):
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51403"] % "Bonding Mode" +
|
|
"The cmd is %s " % cmd)
|
|
cmd = "grep -w 'Slave Interface' %s | awk -F ':' '{print $NF}'" \
|
|
% bondingConfFile
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if (status != 0):
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51403"] %
|
|
"Slave Interface" + "The cmd is %s " % cmd)
|
|
|
|
for networkname in output.split('\n'):
|
|
netNameList.append(networkname.strip())
|
|
return netNameList
|
|
|
|
|
|
def is_local_node(host):
|
|
"""
|
|
function: check whether is or not local node
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
if (host == NetUtil.GetHostIpOrName()):
|
|
return True
|
|
allNetworkInfo = NetUtil.getAllNetworkIp()
|
|
for network in allNetworkInfo:
|
|
if (host == network.ipAddress):
|
|
return True
|
|
return False
|
|
|
|
|
|
def validate_ipv4(ip_str):
|
|
"""
|
|
function: check whether is or not validate ipv4
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
sep = ip_str.split('.')
|
|
if len(sep) != 4:
|
|
return False
|
|
for i, x in enumerate(sep):
|
|
try:
|
|
int_x = int(x)
|
|
if int_x < 0 or int_x > 255:
|
|
return False
|
|
except ValueError:
|
|
return False
|
|
return True
|
|
|
|
|
|
def SetLimitsConf(typeList, item, value, limitFile):
|
|
"""
|
|
function: set limits conf
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
for typeName in typeList:
|
|
cmd = """sed -i '/^.* %s *%s .*$/d' %s &&
|
|
echo "* %s %s %s" >> %s""" % (
|
|
typeName, item, limitFile, typeName, item, value, limitFile)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if (status != 0):
|
|
return "Failed to set variable '%s %s'. Error: \n%s." % (
|
|
typeName, item, output) + "The cmd is %s " % cmd
|
|
return "Success"
|
|
|
|
|
|
def isSupportSystemOs():
|
|
"""
|
|
function: check whether is or not redhat
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
osName = LinuxDistro.linux_distribution()[0]
|
|
if osName in ["redhat", "centos", "euleros", "openEuler", "FusionOS"]:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
|
|
def getInitFile():
|
|
"""
|
|
function: get init file
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
if isSupportSystemOs():
|
|
return INIT_FILE_REDHAT
|
|
else:
|
|
return INIT_FILE_SUSE
|
|
|
|
|
|
def getNICNum(ipAddress):
|
|
"""
|
|
function: get nic num
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
if g_Platform.isPlatFormEulerOSOrRHEL7X():
|
|
cmd = "/sbin/ifconfig -a | grep -B1 \"inet %s \" | " \
|
|
"grep -v \"inet %s \" | awk '{print $1}'" % (
|
|
ipAddress, ipAddress)
|
|
else:
|
|
cmd = "/sbin/ifconfig -a | grep -B1 \"addr:%s \" | " \
|
|
"grep -v \"addr:%s \" | awk '{print $1}'" % (
|
|
ipAddress, ipAddress)
|
|
output = runShellCmd(cmd)
|
|
if g_Platform.isPlatFormEulerOSOrRHEL7X():
|
|
return output.strip()[:-1]
|
|
else:
|
|
return output.strip()
|
|
|
|
|
|
def getIpByHostName(host):
|
|
"""
|
|
function: get ip by hostname
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
ipList = FileUtil.readFile("/etc/hosts", host)
|
|
|
|
pattern = re.compile(
|
|
r'^[1-9 \t].*%s[ \t]*#Gauss.* IP Hosts Mapping' % host)
|
|
for ipInfo in ipList:
|
|
match = pattern.match(ipInfo.strip())
|
|
if (match):
|
|
return match.group().split(' ')[0].strip()
|
|
#If no ip address is found, the first ip address
|
|
# that is not commented out is returned
|
|
for ip_info in ipList:
|
|
ip_info = ip_info.replace("\t", " ").strip()
|
|
if not ip_info.startswith("#"):
|
|
return ip_info.split(' ')[0]
|
|
|
|
# get local host by os function
|
|
# Replace host with the IP address.
|
|
hostIp = host
|
|
return hostIp
|
|
|
|
|
|
def getNetWorkConfFile(networkCardNum):
|
|
"""
|
|
function: get network conf file
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
SuSENetWorkConfPath = "/etc/sysconfig/network"
|
|
RedHatNetWorkConfPath = "/etc/sysconfig/network-scripts"
|
|
if isSupportSystemOs():
|
|
NetWorkConfFile = "%s/ifcfg-%s" % (
|
|
RedHatNetWorkConfPath, networkCardNum)
|
|
else:
|
|
NetWorkConfFile = "%s/ifcfg-%s" % (SuSENetWorkConfPath, networkCardNum)
|
|
|
|
if (not os.path.exists(NetWorkConfFile)):
|
|
if isSupportSystemOs():
|
|
cmd = "find %s -iname 'ifcfg-*-%s' -print" % (
|
|
RedHatNetWorkConfPath, networkCardNum)
|
|
else:
|
|
cmd = "find %s -iname 'ifcfg-*-%s' -print" % (
|
|
SuSENetWorkConfPath, networkCardNum)
|
|
output = runShellCmd(cmd)
|
|
if (DefaultValue.checkDockerEnv() and
|
|
output.find("No such file or directory") >= 0):
|
|
return output.strip()
|
|
if (output.strip() == "" or len(output.split('\n')) != 1):
|
|
if DefaultValue.checkDockerEnv():
|
|
return ""
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"]
|
|
% NetWorkConfFile)
|
|
NetWorkConfFile = output.strip()
|
|
return NetWorkConfFile
|
|
|
|
|
|
def CheckNetWorkBonding(serviceIP):
|
|
"""
|
|
function: check network bonding
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
networkCardNum = getNICNum(serviceIP)
|
|
NetWorkConfFile = getNetWorkConfFile(networkCardNum)
|
|
if ((NetWorkConfFile.find("No such file or directory") >= 0
|
|
or NetWorkConfFile == "") and DefaultValue.checkDockerEnv()):
|
|
return "Shell command faild"
|
|
bondingConfFile = "/proc/net/bonding/%s" % networkCardNum
|
|
networkCardNumList = [networkCardNum]
|
|
cmd = "grep -i 'BONDING_OPTS\|BONDING_MODULE_OPTS' %s" % NetWorkConfFile
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if ((status == 0) and (output.strip() != "")):
|
|
if ((output.find("mode") > 0) and os.path.exists(bondingConfFile)):
|
|
networkCardNumList = networkCardNumList + checkBondMode(
|
|
bondingConfFile)
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_506["GAUSS_50611"] +
|
|
"The cmd is %s " % cmd)
|
|
return networkCardNumList
|
|
|
|
|
|
|
|
def getTHPandOSInitFile():
|
|
"""
|
|
function : We know that the centos have same init file
|
|
and THP file as RedHat.
|
|
input : NA
|
|
output : String, String
|
|
"""
|
|
THPFile = "/sys/kernel/mm/transparent_hugepage/enabled"
|
|
initFile = getOSInitFile()
|
|
if (initFile == ""):
|
|
raise Exception(ErrorCode.GAUSS_506["GAUSS_50618"]
|
|
% "startup file of current OS")
|
|
return (THPFile, initFile)
|
|
|
|
|
|
def getOSInitFile():
|
|
"""
|
|
function : Get the OS initialization file
|
|
input : NA
|
|
output : String
|
|
"""
|
|
distname = LinuxDistro.linux_distribution()[0]
|
|
systemd_system_dir = "/usr/lib/systemd/system/"
|
|
systemd_system_file = "/usr/lib/systemd/system/gs-OS-set.service"
|
|
# OS init file
|
|
# now we only support SuSE and RHEL
|
|
initFileSuse = "/etc/init.d/boot.local"
|
|
initFileRedhat = "/etc/rc.d/rc.local"
|
|
# system init file
|
|
initSystemFile = "/usr/local/gauss/script/gauss-OS-set.sh"
|
|
dirName = os.path.dirname(os.path.realpath(__file__))
|
|
# Get the startup file of suse or redhat os
|
|
if (os.path.isdir(systemd_system_dir)):
|
|
if (not os.path.exists(systemd_system_file)):
|
|
cmd = "cp '%s'/gs-OS-set.service '%s'; chmod %s '%s'" % (
|
|
dirName, systemd_system_file, DefaultValue.KEY_FILE_MODE,
|
|
systemd_system_file)
|
|
runShellCmd(cmd)
|
|
cmd = "systemctl enable gs-OS-set.service"
|
|
runShellCmd(cmd)
|
|
if (not os.path.exists(initSystemFile)):
|
|
cmd = "mkdir -p '%s'" % os.path.dirname(initSystemFile)
|
|
runShellCmd(cmd)
|
|
FileUtil.createFileInSafeMode(initSystemFile)
|
|
with open(initSystemFile, "w") as fp:
|
|
fp.write("#!/bin/bash\n")
|
|
cmd = "chmod %s '%s'" % (DefaultValue.KEY_FILE_MODE, initSystemFile)
|
|
runShellCmd(cmd)
|
|
return initSystemFile
|
|
if (distname == "SuSE" and os.path.isfile(initFileSuse)):
|
|
initFile = initFileSuse
|
|
elif (distname in (
|
|
"redhat", "centos", "euleros", "openEuler", "FusionOS") and os.path.isfile(
|
|
initFileRedhat)):
|
|
initFile = initFileRedhat
|
|
else:
|
|
initFile = ""
|
|
return initFile
|
|
|
|
|
|
def getMaskByIP(IPAddr):
|
|
"""
|
|
function: get netMask by ip addr
|
|
"""
|
|
if g_Platform.isPlatFormEulerOSOrRHEL7X():
|
|
cmd = "/sbin/ifconfig -a |grep -E '\<%s\>'| awk '{print $4}'" % IPAddr
|
|
else:
|
|
cmd = \
|
|
"/sbin/ifconfig -a |grep -E '\<%s\>'| awk -F ':' '{print $NF}'" \
|
|
% IPAddr
|
|
netMask = runShellCmd(cmd)
|
|
return netMask
|