feat: add the check_output_matches plugin (#5)

This PR adds the `check_output_matches` plugin, which can be used to count regexp or substring matches from either text files or command outputs and determine the final status based on the amount of matches that were found.

Reviewed-on: #5
Co-authored-by: Emmanuel BENOÎT <tseeker@nocternity.net>
Co-committed-by: Emmanuel BENOÎT <tseeker@nocternity.net>

.golangci.yml

@@ -34,3 +34,6 @@ linters-settings:
       - standard
       - default
       - localmodule
+  gomoddirectives:
+    replace-allow-list:
+      - github.com/karrick/golf

README.md

@@ -49,6 +49,48 @@ supports the following command-line flags:
 * `-p port`/`--rs-port port`: the port to use on the reference server
   (defaults to 53).
 
+### Generic text match counter
+
+The `check_output_matches` plugin can be used to count occurrences of strings
+in a program's output or in a text file, and compute its final status based on
+that.
+
+It supports the following general command line flags:
+
+* `-f` / `--is-file` indicates that the plugin will be reading from a text file
+  instead of running another program;
+* `-s` / `--source` is either the name of the file to read, or the command to
+  execute. The command may include multiple arguments separated by single
+  spaces; it does not support any form of quoting.
+* `-T` / `--timeout` can set a timeout for the command. It is disabled by
+  default.
+* `-S` / `--strict` determines how unmatched lines are handled. By default they
+  are ignored, but setting this flag will cause the plugin to enter `CRITICAL`
+  mode if unmatched lines are found.
+
+Other flags are available in order to configure the matches. The main flag is
+`-m` / `--match`, which adds a new match string to the set of checks to run.
+The checks are influenced by the following additional flags, which apply to all
+subsequent matches.
+
+* `-r` / `--regexp` indicates that new matches will be based on regular
+  expressions instead of substrings.
+* `-R` / `--no-regexp` switches back to substring-based matches.
+* `-w` / `--warn` can be used to set a warning range. It must be followed by
+  a Nagios range specification.
+* `-W` / `--no-warn` clears the warning range.
+* `-c` / `--critical` can be used to set the critical range. It must be followed
+  by a Nagios range specification.
+* `-C` / `--no-critical` clears the critical range.
+
+For example, the command below:
+
+    gomonop check_output_matches -s 'find /some/place' \
+       -w 4 -r -m '^.*\.warn$' \
+       -W -c 0 -R -m fatal
+
+configures a warning if more than 4 files ending in `.warn` are found, and a
+critical state if any file with `fatal` in its name is found.
 
 Building from source
 --------------------

cmd/matches/cmdline.go

@@ -0,0 +1,95 @@
+package matches // import nocternity.net/gomonop/cmd/matches
+
+import (
+	"context"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/karrick/golf"
+
+	"nocternity.net/gomonop/pkg/perfdata"
+)
+
+// pluginFlags represent command line flags that have been parsed.
+type pluginFlags struct {
+	isFile     bool          // Are we reading from a file?
+	dataSource string        // The file or command to read from
+	timeout    time.Duration // A timeout for the command, or 0 to disable
+	matches    []matchConfig // Configuration for the matches to check
+	strict     bool          // Reject lines that don't match anything
+}
+
+// matchConfig is the configuration for a single match to check.
+type matchConfig struct {
+	isRegexp    bool            // Are we checking against a regular expression?
+	matchString string          // The string or regexp to match
+	compiledRe  *regexp.Regexp  // The compiled regexp
+	warn        *perfdata.Range // Warning range
+	crit        *perfdata.Range // Critical range
+}
+
+// parseArguments parses command line arguments for the plugin.
+func (p *pluginFlags) parseArguments() {
+	golf.BoolVarP(&p.isFile, 'f', "is-file", false, "Are we reading from a file?")
+	golf.StringVarP(&p.dataSource, 's', "source", "", "The file or command to read from")
+	golf.DurationVarP(&p.timeout, 'T', "timeout", 0, "A timeout for the command, or 0 to disable")
+	golf.BoolVarP(&p.strict, 'S', "strict", false, "Reject lines that do not match anything")
+
+	isRegexp := golf.BoolP('R', "no-regexp", true, "Following match argument will be a basic string")
+	golf.BoolVarP(isRegexp, 'r', "regexp", false, "Following match argument will be a regexp")
+
+	var wRange *perfdata.Range
+	golf.StringFuncP('w', "warn", "", "Warning range, in Nagios-compatible format", func(s string) error {
+		locRange, err := perfdata.ParseRange(s)
+		if err == nil {
+			wRange = locRange
+		}
+		return err
+	})
+	golf.BoolFuncP('W', "no-warn", false, "Clear warning range", func(bool) error {
+		wRange = nil
+		return nil
+	})
+
+	var cRange *perfdata.Range
+	golf.StringFuncP('c', "critical", "", "Critical range, in Nagios-compatible format", func(s string) error {
+		locRange, err := perfdata.ParseRange(s)
+		if err == nil {
+			cRange = locRange
+		}
+		return err
+	})
+	golf.BoolFuncP('C', "no-critical", false, "Clear warning range", func(bool) error {
+		cRange = nil
+		return nil
+	})
+
+	golf.StringFuncP('m', "match", "", "Match string", func(s string) error {
+		p.matches = append(p.matches, matchConfig{
+			isRegexp:    *isRegexp,
+			matchString: s,
+			warn:        wRange,
+			crit:        cRange,
+		})
+		return nil
+	})
+
+	golf.Parse()
+}
+
+// makeContext generates a context based on the timeout, if one is set.
+func (p *pluginFlags) makeContext() (context.Context, context.CancelFunc) {
+	if p.timeout == 0 {
+		return context.Background(), func() {}
+	}
+	return context.WithTimeout(context.Background(), p.timeout)
+}
+
+// matches check if the specified string matches a configuration.
+func (p *matchConfig) matches(s string) bool {
+	if p.isRegexp {
+		return p.compiledRe.MatchString(s)
+	}
+	return strings.Contains(s, p.matchString)
+}

cmd/matches/extprogram.go

@@ -0,0 +1,118 @@
+package matches // import  nocternity.net/gomonop/pkg/matches
+
+import (
+	"bufio"
+	"context"
+	"io"
+	"os/exec"
+	"strings"
+)
+
+// streamObtainer refers to functions that may return either an input stream or
+// an error.
+type streamObtainer func() (io.ReadCloser, error)
+
+// pipeCopy encapsulates the structures that are used to transfer data from a
+// single stream to the reader.
+type pipeCopy struct {
+	reader     io.ReadCloser // The input stream being read from
+	dataPipe   chan string   // Channel that receives the data we read
+	aborter    chan struct{} // Channel that causes the copy to abort
+	readResult chan error    // Channel that returns results from reading
+}
+
+// startPipeCopy starts a goroutine that copies data from the reader to the
+// dataPipe.
+func startPipeCopy(obtainer streamObtainer, pipes *readerPipes) *pipeCopy {
+	stream, err := obtainer()
+	if err != nil {
+		pipes.done <- err
+		return nil
+	}
+
+	pipeCopyData := &pipeCopy{
+		reader:     stream,
+		dataPipe:   pipes.data,
+		aborter:    make(chan struct{}),
+		readResult: make(chan error),
+	}
+
+	go pipeCopyData.run()
+
+	return pipeCopyData
+}
+
+// run runs the copy operation from the input stream to the data pipe. It is
+// meant to be executed as a goroutine.
+func (pc *pipeCopy) run() {
+	scanner := bufio.NewScanner(pc.reader)
+	for scanner.Scan() {
+		select {
+		case <-pc.aborter:
+			return
+		case pc.dataPipe <- scanner.Text():
+		}
+	}
+	pc.readResult <- scanner.Err()
+}
+
+// close closes the stream and channels used by a copy pipe.
+func (pc *pipeCopy) close() {
+	pc.abort()
+	_ = pc.reader.Close()
+	close(pc.aborter)
+	close(pc.readResult)
+}
+
+// abort causes the pipe copy to be aborted.
+func (pc *pipeCopy) abort() {
+	pc.aborter <- struct{}{}
+}
+
+// readFromProgram starts a goroutine that controls the program, sending lines
+// from both stderr and stdout to the dataPipe.
+func (pluginInst *matchesPlugin) readFromProgram(ctx context.Context, pipes *readerPipes) {
+	go func() {
+		args := strings.Split(pluginInst.dataSource, " ")
+		cmd := exec.Command(args[0], args[1:]...) //nolint:gosec // Command is in fact user-provided
+
+		outs := startPipeCopy(func() (io.ReadCloser, error) { return cmd.StdoutPipe() }, pipes)
+		defer outs.close()
+		errs := startPipeCopy(func() (io.ReadCloser, error) { return cmd.StderrPipe() }, pipes)
+		defer errs.close()
+
+		if err := cmd.Start(); err != nil {
+			pipes.done <- err
+			return
+		}
+
+		abort := func(err error) {
+			_ = cmd.Process.Kill()
+			pipes.done <- err
+		}
+
+		errComplete := false
+		outComplete := false
+		for !(errComplete && outComplete) {
+			select {
+			case <-ctx.Done():
+				abort(ctx.Err())
+				return
+			case err := <-outs.readResult:
+				if err != nil {
+					abort(err)
+					return
+				}
+				outComplete = true
+			case err := <-errs.readResult:
+				if err != nil {
+					abort(err)
+					return
+				}
+				errComplete = true
+			}
+		}
+
+		pipes.done <- cmd.Wait()
+	}()
+}

cmd/matches/plugin.go

@@ -0,0 +1,76 @@
+// The matches package contains the implementation of the `check_output_matches`
+// plugin, which can be used to run an arbitrary command and check its output
+// against various patterns. It can also be configured to do the same on an
+// arbitrary file.
+package matches // import nocternity.net/gomonop/cmd/matches
+
+import (
+	"regexp"
+
+	"nocternity.net/gomonop/pkg/plugin"
+	"nocternity.net/gomonop/pkg/results"
+	"nocternity.net/gomonop/pkg/status"
+)
+
+// Program data for the string matches plugin.
+type matchesPlugin struct {
+	pluginFlags                     // Flags from the command line
+	results        *results.Results // Plugin output state
+	counters       []int            // Counters for each match
+	unmatchedLines int              // Number of lines that didn't match anything
+}
+
+// Initialise the plugin.
+func NewPlugin() plugin.Plugin {
+	pluginInst := &matchesPlugin{
+		results: results.New("String matches counter"),
+	}
+	pluginInst.parseArguments()
+	return pluginInst
+}
+
+// Return the program's output value.
+func (pluginInst *matchesPlugin) Results() *results.Results {
+	return pluginInst.results
+}
+
+// Check the values that were specified from the command line. Returns true
+// if the arguments made sense.
+func (pluginInst *matchesPlugin) CheckArguments() bool {
+	if pluginInst.dataSource == "" {
+		pluginInst.results.SetState(status.StatusUnknown, "no data source specified")
+		return false
+	}
+
+	if !pluginInst.strict && len(pluginInst.matches) == 0 {
+		pluginInst.results.SetState(status.StatusUnknown, "would match anything")
+		return false
+	}
+
+	for index := range pluginInst.matches {
+		if pluginInst.matches[index].matchString == "" {
+			pluginInst.results.SetState(status.StatusUnknown, "empty match string")
+			pluginInst.results.AddLinef("(At match %d)", index+1)
+			return false
+		}
+		if pluginInst.matches[index].isRegexp {
+			rexp, err := regexp.Compile(pluginInst.matches[index].matchString)
+			if err != nil {
+				pluginInst.results.SetState(status.StatusUnknown, "Invalid regular expression")
+				pluginInst.results.AddLine(err.Error())
+				pluginInst.results.AddLinef("(At match %d)", index+1)
+				return false
+			}
+			pluginInst.matches[index].compiledRe = rexp
+		}
+	}
+
+	return true
+}
+
+// Run the check.
+func (pluginInst *matchesPlugin) RunCheck() {
+	pluginInst.counters = make([]int, len(pluginInst.matches))
+	err := pluginInst.processData()
+	pluginInst.checkResults(err)
+}

cmd/matches/reader.go

@@ -0,0 +1,95 @@
+package matches // import  nocternity.net/gomonop/pkg/matches
+
+import (
+	"bufio"
+	"context"
+	"os"
+)
+
+// readerPipes encapsulates the two channels used to communicate data and state
+// from the functions that acquire the data.
+type readerPipes struct {
+	done chan error
+	data chan string
+}
+
+// makeReaderPipes initializes the channels.
+func makeReaderPipes() *readerPipes {
+	return &readerPipes{
+		done: make(chan error),
+		data: make(chan string),
+	}
+}
+
+// close closes the channels.
+func (rdp *readerPipes) close() {
+	close(rdp.done)
+	close(rdp.data)
+}
+
+// readFromFile starts a goroutine that reads from the file and sends each line
+// to the dataPipe.
+func (pluginInst *matchesPlugin) readFromFile(ctx context.Context, pipes *readerPipes) {
+	go func() {
+		file, err := os.Open(pluginInst.dataSource)
+		if err != nil {
+			pipes.done <- err
+			return
+		}
+		defer file.Close()
+
+		scanner := bufio.NewScanner(file)
+		for scanner.Scan() {
+			select {
+			case <-ctx.Done():
+				pipes.done <- ctx.Err()
+				return
+			case pipes.data <- scanner.Text():
+			}
+		}
+		pipes.done <- scanner.Err()
+	}()
+}
+
+// startReading starts reading data from either a file or a program.
+func (pluginInst *matchesPlugin) startReading(ctx context.Context, pipes *readerPipes) {
+	if pluginInst.isFile {
+		pluginInst.readFromFile(ctx, pipes)
+	} else {
+		pluginInst.readFromProgram(ctx, pipes)
+	}
+}
+
+// processLine processes a single line obtained from the program or file.
+func (pluginInst *matchesPlugin) processLine(line string) {
+	hadMatch := false
+	for index := range pluginInst.matches {
+		if pluginInst.matches[index].matches(line) {
+			pluginInst.counters[index]++
+			hadMatch = true
+		}
+	}
+	if !hadMatch {
+		pluginInst.unmatchedLines++
+	}
+}
+
+// processData processes data from either the program or the file.
+func (pluginInst *matchesPlugin) processData() error {
+	ctx, cancel := pluginInst.makeContext()
+	defer cancel()
+
+	pipes := makeReaderPipes()
+	defer pipes.close()
+
+	pluginInst.startReading(ctx, pipes)
+
+	for {
+		select {
+		case line := <-pipes.data:
+			pluginInst.processLine(line)
+		case err := <-pipes.done:
+			return err
+		}
+	}
+}

cmd/matches/results.go

@@ -0,0 +1,125 @@
+package matches // import nocternity.net/gomonop/cmd/matches
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"nocternity.net/gomonop/pkg/perfdata"
+	"nocternity.net/gomonop/pkg/status"
+)
+
+// resultsInfo contains information about results being processed.
+type resultsInfo struct {
+	nWarns, nCrits, nUnknowns uint
+}
+
+// updateResults updates the result counters based on the specified status.
+func (info *resultsInfo) updateFrom(itemStatus status.Status) {
+	switch itemStatus {
+	case status.StatusCritical:
+		info.nCrits++
+	case status.StatusWarning:
+		info.nWarns++
+	case status.StatusUnknown:
+		info.nUnknowns++
+	case status.StatusOK:
+		// do nothing
+	}
+}
+
+// toProblems generate the list of problems found while running the plugin,
+// as a string which can be returned to the monitoring server.
+func (info *resultsInfo) toProblems() string {
+	problems := []string{}
+	if info.nCrits > 0 {
+		problems = append(problems,
+			fmt.Sprintf("%d value(s) critical", info.nCrits),
+		)
+	}
+	if info.nWarns > 0 {
+		problems = append(problems,
+			fmt.Sprintf("%d value(s) warning", info.nWarns),
+		)
+	}
+	if info.nUnknowns > 0 {
+		problems = append(problems,
+			fmt.Sprintf("%d value(s) unknown", info.nUnknowns),
+		)
+	}
+	if len(problems) == 0 {
+		problems = append(problems, "No match errors")
+	}
+	return strings.Join(problems, ", ")
+}
+
+// toStatus computes the final status of the plugin based on the status
+// counters.
+func (info *resultsInfo) toStatus() status.Status {
+	switch {
+	case info.nCrits > 0:
+		return status.StatusCritical
+	case info.nWarns > 0:
+		return status.StatusWarning
+	case info.nUnknowns > 0:
+		return status.StatusUnknown
+	default:
+		return status.StatusOK
+	}
+}
+
+// checkCounters checks the match counters against their configured thresholds,
+// if any, and adds the corresponding perf data to the result. It initializes a
+// resultsInfo structure containing the counts of critical, warning and unknown
+// statuses gathered so far.
+func (pluginInst *matchesPlugin) checkCounters() resultsInfo {
+	info := resultsInfo{}
+
+	for index := range pluginInst.counters {
+		config := &pluginInst.matches[index]
+
+		var nature string
+		if config.isRegexp {
+			nature = "regexp"
+		} else {
+			nature = "substring"
+		}
+		label := fmt.Sprintf("#%2d : %s %s", index+1, nature, config.matchString)
+		value := strconv.Itoa(pluginInst.counters[index])
+
+		pdat := perfdata.New(label, perfdata.UomNone, value)
+		pdat.SetWarn(config.warn)
+		pdat.SetCrit(config.crit)
+		pluginInst.results.AddPerfData(pdat)
+
+		info.updateFrom(pdat.GetStatus())
+	}
+
+	return info
+}
+
+// checkUnmatched checks the unmatched lines counters, applying a limit if
+// strict mode is enabled. The corresponding performance data is added to the
+// result.
+func (pluginInst *matchesPlugin) checkUnmatched(info *resultsInfo) {
+	umlPdat := perfdata.New("unmatched", perfdata.UomNone, strconv.Itoa(pluginInst.unmatchedLines))
+	if pluginInst.strict {
+		umlPdat.SetCrit(perfdata.RangeMinMax("~", "0"))
+	}
+	info.updateFrom(umlPdat.GetStatus())
+	pluginInst.results.AddPerfData(umlPdat)
+}
+
+// checkResults checks the various counters against their configured thresholds,
+// and the strict mode failure count.
+func (pluginInst *matchesPlugin) checkResults(readError error) {
+	info := pluginInst.checkCounters()
+	pluginInst.checkUnmatched(&info)
+
+	if readError != nil {
+		pluginInst.results.AddLinef("Error while reading data: %s", readError.Error())
+		info.nUnknowns++
+	}
+
+	pluginInst.results.SetState(info.toStatus(), info.toProblems())
+}

