table: remove unnecessary copy of path attributes

the result of memory profile (500 route-server-clients each of them advertises
100 routes)

before:
(pprof) top5
9330.48MB of 9367.53MB total (99.60%)
Dropped 157 nodes (cum <= 46.84MB)
Showing top 10 nodes out of 17 (cum >= 9334.17MB)
flat       flat%   sum%        cum   cum%
6163.04MB 65.79% 65.79%  6163.04MB 65.79% github.com/osrg/gobgp/table.NewPath
1155.05MB 12.33% 78.12%  7302.59MB 77.96% github.com/osrg/gobgp/table.(*Path).Clone
986.31MB  10.53% 88.65%  1388.81MB 14.83% github.com/osrg/gobgp/table.(*AdjRib).Update
402.51MB   4.30% 92.95%   402.51MB  4.30%  fmt.Sprintf
402.51MB   4.30% 97.24%   402.51MB  4.30% net.parseIPv4

after:
(pprof) top
3913.02MB of 3978.69MB total (98.35%)
Dropped 148 nodes (cum <= 19.89MB)
Showing top 10 nodes out of 11 (cum >= 21MB)
flat       flat%   sum%        cum   cum%
2970.30MB 74.66% 74.66%  2975.80MB 74.79% github.com/osrg/gobgp/server.filterpath
810.09MB  20.36% 95.02%   810.59MB 20.37% github.com/osrg/gobgp/table.(*AdjRib).Update
115.60MB   2.91% 97.92%   119.10MB  2.99% github.com/osrg/gobgp/table.createUpdateMsgFromPath
10MB       0.25% 98.17%  1878.02MB 47.20% github.com/osrg/gobgp/server.(*BgpServer).propagateUpdate
4.50MB     0.11% 98.29%   144.60MB  3.63% github.com/osrg/gobgp/table.CreateUpdateMsgFromPaths

Signed-off-by: ISHIDA Wataru <ishida.wataru@lab.ntt.co.jp>

11 files changed, 377 insertions, 311 deletions

