diff --git a/dev-tools/cmd/module_include_list/module_include_list.go b/dev-tools/cmd/module_include_list/module_include_list.go index db46b5e872e0..ac85f157d2b7 100644 --- a/dev-tools/cmd/module_include_list/module_include_list.go +++ b/dev-tools/cmd/module_include_list/module_include_list.go @@ -18,6 +18,7 @@ package main import ( + "bufio" "bytes" "flag" "fmt" @@ -28,28 +29,39 @@ import ( "strings" "text/template" + "github.com/pkg/errors" + "github.com/elastic/beats/dev-tools/mage" "github.com/elastic/beats/licenses" ) var usageText = ` -Usage: module_include_list [flags] [module-dir] +Usage: module_include_list [flags] module_include_list generates a list.go file containing import statements for - the module and its dataset packages. The file is usually written to the - include/list.go in the Beat's root directory. + the specified imports and module directories. An import is a directory or + directory glob containing .go files. A moduleDir is a directory to search + for modules and datasets. + + Packages without .go files or without an init() method are omitted from the + generated file. The output file is written to the include/list.go in the + Beat's root directory by default. Options: `[1:] var ( - license string - pkg string - outFile string + license string + pkg string + outFile string + moduleDirs stringSliceFlag + importDirs stringSliceFlag ) func init() { flag.StringVar(&license, "license", "ASL2", "License header for generated file (ASL2 or Elastic).") flag.StringVar(&pkg, "pkg", "include", "Package name.") flag.StringVar(&outFile, "out", "include/list.go", "Output file.") + flag.Var(&moduleDirs, "moduleDir", "Directory to search for modules to include") + flag.Var(&importDirs, "import", "Directory to include") flag.Usage = usageFlag } @@ -62,19 +74,19 @@ func main() { log.Fatalf("Invalid license specifier: %v", err) } - args := flag.Args() - if len(args) != 1 { - log.Fatal("module-dir must be passed as an argument.") + if len(moduleDirs) == 0 && len(importDirs) == 0 { + log.Fatal("At least one -import or -moduleDir must be specified.") } - dir := args[0] - // Find modules and datasets. - metaDirs, err := mage.FindFiles( - filepath.Join(dir, "*/_meta"), - filepath.Join(dir, "*/*/_meta"), - ) + dirs, err := findModuleAndDatasets() if err != nil { - log.Fatalf("Failed finding modules and datasets: %v", err) + log.Fatal(err) + } + + if imports, err := findImports(); err != nil { + log.Fatal(err) + } else { + dirs = append(dirs, imports...) } // Get the current directories Go import path. @@ -85,11 +97,9 @@ func main() { // Build import paths. var imports []string - for _, metaDir := range metaDirs { - importDir := filepath.Dir(metaDir) - + for _, dir := range dirs { // Skip dirs that have no .go files. - goFiles, err := filepath.Glob(filepath.Join(importDir, "*.go")) + goFiles, err := filepath.Glob(filepath.Join(dir, "*.go")) if err != nil { log.Fatal("Failed checking for .go files in package dir: %v", err) } @@ -97,9 +107,26 @@ func main() { continue } - importDir, err = filepath.Rel(mage.CWD(), filepath.Dir(metaDir)) - if err != nil { - log.Fatal(err) + // Skip packages without an init() function because that cannot register + // anything as a side-effect of being imported (e.g. filebeat/input/file). + var foundInitMethod bool + for _, f := range goFiles { + if hasInitMethod(f) { + foundInitMethod = true + break + } + } + if !foundInitMethod { + continue + } + + importDir := dir + if filepath.IsAbs(dir) { + // Make it relative to the current package if it's absolute. + importDir, err = filepath.Rel(mage.CWD(), dir) + if err != nil { + log.Fatalf("Failure creating import for dir=%v: %v", dir, err) + } } imports = append(imports, filepath.ToSlash( @@ -155,3 +182,61 @@ type Data struct { Package string Imports []string } + +//stringSliceFlag is a flag type that allows more than one value to be specified. +type stringSliceFlag []string + +func (f *stringSliceFlag) String() string { return strings.Join(*f, ", ") } + +func (f *stringSliceFlag) Set(value string) error { + *f = append(*f, value) + return nil +} + +// findModuleAndDatasets searches the specified moduleDirs for packages that +// should be imported. They are designated by the presence of a _meta dir. +func findModuleAndDatasets() ([]string, error) { + var dirs []string + for _, moduleDir := range moduleDirs { + // Find modules and datasets as indicated by the _meta dir. + metaDirs, err := mage.FindFiles( + filepath.Join(moduleDir, "*/_meta"), + filepath.Join(moduleDir, "*/*/_meta"), + ) + if err != nil { + return nil, errors.Wrap(err, "failed finding modules and datasets") + } + + for _, metaDir := range metaDirs { + // Strip off _meta. + dirs = append(dirs, filepath.Dir(metaDir)) + } + } + return dirs, nil +} + +// findImports expands the given import values in case they contain globs. +func findImports() ([]string, error) { + return mage.FindFiles(importDirs...) +} + +// hasInitMethod returns true if the file contains 'func init()'. +func hasInitMethod(file string) bool { + f, err := os.Open(file) + if err != nil { + log.Fatalf("failed to read from %v: %v", file, err) + } + defer f.Close() + + var initSignature = []byte("func init()") + scanner := bufio.NewScanner(f) + for scanner.Scan() { + if bytes.Contains(scanner.Bytes(), initSignature) { + return true + } + } + if err := scanner.Err(); err != nil { + log.Fatal("failed scanning %v: %v", file, err) + } + return false +} diff --git a/dev-tools/mage/config.go b/dev-tools/mage/config.go index 8f04d73742f6..9c12df03759e 100644 --- a/dev-tools/mage/config.go +++ b/dev-tools/mage/config.go @@ -18,9 +18,12 @@ package mage import ( + "fmt" "io/ioutil" + "log" "os" "path/filepath" + "regexp" "sort" "strings" @@ -28,6 +31,137 @@ import ( "gopkg.in/yaml.v2" ) +// Paths to generated config file templates. +var ( + shortTemplate = filepath.Join("build", BeatName+".yml.tmpl") + referenceTemplate = filepath.Join("build", BeatName+".reference.yml.tmpl") + dockerTemplate = filepath.Join("build", BeatName+".docker.yml.tmpl") +) + +// ConfigFileType is a bitset that indicates what types of config files to +// generate. +type ConfigFileType uint8 + +// Config file types. +const ( + ShortConfigType ConfigFileType = 1 << iota + ReferenceConfigType + DockerConfigType + + AllConfigTypes ConfigFileType = 0xFF +) + +// IsShort return true if ShortConfigType is set. +func (t ConfigFileType) IsShort() bool { return t&ShortConfigType > 0 } + +// IsReference return true if ReferenceConfigType is set. +func (t ConfigFileType) IsReference() bool { return t&ReferenceConfigType > 0 } + +// IsDocker return true if DockerConfigType is set. +func (t ConfigFileType) IsDocker() bool { return t&DockerConfigType > 0 } + +// ConfigFileParams defines the files that make up each config file. +type ConfigFileParams struct { + ShortParts []string // List of files or globs. + ReferenceParts []string // List of files or globs. + DockerParts []string // List of files or globs. + ExtraVars map[string]interface{} +} + +// Config generates config files. Set DEV_OS and DEV_ARCH to change the target +// host for the generated configs. Defaults to linux/amd64. +func Config(types ConfigFileType, args ConfigFileParams, targetDir string) error { + if err := makeConfigTemplates(types, args); err != nil { + return errors.Wrap(err, "failed making config templates") + } + + params := map[string]interface{}{ + "GOOS": EnvOr("DEV_OS", "linux"), + "GOARCH": EnvOr("DEV_ARCH", "amd64"), + "Reference": false, + "Docker": false, + } + for k, v := range args.ExtraVars { + params[k] = v + } + + // Short + if types.IsShort() { + file := filepath.Join(targetDir, BeatName+".yml") + fmt.Printf(">> Building %v for %v/%v\n", file, params["GOOS"], params["GOARCH"]) + if err := ExpandFile(shortTemplate, file, params); err != nil { + return errors.Wrapf(err, "failed building %v", file) + } + } + + // Reference + if types.IsReference() { + file := filepath.Join(targetDir, BeatName+".reference.yml") + params["Reference"] = true + fmt.Printf(">> Building %v for %v/%v\n", file, params["GOOS"], params["GOARCH"]) + if err := ExpandFile(referenceTemplate, file, params); err != nil { + return errors.Wrapf(err, "failed building %v", file) + } + } + + // Docker + if types.IsDocker() { + file := filepath.Join(targetDir, BeatName+".docker.yml") + params["Reference"] = false + params["Docker"] = true + fmt.Printf(">> Building %v for %v/%v\n", file, params["GOOS"], params["GOARCH"]) + if err := ExpandFile(dockerTemplate, file, params); err != nil { + return errors.Wrapf(err, "failed building %v", file) + } + } + + return nil +} + +func makeConfigTemplates(types ConfigFileType, args ConfigFileParams) error { + var err error + + if types.IsShort() { + if err = makeConfigTemplate(shortTemplate, 0600, args.ShortParts...); err != nil { + return err + } + } + + if types.IsReference() { + if err = makeConfigTemplate(referenceTemplate, 0644, args.ReferenceParts...); err != nil { + return err + } + } + + if types.IsDocker() { + if err = makeConfigTemplate(dockerTemplate, 0600, args.DockerParts...); err != nil { + return err + } + } + + return nil +} + +func makeConfigTemplate(destination string, mode os.FileMode, parts ...string) error { + configFiles, err := FindFiles(parts...) + if err != nil { + return errors.Wrap(err, "failed to find config templates") + } + + if IsUpToDate(destination, configFiles...) { + return nil + } + + log.Println(">> Building", destination) + if err = FileConcat(destination, mode, configFiles...); err != nil { + return err + } + if err = FindReplace(destination, regexp.MustCompile("beatname"), "{{.BeatName}}"); err != nil { + return err + } + return FindReplace(destination, regexp.MustCompile("beat-index-prefix"), "{{.BeatIndexPrefix}}") +} + const moduleConfigTemplate = ` #========================== Modules configuration ============================= {{.BeatName}}.modules: diff --git a/dev-tools/mage/docs.go b/dev-tools/mage/docs.go new file mode 100644 index 000000000000..edf0551e6ffb --- /dev/null +++ b/dev-tools/mage/docs.go @@ -0,0 +1,56 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +package mage + +import ( + "log" + "path/filepath" + + "github.com/magefile/mage/sh" +) + +type docsBuilder struct{} + +// Docs holds the utilities for building documentation. +var Docs = docsBuilder{} + +// FieldDocs generates docs/fields.asciidoc from the specified fields.yml file. +func (b docsBuilder) FieldDocs(fieldsYML string) error { + // Run the docs_collector.py script. + ve, err := PythonVirtualenv() + if err != nil { + return err + } + + python, err := LookVirtualenvPath(ve, "python") + if err != nil { + return err + } + + esBeats, err := ElasticBeatsDir() + if err != nil { + return err + } + + log.Println(">> Generating docs/fields.asciidoc for", BeatName) + return sh.Run(python, LibbeatDir("scripts/generate_fields_docs.py"), + filepath.Dir(fieldsYML), // Path to dir containing fields.yml. + BeatName, // Beat title. + esBeats, // Path to general beats folder. + "--output_path", OSSBeatDir()) // It writes to {output_path}/docs/fields.asciidoc. +} diff --git a/dev-tools/mage/fields.go b/dev-tools/mage/fields.go index 62aa95bc654e..6117afed3780 100644 --- a/dev-tools/mage/fields.go +++ b/dev-tools/mage/fields.go @@ -82,7 +82,7 @@ func GenerateFieldsGo(fieldsYML, out string) error { // GenerateModuleFieldsGo generates a fields.go file containing a copy of the // each module's field.yml data in a format that can be embedded in Beat's // binary. -func GenerateModuleFieldsGo() error { +func GenerateModuleFieldsGo(moduleDir string) error { const moduleFieldsCmdPath = "dev-tools/cmd/module_fields/module_fields.go" beatsDir, err := ElasticBeatsDir() @@ -94,7 +94,7 @@ func GenerateModuleFieldsGo() error { filepath.Join(beatsDir, moduleFieldsCmdPath), "-beat", BeatName, "-license", toLibbeatLicenseName(BeatLicense), - filepath.Join(CWD(), "module"), + filepath.Join(CWD(), moduleDir), ) return moduleFieldsCmd() @@ -103,6 +103,15 @@ func GenerateModuleFieldsGo() error { // GenerateModuleIncludeListGo generates an include/list.go file containing // a import statement for each module and dataset. func GenerateModuleIncludeListGo() error { + return GenerateIncludeListGo(nil, []string{ + filepath.Join(CWD(), "module"), + }) +} + +// GenerateIncludeListGo generates an include/list.go file containing imports +// for the packages that match the paths (or globs) in importDirs (optional) +// and moduleDirs (optional). +func GenerateIncludeListGo(importDirs []string, moduleDirs []string) error { const moduleIncludeListCmdPath = "dev-tools/cmd/module_include_list/module_include_list.go" beatsDir, err := ElasticBeatsDir() @@ -113,10 +122,17 @@ func GenerateModuleIncludeListGo() error { includeListCmd := sh.RunCmd("go", "run", filepath.Join(beatsDir, moduleIncludeListCmdPath), "-license", toLibbeatLicenseName(BeatLicense), - filepath.Join(CWD(), "module"), ) - return includeListCmd() + var args []string + for _, dir := range importDirs { + args = append(args, "-import", dir) + } + for _, dir := range moduleDirs { + args = append(args, "-moduleDir", dir) + } + + return includeListCmd(args...) } // toLibbeatLicenseName translates the license type used in packages to diff --git a/packetbeat/Makefile b/packetbeat/Makefile index ab895ce7c560..1ef455d71cf1 100644 --- a/packetbeat/Makefile +++ b/packetbeat/Makefile @@ -3,12 +3,13 @@ BEAT_TITLE?=Packetbeat SYSTEM_TESTS?=true TEST_ENVIRONMENT=false ES_BEATS?=.. +EXCLUDE_COMMON_UPDATE_TARGET=true include ${ES_BEATS}/libbeat/scripts/Makefile -# Collects all dependencies and then calls update -.PHONY: collect -collect: imports +.PHONY: update +update: mage + mage update .PHONY: benchmark benchmark: @@ -17,10 +18,3 @@ benchmark: .PHONY: create-tcp-protocol create-tcp-protocol: python-env @${PYTHON_ENV}/bin/python ${ES_BEATS}/packetbeat/scripts/create_tcp_protocol.py - -# Generates imports for all modules and metricsets -.PHONY: imports -imports: python-env - @mkdir -p include - @mkdir -p protos - @${PYTHON_ENV}/bin/python ${ES_BEATS}/script/generate_imports.py ${BEAT_PATH} diff --git a/packetbeat/_meta/beat.reference.yml b/packetbeat/_meta/beat.reference.yml index 42c4d9da3c2f..69a7490832f2 100644 --- a/packetbeat/_meta/beat.reference.yml +++ b/packetbeat/_meta/beat.reference.yml @@ -11,7 +11,7 @@ # Select the network interface to sniff the data. You can use the "any" # keyword to sniff on all connected interfaces. -packetbeat.interfaces.device: any +packetbeat.interfaces.device: {{ call .device .GOOS }} # Packetbeat supports three sniffer types: # * pcap, which uses the libpcap library and works on most platforms, but it's diff --git a/packetbeat/_meta/beat.yml b/packetbeat/_meta/beat.yml index b4b33a6bf5cf..9547b59ac564 100644 --- a/packetbeat/_meta/beat.yml +++ b/packetbeat/_meta/beat.yml @@ -11,7 +11,7 @@ # Select the network interface to sniff the data. On Linux, you can use the # "any" keyword to sniff on all connected interfaces. -packetbeat.interfaces.device: any +packetbeat.interfaces.device: {{ call .device .GOOS }} #================================== Flows ===================================== diff --git a/packetbeat/include/fields.go b/packetbeat/include/fields.go index aaa9eebd1f58..857e21f161ad 100644 --- a/packetbeat/include/fields.go +++ b/packetbeat/include/fields.go @@ -31,5 +31,5 @@ func init() { // Asset returns asset data func Asset() string { - return "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" + return "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" } diff --git a/packetbeat/include/list.go b/packetbeat/include/list.go index b2ba8aa5f837..5a84aacf54c0 100644 --- a/packetbeat/include/list.go +++ b/packetbeat/include/list.go @@ -15,16 +15,12 @@ // specific language governing permissions and limitations // under the License. -// Code generated by 'make imports' - DO NOT EDIT. +// Code generated by beats/dev-tools/module_include_list/module_include_list.go - DO NOT EDIT. -/* -Package include imports all protos packages so that they register with the global -registry. This package can be imported in the main package to automatically register -all of the standard supported Packetbeat protocols. -*/ package include import ( + // Import packages that need to register themselves. _ "github.com/elastic/beats/packetbeat/protos/amqp" _ "github.com/elastic/beats/packetbeat/protos/applayer" _ "github.com/elastic/beats/packetbeat/protos/cassandra" diff --git a/packetbeat/magefile.go b/packetbeat/magefile.go index ac8deeae9ff1..144b8f32e4bb 100644 --- a/packetbeat/magefile.go +++ b/packetbeat/magefile.go @@ -32,12 +32,19 @@ import ( "github.com/pkg/errors" "github.com/elastic/beats/dev-tools/mage" + packetbeat "github.com/elastic/beats/packetbeat/scripts/mage" ) func init() { mage.BeatDescription = "Packetbeat analyzes network traffic and sends the data to Elasticsearch." } +// Aliases provides compatibility with CI while we transition all Beats +// to having common testing targets. +var Aliases = map[string]interface{}{ + "goTestUnit": GoUnitTest, // dev-tools/jenkins_ci.ps1 uses this. +} + // Build builds the Beat binary. func Build() error { return mage.Build(mage.DefaultBuildArgs()) @@ -119,6 +126,7 @@ func Package() { defer func() { fmt.Println("package ran for", time.Since(start)) }() mage.UseElasticBeatPackaging() + mage.PackageKibanaDashboardsFromBuildDir() customizePackaging() mg.Deps(Update) @@ -131,33 +139,85 @@ func TestPackages() error { return mage.TestPackages() } -// Update updates the generated files (aka make update). -func Update() error { - return sh.Run("make", "update") +// Update updates the generated files. +func Update() { + mg.SerialDeps(Fields, Dashboards, Config, includeList, fieldDocs) +} + +// Config generates the config files. +func Config() error { + return mage.Config(mage.AllConfigTypes, packetbeat.ConfigFileParams(), ".") } -// Fields generates a fields.yml and fields.go for the Beat. +func includeList() error { + return mage.GenerateIncludeListGo([]string{"protos/*"}, nil) +} + +// Fields generates fields.yml and fields.go files for the Beat. func Fields() { - mg.SerialDeps(fieldsYML, mage.GenerateAllInOneFieldsGo) + mg.Deps(libbeatAndPacketbeatCommonFieldsGo, protosFieldsGo) + mg.Deps(fieldsYML) } -// fieldsYML generates the fields.yml file. +// libbeatAndPacketbeatCommonFieldsGo generates a fields.go containing both +// libbeat and packetbeat's common fields. +func libbeatAndPacketbeatCommonFieldsGo() error { + if err := mage.GenerateFieldsYAML(); err != nil { + return err + } + return mage.GenerateAllInOneFieldsGo() +} + +// protosFieldsGo generates a fields.go for each protocol. +func protosFieldsGo() error { + return mage.GenerateModuleFieldsGo("protos") +} + +// fieldsYML generates the fields.yml file containing all fields. func fieldsYML() error { return mage.GenerateFieldsYAML("protos") } -// GoTestUnit executes the Go unit tests. +func fieldDocs() error { + return mage.Docs.FieldDocs("fields.yml") +} + +// Dashboards collects all the dashboards and generates index patterns. +func Dashboards() error { + return mage.KibanaDashboards("protos") +} + +// Fmt formats source code and adds file headers. +func Fmt() { + mg.Deps(mage.Format) +} + +// Check runs fmt and update then returns an error if any modifications are found. +func Check() { + mg.SerialDeps(mage.Format, Update, mage.Check) +} + +// IntegTest executes integration tests (it uses Docker to run the tests). +func IntegTest() { + fmt.Println(">> integTest: Complete (no tests require the integ test environment)") +} + +// UnitTest executes the unit tests. +func UnitTest() { + mg.SerialDeps(GoUnitTest, PythonUnitTest) +} + +// GoUnitTest executes the Go unit tests. // Use TEST_COVERAGE=true to enable code coverage profiling. // Use RACE_DETECTOR=true to enable the race detector. -func GoTestUnit(ctx context.Context) error { +func GoUnitTest(ctx context.Context) error { return mage.GoTest(ctx, mage.DefaultGoTestUnitArgs()) } -// GoTestIntegration executes the Go integration tests. -// Use TEST_COVERAGE=true to enable code coverage profiling. -// Use RACE_DETECTOR=true to enable the race detector. -func GoTestIntegration(ctx context.Context) error { - return mage.GoTest(ctx, mage.DefaultGoTestIntegrationArgs()) +// PythonUnitTest executes the python system tests. +func PythonUnitTest() error { + mg.SerialDeps(Fields, mage.BuildSystemTestBinary) + return mage.PythonNoseTest(mage.DefaultPythonTestUnitArgs()) } // ----------------------------------------------------------------------------- @@ -385,7 +445,7 @@ func generateWin64StaticWinpcap() error { ) } -var pcapGoFile = mage.MustExpand("{{elastic_beats_dir}}/vendor/github.com/tsg/gopacket/pcap/pcap.go") +const pcapGoFile = "{{ elastic_beats_dir }}/vendor/github.com/tsg/gopacket/pcap/pcap.go" var cgoDirectiveRegex = regexp.MustCompile(`(?m)#cgo .*(?:LDFLAGS|CFLAGS).*$`) @@ -393,71 +453,59 @@ func patchCGODirectives() error { // cgo directives do not support GOARM tags so we will clear the tags // and set them via CGO_LDFLAGS and CGO_CFLAGS. // Ref: https://github.com/golang/go/issues/7211 - log.Println("Patching", pcapGoFile, cgoDirectiveRegex.String()) - return mage.FindReplace(pcapGoFile, cgoDirectiveRegex, "") + f := mage.MustExpand(pcapGoFile) + log.Println("Patching", f, cgoDirectiveRegex.String()) + return mage.FindReplace(f, cgoDirectiveRegex, "") } func undoPatchCGODirectives() error { - return sh.Run("git", "checkout", pcapGoFile) + return sh.Run("git", "checkout", mage.MustExpand(pcapGoFile)) } // customizePackaging modifies the device in the configuration files based on // the target OS. func customizePackaging() { var ( - defaultDevice = map[string]string{ - "darwin": "en0", - "windows": "0", - } - configYml = mage.PackageFile{ Mode: 0600, Source: "{{.PackageDir}}/{{.BeatName}}.yml", Config: true, Dep: func(spec mage.PackageSpec) error { - if err := mage.Copy("packetbeat.yml", - spec.MustExpand("{{.PackageDir}}/packetbeat.yml")); err != nil { - return errors.Wrap(err, "failed to copy config") - } - - return mage.FindReplace( - spec.MustExpand("{{.PackageDir}}/packetbeat.yml"), - regexp.MustCompile(`device: any`), "device: "+defaultDevice[spec.OS]) + c := packetbeat.ConfigFileParams() + c.ExtraVars["GOOS"] = spec.OS + c.ExtraVars["GOARCH"] = spec.MustExpand("{{.GOARCH}}") + return mage.Config(mage.ShortConfigType, c, spec.MustExpand("{{.PackageDir}}")) }, } referenceConfigYml = mage.PackageFile{ Mode: 0644, Source: "{{.PackageDir}}/{{.BeatName}}.reference.yml", Dep: func(spec mage.PackageSpec) error { - if err := mage.Copy("packetbeat.yml", - spec.MustExpand("{{.PackageDir}}/packetbeat.reference.yml")); err != nil { - return errors.Wrap(err, "failed to copy config") - } - - return mage.FindReplace( - spec.MustExpand("{{.PackageDir}}/packetbeat.reference.yml"), - regexp.MustCompile(`device: any`), "device: "+defaultDevice[spec.OS]) + c := packetbeat.ConfigFileParams() + c.ExtraVars["GOOS"] = spec.OS + c.ExtraVars["GOARCH"] = spec.MustExpand("{{.GOARCH}}") + return mage.Config(mage.ReferenceConfigType, c, spec.MustExpand("{{.PackageDir}}")) }, } ) for _, args := range mage.Packages { - switch args.OS { - case "windows", "darwin": - if args.Types[0] == mage.DMG { + for _, pkgType := range args.Types { + switch pkgType { + case mage.TarGz, mage.Zip: + args.Spec.ReplaceFile("{{.BeatName}}.yml", configYml) + args.Spec.ReplaceFile("{{.BeatName}}.reference.yml", referenceConfigYml) + case mage.Deb, mage.RPM, mage.DMG: args.Spec.ReplaceFile("/etc/{{.BeatName}}/{{.BeatName}}.yml", configYml) args.Spec.ReplaceFile("/etc/{{.BeatName}}/{{.BeatName}}.reference.yml", referenceConfigYml) - continue + case mage.Docker: + args.Spec.ExtraVar("linux_capabilities", "cap_net_raw,cap_net_admin=eip") + default: + panic(errors.Errorf("unhandled package type: %v", pkgType)) } - args.Spec.ReplaceFile("{{.BeatName}}.yml", configYml) - args.Spec.ReplaceFile("{{.BeatName}}.reference.yml", referenceConfigYml) - } - - pkgType := args.Types[0] - switch pkgType { - case mage.Docker: - args.Spec.ExtraVar("linux_capabilities", "cap_net_raw,cap_net_admin=eip") + // Match the first package type then continue. + break } } } diff --git a/packetbeat/protos/amqp/fields.go b/packetbeat/protos/amqp/fields.go new file mode 100644 index 000000000000..0f52dcc6d489 --- /dev/null +++ b/packetbeat/protos/amqp/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package amqp + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "amqp", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJy0WE1v3DYQvftXDHJqAMtJi1zqQ4EgSQEf3C/kXsyKo9XU1JAmR/vRX19QWmrXXdpdR6pPu5T53tNw5nFmK3ig/S1g9+ivAJTV0i28+Xj/+29vrgAMxTqwV3ZyC2kRoqeaG66BNiQKDZM18eYKDp9urwAAKhDsaEJNf7r3dAvr4Pq8crrhdFMgb/dV7QxNj/J262R9svhE3U8nD2DUOiBBQgJ1gAIUggvXELljiyEttqq+zEg77HwKxof3H66eEam00zORD7TfumAu0/mVdgq08xZZWNagLY0qb845a4sxVmxmhOVnZJtoOtLWmRGxwDQ+XpTq7nOBh3Z1i7I+P+hXxfAX7AhcM8bugPgCWZUo5jF+OUANe29KSdOguF7PRXiMkTfn9CvnLKFcRn/XQCS9BuNAnEIdCPX46u8ee+pLATB9wJVdiDvQY09RATPsf/PTrrb9cm8/KZAjMjzHjb26ypAlXYj9BHAkhW1LAr30kUxBgLhqi3zuFt9EnjI9UthQgC1bO2RBoOidmGRq6fFYdiUXcRL7jkKleGEl3xkS5YYpQOPCgJ5BrmGDlg1sWVuW8VEfQroZUjII2VIekuUNhf2/FLzWYL5OQahSUa2FDKCYTFxNN1XmA8V10exixDVVtevl/Hxep0f6bkUhmdEBNcIhLEOOXMO25bodD21F8DcFl2L6BEdoa/eVodpiIDNuLJn0dJDLCs+wMX3BZwsquF5Z1tUD7ed56f0YqAyYNpfLB+uHxavHOIpD9dDOU62A9YO4rSWzpo5E45Dw+SjLsqyr0f5/ZR1JzDGZDsVdOxGqExRoi/oEzPcry7Elk/6zK2jmphpdap7oz6P3ObF74OZ54+Omos7reZbMYRsQC2RDts7syHKxDpDA2fzisYxP7W7Tuqil+qCD7cyN850YrlEHftSDt48l02KEFZGAD7Rh10e7h4l1zBWOT8BcABSnLQWoLZOUlHe9VfZz+4SPx0qaEF+qJAzrfii5M1q3+otqvYz112EVLaAxnD9m5KH5GgMTXZevyHgDn1CSG7vmCdYGQ4rpoKLYJKMYVBdmZvbxfCfA7IWlauo6Moxzu5g/Dr3TBDddkuWLRkl0gb75/u7+S4Z7vndOU9W7YSJ6XgtJ7QzLef/w7XoyZCECLaGhcEFqjgt/zrgGR6pxOAZNjfVLHVRXmpJfNzw5qTyFyHEIwnffv00mcbryw9uCAh/YBS64+uVtR37jDHUN71Np/ljMwBDIYkIpDaWveuGP3ttUcOnyPME9Gn1p9D6M+24mtTGB4nCLjz9NqCuOSZ7DoGmZxuqIN/14M3x7oRVeMsb5snoxvsodRcXOL/PKE1yJar6LZZa9H5uEAksfKcwO46c02KeeOKEBl7or9H45Gjw5toHtnwAAAP//OIaPDg==" +} diff --git a/packetbeat/protos/applayer/fields.go b/packetbeat/protos/applayer/fields.go new file mode 100644 index 000000000000..0d3219f72ee1 --- /dev/null +++ b/packetbeat/protos/applayer/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package applayer + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "applayer", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJwBAAD//wAAAAE=" +} diff --git a/packetbeat/protos/cassandra/fields.go b/packetbeat/protos/cassandra/fields.go new file mode 100644 index 000000000000..0d2623edb538 --- /dev/null +++ b/packetbeat/protos/cassandra/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package cassandra + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "cassandra", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "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" +} diff --git a/packetbeat/protos/dhcpv4/fields.go b/packetbeat/protos/dhcpv4/fields.go new file mode 100644 index 000000000000..a9e83094a71e --- /dev/null +++ b/packetbeat/protos/dhcpv4/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package dhcpv4 + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "dhcpv4", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "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" +} diff --git a/packetbeat/protos/dns/fields.go b/packetbeat/protos/dns/fields.go new file mode 100644 index 000000000000..79050185f455 --- /dev/null +++ b/packetbeat/protos/dns/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package dns + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "dns", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJzsWV9v3LgRf99PMfBLY9RW4hTtgx8KOF0XCNA6qZ0UdwcDmxE50vIscRQOtevNpz+QlPavduNcEjsHXF6yociZ3/z7zZA5hTtanIO2MgLwxld0Dkfjq5ujEYAmUc403rA9h/HVzak0pExhFNCMrIfCUKUlG0H363wEAHAKFmvqRYY/ftHQOZSO26ZbWd+/fsbo5VJ/rGJbri1uYPrn2geAd1MKKKFBdUcejCbrTWHIAYqY0pKGfAF+StA4Lh3W4KfooSRLDj3p8GlD4MeW3CKLcteEGQHFjQn7OUpzJA1boWy0Yw83E8Wavgw/NwGPYQvhbALZeZ4karwzVgMXCSAYGxdrEsGSsi2ZRmCGVUsBt5DvXcDOlMaiZxcEYScKre6NMzaZtyFuZepqje6xbkLa/O/95fXPuz4oKiwlw9ZP2RmP3sxoJ8g5c0VoH+ani+ilILZzy8LYMrlpFQ4d1oTcLEUMLfQIFlCw2xAYTmmu0dgIGVqJ9sf1jy1JADEQ3GSYI9U6MWwnOENTYV59F/PmU/JTctCpm1EXMWmbhp2PNvb6O+wbUqNhyR8PMEWTGEe7xfgt46QqE0hEG0fKp7zu4uUZmtZJS4C79bjyQLXI4Hq/OziCwmqvuSEhQlWriUaP3zkne5idiYqtGE1ONhhkQ+QS3l4D1JTUnbHlRBsJcX+keEVd6wHbkBKYFn3rKNCO0YnIuOiLyS32muNda1Ug4smAP76tPWyrRIOFceLh72cvIV94kh6oo6ZawJzcNv351lnSAyb0kA/yfc/w4tG3Eul9kEmv3lxeX7+53tWyZKPwz4d3lXVyyyl4IUTCkM7gdTI4fopdOaSmR2MFLNvTxhnrtzgNQE3RofIhfZ/lVPEc/vYS2AHmPCM4e/mP45MgNbAQC61vRxed60jI+o2EBUABEoVN6NMoBGcvQhOiMqq5HY/Hxxm8QnUHUqFMSWK3+thyiFuQ2x3eaoCYywkodM5gSV0E5SSerYwlKIh0Oq/Yzsj51Nhv/QncurhvQ96tjaEm5RMDDYVvPp9nJXNZUaa4HkiWZRhDVh9KlvA95KQjxU7LVvCGdF9cXFwcUKgqFDmkMW4IKr9I6+urAzrJV3rSVK1M2B60looi+RU8N6cVzajqU/cZvfvP+BiCFGBLULMjqDCnajPc/2bXo4opCOHcX89Cy4ejgjnL0WUlV2jLjF2ZHYVOcbS+sD0/EYTuEAVo8uRqYxONJNmguCaBwnEdhgyqc9Ka4hS16NhkQ2ASFnZPvW/Onz9v2rwyStqiMPcRwZB/scZPIXqctXcD+YRW5uRkhy45/5WUfyBbWkDncNHXfzASQRsVu2iYDXNuPRCqaacPhOLHJS1CvtiZq/aOHB3mieLW+q+c+m1b5+RSygq3TtEydztrVgPdB20l65R/SJSXjfbCO0i029TqGeZTo6bgw9S9BQUacpFXBwPc/djDFz2Yh9JFTLIty3cRDQL570/71T+cPEKT+woQQ3Sy9IGvHp4Y3tQUm4ibYRUgCCm2WvqpZiBMNS4gJ1Coplv9KacisI7xIFNuKx22aSMKnQ6d9BdynK5aAjWhXU1O0RPpzOZMzn6lKhuugb1+2JpZPzcBBAhpT97TV295uuEGyOFL5Cwj/YmGrJYNcZzqKOZavC/2QV+XuYzuLv7uGmboO/NVYOzEVsuLX09YkX+3mTk59jDiJ2KrFYAlY20L3bMxpjO7+FeXbsaqqg0tKgU3xnz3vqjYFqZs3XJ+fxtfVXJCf9hFPwhjrgF6BNa8ujkM4WmZU2uTrsKPVnFLjb+35FaQn6jkVgA+U3I7Gx+r5FaKf5CSWwP0VCW3BuFHKbk/B5Y1X/xRhxZufDaj+DZ6KKUuQyp1+wZz5ejF0bBwzV/61vW6ACGfLrneoRVMRNsKSUjpm8t/7TGE7v3EHXqmurz3ZANd9Y9a6T8idmhwZdari/H/L69v9hjX6mYi5tPuc94hEr+m+IDA7i8C78dvocFFxaghCIJnxqYHu+NsNPotAAD//+GWCcg=" +} diff --git a/packetbeat/protos/http/fields.go b/packetbeat/protos/http/fields.go new file mode 100644 index 000000000000..b506f5a8812d --- /dev/null +++ b/packetbeat/protos/http/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package http + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "http", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJzUVMGOnDAMvfMV1p4L6mFPHCr11rlU1WqqHruGmCFdSNjEGYa/rxyY6QykWo32tJzAcd6zn/3I4YWmElrmIQNgzR2V8PBtv//xkAEo8rXTA2trSpBg7geqdaNroCMZhkZTp3yRwfJWZgAAORjs6YIqD08DlXBwNpwjN9g701jXo3wAVjYwcEuRERy9BvIMaBQ48oM1nooF45r0mni5c4knOknkbGtMcVzzDOiw9zdHK6ovq0OAfUvwGshN821ich6sAxEAjtgF8kU6CR0BHlF3WHUE2kSNnuY28p9Puw2VSCY5V9ARxBOfr0cpKqsmGFuaQ7U1TIZzkQO0j9ls4fmUj+OYC1YeXEemtorUc5EUpiVU5NbKzALb6g/VvDqag7/njBeaRuvUfbp+hR6HWDxqo81h7gUHDo7UUtAyTGic7eP5sgTFBu1Xq+v23Ia0vyCJILU1jT4EJ2MoYNdc0kbNbYT12NMGcilBBIpTGBx58dAyiZ68xwN9ko8JRt11UMmoZAGYFFTTBrG2fY8+PQGZaVJ+ptNa/BtlZfXiQthmY8IiS1httuQbXtsk3W822be3Co9snpGDj/nrwdIJ+0F+cY+fH7O0pVuH/i6e+cZ/mb5bhsYGo4o04cexyu2/99/zLq9s0MQ77/TKBrOaLl75GwAA//8kTPxR" +} diff --git a/packetbeat/protos/icmp/fields.go b/packetbeat/protos/icmp/fields.go new file mode 100644 index 000000000000..ad81f63180b7 --- /dev/null +++ b/packetbeat/protos/icmp/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package icmp + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "icmp", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJy0kDFvgzAQhXd+xVP2MFUdGCpVnTpU6tC9cswBVozP9Rkq/n1FMBFKCgNSmPD53vee3xFnGgoY3foMiCZaKnB4f/v4PGRASaKD8dGwK/CSAcB4BfGkTWU0qCcXURmypeQZ0l9x2TzCqZau7PGLg6cCdeBuniwFS1FPQQy76/wmy1dD8wq4QmxoCuYDR9Zs84XQs4g5Wfrule1o4TX5Pd2cn7O7MIF+OpKYtySialoIpgedafjlUK6FfUXTtcohkCrVyRIqDu0ce2avu44ed5aWXb1VThJftjfYmsv97FH8L1s8O6EH1ZXgG747C5vU640l+s7KEj119hcAAP//NUH8pQ==" +} diff --git a/packetbeat/protos/memcache/fields.go b/packetbeat/protos/memcache/fields.go new file mode 100644 index 000000000000..9d5ee248316e --- /dev/null +++ b/packetbeat/protos/memcache/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package memcache + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "memcache", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "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" +} diff --git a/packetbeat/protos/mongodb/fields.go b/packetbeat/protos/mongodb/fields.go new file mode 100644 index 000000000000..ae5dd5e162be --- /dev/null +++ b/packetbeat/protos/mongodb/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package mongodb + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "mongodb", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJysV91u20YTvddTDAIDSQBJwHfriw/ITwO4aGLDdlH0yh6SI3GR/WF2di2rT1/s7JISK8qV4uYqInfOmTk8MztewHfaXoJxdu2aagYQVNB0CW++piefqzczgIa49qoLytlL+P8MACC//bjgjmq1UjXQE9kAK0W64SXct8RUfoFR3jsPtXZMeivhoR3erpyXnwURNsoTdN4FVzstSNCqdUseND2RLmGC8i7F0jOaTtMcHn9E8ttHQNvAoyd20df0+B6w6/QWghsYJFUGZNiQ1ssZFMxLAV2ARUP7ikjC244uYe1d7MqT/Zj9OErFDk8nxev/Xa1GlXv6EYkDtMjgiaMO1ICygDaDziG0ijMx1M4GVJYTwghUjoIhZlwTeArRW2qg2goXk38ivzzIehW1/uS0pjol+g0NnVZC+jwpFuohWBCXJ50CJfmnYmoMZFHeuCxLgwErZMonNyq05ewIYj4iiqzsGhAaF+Dd8v1grhHBOLcv+x7qzw/cK+fEUP9grlC+xvGqVs4tK5wQ2kZTkb93d99Vt5dH9pd2dn2a7ncUsnQZL2nWuDoacXZw4IwKsAAO6EOSZOWdKV3nOQxnk73S02y3dDBVzhRgMaLbtGSLl9KhXUj/saT3jld7K6GvqPdeGKU/qAGDz8pEc6z4auf7YyndlvevTGkqgUHSTk8o0n+RL96Z03j+aMlTj1pHz+JRxZkhma3HPGSTz3IazQf49e76284ZocWQKDxx1vXwK/cqyGPYKGkFGUvgLEEaQ84TkCZRZg6oddJq06q6BRM5gMFQt9J2OFCP8PPnVLbWscnjcM98TGGczY1jVpXecfaRcCFJzuHC+YZ8lf7XKhvmcEHPnUZl59LnF2yx49aFQy2zpb7I2L+j1PCnzvlJabUyqshabsKhtjKyB0sdKj6Vy+5KmBafsG536pfJK/PKrQDLtSKpceuibvbbaDxl+4GobKA1eXhCHQn+N2H2M2X6eChTWTBoz4BilwzdD6NdjIPYNRhEgIY0BTpMK5/4z5IqhNmpHfmV82Z/8kC5ZZRNb8odZwvINpWQEXgOTCSQv2fI6468nOchgRw+jPN+d/iKNqI+LDXPi6vm9JFWJoxqyIZUo98Zshj0+ubh9peb3/5My5ni3MdVzjs7QTTayBZTIod8+4t1ORstW76rjy5ao3yvbX178wmm185/2cye1VEZEma/MgWPljFf5zsVSsIjbVHrB1Z/0VmXSKJKkZAi81qDfi3fdoJDZvzPkeTr4SQWDhginyJOAZXzE0BBmfMT7bE772pi2eASzhH4Bw5H58kLaMm8bTSY1hhsMN0RqRsnSDCG9mGl8en43Eo86VgyR106UgKmXOKpWUZ13qbRm4T8W4bIlPpxnkqo01Ka5nUM7SJa9XyMcf0aRmm/n6F80UMDPFPtbIN+OxDxeUwc0Jy3PX/wlQo+UV59LjegrFOSEhisW2UJDG5hTTYN3Sn7CXc5a1/4E+l+72Ldsbzlnmc5m/0dAAD//4VyuRA=" +} diff --git a/packetbeat/protos/mysql/fields.go b/packetbeat/protos/mysql/fields.go new file mode 100644 index 000000000000..1e9a2f928fcd --- /dev/null +++ b/packetbeat/protos/mysql/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package mysql + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "mysql", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJy8k0FvGyEQhe/7K55y6aXOD9hDL5UPkdJKrXO3MAw26gI2MzTaf1/BktTbrFtblcJlV8B78wFvVvhBYw8/8mnoAHEyUI+7L+Pm2+NdBxhindxRXAw9PnUAUNdWfCTtrNOgnxQE1tFg+L5D++vr1hWC8vTbvgwZj9Rjn2I+tplzxbnKMaUU0+v8i3YX40AqnM0vULbxYCEHmphxypRGJJKcAkMFVP+PkIPjiQKOwSSQCEmZ7rs3UMpa0kJmm+Izv0EbYthfxTUH09F7FabqWWtitnmYcekYRLnAVfTCMDMM2e8oIVoUsvItWwfFAhYl5CnIwnlcYEqydeYm7Ievm/X3p3ahV1I706Dm2PQ8jI2CTGFfgAzZb6eU3ES5WT+uP/+b8uzND9TucWYXbctoyw6ZC4x/ZOJdCeur/4Wv1rgO7ulAxW5q2wanirkysCn6SiFJBVa66D+UtVMmXgpY7bGtjob+o1sKUTVCMXo9Jnbj1EEX63piVnu6tYoLNqJpF6v9CgAA///kpYOQ" +} diff --git a/packetbeat/protos/nfs/fields.go b/packetbeat/protos/nfs/fields.go new file mode 100644 index 000000000000..66116b964f6c --- /dev/null +++ b/packetbeat/protos/nfs/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package nfs + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "nfs", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJykjzFP8zAQhnf/iledv+Yb6JSBBdSNFKliRsa5VCecO8t2IuXfo1RJG5RSBjxZ7/l53vMWnzSUkCYZIHP2VGJT7Y8bA9SUXOSQWaVEtT+i3/1/QArkuGEH6kkyGiZfp8JgupUGALYQ29LsHU8eApU4Re3ClCzfL5meYmKVSz6zXuW0CFfbhahZnfpZAOnaD4qFWTW0LBrf/9xz1vzelu1dXb/D0+Hl9fBWPUMDRTuORuiGSoPTmn6yPS4GOLuvvpH/B41oLcsqZ4GziaDNZZdvLme9Tzf2SdnmLt373bUpUvDDRBTGmK8AAAD//3Ajtg4=" +} diff --git a/packetbeat/protos/pgsql/fields.go b/packetbeat/protos/pgsql/fields.go new file mode 100644 index 000000000000..2a4ba5a5ddbf --- /dev/null +++ b/packetbeat/protos/pgsql/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package pgsql + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "pgsql", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJzEk8GO2jAQhu95il976aXwADlUQisqrRS1LHBHJpkkVh07zNgg3r5yEkoKiVRO9QkN/v199kwW+EXXFG0lJ5MAXntDKd42TnzFtPvM3hKgIMlZt147m+JbAgD3DQtpKdelzkFnsh6lJlPIMsHwK+32L2BVQ3dQXP7aUoqKXWiHyjgxTp0C8fVPdVLotvY1gd2lB/VBKAGTKlCya+BrgmdlReUx/yX+dwokfpk8cbUQs+MRoHc+OmdI2X8z+ig75qbafWaDEJMPbAXKogN8ha+19NeHFgh5eAfPgSasusghdwXNCcRHuHeoDyAGlk9XMc5Wc4iGRFT1GmXIzGoLnYm1n+3m5KG30Fi/dSL6aOhwVibQaGh65nq7/bl9qH1f7VfZQ22z+vHx/ixrQ3Pop/GlJu/W2fp9P3RZl5CQ5yRSBjPX4poi60j813GuHL6FYVSomHjQ6Mju8t8MI3vs9zsAAP//6hY8Lw==" +} diff --git a/packetbeat/protos/redis/fields.go b/packetbeat/protos/redis/fields.go new file mode 100644 index 000000000000..4d04328dee77 --- /dev/null +++ b/packetbeat/protos/redis/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package redis + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "redis", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJyMj71uwzAMhHc9xSFzkwfw0L1r0b1grHMs1JIMkg7gty/8kzZBM5STRPK7Ox7xxbmBMiYLgCcf2ODwvvwPAYi0VtPoqZYGrwEA1tnRRrapSy14ZXF0iUO0U8D+atbVI4pk/sov5fPIBhet07h37olHyictn1cZJv4Mn0a61UfPncJKoXbwnltktDVnKRGpQNBPWQqUEuU8EF3VLH4Kf0JQter/3N+emfViUNo0ODfnskm+wPtk2+1oa3FJxRb+QXJdRaaZXG6nMeI83zkZ9Uo9hfAdAAD//8E/imI=" +} diff --git a/packetbeat/protos/tcp/fields.go b/packetbeat/protos/tcp/fields.go new file mode 100644 index 000000000000..7830c3786bc1 --- /dev/null +++ b/packetbeat/protos/tcp/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package tcp + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "tcp", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJwBAAD//wAAAAE=" +} diff --git a/packetbeat/protos/thrift/fields.go b/packetbeat/protos/thrift/fields.go new file mode 100644 index 000000000000..fea1d05328b2 --- /dev/null +++ b/packetbeat/protos/thrift/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package thrift + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "thrift", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJyUUrGum0AQ7PmK0atjPoAiTV5jKVKiyH205obHKscduj148d9HHCTGzy6cq2A1Mzu7swf84qVB7pN2uQKyZs8GL6dSOPz4/uWlAhytTTpmjaHB5woArgDYyFY7bcGZIaNTemd1he2rKfgDggzcdVpevoxs8JbiNG6VPWVPGyXJYP/KDy39faeeWHwNzH10aMX7lc/MZNAAQT8NEpAoTs6e6GIaJNc4dsg9cXz9eqPYqadBEiGzqF8onwpwJzsZi1fDe8/AmQljNNOzZ30j9i33TO9qm8Tx1dClOJSfgWbyxtJqMrq6utuEMc3a8vlVLDTEdbB9aqsOxODYaaBbNrNNv078oHtinlL4OYuf/sNCgW9cOpwvH80sGdU49WpQA0Mb3epnS+pG8WNq9y75u2Ux8+TFbLGXS0m0yee1+1VnyUptPU+0MWTRYIV0xTzv908AAAD//0KDB+4=" +} diff --git a/packetbeat/protos/tls/fields.go b/packetbeat/protos/tls/fields.go new file mode 100644 index 000000000000..9b57cf28e243 --- /dev/null +++ b/packetbeat/protos/tls/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package tls + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "tls", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "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" +} diff --git a/packetbeat/protos/udp/fields.go b/packetbeat/protos/udp/fields.go new file mode 100644 index 000000000000..239194bb3dcd --- /dev/null +++ b/packetbeat/protos/udp/fields.go @@ -0,0 +1,35 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// Code generated by beats/dev-tools/cmd/asset/asset.go - DO NOT EDIT. + +package udp + +import ( + "github.com/elastic/beats/libbeat/asset" +) + +func init() { + if err := asset.SetFields("packetbeat", "udp", Asset); err != nil { + panic(err) + } +} + +// Asset returns asset data +func Asset() string { + return "eJwBAAD//wAAAAE=" +} diff --git a/packetbeat/scripts/generate_imports_helper.py b/packetbeat/scripts/generate_imports_helper.py deleted file mode 100644 index 9f00b9b8811b..000000000000 --- a/packetbeat/scripts/generate_imports_helper.py +++ /dev/null @@ -1,19 +0,0 @@ -from os.path import abspath, isdir, join -from os import listdir - - -comment = """Package include imports all protos packages so that they register with the global -registry. This package can be imported in the main package to automatically register -all of the standard supported Packetbeat protocols.""" - - -def get_importable_lines(go_beat_path, import_line): - path = abspath("protos") - - imported_protocol_lines = [] - protocols = [p for p in listdir(path) if isdir(join(path, p))] - for protocol in sorted(protocols): - proto_import = import_line.format(beat_path=go_beat_path, module="protos", name=protocol) - imported_protocol_lines.append(proto_import) - - return imported_protocol_lines diff --git a/packetbeat/scripts/mage/config.go b/packetbeat/scripts/mage/config.go new file mode 100644 index 000000000000..b0aab867465c --- /dev/null +++ b/packetbeat/scripts/mage/config.go @@ -0,0 +1,66 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +package mage + +import ( + "github.com/elastic/beats/dev-tools/mage" +) + +const ( + // configTemplateGlob matches Packetbeat protocol config file templates. + configTemplateGlob = "protos/*/_meta/config*.yml.tmpl" +) + +var defaultDevice = map[string]string{ + "darwin": "en0", + "linux": "any", + "windows": "0", +} + +func device(goos string) string { + dev, found := defaultDevice[goos] + if found { + return dev + } + return "any" +} + +// ConfigFileParams returns the default ConfigFileParams for generating +// packetbeat*.yml files. +func ConfigFileParams() mage.ConfigFileParams { + return mage.ConfigFileParams{ + ShortParts: []string{ + mage.OSSBeatDir("_meta/beat.yml"), + configTemplateGlob, + mage.LibbeatDir("_meta/config.yml"), + }, + ReferenceParts: []string{ + mage.OSSBeatDir("_meta/beat.reference.yml"), + configTemplateGlob, + mage.LibbeatDir("_meta/config.reference.yml"), + }, + DockerParts: []string{ + mage.OSSBeatDir("_meta/beat.docker.yml"), + configTemplateGlob, + mage.LibbeatDir("_meta/config.docker.yml"), + }, + ExtraVars: map[string]interface{}{ + "device": device, + }, + } +} diff --git a/packetbeat/tests/system/packetbeat.py b/packetbeat/tests/system/packetbeat.py index d1cc555c2b87..f4220bf9c26b 100644 --- a/packetbeat/tests/system/packetbeat.py +++ b/packetbeat/tests/system/packetbeat.py @@ -51,8 +51,11 @@ def run_packetbeat(self, pcap, "-I", os.path.join(self.beat_path + "/tests/system/pcaps", pcap), "-c", os.path.join(self.working_dir, config), "-systemTest", - "-test.coverprofile", os.path.join(self.working_dir, "coverage.cov"), ]) + if os.getenv("TEST_COVERAGE") == "true": + args += [ + "-test.coverprofile", os.path.join(self.working_dir, "coverage.cov"), + ] if extra_args: args.extend(extra_args) @@ -93,8 +96,11 @@ def start_packetbeat(self, "-e", "-c", os.path.join(self.working_dir, config), "-systemTest", - "-test.coverprofile", os.path.join(self.working_dir, "coverage.cov") ] + if os.getenv("TEST_COVERAGE") == "true": + args += [ + "-test.coverprofile", os.path.join(self.working_dir, "coverage.cov"), + ] if extra_args: args.extend(extra_args) diff --git a/x-pack/filebeat/magefile.go b/x-pack/filebeat/magefile.go index 8bbb16e931f6..edc88fb3fd89 100644 --- a/x-pack/filebeat/magefile.go +++ b/x-pack/filebeat/magefile.go @@ -52,7 +52,11 @@ func Clean() error { // Fields generates a fields.yml and fields.go for each module. func Fields() { - mg.Deps(fieldsYML, mage.GenerateModuleFieldsGo) + mg.Deps(fieldsYML, moduleFieldsGo) +} + +func moduleFieldsGo() error { + return mage.GenerateModuleFieldsGo("module") } // fieldsYML generates a fields.yml based on filebeat + x-pack/filebeat/modules. diff --git a/x-pack/metricbeat/magefile.go b/x-pack/metricbeat/magefile.go index ec32803d643a..1f4635fcc6a3 100644 --- a/x-pack/metricbeat/magefile.go +++ b/x-pack/metricbeat/magefile.go @@ -78,7 +78,11 @@ func TestPackages() error { // Fields generates a fields.yml and fields.go for each module. func Fields() { - mg.Deps(fieldsYML, mage.GenerateModuleFieldsGo) + mg.Deps(fieldsYML, moduleFieldsGo) +} + +func moduleFieldsGo() error { + return mage.GenerateModuleFieldsGo("module") } // fieldsYML generates a fields.yml based on filebeat + x-pack/filebeat/modules.