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

Merge pull request #16 from czerwonk/1.2

Browse Source 
1.2
This commit is contained in:
Daniel Czerwonk 2018-01-01 13:03:11 +01:00 committed by GitHub
commit f7cfa2abc1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 353 additions and 150 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
}

80
client/bird_client.go Normal file
View File

@ -0,0 +1,80 @@
package client
import (
"fmt"
"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.protocolsFromBird(ipVersions)
}
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 {
return nil, err
}
return parser.ParseOspf(b), nil
}
func (c *BirdClient) protocolsFromBird(ipVersions []string) ([]*protocol.Protocol, error) {
protocols := make([]*protocol.Protocol, 0)
for _, ipVersion := range ipVersions {
sock := c.socketFor(ipVersion)
s, err := c.protocolsFromSocket(sock, ipVersion)
if err != nil {
return nil, err
}
protocols = append(protocols, s...)
}
return protocols, nil
}
func (c *BirdClient) protocolsFromSocket(socketPath string, ipVersion string) ([]*protocol.Protocol, error) {
b, err := birdsocket.Query(socketPath, "show protocols all")
if err != nil {
return nil, err
}
return parser.ParseProtocols(b, ipVersion), nil
}
func (c *BirdClient) socketFor(ipVersion string) string {
if !c.Options.BirdV2 && ipVersion == "6" {
return c.Options.Bird6Socket
}
return c.Options.BirdSocket
}

12
client/client.go Normal file
View File

@ -0,0 +1,12 @@
package client
import "github.com/czerwonk/bird_exporter/protocol"
type Client interface {
// GetProtocols retrieves protocol information and statistics from bird
GetProtocols() ([]*protocol.Protocol, error)
// GetOspfArea retrieves OSPF specific information from bird
GetOspfAreas(protocol *protocol.Protocol) ([]*protocol.OspfArea, error)
}

