Add support for BFD protocol (#58)

client/bird_client.go

@@ -41,7 +41,7 @@ func (c *BirdClient) GetProtocols() ([]*protocol.Protocol, error) {
 }
 
 // GetOSPFAreas retrieves OSPF specific information from bird
-func (c *BirdClient) GetOSPFAreas(protocol *protocol.Protocol) ([]*protocol.OspfArea, error) {
+func (c *BirdClient) GetOSPFAreas(protocol *protocol.Protocol) ([]*protocol.OSPFArea, error) {
 	sock := c.socketFor(protocol.IPVersion)
 	b, err := birdsocket.Query(sock, fmt.Sprintf("show ospf %s", protocol.Name))
 	if err != nil {
@@ -51,6 +51,17 @@ func (c *BirdClient) GetOSPFAreas(protocol *protocol.Protocol) ([]*protocol.Ospf
 	return parser.ParseOSPF(b), nil
 }
 
+// GetBFDSessions retrieves BFD specific information from bird
+func (c *BirdClient) GetBFDSessions(protocol *protocol.Protocol) ([]*protocol.BFDSession, error) {
+	sock := c.socketFor(protocol.IPVersion)
+	b, err := birdsocket.Query(sock, fmt.Sprintf("show bfd sessions %s", protocol.Name))
+	if err != nil {
+		return nil, err
+	}
+
+	return parser.ParseBFDSessions(protocol.Name, b), nil
+}
+
 func (c *BirdClient) protocolsFromBird(ipVersions []string) ([]*protocol.Protocol, error) {
 	protocols := make([]*protocol.Protocol, 0)
 

client/client.go

@@ -9,5 +9,8 @@ type Client interface {
 	GetProtocols() ([]*protocol.Protocol, error)
 
 	// GetOSPFAreas retrieves OSPF specific information from bird
-	GetOSPFAreas(protocol *protocol.Protocol) ([]*protocol.OspfArea, error)
+	GetOSPFAreas(protocol *protocol.Protocol) ([]*protocol.OSPFArea, error)
+
+	// GetBFDSessions retrieves BFD specific information from bird
+	GetBFDSessions(protocol *protocol.Protocol) ([]*protocol.BFDSession, error)
 }

go.mod

@@ -7,16 +7,20 @@ require (
 	github.com/czerwonk/testutils v0.0.0-20170526233935-dd9dabe360d4
 	github.com/prometheus/client_golang v1.12.0
 	github.com/sirupsen/logrus v1.8.1
+	github.com/stretchr/testify v1.4.0
 )
 
 require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/prometheus/client_model v0.2.0 // indirect
 	github.com/prometheus/common v0.32.1 // indirect
 	github.com/prometheus/procfs v0.7.3 // indirect
 	golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 // indirect
 	google.golang.org/protobuf v1.26.0 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
 )

go.sum

@@ -142,8 +142,10 @@ github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+o
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
@@ -453,6 +455,7 @@ google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQ
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

main.go

@@ -12,7 +12,7 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
-const version string = "1.3.0"
+const version string = "1.4.0"
 
 var (
 	showVersion   = flag.Bool("version", false, "Print version information.")
@@ -28,6 +28,7 @@ var (
 	enableDirect  = flag.Bool("proto.direct", true, "Enables metrics for protocol Direct")
 	enableBabel   = flag.Bool("proto.babel", true, "Enables metrics for protocol Babel")
 	enableRPKI    = flag.Bool("proto.rpki", true, "Enables metrics for protocol RPKI")
+	enableBFD     = flag.Bool("proto.bfd", true, "Enables metrics for protocol BFD")
 	// pre bird 2.0
 	bird6Socket       = flag.String("bird.socket6", "/var/run/bird6.ctl", "Socket to communicate with bird6 routing daemon (not compatible with -bird.v2)")
 	birdEnabled       = flag.Bool("bird.ipv4", true, "Get protocols from bird (not compatible with -bird.v2)")
@@ -122,6 +123,9 @@ func enabledProtocols() protocol.Proto {
 	if *enableRPKI {
 		res |= protocol.RPKI
 	}
+	if *enableBFD {
+		res |= protocol.BFD
+	}
 
 	return res
 }

metric_collector.go

@@ -56,6 +56,7 @@ func exportersForLegacy(c *client.BirdClient) map[protocol.Proto][]metrics.Metri
 		protocol.Static: {metrics.NewLegacyMetricExporter("static4", "static6", l)},
 		protocol.Babel:  {metrics.NewLegacyMetricExporter("babel4", "babel6", l)},
 		protocol.RPKI:   {metrics.NewLegacyMetricExporter("rpki4", "rpki6", l)},
+		protocol.BFD:    {metrics.NewBFDExporter(c)},
 	}
 }
 
@@ -71,6 +72,7 @@ func exportersForDefault(c *client.BirdClient, descriptionLabels bool) map[proto
 		protocol.Static: {e},
 		protocol.Babel:  {e},
 		protocol.RPKI:   {e},
+		protocol.BFD:    {metrics.NewBFDExporter(c)},
 	}
 }
 

metrics/bfd_exporter.go

@@ -0,0 +1,73 @@
+package metrics
+
+import (
+	"github.com/czerwonk/bird_exporter/client"
+	"github.com/czerwonk/bird_exporter/protocol"
+	"github.com/prometheus/client_golang/prometheus"
+	log "github.com/sirupsen/logrus"
+)
+
+var (
+	bfdUpDesc       *prometheus.Desc
+	bfdUptimeDesc   *prometheus.Desc
+	bfdIntervalDesc *prometheus.Desc
+	bfdTimoutDesc   *prometheus.Desc
+)
+
+func init() {
+	l := []string{"name", "ip", "interface"}
+	prefix := "bird_bfd_session_"
+	bfdUpDesc = prometheus.NewDesc(prefix+"up", "Session is up", l, nil)
+	bfdUptimeDesc = prometheus.NewDesc(prefix+"uptime_seconds", "Session uptime in seconds", l, nil)
+	bfdIntervalDesc = prometheus.NewDesc(prefix+"interval_seconds", "Session uptime in seconds", l, nil)
+	bfdTimoutDesc = prometheus.NewDesc(prefix+"timeout_seconds", "Session timeout in seconds", l, nil)
+}
+
+type bfdMetricExporter struct {
+	client client.Client
+}
+
+// NewBFDExporter creates a new MetricExporter for BFD metrics
+func NewBFDExporter(client client.Client) MetricExporter {
+	return &bfdMetricExporter{client: client}
+}
+
+func (m *bfdMetricExporter) Describe(ch chan<- *prometheus.Desc) {
+	ch <- bfdUpDesc
+	ch <- bfdUptimeDesc
+	ch <- bfdIntervalDesc
+	ch <- bfdTimoutDesc
+}
+
+func (m *bfdMetricExporter) Export(p *protocol.Protocol, ch chan<- prometheus.Metric, newFormat bool) {
+	if p.Proto != protocol.BFD {
+		return
+	}
+
+	sessions, err := m.client.GetBFDSessions(p)
+	if err != nil {
+		log.Errorln(err)
+		return
+	}
+
+	for _, s := range sessions {
+		m.exportSession(s, p.Name, ch)
+	}
+}
+
+func (m *bfdMetricExporter) exportSession(s *protocol.BFDSession, protocolName string, ch chan<- prometheus.Metric) {
+	l := []string{protocolName, s.IP, s.Interface}
+
+	var up float64
+	var uptime float64
+
+	if s.Up {
+		up = 1
+		uptime = float64(s.Since)
+	}
+
+	ch <- prometheus.MustNewConstMetric(bfdUpDesc, prometheus.GaugeValue, up, l...)
+	ch <- prometheus.MustNewConstMetric(bfdUptimeDesc, prometheus.GaugeValue, uptime, l...)
+	ch <- prometheus.MustNewConstMetric(bfdIntervalDesc, prometheus.GaugeValue, s.Interval, l...)
+	ch <- prometheus.MustNewConstMetric(bfdTimoutDesc, prometheus.GaugeValue, s.Timeout, l...)
+}

metrics/default_label_strategy.go

@@ -82,6 +82,8 @@ func protoString(p *protocol.Protocol) string {
 		return "Babel"
 	case protocol.RPKI:
 		return "RPKI"
+	case protocol.BFD:
+		return "BFD"
 	}
 
 	return ""

parser/bfd.go

@@ -0,0 +1,63 @@
+package parser
+
+import (
+	"bufio"
+	"bytes"
+	"regexp"
+	"strings"
+
+	"github.com/czerwonk/bird_exporter/protocol"
+)
+
+var (
+	bfdSessionRegex *regexp.Regexp
+)
+
+func init() {
+	bfdSessionRegex = regexp.MustCompile(`^([^\s]+)\s+([^\s]+)\s+(Up|Down)\s+(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}|[^\s]+)\s+([0-9\.]+)\s+([0-9\.]+)$`)
+}
+
+type bfdContext struct {
+	line     string
+	sessions []*protocol.BFDSession
+	protocol string
+}
+
+func ParseBFDSessions(protocolName string, data []byte) []*protocol.BFDSession {
+	reader := bytes.NewReader(data)
+	scanner := bufio.NewScanner(reader)
+
+	c := &bfdContext{
+		sessions: make([]*protocol.BFDSession, 0),
+		protocol: protocolName,
+	}
+
+	for scanner.Scan() {
+		c.line = strings.TrimSpace(scanner.Text())
+		parseBFDSessionLine(c)
+	}
+
+	return c.sessions
+}
+
+func parseBFDSessionLine(c *bfdContext) {
+	m := bfdSessionRegex.FindStringSubmatch(c.line)
+	if m == nil {
+		return
+	}
+
+	sess := protocol.BFDSession{
+		ProtocolName: c.protocol,
+		IP:           m[1],
+		Interface:    m[2],
+		Since:        parseUptime(m[4]),
+		Interval:     parseFloat(m[5]),
+		Timeout:      parseFloat(m[6]),
+	}
+
+	if m[3] == "Up" {
+		sess.Up = true
+	}
+
+	c.sessions = append(c.sessions, &sess)
+}

parser/bfd_test.go

@@ -0,0 +1,45 @@
+package parser
+
+import (
+	"testing"
+	"time"
+
+	"github.com/czerwonk/bird_exporter/protocol"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseBFDSessions(t *testing.T) {
+	overrideNowFunc(func() time.Time {
+		return time.Date(2022, 1, 27, 10, 0, 0, 0, time.Local)
+	})
+
+	data := `BIRD 2.0.7 ready.
+bfd1:
+IP address                Interface  State      Since         Interval  Timeout
+192.168.64.9              enp0s2     Up         2022-01-27 09:00:00    0.100    1.000
+192.168.64.10             enp0s2     Down       2022-01-27 08:00:00    0.300    0.000`
+
+	s := ParseBFDSessions("bfd1", []byte(data))
+
+	assert.Equal(t, 2, len(s), "session count")
+
+	s1 := protocol.BFDSession{
+		ProtocolName: "bfd1",
+		IP:           "192.168.64.9",
+		Interface:    "enp0s2",
+		Up:           true,
+		Since:        3600,
+		Interval:     0.1,
+		Timeout:      1,
+	}
+	s2 := protocol.BFDSession{
+		ProtocolName: "bfd1",
+		IP:           "192.168.64.10",
+		Interface:    "enp0s2",
+		Up:           false,
+		Since:        7200,
+		Interval:     0.3,
+		Timeout:      0,
+	}
+	assert.Equal(t, []*protocol.BFDSession{&s1, &s2}, s, "sessions")
+}

parser/helper.go

@@ -0,0 +1,82 @@
+package parser
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+)
+
+var (
+	nowFunc func() time.Time
+)
+
+func init() {
+	nowFunc = func() time.Time {
+		return time.Now()
+	}
+}
+
+func overrideNowFunc(f func() time.Time) {
+	nowFunc = f
+}
+
+func currentTime() time.Time {
+	return nowFunc()
+}
+
+func parseInt(value string) int64 {
+	i, err := strconv.ParseInt(value, 10, 64)
+
+	if err != nil {
+		log.Errorln(err)
+		return 0
+	}
+
+	return i
+}
+
+func parseFloat(value string) float64 {
+	i, err := strconv.ParseFloat(value, 64)
+
+	if err != nil {
+		log.Errorln(err)
+		return 0
+	}
+
+	return i
+}
+
+func parseUptimeForIso(s string) int {
+	start, err := time.ParseInLocation("2006-01-02 15:04:05", s, time.Local)
+	if err != nil {
+		log.Errorln(err)
+		return 0
+	}
+
+	return int(currentTime().Sub(start).Seconds())
+}
+
+func parseUptimeForDuration(duration []string) int {
+	h := parseInt(duration[2])
+	m := parseInt(duration[3])
+	s := parseInt(duration[4])
+	str := fmt.Sprintf("%dh%dm%ds", h, m, s)
+
+	d, err := time.ParseDuration(str)
+	if err != nil {
+		log.Errorln(err)
+		return 0
+	}
+
+	return int(d.Seconds())
+}
+
+func parseUptimeForTimestamp(timestamp string) int {
+	since := parseInt(timestamp)
+
+	s := time.Unix(since, 0)
+	d := currentTime().Sub(s)
+	return int(d.Seconds())
+}

parser/ospf.go

@@ -17,8 +17,8 @@ type ospfRegex struct {
 
 type ospfContext struct {
 	line    string
-	areas   []*protocol.OspfArea
-	current *protocol.OspfArea
+	areas   []*protocol.OSPFArea
+	current *protocol.OSPFArea
 }
 
 func init() {
@@ -30,12 +30,12 @@ func init() {
 
 var ospf *ospfRegex
 
-func ParseOSPF(data []byte) []*protocol.OspfArea {
+func ParseOSPF(data []byte) []*protocol.OSPFArea {
 	reader := bytes.NewReader(data)
 	scanner := bufio.NewScanner(reader)
 
 	c := &ospfContext{
-		areas: make([]*protocol.OspfArea, 0),
+		areas: make([]*protocol.OSPFArea, 0),
 	}
 
 	for scanner.Scan() {
@@ -53,7 +53,7 @@ func parseLineForOspfArea(c *ospfContext) {
 		return
 	}
 
-	a := &protocol.OspfArea{Name: m[1]}
+	a := &protocol.OSPFArea{Name: m[1]}
 	c.current = a
 	c.areas = append(c.areas, a)
 }

parser/parser.go

@@ -3,14 +3,11 @@ package parser
 import (
 	"bufio"
 	"bytes"
-	"fmt"
 	"regexp"
 	"strconv"
 	"strings"
-	"time"
 
 	"github.com/czerwonk/bird_exporter/protocol"
-	log "github.com/sirupsen/logrus"
 )
 
 var (
@@ -129,6 +126,8 @@ func parseProto(val string) protocol.Proto {
 		return protocol.Babel
 	case "RPKI":
 		return protocol.RPKI
+	case "BFD":
+		return protocol.BFD
 	}
 
 	return protocol.PROTO_UNKNOWN
@@ -160,39 +159,6 @@ func parseUptime(value string) int {
 	return parseUptimeForIso(value)
 }
 
-func parseUptimeForIso(s string) int {
-	start, err := time.ParseInLocation("2006-01-02 15:04:05", s, time.Local)
-	if err != nil {
-		log.Errorln(err)
-		return 0
-	}
-
-	return int(time.Since(start).Seconds())
-}
-
-func parseUptimeForDuration(duration []string) int {
-	h := parseInt(duration[2])
-	m := parseInt(duration[3])
-	s := parseInt(duration[4])
-	str := fmt.Sprintf("%dh%dm%ds", h, m, s)
-
-	d, err := time.ParseDuration(str)
-	if err != nil {
-		log.Errorln(err)
-		return 0
-	}
-
-	return int(d.Seconds())
-}
-
-func parseUptimeForTimestamp(timestamp string) int {
-	since := parseInt(timestamp)
-
-	s := time.Unix(since, 0)
-	d := time.Since(s)
-	return int(d.Seconds())
-}
-
 func parseLineForChannel(c *context) {
 	if c.ipVersion != "" || c.current == nil {
 		return
@@ -305,14 +271,3 @@ func parseLineForFilterName(c *context) {
 
 	c.handled = true
 }
-
-func parseInt(value string) int64 {
-	i, err := strconv.ParseInt(value, 10, 64)
-
-	if err != nil {
-		log.Errorln(err)
-		return 0
-	}
-
-	return i
-}

parser/parser_test.go

@@ -9,11 +9,12 @@ import (
 )
 
 func TestEstablishedBgpOldTimeFormat(t *testing.T) {
+	overrideNowFunc(func() time.Time {
+		return time.Date(2018, 1, 1, 2, 0, 0, 0, time.UTC)
+	})
+
 	data := "foo    BGP      master   up     1514768400  Established\ntest\nbar\n  Routes:         12 imported, 1 filtered, 34 exported, 100 preferred\nxxx"
-	s := time.Date(2018, time.January, 1, 1, 0, 0, 0, time.UTC)
-	min := int(time.Since(s).Seconds())
 	p := ParseProtocols([]byte(data), "4")
-	max := int(time.Since(s).Seconds())
 
 	x := p[0]
 	assert.StringEqual("name", "foo", x.Name, t)
@@ -24,7 +25,7 @@ func TestEstablishedBgpOldTimeFormat(t *testing.T) {
 	assert.Int64Equal("filtered", 1, x.Filtered, t)
 	assert.Int64Equal("preferred", 100, x.Preferred, t)
 	assert.StringEqual("ipVersion", "4", x.IPVersion, t)
-	assert.That("uptime", "uptime is feasable", func() bool { return x.Uptime >= min && max <= x.Uptime }, t)
+	assert.Int64Equal("uptime", 3600, int64(x.Uptime), t)
 }
 
 func TestEstablishedBgpCurrentTimeFormat(t *testing.T) {
@@ -45,11 +46,12 @@ func TestEstablishedBgpCurrentTimeFormat(t *testing.T) {
 }
 
 func TestEstablishedBgpIsoLongTimeFormat(t *testing.T) {
+	overrideNowFunc(func() time.Time {
+		return time.Date(2018, 1, 1, 2, 0, 0, 0, time.Local)
+	})
+
 	data := "foo    BGP      master   up     2018-01-01 01:00:00  Established\ntest\nbar\n  Routes:         12 imported, 1 filtered, 34 exported, 100 preferred\nxxx"
-	s := time.Date(2018, time.January, 1, 1, 0, 0, 0, time.UTC)
-	min := int(time.Since(s).Seconds())
 	p := ParseProtocols([]byte(data), "4")
-	max := int(time.Since(s).Seconds())
 
 	assert.IntEqual("protocols", 1, len(p), t)
 
@@ -62,7 +64,7 @@ func TestEstablishedBgpIsoLongTimeFormat(t *testing.T) {
 	assert.Int64Equal("filtered", 1, x.Filtered, t)
 	assert.Int64Equal("preferred", 100, x.Preferred, t)
 	assert.StringEqual("ipVersion", "4", x.IPVersion, t)
-	assert.That("uptime", "uptime is feasable", func() bool { return x.Uptime >= min && max <= x.Uptime }, t)
+	assert.Int64Equal("uptime", 3600, int64(x.Uptime), t)
 }
 
 func TestIpv6BGP(t *testing.T) {

protocol/bfd_session.go

@@ -0,0 +1,11 @@
+package protocol
+
+type BFDSession struct {
+	ProtocolName string
+	IP           string
+	Interface    string
+	Up           bool
+	Since        int
+	Interval     float64
+	Timeout      float64
+}

protocol/ospf_area.go

@@ -1,6 +1,6 @@
 package protocol
 
-type OspfArea struct {
+type OSPFArea struct {
 	Name                  string
 	InterfaceCount        int64
 	NeighborCount         int64

protocol/protocol.go

@@ -9,6 +9,7 @@ const (
 	Direct        = Proto(16)
 	Babel         = Proto(32)
 	RPKI          = Proto(64)
+	BFD           = Proto(128)
 )
 
 type Proto int