system/system.go
package system
import (
"fmt"
"io"
"io/ioutil"
"os"
"os/exec"
"path/filepath"
"reflect"
"regexp"
"runtime"
"strings"
"syscall"
"time"
"unicode"
)
// SaptuneSectionDir defines saptunes saved state directory
const SaptuneSectionDir = "/run/saptune/sections"
// map to hold the current available systemd services
var services map[string]string
// stdOutOrg contains the origin stdout for resetting, if needed
var stdOutOrg = os.Stdout
// OSExit defines, which exit function should be used
var OSExit = os.Exit
// ErrorExitOut defines, which exit output function should be used
var ErrorExitOut = ErrorLog
// ErrExitOut defines the output function, which should be used in case
// of colored output
var ErrExitOut = errExitOut
// InfoOut defines, which log output function should be used
var InfoOut = InfoLog
// DmiID is the path to the dmidecode representation in the /sys filesystem
var DmiID = "/sys/class/dmi/id"
// IsUserRoot return true only if the current user is root.
func IsUserRoot() bool {
return os.Getuid() == 0
}
// GetSolutionSelector returns the architecture string
// needed to select the supported set os solutions
func GetSolutionSelector() string {
solutionSelector := runtime.GOARCH
if IsPagecacheAvailable() {
solutionSelector = solutionSelector + "_PC"
}
return solutionSelector
}
// CmdIsAvailable returns true, if the cmd is available.
func CmdIsAvailable(cmdName string) bool {
if _, err := os.Stat(cmdName); os.IsNotExist(err) {
return false
}
return true
}
// GetOsVers returns the OS version
func GetOsVers() string {
// VERSION="12", VERSION="15"
// VERSION="12-SP1", VERSION="12-SP2", VERSION="12-SP3"
var re = regexp.MustCompile(`VERSION="([\w-]+)"`)
val, err := ioutil.ReadFile("/etc/os-release")
if err != nil {
return ""
}
matches := re.FindStringSubmatch(string(val))
if len(matches) == 0 {
return ""
}
return matches[1]
}
// GetOsName returns the OS name
func GetOsName() string {
// NAME="SLES"
var re = regexp.MustCompile(`NAME="([\w\s]+)"`)
val, err := ioutil.ReadFile("/etc/os-release")
if err != nil {
return ""
}
matches := re.FindStringSubmatch(string(val))
if len(matches) == 0 {
return ""
}
return matches[1]
}
// IsSLE15 returns true, if System is running a SLE15 release
func IsSLE15() bool {
var re = regexp.MustCompile(`15-SP\d+`)
if GetOsName() == "SLES" && (GetOsVers() == "15" || re.MatchString(GetOsVers())) {
return true
}
return false
}
// IsSLE12 returns true, if System is running a SLE12 release
func IsSLE12() bool {
var re = regexp.MustCompile(`12-SP\d+`)
if GetOsName() == "SLES" && (GetOsVers() == "12" || re.MatchString(GetOsVers())) {
return true
}
return false
}
// CheckForPattern returns true, if the file is available and
// contains the expected string
func CheckForPattern(file, pattern string) bool {
if _, err := os.Stat(file); os.IsNotExist(err) {
return false
}
content, err := ioutil.ReadFile(file)
if err != nil {
return false
}
//check whether content contains substring pattern
return strings.Contains(string(content), pattern)
}
// CalledFrom returns the name and the line number of the calling source file
func CalledFrom() string {
ret := ""
_, file, no, ok := runtime.Caller(2)
if ok {
_, relfile := filepath.Split(file)
ret = fmt.Sprintf("%s:%d: ", relfile, no)
}
return ret
}
func errExitOut(writer io.Writer, template string, stuff ...interface{}) {
// stuff is: color, bold, text/template, reset bold, reset color
stuff = stuff[1:]
fmt.Fprintf(writer, "%s%sERROR: "+template+"%s%s\n", stuff...)
if len(stuff) >= 4 {
stuff = stuff[2 : len(stuff)-2]
}
ErrLog(template+"\n", stuff...)
}
// ErrorExit prints the message to stderr and exit 1.
func ErrorExit(template string, stuff ...interface{}) {
exState := 1
fieldType := ""
field := len(stuff) - 1
if field >= 0 {
fieldType = reflect.TypeOf(stuff[field]).String()
}
if fieldType == "*exec.ExitError" {
// get return code of failed command, if available
if exitError, ok := stuff[field].(*exec.ExitError); ok {
exState = exitError.Sys().(syscall.WaitStatus).ExitStatus()
}
}
if fieldType == "int" {
exState = reflect.ValueOf(stuff[field]).Interface().(int)
stuff = stuff[:len(stuff)-1]
}
if len(template) != 0 {
if len(stuff) > 0 && stuff[0] == "colorPrint" {
ErrExitOut(os.Stderr, template, stuff...)
} else {
ErrorExitOut(template+"\n", stuff...)
}
}
if isOwnLock() {
ReleaseSaptuneLock()
}
if jerr := jOut(exState); jerr != nil {
exState = 130
}
InfoOut("saptune terminated with exit code '%v'", exState)
OSExit(exState)
}
// OutIsTerm returns true, if Stdout is a terminal
func OutIsTerm(writer *os.File) bool {
fileInfo, _ := writer.Stat()
return (fileInfo.Mode() & os.ModeCharDevice) != 0
}
// InitOut initializes the various output methodes
// currently only json and screen are supported
func InitOut(logSwitch map[string]string) {
if GetFlagVal("format") == "json" {
// if writing json format, switch off
// the stdout and stderr output of the log messages
logSwitch["verbose"] = "off"
logSwitch["error"] = "off"
// switch off stdout
if os.Getenv("SAPTUNE_JDEBUG") != "on" {
os.Stdout, _ = os.Open(os.DevNull)
}
jInit()
}
}
// SwitchOffOut disables stdout and stderr
func SwitchOffOut() (*os.File, *os.File) {
oldStdout := os.Stdout
oldSdterr := os.Stderr
os.Stdout, _ = os.Open(os.DevNull)
os.Stderr, _ = os.Open(os.DevNull)
return oldStdout, oldSdterr
}
// SwitchOnOut restores stdout and stderr to the settings before SwitchOffOut
// was called
func SwitchOnOut(stdout *os.File, stderr *os.File) {
os.Stdout = stdout
os.Stderr = stderr
}
// WrapTxt implements something like 'fold' command
// A given text string will be wrapped at word borders into
// lines of a given width
func WrapTxt(text string, width int) (folded []string) {
var words []string
fallback := false
if strings.Contains(text, " ") {
words = strings.Split(text, " ")
} else {
// fallback (e.g. net.ipv4.ip_local_reserved_ports)
words = strings.Split(text, ",")
fallback = true
}
if len(words) == 0 {
return
}
foldedTxt := words[0]
spaceLeft := width - len(foldedTxt)
noSpace := false
for _, word := range words[1:] {
if word == "\n" {
foldedTxt += word
spaceLeft = width
noSpace = true
continue
}
if len(word)+1 > spaceLeft {
// fold; start next row
if fallback {
foldedTxt += ",\n" + word
} else {
foldedTxt += "\n" + word
}
if strings.HasSuffix(word, "\n") {
spaceLeft = width
noSpace = true
} else {
spaceLeft = width - len(word)
noSpace = false
}
} else {
if noSpace {
foldedTxt += word
spaceLeft -= len(word)
noSpace = false
} else if fallback {
foldedTxt += "," + word
spaceLeft -= 1 + len(word)
} else {
foldedTxt += " " + word
spaceLeft -= 1 + len(word)
}
if strings.HasSuffix(word, "\n") {
spaceLeft = width
noSpace = true
}
}
}
folded = strings.Split(foldedTxt, "\n")
return
}
// GetDmiID return the content of /sys/devices/virtual/dmi/id/<file> or
// an empty string
func GetDmiID(file string) (string, error) {
var err error
var content []byte
ret := ""
fileName := fmt.Sprintf("%s/%s", DmiID, file)
if content, err = ioutil.ReadFile(fileName); err == nil {
ret = strings.TrimSpace(string(content))
} else {
InfoLog("failed to read %s - %v", fileName, err)
}
return ret, err
}
// GetHWIdentity returns the hardwar vendor or model of the system
// needs adaption, if the files to identify the hardware will change or
// if we need to look at different files for different vendors
// but the 'open' API GetDmiID exists for workarounds at customer side
func GetHWIdentity(info string) (string, error) {
var err error
var content []byte
fix := ""
fileName := ""
ret := ""
switch info {
case "vendor":
if runtime.GOARCH == "ppc64le" {
fix = "IBM"
} else {
fileName = fmt.Sprintf("%s/board_vendor", DmiID)
}
case "model":
if runtime.GOARCH == "ppc64le" {
fileName = "/sys/firmware/devicetree/base/model"
} else {
fileName = fmt.Sprintf("%s/product_name", DmiID)
}
}
if fileName != "" {
if content, err = ioutil.ReadFile(fileName); err == nil {
ret = strings.TrimSpace(string(content))
} else {
InfoLog("failed to read %s - %v", fileName, err)
}
}
if fix != "" {
ret = fix
err = nil
}
return ret, err
}
// StripComment will strip everything right from the given comment character
// (including the comment character) and returns the resulting string
// comment characters can be '#' or ';' or something else
// or a regex like `\s#[^#]|"\s#[^#]`
func StripComment(str, commentChars string) string {
ret := str
re := regexp.MustCompile(commentChars)
if cut := re.FindStringIndex(str); cut != nil {
ret = strings.TrimRightFunc(str[:cut[0]], unicode.IsSpace)
// strip masked # (\s## -> \s#) inside the text
re = regexp.MustCompile(`\s(##)`)
ret = re.ReplaceAllString(ret, "#")
}
return ret
}
// GetVirtStatus gets the status of virtualization environment
func GetVirtStatus() string {
vtype := ""
// first check vm (-v)
virt, vm, _ := SystemdDetectVirt("-v")
if virt {
// vm detected
vtype = vm
}
// next check container (-c)
virt, container, _ := SystemdDetectVirt("-c")
if virt {
// container detected
if vtype == "" {
vtype = container
} else {
vtype = vtype + " " + container
}
}
// last check for chroot (-r)
// be in mind, that the command will not deliver any output, but only
// return 0, if it found a chroot env or 1, if not
virt, _, _ = SystemdDetectVirt("-r")
if virt {
// chroot detected
if vtype == "" {
vtype = "chroot"
} else {
vtype = vtype + " chroot"
}
}
if vtype == "" {
vtype = "none"
}
return vtype
}
// Watch prints the current time
func Watch() string {
t := time.Now()
//watch := fmt.Sprintf("%s", t.Format(time.UnixDate))
watch := t.Format("2006/01/02 15:04:05.99999999")
return watch
}