Move code to new public config package

cmd/gobgpd/main.go

@@ -27,7 +27,6 @@ import (
 	"syscall"
 
 	"github.com/coreos/go-systemd/daemon"
-	"github.com/golang/protobuf/ptypes/any"
 	"github.com/jessevdk/go-flags"
 	"github.com/kr/pretty"
 	log "github.com/sirupsen/logrus"
@@ -36,323 +35,12 @@ import (
 	"google.golang.org/grpc/credentials"
 
 	api "github.com/osrg/gobgp/api"
-	"github.com/osrg/gobgp/internal/pkg/apiutil"
 	"github.com/osrg/gobgp/internal/pkg/config"
-	"github.com/osrg/gobgp/internal/pkg/table"
 	"github.com/osrg/gobgp/internal/pkg/version"
-	"github.com/osrg/gobgp/pkg/packet/bgp"
+	config_api "github.com/osrg/gobgp/pkg/config"
 	"github.com/osrg/gobgp/pkg/server"
 )
 
-func marshalRouteTargets(l []string) ([]*any.Any, error) {
-	rtList := make([]*any.Any, 0, len(l))
-	for _, rtString := range l {
-		rt, err := bgp.ParseRouteTarget(rtString)
-		if err != nil {
-			return nil, err
-		}
-		rtList = append(rtList, apiutil.MarshalRT(rt))
-	}
-	return rtList, nil
-}
-
-func assignGlobalpolicy(bgpServer *server.BgpServer, a *config.ApplyPolicyConfig) {
-	toDefaultTable := func(r config.DefaultPolicyType) table.RouteType {
-		var def table.RouteType
-		switch r {
-		case config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE:
-			def = table.ROUTE_TYPE_ACCEPT
-		case config.DEFAULT_POLICY_TYPE_REJECT_ROUTE:
-			def = table.ROUTE_TYPE_REJECT
-		}
-		return def
-	}
-	toPolicies := func(r []string) []*table.Policy {
-		p := make([]*table.Policy, 0, len(r))
-		for _, n := range r {
-			p = append(p, &table.Policy{
-				Name: n,
-			})
-		}
-		return p
-	}
-
-	def := toDefaultTable(a.DefaultImportPolicy)
-	ps := toPolicies(a.ImportPolicyList)
-	bgpServer.SetPolicyAssignment(context.Background(), &api.SetPolicyAssignmentRequest{
-		Assignment: table.NewAPIPolicyAssignmentFromTableStruct(&table.PolicyAssignment{
-			Name:     table.GLOBAL_RIB_NAME,
-			Type:     table.POLICY_DIRECTION_IMPORT,
-			Policies: ps,
-			Default:  def,
-		}),
-	})
-
-	def = toDefaultTable(a.DefaultExportPolicy)
-	ps = toPolicies(a.ExportPolicyList)
-	bgpServer.SetPolicyAssignment(context.Background(), &api.SetPolicyAssignmentRequest{
-		Assignment: table.NewAPIPolicyAssignmentFromTableStruct(&table.PolicyAssignment{
-			Name:     table.GLOBAL_RIB_NAME,
-			Type:     table.POLICY_DIRECTION_EXPORT,
-			Policies: ps,
-			Default:  def,
-		}),
-	})
-
-}
-
-func addPeerGroups(bgpServer *server.BgpServer, addedPg []config.PeerGroup) {
-	for _, pg := range addedPg {
-		log.Infof("PeerGroup %s is added", pg.Config.PeerGroupName)
-		if err := bgpServer.AddPeerGroup(context.Background(), &api.AddPeerGroupRequest{
-			PeerGroup: config.NewPeerGroupFromConfigStruct(&pg),
-		}); err != nil {
-			log.Warn(err)
-		}
-	}
-}
-
-func deletePeerGroups(bgpServer *server.BgpServer, deletedPg []config.PeerGroup) {
-	for _, pg := range deletedPg {
-		log.Infof("PeerGroup %s is deleted", pg.Config.PeerGroupName)
-		if err := bgpServer.DeletePeerGroup(context.Background(), &api.DeletePeerGroupRequest{
-			Name: pg.Config.PeerGroupName,
-		}); err != nil {
-			log.Warn(err)
-		}
-	}
-}
-
-func updatePeerGroups(bgpServer *server.BgpServer, updatedPg []config.PeerGroup) bool {
-	for _, pg := range updatedPg {
-		log.Infof("PeerGroup %s is updated", pg.Config.PeerGroupName)
-		if u, err := bgpServer.UpdatePeerGroup(context.Background(), &api.UpdatePeerGroupRequest{
-			PeerGroup: config.NewPeerGroupFromConfigStruct(&pg),
-		}); err != nil {
-			log.Warn(err)
-		} else {
-			return u.NeedsSoftResetIn
-		}
-	}
-	return false
-}
-
-func addDynamicNeighbors(bgpServer *server.BgpServer, dynamicNeighbors []config.DynamicNeighbor) {
-	for _, dn := range dynamicNeighbors {
-		log.Infof("Dynamic Neighbor %s is added to PeerGroup %s", dn.Config.Prefix, dn.Config.PeerGroup)
-		if err := bgpServer.AddDynamicNeighbor(context.Background(), &api.AddDynamicNeighborRequest{
-			DynamicNeighbor: &api.DynamicNeighbor{
-				Prefix:    dn.Config.Prefix,
-				PeerGroup: dn.Config.PeerGroup,
-			},
-		}); err != nil {
-			log.Warn(err)
-		}
-	}
-}
-
-func addNeighbors(bgpServer *server.BgpServer, added []config.Neighbor) {
-	for _, p := range added {
-		log.Infof("Peer %v is added", p.State.NeighborAddress)
-		if err := bgpServer.AddPeer(context.Background(), &api.AddPeerRequest{
-			Peer: config.NewPeerFromConfigStruct(&p),
-		}); err != nil {
-			log.Warn(err)
-		}
-	}
-}
-
-func deleteNeighbors(bgpServer *server.BgpServer, deleted []config.Neighbor) {
-	for _, p := range deleted {
-		log.Infof("Peer %v is deleted", p.State.NeighborAddress)
-		if err := bgpServer.DeletePeer(context.Background(), &api.DeletePeerRequest{
-			Address: p.State.NeighborAddress,
-		}); err != nil {
-			log.Warn(err)
-		}
-	}
-}
-
-func updateNeighbors(bgpServer *server.BgpServer, updated []config.Neighbor) bool {
-	for _, p := range updated {
-		log.Infof("Peer %v is updated", p.State.NeighborAddress)
-		if u, err := bgpServer.UpdatePeer(context.Background(), &api.UpdatePeerRequest{
-			Peer: config.NewPeerFromConfigStruct(&p),
-		}); err != nil {
-			log.Warn(err)
-		} else {
-			return u.NeedsSoftResetIn
-		}
-	}
-	return false
-}
-
-func applyInitialConfig(bgpServer *server.BgpServer, newConfig *config.BgpConfigSet, isGracefulRestart bool) *config.BgpConfigSet {
-	if err := bgpServer.StartBgp(context.Background(), &api.StartBgpRequest{
-		Global: config.NewGlobalFromConfigStruct(&newConfig.Global),
-	}); err != nil {
-		log.Fatalf("failed to set global config: %s", err)
-	}
-
-	if newConfig.Zebra.Config.Enabled {
-		tps := newConfig.Zebra.Config.RedistributeRouteTypeList
-		l := make([]string, 0, len(tps))
-		for _, t := range tps {
-			l = append(l, string(t))
-		}
-		if err := bgpServer.EnableZebra(context.Background(), &api.EnableZebraRequest{
-			Url:                  newConfig.Zebra.Config.Url,
-			RouteTypes:           l,
-			Version:              uint32(newConfig.Zebra.Config.Version),
-			NexthopTriggerEnable: newConfig.Zebra.Config.NexthopTriggerEnable,
-			NexthopTriggerDelay:  uint32(newConfig.Zebra.Config.NexthopTriggerDelay),
-			MplsLabelRangeSize:   uint32(newConfig.Zebra.Config.MplsLabelRangeSize),
-			SoftwareName:         newConfig.Zebra.Config.SoftwareName,
-		}); err != nil {
-			log.Fatalf("failed to set zebra config: %s", err)
-		}
-	}
-
-	if len(newConfig.Collector.Config.Url) > 0 {
-		log.Fatal("collector feature is not supported")
-	}
-
-	for _, c := range newConfig.RpkiServers {
-		if err := bgpServer.AddRpki(context.Background(), &api.AddRpkiRequest{
-			Address:  c.Config.Address,
-			Port:     c.Config.Port,
-			Lifetime: c.Config.RecordLifetime,
-		}); err != nil {
-			log.Fatalf("failed to set rpki config: %s", err)
-		}
-	}
-	for _, c := range newConfig.BmpServers {
-		if err := bgpServer.AddBmp(context.Background(), &api.AddBmpRequest{
-			Address:           c.Config.Address,
-			Port:              c.Config.Port,
-			SysName:           c.Config.SysName,
-			SysDescr:          c.Config.SysDescr,
-			Policy:            api.AddBmpRequest_MonitoringPolicy(c.Config.RouteMonitoringPolicy.ToInt()),
-			StatisticsTimeout: int32(c.Config.StatisticsTimeout),
-		}); err != nil {
-			log.Fatalf("failed to set bmp config: %s", err)
-		}
-	}
-	for _, vrf := range newConfig.Vrfs {
-		rd, err := bgp.ParseRouteDistinguisher(vrf.Config.Rd)
-		if err != nil {
-			log.Fatalf("failed to load vrf rd config: %s", err)
-		}
-
-		importRtList, err := marshalRouteTargets(vrf.Config.ImportRtList)
-		if err != nil {
-			log.Fatalf("failed to load vrf import rt config: %s", err)
-		}
-		exportRtList, err := marshalRouteTargets(vrf.Config.ExportRtList)
-		if err != nil {
-			log.Fatalf("failed to load vrf export rt config: %s", err)
-		}
-
-		if err := bgpServer.AddVrf(context.Background(), &api.AddVrfRequest{
-			Vrf: &api.Vrf{
-				Name:     vrf.Config.Name,
-				Rd:       apiutil.MarshalRD(rd),
-				Id:       uint32(vrf.Config.Id),
-				ImportRt: importRtList,
-				ExportRt: exportRtList,
-			},
-		}); err != nil {
-			log.Fatalf("failed to set vrf config: %s", err)
-		}
-	}
-	for _, c := range newConfig.MrtDump {
-		if len(c.Config.FileName) == 0 {
-			continue
-		}
-		if err := bgpServer.EnableMrt(context.Background(), &api.EnableMrtRequest{
-			DumpType:         int32(c.Config.DumpType.ToInt()),
-			Filename:         c.Config.FileName,
-			DumpInterval:     c.Config.DumpInterval,
-			RotationInterval: c.Config.RotationInterval,
-		}); err != nil {
-			log.Fatalf("failed to set mrt config: %s", err)
-		}
-	}
-	p := config.ConfigSetToRoutingPolicy(newConfig)
-	rp, err := table.NewAPIRoutingPolicyFromConfigStruct(p)
-	if err != nil {
-		log.Warn(err)
-	} else {
-		bgpServer.SetPolicies(context.Background(), &api.SetPoliciesRequest{
-			DefinedSets: rp.DefinedSets,
-			Policies:    rp.Policies,
-		})
-	}
-
-	assignGlobalpolicy(bgpServer, &newConfig.Global.ApplyPolicy.Config)
-
-	added := newConfig.Neighbors
-	addedPg := newConfig.PeerGroups
-	if isGracefulRestart {
-		for i, n := range added {
-			if n.GracefulRestart.Config.Enabled {
-				added[i].GracefulRestart.State.LocalRestarting = true
-			}
-		}
-	}
-
-	addPeerGroups(bgpServer, addedPg)
-	addDynamicNeighbors(bgpServer, newConfig.DynamicNeighbors)
-	addNeighbors(bgpServer, added)
-	return newConfig
-}
-
-func updateConfig(bgpServer *server.BgpServer, c, newConfig *config.BgpConfigSet) *config.BgpConfigSet {
-	addedPg, deletedPg, updatedPg := config.UpdatePeerGroupConfig(c, newConfig)
-	added, deleted, updated := config.UpdateNeighborConfig(c, newConfig)
-	updatePolicy := config.CheckPolicyDifference(config.ConfigSetToRoutingPolicy(c), config.ConfigSetToRoutingPolicy(newConfig))
-
-	if updatePolicy {
-		log.Info("Policy config is updated")
-		p := config.ConfigSetToRoutingPolicy(newConfig)
-		rp, err := table.NewAPIRoutingPolicyFromConfigStruct(p)
-		if err != nil {
-			log.Warn(err)
-		} else {
-			bgpServer.SetPolicies(context.Background(), &api.SetPoliciesRequest{
-				DefinedSets: rp.DefinedSets,
-				Policies:    rp.Policies,
-			})
-		}
-	}
-	// global policy update
-	if !newConfig.Global.ApplyPolicy.Config.Equal(&c.Global.ApplyPolicy.Config) {
-		assignGlobalpolicy(bgpServer, &newConfig.Global.ApplyPolicy.Config)
-		updatePolicy = true
-	}
-
-	addPeerGroups(bgpServer, addedPg)
-	deletePeerGroups(bgpServer, deletedPg)
-	needsSoftResetIn := updatePeerGroups(bgpServer, updatedPg)
-	updatePolicy = updatePolicy || needsSoftResetIn
-	addDynamicNeighbors(bgpServer, newConfig.DynamicNeighbors)
-	addNeighbors(bgpServer, added)
-	deleteNeighbors(bgpServer, deleted)
-	needsSoftResetIn = updateNeighbors(bgpServer, updated)
-	updatePolicy = updatePolicy || needsSoftResetIn
-
-	if updatePolicy {
-		if err := bgpServer.ResetPeer(context.Background(), &api.ResetPeerRequest{
-			Address:   "",
-			Direction: api.ResetPeerRequest_IN,
-			Soft:      true,
-		}); err != nil {
-			log.Warn(err)
-		}
-	}
-	return newConfig
-}
-
 func main() {
 	sigCh := make(chan os.Signal, 1)
 	signal.Notify(sigCh, syscall.SIGTERM)
@@ -475,7 +163,7 @@ func main() {
 	loop := func() {
 		var c *config.BgpConfigSet
 		initialConfig := <-configCh
-		c = applyInitialConfig(bgpServer, initialConfig, opts.GracefulRestart)
+		c = config_api.ApplyInitialConfig(bgpServer, initialConfig, opts.GracefulRestart)
 		for {
 			select {
 			case <-sigCh:
@@ -485,7 +173,7 @@ func main() {
 				}
 				return
 			case newConfig := <-configCh:
-				c = updateConfig(bgpServer, c, newConfig)
+				c = config_api.UpdateConfig(bgpServer, c, newConfig)
 			}
 		}
 	}

pkg/config/config.go

@@ -0,0 +1,323 @@
+package config
+
+import (
+	"github.com/golang/protobuf/ptypes/any"
+	log "github.com/sirupsen/logrus"
+	"golang.org/x/net/context"
+
+	api "github.com/osrg/gobgp/api"
+	"github.com/osrg/gobgp/internal/pkg/apiutil"
+	"github.com/osrg/gobgp/internal/pkg/config"
+	"github.com/osrg/gobgp/internal/pkg/table"
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+	"github.com/osrg/gobgp/pkg/server"
+)
+
+func marshalRouteTargets(l []string) ([]*any.Any, error) {
+	rtList := make([]*any.Any, 0, len(l))
+	for _, rtString := range l {
+		rt, err := bgp.ParseRouteTarget(rtString)
+		if err != nil {
+			return nil, err
+		}
+		rtList = append(rtList, apiutil.MarshalRT(rt))
+	}
+	return rtList, nil
+}
+
+func assignGlobalpolicy(bgpServer *server.BgpServer, a *config.ApplyPolicyConfig) {
+	toDefaultTable := func(r config.DefaultPolicyType) table.RouteType {
+		var def table.RouteType
+		switch r {
+		case config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE:
+			def = table.ROUTE_TYPE_ACCEPT
+		case config.DEFAULT_POLICY_TYPE_REJECT_ROUTE:
+			def = table.ROUTE_TYPE_REJECT
+		}
+		return def
+	}
+	toPolicies := func(r []string) []*table.Policy {
+		p := make([]*table.Policy, 0, len(r))
+		for _, n := range r {
+			p = append(p, &table.Policy{
+				Name: n,
+			})
+		}
+		return p
+	}
+
+	def := toDefaultTable(a.DefaultImportPolicy)
+	ps := toPolicies(a.ImportPolicyList)
+	bgpServer.SetPolicyAssignment(context.Background(), &api.SetPolicyAssignmentRequest{
+		Assignment: table.NewAPIPolicyAssignmentFromTableStruct(&table.PolicyAssignment{
+			Name:     table.GLOBAL_RIB_NAME,
+			Type:     table.POLICY_DIRECTION_IMPORT,
+			Policies: ps,
+			Default:  def,
+		}),
+	})
+
+	def = toDefaultTable(a.DefaultExportPolicy)
+	ps = toPolicies(a.ExportPolicyList)
+	bgpServer.SetPolicyAssignment(context.Background(), &api.SetPolicyAssignmentRequest{
+		Assignment: table.NewAPIPolicyAssignmentFromTableStruct(&table.PolicyAssignment{
+			Name:     table.GLOBAL_RIB_NAME,
+			Type:     table.POLICY_DIRECTION_EXPORT,
+			Policies: ps,
+			Default:  def,
+		}),
+	})
+
+}
+
+func addPeerGroups(bgpServer *server.BgpServer, addedPg []config.PeerGroup) {
+	for _, pg := range addedPg {
+		log.Infof("PeerGroup %s is added", pg.Config.PeerGroupName)
+		if err := bgpServer.AddPeerGroup(context.Background(), &api.AddPeerGroupRequest{
+			PeerGroup: config.NewPeerGroupFromConfigStruct(&pg),
+		}); err != nil {
+			log.Warn(err)
+		}
+	}
+}
+
+func deletePeerGroups(bgpServer *server.BgpServer, deletedPg []config.PeerGroup) {
+	for _, pg := range deletedPg {
+		log.Infof("PeerGroup %s is deleted", pg.Config.PeerGroupName)
+		if err := bgpServer.DeletePeerGroup(context.Background(), &api.DeletePeerGroupRequest{
+			Name: pg.Config.PeerGroupName,
+		}); err != nil {
+			log.Warn(err)
+		}
+	}
+}
+
+func updatePeerGroups(bgpServer *server.BgpServer, updatedPg []config.PeerGroup) bool {
+	for _, pg := range updatedPg {
+		log.Infof("PeerGroup %s is updated", pg.Config.PeerGroupName)
+		if u, err := bgpServer.UpdatePeerGroup(context.Background(), &api.UpdatePeerGroupRequest{
+			PeerGroup: config.NewPeerGroupFromConfigStruct(&pg),
+		}); err != nil {
+			log.Warn(err)
+		} else {
+			return u.NeedsSoftResetIn
+		}
+	}
+	return false
+}
+
+func addDynamicNeighbors(bgpServer *server.BgpServer, dynamicNeighbors []config.DynamicNeighbor) {
+	for _, dn := range dynamicNeighbors {
+		log.Infof("Dynamic Neighbor %s is added to PeerGroup %s", dn.Config.Prefix, dn.Config.PeerGroup)
+		if err := bgpServer.AddDynamicNeighbor(context.Background(), &api.AddDynamicNeighborRequest{
+			DynamicNeighbor: &api.DynamicNeighbor{
+				Prefix:    dn.Config.Prefix,
+				PeerGroup: dn.Config.PeerGroup,
+			},
+		}); err != nil {
+			log.Warn(err)
+		}
+	}
+}
+
+func addNeighbors(bgpServer *server.BgpServer, added []config.Neighbor) {
+	for _, p := range added {
+		log.Infof("Peer %v is added", p.State.NeighborAddress)
+		if err := bgpServer.AddPeer(context.Background(), &api.AddPeerRequest{
+			Peer: config.NewPeerFromConfigStruct(&p),
+		}); err != nil {
+			log.Warn(err)
+		}
+	}
+}
+
+func deleteNeighbors(bgpServer *server.BgpServer, deleted []config.Neighbor) {
+	for _, p := range deleted {
+		log.Infof("Peer %v is deleted", p.State.NeighborAddress)
+		if err := bgpServer.DeletePeer(context.Background(), &api.DeletePeerRequest{
+			Address: p.State.NeighborAddress,
+		}); err != nil {
+			log.Warn(err)
+		}
+	}
+}
+
+func updateNeighbors(bgpServer *server.BgpServer, updated []config.Neighbor) bool {
+	for _, p := range updated {
+		log.Infof("Peer %v is updated", p.State.NeighborAddress)
+		if u, err := bgpServer.UpdatePeer(context.Background(), &api.UpdatePeerRequest{
+			Peer: config.NewPeerFromConfigStruct(&p),
+		}); err != nil {
+			log.Warn(err)
+		} else {
+			return u.NeedsSoftResetIn
+		}
+	}
+	return false
+}
+
+func ApplyInitialConfig(bgpServer *server.BgpServer, newConfig *config.BgpConfigSet, isGracefulRestart bool) *config.BgpConfigSet {
+	if err := bgpServer.StartBgp(context.Background(), &api.StartBgpRequest{
+		Global: config.NewGlobalFromConfigStruct(&newConfig.Global),
+	}); err != nil {
+		log.Fatalf("failed to set global config: %s", err)
+	}
+
+	if newConfig.Zebra.Config.Enabled {
+		tps := newConfig.Zebra.Config.RedistributeRouteTypeList
+		l := make([]string, 0, len(tps))
+		for _, t := range tps {
+			l = append(l, string(t))
+		}
+		if err := bgpServer.EnableZebra(context.Background(), &api.EnableZebraRequest{
+			Url:                  newConfig.Zebra.Config.Url,
+			RouteTypes:           l,
+			Version:              uint32(newConfig.Zebra.Config.Version),
+			NexthopTriggerEnable: newConfig.Zebra.Config.NexthopTriggerEnable,
+			NexthopTriggerDelay:  uint32(newConfig.Zebra.Config.NexthopTriggerDelay),
+			MplsLabelRangeSize:   uint32(newConfig.Zebra.Config.MplsLabelRangeSize),
+			SoftwareName:         newConfig.Zebra.Config.SoftwareName,
+		}); err != nil {
+			log.Fatalf("failed to set zebra config: %s", err)
+		}
+	}
+
+	if len(newConfig.Collector.Config.Url) > 0 {
+		log.Fatal("collector feature is not supported")
+	}
+
+	for _, c := range newConfig.RpkiServers {
+		if err := bgpServer.AddRpki(context.Background(), &api.AddRpkiRequest{
+			Address:  c.Config.Address,
+			Port:     c.Config.Port,
+			Lifetime: c.Config.RecordLifetime,
+		}); err != nil {
+			log.Fatalf("failed to set rpki config: %s", err)
+		}
+	}
+	for _, c := range newConfig.BmpServers {
+		if err := bgpServer.AddBmp(context.Background(), &api.AddBmpRequest{
+			Address:           c.Config.Address,
+			Port:              c.Config.Port,
+			SysName:           c.Config.SysName,
+			SysDescr:          c.Config.SysDescr,
+			Policy:            api.AddBmpRequest_MonitoringPolicy(c.Config.RouteMonitoringPolicy.ToInt()),
+			StatisticsTimeout: int32(c.Config.StatisticsTimeout),
+		}); err != nil {
+			log.Fatalf("failed to set bmp config: %s", err)
+		}
+	}
+	for _, vrf := range newConfig.Vrfs {
+		rd, err := bgp.ParseRouteDistinguisher(vrf.Config.Rd)
+		if err != nil {
+			log.Fatalf("failed to load vrf rd config: %s", err)
+		}
+
+		importRtList, err := marshalRouteTargets(vrf.Config.ImportRtList)
+		if err != nil {
+			log.Fatalf("failed to load vrf import rt config: %s", err)
+		}
+		exportRtList, err := marshalRouteTargets(vrf.Config.ExportRtList)
+		if err != nil {
+			log.Fatalf("failed to load vrf export rt config: %s", err)
+		}
+
+		if err := bgpServer.AddVrf(context.Background(), &api.AddVrfRequest{
+			Vrf: &api.Vrf{
+				Name:     vrf.Config.Name,
+				Rd:       apiutil.MarshalRD(rd),
+				Id:       uint32(vrf.Config.Id),
+				ImportRt: importRtList,
+				ExportRt: exportRtList,
+			},
+		}); err != nil {
+			log.Fatalf("failed to set vrf config: %s", err)
+		}
+	}
+	for _, c := range newConfig.MrtDump {
+		if len(c.Config.FileName) == 0 {
+			continue
+		}
+		if err := bgpServer.EnableMrt(context.Background(), &api.EnableMrtRequest{
+			DumpType:         int32(c.Config.DumpType.ToInt()),
+			Filename:         c.Config.FileName,
+			DumpInterval:     c.Config.DumpInterval,
+			RotationInterval: c.Config.RotationInterval,
+		}); err != nil {
+			log.Fatalf("failed to set mrt config: %s", err)
+		}
+	}
+	p := config.ConfigSetToRoutingPolicy(newConfig)
+	rp, err := table.NewAPIRoutingPolicyFromConfigStruct(p)
+	if err != nil {
+		log.Warn(err)
+	} else {
+		bgpServer.SetPolicies(context.Background(), &api.SetPoliciesRequest{
+			DefinedSets: rp.DefinedSets,
+			Policies:    rp.Policies,
+		})
+	}
+
+	assignGlobalpolicy(bgpServer, &newConfig.Global.ApplyPolicy.Config)
+
+	added := newConfig.Neighbors
+	addedPg := newConfig.PeerGroups
+	if isGracefulRestart {
+		for i, n := range added {
+			if n.GracefulRestart.Config.Enabled {
+				added[i].GracefulRestart.State.LocalRestarting = true
+			}
+		}
+	}
+
+	addPeerGroups(bgpServer, addedPg)
+	addDynamicNeighbors(bgpServer, newConfig.DynamicNeighbors)
+	addNeighbors(bgpServer, added)
+	return newConfig
+}
+
+func UpdateConfig(bgpServer *server.BgpServer, c, newConfig *config.BgpConfigSet) *config.BgpConfigSet {
+	addedPg, deletedPg, updatedPg := config.UpdatePeerGroupConfig(c, newConfig)
+	added, deleted, updated := config.UpdateNeighborConfig(c, newConfig)
+	updatePolicy := config.CheckPolicyDifference(config.ConfigSetToRoutingPolicy(c), config.ConfigSetToRoutingPolicy(newConfig))
+
+	if updatePolicy {
+		log.Info("Policy config is updated")
+		p := config.ConfigSetToRoutingPolicy(newConfig)
+		rp, err := table.NewAPIRoutingPolicyFromConfigStruct(p)
+		if err != nil {
+			log.Warn(err)
+		} else {
+			bgpServer.SetPolicies(context.Background(), &api.SetPoliciesRequest{
+				DefinedSets: rp.DefinedSets,
+				Policies:    rp.Policies,
+			})
+		}
+	}
+	// global policy update
+	if !newConfig.Global.ApplyPolicy.Config.Equal(&c.Global.ApplyPolicy.Config) {
+		assignGlobalpolicy(bgpServer, &newConfig.Global.ApplyPolicy.Config)
+		updatePolicy = true
+	}
+
+	addPeerGroups(bgpServer, addedPg)
+	deletePeerGroups(bgpServer, deletedPg)
+	needsSoftResetIn := updatePeerGroups(bgpServer, updatedPg)
+	updatePolicy = updatePolicy || needsSoftResetIn
+	addDynamicNeighbors(bgpServer, newConfig.DynamicNeighbors)
+	addNeighbors(bgpServer, added)
+	deleteNeighbors(bgpServer, deleted)
+	needsSoftResetIn = updateNeighbors(bgpServer, updated)
+	updatePolicy = updatePolicy || needsSoftResetIn
+
+	if updatePolicy {
+		if err := bgpServer.ResetPeer(context.Background(), &api.ResetPeerRequest{
+			Address:   "",
+			Direction: api.ResetPeerRequest_IN,
+			Soft:      true,
+		}); err != nil {
+			log.Warn(err)
+		}
+	}
+	return newConfig
+}