summaryrefslogtreecommitdiffstats
path: root/api/ifcounters
diff options
context:
space:
mode:
Diffstat (limited to 'api/ifcounters')
-rw-r--r--api/ifcounters/doc.go4
-rw-r--r--api/ifcounters/ifcounters.go147
-rw-r--r--api/ifcounters/ifcounters_test.go129
3 files changed, 280 insertions, 0 deletions
diff --git a/api/ifcounters/doc.go b/api/ifcounters/doc.go
new file mode 100644
index 0000000..c918941
--- /dev/null
+++ b/api/ifcounters/doc.go
@@ -0,0 +1,4 @@
+// Package ifcounters provides the helper API for decoding VnetInterfaceCounters binary API message
+// that contains binary-encoded statistics data into the Go structs that are better consumable by the Go code.
+// TODO: example usage - currently in the example_client.go
+package ifcounters
diff --git a/api/ifcounters/ifcounters.go b/api/ifcounters/ifcounters.go
new file mode 100644
index 0000000..202fe6e
--- /dev/null
+++ b/api/ifcounters/ifcounters.go
@@ -0,0 +1,147 @@
+// Copyright (c) 2017 Cisco and/or its affiliates.
+//
+// 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 ifcounters
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+
+ "github.com/lunixbochs/struc"
+)
+
+// VnetInterfaceCounters is the input data type defined in the 'interface.api', with binary encoded Data field,
+// that can be decoded into the InterfaceCounter or CombinedInterfaceCounter struct using this package.
+type VnetInterfaceCounters struct {
+ VnetCounterType uint8
+ IsCombined uint8
+ FirstSwIfIndex uint32
+ Count uint32 `struc:"sizeof=Data"`
+ Data []byte
+}
+
+// CounterType is the basic counter type - contains only packet statistics.
+type CounterType int
+
+// constants as defined in the vnet_interface_counter_type_t enum in 'vnet/interface.h'
+const (
+ Drop CounterType = 0
+ Punt = 1
+ IPv4 = 2
+ IPv6 = 3
+ RxNoBuf = 4
+ RxMiss = 5
+ RxError = 6
+ TxError = 7
+ MPLS = 8
+)
+
+// CombinedCounterType is the extended counter type - contains both packet and byte statistics.
+type CombinedCounterType int
+
+// constants as defined in the vnet_interface_counter_type_t enum in 'vnet/interface.h'
+const (
+ Rx CombinedCounterType = 0
+ Tx = 1
+)
+
+// InterfaceCounter contains basic counter data (contains only packet statistics).
+type InterfaceCounter struct {
+ Type CounterType
+ SwIfIndex uint32
+ Packets uint64
+}
+
+// CombinedInterfaceCounter contains extended counter data (contains both packet and byte statistics).
+type CombinedInterfaceCounter struct {
+ Type CombinedCounterType
+ SwIfIndex uint32
+ Packets uint64
+ Bytes uint64
+}
+
+type counterData struct {
+ Packets uint64
+}
+
+type counter struct {
+ Count uint32 `struc:"sizeof=Data"`
+ Data []counterData
+}
+
+type combinedCounterData struct {
+ Packets uint64
+ Bytes uint64
+}
+
+type combinedCounter struct {
+ Count uint32 `struc:"sizeof=Data"`
+ Data []combinedCounterData
+}
+
+// DecodeCounters decodes VnetInterfaceCounters struct content into the slice of InterfaceCounter structs.
+func DecodeCounters(vnetCounters VnetInterfaceCounters) ([]InterfaceCounter, error) {
+ if vnetCounters.IsCombined == 1 {
+ return nil, errors.New("invalid argument - combined counter passed in")
+ }
+
+ // decode into internal struct
+ var c counter
+ buf := bytes.NewReader(vnetCounters.Data)
+ err := struc.Unpack(buf, &c)
+ if err != nil {
+ return nil, fmt.Errorf("unable to decode counter data: %v", err)
+ }
+
+ // prepare the slice
+ res := make([]InterfaceCounter, c.Count)
+
+ // fill in the slice
+ for i := uint32(0); i < c.Count; i++ {
+ res[i].Type = CounterType(vnetCounters.VnetCounterType)
+ res[i].SwIfIndex = vnetCounters.FirstSwIfIndex + i
+ res[i].Packets = c.Data[i].Packets
+ }
+
+ return res, nil
+}
+
+// DecodeCombinedCounters decodes VnetInterfaceCounters struct content into the slice of CombinedInterfaceCounter structs.
+func DecodeCombinedCounters(vnetCounters VnetInterfaceCounters) ([]CombinedInterfaceCounter, error) {
+ if vnetCounters.IsCombined != 1 {
+ return nil, errors.New("invalid argument - simple counter passed in")
+ }
+
+ // decode into internal struct
+ var c combinedCounter
+ buf := bytes.NewReader(vnetCounters.Data)
+ err := struc.Unpack(buf, &c)
+ if err != nil {
+ return nil, fmt.Errorf("unable to decode counter data: %v", err)
+ }
+
+ // prepare the slice
+ res := make([]CombinedInterfaceCounter, c.Count)
+
+ // fill in the slice
+ for i := uint32(0); i < c.Count; i++ {
+ res[i].Type = CombinedCounterType(vnetCounters.VnetCounterType)
+ res[i].SwIfIndex = vnetCounters.FirstSwIfIndex + i
+ res[i].Packets = c.Data[i].Packets
+ res[i].Bytes = c.Data[i].Bytes
+ }
+
+ return res, nil
+}
diff --git a/api/ifcounters/ifcounters_test.go b/api/ifcounters/ifcounters_test.go
new file mode 100644
index 0000000..6f9a1d9
--- /dev/null
+++ b/api/ifcounters/ifcounters_test.go
@@ -0,0 +1,129 @@
+// Copyright (c) 2017 Cisco and/or its affiliates.
+//
+// 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 ifcounters
+
+import (
+ "testing"
+
+ . "github.com/onsi/gomega"
+)
+
+func TestDecodeCounters(t *testing.T) {
+ RegisterTestingT(t)
+
+ testCounters := VnetInterfaceCounters{
+ VnetCounterType: 1,
+ IsCombined: 0,
+ FirstSwIfIndex: 5,
+ Count: 2,
+ Data: []byte{0, 0, 0, 2, // Count
+ 0, 0, 0, 0, 0, 0, 0, 10, // first counter
+ 0, 0, 0, 0, 0, 0, 0, 11}, // second counter
+ }
+ counters, err := DecodeCounters(testCounters)
+
+ Expect(err).ShouldNot(HaveOccurred())
+ Expect(len(counters)).To(BeEquivalentTo(2), "Incorrect size of the returned slice.")
+
+ Expect(counters[0].Type).To(BeEquivalentTo(1), "Incorrect counter type.")
+ Expect(counters[0].SwIfIndex).To(BeEquivalentTo(5), "Incorrect SwIfIndex.")
+ Expect(counters[0].Packets).To(BeEquivalentTo(10), "Incorrect Packets count.")
+
+ Expect(counters[1].Type).To(BeEquivalentTo(1), "Incorrect counter type.")
+ Expect(counters[1].SwIfIndex).To(BeEquivalentTo(6), "Incorrect SwIfIndex.")
+ Expect(counters[1].Packets).To(BeEquivalentTo(11), "Incorrect Packets count.")
+}
+
+func TestDecodeCombinedCounters(t *testing.T) {
+ RegisterTestingT(t)
+
+ testCounters := VnetInterfaceCounters{
+ VnetCounterType: 1,
+ IsCombined: 1,
+ FirstSwIfIndex: 20,
+ Count: 2,
+ Data: []byte{0, 0, 0, 2, // Count
+ 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 11, // first counter
+ 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 13}, // second counter
+ }
+ counters, err := DecodeCombinedCounters(testCounters)
+
+ Expect(err).ShouldNot(HaveOccurred())
+ Expect(len(counters)).To(BeEquivalentTo(2), "Incorrect size of the returned slice.")
+
+ Expect(counters[0].Type).To(BeEquivalentTo(1), "Incorrect counter type.")
+ Expect(counters[0].SwIfIndex).To(BeEquivalentTo(20), "Incorrect SwIfIndex.")
+ Expect(counters[0].Packets).To(BeEquivalentTo(10), "Incorrect Packets count.")
+ Expect(counters[0].Bytes).To(BeEquivalentTo(11), "Incorrect Bytes count.")
+
+ Expect(counters[1].Type).To(BeEquivalentTo(1), "Incorrect counter type.")
+ Expect(counters[1].SwIfIndex).To(BeEquivalentTo(21), "Incorrect SwIfIndex.")
+ Expect(counters[1].Packets).To(BeEquivalentTo(12), "Incorrect Packets count.")
+ Expect(counters[1].Bytes).To(BeEquivalentTo(13), "Incorrect Bytes count.")
+}
+
+func TestDecodeCountersNegative1(t *testing.T) {
+ RegisterTestingT(t)
+
+ testCounters := VnetInterfaceCounters{
+ IsCombined: 1, // invalid, should be 0
+ }
+ counters, err := DecodeCounters(testCounters)
+
+ Expect(err).Should(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("invalid argument"))
+ Expect(counters).To(BeNil())
+}
+
+func TestDecodeCombinedCountersNegative1(t *testing.T) {
+ RegisterTestingT(t)
+
+ testCounters := VnetInterfaceCounters{
+ IsCombined: 0, // invalid, should be 1
+ }
+ counters, err := DecodeCombinedCounters(testCounters)
+
+ Expect(err).Should(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("invalid argument"))
+ Expect(counters).To(BeNil())
+}
+
+func TestDecodeCountersNegative2(t *testing.T) {
+ RegisterTestingT(t)
+
+ testCounters := VnetInterfaceCounters{
+ IsCombined: 0,
+ // no data
+ }
+ counters, err := DecodeCounters(testCounters)
+
+ Expect(err).Should(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("unable to decode"))
+ Expect(counters).To(BeNil())
+}
+
+func TestDecodeCombinedCountersNegative2(t *testing.T) {
+ RegisterTestingT(t)
+
+ testCounters := VnetInterfaceCounters{
+ IsCombined: 1,
+ // no data
+ }
+ counters, err := DecodeCombinedCounters(testCounters)
+
+ Expect(err).Should(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("unable to decode"))
+ Expect(counters).To(BeNil())
+}