cmd/sslcert/main.go

@@ -17,6 +17,7 @@ import (
 	"nocternity.net/gomonop/pkg/perfdata"
 	"nocternity.net/gomonop/pkg/plugin"
 	"nocternity.net/gomonop/pkg/results"
+	"nocternity.net/gomonop/pkg/status"
 )
 
 //--------------------------------------------------------------------------------------------------------
@@ -224,20 +225,20 @@ func (program *checkProgram) Results() *results.Results {
 // if the arguments made sense.
 func (program *checkProgram) CheckArguments() bool {
 	if program.hostname == "" {
-		program.plugin.SetState(results.StatusUnknown, "no hostname specified")
+		program.plugin.SetState(status.StatusUnknown, "no hostname specified")
 		return false
 	}
 	if program.port < 1 || program.port > 65535 {
-		program.plugin.SetState(results.StatusUnknown, "invalid or missing port number")
+		program.plugin.SetState(status.StatusUnknown, "invalid or missing port number")
 		return false
 	}
 	if program.warn != -1 && program.crit != -1 && program.warn <= program.crit {
-		program.plugin.SetState(results.StatusUnknown, "nonsensical thresholds")
+		program.plugin.SetState(status.StatusUnknown, "nonsensical thresholds")
 		return false
 	}
 	if _, ok := certGetters[program.startTLS]; !ok {
 		errstr := "unsupported StartTLS protocol " + program.startTLS
-		program.plugin.SetState(results.StatusUnknown, errstr)
+		program.plugin.SetState(status.StatusUnknown, errstr)
 		return false
 	}
 	program.hostname = strings.ToLower(program.hostname)
@@ -262,13 +263,13 @@ func (program *checkProgram) getCertificate() error {
 // matches the requested host name.
 func (program *checkProgram) checkSANlessCertificate() bool {
 	if !program.ignoreCnOnly || len(program.extraNames) != 0 {
-		program.plugin.SetState(results.StatusWarning,
+		program.plugin.SetState(status.StatusWarning,
 			"certificate doesn't have SAN domain names")
 		return false
 	}
 	dn := strings.ToLower(program.certificate.Subject.String())
 	if !strings.HasPrefix(dn, fmt.Sprintf("cn=%s,", program.hostname)) {
-		program.plugin.SetState(results.StatusCritical, "incorrect certificate CN")
+		program.plugin.SetState(status.StatusCritical, "incorrect certificate CN")
 		return false
 	}
 	return true
@@ -298,7 +299,7 @@ func (program *checkProgram) checkNames() bool {
 		certificateIsOk = program.checkHostName(name) && certificateIsOk
 	}
 	if !certificateIsOk {
-		program.plugin.SetState(results.StatusCritical, "names missing from SAN domain names")
+		program.plugin.SetState(status.StatusCritical, "names missing from SAN domain names")
 	}
 	return certificateIsOk
 }
@@ -306,26 +307,26 @@ func (program *checkProgram) checkNames() bool {
 // Check a certificate's time to expiry against the warning and critical
 // thresholds, returning a status code and description based on these
 // values.
-func (program *checkProgram) checkCertificateExpiry(tlDays int) (results.Status, string) {
+func (program *checkProgram) checkCertificateExpiry(tlDays int) (status.Status, string) {
 	if tlDays <= 0 {
-		return results.StatusCritical, "certificate expired"
+		return status.StatusCritical, "certificate expired"
 	}
 
 	var limitStr string
-	var state results.Status
+	var state status.Status
 
 	switch {
 	case program.crit > 0 && tlDays <= program.crit:
 		limitStr = fmt.Sprintf(" (<= %d)", program.crit)
-		state = results.StatusCritical
+		state = status.StatusCritical
 
 	case program.warn > 0 && tlDays <= program.warn:
 		limitStr = fmt.Sprintf(" (<= %d)", program.warn)
-		state = results.StatusWarning
+		state = status.StatusWarning
 
 	default:
 		limitStr = ""
-		state = results.StatusOK
+		state = status.StatusOK
 	}
 
 	statusString := fmt.Sprintf("certificate will expire in %d days%s",
@@ -351,7 +352,7 @@ func (program *checkProgram) setPerfData(tlDays int) {
 func (program *checkProgram) RunCheck() {
 	err := program.getCertificate()
 	if err != nil {
-		program.plugin.SetState(results.StatusUnknown, err.Error())
+		program.plugin.SetState(status.StatusUnknown, err.Error())
 	} else if program.checkNames() {
 		timeLeft := time.Until(program.certificate.NotAfter)
 		tlDays := int((timeLeft + 86399*time.Second) / (24 * time.Hour))

cmd/zoneserial/main.go

@@ -15,6 +15,7 @@ import (
 	"nocternity.net/gomonop/pkg/perfdata"
 	"nocternity.net/gomonop/pkg/plugin"
 	"nocternity.net/gomonop/pkg/results"
+	"nocternity.net/gomonop/pkg/status"
 )
 
 //-------------------------------------------------------------------------------------------------------
@@ -93,23 +94,23 @@ func (program *checkProgram) Results() *results.Results {
 // Check the values that were specified from the command line. Returns true if the arguments made sense.
 func (program *checkProgram) CheckArguments() bool {
 	if program.hostname == "" {
-		program.plugin.SetState(results.StatusUnknown, "no DNS hostname specified")
+		program.plugin.SetState(status.StatusUnknown, "no DNS hostname specified")
 		return false
 	}
 	if program.port < 1 || program.port > 65535 {
-		program.plugin.SetState(results.StatusUnknown, "invalid DNS port number")
+		program.plugin.SetState(status.StatusUnknown, "invalid DNS port number")
 		return false
 	}
 	if program.zone == "" {
-		program.plugin.SetState(results.StatusUnknown, "no DNS zone specified")
+		program.plugin.SetState(status.StatusUnknown, "no DNS zone specified")
 		return false
 	}
 	if program.rsHostname == "" {
-		program.plugin.SetState(results.StatusUnknown, "no reference DNS hostname specified")
+		program.plugin.SetState(status.StatusUnknown, "no reference DNS hostname specified")
 		return false
 	}
 	if program.rsPort < 1 || program.rsPort > 65535 {
-		program.plugin.SetState(results.StatusUnknown, "invalid reference DNS port number")
+		program.plugin.SetState(status.StatusUnknown, "invalid reference DNS port number")
 		return false
 	}
 	program.hostname = strings.ToLower(program.hostname)
@@ -176,12 +177,12 @@ func (program *checkProgram) RunCheck() {
 	cOk, cSerial := program.getSerial("checked", checkResponse)
 	rOk, rSerial := program.getSerial("reference", refResponse)
 	if !(cOk && rOk) {
-		program.plugin.SetState(results.StatusUnknown, "could not read serials")
+		program.plugin.SetState(status.StatusUnknown, "could not read serials")
 		return
 	}
 	if cSerial == rSerial {
-		program.plugin.SetState(results.StatusOK, "serials match")
+		program.plugin.SetState(status.StatusOK, "serials match")
 	} else {
-		program.plugin.SetState(results.StatusCritical, "serials mismatch")
+		program.plugin.SetState(status.StatusCritical, "serials mismatch")
 	}
 }

go.mod

@@ -5,14 +5,16 @@ go 1.22
 require (
 	github.com/karrick/golf v1.4.0
 	github.com/miekg/dns v1.1.40
+	github.com/stretchr/testify v1.9.0
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/stretchr/testify v1.9.0 // indirect
 	golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550 // indirect
 	golang.org/x/net v0.0.0-20190923162816-aa69164e4478 // indirect
 	golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
+
+replace github.com/karrick/golf v1.4.0 => github.com/tseeker/golf v0.0.0-20240720130627-ce082c3b50d5

go.sum

@@ -1,13 +1,13 @@
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/karrick/golf v1.4.0 h1:9i9HnUh7uCyUFJhIqg311HBibw4f2pbGldi0ZM2FhaQ=
-github.com/karrick/golf v1.4.0/go.mod h1:qGN0IhcEL+IEgCXp00RvH32UP59vtwc8w5YcIdArNRk=
 github.com/miekg/dns v1.1.40 h1:pyyPFfGMnciYUk/mXpKkVmeMQjfXqt3FAJ2hy7tPiLA=
 github.com/miekg/dns v1.1.40/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tseeker/golf v0.0.0-20240720130627-ce082c3b50d5 h1:IreFtDkjJg81heDw+xIEkVZXySV4zQzwKbpenJBQHqk=
+github.com/tseeker/golf v0.0.0-20240720130627-ce082c3b50d5/go.mod h1:qGN0IhcEL+IEgCXp00RvH32UP59vtwc8w5YcIdArNRk=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550 h1:ObdrDkeb4kJdCP557AjRjq69pTHfNouLtWZG7j9rPN8=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
@@ -25,6 +25,7 @@ golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -5,15 +5,17 @@ import (
 	"os"
 	"path/filepath"
 
+	"nocternity.net/gomonop/cmd/matches"
 	"nocternity.net/gomonop/cmd/sslcert"
 	"nocternity.net/gomonop/cmd/zoneserial"
 	"nocternity.net/gomonop/pkg/plugin"
-	"nocternity.net/gomonop/pkg/results"
+	"nocternity.net/gomonop/pkg/status"
 	"nocternity.net/gomonop/pkg/version"
 )
 
 var (
 	plugins map[string]plugin.Builder = map[string]plugin.Builder{
+		"check_output_matches":  matches.NewPlugin,
 		"check_ssl_certificate": sslcert.NewProgram,
 		"check_zone_serial":     zoneserial.NewProgram,
 	}
@@ -28,7 +30,7 @@ func getPlugin() plugin.Plugin {
 
 	if len(os.Args) < 2 {
 		fmt.Printf("Syntax: %s <plugin> [arguments]\n", ownName)
-		fmt.Printf("        %s --plugin|-p\n", ownName)
+		fmt.Printf("        %s --plugins|-p\n", ownName)
 		fmt.Printf("        %s --version|-v\n", ownName)
 		os.Exit(1)
 	}
@@ -61,7 +63,7 @@ func main() {
 	output := runPlugin.Results()
 	defer func() {
 		if r := recover(); r != nil {
-			output.SetState(results.StatusUnknown, "Internal error")
+			output.SetState(status.StatusUnknown, "Internal error")
 			output.AddLinef("Error info: %v", r)
 		}
 		fmt.Println(output.String())

pkg/perfdata/perfdata.go

@@ -3,7 +3,10 @@
 package perfdata // import nocternity.net/gomonop/pkg/perfdata
 
 import (
+	"strconv"
 	"strings"
+
+	"nocternity.net/gomonop/pkg/status"
 )
 
 // Performance data, including a label, units, a value, warning/critical
@@ -35,15 +38,23 @@ func New(label string, units UnitOfMeasurement, value string) *PerfData {
 
 // Set the warning range for the performance data record.
 func (d *PerfData) SetWarn(r *Range) {
+	if r == nil {
+		d.bits &^= PDatWarn
+	} else {
 		d.warn = *r
 		d.bits |= PDatWarn
 	}
+}
 
 // Set the critical range for the performance data record.
 func (d *PerfData) SetCrit(r *Range) {
+	if r == nil {
+		d.bits &^= PDatCrit
+	} else {
 		d.crit = *r
 		d.bits |= PDatCrit
 	}
+}
 
 // Set the performance data's minimal value.
 func (d *PerfData) SetMin(min string) {
@@ -63,6 +74,23 @@ func (d *PerfData) SetMax(max string) {
 	d.bits |= PDatMax
 }
 
+// Check the performance data's value against its configured ranges.
+func (d *PerfData) GetStatus() status.Status {
+	value, err := strconv.ParseFloat(d.value, 64)
+	if err != nil {
+		return status.StatusUnknown
+	}
+
+	if d.bits&PDatCrit != 0 && d.crit.Contains(value) {
+		return status.StatusCritical
+	}
+	if d.bits&PDatWarn != 0 && d.warn.Contains(value) {
+		return status.StatusWarning
+	}
+
+	return status.StatusOK
+}
+
 // Converts performance data to a string which may be read by the monitoring
 // system.
 func (d *PerfData) String() string {

pkg/perfdata/perfdata_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"nocternity.net/gomonop/pkg/status"
 )
 
 func TestNewNoValue(t *testing.T) {
@@ -50,6 +51,12 @@ func TestSetWarn(t *testing.T) {
 	assert.Equal(t, rangeStr, data.warn.String())
 }
 
+func TestSetWarnNil(t *testing.T) {
+	data := PerfData{}
+	data.SetWarn(nil)
+	assert.Equal(t, perfDataBits(0), data.bits&PDatWarn)
+}
+
 func TestSetWarnTwice(t *testing.T) {
 	range1Value := Range{start: "A", end: "B"}
 	range2Value := Range{start: "C", end: "D"}
@@ -64,6 +71,16 @@ func TestSetWarnTwice(t *testing.T) {
 	assert.Equal(t, range2Str, data.warn.String())
 }
 
+func TestSetWarnClear(t *testing.T) {
+	range1Value := Range{start: "A", end: "B"}
+
+	data := PerfData{}
+	data.SetWarn(&range1Value)
+	data.SetWarn(nil)
+
+	assert.Equal(t, perfDataBits(0), data.bits&PDatWarn)
+}
+
 func TestSetCrit(t *testing.T) {
 	rangeValue := Range{start: "A", end: "B"}
 	rangeStr := rangeValue.String()
@@ -75,6 +92,12 @@ func TestSetCrit(t *testing.T) {
 	assert.Equal(t, rangeStr, data.crit.String())
 }
 
+func TestSetCritNil(t *testing.T) {
+	data := PerfData{}
+	data.SetCrit(nil)
+	assert.Equal(t, perfDataBits(0), data.bits&PDatCrit)
+}
+
 func TestSetCritTwice(t *testing.T) {
 	range1Value := Range{start: "A", end: "B"}
 	range2Value := Range{start: "C", end: "D"}
@@ -89,6 +112,16 @@ func TestSetCritTwice(t *testing.T) {
 	assert.Equal(t, range2Str, data.crit.String())
 }
 
+func TestSetCritClear(t *testing.T) {
+	range1Value := Range{start: "A", end: "B"}
+
+	data := PerfData{}
+	data.SetCrit(&range1Value)
+	data.SetCrit(nil)
+
+	assert.Equal(t, perfDataBits(0), data.bits&PDatCrit)
+}
+
 func TestSetMin(t *testing.T) {
 	const min = "100"
 
@@ -135,6 +168,35 @@ func TestSetMaxTwice(t *testing.T) {
 	assert.True(t, data.bits&PDatMax != 0)
 }
 
+func TestCheck(t *testing.T) {
+	warnRange := RangeMinMax("0", "10").Inside()
+	critRange := RangeMinMax("1", "9").Inside()
+
+	type Test struct {
+		in  string
+		out status.Status
+	}
+
+	tests := []Test{
+		{in: "moo", out: status.StatusUnknown},
+		{in: "-1", out: status.StatusOK},
+		{in: "0", out: status.StatusWarning},
+		{in: "1", out: status.StatusCritical},
+		{in: "9", out: status.StatusCritical},
+		{in: "10", out: status.StatusWarning},
+		{in: "11", out: status.StatusOK},
+	}
+	for _, test := range tests {
+		pdat := PerfData{
+			value: test.in,
+			bits:  PDatCrit | PDatWarn,
+			warn:  *warnRange,
+			crit:  *critRange,
+		}
+		assert.Equal(t, test.out, pdat.GetStatus())
+	}
+}
+
 func TestString(t *testing.T) {
 	type Test struct {
 		PerfData

pkg/perfdata/range.go

@@ -1,5 +1,10 @@
 package perfdata // import nocternity.net/gomonop/pkg/perfdata
 
+import (
+	"fmt"
+	"strconv"
+)
+
 // Performance data range.
 type Range struct {
 	start  string
@@ -29,6 +34,9 @@ func RangeMinMax(min, max string) *Range {
 		panic("invalid performance data range minimum value")
 	}
 	pdRange := &Range{}
+	if min == "~" {
+		min = ""
+	}
 	pdRange.start = min
 	pdRange.end = max
 	return pdRange
@@ -60,3 +68,26 @@ func (r *Range) String() string {
 
 	return inside + start + ":" + r.end
 }
+
+// Contains checks whether a numeric value is within the range.
+func (r *Range) Contains(value float64) bool {
+	var inStart, inEnd bool
+
+	if r.start != "" {
+		startValue, err := strconv.ParseFloat(r.start, 64)
+		if err != nil {
+			panic(fmt.Sprintf("invalid performance data range start value: %v", err))
+		}
+		inStart = value < startValue
+	}
+
+	if r.end != "" {
+		endValue, err := strconv.ParseFloat(r.end, 64)
+		if err != nil {
+			panic(fmt.Sprintf("invalid performance data range end value: %v", err))
+		}
+		inEnd = value > endValue
+	}
+
+	return (inStart || inEnd) != r.inside
+}

pkg/perfdata/range_test.go

@@ -1,6 +1,7 @@
 package perfdata // import nocternity.net/gomonop/pkg/perfdata
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -40,6 +41,14 @@ func TestRangeMinMax(t *testing.T) {
 	assert.False(t, pdr.inside, "Inside flag should not be set")
 }
 
+func TestRangeMinMaxOpen(t *testing.T) {
+	min, max := "~", "456"
+	pdr := RangeMinMax(min, max)
+	assert.Equal(t, "", pdr.start, "Min value not clear in PerfDataRange")
+	assert.Equal(t, max, pdr.end, "Max value not copied to PerfDataRange")
+	assert.False(t, pdr.inside, "Inside flag should not be set")
+}
+
 func TestRangeInside(t *testing.T) {
 	pdr := &Range{}
 	pdr = pdr.Inside()
@@ -65,3 +74,53 @@ func TestRangeString(t *testing.T) {
 		assert.Equal(t, test.out, result, "Expected '%s', got '%s'", test.out, result)
 	}
 }
+
+func TestRangeContains(t *testing.T) {
+	type Test struct {
+		pdr    Range
+		value  float64
+		result bool
+	}
+
+	tests := []Test{
+		{pdr: Range{start: "0", end: "10"}, value: 0, result: false},
+		{pdr: Range{start: "0", end: "10"}, value: 10, result: false},
+		{pdr: Range{start: "0", end: "10"}, value: -1, result: true},
+		{pdr: Range{start: "0", end: "10"}, value: 11, result: true},
+		{pdr: Range{start: "", end: "10"}, value: -1000, result: false},
+		{pdr: Range{start: "", end: "10"}, value: 10, result: false},
+		{pdr: Range{start: "", end: "10"}, value: 11, result: true},
+		{pdr: Range{start: "10", end: ""}, value: -1000, result: true},
+		{pdr: Range{start: "10", end: ""}, value: 9, result: true},
+		{pdr: Range{start: "10", end: ""}, value: 10, result: false},
+		{pdr: Range{start: "10", end: "20"}, value: 9, result: true},
+		{pdr: Range{start: "10", end: "20"}, value: 10, result: false},
+		{pdr: Range{start: "10", end: "20"}, value: 20, result: false},
+		{pdr: Range{start: "10", end: "20"}, value: 21, result: true},
+	}
+
+	// Test cases with the inside flag set and the opposite result
+	n := len(tests)
+	for i := range n {
+		tests = append(tests, Test{
+			pdr: Range{
+				start:  tests[i].pdr.start,
+				end:    tests[i].pdr.end,
+				inside: !tests[i].pdr.inside,
+			},
+			value:  tests[i].value,
+			result: !tests[i].result,
+		})
+	}
+
+	for _, test := range tests {
+		t.Run(fmt.Sprintf("%v", test), func(t *testing.T) {
+			result := test.pdr.Contains(test.value)
+			assert.Equal(
+				t, test.result, result,
+				"Expected '%v', got '%v' for value '%f' and range '%s'",
+				test.result, result, test.value, test.pdr.String(),
+			)
+		})
+	}
+}

pkg/perfdata/rangeparser.go

@@ -0,0 +1,196 @@
+package perfdata // import nocternity.net/gomonop/pkg/perfdata
+
+import (
+	"fmt"
+	"strings"
+)
+
+// A state of the range parser.
+type rangeParserState int
+
+const (
+	rpsInit        rangeParserState = iota // Initial state
+	rpsExpectStart                         // Expect the start of the range
+	rpsInStart                             // Reading the start of the range
+	rpsExpectColon                         // Expect the colon that separates the start and end
+	rpsExpectEnd                           // Expect the end of the range
+	rpsInEnd                               // Reading the end of the range
+)
+
+// An error emitted by the range parser.
+type rangeParserError struct {
+	input    string
+	position int
+	message  string
+}
+
+// parseError creates a new range parser error.
+func parseError(input string, position int, message string) *rangeParserError {
+	return &rangeParserError{
+		input:    input,
+		position: position,
+		message:  message,
+	}
+}
+
+// Error implements the error interface for the range parser error type.
+func (rpe *rangeParserError) Error() string {
+	return fmt.Sprintf("in `%s' at position %d: %s", rpe.input, rpe.position, rpe.message)
+}
+
+// The full state of the range parser.
+type rangeParser struct {
+	runes        []rune           // The runes being parsed
+	index        int              // The read position
+	state        rangeParserState // The FSM state
+	startOfValue int              // The position of the start of the value being read
+	strBuilder   strings.Builder  // An accumulator for values
+	output       Range            // The output being generated
+}
+
+// initRangeParser initializes the range parser from the specified input.
+func initRangeParser(input string) *rangeParser {
+	return &rangeParser{
+		runes: []rune(input),
+		state: rpsInit,
+	}
+}
+
+// handleInit handles the parser's rpsInit state. It can accept a '@' or skip
+// to rpsExpectStart.
+func (rp *rangeParser) handleInit(current rune) {
+	if current == '@' {
+		rp.output.inside = true
+		rp.index++
+	}
+	rp.state = rpsExpectStart
+}
+
+// handleExpectStart handles the parser's rpsExpectStart state. It may accept
+// a colon, which will move the parser to the rpsExpectEnd state, a '~' which
+// will move it to rpsExpectColon, or any other rune which will cause the
+// accumulation of the "start" value to begin, and the state to be moved to
+// handleInStart.
+func (rp *rangeParser) handleExpectStart(current rune) {
+	switch current {
+	case ':':
+		rp.output.start = "0"
+		rp.state = rpsExpectEnd
+		rp.index++
+	case '~':
+		rp.state = rpsExpectColon
+		rp.index++
+	default:
+		rp.startOfValue = rp.index
+		rp.state = rpsInStart
+	}
+}
+
+// handleInStart handles the parser's rpsInStart state, which corresponds to the
+// reading of the "start" value. If a colon is found, the value will be written
+// to the range structure and validated, before switching to the rpsExpectEnd
+// state. Otherwise it will simply accumulate runes.
+func (rp *rangeParser) handleInStart(current rune) error {
+	switch current {
+	case ':':
+		rp.output.start = rp.strBuilder.String()
+		if !valueCheck.MatchString(rp.output.start) {
+			return parseError(string(rp.runes), rp.startOfValue, "invalid start value")
+		}
+		rp.strBuilder.Reset()
+		rp.state = rpsExpectEnd
+	default:
+		rp.strBuilder.WriteRune(current)
+	}
+
+	rp.index++
+	return nil
+}
+
+// handleExpectColon handles the parser's rpsExpectColon state. A colon MUST be
+// read, otherwise an error will be returned. The parser will then switch to the
+// rpsExpectEnd state.
+func (rp *rangeParser) handleExpectColon(current rune) error {
+	switch current {
+	case ':':
+		rp.state = rpsExpectEnd
+		rp.index++
+	default:
+		return parseError(string(rp.runes), rp.index, "expected ':'")
+	}
+
+	return nil
+}
+
+// handleExpectEnd handles the parser's rpsExpectEnd state, which sets the
+// position of the beginning of the "end" value, and jumps to the rpsInEnd
+// state.
+func (rp *rangeParser) handleExpectEnd() {
+	rp.startOfValue = rp.index
+	rp.state = rpsInEnd
+}
+
+// handleInEnd handles the parser's rpsInEnd state, which accumulates runes for
+// the "end" value.
+func (rp *rangeParser) handleInEnd(current rune) {
+	rp.strBuilder.WriteRune(current)
+	rp.index++
+}
+
+// consumeInput is the parser's state machine.
+func (rp *rangeParser) consumeInput() error {
+	for rp.index < len(rp.runes) {
+		var err error
+		curRune := rp.runes[rp.index]
+
+		switch rp.state {
+		case rpsInit:
+			rp.handleInit(curRune)
+
+		case rpsExpectStart:
+			rp.handleExpectStart(curRune)
+
+		case rpsInStart:
+			err = rp.handleInStart(curRune)
+
+		case rpsExpectColon:
+			err = rp.handleExpectColon(curRune)
+
+		case rpsExpectEnd:
+			rp.handleExpectEnd()
+
+		case rpsInEnd:
+			rp.handleInEnd(curRune)
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Try to parse a string into a performance data range.
+func ParseRange(input string) (*Range, error) {
+	parser := initRangeParser(input)
+	if err := parser.consumeInput(); err != nil {
+		return nil, err
+	}
+
+	if parser.state == rpsInStart {
+		// The range was a single value, so that's the upper bound.
+		parser.output.start = "0"
+		parser.state = rpsInEnd
+	}
+	if parser.state != rpsInEnd {
+		return nil, parseError(input, parser.index, "unexpected end of input")
+	}
+
+	parser.output.end = parser.strBuilder.String()
+	if !valueCheck.MatchString(parser.output.end) {
+		return nil, parseError(input, parser.startOfValue, "invalid end value")
+	}
+
+	return &parser.output, nil
+}

pkg/perfdata/rangeparser_test.go

@@ -0,0 +1,66 @@
+package perfdata // import nocternity.net/gomonop/pkg/perfdata
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRangeParserOk(t *testing.T) {
+	type Test struct {
+		in  string
+		out Range
+	}
+	tests := []Test{
+		{in: ":0", out: Range{start: "0", end: "0"}},
+		{in: "0:0", out: Range{start: "0", end: "0"}},
+		{in: "~:0", out: Range{start: "", end: "0"}},
+		{in: ":123", out: Range{start: "0", end: "123"}},
+		{in: "0:123", out: Range{start: "0", end: "123"}},
+		{in: "~:123", out: Range{start: "", end: "123"}},
+		{in: "1", out: Range{start: "0", end: "1"}},
+		{in: "@:0", out: Range{start: "0", end: "0", inside: true}},
+		{in: "@0:0", out: Range{start: "0", end: "0", inside: true}},
+		{in: "@~:0", out: Range{start: "", end: "0", inside: true}},
+		{in: "@:123", out: Range{start: "0", end: "123", inside: true}},
+		{in: "@0:123", out: Range{start: "0", end: "123", inside: true}},
+		{in: "@~:123", out: Range{start: "", end: "123", inside: true}},
+		{in: "@1", out: Range{start: "0", end: "1", inside: true}},
+	}
+
+	for _, test := range tests {
+		result, err := ParseRange(test.in)
+		require.NoError(t, err, "Expected no error, got '%v'", err)
+		assert.Equal(t, test.out, *result, "Expected '%v', got '%v'", test.out, *result)
+	}
+}
+
+func TestRangeParserError(t *testing.T) {
+	type Test struct {
+		in     string
+		errPos int
+	}
+	tests := []Test{
+		{in: "", errPos: 0},
+		{in: ":", errPos: 1},
+		{in: "x:1", errPos: 0},
+		{in: ":~", errPos: 1},
+		{in: "@", errPos: 1},
+		{in: "@:", errPos: 2},
+		{in: "@x:1", errPos: 1},
+		{in: "@:~", errPos: 2},
+	}
+
+	for _, test := range tests {
+		result, err := ParseRange(test.in)
+		require.Error(t, err, "Expected error, got '%v'", err)
+		assert.Nil(t, result, "Expected nil result, got '%v'", result)
+		assert.True(
+			t, strings.Contains(err.Error(), fmt.Sprintf("at position %d", test.errPos)),
+			"Expected error to contain '%s', got '%s'", fmt.Sprintf("at position %d", test.errPos), err,
+		)
+	}
+}

pkg/results/results.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 
 	"nocternity.net/gomonop/pkg/perfdata"
+	"nocternity.net/gomonop/pkg/status"
 )
 
 // Results represents the monitoring plugin's results, including its name,
@@ -16,7 +17,7 @@ import (
 // data to be encoded in the output.
 type Results struct {
 	name      string
-	status    Status
+	status    status.Status
 	message   string
 	extraText *list.List
 	perfData  map[string]*perfdata.PerfData
@@ -26,7 +27,7 @@ type Results struct {
 func New(name string) *Results {
 	p := new(Results)
 	p.name = name
-	p.status = StatusUnknown
+	p.status = status.StatusUnknown
 	p.message = "no status set"
 	p.perfData = make(map[string]*perfdata.PerfData)
 	return p
@@ -34,7 +35,7 @@ func New(name string) *Results {
 
 // SetState sets the plugin's output code to `status` and its message to
 // the specified `message`.
-func (p *Results) SetState(status Status, message string) {
+func (p *Results) SetState(status status.Status, message string) {
 	p.status = status
 	p.message = message
 }

pkg/results/results_test.go

@@ -5,14 +5,16 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+
 	"nocternity.net/gomonop/pkg/perfdata"
+	"nocternity.net/gomonop/pkg/status"
 )
 
 func TestNew(t *testing.T) {
 	p := New("test")
 
 	assert.Equal(t, p.name, "test")
-	assert.Equal(t, p.status, StatusUnknown)
+	assert.Equal(t, p.status, status.StatusUnknown)
 	assert.Equal(t, p.message, "no status set")
 	assert.Nil(t, p.extraText)
 	assert.NotNil(t, p.perfData)
@@ -21,9 +23,9 @@ func TestNew(t *testing.T) {
 func TestSetState(t *testing.T) {
 	p := Results{}
 
-	p.SetState(StatusWarning, "test")
+	p.SetState(status.StatusWarning, "test")
 
-	assert.Equal(t, p.status, StatusWarning)
+	assert.Equal(t, p.status, status.StatusWarning)
 	assert.Equal(t, p.message, "test")
 }
 
@@ -96,7 +98,7 @@ func TestString(t *testing.T) {
 		{
 			Results{
 				name:     "test",
-				status:   StatusWarning,
+				status:   status.StatusWarning,
 				message:  "test",
 				perfData: make(map[string]*perfdata.PerfData),
 			},
@@ -106,7 +108,7 @@ func TestString(t *testing.T) {
 			func() Results {
 				p := Results{
 					name:      "test",
-					status:    StatusWarning,
+					status:    status.StatusWarning,
 					message:   "test",
 					perfData:  make(map[string]*perfdata.PerfData),
 					extraText: list.New(),
@@ -121,7 +123,7 @@ func TestString(t *testing.T) {
 			func() Results {
 				p := Results{
 					name:     "test",
-					status:   StatusWarning,
+					status:   status.StatusWarning,
 					message:  "test",
 					perfData: make(map[string]*perfdata.PerfData),
 				}
@@ -136,7 +138,7 @@ func TestString(t *testing.T) {
 			func() Results {
 				p := Results{
 					name:      "test",
-					status:    StatusWarning,
+					status:    status.StatusWarning,
 					message:   "test",
 					perfData:  make(map[string]*perfdata.PerfData),
 					extraText: list.New(),
@@ -161,15 +163,15 @@ func TestString(t *testing.T) {
 func TestExitCode(t *testing.T) {
 	p := Results{}
 
-	p.status = StatusOK
-	assert.Equal(t, int(StatusOK), p.ExitCode())
+	p.status = status.StatusOK
+	assert.Equal(t, int(status.StatusOK), p.ExitCode())
 
-	p.status = StatusWarning
-	assert.Equal(t, int(StatusWarning), p.ExitCode())
+	p.status = status.StatusWarning
+	assert.Equal(t, int(status.StatusWarning), p.ExitCode())
 
-	p.status = StatusCritical
-	assert.Equal(t, int(StatusCritical), p.ExitCode())
+	p.status = status.StatusCritical
+	assert.Equal(t, int(status.StatusCritical), p.ExitCode())
 
-	p.status = StatusUnknown
-	assert.Equal(t, int(StatusUnknown), p.ExitCode())
+	p.status = status.StatusUnknown
+	assert.Equal(t, int(status.StatusUnknown), p.ExitCode())
 }

pkg/status/status.go

@@ -1,4 +1,6 @@
-package results // import nocternity.net/gomonop/pkg/results
+// The status package contains the datatype that corresponds to monitoring
+// plugin status values.
+package status // import nocternity.net/gomonop/pkg/status
 
 // Status represents the return status of the monitoring plugin. The
 // corresponding integer value will be used as the program's exit code,

pkg/status/status_test.go

@@ -1,4 +1,4 @@
-package results // import nocternity.net/gomonop/pkg/results
+package status // import nocternity.net/gomonop/pkg/status
 
 import (
 	"testing"