diff --git a/server/rpki.go b/server/rpki.go
index e6097d00..ed4af2ea 100644
--- a/server/rpki.go
+++ b/server/rpki.go
@@ -453,7 +453,7 @@ func (c *roaManager) validate(pathList []*table.Path, isMonitor bool) []*api.ROA
 		}
 		if tree, ok := c.roas[path.GetRouteFamily()]; ok {
 			r, roaList := validatePath(c.AS, tree, path.GetNlri().String(), path.GetAsPath())
-			if isMonitor && path.Validation != config.RpkiValidationResultType(r) {
+			if isMonitor && path.Validation() != config.RpkiValidationResultType(r) {
 				apiRoaList := func() []*api.ROA {
 					apiRoaList := make([]*api.ROA, 0)
 					for _, r := range roaList {
@@ -464,13 +464,13 @@ func (c *roaManager) validate(pathList []*table.Path, isMonitor bool) []*api.ROA
 				rr := &api.ROAResult{
 					OriginAs:  path.GetSourceAs(),
 					Prefix:    path.GetNlri().String(),
-					OldResult: api.ROAResult_ValidationResult(path.Validation.ToInt()),
+					OldResult: api.ROAResult_ValidationResult(path.Validation().ToInt()),
 					NewResult: api.ROAResult_ValidationResult(r.ToInt()),
 					Roas:      apiRoaList,
 				}
 				results = append(results, rr)
 			}
-			path.Validation = config.RpkiValidationResultType(r)
+			path.SetValidation(config.RpkiValidationResultType(r))
 		}
 	}
 	return results
diff --git a/server/server.go b/server/server.go
index 817c7d05..4a198e49 100644
--- a/server/server.go
+++ b/server/server.go
@@ -556,7 +556,7 @@ func filterpath(peer *Peer, path *table.Path) *table.Path {
 	if !peer.isRouteServerClient() && isASLoop(peer, path) {
 		return nil
 	}
-	return path.Clone(net.ParseIP(remoteAddr), path.IsWithdraw)
+	return path.Clone(peer.fsm.peerInfo.Address, path.IsWithdraw)
 }
 
 func (server *BgpServer) dropPeerAllRoutes(peer *Peer) []*SenderMsg {
@@ -643,7 +643,7 @@ func (server *BgpServer) broadcastValidationResults(results []*api.ROAResult) {
 
 func (server *BgpServer) broadcastBests(bests []*table.Path) {
 	for _, path := range bests {
-		if !path.IsFromZebra {
+		if !path.IsFromZebra() {
 			z := newBroadcastZapiBestMsg(server.zclient, path)
 			if z != nil {
 				server.broadcastMsgs = append(server.broadcastMsgs, z)
@@ -1268,7 +1268,7 @@ func (server *BgpServer) handleModPathRequest(grpcReq *GrpcRequest) []*table.Pat
 				path := func() *table.Path {
 					for _, rf := range server.globalRib.GetRFlist() {
 						for _, path := range server.globalRib.GetPathList(table.GLOBAL_RIB_NAME, rf) {
-							if len(path.Uuid) > 0 && bytes.Equal(path.Uuid, arg.Uuid) {
+							if len(path.UUID()) > 0 && bytes.Equal(path.UUID(), arg.Uuid) {
 								return path
 							}
 						}
@@ -1289,7 +1289,7 @@ func (server *BgpServer) handleModPathRequest(grpcReq *GrpcRequest) []*table.Pat
 			if err == nil {
 				u := uuid.NewV4()
 				uuidBytes = u.Bytes()
-				paths[0].Uuid = uuidBytes
+				paths[0].SetUUID(uuidBytes)
 			}
 		}
 	}
diff --git a/server/zclient.go b/server/zclient.go
index 994f1c78..3c3d3180 100644
--- a/server/zclient.go
+++ b/server/zclient.go
@@ -128,7 +128,7 @@ func createPathFromIPRouteMessage(m *zebra.Message, peerInfo *table.PeerInfo) *t
 	pattr = append(pattr, med)
 
 	p := table.NewPath(peerInfo, nlri, isWithdraw, pattr, time.Now(), false)
-	p.IsFromZebra = true
+	p.SetIsFromZebra(true)
 	return p
 }
 
diff --git a/server/zclient_test.go b/server/zclient_test.go
index dcb3cb5c..2fbd7554 100644
--- a/server/zclient_test.go
+++ b/server/zclient_test.go
@@ -59,7 +59,7 @@ func Test_createPathFromIPRouteMessage(t *testing.T) {
 	assert.NotEqual(nil, p)
 	assert.Equal("0.0.0.0", p.GetNexthop().String())
 	assert.Equal("192.168.100.0/24", p.GetNlri().String())
-	assert.True(p.IsFromZebra)
+	assert.True(p.IsFromZebra())
 	assert.False(p.IsWithdraw)
 
 	// withdraw
@@ -71,7 +71,7 @@ func Test_createPathFromIPRouteMessage(t *testing.T) {
 	assert.Equal("192.168.100.0/24", p.GetNlri().String())
 	med, _ := p.GetMed()
 	assert.Equal(uint32(100), med)
-	assert.True(p.IsFromZebra)
+	assert.True(p.IsFromZebra())
 	assert.True(p.IsWithdraw)
 
 	// IPv6
@@ -88,7 +88,7 @@ func Test_createPathFromIPRouteMessage(t *testing.T) {
 	assert.Equal("2001:db8:0:f101::/64", p.GetNlri().String())
 	med, _ = p.GetMed()
 	assert.Equal(uint32(100), med)
-	assert.True(p.IsFromZebra)
+	assert.True(p.IsFromZebra())
 	assert.False(p.IsWithdraw)
 
 	// withdraw
@@ -98,7 +98,7 @@ func Test_createPathFromIPRouteMessage(t *testing.T) {
 	assert.NotEqual(nil, p)
 	assert.Equal("::", p.GetNexthop().String())
 	assert.Equal("2001:db8:0:f101::/64", p.GetNlri().String())
-	assert.True(p.IsFromZebra)
+	assert.True(p.IsFromZebra())
 	assert.True(p.IsWithdraw)
 
 }
diff --git a/table/destination.go b/table/destination.go
index 2577e7cb..d6f1f1de 100644
--- a/table/destination.go
+++ b/table/destination.go
@@ -141,7 +141,7 @@ func (dd *Destination) ToApiStruct(id string) *api.Destination {
 		ret := make([]*api.Path, 0, len(arg))
 		first := true
 		for _, p := range arg {
-			if p.filtered[id] == POLICY_DIRECTION_NONE {
+			if p.Filtered(id) == POLICY_DIRECTION_NONE {
 				pp := p.ToApiStruct(id)
 				if first {
 					pp.Best = true
@@ -181,7 +181,7 @@ func (dd *Destination) setNlri(nlri bgp.AddrPrefixInterface) {
 func (dd *Destination) GetKnownPathList(id string) []*Path {
 	list := make([]*Path, 0, len(dd.knownPathList))
 	for _, p := range dd.knownPathList {
-		if p.filtered[id] == POLICY_DIRECTION_NONE {
+		if p.Filtered(id) == POLICY_DIRECTION_NONE {
 			list = append(list, p)
 		}
 	}
@@ -190,7 +190,7 @@ func (dd *Destination) GetKnownPathList(id string) []*Path {
 
 func (dd *Destination) GetBestPath(id string) *Path {
 	for _, p := range dd.knownPathList {
-		if p.filtered[id] == POLICY_DIRECTION_NONE {
+		if p.Filtered(id) == POLICY_DIRECTION_NONE {
 			return p
 		}
 	}
@@ -199,7 +199,7 @@ func (dd *Destination) GetBestPath(id string) *Path {
 
 func (dd *Destination) oldBest(id string) *Path {
 	for _, p := range dd.oldKnownPathList {
-		if p.filtered[id] == POLICY_DIRECTION_NONE {
+		if p.Filtered(id) == POLICY_DIRECTION_NONE {
 			return p
 		}
 	}
@@ -357,7 +357,7 @@ func (dest *Destination) implicitWithdraw() {
 	for _, path := range dest.knownPathList {
 		found := false
 		for _, newPath := range dest.newPathList {
-			if newPath.NoImplicitWithdraw {
+			if newPath.NoImplicitWithdraw() {
 				continue
 			}
 			// Here we just check if source is same and not check if path
@@ -540,8 +540,8 @@ func compareByLocalPref(path1, path2 *Path) *Path {
 	//
 	//	# Default local-pref values is 100
 	log.Debugf("enter compareByLocalPref")
-	_, attribute1 := path1.getPathAttr(bgp.BGP_ATTR_TYPE_LOCAL_PREF)
-	_, attribute2 := path2.getPathAttr(bgp.BGP_ATTR_TYPE_LOCAL_PREF)
+	attribute1 := path1.getPathAttr(bgp.BGP_ATTR_TYPE_LOCAL_PREF)
+	attribute2 := path2.getPathAttr(bgp.BGP_ATTR_TYPE_LOCAL_PREF)
 
 	if attribute1 == nil || attribute2 == nil {
 		return nil
@@ -591,8 +591,8 @@ func compareByASPath(path1, path2 *Path) *Path {
 	// Shortest as-path length is preferred. If both path have same lengths,
 	// we return None.
 	log.Debugf("enter compareByASPath")
-	_, attribute1 := path1.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
-	_, attribute2 := path2.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attribute1 := path1.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attribute2 := path2.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 
 	if attribute1 == nil || attribute2 == nil {
 		log.WithFields(log.Fields{
@@ -622,8 +622,8 @@ func compareByOrigin(path1, path2 *Path) *Path {
 	//	IGP is preferred over EGP; EGP is preferred over Incomplete.
 	//	If both paths have same origin, we return None.
 	log.Debugf("enter compareByOrigin")
-	_, attribute1 := path1.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
-	_, attribute2 := path2.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attribute1 := path1.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attribute2 := path2.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 
 	if attribute1 == nil || attribute2 == nil {
 		log.WithFields(log.Fields{
@@ -660,7 +660,7 @@ func compareByMED(path1, path2 *Path) *Path {
 	//  like bgp always-compare-med
 	log.Debugf("enter compareByMED")
 	getMed := func(path *Path) uint32 {
-		_, attribute := path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+		attribute := path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 		if attribute == nil {
 			return 0
 		}
@@ -687,7 +687,7 @@ func compareByASNumber(path1, path2 *Path) *Path {
 	//peers, return None.
 	log.Debugf("enter compareByASNumber")
 
-	log.Debugf("compareByASNumber -- p1Asn: %d, p2Asn: %d", path1.source.AS, path2.source.AS)
+	log.Debugf("compareByASNumber -- p1Asn: %d, p2Asn: %d", path1.GetSource().AS, path2.GetSource().AS)
 	// If one path is from ibgp peer and another is from ebgp peer, take the ebgp path
 	if path1.IsIBGP() != path2.IsIBGP() {
 		if path1.IsIBGP() {
@@ -734,8 +734,8 @@ func compareByRouterID(path1, path2 *Path) (*Path, error) {
 	}
 
 	// At least one path is not coming from NC, so we get local bgp id.
-	id1 := binary.BigEndian.Uint32(path1.source.ID)
-	id2 := binary.BigEndian.Uint32(path2.source.ID)
+	id1 := binary.BigEndian.Uint32(path1.GetSource().ID)
+	id2 := binary.BigEndian.Uint32(path2.GetSource().ID)
 
 	// If both router ids are same/equal we cannot decide.
 	// This case is possible since router ids are arbitrary.
diff --git a/table/message.go b/table/message.go
index ecd1610c..02cdaf3b 100644
--- a/table/message.go
+++ b/table/message.go
@@ -198,12 +198,6 @@ func UpdatePathAttrs4ByteAs(msg *bgp.BGPUpdate) error {
 	return nil
 }
 
-func cloneAttrSlice(attrs []bgp.PathAttributeInterface) []bgp.PathAttributeInterface {
-	clonedAttrs := make([]bgp.PathAttributeInterface, 0)
-	clonedAttrs = append(clonedAttrs, attrs...)
-	return clonedAttrs
-}
-
 func createUpdateMsgFromPath(path *Path, msg *bgp.BGPMessage) *bgp.BGPMessage {
 	rf := path.GetRouteFamily()
 
@@ -229,37 +223,47 @@ func createUpdateMsgFromPath(path *Path, msg *bgp.BGPMessage) *bgp.BGPMessage {
 	} else {
 		if path.IsWithdraw {
 			if msg != nil {
-				idx, _ := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_UNREACH_NLRI)
 				u := msg.Body.(*bgp.BGPUpdate)
-				unreach := u.PathAttributes[idx].(*bgp.PathAttributeMpUnreachNLRI)
-				unreach.Value = append(unreach.Value, path.GetNlri())
+				for _, p := range u.PathAttributes {
+					if p.GetType() == bgp.BGP_ATTR_TYPE_MP_UNREACH_NLRI {
+						unreach := p.(*bgp.PathAttributeMpUnreachNLRI)
+						unreach.Value = append(unreach.Value, path.GetNlri())
+					}
+				}
 			} else {
-				clonedAttrs := cloneAttrSlice(path.GetPathAttrs())
-				idx, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+				var nlris []bgp.AddrPrefixInterface
+				attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 				if attr == nil {
 					// for bmp post-policy
-					idx, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_UNREACH_NLRI)
-					reach := attr.(*bgp.PathAttributeMpUnreachNLRI)
-					clonedAttrs[idx] = bgp.NewPathAttributeMpUnreachNLRI(reach.Value)
+					attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_UNREACH_NLRI)
+					nlris = attr.(*bgp.PathAttributeMpUnreachNLRI).Value
 				} else {
-					reach := attr.(*bgp.PathAttributeMpReachNLRI)
-					clonedAttrs[idx] = bgp.NewPathAttributeMpUnreachNLRI(reach.Value)
+					nlris = attr.(*bgp.PathAttributeMpReachNLRI).Value
+				}
+
+				clonedAttrs := path.GetPathAttrs()
+				for i, a := range clonedAttrs {
+					if a.GetType() == bgp.BGP_ATTR_TYPE_MP_UNREACH_NLRI || a.GetType() == bgp.BGP_ATTR_TYPE_MP_REACH_NLRI {
+						clonedAttrs[i] = bgp.NewPathAttributeMpUnreachNLRI(nlris)
+						break
+					}
 				}
 				return bgp.NewBGPUpdateMessage(nil, clonedAttrs, nil)
 			}
 		} else {
 			if msg != nil {
-				idx, _ := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 				u := msg.Body.(*bgp.BGPUpdate)
-				reachAttr := u.PathAttributes[idx].(*bgp.PathAttributeMpReachNLRI)
-				u.PathAttributes[idx] = bgp.NewPathAttributeMpReachNLRI(reachAttr.Nexthop.String(),
-					append(reachAttr.Value, path.GetNlri()))
+				for _, p := range u.PathAttributes {
+					if p.GetType() == bgp.BGP_ATTR_TYPE_MP_REACH_NLRI {
+						reach := p.(*bgp.PathAttributeMpReachNLRI)
+						reach.Value = append(reach.Value, path.GetNlri())
+					}
+				}
 			} else {
 				// we don't need to clone here but we
 				// might merge path to this message in
 				// the future so let's clone anyway.
-				clonedAttrs := cloneAttrSlice(path.GetPathAttrs())
-				return bgp.NewBGPUpdateMessage(nil, clonedAttrs, nil)
+				return bgp.NewBGPUpdateMessage(nil, path.GetPathAttrs(), nil)
 			}
 		}
 	}
diff --git a/table/path.go b/table/path.go
index fc9380a7..c647a7cc 100644
--- a/table/path.go
+++ b/table/path.go
@@ -28,20 +28,44 @@ import (
 	"time"
 )
 
-type Path struct {
-	source             *PeerInfo
-	IsWithdraw         bool
+type Bitmap []uint64
+
+func (b Bitmap) Flag(i uint) {
+	b[i/64] |= 1 << uint(i%64)
+}
+
+func (b Bitmap) Unflag(i uint) {
+	b[i/64] &^= 1 << uint(i%64)
+}
+
+func (b Bitmap) GetFlag(i uint) bool {
+	return b[i/64]&(1<<uint(i%64)) > 0
+}
+
+func NewBitmap(size int) Bitmap {
+	return Bitmap(make([]uint64, size/64+1))
+}
+
+type originInfo struct {
 	nlri               bgp.AddrPrefixInterface
-	pathAttrs          []bgp.PathAttributeInterface
+	source             *PeerInfo
 	timestamp          time.Time
-	NoImplicitWithdraw bool
-	Validation         config.RpkiValidationResultType
-	IsFromZebra        bool
-	Owner              net.IP
-	reason             BestPathReason
-	filtered           map[string]PolicyDirection
+	noImplicitWithdraw bool
+	validation         config.RpkiValidationResultType
+	isFromZebra        bool
 	key                string
-	Uuid               []byte
+	uuid               []byte
+}
+
+type Path struct {
+	info       *originInfo
+	IsWithdraw bool
+	pathAttrs  []bgp.PathAttributeInterface
+	Owner      net.IP
+	reason     BestPathReason
+	parent     *Path
+	dels       []bgp.BGPAttrType
+	filtered   map[string]PolicyDirection
 }
 
 func NewPath(source *PeerInfo, nlri bgp.AddrPrefixInterface, isWithdraw bool, pattrs []bgp.PathAttributeInterface, timestamp time.Time, noImplicitWithdraw bool) *Path {
@@ -60,14 +84,16 @@ func NewPath(source *PeerInfo, nlri bgp.AddrPrefixInterface, isWithdraw bool, pa
 	}
 
 	return &Path{
-		source:             source,
-		IsWithdraw:         isWithdraw,
-		nlri:               nlri,
-		pathAttrs:          pattrs,
-		timestamp:          timestamp,
-		NoImplicitWithdraw: noImplicitWithdraw,
-		Owner:              owner,
-		filtered:           make(map[string]PolicyDirection),
+		info: &originInfo{
+			nlri:               nlri,
+			source:             source,
+			timestamp:          timestamp,
+			noImplicitWithdraw: noImplicitWithdraw,
+		},
+		IsWithdraw: isWithdraw,
+		pathAttrs:  pattrs,
+		Owner:      owner,
+		filtered:   make(map[string]PolicyDirection),
 	}
 }
 
@@ -97,15 +123,13 @@ func (path *Path) UpdatePathAttrs(global *config.Global, peer *config.Neighbor)
 		path.PrependAsn(global.Config.As, 1)
 
 		// MED Handling
-		idx, _ := path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
-		if idx >= 0 && !path.IsLocal() {
-			path.pathAttrs = append(path.pathAttrs[:idx], path.pathAttrs[idx+1:]...)
+		if med := path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC); med != nil && !path.IsLocal() {
+			path.delPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 		}
 
 		// remove local-pref attribute
-		idx, _ = path.getPathAttr(bgp.BGP_ATTR_TYPE_LOCAL_PREF)
-		if idx >= 0 && !config.IsConfederationMember(global, peer) {
-			path.pathAttrs = append(path.pathAttrs[:idx], path.pathAttrs[idx+1:]...)
+		if pref := path.getPathAttr(bgp.BGP_ATTR_TYPE_LOCAL_PREF); pref != nil && !config.IsConfederationMember(global, peer) {
+			path.delPathAttr(bgp.BGP_ATTR_TYPE_LOCAL_PREF)
 		}
 
 	} else if peer.Config.PeerType == config.PEER_TYPE_INTERNAL {
@@ -121,47 +145,38 @@ func (path *Path) UpdatePathAttrs(global *config.Global, peer *config.Neighbor)
 		// AS_PATH handling for iBGP
 		// if the path has AS_PATH path attribute, don't modify it.
 		// if not, attach *empty* AS_PATH path attribute.
-		idx, _ := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
-		if idx < 0 {
+		if nh := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH); nh == nil {
 			path.PrependAsn(0, 0)
 		}
 
 		// For iBGP peers we are required to send local-pref attribute
 		// for connected or local prefixes.
 		// We set default local-pref 100.
-		p := bgp.NewPathAttributeLocalPref(100)
-		idx, _ = path.getPathAttr(bgp.BGP_ATTR_TYPE_LOCAL_PREF)
-		if idx < 0 {
-			path.pathAttrs = append(path.pathAttrs, p)
-		} else if !path.IsLocal() {
-			path.pathAttrs[idx] = p
+		if pref := path.getPathAttr(bgp.BGP_ATTR_TYPE_LOCAL_PREF); pref == nil || !path.IsLocal() {
+			path.setPathAttr(bgp.NewPathAttributeLocalPref(100))
 		}
 
 		// RFC4456: BGP Route Reflection
 		// 8. Avoiding Routing Information Loops
-		info := path.source
+		info := path.GetSource()
 		if peer.RouteReflector.Config.RouteReflectorClient {
 			// This attribute will carry the BGP Identifier of the originator of the route in the local AS.
 			// A BGP speaker SHOULD NOT create an ORIGINATOR_ID attribute if one already exists.
-			idx, _ = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGINATOR_ID)
-			if idx < 0 {
-				p := bgp.NewPathAttributeOriginatorId(info.ID.String())
-				path.pathAttrs = append(path.pathAttrs, p)
+			if path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGINATOR_ID) == nil {
+				path.setPathAttr(bgp.NewPathAttributeOriginatorId(info.ID.String()))
 			}
 			// When an RR reflects a route, it MUST prepend the local CLUSTER_ID to the CLUSTER_LIST.
 			// If the CLUSTER_LIST is empty, it MUST create a new one.
-			idx, _ = path.getPathAttr(bgp.BGP_ATTR_TYPE_CLUSTER_LIST)
 			id := string(peer.RouteReflector.Config.RouteReflectorClusterId)
-			if idx < 0 {
-				p := bgp.NewPathAttributeClusterList([]string{id})
-				path.pathAttrs = append(path.pathAttrs, p)
+			if p := path.getPathAttr(bgp.BGP_ATTR_TYPE_CLUSTER_LIST); p == nil {
+				path.setPathAttr(bgp.NewPathAttributeClusterList([]string{id}))
 			} else {
-				p := path.pathAttrs[idx].(*bgp.PathAttributeClusterList)
-				newClusterList := make([]string, 0, len(p.Value))
-				for _, ip := range p.Value {
+				clusterList := p.(*bgp.PathAttributeClusterList)
+				newClusterList := make([]string, 0, len(clusterList.Value))
+				for _, ip := range clusterList.Value {
 					newClusterList = append(newClusterList, ip.String())
 				}
-				path.pathAttrs[idx] = bgp.NewPathAttributeClusterList(append([]string{id}, newClusterList...))
+				path.setPathAttr(bgp.NewPathAttributeClusterList(append([]string{id}, newClusterList...)))
 			}
 		}
 
@@ -174,19 +189,19 @@ func (path *Path) UpdatePathAttrs(global *config.Global, peer *config.Neighbor)
 }
 
 func (path *Path) GetTimestamp() time.Time {
-	return path.timestamp
+	return path.OriginInfo().timestamp
 }
 
 func (path *Path) setTimestamp(t time.Time) {
-	path.timestamp = t
+	path.OriginInfo().timestamp = t
 }
 
 func (path *Path) IsLocal() bool {
-	return path.source.Address == nil
+	return path.GetSource().Address == nil
 }
 
 func (path *Path) IsIBGP() bool {
-	return path.source.AS == path.source.LocalAS
+	return path.GetSource().AS == path.GetSource().LocalAS
 }
 
 func (path *Path) ToApiStruct(id string) *api.Path {
@@ -204,9 +219,9 @@ func (path *Path) ToApiStruct(id string) *api.Path {
 	return &api.Path{
 		Nlri:       n,
 		Pattrs:     pattrs,
-		Age:        int64(time.Now().Sub(path.timestamp).Seconds()),
+		Age:        int64(time.Now().Sub(path.OriginInfo().timestamp).Seconds()),
 		IsWithdraw: path.IsWithdraw,
-		Validation: int32(path.Validation.ToInt()),
+		Validation: int32(path.OriginInfo().validation.ToInt()),
 		Filtered:   path.Filtered(id) > POLICY_DIRECTION_NONE,
 		Family:     family,
 	}
@@ -214,18 +229,54 @@ func (path *Path) ToApiStruct(id string) *api.Path {
 
 // create new PathAttributes
 func (path *Path) Clone(owner net.IP, isWithdraw bool) *Path {
-	newPathAttrs := make([]bgp.PathAttributeInterface, len(path.pathAttrs))
-	for i, v := range path.pathAttrs {
-		newPathAttrs[i] = v
+	return &Path{
+		parent:     path,
+		IsWithdraw: isWithdraw,
+		Owner:      owner,
+		filtered:   make(map[string]PolicyDirection),
 	}
+}
 
-	p := NewPath(path.source, path.nlri, isWithdraw, newPathAttrs, path.timestamp, path.NoImplicitWithdraw)
-	p.Validation = path.Validation
-	p.Owner = owner
-	p.key = path.key
+func (path *Path) root() *Path {
+	p := path
+	for p.parent != nil {
+		p = p.parent
+	}
 	return p
 }
 
+func (path *Path) OriginInfo() *originInfo {
+	return path.root().info
+}
+
+func (path *Path) NoImplicitWithdraw() bool {
+	return path.OriginInfo().noImplicitWithdraw
+}
+
+func (path *Path) Validation() config.RpkiValidationResultType {
+	return path.OriginInfo().validation
+}
+
+func (path *Path) SetValidation(r config.RpkiValidationResultType) {
+	path.OriginInfo().validation = r
+}
+
+func (path *Path) IsFromZebra() bool {
+	return path.OriginInfo().isFromZebra
+}
+
+func (path *Path) SetIsFromZebra(y bool) {
+	path.OriginInfo().isFromZebra = y
+}
+
+func (path *Path) UUID() []byte {
+	return path.OriginInfo().uuid
+}
+
+func (path *Path) SetUUID(uuid []byte) {
+	path.OriginInfo().uuid = uuid
+}
+
 func (path *Path) Filter(id string, reason PolicyDirection) {
 	path.filtered[id] = reason
 }
@@ -235,18 +286,18 @@ func (path *Path) Filtered(id string) PolicyDirection {
 }
 
 func (path *Path) GetRouteFamily() bgp.RouteFamily {
-	return bgp.AfiSafiToRouteFamily(path.nlri.AFI(), path.nlri.SAFI())
+	return bgp.AfiSafiToRouteFamily(path.OriginInfo().nlri.AFI(), path.OriginInfo().nlri.SAFI())
 }
 
 func (path *Path) setSource(source *PeerInfo) {
-	path.source = source
+	path.OriginInfo().source = source
 }
 func (path *Path) GetSource() *PeerInfo {
-	return path.source
+	return path.OriginInfo().source
 }
 
 func (path *Path) GetSourceAs() uint32 {
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	if attr != nil {
 		asPathParam := attr.(*bgp.PathAttributeAsPath).Value
 		if len(asPathParam) == 0 {
@@ -262,11 +313,11 @@ func (path *Path) GetSourceAs() uint32 {
 }
 
 func (path *Path) GetNexthop() net.IP {
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 	if attr != nil {
 		return attr.(*bgp.PathAttributeNextHop).Value
 	}
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 	if attr != nil {
 		return attr.(*bgp.PathAttributeMpReachNLRI).Nexthop
 	}
@@ -274,34 +325,82 @@ func (path *Path) GetNexthop() net.IP {
 }
 
 func (path *Path) SetNexthop(nexthop net.IP) {
-	idx, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 	if attr != nil {
-		newNexthop := bgp.NewPathAttributeNextHop(nexthop.String())
-		path.pathAttrs[idx] = newNexthop
+		path.setPathAttr(bgp.NewPathAttributeNextHop(nexthop.String()))
 	}
-	idx, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 	if attr != nil {
 		oldNlri := attr.(*bgp.PathAttributeMpReachNLRI)
-		newNlri := bgp.NewPathAttributeMpReachNLRI(nexthop.String(), oldNlri.Value)
-		path.pathAttrs[idx] = newNlri
+		path.setPathAttr(bgp.NewPathAttributeMpReachNLRI(nexthop.String(), oldNlri.Value))
 	}
 }
 
 func (path *Path) GetNlri() bgp.AddrPrefixInterface {
-	return path.nlri
+	return path.OriginInfo().nlri
 }
 
 func (path *Path) GetPathAttrs() []bgp.PathAttributeInterface {
-	return path.pathAttrs
+	seen := NewBitmap(math.MaxUint8)
+	list := make([]bgp.PathAttributeInterface, 0, 4)
+	p := path
+	for {
+		for _, t := range p.dels {
+			seen.Flag(uint(t))
+		}
+		for _, a := range p.pathAttrs {
+			if typ := uint(a.GetType()); !seen.GetFlag(typ) {
+				list = append(list, a)
+				seen.Flag(typ)
+			}
+		}
+		if p.parent == nil {
+			return list
+		}
+		p = p.parent
+	}
+}
+
+func (path *Path) getPathAttr(typ bgp.BGPAttrType) bgp.PathAttributeInterface {
+	p := path
+	for {
+		for _, t := range p.dels {
+			if t == typ {
+				return nil
+			}
+		}
+		for _, a := range p.pathAttrs {
+			if a.GetType() == typ {
+				return a
+			}
+		}
+		if p.parent == nil {
+			return nil
+		}
+		p = p.parent
+	}
 }
 
-func (path *Path) getPathAttr(pattrType bgp.BGPAttrType) (int, bgp.PathAttributeInterface) {
-	for i, p := range path.pathAttrs {
-		if p.GetType() == pattrType {
-			return i, p
+func (path *Path) setPathAttr(a bgp.PathAttributeInterface) {
+	if len(path.pathAttrs) == 0 {
+		path.pathAttrs = []bgp.PathAttributeInterface{a}
+	} else {
+		for i, b := range path.pathAttrs {
+			if a.GetType() == b.GetType() {
+				path.pathAttrs[i] = a
+				return
+			}
 		}
+		path.pathAttrs = append(path.pathAttrs, a)
+	}
+}
+
+func (path *Path) delPathAttr(typ bgp.BGPAttrType) {
+	if len(path.dels) == 0 {
+		path.dels = []bgp.BGPAttrType{typ}
+	} else {
+		path.dels = append(path.dels, typ)
 	}
-	return -1, nil
 }
 
 // return Path's string representation
@@ -318,14 +417,14 @@ func (path *Path) String() string {
 }
 
 func (path *Path) getPrefix() string {
-	if path.key == "" {
-		return path.nlri.String()
+	if path.OriginInfo().key == "" {
+		path.OriginInfo().key = path.GetNlri().String()
 	}
-	return path.key
+	return path.OriginInfo().key
 }
 
 func (path *Path) GetAsPath() *bgp.PathAttributeAsPath {
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	if attr != nil {
 		return attr.(*bgp.PathAttributeAsPath)
 	}
@@ -336,8 +435,7 @@ func (path *Path) GetAsPath() *bgp.PathAttributeAsPath {
 func (path *Path) GetAsPathLen() int {
 
 	var length int = 0
-	if _, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH); attr != nil {
-		aspath := attr.(*bgp.PathAttributeAsPath)
+	if aspath := path.GetAsPath(); aspath != nil {
 		for _, as := range aspath.Value {
 			length += as.ASLen()
 		}
@@ -347,8 +445,7 @@ func (path *Path) GetAsPathLen() int {
 
 func (path *Path) GetAsString() string {
 	s := bytes.NewBuffer(make([]byte, 0, 64))
-	if _, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH); attr != nil {
-		aspath := attr.(*bgp.PathAttributeAsPath)
+	if aspath := path.GetAsPath(); aspath != nil {
 		for i, paramIf := range aspath.Value {
 			segment := paramIf.(*bgp.As4PathParam)
 			if i != 0 {
@@ -388,8 +485,7 @@ func (path *Path) GetAsSeqList() []uint32 {
 
 func (path *Path) getAsListofSpecificType(getAsSeq, getAsSet bool) []uint32 {
 	asList := []uint32{}
-	if _, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH); attr != nil {
-		aspath := attr.(*bgp.PathAttributeAsPath)
+	if aspath := path.GetAsPath(); aspath != nil {
 		for _, paramIf := range aspath.Value {
 			segment := paramIf.(*bgp.As4PathParam)
 			if getAsSeq && segment.Type == bgp.BGP_ASPATH_ATTR_TYPE_SEQ {
@@ -428,7 +524,7 @@ func (path *Path) getAsListofSpecificType(getAsSeq, getAsSet bool) []uint32 {
 //     into that segment, and places that segment into the AS_PATH.
 func (path *Path) PrependAsn(asn uint32, repeat uint8) {
 
-	idx, original := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	original := path.GetAsPath()
 
 	asns := make([]uint32, repeat)
 	for i, _ := range asns {
@@ -436,12 +532,10 @@ func (path *Path) PrependAsn(asn uint32, repeat uint8) {
 	}
 
 	var asPath *bgp.PathAttributeAsPath
-	if idx < 0 {
+	if original == nil {
 		asPath = bgp.NewPathAttributeAsPath([]bgp.AsPathParamInterface{})
-		path.pathAttrs = append(path.pathAttrs, asPath)
 	} else {
-		asPath = cloneAsPath(original.(*bgp.PathAttributeAsPath))
-		path.pathAttrs[idx] = asPath
+		asPath = cloneAsPath(original)
 	}
 
 	if len(asPath.Value) > 0 {
@@ -460,11 +554,12 @@ func (path *Path) PrependAsn(asn uint32, repeat uint8) {
 		p := bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, asns)
 		asPath.Value = append([]bgp.AsPathParamInterface{p}, asPath.Value...)
 	}
+	path.setPathAttr(asPath)
 }
 
 func (path *Path) GetCommunities() []uint32 {
 	communityList := []uint32{}
-	if _, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_COMMUNITIES); attr != nil {
+	if attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_COMMUNITIES); attr != nil {
 		communities := attr.(*bgp.PathAttributeCommunities)
 		communityList = append(communityList, communities.Value...)
 	}
@@ -477,12 +572,12 @@ func (path *Path) SetCommunities(communities []uint32, doReplace bool) {
 
 	if len(communities) == 0 && doReplace {
 		// clear communities
-		path.ClearCommunities()
+		path.delPathAttr(bgp.BGP_ATTR_TYPE_COMMUNITIES)
 		return
 	}
 
 	newList := make([]uint32, 0)
-	idx, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_COMMUNITIES)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_COMMUNITIES)
 	if attr != nil {
 		c := attr.(*bgp.PathAttributeCommunities)
 		if doReplace {
@@ -491,13 +586,10 @@ func (path *Path) SetCommunities(communities []uint32, doReplace bool) {
 			newList = append(newList, c.Value...)
 			newList = append(newList, communities...)
 		}
-		newCommunities := bgp.NewPathAttributeCommunities(newList)
-		path.pathAttrs[idx] = newCommunities
 	} else {
 		newList = append(newList, communities...)
-		newCommunities := bgp.NewPathAttributeCommunities(newList)
-		path.pathAttrs = append(path.pathAttrs, newCommunities)
 	}
+	path.setPathAttr(bgp.NewPathAttributeCommunities(newList))
 
 }
 
@@ -521,7 +613,7 @@ func (path *Path) RemoveCommunities(communities []uint32) int {
 	}
 
 	count := 0
-	idx, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_COMMUNITIES)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_COMMUNITIES)
 	if attr != nil {
 		newList := make([]uint32, 0)
 		c := attr.(*bgp.PathAttributeCommunities)
@@ -535,26 +627,17 @@ func (path *Path) RemoveCommunities(communities []uint32) int {
 		}
 
 		if len(newList) != 0 {
-			newCommunities := bgp.NewPathAttributeCommunities(newList)
-			path.pathAttrs[idx] = newCommunities
+			path.setPathAttr(bgp.NewPathAttributeCommunities(newList))
 		} else {
-			path.pathAttrs = append(path.pathAttrs[:idx], path.pathAttrs[idx+1:]...)
+			path.delPathAttr(bgp.BGP_ATTR_TYPE_COMMUNITIES)
 		}
 	}
 	return count
 }
 
-// ClearCommunities removes Communities path attribute.
-func (path *Path) ClearCommunities() {
-	idx, _ := path.getPathAttr(bgp.BGP_ATTR_TYPE_COMMUNITIES)
-	if idx >= 0 {
-		path.pathAttrs = append(path.pathAttrs[:idx], path.pathAttrs[idx+1:]...)
-	}
-}
-
 func (path *Path) GetExtCommunities() []bgp.ExtendedCommunityInterface {
 	eCommunityList := make([]bgp.ExtendedCommunityInterface, 0)
-	if _, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_EXTENDED_COMMUNITIES); attr != nil {
+	if attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_EXTENDED_COMMUNITIES); attr != nil {
 		eCommunities := attr.(*bgp.PathAttributeExtendedCommunities).Value
 		for _, eCommunity := range eCommunities {
 			eCommunityList = append(eCommunityList, eCommunity)
@@ -564,7 +647,7 @@ func (path *Path) GetExtCommunities() []bgp.ExtendedCommunityInterface {
 }
 
 func (path *Path) SetExtCommunities(exts []bgp.ExtendedCommunityInterface, doReplace bool) {
-	idx, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_EXTENDED_COMMUNITIES)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_EXTENDED_COMMUNITIES)
 	if attr != nil {
 		l := attr.(*bgp.PathAttributeExtendedCommunities).Value
 		if doReplace {
@@ -572,14 +655,14 @@ func (path *Path) SetExtCommunities(exts []bgp.ExtendedCommunityInterface, doRep
 		} else {
 			l = append(l, exts...)
 		}
-		path.pathAttrs[idx] = bgp.NewPathAttributeExtendedCommunities(l)
+		path.setPathAttr(bgp.NewPathAttributeExtendedCommunities(l))
 	} else {
-		path.pathAttrs = append(path.pathAttrs, bgp.NewPathAttributeExtendedCommunities(exts))
+		path.setPathAttr(bgp.NewPathAttributeExtendedCommunities(exts))
 	}
 }
 
 func (path *Path) GetMed() (uint32, error) {
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	if attr == nil {
 		return 0, fmt.Errorf("no med path attr")
 	}
@@ -604,34 +687,27 @@ func (path *Path) SetMed(med int64, doReplace bool) error {
 		return newMed, nil
 	}
 
-	idx, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
-	if attr != nil {
-		m := attr.(*bgp.PathAttributeMultiExitDisc)
-		newMed, err := parseMed(m.Value, med, doReplace)
-		if err != nil {
-			return err
-		}
-		path.pathAttrs[idx] = newMed
-	} else {
-		m := 0
-		newMed, err := parseMed(uint32(m), med, doReplace)
-		if err != nil {
-			return err
-		}
-		path.pathAttrs = append(path.pathAttrs, newMed)
+	m := uint32(0)
+	if attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC); attr != nil {
+		m = attr.(*bgp.PathAttributeMultiExitDisc).Value
+	}
+	newMed, err := parseMed(m, med, doReplace)
+	if err != nil {
+		return err
 	}
+	path.setPathAttr(newMed)
 	return nil
 }
 
 func (path *Path) GetOriginatorID() net.IP {
-	if _, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGINATOR_ID); attr != nil {
+	if attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGINATOR_ID); attr != nil {
 		return attr.(*bgp.PathAttributeOriginatorId).Value
 	}
 	return nil
 }
 
 func (path *Path) GetClusterList() []net.IP {
-	if _, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_CLUSTER_LIST); attr != nil {
+	if attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_CLUSTER_LIST); attr != nil {
 		return attr.(*bgp.PathAttributeClusterList).Value
 	}
 	return nil
diff --git a/table/path_test.go b/table/path_test.go
index 48dec6fe..bcc532a1 100644
--- a/table/path_test.go
+++ b/table/path_test.go
@@ -24,26 +24,12 @@ func TestPathNewIPv6(t *testing.T) {
 	assert.NotNil(t, ipv6p)
 }
 
-func TestPathSetSource(t *testing.T) {
-	pd := &Path{}
-	pr := &PeerInfo{AS: 65000}
-	pd.setSource(pr)
-	r_pr := pd.GetSource()
-	assert.Equal(t, r_pr, pr)
-}
-
-func TestPathGetSource(t *testing.T) {
-	pd := &Path{}
-	pr := &PeerInfo{AS: 65001}
-	pd.setSource(pr)
-	r_pr := pd.GetSource()
-	assert.Equal(t, r_pr, pr)
-}
-
 func TestPathGetNlri(t *testing.T) {
 	nlri := bgp.NewIPAddrPrefix(24, "13.2.3.2")
 	pd := &Path{
-		nlri: nlri,
+		info: &originInfo{
+			nlri: nlri,
+		},
 	}
 	r_nlri := pd.GetNlri()
 	assert.Equal(t, r_nlri, nlri)
@@ -72,7 +58,7 @@ 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)
+	pa := pathP[0].getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 	r_nh := pa.(*bgp.PathAttributeNextHop).Value.String()
 	assert.Equal(t, r_nh, nh)
 }
diff --git a/table/policy.go b/table/policy.go
index be9ba5ad..4484e7e6 100644
--- a/table/policy.go
+++ b/table/policy.go
@@ -1562,7 +1562,7 @@ func (c *RpkiValidationCondition) Type() ConditionType {
 }
 
 func (c *RpkiValidationCondition) Evaluate(path *Path) bool {
-	return c.result == path.Validation
+	return c.result == path.Validation()
 }
 
 func (c *RpkiValidationCondition) Set() DefinedSet {
diff --git a/table/table.go b/table/table.go
index 36a29ed4..ecc067b4 100644
--- a/table/table.go
+++ b/table/table.go
@@ -72,7 +72,7 @@ func (t *Table) deletePathsByVrf(vrf *Vrf) []*Path {
 	for _, dest := range t.destinations {
 		for _, p := range dest.knownPathList {
 			var rd bgp.RouteDistinguisherInterface
-			nlri := p.nlri
+			nlri := p.GetNlri()
 			switch nlri.(type) {
 			case *bgp.LabeledVPNIPAddrPrefix:
 				rd = nlri.(*bgp.LabeledVPNIPAddrPrefix).RD
@@ -146,7 +146,7 @@ func (t *Table) validatePath(path *Path) {
 			"ReceivedRf": path.GetRouteFamily().String(),
 		}).Error("Invalid path. RouteFamily mismatch")
 	}
-	if _, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH); attr != nil {
+	if attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH); attr != nil {
 		pathParam := attr.(*bgp.PathAttributeAsPath).Value
 		for _, as := range pathParam {
 			_, y := as.(*bgp.As4PathParam)
@@ -159,7 +159,7 @@ func (t *Table) validatePath(path *Path) {
 			}
 		}
 	}
-	if _, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS4_PATH); attr != nil {
+	if attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_AS4_PATH); attr != nil {
 		log.WithFields(log.Fields{
 			"Topic": "Table",
 			"Key":   t.routeFamily,
diff --git a/table/table_manager_test.go b/table/table_manager_test.go
index 791c6c48..61019781 100644
--- a/table/table_manager_test.go
+++ b/table/table_manager_test.go
@@ -101,22 +101,22 @@ func TestProcessBGPUpdate_0_select_onlypath_ipv4(t *testing.T) {
 	// check PathAttribute
 	pathAttributes := bgpMessage.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 	pathNexthop := attr.(*bgp.PathAttributeNextHop)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -152,22 +152,22 @@ func TestProcessBGPUpdate_0_select_onlypath_ipv6(t *testing.T) {
 	pathAttributes := bgpMessage.Body.(*bgp.BGPUpdate).PathAttributes
 
 	expectedNexthopAttr := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 	pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -233,22 +233,22 @@ func TestProcessBGPUpdate_1_select_high_localpref_ipv4(t *testing.T) {
 	// check PathAttribute
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 	pathNexthop := attr.(*bgp.PathAttributeNextHop)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -314,22 +314,22 @@ func TestProcessBGPUpdate_1_select_high_localpref_ipv6(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 
 	expectedNexthopAttr := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 	pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -397,22 +397,22 @@ func TestProcessBGPUpdate_2_select_local_origin_ipv4(t *testing.T) {
 	// check PathAttribute
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 	pathNexthop := attr.(*bgp.PathAttributeNextHop)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -481,22 +481,22 @@ func TestProcessBGPUpdate_2_select_local_origin_ipv6(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 
 	expectedNexthopAttr := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 	pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -537,22 +537,22 @@ func TestProcessBGPUpdate_3_select_aspath_ipv4(t *testing.T) {
 	// check PathAttribute
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 	pathNexthop := attr.(*bgp.PathAttributeNextHop)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -593,22 +593,22 @@ func TestProcessBGPUpdate_3_select_aspath_ipv6(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 
 	expectedNexthopAttr := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 	pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -674,22 +674,22 @@ func TestProcessBGPUpdate_4_select_low_origin_ipv4(t *testing.T) {
 	// check PathAttribute
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 	pathNexthop := attr.(*bgp.PathAttributeNextHop)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -755,22 +755,22 @@ func TestProcessBGPUpdate_4_select_low_origin_ipv6(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 
 	expectedNexthopAttr := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 	pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -836,22 +836,22 @@ func TestProcessBGPUpdate_5_select_low_med_ipv4(t *testing.T) {
 	// check PathAttribute
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 	pathNexthop := attr.(*bgp.PathAttributeNextHop)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -917,22 +917,22 @@ func TestProcessBGPUpdate_5_select_low_med_ipv6(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 
 	expectedNexthopAttr := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 	pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -998,22 +998,22 @@ func TestProcessBGPUpdate_6_select_ebgp_path_ipv4(t *testing.T) {
 	// check PathAttribute
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 	pathNexthop := attr.(*bgp.PathAttributeNextHop)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -1079,22 +1079,22 @@ func TestProcessBGPUpdate_6_select_ebgp_path_ipv6(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 
 	expectedNexthopAttr := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 	pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -1162,22 +1162,22 @@ func TestProcessBGPUpdate_7_select_low_routerid_path_ipv4(t *testing.T) {
 	// check PathAttribute
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 	pathNexthop := attr.(*bgp.PathAttributeNextHop)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -1243,22 +1243,22 @@ func TestProcessBGPUpdate_7_select_low_routerid_path_ipv6(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 
 	expectedNexthopAttr := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 	pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -1325,22 +1325,22 @@ func TestProcessBGPUpdate_8_withdraw_path_ipv4(t *testing.T) {
 	checkPattr := func(expected *bgp.BGPMessage, actual *Path) {
 		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
 		expectedOrigin := pathAttributes[0]
-		_, attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+		attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 		pathOrigin := attr.(*bgp.PathAttributeOrigin)
 		assert.Equal(t, expectedOrigin, pathOrigin)
 
 		expectedAsPath := pathAttributes[1]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 		pathAspath := attr.(*bgp.PathAttributeAsPath)
 		assert.Equal(t, expectedAsPath, pathAspath)
 
 		expectedNexthopAttr := pathAttributes[2]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 		pathNexthop := attr.(*bgp.PathAttributeNextHop)
 		assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 		expectedMed := pathAttributes[3]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 		pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 		assert.Equal(t, expectedMed, pathMed)
 
@@ -1428,22 +1428,22 @@ func TestProcessBGPUpdate_8_mpunreach_path_ipv6(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 
 	expectedNexthopAttr := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 	pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -1452,22 +1452,22 @@ func TestProcessBGPUpdate_8_mpunreach_path_ipv6(t *testing.T) {
 		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
 
 		expectedNexthopAttr := pathAttributes[0]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 		pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 		assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 		expectedOrigin := pathAttributes[1]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 		pathOrigin := attr.(*bgp.PathAttributeOrigin)
 		assert.Equal(t, expectedOrigin, pathOrigin)
 
 		expectedAsPath := pathAttributes[2]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 		pathAspath := attr.(*bgp.PathAttributeAsPath)
 		assert.Equal(t, expectedAsPath, pathAspath)
 
 		expectedMed := pathAttributes[3]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 		pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 		assert.Equal(t, expectedMed, pathMed)
 		// check PathAttribute length
@@ -1547,22 +1547,22 @@ func TestProcessBGPUpdate_bestpath_lost_ipv4(t *testing.T) {
 	checkPattr := func(expected *bgp.BGPMessage, actual *Path) {
 		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
 		expectedOrigin := pathAttributes[0]
-		_, attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+		attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 		pathOrigin := attr.(*bgp.PathAttributeOrigin)
 		assert.Equal(t, expectedOrigin, pathOrigin)
 
 		expectedAsPath := pathAttributes[1]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 		pathAspath := attr.(*bgp.PathAttributeAsPath)
 		assert.Equal(t, expectedAsPath, pathAspath)
 
 		expectedNexthopAttr := pathAttributes[2]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 		pathNexthop := attr.(*bgp.PathAttributeNextHop)
 		assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 		expectedMed := pathAttributes[3]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 		pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 		assert.Equal(t, expectedMed, pathMed)
 
@@ -1617,22 +1617,22 @@ func TestProcessBGPUpdate_bestpath_lost_ipv6(t *testing.T) {
 		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
 
 		expectedNexthopAttr := pathAttributes[0]
-		_, attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+		attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 		pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 		assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 		expectedOrigin := pathAttributes[1]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 		pathOrigin := attr.(*bgp.PathAttributeOrigin)
 		assert.Equal(t, expectedOrigin, pathOrigin)
 
 		expectedAsPath := pathAttributes[2]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 		pathAspath := attr.(*bgp.PathAttributeAsPath)
 		assert.Equal(t, expectedAsPath, pathAspath)
 
 		expectedMed := pathAttributes[3]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 		pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 		assert.Equal(t, expectedMed, pathMed)
 		// check PathAttribute length
@@ -1696,22 +1696,22 @@ func TestProcessBGPUpdate_implicit_withdrwal_ipv4(t *testing.T) {
 	checkPattr := func(expected *bgp.BGPMessage, actual *Path) {
 		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
 		expectedOrigin := pathAttributes[0]
-		_, attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+		attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 		pathOrigin := attr.(*bgp.PathAttributeOrigin)
 		assert.Equal(t, expectedOrigin, pathOrigin)
 
 		expectedAsPath := pathAttributes[1]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 		pathAspath := attr.(*bgp.PathAttributeAsPath)
 		assert.Equal(t, expectedAsPath, pathAspath)
 
 		expectedNexthopAttr := pathAttributes[2]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 		pathNexthop := attr.(*bgp.PathAttributeNextHop)
 		assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 		expectedMed := pathAttributes[3]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 		pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 		assert.Equal(t, expectedMed, pathMed)
 
@@ -1777,22 +1777,22 @@ func TestProcessBGPUpdate_implicit_withdrwal_ipv6(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 
 	expectedNexthopAttr := pathAttributes[0]
-	_, attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+	attr := path.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 	pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 	pathOrigin := attr.(*bgp.PathAttributeOrigin)
 	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 	pathAspath := attr.(*bgp.PathAttributeAsPath)
 	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
-	_, attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+	attr = path.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 	pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 	assert.Equal(t, expectedMed, pathMed)
 
@@ -1801,22 +1801,22 @@ func TestProcessBGPUpdate_implicit_withdrwal_ipv6(t *testing.T) {
 		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
 
 		expectedNexthopAttr := pathAttributes[0]
-		_, attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+		attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 		pathNexthop := attr.(*bgp.PathAttributeMpReachNLRI)
 		assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 		expectedOrigin := pathAttributes[1]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 		pathOrigin := attr.(*bgp.PathAttributeOrigin)
 		assert.Equal(t, expectedOrigin, pathOrigin)
 
 		expectedAsPath := pathAttributes[2]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 		pathAspath := attr.(*bgp.PathAttributeAsPath)
 		assert.Equal(t, expectedAsPath, pathAspath)
 
 		expectedMed := pathAttributes[3]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 		pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 		assert.Equal(t, expectedMed, pathMed)
 		// check PathAttribute length
@@ -1855,22 +1855,22 @@ func TestProcessBGPUpdate_multiple_nlri_ipv4(t *testing.T) {
 	checkPattr := func(expected *bgp.BGPMessage, actual *Path) {
 		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
 		expectedOrigin := pathAttributes[0]
-		_, attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+		attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 		pathOrigin := attr.(*bgp.PathAttributeOrigin)
 		assert.Equal(t, expectedOrigin, pathOrigin)
 
 		expectedAsPath := pathAttributes[1]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 		pathAspath := attr.(*bgp.PathAttributeAsPath)
 		assert.Equal(t, expectedAsPath, pathAspath)
 
 		expectedNexthopAttr := pathAttributes[2]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
 		pathNexthop := attr.(*bgp.PathAttributeNextHop)
 		assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 		expectedMed := pathAttributes[3]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 		pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 		assert.Equal(t, expectedMed, pathMed)
 
@@ -1987,27 +1987,27 @@ func TestProcessBGPUpdate_multiple_nlri_ipv6(t *testing.T) {
 	checkPattr := func(expected *bgp.BGPMessage, actual *Path) {
 		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
 		pathNexthop := pathAttributes[4]
-		_, attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
+		attr := actual.getPathAttr(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI)
 		expectedNexthopAttr := attr.(*bgp.PathAttributeMpReachNLRI)
 		assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 		expectedOrigin := pathAttributes[0]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_ORIGIN)
 		pathOrigin := attr.(*bgp.PathAttributeOrigin)
 		assert.Equal(t, expectedOrigin, pathOrigin)
 
 		expectedAsPath := pathAttributes[1]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_AS_PATH)
 		pathAspath := attr.(*bgp.PathAttributeAsPath)
 		assert.Equal(t, expectedAsPath, pathAspath)
 
 		expectedMed := pathAttributes[2]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC)
 		pathMed := attr.(*bgp.PathAttributeMultiExitDisc)
 		assert.Equal(t, expectedMed, pathMed)
 
 		expectedLocalpref := pathAttributes[3]
-		_, attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_LOCAL_PREF)
+		attr = actual.getPathAttr(bgp.BGP_ATTR_TYPE_LOCAL_PREF)
 		localpref := attr.(*bgp.PathAttributeLocalPref)
 		assert.Equal(t, expectedLocalpref, localpref)
 
@@ -2132,7 +2132,7 @@ func TestProcessBGPUpdate_Timestamp(t *testing.T) {
 	peer := peerR1()
 	pList1 := ProcessMessage(m1, peer, time.Now())
 	path1 := pList1[0]
-	t1 := path1.timestamp
+	t1 := path1.OriginInfo().timestamp
 	adjRib.Update(pList1)
 
 	m2 := bgp.NewBGPUpdateMessage(nil, pathAttributes, nlri)