move exported functions to generate api structs from config struct in server/

NewPeerFromConfigStruct()
NewPeerGroupFromConfigStruct()
NewGlobalFromConfigStruct()

The config is an internal package so they should not be exported.

We will remove the usage of the config in server/. This is a part of
the goal.

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

1 files changed, 0 insertions, 377 deletions

diff --git a/pkg/server/grpc_server.go b/pkg/server/grpc_server.go
index 4c2eb700..d5266310 100644
--- a/pkg/server/grpc_server.go
+++ b/pkg/server/grpc_server.go
@@ -94,337 +94,6 @@ func (s *Server) Serve() error {
 	return nil
 }
 
-func NewMpGracefulRestartFromConfigStruct(c *config.MpGracefulRestart) *api.MpGracefulRestart {
-	return &api.MpGracefulRestart{
-		Config: &api.MpGracefulRestartConfig{
-			Enabled: c.Config.Enabled,
-		},
-	}
-}
-
-func extractFamilyFromConfigAfiSafi(c *config.AfiSafi) uint32 {
-	if c == nil {
-		return 0
-	}
-	// If address family value is already stored in AfiSafiState structure,
-	// we prefer to use this value.
-	if c.State.Family != 0 {
-		return uint32(c.State.Family)
-	}
-	// In case that Neighbor structure came from CLI or gRPC, address family
-	// value in AfiSafiState structure can be omitted.
-	// Here extracts value from AfiSafiName field in AfiSafiConfig structure.
-	if rf, err := bgp.GetRouteFamily(string(c.Config.AfiSafiName)); err == nil {
-		return uint32(rf)
-	}
-	// Ignores invalid address family name
-	return 0
-}
-
-func NewAfiSafiConfigFromConfigStruct(c *config.AfiSafi) *api.AfiSafiConfig {
-	rf := extractFamilyFromConfigAfiSafi(c)
-	afi, safi := bgp.RouteFamilyToAfiSafi(bgp.RouteFamily(rf))
-	return &api.AfiSafiConfig{
-		Family:  &api.Family{Afi: api.Family_Afi(afi), Safi: api.Family_Safi(safi)},
-		Enabled: c.Config.Enabled,
-	}
-}
-
-func NewApplyPolicyFromConfigStruct(c *config.ApplyPolicy) *api.ApplyPolicy {
-	applyPolicy := &api.ApplyPolicy{
-		ImportPolicy: &api.PolicyAssignment{
-			Direction:     api.PolicyDirection_IMPORT,
-			DefaultAction: api.RouteAction(c.Config.DefaultImportPolicy.ToInt()),
-		},
-		ExportPolicy: &api.PolicyAssignment{
-			Direction:     api.PolicyDirection_EXPORT,
-			DefaultAction: api.RouteAction(c.Config.DefaultExportPolicy.ToInt()),
-		},
-	}
-
-	for _, pname := range c.Config.ImportPolicyList {
-		applyPolicy.ImportPolicy.Policies = append(applyPolicy.ImportPolicy.Policies, &api.Policy{Name: pname})
-	}
-	for _, pname := range c.Config.ExportPolicyList {
-		applyPolicy.ExportPolicy.Policies = append(applyPolicy.ExportPolicy.Policies, &api.Policy{Name: pname})
-	}
-
-	return applyPolicy
-}
-
-func NewRouteSelectionOptionsFromConfigStruct(c *config.RouteSelectionOptions) *api.RouteSelectionOptions {
-	return &api.RouteSelectionOptions{
-		Config: &api.RouteSelectionOptionsConfig{
-			AlwaysCompareMed:        c.Config.AlwaysCompareMed,
-			IgnoreAsPathLength:      c.Config.IgnoreAsPathLength,
-			ExternalCompareRouterId: c.Config.ExternalCompareRouterId,
-			AdvertiseInactiveRoutes: c.Config.AdvertiseInactiveRoutes,
-			EnableAigp:              c.Config.EnableAigp,
-			IgnoreNextHopIgpMetric:  c.Config.IgnoreNextHopIgpMetric,
-		},
-	}
-}
-
-func NewUseMultiplePathsFromConfigStruct(c *config.UseMultiplePaths) *api.UseMultiplePaths {
-	return &api.UseMultiplePaths{
-		Config: &api.UseMultiplePathsConfig{
-			Enabled: c.Config.Enabled,
-		},
-		Ebgp: &api.Ebgp{
-			Config: &api.EbgpConfig{
-				AllowMultipleAs: c.Ebgp.Config.AllowMultipleAs,
-				MaximumPaths:    c.Ebgp.Config.MaximumPaths,
-			},
-		},
-		Ibgp: &api.Ibgp{
-			Config: &api.IbgpConfig{
-				MaximumPaths: c.Ibgp.Config.MaximumPaths,
-			},
-		},
-	}
-}
-
-func NewPrefixLimitFromConfigStruct(c *config.AfiSafi) *api.PrefixLimit {
-	if c.PrefixLimit.Config.MaxPrefixes == 0 {
-		return nil
-	}
-	afi, safi := bgp.RouteFamilyToAfiSafi(bgp.RouteFamily(c.State.Family))
-	return &api.PrefixLimit{
-		Family:               &api.Family{Afi: api.Family_Afi(afi), Safi: api.Family_Safi(safi)},
-		MaxPrefixes:          c.PrefixLimit.Config.MaxPrefixes,
-		ShutdownThresholdPct: uint32(c.PrefixLimit.Config.ShutdownThresholdPct),
-	}
-}
-
-func NewRouteTargetMembershipFromConfigStruct(c *config.RouteTargetMembership) *api.RouteTargetMembership {
-	return &api.RouteTargetMembership{
-		Config: &api.RouteTargetMembershipConfig{
-			DeferralTime: uint32(c.Config.DeferralTime),
-		},
-	}
-}
-
-func NewLongLivedGracefulRestartFromConfigStruct(c *config.LongLivedGracefulRestart) *api.LongLivedGracefulRestart {
-	return &api.LongLivedGracefulRestart{
-		Config: &api.LongLivedGracefulRestartConfig{
-			Enabled:     c.Config.Enabled,
-			RestartTime: c.Config.RestartTime,
-		},
-	}
-}
-
-func NewAddPathsFromConfigStruct(c *config.AddPaths) *api.AddPaths {
-	return &api.AddPaths{
-		Config: &api.AddPathsConfig{
-			Receive: c.Config.Receive,
-			SendMax: uint32(c.Config.SendMax),
-		},
-	}
-}
-
-func NewAfiSafiFromConfigStruct(c *config.AfiSafi) *api.AfiSafi {
-	return &api.AfiSafi{
-		MpGracefulRestart:        NewMpGracefulRestartFromConfigStruct(&c.MpGracefulRestart),
-		Config:                   NewAfiSafiConfigFromConfigStruct(c),
-		ApplyPolicy:              NewApplyPolicyFromConfigStruct(&c.ApplyPolicy),
-		RouteSelectionOptions:    NewRouteSelectionOptionsFromConfigStruct(&c.RouteSelectionOptions),
-		UseMultiplePaths:         NewUseMultiplePathsFromConfigStruct(&c.UseMultiplePaths),
-		PrefixLimits:             NewPrefixLimitFromConfigStruct(c),
-		RouteTargetMembership:    NewRouteTargetMembershipFromConfigStruct(&c.RouteTargetMembership),
-		LongLivedGracefulRestart: NewLongLivedGracefulRestartFromConfigStruct(&c.LongLivedGracefulRestart),
-		AddPaths:                 NewAddPathsFromConfigStruct(&c.AddPaths),
-	}
-}
-
-func NewPeerFromConfigStruct(pconf *config.Neighbor) *api.Peer {
-	afiSafis := make([]*api.AfiSafi, 0, len(pconf.AfiSafis))
-	for _, f := range pconf.AfiSafis {
-		if afiSafi := NewAfiSafiFromConfigStruct(&f); afiSafi != nil {
-			afiSafis = append(afiSafis, afiSafi)
-		}
-	}
-
-	timer := pconf.Timers
-	s := pconf.State
-	localAddress := pconf.Transport.Config.LocalAddress
-	if pconf.Transport.State.LocalAddress != "" {
-		localAddress = pconf.Transport.State.LocalAddress
-	}
-	remoteCap, err := apiutil.MarshalCapabilities(pconf.State.RemoteCapabilityList)
-	if err != nil {
-		return nil
-	}
-	localCap, err := apiutil.MarshalCapabilities(pconf.State.LocalCapabilityList)
-	if err != nil {
-		return nil
-	}
-	var removePrivateAs api.PeerConf_RemovePrivateAs
-	switch pconf.Config.RemovePrivateAs {
-	case config.REMOVE_PRIVATE_AS_OPTION_ALL:
-		removePrivateAs = api.PeerConf_ALL
-	case config.REMOVE_PRIVATE_AS_OPTION_REPLACE:
-		removePrivateAs = api.PeerConf_REPLACE
-	}
-	return &api.Peer{
-		ApplyPolicy: NewApplyPolicyFromConfigStruct(&pconf.ApplyPolicy),
-		Conf: &api.PeerConf{
-			NeighborAddress:   pconf.Config.NeighborAddress,
-			Id:                s.RemoteRouterId,
-			PeerAs:            pconf.Config.PeerAs,
-			LocalAs:           pconf.Config.LocalAs,
-			PeerType:          uint32(pconf.Config.PeerType.ToInt()),
-			AuthPassword:      pconf.Config.AuthPassword,
-			RouteFlapDamping:  pconf.Config.RouteFlapDamping,
-			Description:       pconf.Config.Description,
-			PeerGroup:         pconf.Config.PeerGroup,
-			RemoteCap:         remoteCap,
-			LocalCap:          localCap,
-			NeighborInterface: pconf.Config.NeighborInterface,
-			Vrf:               pconf.Config.Vrf,
-			AllowOwnAs:        uint32(pconf.AsPathOptions.Config.AllowOwnAs),
-			RemovePrivateAs:   removePrivateAs,
-			ReplacePeerAs:     pconf.AsPathOptions.Config.ReplacePeerAs,
-		},
-		State: &api.PeerState{
-			SessionState: api.PeerState_SessionState(api.PeerState_SessionState_value[strings.ToUpper(string(s.SessionState))]),
-			AdminState:   api.PeerState_AdminState(s.AdminState.ToInt()),
-			Messages: &api.Messages{
-				Received: &api.Message{
-					Notification: s.Messages.Received.Notification,
-					Update:       s.Messages.Received.Update,
-					Open:         s.Messages.Received.Open,
-					Keepalive:    s.Messages.Received.Keepalive,
-					Refresh:      s.Messages.Received.Refresh,
-					Discarded:    s.Messages.Received.Discarded,
-					Total:        s.Messages.Received.Total,
-				},
-				Sent: &api.Message{
-					Notification: s.Messages.Sent.Notification,
-					Update:       s.Messages.Sent.Update,
-					Open:         s.Messages.Sent.Open,
-					Keepalive:    s.Messages.Sent.Keepalive,
-					Refresh:      s.Messages.Sent.Refresh,
-					Discarded:    s.Messages.Sent.Discarded,
-					Total:        s.Messages.Sent.Total,
-				},
-			},
-			Received:        s.AdjTable.Received,
-			Accepted:        s.AdjTable.Accepted,
-			Advertised:      s.AdjTable.Advertised,
-			PeerAs:          s.PeerAs,
-			PeerType:        uint32(s.PeerType.ToInt()),
-			NeighborAddress: pconf.State.NeighborAddress,
-			Queues:          &api.Queues{},
-		},
-		EbgpMultihop: &api.EbgpMultihop{
-			Enabled:     pconf.EbgpMultihop.Config.Enabled,
-			MultihopTtl: uint32(pconf.EbgpMultihop.Config.MultihopTtl),
-		},
-		Timers: &api.Timers{
-			Config: &api.TimersConfig{
-				ConnectRetry:      uint64(timer.Config.ConnectRetry),
-				HoldTime:          uint64(timer.Config.HoldTime),
-				KeepaliveInterval: uint64(timer.Config.KeepaliveInterval),
-			},
-			State: &api.TimersState{
-				KeepaliveInterval:  uint64(timer.State.KeepaliveInterval),
-				NegotiatedHoldTime: uint64(timer.State.NegotiatedHoldTime),
-				Uptime:             uint64(timer.State.Uptime),
-				Downtime:           uint64(timer.State.Downtime),
-			},
-		},
-		RouteReflector: &api.RouteReflector{
-			RouteReflectorClient:    pconf.RouteReflector.Config.RouteReflectorClient,
-			RouteReflectorClusterId: string(pconf.RouteReflector.State.RouteReflectorClusterId),
-		},
-		RouteServer: &api.RouteServer{
-			RouteServerClient: pconf.RouteServer.Config.RouteServerClient,
-		},
-		GracefulRestart: &api.GracefulRestart{
-			Enabled:             pconf.GracefulRestart.Config.Enabled,
-			RestartTime:         uint32(pconf.GracefulRestart.Config.RestartTime),
-			HelperOnly:          pconf.GracefulRestart.Config.HelperOnly,
-			DeferralTime:        uint32(pconf.GracefulRestart.Config.DeferralTime),
-			NotificationEnabled: pconf.GracefulRestart.Config.NotificationEnabled,
-			LonglivedEnabled:    pconf.GracefulRestart.Config.LongLivedEnabled,
-			LocalRestarting:     pconf.GracefulRestart.State.LocalRestarting,
-		},
-		Transport: &api.Transport{
-			RemotePort:   uint32(pconf.Transport.Config.RemotePort),
-			LocalAddress: localAddress,
-			PassiveMode:  pconf.Transport.Config.PassiveMode,
-		},
-		AfiSafis: afiSafis,
-		AddPaths: NewAddPathsFromConfigStruct(&pconf.AddPaths),
-	}
-}
-
-func NewPeerGroupFromConfigStruct(pconf *config.PeerGroup) *api.PeerGroup {
-	afiSafis := make([]*api.AfiSafi, 0, len(pconf.AfiSafis))
-	for _, f := range pconf.AfiSafis {
-		if afiSafi := NewAfiSafiFromConfigStruct(&f); afiSafi != nil {
-			afiSafis = append(afiSafis, afiSafi)
-		}
-	}
-
-	timer := pconf.Timers
-	s := pconf.State
-	return &api.PeerGroup{
-		ApplyPolicy: NewApplyPolicyFromConfigStruct(&pconf.ApplyPolicy),
-		Conf: &api.PeerGroupConf{
-			PeerAs:           pconf.Config.PeerAs,
-			LocalAs:          pconf.Config.LocalAs,
-			PeerType:         uint32(pconf.Config.PeerType.ToInt()),
-			AuthPassword:     pconf.Config.AuthPassword,
-			RouteFlapDamping: pconf.Config.RouteFlapDamping,
-			Description:      pconf.Config.Description,
-			PeerGroupName:    pconf.Config.PeerGroupName,
-		},
-		Info: &api.PeerGroupState{
-			PeerAs:        s.PeerAs,
-			PeerType:      uint32(s.PeerType.ToInt()),
-			TotalPaths:    s.TotalPaths,
-			TotalPrefixes: s.TotalPrefixes,
-		},
-		Timers: &api.Timers{
-			Config: &api.TimersConfig{
-				ConnectRetry:      uint64(timer.Config.ConnectRetry),
-				HoldTime:          uint64(timer.Config.HoldTime),
-				KeepaliveInterval: uint64(timer.Config.KeepaliveInterval),
-			},
-			State: &api.TimersState{
-				KeepaliveInterval:  uint64(timer.State.KeepaliveInterval),
-				NegotiatedHoldTime: uint64(timer.State.NegotiatedHoldTime),
-				Uptime:             uint64(timer.State.Uptime),
-				Downtime:           uint64(timer.State.Downtime),
-			},
-		},
-		RouteReflector: &api.RouteReflector{
-			RouteReflectorClient:    pconf.RouteReflector.Config.RouteReflectorClient,
-			RouteReflectorClusterId: string(pconf.RouteReflector.Config.RouteReflectorClusterId),
-		},
-		RouteServer: &api.RouteServer{
-			RouteServerClient: pconf.RouteServer.Config.RouteServerClient,
-		},
-		GracefulRestart: &api.GracefulRestart{
-			Enabled:             pconf.GracefulRestart.Config.Enabled,
-			RestartTime:         uint32(pconf.GracefulRestart.Config.RestartTime),
-			HelperOnly:          pconf.GracefulRestart.Config.HelperOnly,
-			DeferralTime:        uint32(pconf.GracefulRestart.Config.DeferralTime),
-			NotificationEnabled: pconf.GracefulRestart.Config.NotificationEnabled,
-			LonglivedEnabled:    pconf.GracefulRestart.Config.LongLivedEnabled,
-			LocalRestarting:     pconf.GracefulRestart.State.LocalRestarting,
-		},
-		Transport: &api.Transport{
-			RemotePort:   uint32(pconf.Transport.Config.RemotePort),
-			LocalAddress: pconf.Transport.Config.LocalAddress,
-			PassiveMode:  pconf.Transport.Config.PassiveMode,
-		},
-		AfiSafis: afiSafis,
-		AddPaths: NewAddPathsFromConfigStruct(&pconf.AddPaths),
-	}
-}
-
 func (s *Server) ListPeer(r *api.ListPeerRequest, stream api.GobgpApi_ListPeerServer) error {
 	l, err := s.bgpServer.ListPeer(context.Background(), r)
 	for _, e := range l {
@@ -2342,52 +2011,6 @@ func NewGlobalFromAPIStruct(a *api.Global) *config.Global {
 	return global
 }
 
-func NewGlobalFromConfigStruct(c *config.Global) *api.Global {
-	families := make([]uint32, 0, len(c.AfiSafis))
-	for _, f := range c.AfiSafis {
-		families = append(families, uint32(config.AfiSafiTypeToIntMap[f.Config.AfiSafiName]))
-	}
-
-	applyPolicy := NewApplyPolicyFromConfigStruct(&c.ApplyPolicy)
-
-	return &api.Global{
-		As:               c.Config.As,
-		RouterId:         c.Config.RouterId,
-		ListenPort:       c.Config.Port,
-		ListenAddresses:  c.Config.LocalAddressList,
-		Families:         families,
-		UseMultiplePaths: c.UseMultiplePaths.Config.Enabled,
-		RouteSelectionOptions: &api.RouteSelectionOptionsConfig{
-			AlwaysCompareMed:         c.RouteSelectionOptions.Config.AlwaysCompareMed,
-			IgnoreAsPathLength:       c.RouteSelectionOptions.Config.IgnoreAsPathLength,
-			ExternalCompareRouterId:  c.RouteSelectionOptions.Config.ExternalCompareRouterId,
-			AdvertiseInactiveRoutes:  c.RouteSelectionOptions.Config.AdvertiseInactiveRoutes,
-			EnableAigp:               c.RouteSelectionOptions.Config.EnableAigp,
-			IgnoreNextHopIgpMetric:   c.RouteSelectionOptions.Config.IgnoreNextHopIgpMetric,
-			DisableBestPathSelection: c.RouteSelectionOptions.Config.DisableBestPathSelection,
-		},
-		DefaultRouteDistance: &api.DefaultRouteDistance{
-			ExternalRouteDistance: uint32(c.DefaultRouteDistance.Config.ExternalRouteDistance),
-			InternalRouteDistance: uint32(c.DefaultRouteDistance.Config.InternalRouteDistance),
-		},
-		Confederation: &api.Confederation{
-			Enabled:      c.Confederation.Config.Enabled,
-			Identifier:   c.Confederation.Config.Identifier,
-			MemberAsList: c.Confederation.Config.MemberAsList,
-		},
-		GracefulRestart: &api.GracefulRestart{
-			Enabled:             c.GracefulRestart.Config.Enabled,
-			RestartTime:         uint32(c.GracefulRestart.Config.RestartTime),
-			StaleRoutesTime:     uint32(c.GracefulRestart.Config.StaleRoutesTime),
-			HelperOnly:          c.GracefulRestart.Config.HelperOnly,
-			DeferralTime:        uint32(c.GracefulRestart.Config.DeferralTime),
-			NotificationEnabled: c.GracefulRestart.Config.NotificationEnabled,
-			LonglivedEnabled:    c.GracefulRestart.Config.LongLivedEnabled,
-		},
-		ApplyPolicy: applyPolicy,
-	}
-}
-
 func (s *Server) StartBgp(ctx context.Context, r *api.StartBgpRequest) (*empty.Empty, error) {
 	return &empty.Empty{}, s.bgpServer.StartBgp(ctx, r)
 }