46
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.")
@ -27,9 +27,9 @@ var (
enableStatic = flag.Bool("proto.static", true, "Enables metrics for protocol Static")
enableDirect = flag.Bool("proto.direct", true, "Enables metrics for protocol Direct")
// 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)")
bird6Enabled = flag.Bool("bird.ipv6", true, "Get protocols from bird6 (not compatible with -bird.v2)")
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)")
bird6Enabled = flag.Bool("bird.ipv6", true, "Get protocols from bird6 (not compatible with -bird.v2)")
)
func init() {
@ -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

44
metric_collector.go
View File

@ -1,43 +1,57 @@
package main
import (
"github.com/czerwonk/bird_exporter/client"
"github.com/czerwonk/bird_exporter/metrics"
"github.com/czerwonk/bird_exporter/ospf"
"github.com/czerwonk/bird_exporter/protocol"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/common/log"
)
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), metrics.NewOspfExporter("", 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 +59,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, metrics.NewOspfExporter("bird_", c)},
protocol.Static: []metrics.MetricExporter{e},
}
}
@ -59,8 +73,14 @@ func (m *MetricCollector) Describe(ch chan<- *prometheus.Desc) {
}
func (m *MetricCollector) Collect(ch chan<- prometheus.Metric) {
for _, p := range m.protocols {
if p.Proto == protocol.PROTO_UNKNOWN || (m.enabledProtocols & p.Proto != p.Proto) {
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
}

73
metrics/ospf_exporter.go Normal file
View File

@ -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"
"github.com/prometheus/common/log"
)
type ospfDesc struct {
runningDesc *prometheus.Desc
interfaceCountDesc *prometheus.Desc
neighborCountDesc *prometheus.Desc
neighborAdjacentCountDesc *prometheus.Desc
}
type ospfMetricExporter struct {
descriptions map[string]*ospfDesc
client client.Client
}
func NewOspfExporter(prefix string, client client.Client) MetricExporter {
d := make(map[string]*ospfDesc)
d["4"] = getDesc(prefix + "ospf")
d["6"] = getDesc(prefix + "ospfv3")
return &ospfMetricExporter{descriptions: d, client: client}
}
func getDesc(prefix string) *ospfDesc {
labels := []string{"name"}
d := &ospfDesc{}
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
}
func (m *ospfMetricExporter) Describe(ch chan<- *prometheus.Desc) {
m.describe("4", ch)
m.describe("6", ch)
}
func (m *ospfMetricExporter) describe(ipVersion string, ch chan<- *prometheus.Desc) {
d := m.descriptions[ipVersion]
ch <- d.runningDesc
ch <- d.interfaceCountDesc
ch <- d.neighborCountDesc
ch <- d.neighborAdjacentCountDesc
}
func (m *ospfMetricExporter) Export(p *protocol.Protocol, ch chan<- prometheus.Metric) {
d := m.descriptions[p.IpVersion]
ch <- prometheus.MustNewConstMetric(d.runningDesc, prometheus.GaugeValue, p.Attributes["running"], p.Name)
areas, err := m.client.GetOspfAreas(p)
if err != nil {
log.Errorln(err)
return
}
for _, area := range areas {
l := []string{p.Name, area.Name}
ch <- prometheus.MustNewConstMetric(d.interfaceCountDesc, prometheus.GaugeValue, float64(area.InterfaceCount), l...)
ch <- prometheus.MustNewConstMetric(d.neighborCountDesc, prometheus.GaugeValue, float64(area.NeighborCount), l...)
ch <- prometheus.MustNewConstMetric(d.neighborAdjacentCountDesc, prometheus.GaugeValue, float64(area.NeighborAdjacentCount), l...)
}
}

41
ospf/exporter.go
View File

@ -1,41 +0,0 @@
package ospf
import (
"github.com/czerwonk/bird_exporter/metrics"
"github.com/czerwonk/bird_exporter/protocol"
"github.com/prometheus/client_golang/prometheus"
)
type desc struct {
runningDesc *prometheus.Desc
}
type ospfMetricExporter struct {
descriptions map[string]*desc
}
func NewExporter(prefix string) metrics.MetricExporter {
d := make(map[string]*desc)
d["4"] = getDesc(prefix + "ospf")
d["6"] = getDesc(prefix + "ospfv3")
return &ospfMetricExporter{descriptions: d}
}
func getDesc(prefix string) *desc {
labels := []string{"name"}
d := &desc{}
d.runningDesc = prometheus.NewDesc(prefix+"_running", "State of OSPF: 0 = Alone, 1 = Running (Neighbor-Adjacencies established)", labels, nil)
return d
}
func (m *ospfMetricExporter) Describe(ch chan<- *prometheus.Desc) {
ch <- m.descriptions["4"].runningDesc
ch <- m.descriptions["6"].runningDesc
}
func (m *ospfMetricExporter) Export(p *protocol.Protocol, ch chan<- prometheus.Metric) {
ch <- prometheus.MustNewConstMetric(m.descriptions[p.IpVersion].runningDesc, prometheus.GaugeValue, p.Attributes["running"], p.Name)
}

85
parser/ospf.go Normal file
View File

@ -0,0 +1,85 @@
package parser
import (
"regexp"
"bufio"
"bytes"
"strings"
"github.com/czerwonk/bird_exporter/protocol"
)
type ospfRegex struct {
area *regexp.Regexp
counters *regexp.Regexp
}
type ospfContext struct {
line string
areas []*protocol.OspfArea
current *protocol.OspfArea
}
func init() {
ospf = &ospfRegex{
area: regexp.MustCompile("Area: [^\\s]+ \\(([^\\s]+)\\)"),
counters: regexp.MustCompile("Number of ([^:]+):\\s*(\\d+)"),
}
}
var ospf *ospfRegex
func ParseOspf(data []byte) []*protocol.OspfArea {
reader := bytes.NewReader(data)
scanner := bufio.NewScanner(reader)
c := &ospfContext{
areas: make([]*protocol.OspfArea, 0),
}
for scanner.Scan() {
c.line = strings.Trim(scanner.Text(), " ")
parseLineForOspfArea(c)
parseLineForOspfCounters(c)
}
return c.areas
}
func parseLineForOspfArea(c *ospfContext) {
m := ospf.area.FindStringSubmatch(c.line)
if m == nil {
return
}
a := &protocol.OspfArea{Name: m[1]}
c.current = a
c.areas = append(c.areas, a)
}
func parseLineForOspfCounters(c *ospfContext) {
if c.current == nil {
return
}
m := ospf.counters.FindStringSubmatch(c.line)
if m == nil {
return
}
name := m[1]
value := parseInt(m[2])
if name == "interfaces" {
c.current.InterfaceCount = value
}
if name == "neighbors" {
c.current.NeighborCount = value
}
if name == "adjacent neighbors" {
c.current.NeighborAdjacentCount = value
}
}

2
parser/parser.go
View File

@ -38,7 +38,7 @@ func init() {
}
// Parser parses bird output and returns protocol.Protocol structs
func Parse(data []byte, ipVersion string) []*protocol.Protocol {
func ParseProtocols(data []byte, ipVersion string) []*protocol.Protocol {
reader := bytes.NewReader(data)
scanner := bufio.NewScanner(reader)

61
parser_test.go
View File

@ -10,7 +10,7 @@ import (
func TestEstablishedBgpOldTimeFormat(t *testing.T) {
data := "foo BGP master up 1481973060 Established\ntest\nbar\n Routes: 12 imported, 1 filtered, 34 exported, 100 preferred\nxxx"
p := parser.Parse([]byte(data), "4")
p := parser.ParseProtocols([]byte(data), "4")
assert.IntEqual("protocols", 1, len(p), t)
x := p[0]
@ -26,7 +26,7 @@ func TestEstablishedBgpOldTimeFormat(t *testing.T) {
func TestEstablishedBgpCurrentTimeFormat(t *testing.T) {
data := "foo BGP master up 00:01:00 Established\ntest\nbar\n Routes: 12 imported, 1 filtered, 34 exported, 100 preferred\nxxx"
p := parser.Parse([]byte(data), "4")
p := parser.ParseProtocols([]byte(data), "4")
assert.IntEqual("protocols", 1, len(p), t)
x := p[0]
@ -43,7 +43,7 @@ func TestEstablishedBgpCurrentTimeFormat(t *testing.T) {
func TestIpv6Bgp(t *testing.T) {
data := "foo BGP master up 00:01:00 Established\ntest\nbar\n Routes: 12 imported, 1 filtered, 34 exported, 100 preferred\nxxx"
p := parser.Parse([]byte(data), "6")
p := parser.ParseProtocols([]byte(data), "6")
assert.IntEqual("protocols", 1, len(p), t)
x := p[0]
@ -52,7 +52,7 @@ func TestIpv6Bgp(t *testing.T) {
func TestActiveBgp(t *testing.T) {
data := "bar BGP master start 2016-01-01 Active\ntest\nbar"
p := parser.Parse([]byte(data), "4")
p := parser.ParseProtocols([]byte(data), "4")
assert.IntEqual("protocols", 1, len(p), t)
x := p[0]
@ -67,7 +67,7 @@ func TestActiveBgp(t *testing.T) {
func Test2BgpSessions(t *testing.T) {
data := "foo BGP master up 00:01:00 Established\ntest\n Routes: 12 imported, 1 filtered, 34 exported, 100 preferred\nbar BGP master start 2016-01-01 Active\nxxx"
p := parser.Parse([]byte(data), "4")
p := parser.ParseProtocols([]byte(data), "4")
assert.IntEqual("protocols", 2, len(p), t)
}
@ -79,7 +79,7 @@ func TestUpdateAndWithdrawCounts(t *testing.T) {
" Import withdraws: 6 7 8 9 10\n" +
" Export updates: 11 12 13 14 15\n" +
" Export withdraws: 16 17 18 19 ---"
p := parser.Parse([]byte(data), "4")
p := parser.ParseProtocols([]byte(data), "4")
x := p[0]
assert.Int64Equal("import updates received", 1, x.ImportUpdates.Received, t)
@ -141,7 +141,7 @@ func TestWithBird2(t *testing.T) {
" Routes: 4 imported, 3 filtered, 2 exported, 1 preferred\n" +
"\n"
p := parser.Parse([]byte(data), "")
p := parser.ParseProtocols([]byte(data), "")
assert.IntEqual("protocols", 4, len(p), t)
x := p[0]
@ -223,7 +223,7 @@ func TestWithBird2(t *testing.T) {
func TestOspfOldTimeFormat(t *testing.T) {
data := "ospf1 OSPF master up 1481973060 Running\ntest\nbar\n Routes: 12 imported, 34 exported, 100 preferred\nxxx"
p := parser.Parse([]byte(data), "4")
p := parser.ParseProtocols([]byte(data), "4")
assert.IntEqual("protocols", 1, len(p), t)
x := p[0]
@ -238,7 +238,7 @@ func TestOspfOldTimeFormat(t *testing.T) {
func TestOspfCurrentTimeFormat(t *testing.T) {
data := "ospf1 OSPF master up 00:01:00 Running\ntest\nbar\n Routes: 12 imported, 34 exported, 100 preferred\nxxx"
p := parser.Parse([]byte(data), "4")
p := parser.ParseProtocols([]byte(data), "4")
assert.IntEqual("protocols", 1, len(p), t)
x := p[0]
@ -254,7 +254,7 @@ func TestOspfCurrentTimeFormat(t *testing.T) {
func TestOspfProtocolDown(t *testing.T) {
data := "o_hrz OSPF t_hrz down 1494926415 \n Preference: 150\n Input filter: ACCEPT\n Output filter: REJECT\nxxx"
p := parser.Parse([]byte(data), "6")
p := parser.ParseProtocols([]byte(data), "6")
assert.IntEqual("protocols", 1, len(p), t)
x := p[0]
@ -268,7 +268,7 @@ func TestOspfProtocolDown(t *testing.T) {
func TestOspfRunning(t *testing.T) {
data := "ospf1 OSPF master up 00:01:00 Running\ntest\nbar\n Routes: 12 imported, 34 exported, 100 preferred\nxxx"
p := parser.Parse([]byte(data), "4")
p := parser.ParseProtocols([]byte(data), "4")
assert.IntEqual("protocols", 1, len(p), t)
x := p[0]
@ -277,9 +277,46 @@ func TestOspfRunning(t *testing.T) {
func TestOspfAlone(t *testing.T) {
data := "ospf1 OSPF master up 00:01:00 Alone\ntest\nbar\n Routes: 12 imported, 34 exported, 100 preferred\nxxx"
p := parser.Parse([]byte(data), "4")
p := parser.ParseProtocols([]byte(data), "4")
assert.IntEqual("protocols", 1, len(p), t)
x := p[0]
assert.Float64Equal("running", 0, x.Attributes["running"], t)
}
func TestOspfArea(t *testing.T) {
data := "ospf1:\n" +
"RFC1583 compatibility: disabled\n" +
"Stub router: No\n" +
"RT scheduler tick: 1\n" +
"Number of areas: 2\n" +
"Number of LSAs in DB: 33\n" +
" Area: 0.0.0.0 (0) [BACKBONE]\n" +
" Stub: No\n" +
" NSSA: No\n" +
" Transit: No\n" +
" Number of interfaces: 3\n" +
" Number of neighbors: 2\n" +
" Number of adjacent neighbors: 1\n" +
" Area: 0.0.0.1 (1)\n" +
" Stub: No\n" +
" NSSA: No\n" +
" Transit: No\n" +
" Number of interfaces: 4\n" +
" Number of neighbors: 6\n" +
" Number of adjacent neighbors: 5\n"
a := parser.ParseOspf([]byte(data))
assert.IntEqual("areas", 2, len(a), t)
a1 := a[0]
assert.StringEqual("Area1 Name", "0", a1.Name, t)
assert.Int64Equal("Area1 InterfaceCount", 3, a1.InterfaceCount, t)
assert.Int64Equal("Area1 NeighborCount", 2, a1.NeighborCount, t)
assert.Int64Equal("Area1 NeighborAdjacentCount", 1, a1.NeighborAdjacentCount, t)
a2 := a[1]
assert.StringEqual("Area2 Name", "1", a2.Name, t)
assert.Int64Equal("Area2 InterfaceCount", 4, a2.InterfaceCount, t)
assert.Int64Equal("Area2 NeighborCount", 6, a2.NeighborCount, t)
assert.Int64Equal("Area2 NeighborAdjacentCount", 5, a2.NeighborAdjacentCount, t)
}

8
protocol/ospf_area.go Normal file
View File

@ -0,0 +1,8 @@
package protocol
type OspfArea struct {
Name string
InterfaceCount int64
NeighborCount int64
NeighborAdjacentCount int64
}