CoCalc -- loader_bench

GitHub Repository: projectdiscovery/nuclei
Path: blob/dev/pkg/catalog/loader/loader_bench_test.go
²⁸⁴³ views
1
package loader_test
2

3
import (
4
	"testing"
5

6
	"github.com/projectdiscovery/gologger"
7
	"github.com/projectdiscovery/nuclei/v3/pkg/catalog/config"
8
	"github.com/projectdiscovery/nuclei/v3/pkg/catalog/disk"
9
	"github.com/projectdiscovery/nuclei/v3/pkg/catalog/loader"
10
	"github.com/projectdiscovery/nuclei/v3/pkg/loader/workflow"
11
	"github.com/projectdiscovery/nuclei/v3/pkg/model/types/severity"
12
	"github.com/projectdiscovery/nuclei/v3/pkg/templates"
13
	templateTypes "github.com/projectdiscovery/nuclei/v3/pkg/templates/types"
14
	"github.com/projectdiscovery/nuclei/v3/pkg/testutils"
15
)
16

17
func BenchmarkStoreValidateTemplates(b *testing.B) {
18
	options := testutils.DefaultOptions.Copy()
19
	options.Logger = &gologger.Logger{}
20
	testutils.Init(options)
21

22
	catalog := disk.NewCatalog(config.DefaultConfig.TemplatesDirectory)
23
	executerOpts := testutils.NewMockExecuterOptions(options, nil)
24
	executerOpts.Parser = templates.NewParser()
25

26
	workflowLoader, err := workflow.NewLoader(executerOpts)
27
	if err != nil {
28
		b.Fatalf("could not create workflow loader: %s", err)
29
	}
30
	executerOpts.WorkflowLoader = workflowLoader
31

32
	loaderCfg := loader.NewConfig(options, catalog, executerOpts)
33

34
	store, err := loader.New(loaderCfg)
35
	if err != nil {
36
		b.Fatalf("could not create store: %s", err)
37
	}
38

39
	b.ResetTimer()
40
	b.ReportAllocs()
41

42
	for b.Loop() {
43
		_ = store.ValidateTemplates()
44
	}
45
}
46

