| Server IP : 2.57.91.89 / Your IP : 216.73.216.86 Web Server : LiteSpeed System : Linux id-dci-web1986.main-hosting.eu 5.14.0-611.26.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Jan 29 05:24:47 EST 2026 x86_64 User : u686484674 ( 686484674) PHP Version : 8.0.30 Disable Function : system, exec, shell_exec, passthru, mysql_list_dbs, ini_alter, dl, symlink, link, chgrp, leak, popen, apache_child_terminate, virtual, mb_send_mail MySQL : OFF | cURL : ON | WGET : ON | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /proc/./self/root/opt/go/pkg/mod/github.com/prometheus/alertmanager@v0.28.1/matcher/parse/ |
Upload File : |
// Copyright 2023 The Prometheus Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package parse
import (
"errors"
"fmt"
"os"
"runtime/debug"
"github.com/prometheus/alertmanager/pkg/labels"
)
var (
errEOF = errors.New("end of input")
errExpectedEOF = errors.New("expected end of input")
errNoOpenBrace = errors.New("expected opening brace")
errNoCloseBrace = errors.New("expected close brace")
errNoLabelName = errors.New("expected label name")
errNoLabelValue = errors.New("expected label value")
errNoOperator = errors.New("expected an operator such as '=', '!=', '=~' or '!~'")
errExpectedComma = errors.New("expected a comma")
errExpectedCommaOrCloseBrace = errors.New("expected a comma or close brace")
errExpectedMatcherOrCloseBrace = errors.New("expected a matcher or close brace after comma")
)
// Matchers parses one or more matchers in the input string. It returns an error
// if the input is invalid.
func Matchers(input string) (matchers labels.Matchers, err error) {
defer func() {
if r := recover(); r != nil {
fmt.Fprintf(os.Stderr, "parser panic: %s, %s", r, debug.Stack())
err = errors.New("parser panic: this should never happen, check stderr for the stack trace")
}
}()
p := parser{lexer: lexer{input: input}}
return p.parse()
}
// Matcher parses the matcher in the input string. It returns an error
// if the input is invalid or contains two or more matchers.
func Matcher(input string) (*labels.Matcher, error) {
m, err := Matchers(input)
if err != nil {
return nil, err
}
switch len(m) {
case 1:
return m[0], nil
case 0:
return nil, fmt.Errorf("no matchers")
default:
return nil, fmt.Errorf("expected 1 matcher, found %d", len(m))
}
}
// parseFunc is state in the finite state automata.
type parseFunc func(l *lexer) (parseFunc, error)
// parser reads the sequence of tokens from the lexer and returns either a
// series of matchers or an error. It works as a finite state automata, where
// each state in the automata is a parseFunc. The finite state automata can move
// from one state to another by returning the next parseFunc. It terminates when
// a parseFunc returns nil as the next parseFunc, if the lexer attempts to scan
// input that does not match the expected grammar, or if the tokens returned from
// the lexer cannot be parsed into a complete series of matchers.
type parser struct {
matchers labels.Matchers
// Tracks if the input starts with an open brace and if we should expect to
// parse a close brace at the end of the input.
hasOpenBrace bool
lexer lexer
}
func (p *parser) parse() (labels.Matchers, error) {
var (
err error
fn = p.parseOpenBrace
l = &p.lexer
)
for {
if fn, err = fn(l); err != nil {
return nil, err
} else if fn == nil {
break
}
}
return p.matchers, nil
}
func (p *parser) parseOpenBrace(l *lexer) (parseFunc, error) {
var (
hasCloseBrace bool
err error
)
// Can start with an optional open brace.
p.hasOpenBrace, err = p.accept(l, tokenOpenBrace)
if err != nil {
if errors.Is(err, errEOF) {
return p.parseEOF, nil
}
return nil, err
}
// If the next token is a close brace there are no matchers in the input.
hasCloseBrace, err = p.acceptPeek(l, tokenCloseBrace)
if err != nil {
// If there is no more input after the open brace then parse the close brace
// so the error message contains ErrNoCloseBrace.
if errors.Is(err, errEOF) {
return p.parseCloseBrace, nil
}
return nil, err
}
if hasCloseBrace {
return p.parseCloseBrace, nil
}
return p.parseMatcher, nil
}
func (p *parser) parseCloseBrace(l *lexer) (parseFunc, error) {
if p.hasOpenBrace {
// If there was an open brace there must be a matching close brace.
if _, err := p.expect(l, tokenCloseBrace); err != nil {
return nil, fmt.Errorf("0:%d: %w: %w", l.position().columnEnd, err, errNoCloseBrace)
}
} else {
// If there was no open brace there must not be a close brace either.
if _, err := p.expect(l, tokenCloseBrace); err == nil {
return nil, fmt.Errorf("0:%d: }: %w", l.position().columnEnd, errNoOpenBrace)
}
}
return p.parseEOF, nil
}
func (p *parser) parseMatcher(l *lexer) (parseFunc, error) {
var (
err error
t token
matchName, matchValue string
matchTy labels.MatchType
)
// The first token should be the label name.
if t, err = p.expect(l, tokenQuoted, tokenUnquoted); err != nil {
return nil, fmt.Errorf("%w: %w", err, errNoLabelName)
}
matchName, err = t.unquote()
if err != nil {
return nil, fmt.Errorf("%d:%d: %s: invalid input", t.columnStart, t.columnEnd, t.value)
}
// The next token should be the operator.
if t, err = p.expect(l, tokenEquals, tokenNotEquals, tokenMatches, tokenNotMatches); err != nil {
return nil, fmt.Errorf("%w: %w", err, errNoOperator)
}
switch t.kind {
case tokenEquals:
matchTy = labels.MatchEqual
case tokenNotEquals:
matchTy = labels.MatchNotEqual
case tokenMatches:
matchTy = labels.MatchRegexp
case tokenNotMatches:
matchTy = labels.MatchNotRegexp
default:
panic(fmt.Sprintf("bad operator %s", t))
}
// The next token should be the match value. Like the match name, this too
// can be either double-quoted UTF-8 or unquoted UTF-8 without reserved characters.
if t, err = p.expect(l, tokenUnquoted, tokenQuoted); err != nil {
return nil, fmt.Errorf("%w: %w", err, errNoLabelValue)
}
matchValue, err = t.unquote()
if err != nil {
return nil, fmt.Errorf("%d:%d: %s: invalid input", t.columnStart, t.columnEnd, t.value)
}
m, err := labels.NewMatcher(matchTy, matchName, matchValue)
if err != nil {
return nil, fmt.Errorf("failed to create matcher: %w", err)
}
p.matchers = append(p.matchers, m)
return p.parseEndOfMatcher, nil
}
func (p *parser) parseEndOfMatcher(l *lexer) (parseFunc, error) {
t, err := p.expectPeek(l, tokenComma, tokenCloseBrace)
if err != nil {
if errors.Is(err, errEOF) {
// If this is the end of input we still need to check if the optional
// open brace has a matching close brace.
return p.parseCloseBrace, nil
}
return nil, fmt.Errorf("%w: %w", err, errExpectedCommaOrCloseBrace)
}
switch t.kind {
case tokenComma:
return p.parseComma, nil
case tokenCloseBrace:
return p.parseCloseBrace, nil
default:
panic(fmt.Sprintf("bad token %s", t))
}
}
func (p *parser) parseComma(l *lexer) (parseFunc, error) {
if _, err := p.expect(l, tokenComma); err != nil {
return nil, fmt.Errorf("%w: %w", err, errExpectedComma)
}
// The token after the comma can be another matcher, a close brace or end of input.
t, err := p.expectPeek(l, tokenCloseBrace, tokenUnquoted, tokenQuoted)
if err != nil {
if errors.Is(err, errEOF) {
// If this is the end of input we still need to check if the optional
// open brace has a matching close brace.
return p.parseCloseBrace, nil
}
return nil, fmt.Errorf("%w: %w", err, errExpectedMatcherOrCloseBrace)
}
if t.kind == tokenCloseBrace {
return p.parseCloseBrace, nil
}
return p.parseMatcher, nil
}
func (p *parser) parseEOF(l *lexer) (parseFunc, error) {
t, err := l.scan()
if err != nil {
return nil, fmt.Errorf("%w: %w", err, errExpectedEOF)
}
if !t.isEOF() {
return nil, fmt.Errorf("%d:%d: %s: %w", t.columnStart, t.columnEnd, t.value, errExpectedEOF)
}
return nil, nil
}
// nolint:godot
// accept returns true if the next token is one of the specified kinds,
// otherwise false. If the token is accepted it is consumed. tokenEOF is
// not an accepted kind and instead accept returns ErrEOF if there is no
// more input.
func (p *parser) accept(l *lexer, kinds ...tokenKind) (ok bool, err error) {
ok, err = p.acceptPeek(l, kinds...)
if ok {
if _, err = l.scan(); err != nil {
panic("failed to scan peeked token")
}
}
return ok, err
}
// nolint:godot
// acceptPeek returns true if the next token is one of the specified kinds,
// otherwise false. However, unlike accept, acceptPeek does not consume accepted
// tokens. tokenEOF is not an accepted kind and instead accept returns ErrEOF
// if there is no more input.
func (p *parser) acceptPeek(l *lexer, kinds ...tokenKind) (bool, error) {
t, err := l.peek()
if err != nil {
return false, err
}
if t.isEOF() {
return false, errEOF
}
return t.isOneOf(kinds...), nil
}
// nolint:godot
// expect returns the next token if it is one of the specified kinds, otherwise
// it returns an error. If the token is expected it is consumed. tokenEOF is not
// an accepted kind and instead expect returns ErrEOF if there is no more input.
func (p *parser) expect(l *lexer, kind ...tokenKind) (token, error) {
t, err := p.expectPeek(l, kind...)
if err != nil {
return t, err
}
if _, err = l.scan(); err != nil {
panic("failed to scan peeked token")
}
return t, nil
}
// nolint:godot
// expect returns the next token if it is one of the specified kinds, otherwise
// it returns an error. However, unlike expect, expectPeek does not consume tokens.
// tokenEOF is not an accepted kind and instead expect returns ErrEOF if there is no
// more input.
func (p *parser) expectPeek(l *lexer, kind ...tokenKind) (token, error) {
t, err := l.peek()
if err != nil {
return t, err
}
if t.isEOF() {
return t, errEOF
}
if !t.isOneOf(kind...) {
return t, fmt.Errorf("%d:%d: unexpected %s", t.columnStart, t.columnEnd, t.value)
}
return t, nil
}