ebpf_exporter

1
package cgroup
2

3
import (
4
	"fmt"
5
	"os"
6
	"testing"
7
	"time"
8
)
9

10
const preExistingFile = "i-was-here"
11
const sleepDuration = time.Millisecond * 5
12

13
func TestMonitor(t *testing.T) {
14
	cases := []struct {
15
		kind    string
16
		check   func() bool
17
		factory func(path string) (monitor, error)
18
	}{
19
		{
20
			kind: "Monitor",
21
			factory: func(path string) (monitor, error) {
22
				return NewMonitor(path)
23
			},
24
		},
25
		{
26
			kind: "walkerMonitor",
27
			factory: func(path string) (monitor, error) {
28
				return newWalkerMonitor(path)
29
			},
30
		},
31
		{
32
			kind: "fanotifyMonitor",
33
			check: func() bool {
34
				// Only test fanotify under root
35
				return os.Geteuid() == 0
36
			},
37
			factory: func(path string) (monitor, error) {
38
				return newFanotifyMonitor(path)
39
			},
40
		},
41
	}
42

43
	for _, c := range cases {
44
		t.Run(c.kind, func(t *testing.T) {
45
			path := t.TempDir()
46

47
			preExistingPath := fmt.Sprintf("%s/%s", path, preExistingFile)
48
			if err := os.Mkdir(preExistingPath, 0755); err != nil {
49
				t.Fatalf("Error creating %q: %v", preExistingPath, err)
50
			}
51

52
			if c.check != nil && !c.check() {
53
				t.Skip()
54
			}
55

56
			m, err := c.factory(path)
57
			if err != nil {
58
				t.Fatal(err)
59
			}
60

61
			if m == nil {
62
				t.Skip()
63
			}
64

65
			testMonitor(t, m, path, preExistingPath)
66
		})
67
	}
68
}
69

70
func testMonitor(t *testing.T, m monitor, path, preExistingPath string) {
71
	preExistingID, err := inode(preExistingPath)
72
	if err != nil {
73
		t.Fatalf("Error resolving %q: %v", preExistingPath, err)
74
	}
75

76
	preExistingResolved := m.Resolve(preExistingID)
77
	if preExistingResolved != preExistingPath {
78
		t.Errorf("Expected %d to resolve into pre-existing %q, got %q", preExistingID, preExistingPath, preExistingResolved)
79
	}
80

81
	// What are the chances?
82
	missingName := m.Resolve(88888888888)
83

84
	if missingName != "" {
85
		t.Errorf("Expected empty string for a missing inode, got %q", missingName)
86
	}
87

88
	// Check addition one by one
89
	for i := 0; i < 20; i++ {
90
		dir := fmt.Sprintf("%s/lol-%d", path, i)
91

92
		err = os.Mkdir(dir, 0755)
93
		if err != nil {
94
			t.Fatalf("Error creating %q: %v", dir, err)
95
		}
96

97
		// Sleep for a short time to let fanotify to process
98
		time.Sleep(sleepDuration)
99

100
		id, err := inode(dir)
101
		if err != nil {
102
			t.Fatalf("Error resolving %q: %v", dir, err)
103
		}
104

105
		resolved := m.Resolve(id)
106
		if resolved != dir {
107
			t.Errorf("Expected %q, got %q", dir, resolved)
108
		}
109
	}
110

111
	// Check burst addition
112
	for i := 20; i < 40; i++ {
113
		dir := fmt.Sprintf("%s/lol-%d", path, i)
114

115
		err = os.Mkdir(dir, 0755)
116
		if err != nil {
117
			t.Fatalf("Error creating %q: %v", dir, err)
118
		}
119
	}
120

121
	// Sleep for a short time to let fanotify to process
122
	time.Sleep(sleepDuration)
123

124
	// Continue checking burst addition
125
	for i := 20; i < 40; i++ {
126
		dir := fmt.Sprintf("%s/lol-%d", path, i)
127

128
		id, err := inode(dir)
129
		if err != nil {
130
			t.Fatalf("Error resolving %q: %v", dir, err)
131
		}
132

133
		resolved := m.Resolve(id)
134
		if resolved != dir {
135
			t.Errorf("Expected %q, got %q", dir, resolved)
136
		}
137
	}
138

139
	// Check if overwrites are picked up
140
	overwritePath := fmt.Sprintf("%s/%s", path, "lol-22")
141

142
	idBefore, err := inode(overwritePath)
143
	if err != nil {
144
		t.Fatalf("Error resolving %q (before): %v", overwritePath, err)
145
	}
146

147
	resolvedBefore := m.Resolve(idBefore)
148
	if resolvedBefore != overwritePath {
149
		t.Errorf("Expected %d to resolve into %q, got %q (before)", idBefore, overwritePath, resolvedBefore)
150
	}
151

152
	err = os.Remove(overwritePath)
153
	if err != nil {
154
		t.Fatalf("Error removing %q: %v", overwritePath, err)
155
	}
156

157
	err = os.Mkdir(overwritePath, 0755)
158
	if err != nil {
159
		t.Fatalf("Error re-creating %q: %v", overwritePath, err)
160
	}
161

162
	idAfter, err := inode(overwritePath)
163
	if err != nil {
164
		t.Fatalf("Error resolving %q (after): %v", overwritePath, err)
165
	}
166

167
	// Sleep for a short time to let fanotify to process
168
	time.Sleep(sleepDuration)
169

170
	resolvedAfter := m.Resolve(idAfter)
171
	if resolvedAfter != overwritePath {
172
		t.Errorf("Expected %d to resolve into %q, got %q (after)", idAfter, overwritePath, resolvedAfter)
173
	}
174
}
175