From af98780240d247f4df352c364002d1d77e71f31e Mon Sep 17 00:00:00 2001 From: FUJITA Tomonori Date: Fri, 29 Jul 2016 00:43:52 +0900 Subject: move grpc_server.go from server/ to api/ Now all gRPC code was moved to api/. server/ isn't dependent on gRPC anymore. Signed-off-by: FUJITA Tomonori --- server/grpc_server.go | 1673 ------------------------------------------------- 1 file changed, 1673 deletions(-) delete mode 100644 server/grpc_server.go (limited to 'server') diff --git a/server/grpc_server.go b/server/grpc_server.go deleted file mode 100644 index 03dc9c7b..00000000 --- a/server/grpc_server.go +++ /dev/null @@ -1,1673 +0,0 @@ -// Copyright (C) 2014-2016 Nippon Telegraph and Telephone Corporation. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or -// implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package server - -import ( - "fmt" - log "github.com/Sirupsen/logrus" - api "github.com/osrg/gobgp/api" - "github.com/osrg/gobgp/config" - "github.com/osrg/gobgp/packet/bgp" - "github.com/osrg/gobgp/table" - "golang.org/x/net/context" - "google.golang.org/grpc" - "io" - "net" - "reflect" - "regexp" - "strconv" - "strings" - "sync" - "time" -) - -type Server struct { - bgpServer *BgpServer - grpcServer *grpc.Server - hosts string -} - -func NewGrpcServer(b *BgpServer, hosts string) *Server { - grpc.EnableTracing = false - grpcServer := grpc.NewServer() - server := &Server{ - bgpServer: b, - grpcServer: grpcServer, - hosts: hosts, - } - api.RegisterGobgpApiServer(grpcServer, server) - return server -} - -func (s *Server) Serve() error { - var wg sync.WaitGroup - l := strings.Split(s.hosts, ",") - wg.Add(len(l)) - - serve := func(host string) { - for { - defer wg.Done() - lis, err := net.Listen("tcp", fmt.Sprintf(host)) - if err != nil { - log.WithFields(log.Fields{ - "Topic": "grpc", - "Key": host, - "Error": err, - }).Warn("listen failed") - return - } - err = s.grpcServer.Serve(lis) - log.WithFields(log.Fields{ - "Topic": "grpc", - "Key": host, - "Error": err, - }).Warn("accept failed") - } - } - for _, host := range l { - go serve(host) - } - wg.Wait() - return nil -} - -func (s *Server) GetNeighbor(ctx context.Context, arg *api.GetNeighborRequest) (*api.GetNeighborResponse, error) { - toApi := func(pconf *config.Neighbor) *api.Peer { - prefixLimits := make([]*api.PrefixLimit, 0, len(pconf.AfiSafis)) - for _, family := range pconf.AfiSafis { - if c := family.PrefixLimit.Config; c.MaxPrefixes > 0 { - k, _ := bgp.GetRouteFamily(string(family.Config.AfiSafiName)) - prefixLimits = append(prefixLimits, &api.PrefixLimit{ - Family: uint32(k), - MaxPrefixes: c.MaxPrefixes, - ShutdownThresholdPct: uint32(c.ShutdownThresholdPct), - }) - } - } - - timer := pconf.Timers - s := pconf.State - return &api.Peer{ - Conf: &api.PeerConf{ - NeighborAddress: pconf.Config.NeighborAddress, - Id: s.Description, - PeerAs: pconf.Config.PeerAs, - LocalAs: pconf.Config.LocalAs, - PeerType: uint32(pconf.Config.PeerType.ToInt()), - AuthPassword: pconf.Config.AuthPassword, - RemovePrivateAs: uint32(pconf.Config.RemovePrivateAs.ToInt()), - RouteFlapDamping: pconf.Config.RouteFlapDamping, - SendCommunity: uint32(pconf.Config.SendCommunity.ToInt()), - Description: pconf.Config.Description, - PeerGroup: pconf.Config.PeerGroup, - RemoteCap: s.Capabilities.RemoteList, - LocalCap: s.Capabilities.LocalList, - PrefixLimits: prefixLimits, - }, - Info: &api.PeerState{ - BgpState: bgp.FSMState(s.SessionState.ToInt()).String(), - AdminState: s.AdminState, - 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, - }, - 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, - }, - } - } - - p := []*api.Peer{} - for _, e := range s.bgpServer.GetNeighbor() { - p = append(p, toApi(e)) - } - return &api.GetNeighborResponse{Peers: p}, nil -} - -func toPathApi(id string, path *table.Path) *api.Path { - nlri := path.GetNlri() - n, _ := nlri.Serialize() - family := uint32(bgp.AfiSafiToRouteFamily(nlri.AFI(), nlri.SAFI())) - pattrs := func(arg []bgp.PathAttributeInterface) [][]byte { - ret := make([][]byte, 0, len(arg)) - for _, a := range arg { - aa, _ := a.Serialize() - ret = append(ret, aa) - } - return ret - }(path.GetPathAttrs()) - return &api.Path{ - Nlri: n, - Pattrs: pattrs, - Age: path.GetTimestamp().Unix(), - IsWithdraw: path.IsWithdraw, - Validation: int32(path.Validation().ToInt()), - Filtered: path.Filtered(id) == table.POLICY_DIRECTION_IN, - Family: family, - SourceAsn: path.GetSource().AS, - SourceId: path.GetSource().ID.String(), - NeighborIp: path.GetSource().Address.String(), - Stale: path.IsStale(), - IsFromExternal: path.IsFromExternal(), - } -} - -func (s *Server) GetRib(ctx context.Context, arg *api.GetRibRequest) (*api.GetRibResponse, error) { - f := func() []*LookupPrefix { - l := make([]*LookupPrefix, 0, len(arg.Table.Destinations)) - for _, p := range arg.Table.Destinations { - l = append(l, &LookupPrefix{ - Prefix: p.Prefix, - LookupOption: func() LookupOption { - if p.LongerPrefixes { - return LOOKUP_LONGER - } else if p.ShorterPrefixes { - return LOOKUP_SHORTER - } - return LOOKUP_EXACT - }(), - }) - } - return l - } - - var in bool - var err error - var id string - var r map[string][]*table.Path - - family := bgp.RouteFamily(arg.Table.Family) - switch arg.Table.Type { - case api.Resource_LOCAL, api.Resource_GLOBAL: - id, r, err = s.bgpServer.GetRib(arg.Table.Name, family, f()) - case api.Resource_ADJ_IN: - in = true - fallthrough - case api.Resource_ADJ_OUT: - id, r, err = s.bgpServer.GetAdjRib(arg.Table.Name, family, in, f()) - case api.Resource_VRF: - id, r, err = s.bgpServer.GetVrfRib(arg.Table.Name, family, []*LookupPrefix{}) - default: - return nil, fmt.Errorf("unsupported resource type: %v", arg.Table.Type) - } - - dsts := make([]*api.Destination, 0, len(r)) - if err == nil { - for k, v := range r { - dsts = append(dsts, &api.Destination{ - Prefix: k, - Paths: func(paths []*table.Path) []*api.Path { - l := make([]*api.Path, 0, len(v)) - for i, p := range paths { - pp := toPathApi(id, p) - switch arg.Table.Type { - case api.Resource_LOCAL, api.Resource_GLOBAL: - if i == 0 { - pp.Best = true - } - } - l = append(l, pp) - } - return l - }(v), - }) - } - } - return &api.GetRibResponse{Table: &api.Table{ - Type: arg.Table.Type, - Family: arg.Table.Family, - Destinations: dsts}, - }, err -} - -func (s *Server) MonitorRib(arg *api.Table, stream api.GobgpApi_MonitorRibServer) error { - w, err := func() (*Watcher, error) { - switch arg.Type { - case api.Resource_GLOBAL: - return s.bgpServer.Watch(WatchBestPath()), nil - case api.Resource_ADJ_IN: - if arg.PostPolicy { - return s.bgpServer.Watch(WatchPostUpdate(false)), nil - } - return s.bgpServer.Watch(WatchUpdate(false)), nil - default: - return nil, fmt.Errorf("unsupported resource type: %v", arg.Type) - } - }() - if err != nil { - return nil - } - - return func() error { - defer func() { w.Stop() }() - - sendPath := func(pathList []*table.Path) error { - dsts := make(map[string]*api.Destination) - for _, path := range pathList { - if path == nil { - continue - } - if dst, y := dsts[path.GetNlri().String()]; y { - dst.Paths = append(dst.Paths, toPathApi(table.GLOBAL_RIB_NAME, path)) - } else { - dsts[path.GetNlri().String()] = &api.Destination{ - Prefix: path.GetNlri().String(), - Paths: []*api.Path{toPathApi(table.GLOBAL_RIB_NAME, path)}, - } - } - } - for _, dst := range dsts { - if err := stream.Send(dst); err != nil { - return err - } - } - return nil - } - for { - select { - case ev := <-w.Event(): - switch msg := ev.(type) { - case *WatchEventBestPath: - if err := sendPath(func() []*table.Path { - if len(msg.MultiPathList) > 0 { - l := make([]*table.Path, 0) - for _, p := range msg.MultiPathList { - l = append(l, p...) - } - return l - } else { - return msg.PathList - } - }()); err != nil { - return err - } - case *WatchEventUpdate: - if err := sendPath(msg.PathList); err != nil { - return err - } - } - } - } - }() -} - -func (s *Server) MonitorPeerState(arg *api.Arguments, stream api.GobgpApi_MonitorPeerStateServer) error { - return func() error { - w := s.bgpServer.Watch(WatchPeerState(false)) - defer func() { w.Stop() }() - - for { - select { - case ev := <-w.Event(): - switch msg := ev.(type) { - case *WatchEventPeerState: - if len(arg.Name) > 0 && arg.Name != msg.PeerAddress.String() { - continue - } - if err := stream.Send(&api.Peer{ - Conf: &api.PeerConf{ - PeerAs: msg.PeerAS, - LocalAs: msg.LocalAS, - NeighborAddress: msg.PeerAddress.String(), - Id: msg.PeerID.String(), - }, - Info: &api.PeerState{ - PeerAs: msg.PeerAS, - LocalAs: msg.LocalAS, - NeighborAddress: msg.PeerAddress.String(), - BgpState: msg.State.String(), - AdminState: msg.AdminState.String(), - }, - Transport: &api.Transport{ - LocalAddress: msg.LocalAddress.String(), - LocalPort: uint32(msg.LocalPort), - RemotePort: uint32(msg.PeerPort), - }, - }); err != nil { - return err - } - } - } - } - }() -} - -func (s *Server) ResetNeighbor(ctx context.Context, arg *api.ResetNeighborRequest) (*api.ResetNeighborResponse, error) { - return &api.ResetNeighborResponse{}, s.bgpServer.ResetNeighbor(arg.Address) -} - -func (s *Server) SoftResetNeighbor(ctx context.Context, arg *api.SoftResetNeighborRequest) (*api.SoftResetNeighborResponse, error) { - var err error - addr := arg.Address - if addr == "all" { - addr = "" - } - family := bgp.RouteFamily(0) - switch arg.Direction { - case api.SoftResetNeighborRequest_IN: - err = s.bgpServer.SoftResetIn(addr, family) - case api.SoftResetNeighborRequest_OUT: - err = s.bgpServer.SoftResetOut(addr, family) - default: - err = s.bgpServer.SoftReset(addr, family) - } - return &api.SoftResetNeighborResponse{}, err -} - -func (s *Server) ShutdownNeighbor(ctx context.Context, arg *api.ShutdownNeighborRequest) (*api.ShutdownNeighborResponse, error) { - return &api.ShutdownNeighborResponse{}, s.bgpServer.ShutdownNeighbor(arg.Address) -} - -func (s *Server) EnableNeighbor(ctx context.Context, arg *api.EnableNeighborRequest) (*api.EnableNeighborResponse, error) { - return &api.EnableNeighborResponse{}, s.bgpServer.EnableNeighbor(arg.Address) -} - -func (s *Server) DisableNeighbor(ctx context.Context, arg *api.DisableNeighborRequest) (*api.DisableNeighborResponse, error) { - return &api.DisableNeighborResponse{}, s.bgpServer.DisableNeighbor(arg.Address) -} - -func (s *Server) api2PathList(resource api.Resource, ApiPathList []*api.Path) ([]*table.Path, error) { - var nlri bgp.AddrPrefixInterface - var nexthop string - var pi *table.PeerInfo - - pathList := make([]*table.Path, 0, len(ApiPathList)) - for _, path := range ApiPathList { - seen := make(map[bgp.BGPAttrType]bool) - - pattr := make([]bgp.PathAttributeInterface, 0) - extcomms := make([]bgp.ExtendedCommunityInterface, 0) - - if path.SourceAsn != 0 { - pi = &table.PeerInfo{ - AS: path.SourceAsn, - LocalID: net.ParseIP(path.SourceId), - } - } - - if len(path.Nlri) > 0 { - nlri = &bgp.IPAddrPrefix{} - err := nlri.DecodeFromBytes(path.Nlri) - if err != nil { - return nil, err - } - } - - for _, attr := range path.Pattrs { - p, err := bgp.GetPathAttribute(attr) - if err != nil { - return nil, err - } - - err = p.DecodeFromBytes(attr) - if err != nil { - return nil, err - } - - if _, ok := seen[p.GetType()]; !ok { - seen[p.GetType()] = true - } else { - return nil, fmt.Errorf("the path attribute apears twice. Type : " + strconv.Itoa(int(p.GetType()))) - } - switch p.GetType() { - case bgp.BGP_ATTR_TYPE_NEXT_HOP: - nexthop = p.(*bgp.PathAttributeNextHop).Value.String() - case bgp.BGP_ATTR_TYPE_EXTENDED_COMMUNITIES: - value := p.(*bgp.PathAttributeExtendedCommunities).Value - if len(value) > 0 { - extcomms = append(extcomms, value...) - } - case bgp.BGP_ATTR_TYPE_MP_REACH_NLRI: - mpreach := p.(*bgp.PathAttributeMpReachNLRI) - if len(mpreach.Value) != 1 { - return nil, fmt.Errorf("include only one route in mp_reach_nlri") - } - nlri = mpreach.Value[0] - nexthop = mpreach.Nexthop.String() - default: - pattr = append(pattr, p) - } - } - - if nlri == nil || nexthop == "" { - return nil, fmt.Errorf("not found nlri or nexthop") - } - - rf := bgp.AfiSafiToRouteFamily(nlri.AFI(), nlri.SAFI()) - - if resource != api.Resource_VRF && rf == bgp.RF_IPv4_UC { - pattr = append(pattr, bgp.NewPathAttributeNextHop(nexthop)) - } else { - pattr = append(pattr, bgp.NewPathAttributeMpReachNLRI(nexthop, []bgp.AddrPrefixInterface{nlri})) - } - - if len(extcomms) > 0 { - pattr = append(pattr, bgp.NewPathAttributeExtendedCommunities(extcomms)) - } - newPath := table.NewPath(pi, nlri, path.IsWithdraw, pattr, time.Now(), path.NoImplicitWithdraw) - newPath.SetIsFromExternal(path.IsFromExternal) - pathList = append(pathList, newPath) - } - return pathList, nil -} - -func (s *Server) AddPath(ctx context.Context, arg *api.AddPathRequest) (*api.AddPathResponse, error) { - pathList, err := s.api2PathList(arg.Resource, []*api.Path{arg.Path}) - var uuid []byte - if err == nil { - uuid, err = s.bgpServer.AddPath(arg.VrfId, pathList) - } - return &api.AddPathResponse{Uuid: uuid}, err -} - -func (s *Server) DeletePath(ctx context.Context, arg *api.DeletePathRequest) (*api.DeletePathResponse, error) { - pathList, err := func() ([]*table.Path, error) { - if arg.Path != nil { - arg.Path.IsWithdraw = true - return s.api2PathList(arg.Resource, []*api.Path{arg.Path}) - } - return []*table.Path{}, nil - }() - if err != nil { - return nil, err - } - return &api.DeletePathResponse{}, s.bgpServer.DeletePath(arg.Uuid, bgp.RouteFamily(arg.Family), arg.VrfId, pathList) -} - -func (s *Server) EnableMrt(ctx context.Context, arg *api.EnableMrtRequest) (*api.EnableMrtResponse, error) { - return &api.EnableMrtResponse{}, s.bgpServer.EnableMrt(&config.Mrt{ - Interval: arg.Interval, - DumpType: config.IntToMrtTypeMap[int(arg.DumpType)], - FileName: arg.Filename, - }) -} - -func (s *Server) DisableMrt(ctx context.Context, arg *api.DisableMrtRequest) (*api.DisableMrtResponse, error) { - return &api.DisableMrtResponse{}, s.bgpServer.DisableMrt() -} - -func (s *Server) InjectMrt(stream api.GobgpApi_InjectMrtServer) error { - for { - arg, err := stream.Recv() - - if err == io.EOF { - break - } else if err != nil { - return err - } - - if arg.Resource != api.Resource_GLOBAL && arg.Resource != api.Resource_VRF { - return fmt.Errorf("unsupported resource: %s", arg.Resource) - } - - if pathList, err := s.api2PathList(arg.Resource, arg.Paths); err != nil { - return err - } else { - if _, err = s.bgpServer.AddPath("", pathList); err != nil { - return err - } - } - } - return stream.SendAndClose(&api.InjectMrtResponse{}) -} - -func (s *Server) AddBmp(ctx context.Context, arg *api.AddBmpRequest) (*api.AddBmpResponse, error) { - return &api.AddBmpResponse{}, s.bgpServer.AddBmp(&config.BmpServerConfig{ - Address: arg.Address, - Port: arg.Port, - RouteMonitoringPolicy: config.BmpRouteMonitoringPolicyType(arg.Type), - }) -} - -func (s *Server) DeleteBmp(ctx context.Context, arg *api.DeleteBmpRequest) (*api.DeleteBmpResponse, error) { - return &api.DeleteBmpResponse{}, s.bgpServer.DeleteBmp(&config.BmpServerConfig{ - Address: arg.Address, - Port: arg.Port, - }) -} - -func (s *Server) ValidateRib(ctx context.Context, arg *api.ValidateRibRequest) (*api.ValidateRibResponse, error) { - return &api.ValidateRibResponse{}, s.bgpServer.ValidateRib(arg.Prefix) -} - -func (s *Server) AddRpki(ctx context.Context, arg *api.AddRpkiRequest) (*api.AddRpkiResponse, error) { - return &api.AddRpkiResponse{}, s.bgpServer.AddRpki(&config.RpkiServerConfig{ - Address: arg.Address, - Port: arg.Port, - RecordLifetime: arg.Lifetime, - }) -} - -func (s *Server) DeleteRpki(ctx context.Context, arg *api.DeleteRpkiRequest) (*api.DeleteRpkiResponse, error) { - return &api.DeleteRpkiResponse{}, s.bgpServer.DeleteRpki(&config.RpkiServerConfig{ - Address: arg.Address, - Port: arg.Port, - }) -} - -func (s *Server) EnableRpki(ctx context.Context, arg *api.EnableRpkiRequest) (*api.EnableRpkiResponse, error) { - return &api.EnableRpkiResponse{}, s.bgpServer.EnableRpki(&config.RpkiServerConfig{ - Address: arg.Address, - }) -} - -func (s *Server) DisableRpki(ctx context.Context, arg *api.DisableRpkiRequest) (*api.DisableRpkiResponse, error) { - return &api.DisableRpkiResponse{}, s.bgpServer.DisableRpki(&config.RpkiServerConfig{ - Address: arg.Address, - }) -} - -func (s *Server) ResetRpki(ctx context.Context, arg *api.ResetRpkiRequest) (*api.ResetRpkiResponse, error) { - return &api.ResetRpkiResponse{}, s.bgpServer.ResetRpki(&config.RpkiServerConfig{ - Address: arg.Address, - }) -} - -func (s *Server) SoftResetRpki(ctx context.Context, arg *api.SoftResetRpkiRequest) (*api.SoftResetRpkiResponse, error) { - return &api.SoftResetRpkiResponse{}, s.bgpServer.SoftResetRpki(&config.RpkiServerConfig{ - Address: arg.Address, - }) -} - -func (s *Server) GetRpki(ctx context.Context, arg *api.GetRpkiRequest) (*api.GetRpkiResponse, error) { - servers, err := s.bgpServer.GetRpki() - if err != nil { - return nil, err - } - l := make([]*api.Rpki, 0, len(servers)) - for _, s := range servers { - received := &s.State.RpkiMessages.RpkiReceived - sent := &s.State.RpkiMessages.RpkiSent - rpki := &api.Rpki{ - Conf: &api.RPKIConf{ - Address: s.Config.Address, - RemotePort: strconv.Itoa(int(s.Config.Port)), - }, - State: &api.RPKIState{ - Uptime: s.State.Uptime, - Downtime: s.State.Downtime, - Up: s.State.Up, - RecordIpv4: s.State.RecordsV4, - RecordIpv6: s.State.RecordsV6, - PrefixIpv4: s.State.PrefixesV4, - PrefixIpv6: s.State.PrefixesV6, - Serial: s.State.SerialNumber, - ReceivedIpv4: received.Ipv4Prefix, - ReceivedIpv6: received.Ipv6Prefix, - SerialNotify: received.SerialNotify, - CacheReset: received.CacheReset, - CacheResponse: received.CacheResponse, - EndOfData: received.EndOfData, - Error: received.Error, - SerialQuery: sent.SerialQuery, - ResetQuery: sent.ResetQuery, - }, - } - l = append(l, rpki) - } - return &api.GetRpkiResponse{Servers: l}, nil -} - -func (s *Server) GetRoa(ctx context.Context, arg *api.GetRoaRequest) (*api.GetRoaResponse, error) { - roas, err := s.bgpServer.GetRoa(bgp.RouteFamily(arg.Family)) - if err != nil { - return nil, err - } - l := make([]*api.Roa, 0, len(roas)) - for _, r := range roas { - host, port, _ := net.SplitHostPort(r.Src) - l = append(l, &api.Roa{ - As: r.AS, - Maxlen: uint32(r.MaxLen), - Prefixlen: uint32(r.Prefix.Length), - Prefix: r.Prefix.Prefix.String(), - Conf: &api.RPKIConf{ - Address: host, - RemotePort: port, - }, - }) - } - return &api.GetRoaResponse{Roas: l}, nil -} - -func (s *Server) GetVrf(ctx context.Context, arg *api.GetVrfRequest) (*api.GetVrfResponse, error) { - toApi := func(v *table.Vrf) *api.Vrf { - f := func(rts []bgp.ExtendedCommunityInterface) [][]byte { - ret := make([][]byte, 0, len(rts)) - for _, rt := range rts { - b, _ := rt.Serialize() - ret = append(ret, b) - } - return ret - } - rd, _ := v.Rd.Serialize() - return &api.Vrf{ - Name: v.Name, - Rd: rd, - ImportRt: f(v.ImportRt), - ExportRt: f(v.ExportRt), - } - } - vrfs := s.bgpServer.GetVrf() - l := make([]*api.Vrf, 0, len(vrfs)) - for _, v := range vrfs { - l = append(l, toApi(v)) - } - return &api.GetVrfResponse{Vrfs: l}, nil -} - -func (s *Server) AddVrf(ctx context.Context, arg *api.AddVrfRequest) (r *api.AddVrfResponse, err error) { - rd := bgp.GetRouteDistinguisher(arg.Vrf.Rd) - f := func(bufs [][]byte) ([]bgp.ExtendedCommunityInterface, error) { - ret := make([]bgp.ExtendedCommunityInterface, 0, len(bufs)) - for _, rt := range bufs { - r, err := bgp.ParseExtended(rt) - if err != nil { - return nil, err - } - ret = append(ret, r) - } - return ret, nil - } - im, err := f(arg.Vrf.ImportRt) - if err != nil { - return &api.AddVrfResponse{}, err - } - ex, err := f(arg.Vrf.ExportRt) - if err != nil { - return &api.AddVrfResponse{}, err - } - return &api.AddVrfResponse{}, s.bgpServer.AddVrf(arg.Vrf.Name, rd, im, ex) -} - -func (s *Server) DeleteVrf(ctx context.Context, arg *api.DeleteVrfRequest) (*api.DeleteVrfResponse, error) { - return &api.DeleteVrfResponse{}, s.bgpServer.DeleteVrf(arg.Vrf.Name) -} - -func (s *Server) AddNeighbor(ctx context.Context, arg *api.AddNeighborRequest) (*api.AddNeighborResponse, error) { - c, err := func(a *api.Peer) (config.Neighbor, error) { - pconf := config.Neighbor{} - if a.Conf != nil { - pconf.Config.NeighborAddress = a.Conf.NeighborAddress - pconf.Config.PeerAs = a.Conf.PeerAs - pconf.Config.LocalAs = a.Conf.LocalAs - - if pconf.Config.PeerAs != pconf.Config.LocalAs { - pconf.Config.PeerType = config.PEER_TYPE_EXTERNAL - } else { - pconf.Config.PeerType = config.PEER_TYPE_INTERNAL - } - pconf.Config.AuthPassword = a.Conf.AuthPassword - pconf.Config.RemovePrivateAs = config.RemovePrivateAsOption(a.Conf.RemovePrivateAs) - pconf.Config.RouteFlapDamping = a.Conf.RouteFlapDamping - pconf.Config.SendCommunity = config.CommunityType(a.Conf.SendCommunity) - pconf.Config.Description = a.Conf.Description - pconf.Config.PeerGroup = a.Conf.PeerGroup - pconf.Config.NeighborAddress = a.Conf.NeighborAddress - } - if a.Timers != nil { - if a.Timers.Config != nil { - pconf.Timers.Config.ConnectRetry = float64(a.Timers.Config.ConnectRetry) - pconf.Timers.Config.HoldTime = float64(a.Timers.Config.HoldTime) - pconf.Timers.Config.KeepaliveInterval = float64(a.Timers.Config.KeepaliveInterval) - pconf.Timers.Config.MinimumAdvertisementInterval = float64(a.Timers.Config.MinimumAdvertisementInterval) - } - } else { - pconf.Timers.Config.ConnectRetry = float64(config.DEFAULT_CONNECT_RETRY) - pconf.Timers.Config.HoldTime = float64(config.DEFAULT_HOLDTIME) - pconf.Timers.Config.KeepaliveInterval = float64(config.DEFAULT_HOLDTIME / 3) - } - if a.RouteReflector != nil { - pconf.RouteReflector.Config.RouteReflectorClusterId = config.RrClusterIdType(a.RouteReflector.RouteReflectorClusterId) - pconf.RouteReflector.Config.RouteReflectorClient = a.RouteReflector.RouteReflectorClient - } - if a.RouteServer != nil { - pconf.RouteServer.Config.RouteServerClient = a.RouteServer.RouteServerClient - } - if a.ApplyPolicy != nil { - if a.ApplyPolicy.ImportPolicy != nil { - pconf.ApplyPolicy.Config.DefaultImportPolicy = config.DefaultPolicyType(a.ApplyPolicy.ImportPolicy.Default) - for _, p := range a.ApplyPolicy.ImportPolicy.Policies { - pconf.ApplyPolicy.Config.ImportPolicyList = append(pconf.ApplyPolicy.Config.ImportPolicyList, p.Name) - } - } - if a.ApplyPolicy.ExportPolicy != nil { - pconf.ApplyPolicy.Config.DefaultExportPolicy = config.DefaultPolicyType(a.ApplyPolicy.ExportPolicy.Default) - for _, p := range a.ApplyPolicy.ExportPolicy.Policies { - pconf.ApplyPolicy.Config.ExportPolicyList = append(pconf.ApplyPolicy.Config.ExportPolicyList, p.Name) - } - } - if a.ApplyPolicy.InPolicy != nil { - pconf.ApplyPolicy.Config.DefaultInPolicy = config.DefaultPolicyType(a.ApplyPolicy.InPolicy.Default) - for _, p := range a.ApplyPolicy.InPolicy.Policies { - pconf.ApplyPolicy.Config.InPolicyList = append(pconf.ApplyPolicy.Config.InPolicyList, p.Name) - } - } - } - if a.Families != nil { - for _, family := range a.Families { - name, ok := bgp.AddressFamilyNameMap[bgp.RouteFamily(family)] - if !ok { - return pconf, fmt.Errorf("invalid address family: %d", family) - } - cAfiSafi := config.AfiSafi{ - Config: config.AfiSafiConfig{ - AfiSafiName: config.AfiSafiType(name), - }, - } - pconf.AfiSafis = append(pconf.AfiSafis, cAfiSafi) - } - } else { - if net.ParseIP(a.Conf.NeighborAddress).To4() != nil { - pconf.AfiSafis = []config.AfiSafi{ - config.AfiSafi{ - Config: config.AfiSafiConfig{ - AfiSafiName: "ipv4-unicast", - }, - }, - } - } else { - pconf.AfiSafis = []config.AfiSafi{ - config.AfiSafi{ - Config: config.AfiSafiConfig{ - AfiSafiName: "ipv6-unicast", - }, - }, - } - } - } - if a.Transport != nil { - pconf.Transport.Config.LocalAddress = a.Transport.LocalAddress - pconf.Transport.Config.PassiveMode = a.Transport.PassiveMode - } else { - if net.ParseIP(a.Conf.NeighborAddress).To4() != nil { - pconf.Transport.Config.LocalAddress = "0.0.0.0" - } else { - pconf.Transport.Config.LocalAddress = "::" - } - } - if a.EbgpMultihop != nil { - pconf.EbgpMultihop.Config.Enabled = a.EbgpMultihop.Enabled - pconf.EbgpMultihop.Config.MultihopTtl = uint8(a.EbgpMultihop.MultihopTtl) - } - return pconf, nil - }(arg.Peer) - if err != nil { - return nil, err - } - return &api.AddNeighborResponse{}, s.bgpServer.AddNeighbor(&c) -} - -func (s *Server) DeleteNeighbor(ctx context.Context, arg *api.DeleteNeighborRequest) (*api.DeleteNeighborResponse, error) { - return &api.DeleteNeighborResponse{}, s.bgpServer.DeleteNeighbor(&config.Neighbor{Config: config.NeighborConfig{ - NeighborAddress: arg.Peer.Conf.NeighborAddress, - }}) -} - -func NewPrefixFromApiStruct(a *api.Prefix) (*table.Prefix, error) { - addr, prefix, err := net.ParseCIDR(a.IpPrefix) - if err != nil { - return nil, err - } - rf := bgp.RF_IPv4_UC - if addr.To4() == nil { - rf = bgp.RF_IPv6_UC - } - return &table.Prefix{ - Prefix: prefix, - AddressFamily: rf, - MasklengthRangeMin: uint8(a.MaskLengthMin), - MasklengthRangeMax: uint8(a.MaskLengthMax), - }, nil -} - -func NewDefinedSetFromApiStruct(a *api.DefinedSet) (table.DefinedSet, error) { - if a.Name == "" { - return nil, fmt.Errorf("empty neighbor set name") - } - switch table.DefinedType(a.Type) { - case table.DEFINED_TYPE_PREFIX: - prefixes := make([]*table.Prefix, 0, len(a.Prefixes)) - for _, p := range a.Prefixes { - prefix, err := NewPrefixFromApiStruct(p) - if err != nil { - return nil, err - } - prefixes = append(prefixes, prefix) - } - return table.NewPrefixSetFromApiStruct(a.Name, prefixes) - case table.DEFINED_TYPE_NEIGHBOR: - list := make([]net.IP, 0, len(a.List)) - for _, x := range a.List { - addr := net.ParseIP(x) - if addr == nil { - return nil, fmt.Errorf("invalid ip address format: %s", x) - } - list = append(list, addr) - } - return table.NewNeighborSetFromApiStruct(a.Name, list) - case table.DEFINED_TYPE_AS_PATH: - return table.NewAsPathSet(config.AsPathSet{ - AsPathSetName: a.Name, - AsPathList: a.List, - }) - case table.DEFINED_TYPE_COMMUNITY: - return table.NewCommunitySet(config.CommunitySet{ - CommunitySetName: a.Name, - CommunityList: a.List, - }) - case table.DEFINED_TYPE_EXT_COMMUNITY: - return table.NewExtCommunitySet(config.ExtCommunitySet{ - ExtCommunitySetName: a.Name, - ExtCommunityList: a.List, - }) - default: - return nil, fmt.Errorf("invalid defined type") - } -} - -func (s *Server) GetDefinedSet(ctx context.Context, arg *api.GetDefinedSetRequest) (*api.GetDefinedSetResponse, error) { - cd, err := s.bgpServer.GetDefinedSet(table.DefinedType(arg.Type)) - if err != nil { - return nil, err - } - sets := make([]*api.DefinedSet, 0) - for _, cs := range cd.PrefixSets { - ad := &api.DefinedSet{ - Type: api.DefinedType_PREFIX, - Name: cs.PrefixSetName, - Prefixes: func() []*api.Prefix { - l := make([]*api.Prefix, 0, len(cs.PrefixList)) - for _, p := range cs.PrefixList { - exp := regexp.MustCompile("(\\d+)\\.\\.(\\d+)") - elems := exp.FindStringSubmatch(p.MasklengthRange) - min, _ := strconv.Atoi(elems[1]) - max, _ := strconv.Atoi(elems[2]) - - l = append(l, &api.Prefix{IpPrefix: p.IpPrefix, MaskLengthMin: uint32(min), MaskLengthMax: uint32(max)}) - } - return l - }(), - } - sets = append(sets, ad) - - } - for _, cs := range cd.NeighborSets { - ad := &api.DefinedSet{ - Type: api.DefinedType_NEIGHBOR, - Name: cs.NeighborSetName, - List: cs.NeighborInfoList, - } - sets = append(sets, ad) - } - for _, cs := range cd.BgpDefinedSets.CommunitySets { - ad := &api.DefinedSet{ - Type: api.DefinedType_COMMUNITY, - Name: cs.CommunitySetName, - List: cs.CommunityList, - } - sets = append(sets, ad) - } - for _, cs := range cd.BgpDefinedSets.ExtCommunitySets { - ad := &api.DefinedSet{ - Type: api.DefinedType_EXT_COMMUNITY, - Name: cs.ExtCommunitySetName, - List: cs.ExtCommunityList, - } - sets = append(sets, ad) - } - for _, cs := range cd.BgpDefinedSets.AsPathSets { - ad := &api.DefinedSet{ - Type: api.DefinedType_AS_PATH, - Name: cs.AsPathSetName, - List: cs.AsPathList, - } - sets = append(sets, ad) - } - - return &api.GetDefinedSetResponse{Sets: sets}, nil -} - -func (s *Server) AddDefinedSet(ctx context.Context, arg *api.AddDefinedSetRequest) (*api.AddDefinedSetResponse, error) { - set, err := NewDefinedSetFromApiStruct(arg.Set) - if err != nil { - return nil, err - } - return &api.AddDefinedSetResponse{}, s.bgpServer.AddDefinedSet(set) -} - -func (s *Server) DeleteDefinedSet(ctx context.Context, arg *api.DeleteDefinedSetRequest) (*api.DeleteDefinedSetResponse, error) { - set, err := NewDefinedSetFromApiStruct(arg.Set) - if err != nil { - return nil, err - } - return &api.DeleteDefinedSetResponse{}, s.bgpServer.DeleteDefinedSet(set, arg.All) -} - -func (s *Server) ReplaceDefinedSet(ctx context.Context, arg *api.ReplaceDefinedSetRequest) (*api.ReplaceDefinedSetResponse, error) { - set, err := NewDefinedSetFromApiStruct(arg.Set) - if err != nil { - return nil, err - } - return &api.ReplaceDefinedSetResponse{}, s.bgpServer.ReplaceDefinedSet(set) -} - -func toStatementApi(s *config.Statement) *api.Statement { - cs := &api.Conditions{} - if s.Conditions.MatchPrefixSet.PrefixSet != "" { - cs.PrefixSet = &api.MatchSet{ - Type: api.MatchType(s.Conditions.MatchPrefixSet.MatchSetOptions.ToInt()), - Name: s.Conditions.MatchPrefixSet.PrefixSet, - } - } - if s.Conditions.MatchNeighborSet.NeighborSet != "" { - cs.NeighborSet = &api.MatchSet{ - Type: api.MatchType(s.Conditions.MatchNeighborSet.MatchSetOptions.ToInt()), - Name: s.Conditions.MatchNeighborSet.NeighborSet, - } - } - if s.Conditions.BgpConditions.AsPathLength.Operator != "" { - cs.AsPathLength = &api.AsPathLength{ - Length: s.Conditions.BgpConditions.AsPathLength.Value, - Type: api.AsPathLengthType(s.Conditions.BgpConditions.AsPathLength.Operator.ToInt()), - } - } - if s.Conditions.BgpConditions.MatchAsPathSet.AsPathSet != "" { - cs.AsPathSet = &api.MatchSet{ - Type: api.MatchType(s.Conditions.BgpConditions.MatchAsPathSet.MatchSetOptions.ToInt()), - Name: s.Conditions.BgpConditions.MatchAsPathSet.AsPathSet, - } - } - if s.Conditions.BgpConditions.MatchCommunitySet.CommunitySet != "" { - cs.CommunitySet = &api.MatchSet{ - Type: api.MatchType(s.Conditions.BgpConditions.MatchCommunitySet.MatchSetOptions.ToInt()), - Name: s.Conditions.BgpConditions.MatchCommunitySet.CommunitySet, - } - } - if s.Conditions.BgpConditions.MatchExtCommunitySet.ExtCommunitySet != "" { - cs.CommunitySet = &api.MatchSet{ - Type: api.MatchType(s.Conditions.BgpConditions.MatchExtCommunitySet.MatchSetOptions.ToInt()), - Name: s.Conditions.BgpConditions.MatchExtCommunitySet.ExtCommunitySet, - } - } - cs.RpkiResult = int32(s.Conditions.BgpConditions.RpkiValidationResult.ToInt()) - as := &api.Actions{ - RouteAction: func() api.RouteAction { - if s.Actions.RouteDisposition.AcceptRoute { - return api.RouteAction_ACCEPT - } - return api.RouteAction_REJECT - }(), - Community: func() *api.CommunityAction { - if len(s.Actions.BgpActions.SetCommunity.SetCommunityMethod.CommunitiesList) == 0 { - return nil - } - return &api.CommunityAction{ - Type: api.CommunityActionType(config.BgpSetCommunityOptionTypeToIntMap[config.BgpSetCommunityOptionType(s.Actions.BgpActions.SetCommunity.Options)]), - Communities: s.Actions.BgpActions.SetCommunity.SetCommunityMethod.CommunitiesList} - }(), - Med: func() *api.MedAction { - if len(string(s.Actions.BgpActions.SetMed)) == 0 { - return nil - } - exp := regexp.MustCompile("^(\\+|\\-)?(\\d+)$") - elems := exp.FindStringSubmatch(string(s.Actions.BgpActions.SetMed)) - action := api.MedActionType_MED_REPLACE - switch elems[1] { - case "+", "-": - action = api.MedActionType_MED_MOD - } - value, _ := strconv.Atoi(string(s.Actions.BgpActions.SetMed)) - return &api.MedAction{ - Value: int64(value), - Type: action, - } - }(), - AsPrepend: func() *api.AsPrependAction { - if len(s.Actions.BgpActions.SetAsPathPrepend.As) == 0 { - return nil - } - asn := 0 - useleft := false - if s.Actions.BgpActions.SetAsPathPrepend.As != "last-as" { - asn, _ = strconv.Atoi(s.Actions.BgpActions.SetAsPathPrepend.As) - } else { - useleft = true - } - return &api.AsPrependAction{ - Asn: uint32(asn), - Repeat: uint32(s.Actions.BgpActions.SetAsPathPrepend.RepeatN), - UseLeftMost: useleft, - } - }(), - ExtCommunity: func() *api.CommunityAction { - if len(s.Actions.BgpActions.SetExtCommunity.SetExtCommunityMethod.CommunitiesList) == 0 { - return nil - } - return &api.CommunityAction{ - Type: api.CommunityActionType(config.BgpSetCommunityOptionTypeToIntMap[config.BgpSetCommunityOptionType(s.Actions.BgpActions.SetExtCommunity.Options)]), - Communities: s.Actions.BgpActions.SetExtCommunity.SetExtCommunityMethod.CommunitiesList, - } - }(), - Nexthop: func() *api.NexthopAction { - if len(string(s.Actions.BgpActions.SetNextHop)) == 0 { - return nil - } - - if string(s.Actions.BgpActions.SetNextHop) == "self" { - return &api.NexthopAction{ - Self: true, - } - } - return &api.NexthopAction{ - Address: string(s.Actions.BgpActions.SetNextHop), - } - }(), - LocalPref: func() *api.LocalPrefAction { - if s.Actions.BgpActions.SetLocalPref == 0 { - return nil - } - return &api.LocalPrefAction{Value: s.Actions.BgpActions.SetLocalPref} - }(), - } - return &api.Statement{ - Name: s.Name, - Conditions: cs, - Actions: as, - } -} - -func toConfigMatchSetOption(a api.MatchType) (config.MatchSetOptionsType, error) { - var typ config.MatchSetOptionsType - switch a { - case api.MatchType_ANY: - typ = config.MATCH_SET_OPTIONS_TYPE_ANY - case api.MatchType_ALL: - typ = config.MATCH_SET_OPTIONS_TYPE_ALL - case api.MatchType_INVERT: - typ = config.MATCH_SET_OPTIONS_TYPE_INVERT - default: - return typ, fmt.Errorf("invalid match type") - } - return typ, nil -} - -func toConfigMatchSetOptionRestricted(a api.MatchType) (config.MatchSetOptionsRestrictedType, error) { - var typ config.MatchSetOptionsRestrictedType - switch a { - case api.MatchType_ANY: - typ = config.MATCH_SET_OPTIONS_RESTRICTED_TYPE_ANY - case api.MatchType_INVERT: - typ = config.MATCH_SET_OPTIONS_RESTRICTED_TYPE_INVERT - default: - return typ, fmt.Errorf("invalid match type") - } - return typ, nil -} - -func NewPrefixConditionFromApiStruct(a *api.MatchSet) (*table.PrefixCondition, error) { - if a == nil { - return nil, nil - } - typ, err := toConfigMatchSetOptionRestricted(a.Type) - if err != nil { - return nil, err - } - c := config.MatchPrefixSet{ - PrefixSet: a.Name, - MatchSetOptions: typ, - } - return table.NewPrefixCondition(c) -} - -func NewNeighborConditionFromApiStruct(a *api.MatchSet) (*table.NeighborCondition, error) { - if a == nil { - return nil, nil - } - typ, err := toConfigMatchSetOptionRestricted(a.Type) - if err != nil { - return nil, err - } - c := config.MatchNeighborSet{ - NeighborSet: a.Name, - MatchSetOptions: typ, - } - return table.NewNeighborCondition(c) -} - -func NewAsPathLengthConditionFromApiStruct(a *api.AsPathLength) (*table.AsPathLengthCondition, error) { - if a == nil { - return nil, nil - } - return table.NewAsPathLengthCondition(config.AsPathLength{ - Operator: config.IntToAttributeComparisonMap[int(a.Type)], - Value: a.Length, - }) -} - -func NewAsPathConditionFromApiStruct(a *api.MatchSet) (*table.AsPathCondition, error) { - if a == nil { - return nil, nil - } - typ, err := toConfigMatchSetOption(a.Type) - if err != nil { - return nil, err - } - c := config.MatchAsPathSet{ - AsPathSet: a.Name, - MatchSetOptions: typ, - } - return table.NewAsPathCondition(c) -} - -func NewRpkiValidationConditionFromApiStruct(a int32) (*table.RpkiValidationCondition, error) { - if a < 1 { - return nil, nil - } - return table.NewRpkiValidationCondition(config.IntToRpkiValidationResultTypeMap[int(a)]) -} - -func NewCommunityConditionFromApiStruct(a *api.MatchSet) (*table.CommunityCondition, error) { - if a == nil { - return nil, nil - } - typ, err := toConfigMatchSetOption(a.Type) - if err != nil { - return nil, err - } - c := config.MatchCommunitySet{ - CommunitySet: a.Name, - MatchSetOptions: typ, - } - return table.NewCommunityCondition(c) -} - -func NewExtCommunityConditionFromApiStruct(a *api.MatchSet) (*table.ExtCommunityCondition, error) { - if a == nil { - return nil, nil - } - typ, err := toConfigMatchSetOption(a.Type) - if err != nil { - return nil, err - } - c := config.MatchExtCommunitySet{ - ExtCommunitySet: a.Name, - MatchSetOptions: typ, - } - return table.NewExtCommunityCondition(c) -} - -func NewRoutingActionFromApiStruct(a api.RouteAction) (*table.RoutingAction, error) { - if a == api.RouteAction_NONE { - return nil, nil - } - accept := false - if a == api.RouteAction_ACCEPT { - accept = true - } - return &table.RoutingAction{ - AcceptRoute: accept, - }, nil -} - -func NewCommunityActionFromApiStruct(a *api.CommunityAction) (*table.CommunityAction, error) { - if a == nil { - return nil, nil - } - return table.NewCommunityAction(config.SetCommunity{ - Options: string(config.IntToBgpSetCommunityOptionTypeMap[int(a.Type)]), - SetCommunityMethod: config.SetCommunityMethod{ - CommunitiesList: a.Communities, - }, - }) -} - -func NewExtCommunityActionFromApiStruct(a *api.CommunityAction) (*table.ExtCommunityAction, error) { - if a == nil { - return nil, nil - } - return table.NewExtCommunityAction(config.SetExtCommunity{ - Options: string(config.IntToBgpSetCommunityOptionTypeMap[int(a.Type)]), - SetExtCommunityMethod: config.SetExtCommunityMethod{ - CommunitiesList: a.Communities, - }, - }) -} - -func NewMedActionFromApiStruct(a *api.MedAction) (*table.MedAction, error) { - if a == nil { - return nil, nil - } - return table.NewMedActionFromApiStruct(table.MedActionType(a.Type), int(a.Value)), nil -} - -func NewLocalPrefActionFromApiStruct(a *api.LocalPrefAction) (*table.LocalPrefAction, error) { - if a == nil || a.Value == 0 { - return nil, nil - } - return table.NewLocalPrefAction(a.Value) -} - -func NewAsPathPrependActionFromApiStruct(a *api.AsPrependAction) (*table.AsPathPrependAction, error) { - if a == nil { - return nil, nil - } - return table.NewAsPathPrependAction(config.SetAsPathPrepend{ - RepeatN: uint8(a.Repeat), - As: func() string { - if a.UseLeftMost { - return "last-as" - } - return fmt.Sprintf("%d", a.Asn) - }(), - }) -} - -func NewNexthopActionFromApiStruct(a *api.NexthopAction) (*table.NexthopAction, error) { - if a == nil { - return nil, nil - } - return table.NewNexthopAction(config.BgpNextHopType( - func() string { - if a.Self { - return "self" - } - return a.Address - }(), - )) -} - -func NewStatementFromApiStruct(a *api.Statement) (*table.Statement, error) { - if a.Name == "" { - return nil, fmt.Errorf("empty statement name") - } - var ra table.Action - var as []table.Action - var cs []table.Condition - var err error - if a.Conditions != nil { - cfs := []func() (table.Condition, error){ - func() (table.Condition, error) { - return NewPrefixConditionFromApiStruct(a.Conditions.PrefixSet) - }, - func() (table.Condition, error) { - return NewNeighborConditionFromApiStruct(a.Conditions.NeighborSet) - }, - func() (table.Condition, error) { - return NewAsPathLengthConditionFromApiStruct(a.Conditions.AsPathLength) - }, - func() (table.Condition, error) { - return NewRpkiValidationConditionFromApiStruct(a.Conditions.RpkiResult) - }, - func() (table.Condition, error) { - return NewAsPathConditionFromApiStruct(a.Conditions.AsPathSet) - }, - func() (table.Condition, error) { - return NewCommunityConditionFromApiStruct(a.Conditions.CommunitySet) - }, - func() (table.Condition, error) { - return NewExtCommunityConditionFromApiStruct(a.Conditions.ExtCommunitySet) - }, - } - cs = make([]table.Condition, 0, len(cfs)) - for _, f := range cfs { - c, err := f() - if err != nil { - return nil, err - } - if !reflect.ValueOf(c).IsNil() { - cs = append(cs, c) - } - } - } - if a.Actions != nil { - ra, err = NewRoutingActionFromApiStruct(a.Actions.RouteAction) - if err != nil { - return nil, err - } - afs := []func() (table.Action, error){ - func() (table.Action, error) { - return NewCommunityActionFromApiStruct(a.Actions.Community) - }, - func() (table.Action, error) { - return NewExtCommunityActionFromApiStruct(a.Actions.ExtCommunity) - }, - func() (table.Action, error) { - return NewMedActionFromApiStruct(a.Actions.Med) - }, - func() (table.Action, error) { - return NewLocalPrefActionFromApiStruct(a.Actions.LocalPref) - }, - func() (table.Action, error) { - return NewAsPathPrependActionFromApiStruct(a.Actions.AsPrepend) - }, - func() (table.Action, error) { - return NewNexthopActionFromApiStruct(a.Actions.Nexthop) - }, - } - as = make([]table.Action, 0, len(afs)) - for _, f := range afs { - a, err := f() - if err != nil { - return nil, err - } - if !reflect.ValueOf(a).IsNil() { - as = append(as, a) - } - } - } - return &table.Statement{ - Name: a.Name, - Conditions: cs, - RouteAction: ra, - ModActions: as, - }, nil -} - -func (s *Server) GetStatement(ctx context.Context, arg *api.GetStatementRequest) (*api.GetStatementResponse, error) { - l := make([]*api.Statement, 0) - for _, s := range s.bgpServer.GetStatement() { - l = append(l, toStatementApi(s)) - } - return &api.GetStatementResponse{Statements: l}, nil -} - -func (s *Server) AddStatement(ctx context.Context, arg *api.AddStatementRequest) (*api.AddStatementResponse, error) { - st, err := NewStatementFromApiStruct(arg.Statement) - if err == nil { - err = s.bgpServer.AddStatement(st) - } - return &api.AddStatementResponse{}, err -} - -func (s *Server) DeleteStatement(ctx context.Context, arg *api.DeleteStatementRequest) (*api.DeleteStatementResponse, error) { - st, err := NewStatementFromApiStruct(arg.Statement) - if err == nil { - err = s.bgpServer.DeleteStatement(st, arg.All) - } - return &api.DeleteStatementResponse{}, err -} - -func (s *Server) ReplaceStatement(ctx context.Context, arg *api.ReplaceStatementRequest) (*api.ReplaceStatementResponse, error) { - st, err := NewStatementFromApiStruct(arg.Statement) - if err == nil { - err = s.bgpServer.ReplaceStatement(st) - } - return &api.ReplaceStatementResponse{}, err -} - -func toPolicyApi(p *config.PolicyDefinition) *api.Policy { - return &api.Policy{ - Name: p.Name, - Statements: func() []*api.Statement { - l := make([]*api.Statement, 0) - for _, s := range p.Statements { - l = append(l, toStatementApi(&s)) - } - return l - }(), - } -} - -func NewPolicyFromApiStruct(a *api.Policy) (*table.Policy, error) { - if a.Name == "" { - return nil, fmt.Errorf("empty policy name") - } - stmts := make([]*table.Statement, 0, len(a.Statements)) - for idx, x := range a.Statements { - if x.Name == "" { - x.Name = fmt.Sprintf("%s_stmt%d", a.Name, idx) - } - y, err := NewStatementFromApiStruct(x) - if err != nil { - return nil, err - } - stmts = append(stmts, y) - } - return &table.Policy{ - Name: a.Name, - Statements: stmts, - }, nil -} - -func (s *Server) GetPolicy(ctx context.Context, arg *api.GetPolicyRequest) (*api.GetPolicyResponse, error) { - l := make([]*api.Policy, 0) - for _, p := range s.bgpServer.GetPolicy() { - l = append(l, toPolicyApi(p)) - } - return &api.GetPolicyResponse{Policies: l}, nil -} - -func (s *Server) AddPolicy(ctx context.Context, arg *api.AddPolicyRequest) (*api.AddPolicyResponse, error) { - x, err := NewPolicyFromApiStruct(arg.Policy) - if err != nil { - return nil, err - } - return &api.AddPolicyResponse{}, s.bgpServer.AddPolicy(x, arg.ReferExistingStatements) -} - -func (s *Server) DeletePolicy(ctx context.Context, arg *api.DeletePolicyRequest) (*api.DeletePolicyResponse, error) { - x, err := NewPolicyFromApiStruct(arg.Policy) - if err != nil { - return nil, err - } - return &api.DeletePolicyResponse{}, s.bgpServer.DeletePolicy(x, arg.All, arg.PreserveStatements) -} - -func (s *Server) ReplacePolicy(ctx context.Context, arg *api.ReplacePolicyRequest) (*api.ReplacePolicyResponse, error) { - x, err := NewPolicyFromApiStruct(arg.Policy) - if err != nil { - return nil, err - } - return &api.ReplacePolicyResponse{}, s.bgpServer.ReplacePolicy(x, arg.ReferExistingStatements, arg.PreserveStatements) -} - -func toPolicyAssignmentName(a *api.PolicyAssignment) (string, table.PolicyDirection, error) { - switch a.Resource { - case api.Resource_GLOBAL: - switch a.Type { - case api.PolicyType_IMPORT: - return "", table.POLICY_DIRECTION_IMPORT, nil - case api.PolicyType_EXPORT: - return "", table.POLICY_DIRECTION_EXPORT, nil - default: - return "", table.POLICY_DIRECTION_NONE, fmt.Errorf("invalid policy type") - } - case api.Resource_LOCAL: - switch a.Type { - case api.PolicyType_IN: - return a.Name, table.POLICY_DIRECTION_IN, nil - case api.PolicyType_IMPORT: - return a.Name, table.POLICY_DIRECTION_IMPORT, nil - case api.PolicyType_EXPORT: - return a.Name, table.POLICY_DIRECTION_EXPORT, nil - default: - return "", table.POLICY_DIRECTION_NONE, fmt.Errorf("invalid policy type") - } - default: - return "", table.POLICY_DIRECTION_NONE, fmt.Errorf("invalid resource type") - } - -} - -func (s *Server) GetPolicyAssignment(ctx context.Context, arg *api.GetPolicyAssignmentRequest) (*api.GetPolicyAssignmentResponse, error) { - name, dir, err := toPolicyAssignmentName(arg.Assignment) - if err != nil { - return nil, err - } - d, a, err := s.bgpServer.GetPolicyAssignment(name, dir) - if err != nil { - return nil, err - } - return &api.GetPolicyAssignmentResponse{ - Assignment: &api.PolicyAssignment{ - Default: func() api.RouteAction { - switch d { - case table.ROUTE_TYPE_ACCEPT: - return api.RouteAction_ACCEPT - case table.ROUTE_TYPE_REJECT: - return api.RouteAction_REJECT - } - return api.RouteAction_NONE - - }(), - Policies: func() []*api.Policy { - l := make([]*api.Policy, 0) - for _, p := range a { - l = append(l, toPolicyApi(p)) - } - return l - }(), - }, - }, err -} - -func defaultRouteType(d api.RouteAction) table.RouteType { - switch d { - case api.RouteAction_ACCEPT: - return table.ROUTE_TYPE_ACCEPT - case api.RouteAction_REJECT: - return table.ROUTE_TYPE_REJECT - default: - return table.ROUTE_TYPE_NONE - } -} - -func toPolicyDefinition(policies []*api.Policy) []*config.PolicyDefinition { - l := make([]*config.PolicyDefinition, 0, len(policies)) - for _, p := range policies { - l = append(l, &config.PolicyDefinition{Name: p.Name}) - } - return l -} - -func (s *Server) AddPolicyAssignment(ctx context.Context, arg *api.AddPolicyAssignmentRequest) (*api.AddPolicyAssignmentResponse, error) { - name, dir, err := toPolicyAssignmentName(arg.Assignment) - if err != nil { - return nil, err - } - return &api.AddPolicyAssignmentResponse{}, s.bgpServer.AddPolicyAssignment(name, dir, toPolicyDefinition(arg.Assignment.Policies), defaultRouteType(arg.Assignment.Default)) -} - -func (s *Server) DeletePolicyAssignment(ctx context.Context, arg *api.DeletePolicyAssignmentRequest) (*api.DeletePolicyAssignmentResponse, error) { - name, dir, err := toPolicyAssignmentName(arg.Assignment) - if err != nil { - return nil, err - } - return &api.DeletePolicyAssignmentResponse{}, s.bgpServer.DeletePolicyAssignment(name, dir, toPolicyDefinition(arg.Assignment.Policies), arg.All) -} - -func (s *Server) ReplacePolicyAssignment(ctx context.Context, arg *api.ReplacePolicyAssignmentRequest) (*api.ReplacePolicyAssignmentResponse, error) { - name, dir, err := toPolicyAssignmentName(arg.Assignment) - if err != nil { - return nil, err - } - return &api.ReplacePolicyAssignmentResponse{}, s.bgpServer.ReplacePolicyAssignment(name, dir, toPolicyDefinition(arg.Assignment.Policies), defaultRouteType(arg.Assignment.Default)) -} - -func (s *Server) GetServer(ctx context.Context, arg *api.GetServerRequest) (*api.GetServerResponse, error) { - g := s.bgpServer.GetServer() - return &api.GetServerResponse{ - Global: &api.Global{ - As: g.Config.As, - RouterId: g.Config.RouterId, - ListenPort: g.Config.Port, - ListenAddresses: g.Config.LocalAddressList, - MplsLabelMin: g.MplsLabelRange.MinLabel, - MplsLabelMax: g.MplsLabelRange.MaxLabel, - }, - }, nil -} - -func (s *Server) StartServer(ctx context.Context, arg *api.StartServerRequest) (*api.StartServerResponse, error) { - g := arg.Global - if net.ParseIP(g.RouterId) == nil { - return nil, fmt.Errorf("invalid router-id format: %s", g.RouterId) - } - families := make([]config.AfiSafi, 0, len(g.Families)) - for _, f := range g.Families { - name := config.AfiSafiType(bgp.RouteFamily(f).String()) - families = append(families, config.AfiSafi{ - Config: config.AfiSafiConfig{ - AfiSafiName: name, - Enabled: true, - }, - State: config.AfiSafiState{ - AfiSafiName: name, - }, - }) - } - b := &config.BgpConfigSet{ - Global: config.Global{ - Config: config.GlobalConfig{ - As: g.As, - RouterId: g.RouterId, - Port: g.ListenPort, - LocalAddressList: g.ListenAddresses, - }, - MplsLabelRange: config.MplsLabelRange{ - MinLabel: g.MplsLabelMin, - MaxLabel: g.MplsLabelMax, - }, - AfiSafis: families, - }, - } - if err := config.SetDefaultConfigValues(nil, b); err != nil { - return nil, err - } - return &api.StartServerResponse{}, s.bgpServer.Start(&b.Global) -} - -func (s *Server) StopServer(ctx context.Context, arg *api.StopServerRequest) (*api.StopServerResponse, error) { - return &api.StopServerResponse{}, s.bgpServer.Stop() -} -- cgit v1.2.3