From b40ec5ef37ac4acf61d818514e0b485f1ce10115 Mon Sep 17 00:00:00 2001 From: Enrique Llorente Pastora Date: Mon, 3 Jan 2022 17:49:13 +0100 Subject: [PATCH] deps: Bump nmpolicy to v0.2.0 (#953) To be able to implement a capture entry with replace operator using a capture reference, this change bump nmpolicy to v0.2.0. Signed-off-by: Quique Llorente --- go.mod | 2 +- go.sum | 4 +- .../nmpolicy/internal/capture/capture.go | 11 +- .../internal/capture/capture_entry.go | 4 +- .../nmpolicy/internal/expression/error.go | 33 ++++++ .../nmpolicy/internal/expression/snippet.go | 44 ++++++++ .../nmpolicy/nmpolicy/internal/lexer/lexer.go | 14 ++- .../nmpolicy/internal/parser/errors.go | 8 +- .../nmpolicy/internal/parser/parser.go | 71 +++++------- .../nmpolicy/internal/resolver/resolver.go | 104 +++++++++++------- vendor/modules.txt | 3 +- 11 files changed, 199 insertions(+), 99 deletions(-) create mode 100644 vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/expression/error.go create mode 100644 vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/expression/snippet.go diff --git a/go.mod b/go.mod index 7a466ce7e9..ed9a8769c6 100644 --- a/go.mod +++ b/go.mod @@ -11,7 +11,7 @@ require ( github.com/gorilla/mux v1.7.4 // indirect github.com/kelseyhightower/envconfig v1.4.0 github.com/nmstate/kubernetes-nmstate/api v0.0.0 - github.com/nmstate/nmpolicy v0.1.2 + github.com/nmstate/nmpolicy v0.2.0 github.com/onsi/ginkgo v1.16.4 github.com/onsi/gomega v1.15.0 github.com/opencontainers/image-spec v1.0.2 // indirect diff --git a/go.sum b/go.sum index 745f0bbf1d..d419e8e0b6 100644 --- a/go.sum +++ b/go.sum @@ -1181,8 +1181,8 @@ github.com/nakagami/firebirdsql v0.0.0-20190310045651-3c02a58cfed8/go.mod h1:86w github.com/nbutton23/zxcvbn-go v0.0.0-20180912185939-ae427f1e4c1d/go.mod h1:o96djdrsSGy3AWPyBgZMAGfxZNfgntdJG+11KU4QvbU= github.com/ncw/swift v1.0.47/go.mod h1:23YIA4yWVnGwv2dQlN4bB7egfYX6YLn0Yo/S6zZO/ZM= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= -github.com/nmstate/nmpolicy v0.1.2 h1:3g5zkJK+K7uM74MS7eu9ikotVHsz9enODD0+v70lMaw= -github.com/nmstate/nmpolicy v0.1.2/go.mod h1:uItjRVdUUTrtIUmG/772gMujJwMTHgUxPkUPjnpy6Is= +github.com/nmstate/nmpolicy v0.2.0 h1:Z4JeOpr5au/QcHOLP0FBIRury08vEbUrOXWsWTiyyyk= +github.com/nmstate/nmpolicy v0.2.0/go.mod h1:uItjRVdUUTrtIUmG/772gMujJwMTHgUxPkUPjnpy6Is= github.com/nozzle/throttler v0.0.0-20180817012639-2ea982251481 h1:Up6+btDp321ZG5/zdSLo48H9Iaq0UQGthrhWC6pCxzE= github.com/nozzle/throttler v0.0.0-20180817012639-2ea982251481/go.mod h1:yKZQO8QE2bHlgozqWDiRVqTFlLQSj30K/6SAK8EeYFw= github.com/nwaples/rardecode v1.1.0/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0= diff --git a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/capture/capture.go b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/capture/capture.go index 8023d87fbb..43c2bf51df 100644 --- a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/capture/capture.go +++ b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/capture/capture.go @@ -35,12 +35,13 @@ type Lexer interface { } type Parser interface { - Parse([]lexer.Token) (ast.Node, error) + Parse(string, []lexer.Token) (ast.Node, error) } type Resolver interface { - Resolve(captureASTPool types.CaptureASTPool, state types.NMState, capturedStates types.CapturedStates) (types.CapturedStates, error) - ResolveCaptureEntryPath(captureEntryPathAST ast.Node, capturedStates types.CapturedStates) (interface{}, error) + Resolve(captureExpressions types.CaptureExpressions, captureASTPool types.CaptureASTPool, + state types.NMState, capturedStates types.CapturedStates) (types.CapturedStates, error) + ResolveCaptureEntryPath(expression string, captureEntryPathAST ast.Node, capturedStates types.CapturedStates) (interface{}, error) } func New(leXer Lexer, parser Parser, resolver Resolver) Capture { @@ -69,7 +70,7 @@ func (c Capture) Resolve( return nil, fmt.Errorf("failed to resolve capture expression, err: %v", err) } - astRoot, err := c.parser.Parse(tokens) + astRoot, err := c.parser.Parse(capExpr, tokens) if err != nil { return nil, fmt.Errorf("failed to resolve capture expression, err: %v", err) } @@ -77,7 +78,7 @@ func (c Capture) Resolve( astPool[capID] = astRoot } - resolvedCapturedStates, err := c.resolver.Resolve(astPool, state, capturesState) + resolvedCapturedStates, err := c.resolver.Resolve(capturesExpr, astPool, state, capturesState) if err != nil { return nil, fmt.Errorf("failed to resolve capture expression, err: %v", err) } diff --git a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/capture/capture_entry.go b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/capture/capture_entry.go index aec920fde9..ade26c8cfb 100644 --- a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/capture/capture_entry.go +++ b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/capture/capture_entry.go @@ -53,12 +53,12 @@ func (c CaptureEntry) ResolveCaptureEntryPath( return nil, fmt.Errorf("failed to resolve capture entry path expression: %v", err) } - captureEntryPathAST, err := c.parser.Parse(captureEntryPathTokens) + captureEntryPathAST, err := c.parser.Parse(captureEntryPathExpression, captureEntryPathTokens) if err != nil { return nil, fmt.Errorf("failed to resolve capture entry path expression: %v", err) } - resolvedCaptureEntryPath, err := c.resolver.ResolveCaptureEntryPath(captureEntryPathAST, c.capturedStates) + resolvedCaptureEntryPath, err := c.resolver.ResolveCaptureEntryPath(captureEntryPathExpression, captureEntryPathAST, c.capturedStates) if err != nil { return nil, fmt.Errorf("failed to resolve capture entry path expression: %v", err) } diff --git a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/expression/error.go b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/expression/error.go new file mode 100644 index 0000000000..c63ccebc06 --- /dev/null +++ b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/expression/error.go @@ -0,0 +1,33 @@ +/* + * Copyright 2001 NMPolicy 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 expression + +import ( + "fmt" +) + +// WrapError construct a new error wrapping the error and decorating it +// with the expression and a pointer at the position specified. +func WrapError(err error, expression string, pos int) error { + return fmt.Errorf("%w\n%s", err, snippet(expression, pos)) +} + +// DecorateError construct a new error including the error and decorating it +// with the expression and a pointer at the position specified. +func DecorateError(err error, expression string, pos int) error { + return fmt.Errorf("%s\n%s", err, snippet(expression, pos)) +} diff --git a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/expression/snippet.go b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/expression/snippet.go new file mode 100644 index 0000000000..696650f244 --- /dev/null +++ b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/expression/snippet.go @@ -0,0 +1,44 @@ +/* + * Copyright 2001 NMPolicy 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 expression + +import ( + "fmt" + "strings" +) + +// Snippet returns a string containing src and a pointer at pos. +// Example of str "123456" and pos "4": +// +// | 123456 +// | ...^ +func snippet(expression string, pos int) string { + if expression == "" { + return "" + } + + if pos >= len(expression) { + pos = len(expression) - 1 + } + + marker := strings.Builder{} + for i := 0; i < pos; i++ { + marker.WriteString(".") + } + marker.WriteString("^") + return fmt.Sprintf("| %s\n| %s", expression, marker.String()) +} diff --git a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/lexer/lexer.go b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/lexer/lexer.go index 523f0a816b..3dc87b65e5 100644 --- a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/lexer/lexer.go +++ b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/lexer/lexer.go @@ -20,6 +20,7 @@ import ( "fmt" "strings" + "github.com/nmstate/nmpolicy/nmpolicy/internal/expression" "github.com/nmstate/nmpolicy/nmpolicy/internal/lexer/scanner" ) @@ -27,7 +28,8 @@ import ( type Lexer struct{} type lexer struct { - scn *scanner.Scanner + expression string + scn *scanner.Scanner } // NewLexer construct a Lexer using reader as the input. @@ -35,14 +37,14 @@ func New() Lexer { return Lexer{} } -func newLexer(expression string) *lexer { - return &lexer{scn: scanner.New(strings.NewReader(expression))} +func newLexer(expr string) *lexer { + return &lexer{expression: expr, scn: scanner.New(strings.NewReader(expr))} } // Lex scans the input for the next token. // It returns a Token struct with position, type, and the literal value. -func (Lexer) Lex(expression string) ([]Token, error) { - return newLexer(expression).Lex() +func (Lexer) Lex(expr string) ([]Token, error) { + return newLexer(expr).Lex() } // Lex scans the input for the next token. @@ -53,7 +55,7 @@ func (l *lexer) Lex() ([]Token, error) { for { token, err := l.lex() if err != nil { - return nil, err + return nil, expression.WrapError(err, l.expression, l.scn.Position()) } if token == nil { continue diff --git a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/parser/errors.go b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/parser/errors.go index 19585c61b3..d99e844737 100644 --- a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/parser/errors.go +++ b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/parser/errors.go @@ -58,17 +58,17 @@ func invalidPathError(msg string) *parserError { } } -func invalidEqualityFilterError(msg string) *parserError { +func wrapWithInvalidEqualityFilterError(err error) *parserError { return &parserError{ prefix: "invalid equality filter", - msg: msg, + inner: err, } } -func invalidReplaceError(msg string) *parserError { +func wrapWithInvalidReplaceError(err error) *parserError { return &parserError{ prefix: "invalid replace", - msg: msg, + inner: err, } } diff --git a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/parser/parser.go b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/parser/parser.go index a4e8c73cea..c8473305c8 100644 --- a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/parser/parser.go +++ b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/parser/parser.go @@ -21,6 +21,7 @@ import ( "strconv" "github.com/nmstate/nmpolicy/nmpolicy/internal/ast" + "github.com/nmstate/nmpolicy/nmpolicy/internal/expression" "github.com/nmstate/nmpolicy/nmpolicy/internal/lexer" ) @@ -28,6 +29,7 @@ import ( type Parser struct{} type parser struct { + expression string tokens []lexer.Token currentTokenIdx int lastNode *ast.Node @@ -38,18 +40,18 @@ func New() Parser { return Parser{} } -func newParser(tokens []lexer.Token) *parser { - return &parser{tokens: tokens} +func newParser(expr string, tokens []lexer.Token) *parser { + return &parser{expression: expr, tokens: tokens} } -func (Parser) Parse(tokens []lexer.Token) (ast.Node, error) { - return newParser(tokens).Parse() +func (Parser) Parse(expr string, tokens []lexer.Token) (ast.Node, error) { + return newParser(expr, tokens).Parse() } func (p *parser) Parse() (ast.Node, error) { node, err := p.parse() if err != nil { - return ast.Node{}, err + return ast.Node{}, expression.WrapError(err, p.expression, p.currentToken().Position) } return node, nil } @@ -198,34 +200,8 @@ func (p *parser) parseEqFilter() error { Meta: ast.Meta{Position: p.currentToken().Position}, EqFilter: &ast.TernaryOperator{}, } - if p.lastNode == nil { - return invalidEqualityFilterError("missing left hand argument") - } - if p.lastNode.Path == nil { - return invalidEqualityFilterError("left hand argument is not a path") - } - - p.fillInPipedInOrCurrentState(&operator.EqFilter[0]) - - operator.EqFilter[1] = *p.lastNode - - p.nextToken() - - if p.currentToken().Type == lexer.STRING { - if err := p.parseString(); err != nil { - return err - } - operator.EqFilter[2] = *p.lastNode - } else if p.currentToken().Type == lexer.IDENTITY { - err := p.parsePath() - if err != nil { - return err - } - operator.EqFilter[2] = *p.lastNode - } else if p.currentToken().Type == lexer.EOF { - return invalidEqualityFilterError("missing right hand argument") - } else { - return invalidEqualityFilterError("right hand argument is not a string or identity") + if err := p.fillInTernaryOperator(operator.EqFilter); err != nil { + return wrapWithInvalidEqualityFilterError(err) } p.lastNode = operator return nil @@ -236,29 +212,42 @@ func (p *parser) parseReplace() error { Meta: ast.Meta{Position: p.currentToken().Position}, Replace: &ast.TernaryOperator{}, } + if err := p.fillInTernaryOperator(operator.Replace); err != nil { + return wrapWithInvalidReplaceError(err) + } + p.lastNode = operator + return nil +} + +func (p *parser) fillInTernaryOperator(operator *ast.TernaryOperator) error { if p.lastNode == nil { - return invalidReplaceError("missing left hand argument") + return fmt.Errorf("missing left hand argument") } if p.lastNode.Path == nil { - return invalidReplaceError("left hand argument is not a path") + return fmt.Errorf("left hand argument is not a path") } - p.fillInPipedInOrCurrentState(&operator.Replace[0]) + p.fillInPipedInOrCurrentState(&operator[0]) - operator.Replace[1] = *p.lastNode + operator[1] = *p.lastNode p.nextToken() if p.currentToken().Type == lexer.STRING { if err := p.parseString(); err != nil { return err } - operator.Replace[2] = *p.lastNode + operator[2] = *p.lastNode + } else if p.currentToken().Type == lexer.IDENTITY { + err := p.parsePath() + if err != nil { + return err + } + operator[2] = *p.lastNode } else if p.currentToken().Type == lexer.EOF { - return invalidReplaceError("missing right hand argument") + return fmt.Errorf("missing right hand argument") } else { - return invalidReplaceError("right hand argument is not a string") + return fmt.Errorf("right hand argument is not a string or identity") } - p.lastNode = operator return nil } diff --git a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/resolver/resolver.go b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/resolver/resolver.go index 7082a90c37..766d72d57b 100644 --- a/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/resolver/resolver.go +++ b/vendor/github.com/nmstate/nmpolicy/nmpolicy/internal/resolver/resolver.go @@ -20,15 +20,19 @@ import ( "fmt" "github.com/nmstate/nmpolicy/nmpolicy/internal/ast" + "github.com/nmstate/nmpolicy/nmpolicy/internal/expression" "github.com/nmstate/nmpolicy/nmpolicy/internal/types" ) type Resolver struct{} type resolver struct { - currentState types.NMState - capturedStates types.CapturedStates - captureASTPool types.CaptureASTPool + currentState types.NMState + capturedStates types.CapturedStates + captureExpressions types.CaptureExpressions + captureASTPool types.CaptureASTPool + currentNode *ast.Node + currentExpression *string } func New() Resolver { @@ -43,23 +47,29 @@ func newResolver() *resolver { } } -func (Resolver) Resolve(captureASTPool types.CaptureASTPool, +func (Resolver) Resolve(captureExpressions types.CaptureExpressions, + captureASTPool types.CaptureASTPool, currentState types.NMState, capturedStates types.CapturedStates) (types.CapturedStates, error) { r := newResolver() r.currentState = currentState r.captureASTPool = captureASTPool + r.captureExpressions = captureExpressions if capturedStates != nil { r.capturedStates = capturedStates } - return r.resolve() + capturedStates, err := r.resolve() + return capturedStates, r.wrapErrorWithCurrentExpression(err) } -func (Resolver) ResolveCaptureEntryPath(captureEntryPathAST ast.Node, +func (Resolver) ResolveCaptureEntryPath(expr string, captureEntryPathAST ast.Node, capturedStates types.CapturedStates) (interface{}, error) { r := newResolver() + r.currentExpression = &expr r.capturedStates = capturedStates - return r.resolveCaptureEntryPath(captureEntryPathAST) + r.currentNode = &captureEntryPathAST + resolvedCaptureEntryPath, err := r.resolveCaptureEntryPath() + return resolvedCaptureEntryPath, r.wrapErrorWithCurrentExpression(err) } func (r *resolver) resolve() (types.CapturedStates, error) { @@ -72,6 +82,10 @@ func (r *resolver) resolve() (types.CapturedStates, error) { } func (r *resolver) resolveCaptureEntryName(captureEntryName string) (types.NMState, error) { + expr, ok := r.captureExpressions[captureEntryName] + if ok { + r.currentExpression = &expr + } capturedStateEntry, ok := r.capturedStates[captureEntryName] if ok { return capturedStateEntry.State, nil @@ -80,9 +94,10 @@ func (r *resolver) resolveCaptureEntryName(captureEntryName string) (types.NMSta if !ok { return nil, fmt.Errorf("capture entry '%s' not found", captureEntryName) } + r.currentNode = &captureASTEntry var err error capturedStateEntry = types.CapturedState{} - capturedStateEntry.State, err = r.resolveCaptureASTEntry(captureASTEntry) + capturedStateEntry.State, err = r.resolveCaptureASTEntry() if err != nil { return nil, err } @@ -90,16 +105,17 @@ func (r *resolver) resolveCaptureEntryName(captureEntryName string) (types.NMSta return capturedStateEntry.State, nil } -func (r resolver) resolveCaptureASTEntry(captureASTEntry ast.Node) (types.NMState, error) { - if captureASTEntry.EqFilter != nil { - return r.resolveEqFilter(captureASTEntry.EqFilter) - } else if captureASTEntry.Replace != nil { - return r.resolveReplace(captureASTEntry.Replace) +func (r resolver) resolveCaptureASTEntry() (types.NMState, error) { + if r.currentNode.EqFilter != nil { + return r.resolveEqFilter() + } else if r.currentNode.Replace != nil { + return r.resolveReplace() } - return nil, fmt.Errorf("root node has unsupported operation : %+v", captureASTEntry) + return nil, fmt.Errorf("root node has unsupported operation : %+v", *r.currentNode) } -func (r resolver) resolveEqFilter(operator *ast.TernaryOperator) (types.NMState, error) { +func (r resolver) resolveEqFilter() (types.NMState, error) { + operator := r.currentNode.EqFilter filteredState, err := r.resolveTernaryOperator(operator, filter) if err != nil { return nil, wrapWithEqFilterError(err) @@ -107,7 +123,8 @@ func (r resolver) resolveEqFilter(operator *ast.TernaryOperator) (types.NMState, return filteredState, nil } -func (r resolver) resolveReplace(operator *ast.TernaryOperator) (types.NMState, error) { +func (r resolver) resolveReplace() (types.NMState, error) { + operator := r.currentNode.Replace replacedState, err := r.resolveTernaryOperator(operator, replace) if err != nil { return nil, wrapWithResolveError(err) @@ -117,16 +134,19 @@ func (r resolver) resolveReplace(operator *ast.TernaryOperator) (types.NMState, func (r resolver) resolveTernaryOperator(operator *ast.TernaryOperator, resolverFunc func(map[string]interface{}, ast.VariadicOperator, ast.Node) (map[string]interface{}, error)) (types.NMState, error) { - inputSource, err := r.resolveInputSource((*operator)[0]) + r.currentNode = &(*operator)[0] + inputSource, err := r.resolveInputSource() if err != nil { return nil, err } - path, err := r.resolvePath((*operator)[1]) + r.currentNode = &(*operator)[1] + path, err := r.resolvePath() if err != nil { return nil, err } - value, err := r.resolveStringOrCaptureEntryPath((*operator)[2]) + r.currentNode = &(*operator)[2] + value, err := r.resolveStringOrCaptureEntryPath() if err != nil { return nil, err } @@ -137,11 +157,11 @@ func (r resolver) resolveTernaryOperator(operator *ast.TernaryOperator, return resolvedState, nil } -func (r resolver) resolveInputSource(inputSourceNode ast.Node) (types.NMState, error) { - if ast.CurrentStateIdentity().DeepEqual(inputSourceNode.Terminal) { +func (r resolver) resolveInputSource() (types.NMState, error) { + if ast.CurrentStateIdentity().DeepEqual(r.currentNode.Terminal) { return r.currentState, nil - } else if inputSourceNode.Path != nil { - resolvedPath, err := r.resolvePath(inputSourceNode) + } else if r.currentNode.Path != nil { + resolvedPath, err := r.resolvePath() if err != nil { return nil, err } @@ -155,14 +175,14 @@ func (r resolver) resolveInputSource(inputSourceNode ast.Node) (types.NMState, e return capturedState, nil } - return nil, fmt.Errorf("invalid input source %v, only current state or capture reference is supported", inputSourceNode) + return nil, fmt.Errorf("invalid input source %v, only current state or capture reference is supported", *r.currentNode) } -func (r resolver) resolveStringOrCaptureEntryPath(filteredValueNode ast.Node) (*ast.Node, error) { - if filteredValueNode.String != nil { - return &filteredValueNode, nil - } else if filteredValueNode.Path != nil { - resolvedCaptureEntryPath, err := r.resolveCaptureEntryPath(filteredValueNode) +func (r resolver) resolveStringOrCaptureEntryPath() (*ast.Node, error) { + if r.currentNode.String != nil { + return r.currentNode, nil + } else if r.currentNode.Path != nil { + resolvedCaptureEntryPath, err := r.resolveCaptureEntryPath() if err != nil { return nil, err } @@ -178,8 +198,8 @@ func (r resolver) resolveStringOrCaptureEntryPath(filteredValueNode ast.Node) (* } } -func (r resolver) resolveCaptureEntryPath(pathNode ast.Node) (interface{}, error) { - resolvedPath, err := r.resolvePath(pathNode) +func (r resolver) resolveCaptureEntryPath() (interface{}, error) { + resolvedPath, err := r.resolvePath() if err != nil { return nil, err } @@ -193,16 +213,16 @@ func (r resolver) resolveCaptureEntryPath(pathNode ast.Node) (interface{}, error return resolvedPath.walkState(capturedStateEntry) } -func (r resolver) resolvePath(pathNode ast.Node) (*captureEntryNameAndSteps, error) { - if pathNode.Path == nil { - return nil, fmt.Errorf("invalid path type %T", pathNode) - } else if len(*pathNode.Path) == 0 { +func (r resolver) resolvePath() (*captureEntryNameAndSteps, error) { + if r.currentNode.Path == nil { + return nil, fmt.Errorf("invalid path type %T", *r.currentNode) + } else if len(*r.currentNode.Path) == 0 { return nil, fmt.Errorf("empty path length") - } else if (*pathNode.Path)[0].Identity == nil { + } else if (*r.currentNode.Path)[0].Identity == nil { return nil, fmt.Errorf("path first step has to be an identity") } resolvedPath := captureEntryNameAndSteps{ - steps: *pathNode.Path, + steps: *r.currentNode.Path, } if *resolvedPath.steps[0].Identity == "capture" { const captureRefSize = 2 @@ -216,3 +236,13 @@ func (r resolver) resolvePath(pathNode ast.Node) (*captureEntryNameAndSteps, err } return &resolvedPath, nil } + +func (r resolver) wrapErrorWithCurrentExpression(err error) error { + if err == nil { + return nil + } + if r.currentNode == nil || r.currentExpression == nil { + return err + } + return expression.WrapError(err, *r.currentExpression, r.currentNode.Meta.Position) +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 747f84209e..1340a19019 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -463,13 +463,14 @@ github.com/nmstate/kubernetes-nmstate/api/shared github.com/nmstate/kubernetes-nmstate/api/v1 github.com/nmstate/kubernetes-nmstate/api/v1alpha1 github.com/nmstate/kubernetes-nmstate/api/v1beta1 -# github.com/nmstate/nmpolicy v0.1.2 +# github.com/nmstate/nmpolicy v0.2.0 ## explicit github.com/nmstate/nmpolicy/nmpolicy github.com/nmstate/nmpolicy/nmpolicy/internal github.com/nmstate/nmpolicy/nmpolicy/internal/ast github.com/nmstate/nmpolicy/nmpolicy/internal/capture github.com/nmstate/nmpolicy/nmpolicy/internal/expander +github.com/nmstate/nmpolicy/nmpolicy/internal/expression github.com/nmstate/nmpolicy/nmpolicy/internal/lexer github.com/nmstate/nmpolicy/nmpolicy/internal/lexer/scanner github.com/nmstate/nmpolicy/nmpolicy/internal/parser