Implement DSL based on goyacc

Author: jotak

.gitignore

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

go.mod

@@ -24,6 +24,7 @@ require (
 	github.com/prometheus/client_golang v1.22.0
 	github.com/prometheus/client_model v0.6.2
 	github.com/prometheus/common v0.63.0
+	github.com/prometheus/prometheus v1.8.2-0.20201028100903-3245b3267b24
 	github.com/segmentio/kafka-go v0.4.47
 	github.com/sirupsen/logrus v1.9.3
 	github.com/spf13/cobra v1.9.1
@@ -114,7 +115,6 @@ 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.16.0 // indirect
-	github.com/prometheus/prometheus v1.8.2-0.20201028100903-3245b3267b24 // indirect
 	github.com/rs/xid v1.6.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/safchain/ethtool v0.5.10 // indirect

pkg/dsl/dsl.go

@@ -0,0 +1,33 @@
+package dsl
+
+import (
+	"github.com/netobserv/flowlogs-pipeline/pkg/config"
+	"github.com/netobserv/flowlogs-pipeline/pkg/utils/filters"
+)
+
+type tree struct {
+	logicalOp string
+	children  []*tree
+	predicate filters.Predicate
+}
+
+func (t *tree) apply(flow config.GenericMap) bool {
+	if t.predicate != nil {
+		return t.predicate(flow)
+	}
+	if t.logicalOp == operatorAnd {
+		for _, child := range t.children {
+			if !child.apply(flow) {
+				return false
+			}
+		}
+		return true
+	}
+	// t.logicalOp == operatorOr
+	for _, child := range t.children {
+		if child.apply(flow) {
+			return true
+		}
+	}
+	return false
+}

pkg/dsl/dsl_test.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
+	predicate, err := Parse(`(srcnamespace="netobserv" OR (srcnamespace="ingress" AND dstnamespace="netobserv")) AND srckind!="service"`)
+	assert.NoError(t, err)
+	assert.NotNil(t, predicate)
+
+	result := predicate(config.GenericMap{
+		"srcnamespace": "plop",
+		"dstnamespace": "netobserv",
+		"srckind":      "pod",
+	})
+	assert.False(t, result)
+
+	result = predicate(config.GenericMap{
+		"srcnamespace": "ingress",
+		"dstnamespace": "netobserv",
+		"srckind":      "pod",
+	})
+	assert.True(t, result)
+
+	result = predicate(config.GenericMap{
+		"srcnamespace": "ingress",
+		"dstnamespace": "netobserv",
+		"srckind":      "service",
+	})
+	assert.False(t, result)
+}
+
+func TestRegexp(t *testing.T) {
+	yyErrorVerbose = true
+	predicate, err := Parse(`srcnamespace=~"openshift.*" and dstnamespace!~"openshift.*"`)
+	assert.NoError(t, err)
+	assert.NotNil(t, predicate)
+
+	result := predicate(config.GenericMap{
+		"srcnamespace": "openshift-ingress",
+		"dstnamespace": "my-app",
+		"srckind":      "pod",
+	})
+	assert.True(t, result, "Should accept flows from OpenShift to App")
+
+	result = predicate(config.GenericMap{
+		"srcnamespace": "my-app",
+		"dstnamespace": "openshift-ingress",
+		"srckind":      "pod",
+	})
+	assert.False(t, result, "Should reject flows from App to OpenShift")
+
+	result = predicate(config.GenericMap{
+		"srcnamespace": "my-app",
+		"dstnamespace": "my-app",
+		"srckind":      "pod",
+	})
+	assert.False(t, result, "Should reject flows from App to App")
+
+	result = predicate(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
+	predicate, err := Parse(`srcnamespace="foo" and with(rtt)`)
+	assert.NoError(t, err)
+	assert.NotNil(t, predicate)
+
+	result := predicate(config.GenericMap{
+		"srcnamespace": "foo",
+		"rtt":          4.5,
+	})
+	assert.True(t, result, "Should accept flows from foo with rtt")
+
+	result = predicate(config.GenericMap{
+		"srcnamespace": "foo",
+	})
+	assert.False(t, result, "Should reject flows from foo without rtt")
+}
+
+func TestWithout(t *testing.T) {
+	yyErrorVerbose = true
+	predicate, err := Parse(`srcnamespace="foo" or without(srcnamespace)`)
+	assert.NoError(t, err)
+	assert.NotNil(t, predicate)
+
+	result := predicate(config.GenericMap{
+		"srcnamespace": "foo",
+	})
+	assert.True(t, result, "Should accept flows from foo")
+
+	result = predicate(config.GenericMap{})
+	assert.True(t, result, "Should accept flows without srcnamespace")
+
+	result = predicate(config.GenericMap{
+		"srcnamespace": "bar",
+	})
+	assert.False(t, result, "Should reject flows from bar")
+}

pkg/dsl/eval.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: operatorAnd, right: $3} }
+	| expr OR expr { $$ = LogicalExpr{left: $1, operator: operatorOr, right: $3} }
+	| WITH OPEN_PARENTHESIS VAR CLOSE_PARENTHESIS { $$ = WithExpr{key: $3} }
+	| WITHOUT OPEN_PARENTHESIS VAR CLOSE_PARENTHESIS { $$ = WithoutExpr{key: $3} }
+	| VAR EQ STRING { $$ = EqExpr{key: $1, value: $3} }
+	| VAR NEQ STRING { $$ = NEqExpr{key: $1, value: $3} }
+	| VAR REG STRING { $$ = RegExpr{key: $1, value: $3} }
+	| VAR NREG STRING { $$ = NRegExpr{key: $1, value: $3} }
+%%