Implement DSL based on goyacc

Author: jotak

.gitignore

@@ -2,3 +2,4 @@
 /confgenerator
 /bin/
 cover.out
+y.output

go.mod

@@ -118,7 +118,7 @@ require (
 	github.com/pion/transport/v2 v2.2.10 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/prometheus/procfs v0.15.1 // indirect
-	github.com/prometheus/prometheus v1.8.2-0.20201028100903-3245b3267b24 // indirect
+	github.com/prometheus/prometheus v1.8.2-0.20201028100903-3245b3267b24
 	github.com/rs/xid v1.6.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/safchain/ethtool v0.3.1-0.20231027162144-83e5e0097c91 // indirect

pkg/dsl/dsl_test.go

@@ -1,45 +1,21 @@
 package dsl
 
 import (
-	"github.com/netobserv/flowlogs-pipeline/pkg/api"
 	"github.com/netobserv/flowlogs-pipeline/pkg/config"
 	"github.com/netobserv/flowlogs-pipeline/pkg/utils/filters"
 )
 
 type Node struct {
-	op        string
-	leaf      *api.KeepEntryRule
+	logicalOp string
 	children  []*Node
 	predicate filters.Predicate
 }
 
-func Parse(s string) Node {
-	return Node{}
-}
-
-func (n *Node) Preprocess() error {
-	if n.leaf != nil {
-		p, err := filters.FromKeepEntry(n.leaf)
-		if err != nil {
-			return err
-		}
-		n.predicate = p
-		return nil
-	}
-	for _, child := range n.children {
-		err := child.Preprocess()
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 func (n *Node) Apply(flow config.GenericMap) bool {
-	if n.leaf != nil {
+	if n.predicate != nil {
 		return n.predicate(flow)
 	}
-	if n.op == "and" {
+	if n.logicalOp == OperatorAnd {
 		for _, child := range n.children {
 			if !child.Apply(flow) {
 				return false

pkg/dsl/dsl.go pkg/dsl/eval.gopkg/dsl/dsl.go renamed to pkg/dsl/eval.go

@@ -0,0 +1,109 @@
+package dsl
+
+import (
+	"testing"
+
+	"github.com/netobserv/flowlogs-pipeline/pkg/config"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAndOrEqual(t *testing.T) {
+	yyErrorVerbose = true
+	n, err := Parse(`(srcnamespace="netobserv" OR (srcnamespace="ingress" AND dstnamespace="netobserv")) AND srckind!="service"`)
+	assert.NoError(t, err)
+	assert.NotNil(t, n)
+
+	result := n.Apply(config.GenericMap{
+		"srcnamespace": "plop",
+		"dstnamespace": "netobserv",
+		"srckind":      "pod",
+	})
+	assert.False(t, result)
+
+	result = n.Apply(config.GenericMap{
+		"srcnamespace": "ingress",
+		"dstnamespace": "netobserv",
+		"srckind":      "pod",
+	})
+	assert.True(t, result)
+
+	result = n.Apply(config.GenericMap{
+		"srcnamespace": "ingress",
+		"dstnamespace": "netobserv",
+		"srckind":      "service",
+	})
+	assert.False(t, result)
+}
+
+func TestRegexp(t *testing.T) {
+	yyErrorVerbose = true
+	n, err := Parse(`srcnamespace=~"openshift.*" and dstnamespace!~"openshift.*"`)
+	assert.NoError(t, err)
+	assert.NotNil(t, n)
+
+	result := n.Apply(config.GenericMap{
+		"srcnamespace": "openshift-ingress",
+		"dstnamespace": "my-app",
+		"srckind":      "pod",
+	})
+	assert.True(t, result, "Should accept flows from OpenShift to App")
+
+	result = n.Apply(config.GenericMap{
+		"srcnamespace": "my-app",
+		"dstnamespace": "openshift-ingress",
+		"srckind":      "pod",
+	})
+	assert.False(t, result, "Should reject flows from App to OpenShift")
+
+	result = n.Apply(config.GenericMap{
+		"srcnamespace": "my-app",
+		"dstnamespace": "my-app",
+		"srckind":      "pod",
+	})
+	assert.False(t, result, "Should reject flows from App to App")
+
+	result = n.Apply(config.GenericMap{
+		"srcnamespace": "openshift-operators",
+		"dstnamespace": "openshift-ingress",
+		"srckind":      "pod",
+	})
+	assert.False(t, result, "Should reject flows from OpenShift to OpenShift")
+}
+
+func TestWith(t *testing.T) {
+	yyErrorVerbose = true
+	n, err := Parse(`srcnamespace="foo" and with(rtt)`)
+	assert.NoError(t, err)
+	assert.NotNil(t, n)
+
+	result := n.Apply(config.GenericMap{
+		"srcnamespace": "foo",
+		"rtt":          4.5,
+	})
+	assert.True(t, result, "Should accept flows from foo with rtt")
+
+	result = n.Apply(config.GenericMap{
+		"srcnamespace": "foo",
+	})
+	assert.False(t, result, "Should reject flows from foo without rtt")
+}
+
+func TestWithout(t *testing.T) {
+	yyErrorVerbose = true
+	n, err := Parse(`srcnamespace="foo" or without(srcnamespace)`)
+	assert.NoError(t, err)
+	assert.NotNil(t, n)
+
+	result := n.Apply(config.GenericMap{
+		"srcnamespace": "foo",
+	})
+	assert.True(t, result, "Should accept flows from foo")
+
+	result = n.Apply(config.GenericMap{})
+	assert.True(t, result, "Should accept flows without srcnamespace")
+
+	result = n.Apply(config.GenericMap{
+		"srcnamespace": "bar",
+	})
+	assert.False(t, result, "Should reject flows from bar")
+}

pkg/dsl/eval_test.go

@@ -0,0 +1,34 @@
+%{
+package dsl
+%}
+
+%union{
+	expr  Expression
+	value string
+}
+
+%type <expr> root
+%type <expr> expr
+
+%token <value> VAR STRING NUMBER AND OR EQ NEQ REG NREG OPEN_PARENTHESIS CLOSE_PARENTHESIS WITH WITHOUT
+%left AND
+%left OR
+%%
+
+root:
+        expr {
+		$$ = $1
+		yylex.(*Lexer).result = $$
+	}
+
+expr:
+	OPEN_PARENTHESIS expr CLOSE_PARENTHESIS { $$ = ParenthesisExpr{inner: $2} }
+	| expr AND expr { $$ = LogicalExpr{left: $1, operator: "and", right: $3} }
+	| expr OR expr { $$ = LogicalExpr{left: $1, operator: "or", right: $3} }
+	| WITH OPEN_PARENTHESIS VAR CLOSE_PARENTHESIS { $$ = WithExpr{key: $3} }
+	| WITHOUT OPEN_PARENTHESIS VAR CLOSE_PARENTHESIS { $$ = WithoutExpr{key: $3} }
+	| VAR EQ STRING { $$ = ComparisonExpr{key: $1, operator: "=", value: $3} }
+	| VAR NEQ STRING { $$ = ComparisonExpr{key: $1, operator: "!=", value: $3} }
+	| VAR REG STRING { $$ = ComparisonExpr{key: $1, operator: "=~", value: $3} }
+	| VAR NREG STRING { $$ = ComparisonExpr{key: $1, operator: "!~", value: $3} }
+%%