New constraints management.

Co-authored-by: Mathieu Lonjaret <mathieu.lonjaret@gmail.com>

vendor/github.com/vulcand/predicate/lib.go

@@ -119,6 +119,14 @@ func Or(a, b BoolPredicate) BoolPredicate {
 	}
 }
 
+// Not is a boolean predicate that calls a boolean predicate
+// and returns negated result
+func Not(a BoolPredicate) BoolPredicate {
+	return func() bool {
+		return !a()
+	}
+}
+
 // GetFieldByTag returns a field from the object based on the tag
 func GetFieldByTag(ival interface{}, tagName string, fieldNames []string) (interface{}, error) {
 	if len(fieldNames) == 0 {

vendor/github.com/vulcand/predicate/parse.go

@@ -59,6 +59,16 @@ func (p *predicateParser) parseNode(node ast.Node) (interface{}, error) {
 		return callFunction(fn, arguments)
 	case *ast.ParenExpr:
 		return p.parseNode(n.X)
+	case *ast.UnaryExpr:
+		joinFn, err := p.getJoinFunction(n.Op)
+		if err != nil {
+			return nil, err
+		}
+		node, err := p.parseNode(n.X)
+		if err != nil {
+			return nil, err
+		}
+		return callFunction(joinFn, []interface{}{node})
 	}
 	return nil, trace.BadParameter("unsupported %T", node)
 }
@@ -122,6 +132,20 @@ func (p *predicateParser) evaluateExpr(n ast.Expr) (interface{}, error) {
 			return nil, trace.Wrap(err)
 		}
 		return val, nil
+	case *ast.CallExpr:
+		name, err := getIdentifier(l.Fun)
+		if err != nil {
+			return nil, err
+		}
+		fn, err := p.getFunction(name)
+		if err != nil {
+			return nil, err
+		}
+		arguments, err := p.evaluateArguments(l.Args)
+		if err != nil {
+			return nil, err
+		}
+		return callFunction(fn, arguments)
 	default:
 		return nil, trace.BadParameter("%T is not supported", n)
 	}
@@ -161,6 +185,8 @@ func (p *predicateParser) joinPredicates(op token.Token, a, b interface{}) (inte
 func (p *predicateParser) getJoinFunction(op token.Token) (interface{}, error) {
 	var fn interface{}
 	switch op {
+	case token.NOT:
+		fn = p.d.Operators.NOT
 	case token.LAND:
 		fn = p.d.Operators.AND
 	case token.LOR:

vendor/github.com/vulcand/predicate/predicate.go

@@ -1,3 +1,20 @@
+/*
+Copyright 2014-2018 Vulcand 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.
+
+*/
+
 /*
 Predicate package used to create interpreted mini languages with Go syntax - mostly to define
 various predicates for configuration, e.g. Latency() > 40 || ErrorRate() > 0.5.
@@ -76,6 +93,7 @@ type Operators struct {
 
 	OR  interface{}
 	AND interface{}
+	NOT interface{}
 }
 
 // Parser takes the string with expression and calls the operators and functions.