Add muxer for TCP Routers

pkg/rules/parser.go

@@ -1,7 +1,7 @@
 package rules
 
 import (
-	"errors"
+	"fmt"
 	"strings"
 
 	"github.com/vulcand/predicate"
@@ -12,121 +12,29 @@ const (
 	or  = "or"
 )
 
-type treeBuilder func() *tree
+// TreeBuilder defines the type for a Tree builder.
+type TreeBuilder func() *Tree
 
-// ParseDomains extract domains from rule.
-func ParseDomains(rule string) ([]string, error) {
-	parser, err := newParser()
-	if err != nil {
-		return nil, err
-	}
-
-	parse, err := parser.Parse(rule)
-	if err != nil {
-		return nil, err
-	}
-
-	buildTree, ok := parse.(treeBuilder)
-	if !ok {
-		return nil, errors.New("cannot parse")
-	}
-
-	return lower(parseDomain(buildTree())), nil
+// Tree represents the rules' tree structure.
+type Tree struct {
+	Matcher   string
+	Not       bool
+	Value     []string
+	RuleLeft  *Tree
+	RuleRight *Tree
 }
 
-// ParseHostSNI extracts the HostSNIs declared in a rule.
-// This is a first naive implementation used in TCP routing.
-func ParseHostSNI(rule string) ([]string, error) {
-	parser, err := newTCPParser()
-	if err != nil {
-		return nil, err
-	}
-
-	parse, err := parser.Parse(rule)
-	if err != nil {
-		return nil, err
-	}
-
-	buildTree, ok := parse.(treeBuilder)
-	if !ok {
-		return nil, errors.New("cannot parse")
-	}
-
-	return lower(parseDomain(buildTree())), nil
-}
-
-func lower(slice []string) []string {
-	var lowerStrings []string
-	for _, value := range slice {
-		lowerStrings = append(lowerStrings, strings.ToLower(value))
-	}
-	return lowerStrings
-}
-
-func parseDomain(tree *tree) []string {
-	switch tree.matcher {
-	case and, or:
-		return append(parseDomain(tree.ruleLeft), parseDomain(tree.ruleRight)...)
-	case "Host", "HostSNI":
-		return tree.value
-	default:
-		return nil
-	}
-}
-
-func andFunc(left, right treeBuilder) treeBuilder {
-	return func() *tree {
-		return &tree{
-			matcher:   and,
-			ruleLeft:  left(),
-			ruleRight: right(),
-		}
-	}
-}
-
-func orFunc(left, right treeBuilder) treeBuilder {
-	return func() *tree {
-		return &tree{
-			matcher:   or,
-			ruleLeft:  left(),
-			ruleRight: right(),
-		}
-	}
-}
-
-func invert(t *tree) *tree {
-	switch t.matcher {
-	case or:
-		t.matcher = and
-		t.ruleLeft = invert(t.ruleLeft)
-		t.ruleRight = invert(t.ruleRight)
-	case and:
-		t.matcher = or
-		t.ruleLeft = invert(t.ruleLeft)
-		t.ruleRight = invert(t.ruleRight)
-	default:
-		t.not = !t.not
-	}
-
-	return t
-}
-
-func notFunc(elem treeBuilder) treeBuilder {
-	return func() *tree {
-		return invert(elem())
-	}
-}
-
-func newParser() (predicate.Parser, error) {
+// NewParser constructs a parser for the given matchers.
+func NewParser(matchers []string) (predicate.Parser, error) {
 	parserFuncs := make(map[string]interface{})
 
-	for matcherName := range funcs {
+	for _, matcherName := range matchers {
 		matcherName := matcherName
-		fn := func(value ...string) treeBuilder {
-			return func() *tree {
-				return &tree{
-					matcher: matcherName,
-					value:   value,
+		fn := func(value ...string) TreeBuilder {
+			return func() *Tree {
+				return &Tree{
+					Matcher: matcherName,
+					Value:   value,
 				}
 			}
 		}
@@ -146,28 +54,85 @@ func newParser() (predicate.Parser, error) {
 	})
 }
 
-func newTCPParser() (predicate.Parser, error) {
-	parserFuncs := make(map[string]interface{})
-
-	// FIXME quircky way of waiting for new rules
-	matcherName := "HostSNI"
-	fn := func(value ...string) treeBuilder {
-		return func() *tree {
-			return &tree{
-				matcher: matcherName,
-				value:   value,
-			}
+func andFunc(left, right TreeBuilder) TreeBuilder {
+	return func() *Tree {
+		return &Tree{
+			Matcher:   and,
+			RuleLeft:  left(),
+			RuleRight: right(),
 		}
 	}
-	parserFuncs[matcherName] = fn
-	parserFuncs[strings.ToLower(matcherName)] = fn
-	parserFuncs[strings.ToUpper(matcherName)] = fn
-	parserFuncs[strings.Title(strings.ToLower(matcherName))] = fn
-
-	return predicate.NewParser(predicate.Def{
-		Operators: predicate.Operators{
-			OR: orFunc,
-		},
-		Functions: parserFuncs,
-	})
+}
+
+func orFunc(left, right TreeBuilder) TreeBuilder {
+	return func() *Tree {
+		return &Tree{
+			Matcher:   or,
+			RuleLeft:  left(),
+			RuleRight: right(),
+		}
+	}
+}
+
+func invert(t *Tree) *Tree {
+	switch t.Matcher {
+	case or:
+		t.Matcher = and
+		t.RuleLeft = invert(t.RuleLeft)
+		t.RuleRight = invert(t.RuleRight)
+	case and:
+		t.Matcher = or
+		t.RuleLeft = invert(t.RuleLeft)
+		t.RuleRight = invert(t.RuleRight)
+	default:
+		t.Not = !t.Not
+	}
+
+	return t
+}
+
+func notFunc(elem TreeBuilder) TreeBuilder {
+	return func() *Tree {
+		return invert(elem())
+	}
+}
+
+// ParseMatchers returns the subset of matchers in the Tree matching the given matchers.
+func (tree *Tree) ParseMatchers(matchers []string) []string {
+	switch tree.Matcher {
+	case and, or:
+		return append(tree.RuleLeft.ParseMatchers(matchers), tree.RuleRight.ParseMatchers(matchers)...)
+	default:
+		for _, matcher := range matchers {
+			if tree.Matcher == matcher {
+				return lower(tree.Value)
+			}
+		}
+
+		return nil
+	}
+}
+
+// CheckRule validates the given rule.
+func CheckRule(rule *Tree) error {
+	if len(rule.Value) == 0 {
+		return fmt.Errorf("no args for matcher %s", rule.Matcher)
+	}
+
+	for _, v := range rule.Value {
+		if len(v) == 0 {
+			return fmt.Errorf("empty args for matcher %s, %v", rule.Matcher, rule.Value)
+		}
+	}
+
+	return nil
+}
+
+func lower(slice []string) []string {
+	var lowerStrings []string
+	for _, value := range slice {
+		lowerStrings = append(lowerStrings, strings.ToLower(value))
+	}
+
+	return lowerStrings
 }