mirrors/bird_exporter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

bird client refactoring to support protocol specific ad hoc requests

Browse Source
This commit is contained in:
Daniel Czerwonk 2017-12-31 17:12:43 +01:00
parent 48384e8613
commit 176ec6f113
5 changed files with 122 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
bird_client.go
View File

@ -1,51 +0,0 @@
package main
import (
"github.com/czerwonk/bird_exporter/parser"
"github.com/czerwonk/bird_exporter/protocol"
"github.com/czerwonk/bird_socket"
)
func getProtocols() ([]*protocol.Protocol, error) {
var protocols []*protocol.Protocol = nil
var err error = nil
if *birdV2 {
protocols, err = getProtocolsFromBird(*birdSocket, "")
} else {
protocols, err = getProtocolsFromBird1()
}
return protocols, err
}
func getProtocolsFromBird1() ([]*protocol.Protocol, error) {
protocols := make([]*protocol.Protocol, 0)
if *birdEnabled {
s, err := getProtocolsFromBird(*birdSocket, "4")
if err != nil {
return nil, err
}
protocols = append(protocols, s...)
}
if *bird6Enabled {
s, err := getProtocolsFromBird(*bird6Socket, "6")
if err != nil {
return nil, err
}
protocols = append(protocols, s...)
}
return protocols, nil
}
func getProtocolsFromBird(socketPath string, ipVersion string) ([]*protocol.Protocol, error) {
b, err := birdsocket.Query(socketPath, "show protocols all")
if err != nil {
return nil, err
}
return parser.Parse(b, ipVersion), nil
}

69
client/bird_client.go Normal file
View File

@ -0,0 +1,69 @@
package client
import (
"github.com/czerwonk/bird_exporter/parser"
"github.com/czerwonk/bird_exporter/protocol"
"github.com/czerwonk/bird_socket"
)
type BirdClient struct {
Options *BirdClientOptions
}
type BirdClientOptions struct {
BirdV2 bool
BirdEnabled bool
Bird6Enabled bool
BirdSocket string
Bird6Socket string
}
func (c *BirdClient) GetProtocols() ([]*protocol.Protocol, error) {
ipVersions := make([]string, 0)
if c.Options.BirdV2 {
ipVersions = append(ipVersions, "")
} else {
if c.Options.BirdEnabled {
ipVersions = append(ipVersions, "4")
}
if c.Options.Bird6Enabled {
ipVersions = append(ipVersions, "6")
}
}
return c.getProtocolsFromBird(ipVersions)
}
func (c *BirdClient) getProtocolsFromBird(ipVersions []string) ([]*protocol.Protocol, error) {
protocols := make([]*protocol.Protocol, 0)
for _, ipVersion := range ipVersions {
sock := c.socketFor(ipVersion)
s, err := c.getProtocolsFromSocket(sock, ipVersion)
if err != nil {
return nil, err
}
protocols = append(protocols, s...)
}
return protocols, nil
}
func (c *BirdClient) getProtocolsFromSocket(socketPath string, ipVersion string) ([]*protocol.Protocol, error) {
b, err := birdsocket.Query(socketPath, "show protocols all")
if err != nil {
return nil, err
}
return parser.Parse(b, ipVersion), nil
}
func (c *BirdClient) socketFor(ipVersion string) string {
if !c.Options.BirdV2 && ipVersion == "6" {
return c.Options.Bird6Socket
}
return c.Options.BirdSocket
}

40
main.go
View File

