CL-Softwares
/
telegraf
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore: Spell endianness correctly (#13752)

This commit is contained in:
Joshua Powers 2023-08-14 02:43:32 -06:00 committed by GitHub
parent f02cd3c94a
commit 013b73213d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 126 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
internal/host_endianess_be.go → internal/host_endianness_be.go
View File

@ -4,4 +4,4 @@ package internal
import "encoding/binary" import "encoding/binary"
var HostEndianess = binary.BigEndian var HostEndianness = binary.BigEndian

2
internal/host_endianess_le.go → internal/host_endianness_le.go
View File

@ -4,4 +4,4 @@ package internal
import "encoding/binary" import "encoding/binary"
var HostEndianess = binary.LittleEndian var HostEndianness = binary.LittleEndian

14
plugins/inputs/modbus/type_conversions16.go
View File

@ -9,7 +9,7 @@ import (
type convert16 func([]byte) uint16 type convert16 func([]byte) uint16
func endianessConverter16(byteOrder string) (convert16, error) { func endiannessConverter16(byteOrder string) (convert16, error) {
switch byteOrder { switch byteOrder {
case "ABCD", "CDAB": // Big endian (Motorola) case "ABCD", "CDAB": // Big endian (Motorola)
return binary.BigEndian.Uint16, nil return binary.BigEndian.Uint16, nil
@ -21,7 +21,7 @@ func endianessConverter16(byteOrder string) (convert16, error) {
// I16 - no scale // I16 - no scale
func determineConverterI16(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterI16(outType, byteOrder string) (fieldConverterFunc, error) {
tohost, err := endianessConverter16(byteOrder) tohost, err := endiannessConverter16(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -49,7 +49,7 @@ func determineConverterI16(outType, byteOrder string) (fieldConverterFunc, error
// U16 - no scale // U16 - no scale
func determineConverterU16(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterU16(outType, byteOrder string) (fieldConverterFunc, error) {
tohost, err := endianessConverter16(byteOrder) tohost, err := endiannessConverter16(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -77,7 +77,7 @@ func determineConverterU16(outType, byteOrder string) (fieldConverterFunc, error
// F16 - no scale // F16 - no scale
func determineConverterF16(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterF16(outType, byteOrder string) (fieldConverterFunc, error) {
tohost, err := endianessConverter16(byteOrder) tohost, err := endiannessConverter16(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -100,7 +100,7 @@ func determineConverterF16(outType, byteOrder string) (fieldConverterFunc, error
// I16 - scale // I16 - scale
func determineConverterI16Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterI16Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
tohost, err := endianessConverter16(byteOrder) tohost, err := endiannessConverter16(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -132,7 +132,7 @@ func determineConverterI16Scale(outType, byteOrder string, scale float64) (field
// U16 - scale // U16 - scale
func determineConverterU16Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterU16Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
tohost, err := endianessConverter16(byteOrder) tohost, err := endiannessConverter16(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -164,7 +164,7 @@ func determineConverterU16Scale(outType, byteOrder string, scale float64) (field
// F16 - scale // F16 - scale
func determineConverterF16Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterF16Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
tohost, err := endianessConverter16(byteOrder) tohost, err := endiannessConverter16(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }

14
plugins/inputs/modbus/type_conversions32.go
View File

@ -18,7 +18,7 @@ func binaryLSWBEU32(b []byte) uint32 {
return uint32(binary.BigEndian.Uint16(b[2:]))<<16 | uint32(binary.BigEndian.Uint16(b[0:])) return uint32(binary.BigEndian.Uint16(b[2:]))<<16 | uint32(binary.BigEndian.Uint16(b[0:]))
} }
func endianessConverter32(byteOrder string) (convert32, error) { func endiannessConverter32(byteOrder string) (convert32, error) {
switch byteOrder { switch byteOrder {
case "ABCD": // Big endian (Motorola) case "ABCD": // Big endian (Motorola)
return binary.BigEndian.Uint32, nil return binary.BigEndian.Uint32, nil
@ -34,7 +34,7 @@ func endianessConverter32(byteOrder string) (convert32, error) {
// I32 - no scale // I32 - no scale
func determineConverterI32(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterI32(outType, byteOrder string) (fieldConverterFunc, error) {
tohost, err := endianessConverter32(byteOrder) tohost, err := endiannessConverter32(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -62,7 +62,7 @@ func determineConverterI32(outType, byteOrder string) (fieldConverterFunc, error
// U32 - no scale // U32 - no scale
func determineConverterU32(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterU32(outType, byteOrder string) (fieldConverterFunc, error) {
tohost, err := endianessConverter32(byteOrder) tohost, err := endiannessConverter32(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -90,7 +90,7 @@ func determineConverterU32(outType, byteOrder string) (fieldConverterFunc, error
// F32 - no scale // F32 - no scale
func determineConverterF32(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterF32(outType, byteOrder string) (fieldConverterFunc, error) {
tohost, err := endianessConverter32(byteOrder) tohost, err := endiannessConverter32(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -113,7 +113,7 @@ func determineConverterF32(outType, byteOrder string) (fieldConverterFunc, error
// I32 - scale // I32 - scale
func determineConverterI32Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterI32Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
tohost, err := endianessConverter32(byteOrder) tohost, err := endiannessConverter32(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -145,7 +145,7 @@ func determineConverterI32Scale(outType, byteOrder string, scale float64) (field
// U32 - scale // U32 - scale
func determineConverterU32Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterU32Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
tohost, err := endianessConverter32(byteOrder) tohost, err := endiannessConverter32(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -177,7 +177,7 @@ func determineConverterU32Scale(outType, byteOrder string, scale float64) (field
// F32 - scale // F32 - scale
func determineConverterF32Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterF32Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
tohost, err := endianessConverter32(byteOrder) tohost, err := endiannessConverter32(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }

14
plugins/inputs/modbus/type_conversions64.go
View File

@ -20,7 +20,7 @@ func binaryLSWBEU64(b []byte) uint64 {
uint64(binary.BigEndian.Uint16(b[2:]))<<16 | uint64(binary.BigEndian.Uint16(b[0:])) uint64(binary.BigEndian.Uint16(b[2:]))<<16 | uint64(binary.BigEndian.Uint16(b[0:]))
} }
func endianessConverter64(byteOrder string) (convert64, error) { func endiannessConverter64(byteOrder string) (convert64, error) {
switch byteOrder { switch byteOrder {
case "ABCD": // Big endian (Motorola) case "ABCD": // Big endian (Motorola)
return binary.BigEndian.Uint64, nil return binary.BigEndian.Uint64, nil
@ -36,7 +36,7 @@ func endianessConverter64(byteOrder string) (convert64, error) {
// I64 - no scale // I64 - no scale
func determineConverterI64(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterI64(outType, byteOrder string) (fieldConverterFunc, error) {
tohost, err := endianessConverter64(byteOrder) tohost, err := endiannessConverter64(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -62,7 +62,7 @@ func determineConverterI64(outType, byteOrder string) (fieldConverterFunc, error
// U64 - no scale // U64 - no scale
func determineConverterU64(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterU64(outType, byteOrder string) (fieldConverterFunc, error) {
tohost, err := endianessConverter64(byteOrder) tohost, err := endiannessConverter64(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -86,7 +86,7 @@ func determineConverterU64(outType, byteOrder string) (fieldConverterFunc, error
// F64 - no scale // F64 - no scale
func determineConverterF64(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterF64(outType, byteOrder string) (fieldConverterFunc, error) {
tohost, err := endianessConverter64(byteOrder) tohost, err := endiannessConverter64(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -103,7 +103,7 @@ func determineConverterF64(outType, byteOrder string) (fieldConverterFunc, error
// I64 - scale // I64 - scale
func determineConverterI64Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterI64Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
tohost, err := endianessConverter64(byteOrder) tohost, err := endiannessConverter64(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -135,7 +135,7 @@ func determineConverterI64Scale(outType, byteOrder string, scale float64) (field
// U64 - scale // U64 - scale
func determineConverterU64Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterU64Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
tohost, err := endianessConverter64(byteOrder) tohost, err := endiannessConverter64(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -167,7 +167,7 @@ func determineConverterU64Scale(outType, byteOrder string, scale float64) (field
// F64 - scale // F64 - scale
func determineConverterF64Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterF64Scale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
tohost, err := endianessConverter64(byteOrder) tohost, err := endiannessConverter64(byteOrder)
if err != nil { if err != nil {
return nil, err return nil, err
} }

18
plugins/inputs/modbus/type_conversions8.go
View File

@ -4,7 +4,7 @@ import (
"fmt" "fmt"
) )
func endianessIndex8(byteOrder string, low bool) (int, error) { func endiannessIndex8(byteOrder string, low bool) (int, error) {
switch byteOrder { switch byteOrder {
case "ABCD": // Big endian (Motorola) case "ABCD": // Big endian (Motorola)
if low { if low {
@ -22,7 +22,7 @@ func endianessIndex8(byteOrder string, low bool) (int, error) {
// I8 lower byte - no scale // I8 lower byte - no scale
func determineConverterI8L(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterI8L(outType, byteOrder string) (fieldConverterFunc, error) {
idx, err := endianessIndex8(byteOrder, true) idx, err := endiannessIndex8(byteOrder, true)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -50,7 +50,7 @@ func determineConverterI8L(outType, byteOrder string) (fieldConverterFunc, error
// I8 higher byte - no scale // I8 higher byte - no scale
func determineConverterI8H(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterI8H(outType, byteOrder string) (fieldConverterFunc, error) {
idx, err := endianessIndex8(byteOrder, false) idx, err := endiannessIndex8(byteOrder, false)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -78,7 +78,7 @@ func determineConverterI8H(outType, byteOrder string) (fieldConverterFunc, error
// U8 lower byte - no scale // U8 lower byte - no scale
func determineConverterU8L(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterU8L(outType, byteOrder string) (fieldConverterFunc, error) {
idx, err := endianessIndex8(byteOrder, true) idx, err := endiannessIndex8(byteOrder, true)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -106,7 +106,7 @@ func determineConverterU8L(outType, byteOrder string) (fieldConverterFunc, error
// U8 higher byte - no scale // U8 higher byte - no scale
func determineConverterU8H(outType, byteOrder string) (fieldConverterFunc, error) { func determineConverterU8H(outType, byteOrder string) (fieldConverterFunc, error) {
idx, err := endianessIndex8(byteOrder, false) idx, err := endiannessIndex8(byteOrder, false)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -134,7 +134,7 @@ func determineConverterU8H(outType, byteOrder string) (fieldConverterFunc, error
// I8 lower byte - scale // I8 lower byte - scale
func determineConverterI8LScale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterI8LScale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
idx, err := endianessIndex8(byteOrder, true) idx, err := endiannessIndex8(byteOrder, true)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -166,7 +166,7 @@ func determineConverterI8LScale(outType, byteOrder string, scale float64) (field
// I8 higher byte - scale // I8 higher byte - scale
func determineConverterI8HScale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterI8HScale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
idx, err := endianessIndex8(byteOrder, false) idx, err := endiannessIndex8(byteOrder, false)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -198,7 +198,7 @@ func determineConverterI8HScale(outType, byteOrder string, scale float64) (field
// U8 lower byte - scale // U8 lower byte - scale
func determineConverterU8LScale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterU8LScale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
idx, err := endianessIndex8(byteOrder, true) idx, err := endiannessIndex8(byteOrder, true)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -226,7 +226,7 @@ func determineConverterU8LScale(outType, byteOrder string, scale float64) (field
// U8 higher byte - scale // U8 higher byte - scale
func determineConverterU8HScale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) { func determineConverterU8HScale(outType, byteOrder string, scale float64) (fieldConverterFunc, error) {
idx, err := endianessIndex8(byteOrder, false) idx, err := endiannessIndex8(byteOrder, false)
if err != nil { if err != nil {
return nil, err return nil, err
} }

8
plugins/inputs/powerdns_recursor/protocol_commons.go
View File

@ -53,9 +53,9 @@ func writeNativeUIntToConn(conn net.Conn, value uint) error {
switch uintSizeInBytes { switch uintSizeInBytes {
case 4: case 4:
internal.HostEndianess.PutUint32(intData, uint32(value)) internal.HostEndianness.PutUint32(intData, uint32(value))
case 8: case 8:
internal.HostEndianess.PutUint64(intData, uint64(value)) internal.HostEndianness.PutUint64(intData, uint64(value))
default: default:
return fmt.Errorf("unsupported system configuration") return fmt.Errorf("unsupported system configuration")
} }
@ -79,9 +79,9 @@ func readNativeUIntFromConn(conn net.Conn) (uint, error) {
switch uintSizeInBytes { switch uintSizeInBytes {
case 4: case 4:
return uint(internal.HostEndianess.Uint32(intData)), nil return uint(internal.HostEndianness.Uint32(intData)), nil
case 8: case 8:
return uint(internal.HostEndianess.Uint64(intData)), nil return uint(internal.HostEndianness.Uint64(intData)), nil
default: default:
return 0, fmt.Errorf("unsupported system configuration") return 0, fmt.Errorf("unsupported system configuration")
} }

2
plugins/inputs/socket_listener/socket_listener.go
View File

@ -88,7 +88,7 @@ func (sl *SocketListener) Init() error {
case "le": case "le":
order = binary.LittleEndian order = binary.LittleEndian
default: default:
return fmt.Errorf("invalid 'endianess' %q", sl.SplittingLengthField.Endianness) return fmt.Errorf("invalid 'endianness' %q", sl.SplittingLengthField.Endianness)
} }
switch sl.SplittingLengthField.Bytes { switch sl.SplittingLengthField.Bytes {

4
plugins/parsers/binary/README.md
View File

@ -21,7 +21,7 @@ user-specified configurations.
## Specify the endianness of the data. ## Specify the endianness of the data.
## Available values are "be" (big-endian), "le" (little-endian) and "host", ## Available values are "be" (big-endian), "le" (little-endian) and "host",
## where "host" means the same endianness as the machine running Telegraf. ## where "host" means the same endianness as the machine running Telegraf.
# endianess = "host" # endianness = "host"
## Interpret input as string containing hex-encoded data. ## Interpret input as string containing hex-encoded data.
# hex_encoding = false # hex_encoding = false
@ -282,7 +282,7 @@ you can use the following configuration
[[inputs.file]] [[inputs.file]]
files = ["messageA.bin", "messageB.bin", "messageC.bin"] files = ["messageA.bin", "messageB.bin", "messageC.bin"]
data_format = "binary" data_format = "binary"
endianess = "le" endianness = "le"
[[inputs.file.binary]] [[inputs.file.binary]]
metric_name = "messageA" metric_name = "messageA"

8
plugins/parsers/binary/entry_test.go
View File

@ -20,7 +20,7 @@ func TestEntryConvertType(t *testing.T) {
testdata := []byte{0x01, 0x02, 0x03, 0x04} testdata := []byte{0x01, 0x02, 0x03, 0x04}
e := &Entry{Type: "garbage"} e := &Entry{Type: "garbage"}
_, err := e.convertType(testdata, internal.HostEndianess) _, err := e.convertType(testdata, internal.HostEndianness)
require.EqualError(t, err, `cannot handle type "garbage"`) require.EqualError(t, err, `cannot handle type "garbage"`)
} }
@ -28,16 +28,16 @@ func TestEntryConvertTimeType(t *testing.T) {
testdata := []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09} testdata := []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09}
e := &Entry{Type: "unix_ns", location: time.UTC} e := &Entry{Type: "unix_ns", location: time.UTC}
_, err := e.convertTimeType(testdata, internal.HostEndianess) _, err := e.convertTimeType(testdata, internal.HostEndianness)
require.EqualError(t, err, `too many bytes 9 vs 8`) require.EqualError(t, err, `too many bytes 9 vs 8`)
} }
func TestConvertNumericType(t *testing.T) { func TestConvertNumericType(t *testing.T) {
testdata := []byte{0x01, 0x02, 0x03, 0x04} testdata := []byte{0x01, 0x02, 0x03, 0x04}
_, err := convertNumericType(testdata, "garbage", internal.HostEndianess) _, err := convertNumericType(testdata, "garbage", internal.HostEndianness)
require.EqualError(t, err, `cannot determine length for type "garbage"`) require.EqualError(t, err, `cannot determine length for type "garbage"`)
_, err = convertNumericType(testdata, "uint8", internal.HostEndianess) _, err = convertNumericType(testdata, "uint8", internal.HostEndianness)
require.EqualError(t, err, `too many bytes 4 vs 1`) require.EqualError(t, err, `too many bytes 4 vs 1`)
} }

13
plugins/parsers/binary/parser.go
View File

@ -15,7 +15,8 @@ import (
type Parser struct { type Parser struct {
AllowNoMatch bool `toml:"allow_no_match"` AllowNoMatch bool `toml:"allow_no_match"`
Endianess string `toml:"endianess"` Endianess string `toml:"endianess" deprecated:"1.27.4;use 'endianness' instead"`
Endianness string `toml:"endianness"`
Configs []Config `toml:"binary"` Configs []Config `toml:"binary"`
HexEncoding bool `toml:"hex_encoding"` HexEncoding bool `toml:"hex_encoding"`
Log telegraf.Logger `toml:"-"` Log telegraf.Logger `toml:"-"`
@ -26,15 +27,19 @@ type Parser struct {
} }
func (p *Parser) Init() error { func (p *Parser) Init() error {
switch p.Endianess { if p.Endianess != "" && p.Endianness == "" {
p.Endianness = p.Endianess
}
switch p.Endianness {
case "le": case "le":
p.converter = binary.LittleEndian p.converter = binary.LittleEndian
case "be": case "be":
p.converter = binary.BigEndian p.converter = binary.BigEndian
case "", "host": case "", "host":
p.converter = internal.HostEndianess p.converter = internal.HostEndianness
default: default:
return fmt.Errorf("unknown endianess %q", p.Endianess) return fmt.Errorf("unknown endianness %q", p.Endianness)
} }
// Pre-process the configurations // Pre-process the configurations

144
plugins/parsers/binary/parser_test.go
View File

@ -50,43 +50,43 @@ func generateBinary(data []interface{}, order binary.ByteOrder) ([]byte, error)
return buf.Bytes(), nil return buf.Bytes(), nil
} }
func determineEndianess(endianess string) binary.ByteOrder { func determineEndianness(endianness string) binary.ByteOrder {
switch endianess { switch endianness {
case "le": case "le":
return binary.LittleEndian return binary.LittleEndian
case "be": case "be":
return binary.BigEndian return binary.BigEndian
case "host": case "host":
return internal.HostEndianess return internal.HostEndianness
} }
panic(fmt.Errorf("unknown endianess %q", endianess)) panic(fmt.Errorf("unknown endianness %q", endianness))
} }
func TestInitInvalid(t *testing.T) { func TestInitInvalid(t *testing.T) {
var tests = []struct { var tests = []struct {
name string name string
metric string metric string
config []Config config []Config
endianess string endianness string
expected string expected string
}{ }{
{ {
name: "wrong endianess", name: "wrong endianness",
metric: "binary", metric: "binary",
endianess: "garbage", endianness: "garbage",
expected: `unknown endianess "garbage"`, expected: `unknown endianness "garbage"`,
}, },
{ {
name: "empty configuration", name: "empty configuration",
metric: "binary", metric: "binary",
endianess: "host", endianness: "host",
expected: `no configuration given`, expected: `no configuration given`,
}, },
{ {
name: "no metric name", name: "no metric name",
config: []Config{{}}, config: []Config{{}},
endianess: "host", endianness: "host",
expected: `config 0 invalid: no metric name given`, expected: `config 0 invalid: no metric name given`,
}, },
{ {
name: "no field", name: "no field",
@ -128,7 +128,7 @@ func TestInitInvalid(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
parser := &Parser{ parser := &Parser{
Endianess: tt.endianess, Endianness: tt.endianness,
Log: testutil.Logger{Name: "parsers.binary"}, Log: testutil.Logger{Name: "parsers.binary"},
metricName: tt.metric, metricName: tt.metric,
} }
@ -219,7 +219,7 @@ func TestFilterNoMatch(t *testing.T) {
} }
require.NoError(t, parser.Init()) require.NoError(t, parser.Init())
data, err := generateBinary(testdata, internal.HostEndianess) data, err := generateBinary(testdata, internal.HostEndianness)
require.NoError(t, err) require.NoError(t, err)
_, err = parser.Parse(data) _, err = parser.Parse(data)
@ -240,7 +240,7 @@ func TestFilterNoMatch(t *testing.T) {
} }
require.NoError(t, parser.Init()) require.NoError(t, parser.Init())
data, err := generateBinary(testdata, internal.HostEndianess) data, err := generateBinary(testdata, internal.HostEndianness)
require.NoError(t, err) require.NoError(t, err)
metrics, err := parser.Parse(data) metrics, err := parser.Parse(data)
@ -259,53 +259,53 @@ func TestFilterNone(t *testing.T) {
} }
var tests = []struct { var tests = []struct {
name string name string
data []interface{} data []interface{}
filter *Filter filter *Filter
endianess string endianness string
}{ }{
{ {
name: "no filter (BE)", name: "no filter (BE)",
data: testdata, data: testdata,
filter: nil, filter: nil,
endianess: "be", endianness: "be",
}, },
{ {
name: "no filter (LE)", name: "no filter (LE)",
data: testdata, data: testdata,
filter: nil, filter: nil,
endianess: "le", endianness: "le",
}, },
{ {
name: "no filter (host)", name: "no filter (host)",
data: testdata, data: testdata,
filter: nil, filter: nil,
endianess: "host", endianness: "host",
}, },
{ {
name: "empty filter (BE)", name: "empty filter (BE)",
data: testdata, data: testdata,
filter: &Filter{}, filter: &Filter{},
endianess: "be", endianness: "be",
}, },
{ {
name: "empty filter (LE)", name: "empty filter (LE)",
data: testdata, data: testdata,
filter: &Filter{}, filter: &Filter{},
endianess: "le", endianness: "le",
}, },
{ {
name: "empty filter (host)", name: "empty filter (host)",
data: testdata, data: testdata,
filter: &Filter{}, filter: &Filter{},
endianess: "host", endianness: "host",
}, },
} }
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
parser := &Parser{ parser := &Parser{
Endianess: tt.endianess, Endianness: tt.endianness,
Configs: []Config{ Configs: []Config{
{ {
Filter: tt.filter, Filter: tt.filter,
@ -317,7 +317,7 @@ func TestFilterNone(t *testing.T) {
} }
require.NoError(t, parser.Init()) require.NoError(t, parser.Init())
order := determineEndianess(tt.endianess) order := determineEndianness(tt.endianness)
data, err := generateBinary(tt.data, order) data, err := generateBinary(tt.data, order)
require.NoError(t, err) require.NoError(t, err)
@ -390,7 +390,7 @@ func TestFilterLength(t *testing.T) {
} }
require.NoError(t, parser.Init()) require.NoError(t, parser.Init())
data, err := generateBinary(tt.data, internal.HostEndianess) data, err := generateBinary(tt.data, internal.HostEndianness)
require.NoError(t, err) require.NoError(t, err)
metrics, err := parser.Parse(data) metrics, err := parser.Parse(data)
@ -652,18 +652,18 @@ func TestParseLineInvalid(t *testing.T) {
} }
for _, tt := range tests { for _, tt := range tests {
for _, endianess := range []string{"be", "le", "host"} { for _, endianness := range []string{"be", "le", "host"} {
name := fmt.Sprintf("%s (%s)", tt.name, endianess) name := fmt.Sprintf("%s (%s)", tt.name, endianness)
t.Run(name, func(t *testing.T) { t.Run(name, func(t *testing.T) {
parser := &Parser{ parser := &Parser{
Endianess: endianess, Endianness: endianness,
Configs: tt.configs, Configs: tt.configs,
Log: testutil.Logger{Name: "parsers.binary"}, Log: testutil.Logger{Name: "parsers.binary"},
metricName: "binary", metricName: "binary",
} }
require.NoError(t, parser.Init()) require.NoError(t, parser.Init())
order := determineEndianess(endianess) order := determineEndianness(endianness)
data, err := generateBinary(tt.data, order) data, err := generateBinary(tt.data, order)
require.NoError(t, err) require.NoError(t, err)
@ -738,12 +738,12 @@ func TestParseLine(t *testing.T) {
} }
for _, tt := range tests { for _, tt := range tests {
for _, endianess := range []string{"be", "le", "host"} { for _, endianness := range []string{"be", "le", "host"} {
name := fmt.Sprintf("%s (%s)", tt.name, endianess) name := fmt.Sprintf("%s (%s)", tt.name, endianness)
t.Run(name, func(t *testing.T) { t.Run(name, func(t *testing.T) {
parser := &Parser{ parser := &Parser{
AllowNoMatch: true, AllowNoMatch: true,
Endianess: endianess, Endianness: endianness,
Configs: []Config{{ Configs: []Config{{
Filter: tt.filter, Filter: tt.filter,
Entries: tt.entries, Entries: tt.entries,
@ -753,7 +753,7 @@ func TestParseLine(t *testing.T) {
} }
require.NoError(t, parser.Init()) require.NoError(t, parser.Init())
order := determineEndianess(endianess) order := determineEndianness(endianness)
data, err := generateBinary(tt.data, order) data, err := generateBinary(tt.data, order)
require.NoError(t, err) require.NoError(t, err)
@ -851,18 +851,18 @@ func TestParseInvalid(t *testing.T) {
} }
for _, tt := range tests { for _, tt := range tests {
for _, endianess := range []string{"be", "le", "host"} { for _, endianness := range []string{"be", "le", "host"} {
name := fmt.Sprintf("%s (%s)", tt.name, endianess) name := fmt.Sprintf("%s (%s)", tt.name, endianness)
t.Run(name, func(t *testing.T) { t.Run(name, func(t *testing.T) {
parser := &Parser{ parser := &Parser{
Endianess: endianess, Endianness: endianness,
Configs: []Config{{Entries: tt.entries}}, Configs: []Config{{Entries: tt.entries}},
Log: testutil.Logger{Name: "parsers.binary"}, Log: testutil.Logger{Name: "parsers.binary"},
metricName: "binary", metricName: "binary",
} }
require.NoError(t, parser.Init()) require.NoError(t, parser.Init())
order := determineEndianess(endianess) order := determineEndianness(endianness)
data, err := generateBinary(tt.data, order) data, err := generateBinary(tt.data, order)
require.NoError(t, err) require.NoError(t, err)
@ -1376,18 +1376,18 @@ func TestParse(t *testing.T) {
} }
for _, tt := range tests { for _, tt := range tests {
for _, endianess := range []string{"be", "le", "host"} { for _, endianness := range []string{"be", "le", "host"} {
name := fmt.Sprintf("%s (%s)", tt.name, endianess) name := fmt.Sprintf("%s (%s)", tt.name, endianness)
t.Run(name, func(t *testing.T) { t.Run(name, func(t *testing.T) {
parser := &Parser{ parser := &Parser{
Endianess: endianess, Endianness: endianness,
Configs: []Config{{Entries: tt.entries}}, Configs: []Config{{Entries: tt.entries}},
Log: testutil.Logger{Name: "parsers.binary"}, Log: testutil.Logger{Name: "parsers.binary"},
metricName: "binary", metricName: "binary",
} }
require.NoError(t, parser.Init()) require.NoError(t, parser.Init())
order := determineEndianess(endianess) order := determineEndianness(endianness)
data, err := generateBinary(tt.data, order) data, err := generateBinary(tt.data, order)
require.NoError(t, err) require.NoError(t, err)
@ -1478,7 +1478,7 @@ func TestHexEncoding(t *testing.T) {
} }
parser := &Parser{ parser := &Parser{
Endianess: "be", Endianness: "be",
HexEncoding: true, HexEncoding: true,
Configs: []Config{ Configs: []Config{
{ {

2
plugins/parsers/binary/testcases/multiple_messages/telegraf.conf
View File

@ -1,7 +1,7 @@
[[inputs.file]] [[inputs.file]]
files = ["./testcases/multiple_messages/messageA.bin", "./testcases/multiple_messages/messageB.bin", "./testcases/multiple_messages/messageC.bin"] files = ["./testcases/multiple_messages/messageA.bin", "./testcases/multiple_messages/messageB.bin", "./testcases/multiple_messages/messageC.bin"]
data_format = "binary" data_format = "binary"
endianess = "le" endianness = "le"
[[inputs.file.binary]] [[inputs.file.binary]]
metric_name = "metricA" metric_name = "metricA"

2
plugins/processors/parser/parser.go
View File

@ -164,7 +164,7 @@ func (p *Parser) toBytes(value interface{}) ([]byte, error) {
} }
var buf bytes.Buffer var buf bytes.Buffer
if err := gobin.Write(&buf, internal.HostEndianess, value); err != nil { if err := gobin.Write(&buf, internal.HostEndianness, value); err != nil {
return nil, err return nil, err
} }