47
func BenchmarkLoadTemplates(b *testing.B) {
48
	options := testutils.DefaultOptions.Copy()
49
	options.Logger = &gologger.Logger{}
50
	options.ExecutionId = "bench-load-templates"
51
	testutils.Init(options)
52

53
	catalog := disk.NewCatalog(config.DefaultConfig.TemplatesDirectory)
54
	executerOpts := testutils.NewMockExecuterOptions(options, nil)
55
	executerOpts.Parser = templates.NewParser()
56

57
	workflowLoader, err := workflow.NewLoader(executerOpts)
58
	if err != nil {
59
		b.Fatalf("could not create workflow loader: %s", err)
60
	}
61
	executerOpts.WorkflowLoader = workflowLoader
62

63
	b.Run("NoFilter", func(b *testing.B) {
64
		loaderCfg := loader.NewConfig(options, catalog, executerOpts)
65
		store, err := loader.New(loaderCfg)
66
		if err != nil {
67
			b.Fatalf("could not create store: %s", err)
68
		}
69

70
		b.ResetTimer()
71
		b.ReportAllocs()
72

73
		for b.Loop() {
74
			_ = store.LoadTemplates([]string{config.DefaultConfig.TemplatesDirectory})
75
		}
76
	})
77

78
	b.Run("FilterBySeverityCritical", func(b *testing.B) {
79
		opts := options.Copy()
80
		opts.Severities = severity.Severities{severity.Critical}
81
		loaderCfg := loader.NewConfig(opts, catalog, executerOpts)
82

83
		store, err := loader.New(loaderCfg)
84
		if err != nil {
85
			b.Fatalf("could not create store: %s", err)
86
		}
87

88
		b.ResetTimer()
89
		b.ReportAllocs()
90

91
		for b.Loop() {
92
			_ = store.LoadTemplates([]string{config.DefaultConfig.TemplatesDirectory})
93
		}
94
	})
95

96
	b.Run("FilterBySeverityHighCritical", func(b *testing.B) {
97
		opts := options.Copy()
98
		opts.Severities = severity.Severities{severity.High, severity.Critical}
99
		loaderCfg := loader.NewConfig(opts, catalog, executerOpts)
100

101
		store, err := loader.New(loaderCfg)
102
		if err != nil {
103
			b.Fatalf("could not create store: %s", err)
104
		}
105

106
		b.ResetTimer()
107
		b.ReportAllocs()
108

109
		for b.Loop() {
110
			_ = store.LoadTemplates([]string{config.DefaultConfig.TemplatesDirectory})
111
		}
112
	})
113

114
	b.Run("FilterByAuthor", func(b *testing.B) {
115
		opts := options.Copy()
116
		opts.Authors = []string{"pdteam"}
117
		loaderCfg := loader.NewConfig(opts, catalog, executerOpts)
118

119
		store, err := loader.New(loaderCfg)
120
		if err != nil {
121
			b.Fatalf("could not create store: %s", err)
122
		}
123

124
		b.ResetTimer()
125
		b.ReportAllocs()
126

127
		for b.Loop() {
128
			_ = store.LoadTemplates([]string{config.DefaultConfig.TemplatesDirectory})
129
		}
130
	})
131

132
	b.Run("FilterByTags", func(b *testing.B) {
133
		opts := options.Copy()
134
		opts.Tags = []string{"cve", "rce"}
135
		loaderCfg := loader.NewConfig(opts, catalog, executerOpts)
136

137
		store, err := loader.New(loaderCfg)
138
		if err != nil {
139
			b.Fatalf("could not create store: %s", err)
140
		}
141

142
		b.ResetTimer()
143
		b.ReportAllocs()
144

145
		for b.Loop() {
146
			_ = store.LoadTemplates([]string{config.DefaultConfig.TemplatesDirectory})
147
		}
148
	})
149

150
	b.Run("FilterByProtocol", func(b *testing.B) {
151
		opts := options.Copy()
152
		opts.Protocols = templateTypes.ProtocolTypes{templateTypes.HTTPProtocol}
153
		loaderCfg := loader.NewConfig(opts, catalog, executerOpts)
154

155
		store, err := loader.New(loaderCfg)
156
		if err != nil {
157
			b.Fatalf("could not create store: %s", err)
158
		}
159

160
		b.ResetTimer()
161
		b.ReportAllocs()
162

163
		for b.Loop() {
164
			_ = store.LoadTemplates([]string{config.DefaultConfig.TemplatesDirectory})
165
		}
166
	})
167

168
	b.Run("ComplexFilter", func(b *testing.B) {
169
		opts := options.Copy()
170
		opts.Severities = severity.Severities{severity.High, severity.Critical}
171
		opts.Authors = []string{"pdteam"}
172
		opts.Tags = []string{"cve"}
173
		loaderCfg := loader.NewConfig(opts, catalog, executerOpts)
174

175
		store, err := loader.New(loaderCfg)
176
		if err != nil {
177
			b.Fatalf("could not create store: %s", err)
178
		}
179

180
		b.ResetTimer()
181
		b.ReportAllocs()
182

183
		for b.Loop() {
184
			_ = store.LoadTemplates([]string{config.DefaultConfig.TemplatesDirectory})
185
		}
186
	})
187
}
188

189
func BenchmarkLoadTemplatesOnlyMetadata(b *testing.B) {
190
	options := testutils.DefaultOptions.Copy()
191
	options.Logger = &gologger.Logger{}
192
	options.ExecutionId = "bench-metadata"
193
	testutils.Init(options)
194

195
	catalog := disk.NewCatalog(config.DefaultConfig.TemplatesDirectory)
196
	executerOpts := testutils.NewMockExecuterOptions(options, nil)
197
	executerOpts.Parser = templates.NewParser()
198

199
	workflowLoader, err := workflow.NewLoader(executerOpts)
200
	if err != nil {
201
		b.Fatalf("could not create workflow loader: %s", err)
202
	}
203
	executerOpts.WorkflowLoader = workflowLoader
204

205
	b.Run("WithoutFilter", func(b *testing.B) {
206
		loaderCfg := loader.NewConfig(options, catalog, executerOpts)
207
		store, err := loader.New(loaderCfg)
208
		if err != nil {
209
			b.Fatalf("could not create store: %s", err)
210
		}
211

212
		// Pre-warm the cache
213
		_ = store.LoadTemplatesOnlyMetadata()
214

215
		b.ResetTimer()
216
		b.ReportAllocs()
217

218
		for b.Loop() {
219
			_ = store.LoadTemplatesOnlyMetadata()
220
		}
221
	})
222

223
	b.Run("WithSeverityFilter", func(b *testing.B) {
224
		opts := options.Copy()
225
		opts.Severities = severity.Severities{severity.Critical}
226
		loaderCfg := loader.NewConfig(opts, catalog, executerOpts)
227

228
		store, err := loader.New(loaderCfg)
229
		if err != nil {
230
			b.Fatalf("could not create store: %s", err)
231
		}
232

233
		// Pre-warm the cache
234
		_ = store.LoadTemplatesOnlyMetadata()
235

236
		b.ResetTimer()
237
		b.ReportAllocs()
238

239
		for b.Loop() {
240
			_ = store.LoadTemplatesOnlyMetadata()
241
		}
242
	})
243
}
244

245
Product

Resources

Company
