Пример #1
0
func (chk PHPConfig) Status() (int, string, error) {
	// getPHPVariable returns the value of a PHP configuration value as a string
	// or just "" if it doesn't exist
	getPHPVariable := func(name string) (val string) {
		quote := func(str string) string {
			return "\"" + str + "\""
		}
		// php -r 'echo get_cfg_var("default_mimetype");
		echo := fmt.Sprintf("echo get_cfg_var(%s);", quote(name))
		cmd := exec.Command("php", "-r", echo)
		out, err := cmd.CombinedOutput()
		if err != nil {
			errutil.ExecError(cmd, string(out), err)
		}
		return string(out)
	}
	actualValue := getPHPVariable(chk.variable)
	if actualValue == chk.value {
		return errutil.Success()
	} else if actualValue == "" {
		msg := "PHP configuration variable not set"
		return errutil.GenericError(msg, chk.value, []string{actualValue})
	}
	msg := "PHP variable did not match expected value"
	return errutil.GenericError(msg, chk.value, []string{actualValue})
}
Пример #2
0
func (chk Installed) Status() (int, string, error) {
	name := getManager()
	options := managers[name]
	cmd := exec.Command(name, options, chk.pkg)
	out, err := cmd.CombinedOutput()
	outstr := string(out)
	var msg string
	switch {
	case err == nil && (name == "rpm" || name == "pacman"):
		return errutil.Success()
	// failures due to mising package
	case name == "dpkg" && strings.Contains(outstr, "not installed"):
	case name == "pacman" && strings.Contains(outstr, "not found"):
	case name == "rpm" && strings.Contains(outstr, "not installed"):
		msg := "Package was not found:"
		msg += "\n\tPackage name: " + chk.pkg
		msg += "\n\tPackage manager: " + name
		msg += "\n\tCommand output: " + outstr
		return 1, msg, nil
	// failures that were not due to packages not being installed
	case err != nil:
		errutil.ExecError(cmd, outstr, err)
	default:
		return errutil.Success()
	}
	return 1, msg, nil
}
Пример #3
0
// CommandOutput returns a string version of the ouput of a given command,
// and reports errors effectively.
func CommandOutput(cmd *exec.Cmd) string {
	out, err := cmd.CombinedOutput()
	outStr := string(out)
	if err != nil {
		errutil.ExecError(cmd, outStr, err)
	}
	return outStr
}
Пример #4
0
func (chk CommandOutputMatches) Status() (int, string, error) {
	cmd := exec.Command("bash", "-c", chk.Command)
	out, err := cmd.CombinedOutput()
	if err != nil {
		errutil.ExecError(cmd, string(out), err)
	}
	if chk.re.Match(out) {
		return errutil.Success()
	}
	msg := "Command output did not match regexp"
	return errutil.GenericError(msg, chk.re.String(), []string{string(out)})
}
Пример #5
0
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)})
}
Пример #6
0
func (chk KernelParameter) Status() (int, string, error) {
	// parameterValue returns the value of a kernel parameter
	parameterSet := func(name string) bool {
		cmd := exec.Command("/sbin/sysctl", "-q", "-n", name)
		out, err := cmd.CombinedOutput()
		// failed on incorrect module name
		if err != nil && strings.Contains(err.Error(), "255") {
			return false
		} else if err != nil {
			errutil.ExecError(cmd, string(out), err)
		}
		return true
	}
	if parameterSet(chk.name) {
		return errutil.Success()
	}
	return 1, "Kernel parameter not set: " + chk.name, nil
}
Пример #7
0
func (chk Installed) Status() (int, string, error) {
	name := getManager()
	options := managers[name]
	cmd := exec.Command(name, options, chk.pkg)
	out, err := cmd.CombinedOutput()
	outstr := string(out)
	if strings.Contains(outstr, chk.pkg) {
		return errutil.Success()
	} else if outstr != "" && err != nil {
		// pacman - outstr == "", and exit code of 1 if it can't find the pkg
		errutil.ExecError(cmd, outstr, err)
	}
	msg := "Package was not found:"
	msg += "\n\tPackage name: " + chk.pkg
	msg += "\n\tPackage manager: " + name
	msg += "\n\tCommand output: " + outstr
	return 1, msg, nil

}