@ -12,7 +12,7 @@ import (
"github.com/prometheus/common/log"
)
const version string = "1.1.0"
const version string = "1.2.0"
var (
showVersion = flag.Bool("version", false, "Print version information.")
@ -76,41 +76,21 @@ func startServer() {
</body>
</html>`))
})
http.HandleFunc(*metricsPath, errorHandler(handleMetricsRequest))
http.HandleFunc(*metricsPath, handleMetricsRequest)
log.Infof("Listening for %s on %s\n", *metricsPath, *listenAddress)
log.Fatal(http.ListenAndServe(*listenAddress, nil))
}
func errorHandler(f func(http.ResponseWriter, *http.Request) error) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
err := f(w, r)
func handleMetricsRequest(w http.ResponseWriter, r *http.Request) {
reg := prometheus.NewRegistry()
p := enabledProtocols()
c := NewMetricCollector(*newFormat, p)
reg.MustRegister(c)
if err != nil {
log.Errorln(err)
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
}
func handleMetricsRequest(w http.ResponseWriter, r *http.Request) error {
protocols, err := getProtocols()
if err != nil {
return err
}
if len(protocols) > 0 {
reg := prometheus.NewRegistry()
p := enabledProtocols()
c := NewMetricCollectorForProtocols(protocols, *newFormat, p)
reg.MustRegister(c)
promhttp.HandlerFor(reg, promhttp.HandlerOpts{
ErrorLog: log.NewErrorLogger(),
ErrorHandling: promhttp.ContinueOnError}).ServeHTTP(w, r)
}
return nil
promhttp.HandlerFor(reg, promhttp.HandlerOpts{
ErrorLog: log.NewErrorLogger(),
ErrorHandling: promhttp.ContinueOnError}).ServeHTTP(w, r)
}
func enabledProtocols() int {
res := 0

41
metric_collector.go
View File

@ -5,39 +5,54 @@ import (
"github.com/czerwonk/bird_exporter/ospf"
"github.com/czerwonk/bird_exporter/protocol"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/common/log"
"github.com/czerwonk/bird_exporter/client"
)
type MetricCollector struct {
protocols []*protocol.Protocol
exporters map[int][]metrics.MetricExporter
client *client.BirdClient
enabledProtocols int
}
func NewMetricCollectorForProtocols(protocols []*protocol.Protocol, newFormat bool, enabledProtocols int) *MetricCollector {
func NewMetricCollector(newFormat bool, enabledProtocols int) *MetricCollector {
c := getClient()
var e map[int][]metrics.MetricExporter
if newFormat {
e = exportersForDefault()
e = exportersForDefault(c)
} else {
e = exportersForLegacy()
e = exportersForLegacy(c)
}
return &MetricCollector{protocols: protocols, exporters: e, enabledProtocols: enabledProtocols}
return &MetricCollector{exporters: e, client: c, enabledProtocols: enabledProtocols}
}
func exportersForLegacy() map[int][]metrics.MetricExporter {
func getClient() *client.BirdClient {
o := &client.BirdClientOptions{
BirdSocket: *birdSocket,
Bird6Socket: *bird6Socket,
Bird6Enabled: *bird6Enabled,
BirdEnabled: *birdEnabled,
BirdV2: *birdV2,
}
return &client.BirdClient{Options: o}
}
func exportersForLegacy(c *client.BirdClient) map[int][]metrics.MetricExporter {
l := &metrics.LegacyLabelStrategy{}
return map[int][]metrics.MetricExporter{
protocol.BGP: []metrics.MetricExporter{metrics.NewLegacyMetricExporter("bgp4_session", "bgp6_session", l)},
protocol.Direct: []metrics.MetricExporter{metrics.NewLegacyMetricExporter("direct4", "direct6", l)},
protocol.Kernel: []metrics.MetricExporter{metrics.NewLegacyMetricExporter("kernel4", "kernel6", l)},
protocol.OSPF: []metrics.MetricExporter{metrics.NewLegacyMetricExporter("ospf", "ospfv3", l), ospf.NewExporter("")},
protocol.OSPF: []metrics.MetricExporter{metrics.NewLegacyMetricExporter("ospf", "ospfv3", l), ospf.NewExporter("", c), },
protocol.Static: []metrics.MetricExporter{metrics.NewLegacyMetricExporter("static4", "static6", l)},
}
}
func exportersForDefault() map[int][]metrics.MetricExporter {
func exportersForDefault(c *client.BirdClient) map[int][]metrics.MetricExporter {
l := &metrics.DefaultLabelStrategy{}
e := metrics.NewGenericProtocolMetricExporter("bird_protocol", true, l)
@ -45,7 +60,7 @@ func exportersForDefault() map[int][]metrics.MetricExporter {
protocol.BGP: []metrics.MetricExporter{e},
protocol.Direct: []metrics.MetricExporter{e},
protocol.Kernel: []metrics.MetricExporter{e},
protocol.OSPF: []metrics.MetricExporter{e, ospf.NewExporter("bird_")},
protocol.OSPF: []metrics.MetricExporter{e, ospf.NewExporter("bird_", c), },
protocol.Static: []metrics.MetricExporter{e},
}
}
@ -59,7 +74,13 @@ func (m *MetricCollector) Describe(ch chan<- *prometheus.Desc) {
}
func (m *MetricCollector) Collect(ch chan<- prometheus.Metric) {
for _, p := range m.protocols {
protocols, err := m.client.GetProtocols()
if err != nil {
log.Errorln(err)
return
}
for _, p := range protocols {
if p.Proto == protocol.PROTO_UNKNOWN || (m.enabledProtocols & p.Proto != p.Proto) {
continue
}

14
ospf/exporter.go
View File

@ -4,22 +4,27 @@ import (
"github.com/czerwonk/bird_exporter/metrics"
"github.com/czerwonk/bird_exporter/protocol"
"github.com/prometheus/client_golang/prometheus"
"github.com/czerwonk/bird_exporter/client"
)
type desc struct {
runningDesc *prometheus.Desc
interfaceCountDesc *prometheus.Desc
neighborCountDesc *prometheus.Desc
neighborAdjacentCountDesc *prometheus.Desc
}
type ospfMetricExporter struct {
descriptions map[string]*desc
client *client.BirdClient
}
func NewExporter(prefix string) metrics.MetricExporter {
func NewExporter(prefix string, client *client.BirdClient) metrics.MetricExporter {
d := make(map[string]*desc)
d["4"] = getDesc(prefix + "ospf")
d["6"] = getDesc(prefix + "ospfv3")
return &ospfMetricExporter{descriptions: d}
return &ospfMetricExporter{descriptions: d, client: client}
}
func getDesc(prefix string) *desc {
@ -28,6 +33,11 @@ func getDesc(prefix string) *desc {
d := &desc{}
d.runningDesc = prometheus.NewDesc(prefix+"_running", "State of OSPF: 0 = Alone, 1 = Running (Neighbor-Adjacencies established)", labels, nil)
labels = append(labels, "area")
d.interfaceCountDesc = prometheus.NewDesc(prefix+"_interface_count", "Number of interfaces in the area", labels, nil)
d.neighborCountDesc = prometheus.NewDesc(prefix+"_neighbor_count", "Number of neighbors in the area", labels, nil)
d.neighborAdjacentCountDesc = prometheus.NewDesc(prefix+"_neighbor_adjacent_count", "Number of adjacent neighbors in the area", labels, nil)
return d
}