tetragon

1
// SPDX-License-Identifier: Apache-2.0
2
// Copyright Authors of Tetragon
3

4
package labels
5

6
import (
7
	"fmt"
8

9
	slimv1 "github.com/cilium/cilium/pkg/k8s/slim/k8s/apis/meta/v1"
10
)
11

12
type Labels map[string]string
13

14
type operator int
15

16
const (
17
	opExists = iota
18
	opDoesNotExist
19
	opIn
20
	opNotIn
21
)
22

23
const (
24
	K8sPodNamespace = "k8s:io.kubernetes.pod.namespace"
25
)
26

27
type selectorOp struct {
28
	key      string
29
	operator operator
30
	values   []string
31
}
32

33
func (s selectorOp) hasValue(val string) bool {
34
	for i := range s.values {
35
		if val == s.values[i] {
36
			return true
37
		}
38
	}
39
	return false
40
}
41

42
func (s *selectorOp) match(labels Labels) bool {
43
	val, exists := labels[s.key]
44
	switch s.operator {
45
	case opExists:
46
		return exists
47
	case opDoesNotExist:
48
		return !exists
49
	case opIn:
50
		return exists && s.hasValue(val)
51
	case opNotIn:
52
		return !exists || !s.hasValue(val)
53
	default:
54
		return false
55
	}
56
}
57

58
type Selector []selectorOp
59

60
func (s Selector) Match(labels Labels) bool {
61
	for i := range s {
62
		if !s[i].match(labels) {
63
			return false
64
		}
65
	}
66

67
	return true
68
}
69

70
func SelectorFromLabelSelector(ls *slimv1.LabelSelector) (Selector, error) {
71
	if ls == nil {
72
		return []selectorOp{}, nil
73
	}
74
	ret := make([]selectorOp, 0, len(ls.MatchLabels)+len(ls.MatchExpressions))
75
	for key, val := range ls.MatchLabels {
76
		ret = append(ret, selectorOp{
77
			key:      key,
78
			operator: opIn,
79
			values:   []string{val},
80
		})
81
	}
82
	for _, exp := range ls.MatchExpressions {
83
		var op operator
84
		switch exp.Operator {
85
		case slimv1.LabelSelectorOpIn:
86
			op = opIn
87
		case slimv1.LabelSelectorOpNotIn:
88
			op = opNotIn
89
		case slimv1.LabelSelectorOpExists:
90
			op = opExists
91
		case slimv1.LabelSelectorOpDoesNotExist:
92
			op = opDoesNotExist
93
		default:
94
			return nil, fmt.Errorf("unknown operator: '%s'", exp.Operator)
95
		}
96

97
		ret = append(ret, selectorOp{
98
			key:      exp.Key,
99
			operator: op,
100
			values:   exp.Values,
101
		})
102
	}
103

104
	return ret, nil
105
}
106

107
// Cmp checks if the labels are different. Returns true if they are.
108
func (l Labels) Cmp(a Labels) bool {
109

110
	if len(l) != len(a) {
111
		return true
112
	}
113

114
	for lk, lv := range l {
115
		av, ok := a[lk]
116
		if !ok || lv != av {
117
			return true
118
		}
119
	}
120

121
	return false
122
}
123