mirror of
https://github.com/cloudnativelabs/kube-router.git
synced 2025-10-13 10:51:05 +02:00
334 lines
11 KiB
Go
334 lines
11 KiB
Go
// path_test.go
|
|
package table
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/osrg/gobgp/packet/bgp"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestPathNewIPv4(t *testing.T) {
|
|
peerP := PathCreatePeer()
|
|
pathP := PathCreatePath(peerP)
|
|
ipv4p := NewPath(pathP[0].GetSource(), pathP[0].GetNlri(), true, pathP[0].GetPathAttrs(), time.Now(), false)
|
|
assert.NotNil(t, ipv4p)
|
|
}
|
|
|
|
func TestPathNewIPv6(t *testing.T) {
|
|
peerP := PathCreatePeer()
|
|
pathP := PathCreatePath(peerP)
|
|
ipv6p := NewPath(pathP[0].GetSource(), pathP[0].GetNlri(), true, pathP[0].GetPathAttrs(), time.Now(), false)
|
|
assert.NotNil(t, ipv6p)
|
|
}
|
|
|
|
func TestPathGetNlri(t *testing.T) {
|
|
nlri := bgp.NewIPAddrPrefix(24, "13.2.3.2")
|
|
pd := &Path{
|
|
info: &originInfo{
|
|
nlri: nlri,
|
|
},
|
|
}
|
|
r_nlri := pd.GetNlri()
|
|
assert.Equal(t, r_nlri, nlri)
|
|
}
|
|
|
|
func TestPathCreatePath(t *testing.T) {
|
|
peerP := PathCreatePeer()
|
|
msg := updateMsgP1()
|
|
updateMsgP := msg.Body.(*bgp.BGPUpdate)
|
|
nlriList := updateMsgP.NLRI
|
|
pathAttributes := updateMsgP.PathAttributes
|
|
nlri_info := nlriList[0]
|
|
path := NewPath(peerP[0], nlri_info, false, pathAttributes, time.Now(), false)
|
|
assert.NotNil(t, path)
|
|
|
|
}
|
|
|
|
func TestPathGetPrefix(t *testing.T) {
|
|
peerP := PathCreatePeer()
|
|
pathP := PathCreatePath(peerP)
|
|
prefix := "10.10.10.0/24"
|
|
r_prefix := pathP[0].getPrefix()
|
|
assert.Equal(t, r_prefix, prefix)
|
|
}
|
|
|
|
func TestPathGetAttribute(t *testing.T) {
|
|
peerP := PathCreatePeer()
|
|
pathP := PathCreatePath(peerP)
|
|
nh := "192.168.50.1"
|
|
pa := pathP[0].getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
|
|
r_nh := pa.(*bgp.PathAttributeNextHop).Value.String()
|
|
assert.Equal(t, r_nh, nh)
|
|
}
|
|
|
|
func TestASPathLen(t *testing.T) {
|
|
assert := assert.New(t)
|
|
origin := bgp.NewPathAttributeOrigin(0)
|
|
aspathParam := []bgp.AsPathParamInterface{
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, []uint16{65001, 65002, 65003, 65004, 65004, 65004, 65004, 65004, 65005}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SET, []uint16{65001, 65002, 65003, 65004, 65005}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SEQ, []uint16{65100, 65101, 65102}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SET, []uint16{65100, 65101})}
|
|
aspath := bgp.NewPathAttributeAsPath(aspathParam)
|
|
nexthop := bgp.NewPathAttributeNextHop("192.168.50.1")
|
|
med := bgp.NewPathAttributeMultiExitDisc(0)
|
|
|
|
pathAttributes := []bgp.PathAttributeInterface{
|
|
origin,
|
|
aspath,
|
|
nexthop,
|
|
med,
|
|
}
|
|
|
|
nlri := []*bgp.IPAddrPrefix{bgp.NewIPAddrPrefix(24, "10.10.10.0")}
|
|
bgpmsg := bgp.NewBGPUpdateMessage(nil, pathAttributes, nlri)
|
|
update := bgpmsg.Body.(*bgp.BGPUpdate)
|
|
UpdatePathAttrs4ByteAs(update)
|
|
peer := PathCreatePeer()
|
|
p := NewPath(peer[0], update.NLRI[0], false, update.PathAttributes, time.Now(), false)
|
|
assert.Equal(10, p.GetAsPathLen())
|
|
}
|
|
|
|
func TestPathPrependAsnToExistingSeqAttr(t *testing.T) {
|
|
assert := assert.New(t)
|
|
origin := bgp.NewPathAttributeOrigin(0)
|
|
aspathParam := []bgp.AsPathParamInterface{
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, []uint16{65001, 65002, 65003, 65004, 65005}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SET, []uint16{65001, 65002, 65003, 65004, 65005}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SEQ, []uint16{65100, 65101, 65102}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SET, []uint16{65100, 65101})}
|
|
aspath := bgp.NewPathAttributeAsPath(aspathParam)
|
|
nexthop := bgp.NewPathAttributeNextHop("192.168.50.1")
|
|
|
|
pathAttributes := []bgp.PathAttributeInterface{
|
|
origin,
|
|
aspath,
|
|
nexthop,
|
|
}
|
|
|
|
nlri := []*bgp.IPAddrPrefix{bgp.NewIPAddrPrefix(24, "10.10.10.0")}
|
|
bgpmsg := bgp.NewBGPUpdateMessage(nil, pathAttributes, nlri)
|
|
update := bgpmsg.Body.(*bgp.BGPUpdate)
|
|
UpdatePathAttrs4ByteAs(update)
|
|
peer := PathCreatePeer()
|
|
p := NewPath(peer[0], update.NLRI[0], false, update.PathAttributes, time.Now(), false)
|
|
|
|
p.PrependAsn(65000, 1)
|
|
assert.Equal([]uint32{65000, 65001, 65002, 65003, 65004, 65005, 0, 0, 0}, p.GetAsSeqList())
|
|
fmt.Printf("asns: %v", p.GetAsSeqList())
|
|
}
|
|
|
|
func TestPathPrependAsnToNewAsPathAttr(t *testing.T) {
|
|
assert := assert.New(t)
|
|
origin := bgp.NewPathAttributeOrigin(0)
|
|
nexthop := bgp.NewPathAttributeNextHop("192.168.50.1")
|
|
|
|
pathAttributes := []bgp.PathAttributeInterface{
|
|
origin,
|
|
nexthop,
|
|
}
|
|
|
|
nlri := []*bgp.IPAddrPrefix{bgp.NewIPAddrPrefix(24, "10.10.10.0")}
|
|
bgpmsg := bgp.NewBGPUpdateMessage(nil, pathAttributes, nlri)
|
|
update := bgpmsg.Body.(*bgp.BGPUpdate)
|
|
UpdatePathAttrs4ByteAs(update)
|
|
peer := PathCreatePeer()
|
|
p := NewPath(peer[0], update.NLRI[0], false, update.PathAttributes, time.Now(), false)
|
|
|
|
asn := uint32(65000)
|
|
p.PrependAsn(asn, 1)
|
|
assert.Equal([]uint32{asn}, p.GetAsSeqList())
|
|
}
|
|
|
|
func TestPathPrependAsnToNewAsPathSeq(t *testing.T) {
|
|
assert := assert.New(t)
|
|
origin := bgp.NewPathAttributeOrigin(0)
|
|
aspathParam := []bgp.AsPathParamInterface{
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SET, []uint16{65001, 65002, 65003, 65004, 65005}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SEQ, []uint16{65100, 65101, 65102}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SET, []uint16{65100, 65101})}
|
|
aspath := bgp.NewPathAttributeAsPath(aspathParam)
|
|
nexthop := bgp.NewPathAttributeNextHop("192.168.50.1")
|
|
|
|
pathAttributes := []bgp.PathAttributeInterface{
|
|
origin,
|
|
aspath,
|
|
nexthop,
|
|
}
|
|
|
|
nlri := []*bgp.IPAddrPrefix{bgp.NewIPAddrPrefix(24, "10.10.10.0")}
|
|
bgpmsg := bgp.NewBGPUpdateMessage(nil, pathAttributes, nlri)
|
|
update := bgpmsg.Body.(*bgp.BGPUpdate)
|
|
UpdatePathAttrs4ByteAs(update)
|
|
peer := PathCreatePeer()
|
|
p := NewPath(peer[0], update.NLRI[0], false, update.PathAttributes, time.Now(), false)
|
|
|
|
asn := uint32(65000)
|
|
p.PrependAsn(asn, 1)
|
|
assert.Equal([]uint32{asn, 0, 0, 0}, p.GetAsSeqList())
|
|
fmt.Printf("asns: %v", p.GetAsSeqList())
|
|
}
|
|
|
|
func TestPathPrependAsnToEmptyAsPathAttr(t *testing.T) {
|
|
assert := assert.New(t)
|
|
origin := bgp.NewPathAttributeOrigin(0)
|
|
aspathParam := []bgp.AsPathParamInterface{
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, []uint16{}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SET, []uint16{65001, 65002, 65003, 65004, 65005}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SEQ, []uint16{65100, 65101, 65102}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SET, []uint16{65100, 65101})}
|
|
aspath := bgp.NewPathAttributeAsPath(aspathParam)
|
|
nexthop := bgp.NewPathAttributeNextHop("192.168.50.1")
|
|
|
|
pathAttributes := []bgp.PathAttributeInterface{
|
|
origin,
|
|
aspath,
|
|
nexthop,
|
|
}
|
|
|
|
nlri := []*bgp.IPAddrPrefix{bgp.NewIPAddrPrefix(24, "10.10.10.0")}
|
|
bgpmsg := bgp.NewBGPUpdateMessage(nil, pathAttributes, nlri)
|
|
update := bgpmsg.Body.(*bgp.BGPUpdate)
|
|
UpdatePathAttrs4ByteAs(update)
|
|
peer := PathCreatePeer()
|
|
p := NewPath(peer[0], update.NLRI[0], false, update.PathAttributes, time.Now(), false)
|
|
|
|
asn := uint32(65000)
|
|
p.PrependAsn(asn, 1)
|
|
assert.Equal([]uint32{asn, 0, 0, 0}, p.GetAsSeqList())
|
|
fmt.Printf("asns: %v", p.GetAsSeqList())
|
|
}
|
|
|
|
func TestPathPrependAsnToFullPathAttr(t *testing.T) {
|
|
assert := assert.New(t)
|
|
origin := bgp.NewPathAttributeOrigin(0)
|
|
|
|
asns := make([]uint16, 255)
|
|
for i, _ := range asns {
|
|
asns[i] = 65000 + uint16(i)
|
|
}
|
|
|
|
aspathParam := []bgp.AsPathParamInterface{
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, asns),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SET, []uint16{65001, 65002, 65003, 65004, 65005}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SEQ, []uint16{65100, 65101, 65102}),
|
|
bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SET, []uint16{65100, 65101})}
|
|
aspath := bgp.NewPathAttributeAsPath(aspathParam)
|
|
nexthop := bgp.NewPathAttributeNextHop("192.168.50.1")
|
|
|
|
pathAttributes := []bgp.PathAttributeInterface{
|
|
origin,
|
|
aspath,
|
|
nexthop,
|
|
}
|
|
|
|
nlri := []*bgp.IPAddrPrefix{bgp.NewIPAddrPrefix(24, "10.10.10.0")}
|
|
bgpmsg := bgp.NewBGPUpdateMessage(nil, pathAttributes, nlri)
|
|
update := bgpmsg.Body.(*bgp.BGPUpdate)
|
|
UpdatePathAttrs4ByteAs(update)
|
|
peer := PathCreatePeer()
|
|
p := NewPath(peer[0], update.NLRI[0], false, update.PathAttributes, time.Now(), false)
|
|
|
|
expected := []uint32{65000, 65000}
|
|
for _, v := range asns {
|
|
expected = append(expected, uint32(v))
|
|
}
|
|
p.PrependAsn(65000, 2)
|
|
assert.Equal(append(expected, []uint32{0, 0, 0}...), p.GetAsSeqList())
|
|
fmt.Printf("asns: %v", p.GetAsSeqList())
|
|
}
|
|
|
|
func TestGetPathAttrs(t *testing.T) {
|
|
paths := PathCreatePath(PathCreatePeer())
|
|
path0 := paths[0]
|
|
path1 := path0.Clone(false)
|
|
path1.delPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
|
|
path2 := path1.Clone(false)
|
|
path2.setPathAttr(bgp.NewPathAttributeNextHop("192.168.50.1"))
|
|
assert.NotNil(t, path2.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP))
|
|
}
|
|
|
|
func PathCreatePeer() []*PeerInfo {
|
|
peerP1 := &PeerInfo{AS: 65000}
|
|
peerP2 := &PeerInfo{AS: 65001}
|
|
peerP3 := &PeerInfo{AS: 65002}
|
|
peerP := []*PeerInfo{peerP1, peerP2, peerP3}
|
|
return peerP
|
|
}
|
|
|
|
func PathCreatePath(peerP []*PeerInfo) []*Path {
|
|
bgpMsgP1 := updateMsgP1()
|
|
bgpMsgP2 := updateMsgP2()
|
|
bgpMsgP3 := updateMsgP3()
|
|
pathP := make([]*Path, 3)
|
|
for i, msg := range []*bgp.BGPMessage{bgpMsgP1, bgpMsgP2, bgpMsgP3} {
|
|
updateMsgP := msg.Body.(*bgp.BGPUpdate)
|
|
nlriList := updateMsgP.NLRI
|
|
pathAttributes := updateMsgP.PathAttributes
|
|
nlri_info := nlriList[0]
|
|
pathP[i] = NewPath(peerP[i], nlri_info, false, pathAttributes, time.Now(), false)
|
|
}
|
|
return pathP
|
|
}
|
|
|
|
func updateMsgP1() *bgp.BGPMessage {
|
|
|
|
origin := bgp.NewPathAttributeOrigin(0)
|
|
aspathParam := []bgp.AsPathParamInterface{bgp.NewAsPathParam(2, []uint16{65000})}
|
|
aspath := bgp.NewPathAttributeAsPath(aspathParam)
|
|
nexthop := bgp.NewPathAttributeNextHop("192.168.50.1")
|
|
med := bgp.NewPathAttributeMultiExitDisc(0)
|
|
|
|
pathAttributes := []bgp.PathAttributeInterface{
|
|
origin,
|
|
aspath,
|
|
nexthop,
|
|
med,
|
|
}
|
|
|
|
nlri := []*bgp.IPAddrPrefix{bgp.NewIPAddrPrefix(24, "10.10.10.0")}
|
|
return bgp.NewBGPUpdateMessage(nil, pathAttributes, nlri)
|
|
}
|
|
|
|
func updateMsgP2() *bgp.BGPMessage {
|
|
|
|
origin := bgp.NewPathAttributeOrigin(0)
|
|
aspathParam := []bgp.AsPathParamInterface{bgp.NewAsPathParam(2, []uint16{65100})}
|
|
aspath := bgp.NewPathAttributeAsPath(aspathParam)
|
|
nexthop := bgp.NewPathAttributeNextHop("192.168.100.1")
|
|
med := bgp.NewPathAttributeMultiExitDisc(100)
|
|
|
|
pathAttributes := []bgp.PathAttributeInterface{
|
|
origin,
|
|
aspath,
|
|
nexthop,
|
|
med,
|
|
}
|
|
|
|
nlri := []*bgp.IPAddrPrefix{bgp.NewIPAddrPrefix(24, "20.20.20.0")}
|
|
return bgp.NewBGPUpdateMessage(nil, pathAttributes, nlri)
|
|
}
|
|
|
|
func updateMsgP3() *bgp.BGPMessage {
|
|
origin := bgp.NewPathAttributeOrigin(0)
|
|
aspathParam := []bgp.AsPathParamInterface{bgp.NewAsPathParam(2, []uint16{65100})}
|
|
aspath := bgp.NewPathAttributeAsPath(aspathParam)
|
|
nexthop := bgp.NewPathAttributeNextHop("192.168.150.1")
|
|
med := bgp.NewPathAttributeMultiExitDisc(100)
|
|
|
|
pathAttributes := []bgp.PathAttributeInterface{
|
|
origin,
|
|
aspath,
|
|
nexthop,
|
|
med,
|
|
}
|
|
|
|
nlri := []*bgp.IPAddrPrefix{bgp.NewIPAddrPrefix(24, "30.30.30.0")}
|
|
w1 := bgp.NewIPAddrPrefix(23, "40.40.40.0")
|
|
withdrawnRoutes := []*bgp.IPAddrPrefix{w1}
|
|
return bgp.NewBGPUpdateMessage(withdrawnRoutes, pathAttributes, nlri)
|
|
}
|