use Destination instead of Path for path selection API

With Destination struct, multiple Paths can be moved from the table
package to the server package in a cleaner way; for features such as
add-path.

Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>

7 files changed, 169 insertions, 167 deletions

diff --git a/gobgp/cmd/mrt.go b/gobgp/cmd/mrt.go
index f89e801f..8aa6be95 100644
--- a/gobgp/cmd/mrt.go
+++ b/gobgp/cmd/mrt.go
@@ -112,11 +112,11 @@ func injectMrt(filename string, count int, skip int, onlyBest bool) error {
 					for _, p := range paths {
 						dst.AddNewPath(p)
 					}
-					best, _, _ := dst.Calculate([]string{table.GLOBAL_RIB_NAME}, false)
-					if best[table.GLOBAL_RIB_NAME] == nil {
+					best, _, _ := dst.Calculate().GetChanges(table.GLOBAL_RIB_NAME, false)
+					if best == nil {
 						exitWithError(fmt.Errorf("Can't find the best %v", nlri))
 					}
-					paths = []*table.Path{best[table.GLOBAL_RIB_NAME]}
+					paths = []*table.Path{best}
 				}
 
 				if idx >= skip {
diff --git a/server/server.go b/server/server.go
index 1885c7a7..b821ea82 100644
--- a/server/server.go
+++ b/server/server.go
@@ -467,12 +467,12 @@ func clonePathList(pathList []*table.Path) []*table.Path {
 	return l
 }
 
-func (server *BgpServer) notifyBestWatcher(best map[string][]*table.Path, multipath [][]*table.Path) {
+func (server *BgpServer) notifyBestWatcher(best []*table.Path, multipath [][]*table.Path) {
 	clonedM := make([][]*table.Path, len(multipath))
 	for i, pathList := range multipath {
 		clonedM[i] = clonePathList(pathList)
 	}
-	clonedB := clonePathList(best[table.GLOBAL_RIB_NAME])
+	clonedB := clonePathList(best)
 	for _, p := range clonedB {
 		switch p.GetRouteFamily() {
 		case bgp.RF_IPv4_VPN, bgp.RF_IPv6_VPN:
@@ -510,33 +510,45 @@ func (server *BgpServer) notifyPostPolicyUpdateWatcher(peer *Peer, pathList []*t
 	server.notifyWatcher(WATCH_EVENT_TYPE_POST_UPDATE, ev)
 }
 
-func (server *BgpServer) dropPeerAllRoutes(peer *Peer, families []bgp.RouteFamily) {
+func dstsToPaths(id string, dsts []*table.Destination) ([]*table.Path, []*table.Path, [][]*table.Path) {
+	bestList := make([]*table.Path, 0, len(dsts))
+	oldList := make([]*table.Path, 0, len(dsts))
+	mpathList := make([][]*table.Path, 0, len(dsts))
+
+	for _, dst := range dsts {
+		best, old, mpath := dst.GetChanges(id, false)
+		bestList = append(bestList, best)
+		oldList = append(oldList, old)
+		if mpath != nil {
+			mpathList = append(mpathList, mpath)
+		}
+	}
+	return bestList, oldList, mpathList
+}
 
+func (server *BgpServer) dropPeerAllRoutes(peer *Peer, families []bgp.RouteFamily) {
+	var bestList []*table.Path
+	var mpathList [][]*table.Path
 	families = peer.toGlobalFamilies(families)
 	rib := server.globalRib
-	ids := make([]string, 0, len(server.neighborMap))
 	if peer.isRouteServerClient() {
 		rib = server.rsRib
-		for _, targetPeer := range server.neighborMap {
-			if !targetPeer.isRouteServerClient() || targetPeer == peer || targetPeer.fsm.state != bgp.BGP_FSM_ESTABLISHED {
-				continue
-			}
-			ids = append(ids, targetPeer.TableID())
-		}
-	} else {
-		ids = append(ids, table.GLOBAL_RIB_NAME)
 	}
 	for _, rf := range families {
-		best, _, multipath := rib.DeletePathsByPeer(ids, peer.fsm.peerInfo, rf)
+		dsts := rib.DeletePathsByPeer(peer.fsm.peerInfo, rf)
 		if !peer.isRouteServerClient() {
-			server.notifyBestWatcher(best, multipath)
+			bestList, _, mpathList = dstsToPaths(table.GLOBAL_RIB_NAME, dsts)
+			server.notifyBestWatcher(bestList, mpathList)
 		}
 
 		for _, targetPeer := range server.neighborMap {
 			if peer.isRouteServerClient() != targetPeer.isRouteServerClient() || targetPeer == peer {
 				continue
 			}
-			if paths := targetPeer.processOutgoingPaths(best[targetPeer.TableID()], nil); len(paths) > 0 {
+			if targetPeer.isRouteServerClient() {
+				bestList, _, _ = dstsToPaths(targetPeer.TableID(), dsts)
+			}
+			if paths := targetPeer.processOutgoingPaths(bestList, nil); len(paths) > 0 {
 				sendFsmOutgoingMsg(targetPeer, paths, nil, false)
 			}
 		}
@@ -624,8 +636,12 @@ func (server *BgpServer) RSimportPaths(peer *Peer, pathList []*table.Path) []*ta
 }
 
 func (server *BgpServer) propagateUpdate(peer *Peer, pathList []*table.Path) {
+	var dsts []*table.Destination
+
+	var bestList, oldList []*table.Path
+	var mpathList [][]*table.Path
+
 	rib := server.globalRib
-	var best, old map[string][]*table.Path
 
 	if peer != nil && peer.fsm.pConf.Config.Vrf != "" {
 		vrf := server.globalRib.Vrfs[peer.fsm.pConf.Config.Vrf]
@@ -647,17 +663,7 @@ func (server *BgpServer) propagateUpdate(peer *Peer, pathList []*table.Path) {
 			}
 			moded = append(moded, server.RSimportPaths(targetPeer, pathList)...)
 		}
-		isTarget := func(p *Peer) bool {
-			return p.isRouteServerClient() && p.fsm.state == bgp.BGP_FSM_ESTABLISHED && !p.fsm.pConf.GracefulRestart.State.LocalRestarting
-		}
-
-		ids := make([]string, 0, len(server.neighborMap))
-		for _, targetPeer := range server.neighborMap {
-			if isTarget(targetPeer) {
-				ids = append(ids, targetPeer.TableID())
-			}
-		}
-		best, old, _ = rib.ProcessPaths(ids, append(pathList, moded...))
+		dsts = rib.ProcessPaths(append(pathList, moded...))
 	} else {
 		for idx, path := range pathList {
 			if p := server.policy.ApplyPolicy(table.GLOBAL_RIB_NAME, table.POLICY_DIRECTION_IMPORT, path, nil); p != nil {
@@ -712,20 +718,23 @@ func (server *BgpServer) propagateUpdate(peer *Peer, pathList []*table.Path) {
 			}
 		}
 		server.notifyPostPolicyUpdateWatcher(peer, pathList)
-		var multipath [][]*table.Path
-		best, old, multipath = rib.ProcessPaths([]string{table.GLOBAL_RIB_NAME}, pathList)
+		dsts = rib.ProcessPaths(pathList)
 
-		if len(best[table.GLOBAL_RIB_NAME]) == 0 {
+		bestList, oldList, mpathList = dstsToPaths(table.GLOBAL_RIB_NAME, dsts)
+		if len(bestList) == 0 {
 			return
 		}
-		server.notifyBestWatcher(best, multipath)
+		server.notifyBestWatcher(bestList, mpathList)
 	}
 
 	for _, targetPeer := range server.neighborMap {
 		if (peer == nil && targetPeer.isRouteServerClient()) || (peer != nil && peer.isRouteServerClient() != targetPeer.isRouteServerClient()) {
 			continue
 		}
-		if paths := targetPeer.processOutgoingPaths(best[targetPeer.TableID()], old[targetPeer.TableID()]); len(paths) > 0 {
+		if targetPeer.isRouteServerClient() {
+			bestList, oldList, _ = dstsToPaths(targetPeer.TableID(), dsts)
+		}
+		if paths := targetPeer.processOutgoingPaths(bestList, oldList); len(paths) > 0 {
 			sendFsmOutgoingMsg(targetPeer, paths, nil, false)
 		}
 	}
@@ -1743,7 +1752,7 @@ func (server *BgpServer) addNeighbor(c *config.Neighbor) error {
 		}
 		moded := server.RSimportPaths(peer, pathList)
 		if len(moded) > 0 {
-			server.rsRib.ProcessPaths(nil, moded)
+			server.rsRib.ProcessPaths(moded)
 		}
 	}
 	server.neighborMap[addr] = peer
diff --git a/server/server_test.go b/server/server_test.go
index e5deb975..fb7b97f3 100644
--- a/server/server_test.go
+++ b/server/server_test.go
@@ -16,15 +16,16 @@
 package server
 
 import (
+	"net"
+	"runtime"
+	"testing"
+	"time"
+
 	"github.com/osrg/gobgp/config"
 	"github.com/osrg/gobgp/packet/bgp"
 	"github.com/osrg/gobgp/table"
 	log "github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
-	"net"
-	"runtime"
-	"testing"
-	"time"
 )
 
 func TestModPolicyAssign(t *testing.T) {
@@ -214,14 +215,14 @@ func newPeerandInfo(myAs, as uint32, address string, rib *table.TableManager) (*
 }
 
 func process(rib *table.TableManager, l []*table.Path) (*table.Path, *table.Path) {
-	news, olds, _ := rib.ProcessPaths([]string{table.GLOBAL_RIB_NAME}, l)
+	news, olds, _ := dstsToPaths(table.GLOBAL_RIB_NAME, rib.ProcessPaths(l))
 	if len(news) != 1 {
 		panic("can't handle multiple paths")
 	}
-	for idx, path := range news[table.GLOBAL_RIB_NAME] {
+	for idx, path := range news {
 		var old *table.Path
 		if olds != nil {
-			old = olds[table.GLOBAL_RIB_NAME][idx]
+			old = olds[idx]
 		}
 		return path, old
 	}
diff --git a/table/destination.go b/table/destination.go
index af74f8fd..6f4f95ad 100644
--- a/table/destination.go
+++ b/table/destination.go
@@ -140,12 +140,13 @@ func NewPeerInfo(g *config.Global, p *config.Neighbor) *PeerInfo {
 }
 
 type Destination struct {
-	routeFamily   bgp.RouteFamily
-	nlri          bgp.AddrPrefixInterface
-	knownPathList paths
-	withdrawList  paths
-	newPathList   paths
-	RadixKey      string
+	routeFamily      bgp.RouteFamily
+	nlri             bgp.AddrPrefixInterface
+	knownPathList    paths
+	withdrawList     paths
+	newPathList      paths
+	oldKnownPathList paths
+	RadixKey         string
 }
 
 func NewDestination(nlri bgp.AddrPrefixInterface, known ...*Path) *Destination {
@@ -226,50 +227,10 @@ func (dd *Destination) GetMultiBestPath(id string) []*Path {
 	return getMultiBestPath(id, &dd.knownPathList)
 }
 
-func (dd *Destination) AddWithdraw(withdraw *Path) {
-	dd.validatePath(withdraw)
-	dd.withdrawList = append(dd.withdrawList, withdraw)
-}
-
-func (dd *Destination) AddNewPath(newPath *Path) {
-	dd.validatePath(newPath)
-	dd.newPathList = append(dd.newPathList, newPath)
-}
-
-func (dd *Destination) validatePath(path *Path) {
-	if path == nil || path.GetRouteFamily() != dd.routeFamily {
-
-		log.WithFields(log.Fields{
-			"Topic":      "Table",
-			"Key":        dd.GetNlri().String(),
-			"Path":       path,
-			"ExpectedRF": dd.routeFamily,
-		}).Error("path is nil or invalid route family")
-	}
-}
-
-// Calculates best-path among known paths for this destination.
-//
-// Modifies destination's state related to stored paths. Removes withdrawn
-// paths from known paths. Also, adds new paths to known paths.
-func (dest *Destination) Calculate(ids []string, peerDown bool) (map[string]*Path, map[string]*Path, []*Path) {
-	bestList := make(map[string]*Path, len(ids))
-	oldList := make(map[string]*Path, len(ids))
-	oldKnownPathList := dest.knownPathList
-	// First remove the withdrawn paths.
-	dest.explicitWithdraw()
-	// Do implicit withdrawal
-	dest.implicitWithdraw()
-	// Collect all new paths into known paths.
-	dest.knownPathList = append(dest.knownPathList, dest.newPathList...)
-	// Clear new paths as we copied them.
-	dest.newPathList = make([]*Path, 0)
-	// Compute new best path
-	dest.computeKnownBestPath()
-
-	f := func(id string) (*Path, *Path) {
-		old := getBestPath(id, &oldKnownPathList)
-		best := dest.GetBestPath(id)
+func (dd *Destination) GetChanges(id string, peerDown bool) (*Path, *Path, []*Path) {
+	best, old := func(id string) (*Path, *Path) {
+		old := getBestPath(id, &dd.oldKnownPathList)
+		best := dd.GetBestPath(id)
 		if best != nil && best.Equal(old) {
 			// RFC4684 3.2. Intra-AS VPN Route Distribution
 			// When processing RT membership NLRIs received from internal iBGP
@@ -300,35 +261,79 @@ func (dest *Destination) Calculate(ids []string, peerDown bool) (map[string]*Pat
 			return old.Clone(true), old
 		}
 		return best, old
-	}
+	}(id)
 
 	var multi []*Path
-	for _, id := range ids {
-		bestList[id], oldList[id] = f(id)
-		if id == GLOBAL_RIB_NAME && UseMultiplePaths.Enabled {
-			diff := func(lhs, rhs []*Path) bool {
-				if len(lhs) != len(rhs) {
+
+	if id == GLOBAL_RIB_NAME && UseMultiplePaths.Enabled {
+		diff := func(lhs, rhs []*Path) bool {
+			if len(lhs) != len(rhs) {
+				return true
+			}
+			for idx, l := range lhs {
+				if !l.Equal(rhs[idx]) {
 					return true
 				}
-				for idx, l := range lhs {
-					if !l.Equal(rhs[idx]) {
-						return true
-					}
-				}
-				return false
 			}
-			oldM := getMultiBestPath(id, &oldKnownPathList)
-			newM := dest.GetMultiBestPath(id)
-			if diff(oldM, newM) {
-				multi = newM
-				if len(newM) == 0 {
-					multi = []*Path{bestList[id]}
-				}
+			return false
+		}
+		oldM := getMultiBestPath(id, &dd.oldKnownPathList)
+		newM := dd.GetMultiBestPath(id)
+		if diff(oldM, newM) {
+			multi = newM
+			if len(newM) == 0 {
+				multi = []*Path{best}
 			}
 		}
 	}
+	return best, old, multi
+}
+
+func (dd *Destination) AddWithdraw(withdraw *Path) {
+	dd.validatePath(withdraw)
+	dd.withdrawList = append(dd.withdrawList, withdraw)
+}
+
+func (dd *Destination) AddNewPath(newPath *Path) {
+	dd.validatePath(newPath)
+	dd.newPathList = append(dd.newPathList, newPath)
+}
+
+func (dd *Destination) validatePath(path *Path) {
+	if path == nil || path.GetRouteFamily() != dd.routeFamily {
 
-	return bestList, oldList, multi
+		log.WithFields(log.Fields{
+			"Topic":      "Table",
+			"Key":        dd.GetNlri().String(),
+			"Path":       path,
+			"ExpectedRF": dd.routeFamily,
+		}).Error("path is nil or invalid route family")
+	}
+}
+
+// Calculates best-path among known paths for this destination.
+//
+// Modifies destination's state related to stored paths. Removes withdrawn
+// paths from known paths. Also, adds new paths to known paths.
+func (dest *Destination) Calculate() *Destination {
+	oldKnownPathList := dest.knownPathList
+	// First remove the withdrawn paths.
+	dest.explicitWithdraw()
+	// Do implicit withdrawal
+	dest.implicitWithdraw()
+	// Collect all new paths into known paths.
+	dest.knownPathList = append(dest.knownPathList, dest.newPathList...)
+	// Clear new paths as we copied them.
+	dest.newPathList = make([]*Path, 0)
+	// Compute new best path
+	dest.computeKnownBestPath()
+
+	return &Destination{
+		routeFamily:      dest.routeFamily,
+		nlri:             dest.nlri,
+		knownPathList:    dest.knownPathList,
+		oldKnownPathList: oldKnownPathList,
+	}
 }
 
 // Removes withdrawn paths.
diff --git a/table/destination_test.go b/table/destination_test.go
index e1f13410..d1124b4b 100644
--- a/table/destination_test.go
+++ b/table/destination_test.go
@@ -92,7 +92,7 @@ func TestCalculate(t *testing.T) {
 	d.AddNewPath(path1)
 	d.AddNewPath(path2)
 
-	d.Calculate([]string{"1", "2"}, false)
+	d.Calculate()
 
 	assert.Equal(t, len(d.GetKnownPathList("1")), 0)
 	assert.Equal(t, len(d.GetKnownPathList("2")), 1)
@@ -100,7 +100,7 @@ func TestCalculate(t *testing.T) {
 
 	d.AddWithdraw(path1.Clone(true))
 
-	d.Calculate([]string{"1", "2"}, false)
+	d.Calculate()
 
 	assert.Equal(t, len(d.GetKnownPathList("1")), 0)
 	assert.Equal(t, len(d.GetKnownPathList("2")), 0)
@@ -124,7 +124,7 @@ func TestCalculate2(t *testing.T) {
 
 	d := NewDestination(nlri)
 	d.AddNewPath(path1)
-	d.Calculate(nil, false)
+	d.Calculate()
 
 	// suppose peer2 sends grammaatically correct but semantically flawed update message
 	// which has a withdrawal nlri not advertised before
@@ -134,7 +134,7 @@ func TestCalculate2(t *testing.T) {
 	assert.Equal(t, path2.IsWithdraw, true)
 
 	d.AddWithdraw(path2)
-	d.Calculate(nil, false)
+	d.Calculate()
 
 	// we have a path from peer1 here
 	assert.Equal(t, len(d.knownPathList), 1)
@@ -145,7 +145,7 @@ func TestCalculate2(t *testing.T) {
 	assert.Equal(t, path3.IsWithdraw, false)
 
 	d.AddNewPath(path3)
-	d.Calculate(nil, false)
+	d.Calculate()
 
 	// this time, we have paths from peer1 and peer2
 	assert.Equal(t, len(d.knownPathList), 2)
@@ -156,7 +156,7 @@ func TestCalculate2(t *testing.T) {
 	path4 := ProcessMessage(update4, peer3, time.Now())[0]
 
 	d.AddNewPath(path4)
-	d.Calculate(nil, false)
+	d.Calculate()
 
 	// we must have paths from peer1, peer2 and peer3
 	assert.Equal(t, len(d.knownPathList), 3)
@@ -190,7 +190,7 @@ func TestImplicitWithdrawCalculate(t *testing.T) {
 	d.AddNewPath(path1)
 	d.AddNewPath(path2)
 
-	d.Calculate(nil, false)
+	d.Calculate()
 
 	assert.Equal(t, len(d.GetKnownPathList("1")), 0) // peer "1" is the originator
 	assert.Equal(t, len(d.GetKnownPathList("2")), 1)
@@ -209,7 +209,7 @@ func TestImplicitWithdrawCalculate(t *testing.T) {
 	path3.Filter("1", POLICY_DIRECTION_IMPORT)
 
 	d.AddNewPath(path3)
-	d.Calculate(nil, false)
+	d.Calculate()
 
 	assert.Equal(t, len(d.GetKnownPathList("1")), 0) // peer "1" is the originator
 	assert.Equal(t, len(d.GetKnownPathList("2")), 1)
@@ -294,7 +294,7 @@ func TestTimeTieBreaker(t *testing.T) {
 	d.AddNewPath(path1)
 	d.AddNewPath(path2)
 
-	d.Calculate(nil, false)
+	d.Calculate()
 
 	assert.Equal(t, len(d.knownPathList), 2)
 	assert.Equal(t, true, d.GetBestPath("").GetSource().ID.Equal(net.IP{2, 2, 2, 2})) // path from peer2 win
@@ -305,7 +305,7 @@ func TestTimeTieBreaker(t *testing.T) {
 	d.AddNewPath(path1)
 	d.AddNewPath(path2)
 
-	d.Calculate(nil, false)
+	d.Calculate()
 
 	assert.Equal(t, len(d.knownPathList), 2)
 	assert.Equal(t, true, d.GetBestPath("").GetSource().ID.Equal(net.IP{1, 1, 1, 1})) // path from peer1 win
@@ -462,17 +462,18 @@ func TestMultipath(t *testing.T) {
 	d.AddNewPath(path1)
 	d.AddNewPath(path2)
 
-	best, old, multi := d.Calculate([]string{GLOBAL_RIB_NAME}, false)
-	assert.Equal(t, len(best), 1)
-	assert.Equal(t, old[GLOBAL_RIB_NAME], (*Path)(nil))
+	best, old, multi := d.Calculate().GetChanges(GLOBAL_RIB_NAME, false)
+	assert.NotNil(t, best)
+	assert.Equal(t, old, (*Path)(nil))
 	assert.Equal(t, len(multi), 2)
 	assert.Equal(t, len(d.GetKnownPathList(GLOBAL_RIB_NAME)), 2)
 
 	path3 := path2.Clone(true)
 	d.AddWithdraw(path3)
-	best, old, multi = d.Calculate([]string{GLOBAL_RIB_NAME}, false)
-	assert.Equal(t, len(best), 1)
-	assert.Equal(t, old[GLOBAL_RIB_NAME], path1)
+	dd := d.Calculate()
+	best, old, multi = dd.GetChanges(GLOBAL_RIB_NAME, false)
+	assert.Nil(t, best)
+	assert.Equal(t, old, path1)
 	assert.Equal(t, len(multi), 1)
 	assert.Equal(t, len(d.GetKnownPathList(GLOBAL_RIB_NAME)), 1)
 
@@ -489,8 +490,8 @@ func TestMultipath(t *testing.T) {
 	path4 := ProcessMessage(updateMsg, peer3, time.Now())[0]
 	d.AddNewPath(path4)
 
-	best, _, multi = d.Calculate([]string{GLOBAL_RIB_NAME}, false)
-	assert.Equal(t, len(best), 1)
+	best, _, multi = d.Calculate().GetChanges(GLOBAL_RIB_NAME, false)
+	assert.NotNil(t, best)
 	assert.Equal(t, len(multi), 1)
 	assert.Equal(t, len(d.GetKnownPathList(GLOBAL_RIB_NAME)), 2)
 
@@ -505,8 +506,8 @@ func TestMultipath(t *testing.T) {
 	path5 := ProcessMessage(updateMsg, peer2, time.Now())[0]
 	d.AddNewPath(path5)
 
-	best, _, multi = d.Calculate([]string{GLOBAL_RIB_NAME}, false)
-	assert.Equal(t, len(best), 1)
+	best, _, multi = d.Calculate().GetChanges(GLOBAL_RIB_NAME, false)
+	assert.NotNil(t, best)
 	assert.Equal(t, len(multi), 2)
 	assert.Equal(t, len(d.GetKnownPathList(GLOBAL_RIB_NAME)), 3)
 
diff --git a/table/table_manager.go b/table/table_manager.go
index e41c2798..023672fc 100644
--- a/table/table_manager.go
+++ b/table/table_manager.go
@@ -18,10 +18,11 @@ package table
 import (
 	"bytes"
 	"fmt"
-	"github.com/osrg/gobgp/packet/bgp"
-	log "github.com/sirupsen/logrus"
 	"net"
 	"time"
+
+	"github.com/osrg/gobgp/packet/bgp"
+	log "github.com/sirupsen/logrus"
 )
 
 const (
@@ -185,29 +186,17 @@ func (manager *TableManager) DeleteVrf(name string) ([]*Path, error) {
 	return msgs, nil
 }
 
-func (manager *TableManager) calculate(ids []string, destinations []*Destination, peerDown bool) (map[string][]*Path, map[string][]*Path, [][]*Path) {
-	best := make(map[string][]*Path, len(ids))
-	old := make(map[string][]*Path, len(ids))
+func (manager *TableManager) calculate(dsts []*Destination) []*Destination {
+	emptyDsts := make([]*Destination, 0, len(dsts))
+	clonedDsts := make([]*Destination, 0, len(dsts))
 
-	emptyDsts := make([]*Destination, 0, len(destinations))
-	var multi [][]*Path
-	if UseMultiplePaths.Enabled && len(ids) == 1 && ids[0] == GLOBAL_RIB_NAME {
-		multi = make([][]*Path, 0, len(destinations))
-	}
-
-	for _, dst := range destinations {
+	for _, dst := range dsts {
 		log.WithFields(log.Fields{
 			"Topic": "table",
 			"Key":   dst.GetNlri().String(),
 		}).Debug("Processing destination")
-		paths, olds, m := dst.Calculate(ids, peerDown)
-		for id, path := range paths {
-			best[id] = append(best[id], path)
-			old[id] = append(old[id], olds[id])
-		}
-		if m != nil {
-			multi = append(multi, m)
-		}
+
+		clonedDsts = append(clonedDsts, dst.Calculate())
 
 		if len(dst.knownPathList) == 0 {
 			emptyDsts = append(emptyDsts, dst)
@@ -218,18 +207,18 @@ func (manager *TableManager) calculate(ids []string, destinations []*Destination
 		t := manager.Tables[dst.Family()]
 		t.deleteDest(dst)
 	}
-	return best, old, multi
+	return clonedDsts
 }
 
-func (manager *TableManager) DeletePathsByPeer(ids []string, info *PeerInfo, rf bgp.RouteFamily) (map[string][]*Path, map[string][]*Path, [][]*Path) {
+func (manager *TableManager) DeletePathsByPeer(info *PeerInfo, rf bgp.RouteFamily) []*Destination {
 	if t, ok := manager.Tables[rf]; ok {
 		dsts := t.DeleteDestByPeer(info)
-		return manager.calculate(ids, dsts, true)
+		return manager.calculate(dsts)
 	}
-	return nil, nil, nil
+	return nil
 }
 
-func (manager *TableManager) ProcessPaths(ids []string, pathList []*Path) (map[string][]*Path, map[string][]*Path, [][]*Path) {
+func (manager *TableManager) ProcessPaths(pathList []*Path) []*Destination {
 	m := make(map[string]bool, len(pathList))
 	dsts := make([]*Destination, 0, len(pathList))
 	for _, path := range pathList {
@@ -255,7 +244,7 @@ func (manager *TableManager) ProcessPaths(ids []string, pathList []*Path) (map[s
 			}
 		}
 	}
-	return manager.calculate(ids, dsts, false)
+	return manager.calculate(dsts)
 }
 
 // EVPN MAC MOBILITY HANDLING
diff --git a/table/table_manager_test.go b/table/table_manager_test.go
index 2a8ed2f6..ec979bf6 100644
--- a/table/table_manager_test.go
+++ b/table/table_manager_test.go
@@ -29,15 +29,12 @@ import (
 // process BGPUpdate message
 // this function processes only BGPUpdate
 func (manager *TableManager) ProcessUpdate(fromPeer *PeerInfo, message *bgp.BGPMessage) ([]*Path, error) {
-	paths := ProcessMessage(message, fromPeer, time.Now())
-	best, _, _ := manager.ProcessPaths([]string{GLOBAL_RIB_NAME}, paths)
-	paths2 := make([]*Path, 0, len(paths))
-	for _, p := range best[GLOBAL_RIB_NAME] {
-		if p != nil {
-			paths2 = append(paths2, p)
-		}
+	pathList := make([]*Path, 0)
+	for _, d := range manager.ProcessPaths(ProcessMessage(message, fromPeer, time.Now())) {
+		b, _, _ := d.GetChanges(GLOBAL_RIB_NAME, false)
+		pathList = append(pathList, b)
 	}
-	return paths2, nil
+	return pathList, nil
 }
 
 func getLogger(lv log.Level) *log.Logger {