From 40cab0309348d1030ed33007c81909a9e5978702 Mon Sep 17 00:00:00 2001 From: Matt Layher Date: Fri, 22 Nov 2019 19:14:09 -0500 Subject: [PATCH] procfs: implement parsing of NetSockstat{,6} Signed-off-by: Matt Layher --- fixtures.ttar | 19 +++ internal/util/valueparser.go | 18 ++- internal/util/valueparser_test.go | 13 ++ net_sockstat.go | 158 +++++++++++++++++++++++ net_sockstat_test.go | 201 ++++++++++++++++++++++++++++++ 5 files changed, 407 insertions(+), 2 deletions(-) create mode 100644 net_sockstat.go create mode 100644 net_sockstat_test.go diff --git a/fixtures.ttar b/fixtures.ttar index 38b71fe32..c50a18ace 100644 --- a/fixtures.ttar +++ b/fixtures.ttar @@ -1801,6 +1801,25 @@ proc4 2 2 10853 proc4ops 72 0 0 0 1098 2 0 0 0 0 8179 5896 0 0 0 0 5900 0 0 2 0 2 0 9609 0 2 150 1272 0 0 0 1236 0 0 0 0 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Mode: 644 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +Path: fixtures/proc/net/sockstat +Lines: 6 +sockets: used 1602 +TCP: inuse 35 orphan 0 tw 4 alloc 59 mem 22 +UDP: inuse 12 mem 62 +UDPLITE: inuse 0 +RAW: inuse 0 +FRAG: inuse 0 memory 0 +Mode: 444 +# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +Path: fixtures/proc/net/sockstat6 +Lines: 5 +TCP6: inuse 17 +UDP6: inuse 9 +UDPLITE6: inuse 0 +RAW6: inuse 1 +FRAG6: inuse 0 memory 0 +Mode: 444 +# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Path: fixtures/proc/net/softnet_stat Lines: 1 00015c73 00020e76 F0000769 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 diff --git a/internal/util/valueparser.go b/internal/util/valueparser.go index ac93cb42d..fe2355d3c 100644 --- a/internal/util/valueparser.go +++ b/internal/util/valueparser.go @@ -33,6 +33,9 @@ func NewValueParser(v string) *ValueParser { return &ValueParser{v: v} } +// Int interprets the underlying value as an int and returns that value. +func (vp *ValueParser) Int() int { return int(vp.int64()) } + // PInt64 interprets the underlying value as an int64 and returns a pointer to // that value. func (vp *ValueParser) PInt64() *int64 { @@ -40,16 +43,27 @@ func (vp *ValueParser) PInt64() *int64 { return nil } + v := vp.int64() + return &v +} + +// int64 interprets the underlying value as an int64 and returns that value. +// TODO: export if/when necessary. +func (vp *ValueParser) int64() int64 { + if vp.err != nil { + return 0 + } + // A base value of zero makes ParseInt infer the correct base using the // string's prefix, if any. const base = 0 v, err := strconv.ParseInt(vp.v, base, 64) if err != nil { vp.err = err - return nil + return 0 } - return &v + return v } // PUInt64 interprets the underlying value as an uint64 and returns a pointer to diff --git a/internal/util/valueparser_test.go b/internal/util/valueparser_test.go index d95745a3b..fccdf6337 100644 --- a/internal/util/valueparser_test.go +++ b/internal/util/valueparser_test.go @@ -27,6 +27,19 @@ func TestValueParser(t *testing.T) { ok bool fn func(t *testing.T, vp *util.ValueParser) }{ + { + name: "ok Int", + v: "10", + ok: true, + fn: func(t *testing.T, vp *util.ValueParser) { + want := 10 + got := vp.Int() + + if diff := cmp.Diff(want, got); diff != "" { + t.Fatalf("unexpected integer (-want +got):\n%s", diff) + } + }, + }, { name: "bad PInt64", v: "hello", diff --git a/net_sockstat.go b/net_sockstat.go new file mode 100644 index 000000000..a34c9b862 --- /dev/null +++ b/net_sockstat.go @@ -0,0 +1,158 @@ +// Copyright 2019 The Prometheus Authors +// Licensed 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 procfs + +import ( + "bufio" + "bytes" + "errors" + "fmt" + "io" + "strings" + + "github.com/prometheus/procfs/internal/util" +) + +// A NetSockstat contains the output of /proc/net/sockstat{,6} for IPv4 or IPv6, +// respectively. +type NetSockstat struct { + // Used is non-nil for IPv4 sockstat results, but nil for IPv6. + Used *int + Protocols []NetSockstatProtocol +} + +// A NetSockstatProtocol contains statistics about a given socket protocol. +// Pointer fields indicate that the value may or may not be present on any +// given protocol. +type NetSockstatProtocol struct { + Protocol string + InUse int + Orphan *int + TW *int + Alloc *int + Mem *int + Memory *int +} + +// NetSockstat retrieves IPv4 socket statistics. +func (fs FS) NetSockstat() (*NetSockstat, error) { + return readSockstat(fs.proc.Path("net", "sockstat")) +} + +// NetSockstat6 retrieves IPv6 socket statistics. +func (fs FS) NetSockstat6() (*NetSockstat, error) { + return readSockstat(fs.proc.Path("net", "sockstat6")) +} + +// readSockstat opens and parses a NetSockstat from the input file. +func readSockstat(name string) (*NetSockstat, error) { + // This file is small and can be read with one syscall. + b, err := util.ReadFileNoStat(name) + if err != nil { + return nil, err + } + + stat, err := parseSockstat(bytes.NewReader(b)) + if err != nil { + return nil, fmt.Errorf("failed to read sockstats from %q: %v", name, err) + } + + return stat, nil +} + +// parseSockstat reads the contents of a sockstat file and parses a NetSockstat. +func parseSockstat(r io.Reader) (*NetSockstat, error) { + var stat NetSockstat + s := bufio.NewScanner(r) + for s.Scan() { + // Expect a minimum of a protocol and one key/value pair. + fields := strings.Split(s.Text(), " ") + if len(fields) < 3 { + return nil, fmt.Errorf("malformed sockstat line: %q", s.Text()) + } + + // The remaining fields are key/value pairs. + kvs, err := parseSockstatKVs(fields[1:]) + if err != nil { + return nil, fmt.Errorf("error parsing sockstat key/value pairs from %q: %v", s.Text(), err) + } + + // The first field is the protocol. We must trim its colon suffix. + proto := strings.TrimSuffix(fields[0], ":") + switch proto { + case "sockets": + // Special case: IPv4 has a sockets "used" key/value pair that we + // embed at the top level of the structure. + used := kvs["used"] + stat.Used = &used + default: + // Parse all other lines as individual protocols. + nsp := parseSockstatProtocol(kvs) + nsp.Protocol = proto + stat.Protocols = append(stat.Protocols, nsp) + } + } + + if err := s.Err(); err != nil { + return nil, err + } + + return &stat, nil +} + +// parseSockstatKVs parses a string slice into a map of key/value pairs. +func parseSockstatKVs(kvs []string) (map[string]int, error) { + if len(kvs)%2 != 0 { + return nil, errors.New("odd number of fields in key/value pairs") + } + + // Iterate two values at a time to gather key/value pairs. + out := make(map[string]int, len(kvs)/2) + for i := 0; i < len(kvs); i += 2 { + vp := util.NewValueParser(kvs[i+1]) + out[kvs[i]] = vp.Int() + + if err := vp.Err(); err != nil { + return nil, err + } + } + + return out, nil +} + +// parseSockstatProtocol parses a NetSockstatProtocol from the input kvs map. +func parseSockstatProtocol(kvs map[string]int) NetSockstatProtocol { + var nsp NetSockstatProtocol + for k, v := range kvs { + // Capture the range variable to ensure we get unique pointers for + // each of the optional fields. + v := v + switch k { + case "inuse": + nsp.InUse = v + case "orphan": + nsp.Orphan = &v + case "tw": + nsp.TW = &v + case "alloc": + nsp.Alloc = &v + case "mem": + nsp.Mem = &v + case "memory": + nsp.Memory = &v + } + } + + return nsp +} diff --git a/net_sockstat_test.go b/net_sockstat_test.go new file mode 100644 index 000000000..657d61e8a --- /dev/null +++ b/net_sockstat_test.go @@ -0,0 +1,201 @@ +// Copyright 2019 The Prometheus Authors +// Licensed 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 procfs + +import ( + "strings" + "testing" + + "github.com/google/go-cmp/cmp" +) + +// The majority of test cases are covered in Test_parseSockstat. The top level +// tests just check the basics for integration test purposes. + +func TestNetSockstat(t *testing.T) { + fs, err := NewFS(procTestFixtures) + if err != nil { + t.Fatalf("failed to open procfs: %v", err) + } + + stat, err := fs.NetSockstat() + if err != nil { + t.Fatalf("failed to get sockstat: %v", err) + } + + // IPv4 stats should include Used. + if stat.Used == nil { + t.Fatalf("IPv4 sockstat used value was nil") + } + if diff := cmp.Diff(1602, *stat.Used); diff != "" { + t.Fatalf("unexpected IPv4 used sockets (-want +got):\n%s", diff) + } + + // TCP occurs first; do a basic sanity check. + if diff := cmp.Diff("TCP", stat.Protocols[0].Protocol); diff != "" { + t.Fatalf("unexpected socket protocol (-want +got):\n%s", diff) + } + if diff := cmp.Diff(35, stat.Protocols[0].InUse); diff != "" { + t.Fatalf("unexpected number of TCP sockets (-want +got):\n%s", diff) + } +} + +func TestNetSockstat6(t *testing.T) { + fs, err := NewFS(procTestFixtures) + if err != nil { + t.Fatalf("failed to open procfs: %v", err) + } + + stat, err := fs.NetSockstat6() + if err != nil { + t.Fatalf("failed to get sockstat: %v", err) + } + + // IPv6 stats should not include Used. + if stat.Used != nil { + t.Fatalf("IPv6 sockstat used value was not nil") + } + + // TCP6 occurs first; do a basic sanity check. + if diff := cmp.Diff("TCP6", stat.Protocols[0].Protocol); diff != "" { + t.Fatalf("unexpected socket protocol (-want +got):\n%s", diff) + } + if diff := cmp.Diff(17, stat.Protocols[0].InUse); diff != "" { + t.Fatalf("unexpected number of TCP sockets (-want +got):\n%s", diff) + } +} + +func Test_parseSockstat(t *testing.T) { + tests := []struct { + name string + s string + ok bool + stat *NetSockstat + }{ + { + name: "empty", + ok: true, + stat: &NetSockstat{}, + }, + { + name: "bad line", + s: ` +sockets: used +`, + }, + { + name: "bad key/value pairs", + s: ` +TCP: inuse 32 orphan +`, + }, + { + name: "IPv4", + s: ` +sockets: used 1591 +TCP: inuse 32 orphan 0 tw 0 alloc 58 mem 13 +UDP: inuse 8 mem 115 +UDPLITE: inuse 0 +RAW: inuse 0 +FRAG: inuse 0 memory 0 + `, + ok: true, + stat: &NetSockstat{ + Used: intp(1591), + Protocols: []NetSockstatProtocol{ + { + Protocol: "TCP", + InUse: 32, + Orphan: intp(0), + TW: intp(0), + Alloc: intp(58), + Mem: intp(13), + }, + { + Protocol: "UDP", + InUse: 8, + Mem: intp(115), + }, + { + Protocol: "UDPLITE", + }, + { + Protocol: "RAW", + }, + { + Protocol: "FRAG", + Memory: intp(0), + }, + }, + }, + }, + { + name: "IPv6", + s: ` +TCP6: inuse 24 +UDP6: inuse 9 +UDPLITE6: inuse 0 +RAW6: inuse 1 +FRAG6: inuse 0 memory 0 + `, + ok: true, + stat: &NetSockstat{ + Protocols: []NetSockstatProtocol{ + { + Protocol: "TCP6", + InUse: 24, + }, + { + Protocol: "UDP6", + InUse: 9, + }, + { + Protocol: "UDPLITE6", + }, + { + Protocol: "RAW6", + InUse: 1, + }, + { + Protocol: "FRAG6", + Memory: intp(0), + }, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + stat, err := parseSockstat(strings.NewReader(strings.TrimSpace(tt.s))) + if err != nil { + if tt.ok { + t.Fatalf("failed to parse sockstats: %v", err) + } + + t.Logf("OK error: %v", err) + return + } + if !tt.ok { + t.Fatal("expected an error, but none occurred") + } + + if diff := cmp.Diff(tt.stat, stat); diff != "" { + t.Errorf("unexpected sockstats (-want +got):\n%s", diff) + } + }) + } +} + +func intp(i int) *int { return &i }