// getYumRepos constructs Repos from the yum.conf file at path. Gives non-zero
// Names, Fullnames, and URLs.
func getYumRepos() (repos []repo) {
// safeAccess allows access w/o fear of a panic into a slice of strings
safeAccess := func(slc []string, index int) string {
// catch runtime panic
defer func() {
if err := recover(); err != nil {
msg := "safeAccess: Please report this error"
errutil.IndexError(msg, index, slc)
}
}() // invoke inside defer
if len(slc) > index {
return slc[index]
}
return ""
}
// get and parse output of `yum repolist`
cmd := exec.Command("yum", "repolist")
outstr := chkutil.CommandOutput(cmd)
// handle empty case
if strings.Contains(outstr, "repolist: 0") {
return repos
}
slc := tabular.ProbabalisticSplit(outstr)
ids := tabular.GetColumnNoHeader(0, slc) // TODO use columnbyheader here
errutil.IndexError("getYumRepos", 2, ids)
ids = ids[:len(ids)-2]
names := tabular.GetColumnNoHeader(1, slc) // TODO and here
statuses := tabular.GetColumnNoHeader(2, slc) // TODO and here
if len(ids) != len(names) || len(names) != len(statuses) {
log.WithFields(log.Fields{
"names": len(names),
"ids": len(ids),
"statuses": len(statuses),
}).Warn("Could not fetch complete metadata for every repo.")
}
// Construct repos
for i := range ids {
name := safeAccess(names, i)
id := safeAccess(ids, i)
status := safeAccess(statuses, i)
repo := repo{Name: name, ID: id, Status: status}
repos = append(repos, repo)
}
return repos
}
func (chk Temp) Status() (int, string, error) {
// allCoreTemps returns the Temperature of each core
allCoreTemps := func() (Temps []int) {
cmd := exec.Command("sensors")
out, err := cmd.CombinedOutput()
outstr := string(out)
errutil.ExecError(cmd, outstr, err)
restr := `Core\s\d+:\s+[\+\-](?P<Temp>\d+)\.*\d*°C`
re := regexp.MustCompile(restr)
for _, line := range regexp.MustCompile(`\n+`).Split(outstr, -1) {
if re.MatchString(line) {
// submatch captures only the integer part of the Temperature
matchDict := chkutil.SubmatchMap(re, line)
if _, ok := matchDict["Temp"]; !ok {
log.WithFields(log.Fields{
"regexp": re.String(),
"matchDict": matchDict,
"output": outstr,
}).Fatal("Couldn't find any Temperatures in `sensors` output")
}
TempInt64, err := strconv.ParseInt(matchDict["Temp"], 10, 64)
if err != nil {
log.WithFields(log.Fields{
"regexp": re.String(),
"matchDict": matchDict,
"output": outstr,
"error": err.Error(),
}).Fatal("Couldn't parse integer from `sensors` output")
}
Temps = append(Temps, int(TempInt64))
}
}
return Temps
}
// getCoreTemp returns an integer Temperature for a certain core
getCoreTemp := func(core int) (Temp int) {
Temps := allCoreTemps()
errutil.IndexError("No such core available", core, Temps)
return Temps[core]
}
Temp := getCoreTemp(0)
if Temp < int(chk.max) {
return errutil.Success()
}
msg := "Core Temp exceeds defined maximum"
return errutil.GenericError(msg, chk.max, []string{fmt.Sprint(Temp)})
}
func (chk PacmanIgnore) Status() (int, string, error) {
path := "/etc/pacman.conf"
data := chkutil.FileToString(path)
re := regexp.MustCompile(`[^#]IgnorePkg\s+=\s+.+`)
find := re.FindString(data)
var packages []string
if find != "" {
spl := strings.Split(find, " ")
errutil.IndexError("Not enough lines in "+path, 2, spl)
packages = spl[2:] // first two are "IgnorePkg" and "="
if tabular.StrIn(chk.pkg, packages) {
return errutil.Success()
}
}
msg := "Couldn't find package in IgnorePkg"
return errutil.GenericError(msg, chk.pkg, packages)
}
func (chk GatewayInterface) Status() (int, string, error) {
// getGatewayInterface returns the interface that the default Gateway is
// operating on
getGatewayInterface := func() (iface string) {
ips := RoutingTableColumn("Gateway")
names := RoutingTableColumn("Iface")
for i, ip := range ips {
if ip != "0.0.0.0" {
msg := "Fewer names in kernel routing table than IPs"
errutil.IndexError(msg, i, names)
return names[i] // interface name
}
}
return ""
}
iface := getGatewayInterface()
if chk.name == iface {
return errutil.Success()
}
msg := "Default Gateway does not operate on interface"
return errutil.GenericError(msg, chk.name, []string{iface})
}