2000 lines
65 KiB
Python
2000 lines
65 KiB
Python
# -*- coding:utf-8 -*-
|
|
#############################################################################
|
|
# Portions Copyright (c) 2020 Huawei Technologies Co.,Ltd.
|
|
# Portions Copyright (c) 1999-2000, Marc-Andre Lemburg; mailto:mal@lemburg.com
|
|
# Portions Copyright (c) 2000-2010, eGenix.com Software GmbH; mailto:info@egenix.com
|
|
#
|
|
# 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.
|
|
# ----------------------------------------------------------------------------
|
|
# Description : gsplatform.py is a utility to do something for
|
|
# platform information.
|
|
#############################################################################
|
|
|
|
""" 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 re
|
|
import subprocess
|
|
import platform
|
|
import socket
|
|
import time
|
|
|
|
sys.path.append(sys.path[0] + "/../../")
|
|
from gspylib.common.ErrorCode import ErrorCode
|
|
|
|
localDirPath = os.path.dirname(os.path.realpath(__file__))
|
|
sys.path.insert(0, localDirPath + "/../../../lib/netifaces/")
|
|
sys.path.append(localDirPath + "/../inspection/lib/netifaces/")
|
|
try:
|
|
from netifaces import interfaces, ifaddresses, AF_INET, AF_INET6
|
|
except ImportError as e:
|
|
# get python unicode value. The current environment python is compiled
|
|
# with UCS2 or UCS4.
|
|
# 1114111 is UCS4
|
|
# 65535 is UCS2
|
|
flagNum = 4 if sys.maxunicode == 1114111 else 2
|
|
omToolsNetifacesPath = os.path.join(
|
|
localDirPath, "./../../../lib/netifaces/netifaces.so")
|
|
inspectToolsNetifacesPath = os.path.join(
|
|
localDirPath, "./../../../script/gspylib/inspection/\
|
|
lib/netifaces/netifaces.so")
|
|
newPythonDependNetifacesPath = "%s_UCS%d" % (omToolsNetifacesPath,
|
|
flagNum)
|
|
glo_cmd = "rm -f '%s' && " \
|
|
"cp -f -p '%s' '%s' " % (omToolsNetifacesPath,
|
|
newPythonDependNetifacesPath,
|
|
omToolsNetifacesPath)
|
|
glo_cmd += " && rm -f '%s' && " \
|
|
"cp -f -p '%s' '%s' " % (inspectToolsNetifacesPath,
|
|
newPythonDependNetifacesPath,
|
|
inspectToolsNetifacesPath)
|
|
flagExce = True
|
|
for retryNum in range(3):
|
|
(statusExec, outputExec) = subprocess.getstatusoutput(glo_cmd)
|
|
if statusExec != 0:
|
|
flagExce = False
|
|
time.sleep(1)
|
|
else:
|
|
flagExce = True
|
|
break
|
|
if not flagExce:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % glo_cmd
|
|
+ "Error:\n%s" % outputExec)
|
|
from netifaces import interfaces, ifaddresses, AF_INET, AF_INET6
|
|
|
|
# ---------------platforms--------------------
|
|
# global variable for our platform
|
|
_supported_dists = (
|
|
'SuSE', 'debian', 'fedora', 'redhat', 'centos', 'euleros', "openEuler",
|
|
'mandrake', 'mandriva', 'rocks', 'slackware', 'yellowdog', 'gentoo',
|
|
'UnitedLinux', 'turbolinux')
|
|
_release_filename = re.compile(r'(\w+)[-_](release|version)')
|
|
_lsb_release_version = re.compile(r'(.+)'
|
|
' release '
|
|
'([\d.]+)'
|
|
'[^(]*(?:\((.+)\))?')
|
|
_release_version = re.compile(r'([^0-9]+)'
|
|
'(?: release )?'
|
|
'([\d.]+)'
|
|
'[^(]*(?:\((.+)\))?')
|
|
SUSE = "suse"
|
|
REDHAT = "redhat"
|
|
CENTOS = "centos"
|
|
EULEROS = "euleros"
|
|
KYLIN = "kylin"
|
|
OPENEULER = "openeuler"
|
|
ASIANUX = "asianux"
|
|
SUPPORT_WHOLE_PLATFORM_LIST = [SUSE, REDHAT, CENTOS, EULEROS,
|
|
OPENEULER, KYLIN, ASIANUX]
|
|
# RedhatX platform
|
|
SUPPORT_RHEL_SERIES_PLATFORM_LIST = [REDHAT, CENTOS, "kylin", "asianux"]
|
|
SUPPORT_RHEL6X_VERSION_LIST = ["6.4", "6.5", "6.6", "6.7", "6.8", "6.9", "10"]
|
|
SUPPORT_RHEL7X_VERSION_LIST = ["7.0", "7.1", "7.2", "7.3", "7.4", "7.5", "7.6", "10"]
|
|
SUPPORT_RHEL_SERIES_VERSION_LIST = (SUPPORT_RHEL6X_VERSION_LIST +
|
|
SUPPORT_RHEL7X_VERSION_LIST)
|
|
# EulerOS 2.3 -> 2.0 SP3
|
|
SUPPORT_EULEROS_VERSION_LIST = ["2.0"]
|
|
# SuSE platform
|
|
SUSE11 = "11"
|
|
SUSE12 = "12"
|
|
SUPPORT_SUSE_VERSION_LIST = [SUSE11, SUSE12]
|
|
SUPPORT_SUSE11X_VERSION_LIST = ["1", "2", "3", "4"]
|
|
SUPPORT_RHEL12X_VERSION_LIST = ["0", "1", "2", "3"]
|
|
BIT_VERSION = "64bit"
|
|
|
|
# ---------------command path--------------------
|
|
CMD_PATH = ['/bin', '/usr/local/bin', '/usr/bin', '/sbin', '/usr/sbin']
|
|
CMD_CACHE = {}
|
|
BLANK_SPACE = " "
|
|
COLON = ":"
|
|
# Need to be consistent with the packaging script
|
|
PAK_CENTOS = "CentOS"
|
|
PAK_EULER = "Euler"
|
|
PAK_OPENEULER = "openEuler"
|
|
PAK_REDHAT = "RedHat"
|
|
PAK_ASIANUX = "asianux"
|
|
|
|
#######################################################
|
|
_supported_dists = (
|
|
'SuSE', 'debian', 'fedora', 'redhat', 'centos', 'euleros', "openEuler",
|
|
'mandrake', 'mandriva', 'rocks', 'slackware', 'yellowdog', 'gentoo',
|
|
'UnitedLinux', 'turbolinux', 'kylin', 'asianux')
|
|
_release_filename = re.compile(r'(\w+)[-_](release|version)')
|
|
_lsb_release_version = re.compile(r'(.+)'
|
|
' release '
|
|
'([\d.]+)'
|
|
'[^(]*(?:\((.+)\))?')
|
|
_release_version = re.compile(r'([^0-9]+)'
|
|
'(?: release )?'
|
|
'([\d.]+)'
|
|
'[^(]*(?:\((.+)\))?')
|
|
|
|
|
|
def _parse_release_file(firstline):
|
|
"""
|
|
Default to empty 'version' and 'id' strings. Both defaults are used
|
|
when 'firstline' is empty. 'id' defaults to empty when an id can not
|
|
be deduced.
|
|
"""
|
|
version = ''
|
|
idNum = ''
|
|
|
|
# Parse the first line
|
|
m = _lsb_release_version.match(firstline)
|
|
if m is not None:
|
|
# LSB format: "distro release x.x (codename)"
|
|
return tuple(m.groups())
|
|
|
|
# Pre-LSB format: "distro x.x (codename)"
|
|
m = _release_version.match(firstline)
|
|
if m is not None:
|
|
return tuple(m.groups())
|
|
|
|
# Unkown format... take the first two words
|
|
l = str.split(str.strip(firstline))
|
|
if l:
|
|
version = l[0]
|
|
if len(l) > 1:
|
|
idNum = l[1]
|
|
return '', version, idNum
|
|
|
|
|
|
def linux_distribution(distname='', version='', idNum='',
|
|
supported_dists=_supported_dists,
|
|
full_distribution_name=1):
|
|
"""
|
|
Tries to determine the name of the Linux OS distribution name.
|
|
|
|
The function first looks for a distribution release file in
|
|
/etc and then reverts to _dist_try_harder() in case no
|
|
suitable files are found.
|
|
|
|
supported_dists may be given to define the set of Linux
|
|
distributions to look for. It defaults to a list of currently
|
|
supported Linux distributions identified by their release file
|
|
name.
|
|
|
|
If full_distribution_name is true (default), the full
|
|
distribution read from the OS is returned. Otherwise the short
|
|
name taken from supported_dists is used.
|
|
|
|
Returns a tuple (distname,version,id) which default to the
|
|
args given as parameters.
|
|
|
|
"""
|
|
try:
|
|
etc = os.listdir('/etc')
|
|
except os.error:
|
|
# Probably not a Unix system
|
|
return distname, version, idNum
|
|
sortEtc = sorted(etc)
|
|
gFile = None
|
|
for file in sortEtc:
|
|
if os.path.islink('/etc/' + file):
|
|
continue
|
|
m = _release_filename.match(file)
|
|
if m is not None:
|
|
_distname, dummy = m.groups()
|
|
if _distname in supported_dists:
|
|
gFile = file
|
|
distname = _distname
|
|
break
|
|
|
|
# Read the first line
|
|
if gFile is None:
|
|
return distname, version, idNum
|
|
with open('/etc/' + gFile, 'r') as f:
|
|
firstline = f.readline()
|
|
_distname, _version, _id = _parse_release_file(firstline)
|
|
|
|
if _distname and full_distribution_name:
|
|
distname = _distname
|
|
if _version:
|
|
version = _version
|
|
if _id:
|
|
idNum = _id
|
|
return distname, version, idNum
|
|
|
|
|
|
def dist(supported_dists=_supported_dists):
|
|
""" Tries to determine the name of the Linux OS distribution name.
|
|
|
|
The function first looks for a distribution release file in
|
|
/etc and then reverts to _dist_try_harder() in case no
|
|
suitable files are found.
|
|
|
|
Returns a tuple (distname,version,id) which default to the
|
|
args given as parameters.
|
|
|
|
"""
|
|
return linux_distribution(supported_dists=supported_dists,
|
|
full_distribution_name=0)
|
|
|
|
|
|
# ------------------platform module----------------------
|
|
class CommandNotFoundException(Exception):
|
|
"""
|
|
"""
|
|
|
|
def __init__(self, cmd, paths):
|
|
"""
|
|
function: constructor
|
|
"""
|
|
self.cmd = cmd
|
|
self.paths = paths
|
|
|
|
def __str__(self):
|
|
"""
|
|
function: str
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
return "Could not locate command: '%s' in this " \
|
|
"set of paths: %s" % (self.cmd, repr(self.paths))
|
|
|
|
|
|
def findCmdInPath(cmd, additionalPaths=None, printError=True):
|
|
"""
|
|
function: find cmd in path
|
|
input: cmd, additionalPaths, printError
|
|
output: NA
|
|
"""
|
|
global CMD_CACHE
|
|
if additionalPaths is None:
|
|
additionalPaths = []
|
|
if cmd not in CMD_CACHE:
|
|
# Search additional paths and don't add to cache.
|
|
for p in additionalPaths:
|
|
f = os.path.join(p, cmd)
|
|
if os.path.exists(f):
|
|
return f
|
|
|
|
for p in CMD_PATH:
|
|
f = os.path.join(p, cmd)
|
|
if os.path.exists(f):
|
|
CMD_CACHE[cmd] = f
|
|
return f
|
|
|
|
if cmd == "killall":
|
|
gphome = os.getenv("GPHOME")
|
|
if gphome is None or \
|
|
not os.path.exists(os.path.join(gphome, "script/killall")):
|
|
gphome = os.path.dirname(os.path.realpath(__file__))\
|
|
+ "/../../.."
|
|
gphome = gphome.replace("\\", "\\\\").replace('"', '\\"\\"')
|
|
for rac in ["|", ";", "&", "$", "<", ">", "`", "\\", "'", "\"",
|
|
"{", "}", "(", ")", "[", "]", "~", "*",
|
|
"?", " ", "!", "\n"]:
|
|
if rac in gphome:
|
|
raise Exception(
|
|
ErrorCode.GAUSS_502["GAUSS_50219"] % gphome
|
|
+ " There are illegal characters in the path.")
|
|
if gphome != "" and os.path.exists(os.path.join(gphome,
|
|
"script/killall")):
|
|
return os.path.join(gphome, "script/killall")
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50201"] % "killall")
|
|
|
|
if printError:
|
|
print('Command %s not found' % cmd)
|
|
search_path = CMD_PATH[:]
|
|
search_path.extend(additionalPaths)
|
|
raise CommandNotFoundException(cmd, search_path)
|
|
else:
|
|
return CMD_CACHE[cmd]
|
|
|
|
|
|
# Requirements:
|
|
# 1. ulimit, ntpq, source, kerberos is not found under system path
|
|
|
|
|
|
class GenericPlatform:
|
|
"""
|
|
manage OS command,config or service for muti-platform
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
function: constructor
|
|
"""
|
|
pass
|
|
|
|
def echoCmdWithNoReturn(self, line, filePath):
|
|
"""
|
|
function: echo cmd with no return
|
|
input : line, filePath
|
|
output : str
|
|
"""
|
|
cmd = "echo %s >> '%s' 2>/dev/null" % (line, filePath)
|
|
return cmd
|
|
|
|
def getCreateFileCmd(self, path):
|
|
"""
|
|
function: get create file cmd
|
|
input : path
|
|
output : str
|
|
"""
|
|
cmd = "touch '%s'" % path
|
|
return cmd
|
|
|
|
def getMoveFileCmd(self, src, dest):
|
|
"""
|
|
function: get move file cmd
|
|
input : src, dest
|
|
output : str
|
|
"""
|
|
cmd = "mv '%s' '%s'" % (src, dest)
|
|
return cmd
|
|
|
|
def get_machine_arch_cmd(self):
|
|
"""
|
|
function: get machine arch cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return 'uname -i'
|
|
|
|
def getDefaultLocale(self):
|
|
"""
|
|
function: get default locale
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return 'en_US.utf-8'
|
|
|
|
def getRemoveCmd(self, pathType):
|
|
"""
|
|
function: get remove cmd
|
|
input : pathType
|
|
output : str
|
|
"""
|
|
opts = " "
|
|
if pathType == "file":
|
|
opts = " -f "
|
|
elif pathType == "directory":
|
|
opts = " -rf "
|
|
return findCmdInPath('rm') + opts
|
|
|
|
def getChmodCmd(self, Permission, src, recursive=False):
|
|
"""
|
|
function: get chmod cmd
|
|
input : Permission, src, recursive
|
|
output : str
|
|
"""
|
|
return findCmdInPath('chmod') + \
|
|
(" -R " if recursive else BLANK_SPACE) + \
|
|
Permission + BLANK_SPACE + src
|
|
|
|
def getChownCmd(self, owner, group, src, recursive=False):
|
|
"""
|
|
function: get chown cmd
|
|
input : owner, group, src, recursive
|
|
output : str
|
|
"""
|
|
return findCmdInPath('chown') + \
|
|
(" -R " if recursive else BLANK_SPACE) + owner + \
|
|
COLON + group + BLANK_SPACE + src
|
|
|
|
def getCopyCmd(self, src, dest, pathType=""):
|
|
"""
|
|
function: get copy cmd
|
|
input : src, dest, pathType
|
|
output : str
|
|
"""
|
|
opts = " "
|
|
if pathType == "directory":
|
|
opts = " -r "
|
|
return findCmdInPath('cp') + " -p -f " + opts + BLANK_SPACE + "'" + \
|
|
src + "'" + BLANK_SPACE + "'" + dest + "'"
|
|
|
|
def getRemoteCopyCmd(self, src, dest, remoteHost, copyTo=True,
|
|
pathType="", otherHost=None):
|
|
"""
|
|
function: get remote copy cmd
|
|
input : src, dest, remoteHost, copyTo=True,
|
|
pathType="", otherHost
|
|
output : str
|
|
"""
|
|
opts = " "
|
|
if pathType == "directory":
|
|
opts = " -r "
|
|
if copyTo:
|
|
return "pscp -x '%s' -H %s %s %s " % (opts.strip(),
|
|
remoteHost, src, dest)
|
|
else:
|
|
localhost = self.getLocalIp()
|
|
if otherHost is not None:
|
|
localhost = otherHost
|
|
return "pssh -s -H %s \" pscp -x '%s' -H %s %s %s \" " % (
|
|
remoteHost, opts.strip(), localhost, src, dest)
|
|
|
|
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 getLocalIp(self):
|
|
"""
|
|
function: Obtaining the local IP address
|
|
input: NA
|
|
output: str
|
|
"""
|
|
return self.getHostName()
|
|
|
|
def getScpCmd(self):
|
|
"""
|
|
Get scp cmd for special remotely copy, just like remote to
|
|
remote or remote to local.
|
|
:return: str
|
|
"""
|
|
return "pscp -H "
|
|
|
|
def getUseraddCmd(self, user, group):
|
|
"""
|
|
function: get user add cmd
|
|
input : user, group
|
|
output : str
|
|
"""
|
|
return findCmdInPath('useradd') + " -m " + user + " -g " + group
|
|
|
|
def getUserdelCmd(self, user):
|
|
"""
|
|
function: get userdel cmd
|
|
input : user
|
|
output : str
|
|
"""
|
|
return findCmdInPath('userdel') + " -r " + user
|
|
|
|
def getGroupaddCmd(self, group):
|
|
"""
|
|
function: get group add cmd
|
|
input : group
|
|
output : str
|
|
"""
|
|
return findCmdInPath('groupadd') + " " + group
|
|
|
|
def getGroupdelCmd(self, group):
|
|
"""
|
|
function: get group del cmd
|
|
input : group
|
|
output : str
|
|
"""
|
|
return findCmdInPath('groupdel') + " " + group
|
|
|
|
def getMoveCmd(self, src, dest):
|
|
"""
|
|
function: get move cmd
|
|
input : src, dest
|
|
output : str
|
|
"""
|
|
return findCmdInPath('mv') + " -f " + "'" + src + \
|
|
"'" + BLANK_SPACE + "'" + dest + "'"
|
|
|
|
def getMakeDirCmd(self, src, recursive=False):
|
|
"""
|
|
function: get make dir cmd
|
|
input : src, recursive
|
|
output : str
|
|
"""
|
|
return findCmdInPath('mkdir') + \
|
|
(" -p " if recursive else BLANK_SPACE) + "'" + src + "'"
|
|
|
|
def getPingCmd(self, host, count, interval, packetSize=56):
|
|
"""
|
|
function: get ping cmd
|
|
input : host, count, interval, packetSize
|
|
output : str
|
|
"""
|
|
opts = " "
|
|
if int(packetSize) != int(56):
|
|
opts = " -s " + str(packetSize)
|
|
return findCmdInPath('ping') + BLANK_SPACE + host + " -c " + \
|
|
count + " -i " + interval + opts
|
|
|
|
def getWcCmd(self):
|
|
"""
|
|
function: get wc cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('wc')
|
|
|
|
def getTarCmd(self):
|
|
"""
|
|
function: get tar cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('tar')
|
|
|
|
def getZipCmd(self):
|
|
"""
|
|
function: get zip cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('zip')
|
|
|
|
def getUnzipCmd(self):
|
|
"""
|
|
function: get unzip cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('unzip')
|
|
|
|
def getEchoCmd(self, echoString):
|
|
"""
|
|
function: get echo cmd
|
|
input : echoString
|
|
output : str
|
|
"""
|
|
cmdStr = '%s "%s"' % (findCmdInPath('echo'), echoString)
|
|
return cmdStr
|
|
|
|
def getSedCmd(self):
|
|
"""
|
|
function: get sed cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('sed')
|
|
|
|
def getGrepCmd(self):
|
|
"""
|
|
function: get grep cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('grep')
|
|
|
|
def getLsofCmd(self):
|
|
"""
|
|
function: get lsof cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('lsof') + " -i:"
|
|
|
|
def getIfconfigCmd(self):
|
|
"""
|
|
function: get ifconfig cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('ifconfig')
|
|
|
|
def getIpCmd(self):
|
|
"""
|
|
function: get ip cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('ip')
|
|
|
|
def getDateCmd(self):
|
|
"""
|
|
function: get date cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('date')
|
|
|
|
def getAwkCmd(self):
|
|
"""
|
|
function: get awk cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('awk')
|
|
|
|
def getFindCmd(self):
|
|
"""
|
|
function: get find cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('find')
|
|
|
|
def getTouchCmd(self, filename):
|
|
"""
|
|
function: get touch cmd
|
|
input : filename
|
|
output : str
|
|
"""
|
|
return findCmdInPath('touch') + BLANK_SPACE + filename
|
|
|
|
def getListCmd(self):
|
|
"""
|
|
function: get list cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('ls')
|
|
|
|
def getSHA256Cmd(self):
|
|
"""
|
|
function: get sha256 cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('sha256sum')
|
|
|
|
def getProcessCmd(self):
|
|
"""
|
|
function: get process cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('ps')
|
|
|
|
def getCatCmd(self):
|
|
"""
|
|
function: get cat cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('cat')
|
|
|
|
def getDdCmd(self):
|
|
"""
|
|
function: get dd cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('dd')
|
|
|
|
def getCdCmd(self, path):
|
|
"""
|
|
function: get cd cmd
|
|
input : path
|
|
output : str
|
|
"""
|
|
return 'cd' + BLANK_SPACE + "'" + path + "'"
|
|
|
|
def getAllCrontabCmd(self):
|
|
"""
|
|
function: get all crontab cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
cmd = findCmdInPath('crontab') + BLANK_SPACE + " -l"
|
|
return cmd
|
|
|
|
def getCrontabCmd(self):
|
|
"""
|
|
function: get crontab cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('crontab')
|
|
|
|
def getKillProcessCmd(self, signal, pid):
|
|
"""
|
|
function: get kill process cmd
|
|
input : signal, pid
|
|
output : str
|
|
"""
|
|
return findCmdInPath('kill') + " -" + signal + BLANK_SPACE + pid
|
|
|
|
def getKillallCmd(self):
|
|
"""
|
|
function: get killall cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('killall')
|
|
|
|
def getKillallProcessCmd(self, signal, username, procName=""):
|
|
"""
|
|
function: get killall process cmd
|
|
input : signal, username, procName
|
|
output : str
|
|
"""
|
|
if procName != "":
|
|
return findCmdInPath('killall') + " -s " + signal + " -u " + \
|
|
username + BLANK_SPACE + procName
|
|
else:
|
|
return findCmdInPath('killall') + " -s " + signal + " -u " + \
|
|
username
|
|
|
|
def getXargsCmd(self):
|
|
"""
|
|
function: get xargs cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('xargs')
|
|
|
|
def getDeleteSemaphoreCmd(self, user):
|
|
"""
|
|
function: get delete semaphore cmd
|
|
input : user
|
|
output : str
|
|
"""
|
|
ipcs = findCmdInPath('ipcs')
|
|
ipcrm = findCmdInPath('ipcrm')
|
|
xargs = findCmdInPath('xargs')
|
|
awk = findCmdInPath('awk')
|
|
return "%s -s | %s '/ %s /{print $2}' | %s -n1 %s -s" % (
|
|
ipcs, awk, user, xargs, ipcrm)
|
|
|
|
def getProcessIdByKeyWordsCmd(self, keywords):
|
|
"""
|
|
function: get proecess id by keywords cmd
|
|
input : keywords
|
|
output : str
|
|
"""
|
|
ps = findCmdInPath('ps')
|
|
grep = findCmdInPath('grep')
|
|
awk = findCmdInPath('awk')
|
|
return "%s -ef| %s -F '%s' | %s -F -v 'grep'| %s '{print $2}'" % (
|
|
ps, grep, keywords, grep, awk)
|
|
|
|
def getSysctlCmd(self):
|
|
"""
|
|
function: get sysctl cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('sysctl')
|
|
|
|
def getServiceCmd(self, serviceName, action):
|
|
"""
|
|
function: get service cmd
|
|
input : serviceName, action
|
|
output : str
|
|
"""
|
|
return findCmdInPath('service') + BLANK_SPACE + serviceName + \
|
|
BLANK_SPACE + action
|
|
|
|
def getSystemctlCmd(self, serviceName, action):
|
|
"""
|
|
function: get systemctl cmd
|
|
input : serviceName, action
|
|
output : str
|
|
"""
|
|
return findCmdInPath('systemctl') + BLANK_SPACE + action + \
|
|
BLANK_SPACE + serviceName
|
|
|
|
def getUlimitCmd(self):
|
|
"""
|
|
function: get ulimit cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return 'ulimit'
|
|
|
|
def getGetConfValueCmd(self):
|
|
"""
|
|
function: get conf value cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('getconf') + " PAGESIZE "
|
|
|
|
def getBlockdevCmd(self, device, value="", isSet=False):
|
|
"""
|
|
function: get block dev cmd
|
|
input : device, value, isSet
|
|
output : str
|
|
"""
|
|
if isSet and value != "":
|
|
return findCmdInPath('blockdev') + " --setra " + value + \
|
|
BLANK_SPACE + device
|
|
else:
|
|
return findCmdInPath('blockdev') + " --getra " + device
|
|
|
|
def getSysModManagementCmd(self, OperType, module):
|
|
|
|
"""
|
|
OperType: 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
|
|
"""
|
|
if OperType == "list":
|
|
return findCmdInPath('lsmod') + BLANK_SPACE + module
|
|
elif OperType == "load":
|
|
return findCmdInPath('modprobe') + BLANK_SPACE + module
|
|
elif OperType == "insert":
|
|
return findCmdInPath('insmod') + BLANK_SPACE + module
|
|
elif OperType == "remove":
|
|
return findCmdInPath('rmmod') + BLANK_SPACE + module
|
|
elif OperType == "dep":
|
|
return findCmdInPath('depmod') + BLANK_SPACE + module
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51404"] + OperType)
|
|
|
|
def getMountCmd(self):
|
|
"""
|
|
function: get dd cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('mount')
|
|
|
|
def getLocaleCmd(self):
|
|
"""
|
|
function: get locale cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('locale')
|
|
|
|
def getPasswordExpiresCmd(self, user):
|
|
"""
|
|
function: get password expires cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('chage') + " -l " + user
|
|
|
|
def getIOStatCmd(self):
|
|
"""
|
|
function: get io stat cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('iostat') + " -xm 2 3 "
|
|
|
|
def getEthtoolCmd(self):
|
|
"""
|
|
function: get eth tool cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('ethtool')
|
|
|
|
def getTailCmd(self):
|
|
"""
|
|
function: get tail cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('tail')
|
|
|
|
def getSshCmd(self, address):
|
|
"""
|
|
function: get ssh cmd
|
|
input : address
|
|
output : str
|
|
"""
|
|
return "pssh -s -H " + BLANK_SPACE + address
|
|
|
|
def getChkconfigCmd(self, OperType, service=""):
|
|
"""
|
|
function: get chkconfig cmd
|
|
input : OperType, service
|
|
output : str
|
|
"""
|
|
if OperType == "list":
|
|
return findCmdInPath('chkconfig') + " --list "
|
|
elif OperType == "delete" and service:
|
|
return findCmdInPath('chkconfig') + " --del " + service
|
|
|
|
def getManageKerberosCmd(self, OperType):
|
|
"""
|
|
OperType: init --init kerberos
|
|
destory --destory kerberos
|
|
"""
|
|
if OperType == "init":
|
|
return "kinit -k -t "
|
|
elif OperType == "destory":
|
|
return "kdestroy"
|
|
|
|
def getManageSSDCmd(self):
|
|
"""
|
|
function: get manage ssd cmd
|
|
input : NA
|
|
output : NA
|
|
"""
|
|
pass
|
|
|
|
def getPythonCmd(self):
|
|
"""
|
|
function: get python cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('python3')
|
|
|
|
def getShellCmd(self):
|
|
"""
|
|
function: get shell cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return findCmdInPath('sh')
|
|
|
|
def getSourceCmd(self):
|
|
"""
|
|
function: get source cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return 'source'
|
|
|
|
def getTestCmd(self):
|
|
"""
|
|
Linux test cmd
|
|
example: test -f /etc/profile && echo 1 || echo 2
|
|
"""
|
|
return findCmdInPath("test")
|
|
|
|
def getPgrepCmd(self):
|
|
"""
|
|
Linux pgrep cmd
|
|
"""
|
|
return findCmdInPath("pgrep")
|
|
|
|
def getExportCmd(self, key="", value=""):
|
|
"""
|
|
Linux export cmd
|
|
"""
|
|
cmd = findCmdInPath("export")
|
|
if key:
|
|
cmd += " %s=%s" % (key, value)
|
|
return cmd
|
|
|
|
|
|
class LinuxPlatform(GenericPlatform):
|
|
"""
|
|
manage Linux command,config or service for muti-platform
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
function: constructor
|
|
"""
|
|
pass
|
|
|
|
def dist(self):
|
|
"""
|
|
function: dist
|
|
input : NA
|
|
output : distname, version, id
|
|
"""
|
|
return dist()
|
|
|
|
def getCpuInfoFile(self):
|
|
"""
|
|
function: get cpu info file
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return "/proc/cpuinfo"
|
|
|
|
def getMemInfoFile(self):
|
|
"""
|
|
function: get dd cmd
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return "/proc/meminfo"
|
|
|
|
def getBondInfoPath(self):
|
|
"""
|
|
function: get bond info path
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return "/proc/net/bonding/"
|
|
|
|
def getSysctlFile(self):
|
|
"""
|
|
function: get sysctl file
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return "/etc/sysctl.conf"
|
|
|
|
def getMtablFile(self):
|
|
"""
|
|
function: get mtab file
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return "/etc/mtab"
|
|
|
|
def getInterruptFile(self):
|
|
"""
|
|
function: get interrput file
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return "/proc/interrupts"
|
|
|
|
def getHostsFile(self):
|
|
"""
|
|
function: get hostfile
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return "/etc/hosts"
|
|
|
|
def getName(self):
|
|
"""
|
|
function: get name
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return "linux"
|
|
|
|
def getDefaultLocale(self):
|
|
"""
|
|
function: get default locale
|
|
input : NA
|
|
output : str
|
|
"""
|
|
return 'en_US.utf8'
|
|
|
|
def getDiskFreeCmd(self, Mounted="", inode=False):
|
|
# -P is for POSIX formatting. Prevents error
|
|
# on lines that would wrap
|
|
return findCmdInPath('df') + " -Pk " + \
|
|
(" -i " if inode else " -h ") + Mounted
|
|
|
|
def getDirSizeCmd(self, path, unit=""):
|
|
# -s only shows the total size
|
|
# unit specify the output size unit
|
|
return findCmdInPath('du') + " -s " + (" -B %s " % unit
|
|
if unit else " -h ") + path
|
|
|
|
def getSadcCmd(self, interval, outFileName):
|
|
"""
|
|
function: get sadc cmd
|
|
input : interval, outFileName
|
|
output : str
|
|
"""
|
|
cmd = "/usr/lib64/sa/sadc -F -d " + str(interval) + " " + outFileName
|
|
return cmd
|
|
|
|
def getCompressFilesCmd(self, tarName, fileSrc):
|
|
"""
|
|
function: get compress file cmd
|
|
input : tarName, fileSrc
|
|
output : str
|
|
"""
|
|
cmd = "%s -zvcf '%s' %s" % (self.getTarCmd(), tarName, fileSrc)
|
|
return cmd
|
|
|
|
def getDecompressFilesCmd(self, srcPackage, dest):
|
|
"""
|
|
function: get decompress file cmd
|
|
input : srcPackage, dest
|
|
output : str
|
|
"""
|
|
cmd = "%s -zxvf '%s' -C '%s'" % (self.getTarCmd(), srcPackage, dest)
|
|
return cmd
|
|
|
|
def getCompressZipFilesCmd(self, zipName, fileSrc):
|
|
"""
|
|
function: get compress zip files cmd
|
|
input : zipName, fileSrc
|
|
output : str
|
|
"""
|
|
cmd = "cd %s && %s -r '%s.zip' ./*" % (fileSrc, self.getZipCmd(),
|
|
zipName)
|
|
return cmd
|
|
|
|
def getDecompressZipFilesCmd(self, srcPackage, dest):
|
|
"""
|
|
function: get decompress zip files cmd
|
|
input : srcPackage, dest
|
|
output : str
|
|
"""
|
|
cmd = "%s -o '%s' -d '%s'" % (self.getUnzipCmd(), srcPackage, dest)
|
|
return cmd
|
|
|
|
def getReplaceFileLineContentCmd(self, oldLine, newLine, path):
|
|
"""
|
|
function: get replace file line content cmd
|
|
input : oldLine, newLine, path
|
|
output : str
|
|
"""
|
|
cmd = "%s -i \"s/%s/%s/g\" '%s'" % (self.getSedCmd(), oldLine,
|
|
newLine, path)
|
|
return cmd
|
|
|
|
def getDirPermissionCmd(self, dirPath):
|
|
"""
|
|
function: get dir permission cmd
|
|
input : dirPath
|
|
output : str
|
|
"""
|
|
cmd = "%s -ld '%s' | %s -F\" \" '{print $1}' " % (self.getListCmd(),
|
|
dirPath,
|
|
self.getAwkCmd())
|
|
return cmd
|
|
|
|
def getFileSHA256Cmd(self, fileName):
|
|
"""
|
|
function: get file sha256 cmd
|
|
input : fileName
|
|
output : str
|
|
"""
|
|
cmd = "%s '%s' | %s -F\" \" '{print $1}' " % (self.getSHA256Cmd(),
|
|
fileName,
|
|
self.getAwkCmd())
|
|
return cmd
|
|
|
|
def getExecuteCmdWithUserProfile(self, user, userProfile, executeCmd,
|
|
ignoreError=True):
|
|
"""
|
|
function: get execute cmd with user profile
|
|
input: user, userProfile, executeCmd, ignoreError
|
|
output: str
|
|
"""
|
|
if (user != "") and (os.getuid() == 0):
|
|
cmd = "su - %s -c '%s %s; %s'" % (user, self.getSourceCmd(),
|
|
userProfile, executeCmd)
|
|
else:
|
|
cmd = "%s %s; %s" % (self.getSourceCmd(), userProfile, executeCmd)
|
|
if ignoreError:
|
|
cmd += " 2>/dev/null"
|
|
return cmd
|
|
|
|
def getUserHomePath(self):
|
|
"""
|
|
function: get user home path
|
|
input: NA
|
|
output: str
|
|
"""
|
|
# converts the relative path to an absolute path
|
|
cmd = "echo ~ 2>/dev/null"
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS_50219"] % "user home"
|
|
+ "The cmd is %s" % cmd)
|
|
return output
|
|
|
|
def checkProcAlive(self, procPid):
|
|
"""
|
|
function: check Proc alive
|
|
input: procPid
|
|
output: True/False
|
|
"""
|
|
try:
|
|
os.kill(procPid, 0)
|
|
except OSError:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def getIpAddressAndNIC(self, ipType="ipv4"):
|
|
"""
|
|
function: get ip address and nic
|
|
input: ipType
|
|
output: NA
|
|
"""
|
|
if ipType == "ipv4":
|
|
key = AF_INET
|
|
else:
|
|
key = AF_INET6
|
|
|
|
for iface in interfaces():
|
|
if key in ifaddresses(iface):
|
|
ipAddress = ifaddresses(iface)[key][0]['addr']
|
|
yield (iface, ipAddress)
|
|
|
|
def getIpAddressAndNICList(self, ipType="ipv4"):
|
|
"""
|
|
function: get ip address and nicList
|
|
input: ipType
|
|
output: []
|
|
"""
|
|
return list(self.getIpAddressAndNIC(ipType))
|
|
|
|
def getNetworkNumByIPAddr(self, ipAddress, ipType="ipv4"):
|
|
"""
|
|
function: get netWork num by IP addr
|
|
input: ipAddress, ipType
|
|
output: str
|
|
"""
|
|
try:
|
|
mappingList = self.getIpAddressAndNICList(ipType)
|
|
for mapInfo in mappingList:
|
|
if mapInfo[1] == ipAddress:
|
|
return mapInfo[0]
|
|
raise Exception(ErrorCode.GAUSS_506["GAUSS-50612"] % ipAddress)
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getHostNameByIPAddr(self, ipAddress):
|
|
"""
|
|
function: get host name by ip addr
|
|
input: ipAddress
|
|
output: str
|
|
"""
|
|
try:
|
|
return socket.gethostbyaddr(ipAddress)[0]
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getLinuxNetworkConfigFile(self, networkConfPath, networkCardNum):
|
|
"""
|
|
function: get linux network config file
|
|
input: networkConfPath, networkCardNum
|
|
output: str
|
|
"""
|
|
try:
|
|
networkConfFile = "%sifcfg-%s" % (networkConfPath, networkCardNum)
|
|
# Network configuration file does not exist
|
|
if not os.path.exists(networkConfFile):
|
|
cmd = "%s %s -iname 'ifcfg-*-%s' -print" % (self.getFindCmd(),
|
|
networkConfFile,
|
|
networkCardNum)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if (status != 0 or output.strip() == ""
|
|
or len(output.split('\n')) != 1):
|
|
raise Exception(ErrorCode.GAUSS_502["GAUSS-50201"] %
|
|
networkConfFile + "The cmd is %s" % cmd)
|
|
networkConfFile = output.strip()
|
|
return networkConfFile
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getNetworkBondModeByBondConfigFile(self, bondingConfFile):
|
|
"""
|
|
function: get Network Bond Mode By Bond ConfigFile
|
|
input: bondingConfFile
|
|
output: str
|
|
"""
|
|
try:
|
|
# Check the bond mode
|
|
cmd = "%s -w '\<Bonding Mode\>' %s | %s -F ':' '{print $NF}'" % (
|
|
self.getGrepCmd(), bondingConfFile, self.getAwkCmd())
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error: \n%s " % output)
|
|
return "BondMode %s" % output.strip()
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getNetworkBondModeInfo(self, networkConfFile, networkCardNum):
|
|
"""
|
|
function: get Network Bond Mode Info
|
|
input: networkConfFile, networkCardNum
|
|
output: str
|
|
"""
|
|
# Get the bond profile
|
|
if not os.path.isfile(networkConfFile):
|
|
return "BondMode Null"
|
|
|
|
bondingConfFile = "%s%s" % (self.getBondInfoPath(), networkCardNum)
|
|
cmd = "%s -i 'BONDING_OPTS\|BONDING_MODULE_OPTS' %s" % (
|
|
self.getGrepCmd(), networkConfFile)
|
|
output = subprocess.getstatusoutput(cmd)[1]
|
|
# Analysis results
|
|
if output.strip() != "":
|
|
if (output.find("mode") > 0) and os.path.exists(bondingConfFile):
|
|
bondInfo = self.getNetworkBondModeByBondConfigFile(
|
|
bondingConfFile)
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error: \n%s " % output)
|
|
elif os.path.exists(bondingConfFile):
|
|
bondInfo = self.getNetworkBondModeByBondConfigFile(bondingConfFile)
|
|
bondInfo += "\nNo 'BONDING_OPTS' or \
|
|
'BONDING_MODULE_OPTS' in bond config file[%s]." % networkConfFile
|
|
else:
|
|
bondInfo = "BondMode Null"
|
|
return bondInfo
|
|
|
|
def getNetworkMaskByNICNum(self, networkCardNum, ipType="ipv4"):
|
|
"""
|
|
function: get Network Mask By NICNum
|
|
input: networkCardNum, ipType
|
|
output: str
|
|
"""
|
|
if ipType == "ipv4":
|
|
return ifaddresses(networkCardNum)[AF_INET][0]["netmask"]
|
|
else:
|
|
return ifaddresses(networkCardNum)[AF_INET6][0]["netmask"]
|
|
|
|
def getNetworkRXTXValueByNICNum(self, networkCardNum, valueType):
|
|
"""
|
|
function: get Network RXTX Value By NICNum
|
|
input: networkCardNum, valueType
|
|
output: int
|
|
"""
|
|
try:
|
|
cmd = "%s -g %s | %s '%s:' | %s -n 1" % (self.getEthtoolCmd(),
|
|
networkCardNum,
|
|
self.getGrepCmd(),
|
|
valueType.upper(),
|
|
self.getTailCmd())
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error: \n%s " % output)
|
|
value = output.split(':')[-1].split(' ')[0].strip()
|
|
if not str(value).isdigit():
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error: \n%s " % output)
|
|
return int(value)
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def setNetworkRXTXValue(self, networkCardNum, rxValue=8192,
|
|
txValue=8192):
|
|
"""
|
|
function: set Network RXTX Value
|
|
input: networkCardNum, rxValue, txValue
|
|
output: NA
|
|
"""
|
|
try:
|
|
cmd = "%s -G %s rx %s tx %s" % (
|
|
self.getEthtoolCmd(), networkCardNum, rxValue, txValue)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
if output.find("no ring parameters changed, aborting") < 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error: \n%s " % output)
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getNetworkSpeedByNICNum(self, networkCardNum):
|
|
"""
|
|
function: get Network Speed By NICNum
|
|
input: networkCardNum
|
|
output: int
|
|
"""
|
|
keyWord = "Speed: "
|
|
speedUnit = "Mb/s"
|
|
try:
|
|
cmd = "%s %s | grep '%s'" % (self.getEthtoolCmd(),
|
|
networkCardNum, keyWord)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0 or output == "":
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error: \n%s " % output)
|
|
if len(output.split('\n')) >= 1:
|
|
for line in output.split('\n'):
|
|
if line.find(keyWord) >= 0 and line.find(speedUnit) >= 0:
|
|
return int(line.split(':')[-1].strip()[:-4])
|
|
return 0
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def checkNetworkInterruptByNIC(self, networkCardNum):
|
|
"""
|
|
function: check Network Interrupt By NIC
|
|
"""
|
|
try:
|
|
interruptConfFile = self.getInterruptFile()
|
|
numberedListCmd = "%s %s | %s '%s-' | \
|
|
%s -F ' ' '{print $1}' | %s -F ':' '{print $1}'" % (
|
|
self.getCatCmd(), interruptConfFile, self.getGrepCmd(),
|
|
networkCardNum, self.getAwkCmd(), self.getAwkCmd())
|
|
irqCmd = "%s /proc/irq/$i/smp_affinity" % self.getCatCmd()
|
|
cmd = "for i in `%s`; do %s ; done" % (numberedListCmd, irqCmd)
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error: \n%s " % output)
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
# cpu core number followed by 1 2 4 8,every 4 left shift one
|
|
Mapping = {0: "1", 1: "2", 2: "4", 3: "8"}
|
|
flag = True
|
|
for index, eachLine in enumerate(output.split()):
|
|
# Remove the ','
|
|
eachLine = eachLine.replace(",", "")
|
|
# Replace 0000,00001000 to 1,Remove invalid content
|
|
validValue = eachLine.replace("0", "")
|
|
# Convert the row index to the expected value
|
|
expandNum = Mapping[index % 4]
|
|
# Convert line index to expected position
|
|
expandBit = index // 4 * -1 - 1
|
|
# value and position is correct
|
|
if eachLine[expandBit] == expandNum and validValue == expandNum:
|
|
continue
|
|
else:
|
|
print("Network card [%s] multi-queue \
|
|
support is not enabled.\n" % networkCardNum)
|
|
flag = False
|
|
break
|
|
return flag
|
|
|
|
def getInterruptCountNum(self, networkCardNum):
|
|
"""
|
|
function : We can makesure that all dev names is startwith
|
|
'ethX-' and endwith '-X'
|
|
input : String
|
|
output : Int
|
|
"""
|
|
try:
|
|
interruptConfFile = self.getInterruptFile()
|
|
cmd = "%s %s | %s '%s-' | %s -l" % (self.getCatCmd(),
|
|
interruptConfFile,
|
|
self.getGrepCmd(),
|
|
networkCardNum,
|
|
self.getWcCmd())
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception(ErrorCode.GAUSS_506["GAUSS_50622"] % cmd)
|
|
if not str(output.strip()).isdigit():
|
|
return 0
|
|
return int(output.strip())
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getPackageFile(self, distName, version, packageVersion,
|
|
productVersion, fileType="tarFile"):
|
|
"""
|
|
function : Get the path of binary file version.
|
|
input : distName, version, packageVersion,
|
|
productVersion, fileType
|
|
output : String
|
|
"""
|
|
distname, version, idnum = dist()
|
|
distname = distname.lower()
|
|
dirName = os.path.dirname(os.path.realpath(__file__))
|
|
prefixStr = productVersion
|
|
if fileType == "tarFile":
|
|
postfixStr = "tar.gz"
|
|
elif fileType == "binFile":
|
|
postfixStr = "bin"
|
|
elif fileType == "sha256File":
|
|
postfixStr = "sha256"
|
|
elif fileType == "bz2File":
|
|
postfixStr = "tar.bz2"
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_500["GAUSS_50019"] % "fileType")
|
|
|
|
# RHEL and CentOS have the same kernel version,
|
|
# So RHEL cluster package can run directly on CentOS.
|
|
if distname in REDHAT:
|
|
fileName = os.path.join(dirName, "./../../../",
|
|
"%s-%s-%s-%s.%s" % (
|
|
prefixStr, packageVersion, PAK_REDHAT,
|
|
BIT_VERSION, postfixStr))
|
|
elif distname in CENTOS:
|
|
if os.path.isfile(os.path.join("/etc", "euleros-release")):
|
|
fileName = os.path.join(dirName, "./../../../",
|
|
"%s-%s-%s-%s.%s" % (
|
|
prefixStr, packageVersion,
|
|
PAK_EULER,
|
|
BIT_VERSION, postfixStr))
|
|
if not os.path.isfile(fileName):
|
|
fileName = os.path.join(dirName, "./../../../",
|
|
"%s-%s-%s-%s.%s" % (
|
|
prefixStr, packageVersion,
|
|
PAK_CENTOS, BIT_VERSION,
|
|
postfixStr))
|
|
else:
|
|
fileName = os.path.join(dirName, "./../../../",
|
|
"%s-%s-%s-%s.%s" % (
|
|
prefixStr, packageVersion,
|
|
PAK_CENTOS,
|
|
BIT_VERSION, postfixStr))
|
|
if not os.path.isfile(fileName):
|
|
fileName = os.path.join(dirName, "./../../../",
|
|
"%s-%s-%s-%s.%s" % (
|
|
prefixStr, packageVersion,
|
|
PAK_REDHAT,
|
|
BIT_VERSION, postfixStr))
|
|
elif distname in ASIANUX:
|
|
fileName = os.path.join(dirName, "./../../../",
|
|
"%s-%s-%s-%s.%s" % (
|
|
prefixStr, packageVersion, PAK_ASIANUX,
|
|
BIT_VERSION, postfixStr))
|
|
elif distname == SUSE and version.split('.')[0] in ("11", "12"):
|
|
fileName = os.path.join(dirName, "./../../../",
|
|
"%s-%s-%s-%s.%s" % (
|
|
prefixStr, packageVersion, "SUSE11",
|
|
BIT_VERSION, postfixStr))
|
|
elif distname in EULEROS and (idnum in ["SP2", "SP3", "SP5"]):
|
|
fileName = os.path.join(dirName, "./../../../",
|
|
"%s-%s-%s-%s.%s" % (
|
|
prefixStr, packageVersion, PAK_EULER,
|
|
BIT_VERSION, postfixStr))
|
|
if not os.path.isfile(fileName):
|
|
fileName = os.path.join(dirName, "./../../../",
|
|
"%s-%s-%s-%s.%s" % (
|
|
prefixStr, packageVersion,
|
|
PAK_REDHAT,
|
|
BIT_VERSION, postfixStr))
|
|
elif distname in EULEROS and (idnum == "SP8"):
|
|
fileName = os.path.join(dirName, "./../../../",
|
|
"%s-%s-%s-%s.%s" % (
|
|
prefixStr, packageVersion, PAK_EULER,
|
|
BIT_VERSION, postfixStr))
|
|
elif distname in EULEROS:
|
|
fileName = os.path.join(dirName, "./../../../",
|
|
"%s-%s-%s-%s.%s" % (
|
|
prefixStr, packageVersion, PAK_REDHAT,
|
|
BIT_VERSION, postfixStr))
|
|
elif distname in OPENEULER or distname in KYLIN:
|
|
fileName = os.path.join(dirName, "./../../../",
|
|
"%s-%s-%s-%s.%s" % (
|
|
prefixStr, packageVersion,
|
|
PAK_OPENEULER,
|
|
BIT_VERSION, postfixStr))
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_519["GAUSS_51900"] +
|
|
"Supported platforms are: %s." % str(
|
|
SUPPORT_WHOLE_PLATFORM_LIST))
|
|
|
|
fileName = os.path.normpath(fileName)
|
|
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)
|
|
return fileName
|
|
|
|
def setKeyValueInSshd(self, key, value):
|
|
"""
|
|
function: Set a (key, value) pair into /etc/ssh/sshd_config,
|
|
before "Match" section.
|
|
"Match" section in sshd_config should always places in the end.
|
|
Attention: you need to remove the old (key, value)
|
|
from sshd_config manually.
|
|
input:
|
|
key: the configuration name of sshd_config
|
|
value: the configuration value(Only single line string
|
|
permitted here).
|
|
output:
|
|
void
|
|
"""
|
|
sshd_config = '/etc/ssh/sshd_config'
|
|
cmd = "grep -E '^\<Match\>' %s" % sshd_config
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
|
|
if status == 0:
|
|
cmd = "sed -i '/^\<Match\>.*/i %s %s' %s" % (key, value,
|
|
sshd_config)
|
|
else:
|
|
if output is not None and len(output.strip()) != 0:
|
|
raise Exception(ErrorCode.GAUSS_503["GAUSS_50321"] %
|
|
"Match section" + "Command: %s, Error: %s" %
|
|
(cmd, output))
|
|
cmd = "echo '' >> %s ; echo '%s %s' >> %s" % (sshd_config,
|
|
key, value,
|
|
sshd_config)
|
|
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception((ErrorCode.GAUSS_503["GAUSS_50320"] % (
|
|
key, value)) + ("Command: %s, Error: %s" % (cmd, output)))
|
|
|
|
|
|
class SLESPlatform(LinuxPlatform):
|
|
"""
|
|
manage SUSE Linux Enterprise Server command,
|
|
config or service for muti-platform
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.NetWorkConfPath = "/etc/sysconfig/network/"
|
|
self.SuSEReleaseFile = "/etc/SuSE-release"
|
|
self.OSReleaseFile = "/etc/SuSE-release"
|
|
|
|
def isPlatFormEulerOSOrRHEL7X(self):
|
|
"""
|
|
function: the patform is euleros or rhel7x
|
|
input : NA
|
|
output : bool
|
|
"""
|
|
return False
|
|
|
|
def getManageFirewallCmd(self, action):
|
|
"""
|
|
function: get manage firewall cmd
|
|
input : action
|
|
output : str
|
|
"""
|
|
return findCmdInPath('SuSEfirewall2') + BLANK_SPACE + action
|
|
|
|
def getLinuxFirewallStatus(self):
|
|
"""
|
|
function: get Linux Firewall Status
|
|
input: NA
|
|
output: str
|
|
"""
|
|
try:
|
|
cmd = self.getManageFirewallCmd("status")
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0 or output == "":
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error: \n%s " % output)
|
|
|
|
if output.strip().find("SuSEfirewall2 not active") > 0:
|
|
firewallStatus = "disabled"
|
|
else:
|
|
firewallStatus = "enabled"
|
|
return firewallStatus
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getManageCrondCmd(self, action):
|
|
"""
|
|
function: get manage crond cmd
|
|
input : action
|
|
output : str
|
|
"""
|
|
return self.getServiceCmd("cron", action)
|
|
|
|
def getManageSshdCmd(self, action):
|
|
"""
|
|
function: get manage sshd cmd
|
|
input : action
|
|
output : str
|
|
"""
|
|
return self.getServiceCmd("sshd", action)
|
|
|
|
def getManageSyslogCmd(self, action):
|
|
"""
|
|
function: get manage syslog cmd
|
|
input : action
|
|
output : str
|
|
"""
|
|
return self.getServiceCmd("syslog", action)
|
|
|
|
def getManageRsyslogCmd(self, action):
|
|
"""
|
|
function: get manage rsyslog cmd
|
|
input : action
|
|
output : str
|
|
"""
|
|
return self.getServiceCmd("rsyslog", action)
|
|
|
|
def getManageSystemdJournaldCmd(self, action):
|
|
"""
|
|
function: get systemd-jorunald cmd
|
|
input : action
|
|
output : str
|
|
"""
|
|
return self.getServiceCmd("systemd-journald", action)
|
|
|
|
def getManageGsOsServerCmd(self, action):
|
|
"""
|
|
function: get rhel/centos cmd
|
|
input : action
|
|
output : NA
|
|
"""
|
|
try:
|
|
raise Exception(ErrorCode.GAUSS_530["GAUSS_53021"]
|
|
% ("gs-OS-set service", "RHEL/CentOS"))
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getCurrentPlatForm(self):
|
|
"""
|
|
function: get current platform
|
|
input: NA
|
|
output: str, str
|
|
"""
|
|
try:
|
|
distName, version = dist()[0:2]
|
|
bits = platform.architecture()[0]
|
|
if (distName.lower() != SUSE or
|
|
version not in SUPPORT_SUSE_VERSION_LIST):
|
|
raise Exception(ErrorCode.GAUSS_530["GAUSS_53022"]
|
|
% (distName.lower(), version))
|
|
|
|
# os-release is added since SLE 12; SuSE-release will
|
|
# be removed in a future service pack or release
|
|
if os.path.exists(self.SuSEReleaseFile):
|
|
cmd = "%s -i 'PATCHLEVEL' %s | " \
|
|
"%s -F '=' '{print $2}'" % (self.getGrepCmd(),
|
|
self.SuSEReleaseFile,
|
|
self.getAwkCmd())
|
|
else:
|
|
cmd = "%s -i 'VERSION_ID' %s | " \
|
|
"%s -F '.' '{print $2}' | %s 's/\"//'" % (
|
|
self.getGrepCmd(), self.OSReleaseFile,
|
|
self.getAwkCmd(), self.getSedCmd())
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status == 0 and output != "":
|
|
patchlevel = output.strip()
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error: \n%s " % output)
|
|
|
|
if (bits == BIT_VERSION and
|
|
((version == SUSE11 and
|
|
patchlevel in SUPPORT_SUSE11X_VERSION_LIST) or
|
|
(version == SUSE12 and
|
|
patchlevel in SUPPORT_RHEL12X_VERSION_LIST))):
|
|
platformVersion = "%s.%s" % (version, patchlevel)
|
|
return distName.lower(), platformVersion
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_519["GAUSS_51900"] +
|
|
" The current system is: %s%s.%s" % (
|
|
distName.lower(), version, patchlevel))
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getNetworkConfigFileByNICNum(self, networkCardNum):
|
|
"""
|
|
function: get Network ConfigFile By NICNum
|
|
input: networkCardNum
|
|
output: str
|
|
"""
|
|
return self.getLinuxNetworkConfigFile(self.NetWorkConfPath,
|
|
networkCardNum)
|
|
|
|
def getNetworkConfigFileByIPAddr(self, ipAddress):
|
|
"""
|
|
function: get Network ConfigFile By ip addr
|
|
input: ipAddress
|
|
output: str
|
|
"""
|
|
networkCardNum = self.getNetworkNumByIPAddr(ipAddress)
|
|
return self.getNetworkConfigFileByNICNum(networkCardNum)
|
|
|
|
|
|
class RHELPlatform(LinuxPlatform):
|
|
"""
|
|
manage Red Hat Enterprise Linux command,config or service for muti-platform
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
function: constructor
|
|
"""
|
|
self.NetWorkConfPath = "/etc/sysconfig/network-scripts/"
|
|
|
|
def isSupportSystemctl(self):
|
|
"""
|
|
function: isSupportSystemctl
|
|
input: NA
|
|
output: bool
|
|
"""
|
|
distName, version = dist()[0:2]
|
|
if ((distName.lower() == EULEROS and version[0:3] in
|
|
SUPPORT_EULEROS_VERSION_LIST) or
|
|
(distName.lower() in SUPPORT_RHEL_SERIES_PLATFORM_LIST and
|
|
version[0:3] in SUPPORT_RHEL7X_VERSION_LIST) or
|
|
(distName.lower() == CENTOS and version[0:3] ==
|
|
SUPPORT_EULEROS_VERSION_LIST and
|
|
os.path.isfile(os.path.join("/etc", "euleros-release"))) or
|
|
distName.lower() == OPENEULER):
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def isPlatFormEulerOSOrRHEL7X(self):
|
|
"""
|
|
function: check is PlatForm EulerOS Or RHEL7X
|
|
"""
|
|
return self.isSupportSystemctl()
|
|
|
|
def getManageFirewallCmd(self, action):
|
|
"""
|
|
function: get manage firewall cmd
|
|
input : action
|
|
output : str
|
|
"""
|
|
if self.isSupportSystemctl():
|
|
return self.getSystemctlCmd("firewalld.service", action)
|
|
else:
|
|
return self.getServiceCmd("iptables", action)
|
|
|
|
def getLinuxFirewallStatus(self):
|
|
"""
|
|
function: get Linux Firewall Status
|
|
"""
|
|
try:
|
|
cmd = self.getManageFirewallCmd("status")
|
|
(status, output) = subprocess.getstatusoutput(cmd)
|
|
if status != 0 and output == "":
|
|
raise Exception(ErrorCode.GAUSS_514["GAUSS_51400"] % cmd +
|
|
" Error: \n%s " % output)
|
|
|
|
if self.isSupportSystemctl():
|
|
if output.strip().find("Active: active (running)") > 0:
|
|
firewallStatus = "enabled"
|
|
else:
|
|
firewallStatus = "disabled"
|
|
else:
|
|
if output.strip().find("Firewall is not running") > 0:
|
|
firewallStatus = "disabled"
|
|
else:
|
|
firewallStatus = "enabled"
|
|
return firewallStatus
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getManageCrondCmd(self, action):
|
|
"""
|
|
function: get crond.server cmd
|
|
input : action
|
|
output : str
|
|
"""
|
|
if self.isSupportSystemctl():
|
|
return self.getSystemctlCmd("crond.service", action)
|
|
else:
|
|
return self.getServiceCmd("crond", action)
|
|
|
|
def getManageSshdCmd(self, action):
|
|
"""
|
|
function: get sshd.server cmd
|
|
input : action
|
|
output : str
|
|
"""
|
|
if self.isSupportSystemctl():
|
|
return self.getSystemctlCmd("sshd.service", action)
|
|
else:
|
|
return self.getServiceCmd("sshd", action)
|
|
|
|
def getManageGsOsServerCmd(self, action):
|
|
"""
|
|
function: get gs-OS-set.service cmd
|
|
input : action
|
|
output : str
|
|
"""
|
|
if self.isSupportSystemctl():
|
|
return self.getSystemctlCmd("gs-OS-set.service", action)
|
|
else:
|
|
return self.getServiceCmd("gs-OS-set", action)
|
|
|
|
def getManageSyslogCmd(self, action):
|
|
"""
|
|
function: get syslog service cmd
|
|
"""
|
|
try:
|
|
raise Exception(ErrorCode.GAUSS_530["GAUSS_53021"]
|
|
% ("Syslog service", "SuSE"))
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getManageRsyslogCmd(self, action):
|
|
"""
|
|
function: get syslog cmd
|
|
"""
|
|
try:
|
|
raise Exception(ErrorCode.GAUSS_530["GAUSS_53021"]
|
|
% ("Rsyslog service", "SuSE"))
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getManageSystemdJournaldCmd(self, action):
|
|
"""
|
|
function: get systemd journal cmd
|
|
"""
|
|
try:
|
|
raise Exception(ErrorCode.GAUSS_530["GAUSS_53021"]
|
|
% ("systemd-journald", "SuSE"))
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getCurrentPlatForm(self):
|
|
"""
|
|
function: get current platform
|
|
"""
|
|
try:
|
|
distName, version, currentId = dist()
|
|
bits = platform.architecture()[0]
|
|
if ((bits == BIT_VERSION and
|
|
((distName.lower() == EULEROS and version[0:3] in
|
|
SUPPORT_EULEROS_VERSION_LIST) or
|
|
(distName.lower() in SUPPORT_RHEL_SERIES_PLATFORM_LIST and
|
|
version[0:3] in SUPPORT_RHEL_SERIES_VERSION_LIST)) or
|
|
(distName.lower() == OPENEULER)
|
|
)):
|
|
return distName.lower(), version[0:3]
|
|
else:
|
|
if distName.lower() == CENTOS and os.path.isfile(
|
|
os.path.join("/etc", "euleros-release")) and \
|
|
(version[0:3] in SUPPORT_EULEROS_VERSION_LIST):
|
|
return EULEROS, version[0:3]
|
|
if distName.lower() == EULEROS:
|
|
raise Exception(ErrorCode.GAUSS_519["GAUSS_51900"] +
|
|
" The current system is: %s%s%s" % (
|
|
distName.lower(),
|
|
version[0:3], currentId))
|
|
else:
|
|
raise Exception(ErrorCode.GAUSS_519["GAUSS_51900"] +
|
|
" The current system is: %s%s" % (
|
|
distName.lower(), version[0:3]))
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
def getNetworkConfigFileByIPAddr(self, ipAddress):
|
|
"""
|
|
function: get Network ConfigFile By IPAddr
|
|
"""
|
|
networkCardNum = self.getNetworkNumByIPAddr(ipAddress)
|
|
return self.getLinuxNetworkConfigFile(self.NetWorkConfPath,
|
|
networkCardNum)
|
|
|
|
def getNetworkConfigFileByNICNum(self, networkCardNum):
|
|
"""
|
|
function: get Network ConfigFile By NICNum
|
|
"""
|
|
return self.getLinuxNetworkConfigFile(self.NetWorkConfPath,
|
|
networkCardNum)
|
|
|
|
|
|
class UserPlatform():
|
|
"""
|
|
manage Red Hat Enterprise Linux command,config or service for muti-platform
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
function : Check support OS version and init OS class
|
|
"""
|
|
# now we support this platform:
|
|
# RHEL/CentOS "6.4", "6.5", "6.6", "6.7", "6.8", "6.9",
|
|
# "7.0", "7.1", "7.2", "7.3", "7.4", "7.5 "64bit
|
|
# EulerOS "2.0", "2.3" 64bit
|
|
# SuSE11 sp1/2/3/4 64bit
|
|
# SuSE12 sp0/1/2/3 64bit
|
|
# Kylin "10" 64bit
|
|
distName, version, idNum = dist()
|
|
if distName.lower() not in SUPPORT_WHOLE_PLATFORM_LIST:
|
|
raise Exception(ErrorCode.GAUSS_519["GAUSS_51900"] +
|
|
"Supported platforms are: %s." % str(
|
|
SUPPORT_WHOLE_PLATFORM_LIST))
|
|
|
|
if distName.lower() == SUSE:
|
|
# SuSE11.X SUSE12.X
|
|
self.userPlatform = SLESPlatform()
|
|
elif distName.lower() in SUPPORT_RHEL_SERIES_PLATFORM_LIST:
|
|
# RHEL6.X RHEL7.X
|
|
self.userPlatform = RHELPlatform()
|
|
else:
|
|
# EULEROS 2.0/2.3
|
|
self.userPlatform = RHELPlatform()
|
|
try:
|
|
self.userPlatform.getCurrentPlatForm()
|
|
except Exception as e:
|
|
raise Exception(str(e))
|
|
|
|
|
|
# global platform class
|
|
g_Platform = UserPlatform().userPlatform
|