Merge pull request #158 from linux-on-ibm-z/cross-compile

Edited Makefile to add cross build support for s390x.

Adding External Metrics Provider

pkg/external-provider/query_builder.go

@@ -0,0 +1,206 @@
+package provider
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+	"text/template"
+
+	"k8s.io/apimachinery/pkg/selection"
+
+	prom "github.com/directxman12/k8s-prometheus-adapter/pkg/client"
+)
+
+// QueryBuilder provides functions for generating Prometheus queries.
+type QueryBuilder interface {
+	BuildSelector(seriesName string, groupBy string, groupBySlice []string, queryParts []queryPart) (prom.Selector, error)
+}
+
+type queryBuilder struct {
+	metricsQueryTemplate *template.Template
+}
+
+// NewQueryBuilder creates a QueryBuilder.
+func NewQueryBuilder(metricsQuery string) (QueryBuilder, error) {
+	metricsQueryTemplate, err := template.New("metrics-query").Delims("<<", ">>").Parse(metricsQuery)
+	if err != nil {
+		return nil, fmt.Errorf("unable to parse metrics query template %q: %v", metricsQuery, err)
+	}
+
+	return &queryBuilder{
+		metricsQueryTemplate: metricsQueryTemplate,
+	}, nil
+}
+
+func (n *queryBuilder) BuildSelector(seriesName string, groupBy string, groupBySlice []string, queryParts []queryPart) (prom.Selector, error) {
+	// Convert our query parts into the types we need for our template.
+	exprs, valuesByName, err := n.processQueryParts(queryParts)
+
+	if err != nil {
+		return "", err
+	}
+
+	args := queryTemplateArgs{
+		Series:            seriesName,
+		LabelMatchers:     strings.Join(exprs, ","),
+		LabelValuesByName: valuesByName,
+		GroupBy:           groupBy,
+		GroupBySlice:      groupBySlice,
+	}
+
+	selector, err := n.createSelectorFromTemplateArgs(args)
+	if err != nil {
+		return "", err
+	}
+
+	return selector, nil
+}
+
+func (n *queryBuilder) createSelectorFromTemplateArgs(args queryTemplateArgs) (prom.Selector, error) {
+	//Turn our template arguments into a Selector.
+	queryBuff := new(bytes.Buffer)
+	if err := n.metricsQueryTemplate.Execute(queryBuff, args); err != nil {
+		return "", err
+	}
+
+	if queryBuff.Len() == 0 {
+		return "", fmt.Errorf("empty query produced by metrics query template")
+	}
+
+	return prom.Selector(queryBuff.String()), nil
+}
+
+func (n *queryBuilder) processQueryParts(queryParts []queryPart) ([]string, map[string][]string, error) {
+	// We've take the approach here that if we can't perfectly map their query into a Prometheus
+	// query that we should abandon the effort completely.
+	// The concern is that if we don't get a perfect match on their query parameters, the query result
+	// might contain unexpected data that would cause them to take an erroneous action based on the result.
+
+	// Contains the expressions that we want to include as part of the query to Prometheus.
+	// e.g. "namespace=my-namespace"
+	// e.g. "some_label=some-value"
+	var exprs []string
+
+	// Contains the list of label values we're targeting, by namespace.
+	// e.g. "some_label" => ["value-one", "value-two"]
+	valuesByName := map[string][]string{}
+
+	// Convert our query parts into template arguments.
+	for _, qPart := range queryParts {
+		// Be resilient against bad inputs.
+		// We obviously can't generate label filters for these cases.
+		fmt.Println("This is queryPart", qPart.labelName, qPart.operator, qPart.values)
+		if qPart.labelName == "" {
+			return nil, nil, NewLabelNotSpecifiedError()
+		}
+
+		if !n.operatorIsSupported(qPart.operator) {
+			return nil, nil, NewOperatorNotSupportedByPrometheusError()
+		}
+
+		matcher, err := n.selectMatcher(qPart.operator, qPart.values)
+
+		if err != nil {
+			return nil, nil, err
+		}
+
+		targetValue, err := n.selectTargetValue(qPart.operator, qPart.values)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		expression := matcher(qPart.labelName, targetValue)
+		exprs = append(exprs, expression)
+		valuesByName[qPart.labelName] = qPart.values
+	}
+
+	return exprs, valuesByName, nil
+}
+
+func (n *queryBuilder) selectMatcher(operator selection.Operator, values []string) (func(string, string) string, error) {
+
+	numValues := len(values)
+	if numValues == 0 {
+		switch operator {
+		case selection.Exists:
+			return prom.LabelNeq, nil
+		case selection.DoesNotExist:
+			return prom.LabelEq, nil
+		case selection.Equals, selection.DoubleEquals, selection.NotEquals, selection.In, selection.NotIn:
+			return nil, NewOperatorRequiresValuesError()
+		}
+	} else if numValues == 1 {
+		switch operator {
+		case selection.Equals, selection.DoubleEquals:
+			return prom.LabelEq, nil
+		case selection.NotEquals:
+			return prom.LabelNeq, nil
+		case selection.In, selection.Exists:
+			return prom.LabelMatches, nil
+		case selection.DoesNotExist, selection.NotIn:
+			return prom.LabelNotMatches, nil
+		}
+	} else {
+		// Since labels can only have one value, providing multiple
+		// values results in a regex match, even if that's not what the user
+		// asked for.
+		switch operator {
+		case selection.Equals, selection.DoubleEquals, selection.In, selection.Exists:
+			return prom.LabelMatches, nil
+		case selection.NotEquals, selection.DoesNotExist, selection.NotIn:
+			return prom.LabelNotMatches, nil
+		}
+	}
+
+	return nil, errors.New("operator not supported by query builder")
+}
+
+func (n *queryBuilder) selectTargetValue(operator selection.Operator, values []string) (string, error) {
+	numValues := len(values)
+	if numValues == 0 {
+		switch operator {
+		case selection.Exists, selection.DoesNotExist:
+			// Return an empty string when values are equal to 0
+			// When the operator is LabelNotMatches this will select series without the label
+			// or with the label but a value of "".
+			// When the operator is LabelMatches this will select series with the label
+			// whose value is NOT "".
+			return "", nil
+		case selection.Equals, selection.DoubleEquals, selection.NotEquals, selection.In, selection.NotIn:
+			return "", NewOperatorRequiresValuesError()
+		}
+	} else if numValues == 1 {
+		switch operator {
+		case selection.Equals, selection.DoubleEquals, selection.NotEquals, selection.In, selection.NotIn:
+			// Pass the value through as-is.
+			// It's somewhat strange to do this for both the regex and equality
+			// operators, but if we do it this way it gives the user a little more control.
+			// They might choose to send an "IN" request and give a list of static values
+			// or they could send a single value that's a regex, giving them a passthrough
+			// for their label selector.
+			return values[0], nil
+		case selection.Exists, selection.DoesNotExist:
+			return "", errors.New("operator does not support values")
+		}
+	} else {
+		switch operator {
+		case selection.Equals, selection.DoubleEquals, selection.NotEquals, selection.In, selection.NotIn:
+			// Pass the value through as-is.
+			// It's somewhat strange to do this for both the regex and equality
+			// operators, but if we do it this way it gives the user a little more control.
+			// They might choose to send an "IN" request and give a list of static values
+			// or they could send a single value that's a regex, giving them a passthrough
+			// for their label selector.
+			return strings.Join(values, "|"), nil
+		case selection.Exists, selection.DoesNotExist:
+			return "", NewOperatorDoesNotSupportValuesError()
+		}
+	}
+
+	return "", errors.New("operator not supported by query builder")
+}
+
+func (n *queryBuilder) operatorIsSupported(operator selection.Operator) bool {
+	return operator != selection.GreaterThan && operator != selection.LessThan
+}