summaryrefslogtreecommitdiffhomepage
path: root/server/server.go
diff options
context:
space:
mode:
Diffstat (limited to 'server/server.go')
-rw-r--r--server/server.go1341
1 files changed, 790 insertions, 551 deletions
diff --git a/server/server.go b/server/server.go
index 8d156ae9..5f83a258 100644
--- a/server/server.go
+++ b/server/server.go
@@ -984,7 +984,7 @@ func (server *BgpServer) handleFSMMessage(peer *Peer, e *FsmMsg) []*SenderMsg {
func (server *BgpServer) SetGlobalType(g config.Global) error {
ch := make(chan *GrpcResponse)
server.GrpcReqCh <- &GrpcRequest{
- RequestType: REQ_MOD_GLOBAL_CONFIG,
+ RequestType: REQ_START_SERVER,
Data: &g,
ResponseCh: ch,
}
@@ -1005,12 +1005,9 @@ func (server *BgpServer) SetGlobalType(g config.Global) error {
func (server *BgpServer) SetRpkiConfig(c []config.RpkiServer) error {
ch := make(chan *GrpcResponse)
server.GrpcReqCh <- &GrpcRequest{
- RequestType: REQ_MOD_RPKI,
- Data: &api.ModRpkiArguments{
- Operation: api.Operation_INITIALIZE,
- Asn: server.bgpConfig.Global.Config.As,
- },
- ResponseCh: ch,
+ RequestType: REQ_INITIALIZE_RPKI,
+ Data: &server.bgpConfig.Global,
+ ResponseCh: ch,
}
if err := (<-ch).Err(); err != nil {
return err
@@ -1019,12 +1016,11 @@ func (server *BgpServer) SetRpkiConfig(c []config.RpkiServer) error {
for _, s := range c {
ch := make(chan *GrpcResponse)
server.GrpcReqCh <- &GrpcRequest{
- RequestType: REQ_MOD_RPKI,
- Data: &api.ModRpkiArguments{
- Operation: api.Operation_ADD,
- Address: s.Config.Address,
- Port: s.Config.Port,
- Lifetime: s.Config.RecordLifetime,
+ RequestType: REQ_ADD_RPKI,
+ Data: &api.AddRpkiRequest{
+ Address: s.Config.Address,
+ Port: s.Config.Port,
+ Lifetime: s.Config.RecordLifetime,
},
ResponseCh: ch,
}
@@ -1039,7 +1035,7 @@ func (server *BgpServer) SetBmpConfig(c []config.BmpServer) error {
for _, s := range c {
ch := make(chan *GrpcResponse)
server.GrpcReqCh <- &GrpcRequest{
- RequestType: REQ_MOD_BMP,
+ RequestType: REQ_ADD_BMP,
Data: &s.Config,
ResponseCh: ch,
}
@@ -1055,12 +1051,11 @@ func (server *BgpServer) SetMrtConfig(c []config.Mrt) error {
if s.FileName != "" {
ch := make(chan *GrpcResponse)
server.GrpcReqCh <- &GrpcRequest{
- RequestType: REQ_MOD_MRT,
- Data: &api.ModMrtArguments{
- Operation: api.Operation_ADD,
- DumpType: int32(s.DumpType.ToInt()),
- Filename: s.FileName,
- Interval: s.Interval,
+ RequestType: REQ_ENABLE_MRT,
+ Data: &api.EnableMrtRequest{
+ DumpType: int32(s.DumpType.ToInt()),
+ Filename: s.FileName,
+ Interval: s.Interval,
},
ResponseCh: ch,
}
@@ -1380,44 +1375,57 @@ func (server *BgpServer) Api2PathList(resource api.Resource, name string, ApiPat
return paths, nil
}
-func (server *BgpServer) handleModPathRequest(grpcReq *GrpcRequest) []*table.Path {
+func (server *BgpServer) handleAddPathRequest(grpcReq *GrpcRequest) []*table.Path {
var err error
var uuidBytes []byte
paths := make([]*table.Path, 0, 1)
- arg, ok := grpcReq.Data.(*api.ModPathArguments)
+ arg, ok := grpcReq.Data.(*api.AddPathRequest)
if !ok {
err = fmt.Errorf("type assertion failed")
+ } else {
+ paths, err = server.Api2PathList(arg.Resource, arg.VrfId, []*api.Path{arg.Path})
+ if err == nil {
+ u := uuid.NewV4()
+ uuidBytes = u.Bytes()
+ paths[0].SetUUID(uuidBytes)
+ }
+ }
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: &api.AddPathResponse{
+ Uuid: uuidBytes,
+ },
}
+ close(grpcReq.ResponseCh)
+ return paths
+}
- if err == nil {
- switch arg.Operation {
- case api.Operation_DEL:
- if len(arg.Uuid) > 0 {
- path := func() *table.Path {
- for _, path := range server.globalRib.GetPathList(table.GLOBAL_RIB_NAME, server.globalRib.GetRFlist()) {
- if len(path.UUID()) > 0 && bytes.Equal(path.UUID(), arg.Uuid) {
- return path
- }
+func (server *BgpServer) handleDeletePathRequest(grpcReq *GrpcRequest) []*table.Path {
+ var err error
+ paths := make([]*table.Path, 0, 1)
+ arg, ok := grpcReq.Data.(*api.DeletePathRequest)
+ if !ok {
+ err = fmt.Errorf("type assertion failed")
+ } else {
+ if len(arg.Uuid) > 0 {
+ path := func() *table.Path {
+ for _, path := range server.globalRib.GetPathList(table.GLOBAL_RIB_NAME, server.globalRib.GetRFlist()) {
+ if len(path.UUID()) > 0 && bytes.Equal(path.UUID(), arg.Uuid) {
+ return path
}
- return nil
- }()
- if path != nil {
- paths = append(paths, path.Clone(true))
- } else {
- err = fmt.Errorf("Can't find a specified path")
}
- break
+ return nil
+ }()
+ if path != nil {
+ paths = append(paths, path.Clone(true))
+ } else {
+ err = fmt.Errorf("Can't find a specified path")
}
+ } else if arg.Path != nil {
arg.Path.IsWithdraw = true
- fallthrough
- case api.Operation_ADD:
- paths, err = server.Api2PathList(arg.Resource, arg.Name, []*api.Path{arg.Path})
- if err == nil {
- u := uuid.NewV4()
- uuidBytes = u.Bytes()
- paths[0].SetUUID(uuidBytes)
- }
- case api.Operation_DEL_ALL:
+ paths, err = server.Api2PathList(arg.Resource, arg.VrfId, []*api.Path{arg.Path})
+ } else {
+ // delete all paths
families := server.globalRib.GetRFlist()
if arg.Family != 0 {
families = []bgp.RouteFamily{bgp.RouteFamily(arg.Family)}
@@ -1427,26 +1435,23 @@ func (server *BgpServer) handleModPathRequest(grpcReq *GrpcRequest) []*table.Pat
}
}
}
- result := &GrpcResponse{
+ grpcReq.ResponseCh <- &GrpcResponse{
ResponseErr: err,
- Data: &api.ModPathResponse{
- Uuid: uuidBytes,
- },
+ Data: &api.DeletePathResponse{},
}
- grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
return paths
}
-func (server *BgpServer) handleModPathsRequest(grpcReq *GrpcRequest) []*table.Path {
+func (server *BgpServer) handleInjectMrtRequest(grpcReq *GrpcRequest) []*table.Path {
var err error
var paths []*table.Path
- arg, ok := grpcReq.Data.(*api.ModPathsArguments)
+ arg, ok := grpcReq.Data.(*api.InjectMrtRequest)
if !ok {
err = fmt.Errorf("type assertion failed")
}
if err == nil {
- paths, err = server.Api2PathList(arg.Resource, arg.Name, arg.Paths)
+ paths, err = server.Api2PathList(arg.Resource, arg.VrfId, arg.Paths)
if err == nil {
return paths
}
@@ -1460,49 +1465,40 @@ func (server *BgpServer) handleModPathsRequest(grpcReq *GrpcRequest) []*table.Pa
}
-func (server *BgpServer) handleVrfMod(arg *api.ModVrfArguments) ([]*table.Path, error) {
+func (server *BgpServer) handleAddVrfRequest(grpcReq *GrpcRequest) ([]*table.Path, error) {
+ arg, _ := grpcReq.Data.(*api.AddVrfRequest)
rib := server.globalRib
- var msgs []*table.Path
- switch arg.Operation {
- case api.Operation_ADD:
- 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)
+ 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
}
- return ret, nil
- }
- importRt, err := f(arg.Vrf.ImportRt)
- if err != nil {
- return nil, err
- }
- exportRt, err := f(arg.Vrf.ExportRt)
- if err != nil {
- return nil, err
- }
- pi := &table.PeerInfo{
- AS: server.bgpConfig.Global.Config.As,
- LocalID: net.ParseIP(server.bgpConfig.Global.Config.RouterId).To4(),
- }
- msgs, err = rib.AddVrf(arg.Vrf.Name, rd, importRt, exportRt, pi)
- if err != nil {
- return nil, err
- }
- case api.Operation_DEL:
- var err error
- msgs, err = rib.DeleteVrf(arg.Vrf.Name)
- if err != nil {
- return nil, err
+ ret = append(ret, r)
}
- default:
- return nil, fmt.Errorf("unknown operation: %d", arg.Operation)
+ return ret, nil
}
- return msgs, nil
+ importRt, err := f(arg.Vrf.ImportRt)
+ if err != nil {
+ return nil, err
+ }
+ exportRt, err := f(arg.Vrf.ExportRt)
+ if err != nil {
+ return nil, err
+ }
+ pi := &table.PeerInfo{
+ AS: server.bgpConfig.Global.Config.As,
+ LocalID: net.ParseIP(server.bgpConfig.Global.Config.RouterId).To4(),
+ }
+ return rib.AddVrf(arg.Vrf.Name, rd, importRt, exportRt, pi)
+}
+
+func (server *BgpServer) handleDeleteVrfRequest(grpcReq *GrpcRequest) ([]*table.Path, error) {
+ arg, _ := grpcReq.Data.(*api.DeleteVrfRequest)
+ rib := server.globalRib
+ return rib.DeleteVrf(arg.Vrf.Name)
}
func (server *BgpServer) handleVrfRequest(req *GrpcRequest) []*table.Path {
@@ -1511,8 +1507,8 @@ func (server *BgpServer) handleVrfRequest(req *GrpcRequest) []*table.Path {
switch req.RequestType {
case REQ_VRF:
- arg := req.Data.(*api.Table)
- name := arg.Name
+ arg := req.Data.(*api.GetRibRequest)
+ name := arg.Table.Name
rib := server.globalRib
vrfs := rib.Vrfs
if _, ok := vrfs[name]; !ok {
@@ -1520,7 +1516,7 @@ func (server *BgpServer) handleVrfRequest(req *GrpcRequest) []*table.Path {
break
}
var rf bgp.RouteFamily
- switch bgp.RouteFamily(arg.Family) {
+ switch bgp.RouteFamily(arg.Table.Family) {
case bgp.RF_IPv4_UC:
rf = bgp.RF_IPv4_VPN
case bgp.RF_IPv6_UC:
@@ -1528,7 +1524,7 @@ func (server *BgpServer) handleVrfRequest(req *GrpcRequest) []*table.Path {
case bgp.RF_EVPN:
rf = bgp.RF_EVPN
default:
- result.ResponseErr = fmt.Errorf("unsupported route family: %s", bgp.RouteFamily(arg.Family))
+ result.ResponseErr = fmt.Errorf("unsupported route family: %s", bgp.RouteFamily(arg.Table.Family))
break
}
paths := rib.GetPathList(table.GLOBAL_RIB_NAME, []bgp.RouteFamily{rf})
@@ -1544,24 +1540,27 @@ func (server *BgpServer) handleVrfRequest(req *GrpcRequest) []*table.Path {
})
}
req.ResponseCh <- &GrpcResponse{
- Data: &api.Table{
- Type: arg.Type,
- Family: arg.Family,
- Destinations: dsts,
+ Data: &api.GetRibResponse{
+ Table: &api.Table{
+ Type: arg.Table.Type,
+ Family: arg.Table.Family,
+ Destinations: dsts,
+ },
},
}
goto END
- case REQ_VRFS:
- vrfs := server.globalRib.Vrfs
- for _, vrf := range vrfs {
- req.ResponseCh <- &GrpcResponse{
- Data: vrf.ToApiStruct(),
- }
- }
- goto END
- case REQ_VRF_MOD:
- arg := req.Data.(*api.ModVrfArguments)
- msgs, result.ResponseErr = server.handleVrfMod(arg)
+ case REQ_GET_VRF:
+ l := make([]*api.Vrf, 0, len(server.globalRib.Vrfs))
+ for _, vrf := range server.globalRib.Vrfs {
+ l = append(l, vrf.ToApiStruct())
+ }
+ result.Data = &api.GetVrfResponse{Vrfs: l}
+ case REQ_ADD_VRF:
+ msgs, result.ResponseErr = server.handleAddVrfRequest(req)
+ result.Data = &api.AddVrfResponse{}
+ case REQ_DELETE_VRF:
+ msgs, result.ResponseErr = server.handleDeleteVrfRequest(req)
+ result.Data = &api.DeleteVrfResponse{}
default:
result.ResponseErr = fmt.Errorf("unknown request type: %d", req.RequestType)
}
@@ -1573,87 +1572,51 @@ END:
}
func (server *BgpServer) handleModConfig(grpcReq *GrpcRequest) error {
- var op api.Operation
var c *config.Global
switch arg := grpcReq.Data.(type) {
- case *api.ModGlobalConfigArguments:
- op = arg.Operation
- if op == api.Operation_ADD {
- g := arg.Global
- if net.ParseIP(g.RouterId) == nil {
- return 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,
+ case *api.StartServerRequest:
+ g := arg.Global
+ if net.ParseIP(g.RouterId) == nil {
+ return 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,
},
- }
- if err := config.SetDefaultConfigValues(nil, b); err != nil {
- return err
- }
- c = &b.Global
- }
- case *config.Global:
- op = api.Operation_ADD
- c = arg
- }
-
- switch op {
- case api.Operation_ADD:
- if server.bgpConfig.Global.Config.As != 0 {
- return fmt.Errorf("gobgp is already started")
+ State: config.AfiSafiState{
+ AfiSafiName: name,
+ },
+ })
}
-
- if c.Config.Port > 0 {
- acceptCh := make(chan *net.TCPConn, 4096)
- for _, addr := range c.Config.LocalAddressList {
- l, err := NewTCPListener(addr, uint32(c.Config.Port), acceptCh)
- if err != nil {
- return err
- }
- server.listeners = append(server.listeners, l)
- }
- server.acceptCh = acceptCh
+ 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,
+ },
}
-
- rfs, _ := config.AfiSafis(c.AfiSafis).ToRfList()
- server.globalRib = table.NewTableManager(rfs, c.MplsLabelRange.MinLabel, c.MplsLabelRange.MaxLabel)
-
- p := config.RoutingPolicy{}
- if err := server.SetRoutingPolicy(p); err != nil {
+ if err := config.SetDefaultConfigValues(nil, b); err != nil {
return err
}
- server.bgpConfig.Global = *c
- // update route selection options
- table.SelectionOptions = c.RouteSelectionOptions.Config
- case api.Operation_DEL_ALL:
+ c = &b.Global
+ case *config.Global:
+ c = arg
+ case *api.StopServerRequest:
for k, _ := range server.neighborMap {
- _, err := server.handleGrpcModNeighbor(&GrpcRequest{
- Data: &api.ModNeighborArguments{
- Operation: api.Operation_DEL,
+ _, err := server.handleDeleteNeighborRequest(&GrpcRequest{
+ Data: &api.DeleteNeighborRequest{
Peer: &api.Peer{
Conf: &api.PeerConf{
NeighborAddress: k,
@@ -1669,7 +1632,35 @@ func (server *BgpServer) handleModConfig(grpcReq *GrpcRequest) error {
l.Close()
}
server.bgpConfig.Global = config.Global{}
+ return nil
}
+
+ if server.bgpConfig.Global.Config.As != 0 {
+ return fmt.Errorf("gobgp is already started")
+ }
+
+ if c.Config.Port > 0 {
+ acceptCh := make(chan *net.TCPConn, 4096)
+ for _, addr := range c.Config.LocalAddressList {
+ l, err := NewTCPListener(addr, uint32(c.Config.Port), acceptCh)
+ if err != nil {
+ return err
+ }
+ server.listeners = append(server.listeners, l)
+ }
+ server.acceptCh = acceptCh
+ }
+
+ rfs, _ := config.AfiSafis(c.AfiSafis).ToRfList()
+ server.globalRib = table.NewTableManager(rfs, c.MplsLabelRange.MinLabel, c.MplsLabelRange.MaxLabel)
+
+ p := config.RoutingPolicy{}
+ if err := server.SetRoutingPolicy(p); err != nil {
+ return err
+ }
+ server.bgpConfig.Global = *c
+ // update route selection options
+ table.SelectionOptions = c.RouteSelectionOptions.Config
return nil
}
@@ -1723,7 +1714,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
return results
}
- if server.bgpConfig.Global.Config.As == 0 && grpcReq.RequestType != REQ_MOD_GLOBAL_CONFIG {
+ if server.bgpConfig.Global.Config.As == 0 && grpcReq.RequestType != REQ_START_SERVER {
grpcReq.ResponseCh <- &GrpcResponse{
ResponseErr: fmt.Errorf("bgpd main loop is not started yet"),
}
@@ -1734,47 +1725,57 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
var err error
switch grpcReq.RequestType {
- case REQ_GLOBAL_CONFIG:
+ case REQ_GET_SERVER:
g := server.bgpConfig.Global
result := &GrpcResponse{
- Data: &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,
+ Data: &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,
+ },
},
}
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
- case REQ_MOD_GLOBAL_CONFIG:
+ case REQ_START_SERVER:
+ err := server.handleModConfig(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: &api.StartServerResponse{},
+ }
+ close(grpcReq.ResponseCh)
+ case REQ_STOP_SERVER:
err := server.handleModConfig(grpcReq)
grpcReq.ResponseCh <- &GrpcResponse{
ResponseErr: err,
+ Data: &api.StopServerResponse{},
}
close(grpcReq.ResponseCh)
case REQ_GLOBAL_RIB, REQ_LOCAL_RIB:
- arg := grpcReq.Data.(*api.Table)
+ arg := grpcReq.Data.(*api.GetRibRequest)
d := &api.Table{
- Type: arg.Type,
- Family: arg.Family,
+ Type: arg.Table.Type,
+ Family: arg.Table.Family,
}
rib := server.globalRib
id := table.GLOBAL_RIB_NAME
if grpcReq.RequestType == REQ_LOCAL_RIB {
- peer, ok := server.neighborMap[arg.Name]
+ peer, ok := server.neighborMap[arg.Table.Name]
if !ok {
- err = fmt.Errorf("Neighbor that has %v doesn't exist.", arg.Name)
+ err = fmt.Errorf("Neighbor that has %v doesn't exist.", arg.Table.Name)
goto ERROR
}
if !peer.isRouteServerClient() {
- err = fmt.Errorf("Neighbor %v doesn't have local rib", arg.Name)
+ err = fmt.Errorf("Neighbor %v doesn't have local rib", arg.Table.Name)
goto ERROR
}
id = peer.ID()
}
- af := bgp.RouteFamily(arg.Family)
+ af := bgp.RouteFamily(arg.Table.Family)
if _, ok := rib.Tables[af]; !ok {
err = fmt.Errorf("address family: %s not supported", af)
goto ERROR
@@ -1782,7 +1783,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
switch af {
case bgp.RF_IPv4_UC, bgp.RF_IPv6_UC:
- if len(arg.Destinations) > 0 {
+ if len(arg.Table.Destinations) > 0 {
dsts := []*api.Destination{}
f := func(id, cidr string) (bool, error) {
_, prefix, err := net.ParseCIDR(cidr)
@@ -1798,7 +1799,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
return false, nil
}
}
- for _, dst := range arg.Destinations {
+ for _, dst := range arg.Table.Destinations {
key := dst.Prefix
if _, err := f(id, key); err != nil {
if host := net.ParseIP(key); host != nil {
@@ -1834,7 +1835,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
}
}
grpcReq.ResponseCh <- &GrpcResponse{
- Data: d,
+ Data: &api.GetRibResponse{Table: d},
}
close(grpcReq.ResponseCh)
case REQ_BMP_GLOBAL:
@@ -1849,29 +1850,16 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
Data: bmpmsgs,
}
close(grpcReq.ResponseCh)
- case REQ_MOD_PATH:
- pathList := server.handleModPathRequest(grpcReq)
+ case REQ_ADD_PATH:
+ pathList := server.handleAddPathRequest(grpcReq)
if len(pathList) > 0 {
msgs, _ = server.propagateUpdate(nil, pathList)
}
- case REQ_MOD_PATHS:
- pathList := server.handleModPathsRequest(grpcReq)
+ case REQ_DELETE_PATH:
+ pathList := server.handleDeletePathRequest(grpcReq)
if len(pathList) > 0 {
msgs, _ = server.propagateUpdate(nil, pathList)
- grpcReq.ResponseCh <- &GrpcResponse{}
- close(grpcReq.ResponseCh)
}
- case REQ_NEIGHBORS:
- results := make([]*GrpcResponse, len(server.neighborMap))
- i := 0
- for _, peer := range server.neighborMap {
- result := &GrpcResponse{
- Data: peer.ToApiStruct(),
- }
- results[i] = result
- i++
- }
- go sendMultipleResponses(grpcReq, results)
case REQ_BMP_NEIGHBORS:
//TODO: merge REQ_NEIGHBORS and REQ_BMP_NEIGHBORS
msgs := make([]*bmp.BMPMessage, 0, len(server.neighborMap))
@@ -1892,30 +1880,30 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
}
close(grpcReq.ResponseCh)
case REQ_NEIGHBOR:
- peer, err := server.checkNeighborRequest(grpcReq)
- if err != nil {
- break
+ l := []*api.Peer{}
+ for _, peer := range server.neighborMap {
+ l = append(l, peer.ToApiStruct())
}
- result := &GrpcResponse{
- Data: peer.ToApiStruct(),
+ grpcReq.ResponseCh <- &GrpcResponse{
+ Data: &api.GetNeighborResponse{
+ Peers: l,
+ },
}
- grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
-
case REQ_ADJ_RIB_IN, REQ_ADJ_RIB_OUT:
- arg := grpcReq.Data.(*api.Table)
+ arg := grpcReq.Data.(*api.GetRibRequest)
d := &api.Table{
- Type: arg.Type,
- Family: arg.Family,
+ Type: arg.Table.Type,
+ Family: arg.Table.Family,
}
- peer, ok := server.neighborMap[arg.Name]
+ peer, ok := server.neighborMap[arg.Table.Name]
if !ok {
- err = fmt.Errorf("Neighbor that has %v doesn't exist.", arg.Name)
+ err = fmt.Errorf("Neighbor that has %v doesn't exist.", arg.Table.Name)
goto ERROR
}
- rf := bgp.RouteFamily(arg.Family)
+ rf := bgp.RouteFamily(arg.Table.Family)
var paths []*table.Path
if grpcReq.RequestType == REQ_ADJ_RIB_IN {
paths = peer.adjRibIn.PathList([]bgp.RouteFamily{rf}, false)
@@ -1932,7 +1920,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
for _, p := range paths {
key := p.GetNlri().String()
found := true
- for _, dst := range arg.Destinations {
+ for _, dst := range arg.Table.Destinations {
found = false
if dst.Prefix == key {
found = true
@@ -1967,7 +1955,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
}
d.Destinations = results
grpcReq.ResponseCh <- &GrpcResponse{
- Data: d,
+ Data: &api.GetRibResponse{Table: d},
}
close(grpcReq.ResponseCh)
case REQ_BMP_ADJ_IN:
@@ -1996,7 +1984,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
for _, peer := range peers {
msgs = append(msgs, newSenderMsg(peer, nil, m, false))
}
- grpcReq.ResponseCh <- &GrpcResponse{}
+ grpcReq.ResponseCh <- &GrpcResponse{Data: &api.ShutdownNeighborResponse{}}
close(grpcReq.ResponseCh)
case REQ_NEIGHBOR_RESET:
@@ -2010,7 +1998,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
peer.fsm.idleHoldTime = peer.fsm.pConf.Timers.Config.IdleHoldTimeAfterReset
msgs = append(msgs, newSenderMsg(peer, nil, m, false))
}
- grpcReq.ResponseCh <- &GrpcResponse{}
+ grpcReq.ResponseCh <- &GrpcResponse{Data: &api.ResetNeighborResponse{}}
close(grpcReq.ResponseCh)
case REQ_NEIGHBOR_SOFT_RESET, REQ_NEIGHBOR_SOFT_RESET_IN:
@@ -2048,7 +2036,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
}
if grpcReq.RequestType == REQ_NEIGHBOR_SOFT_RESET_IN {
- grpcReq.ResponseCh <- &GrpcResponse{}
+ grpcReq.ResponseCh <- &GrpcResponse{Data: &api.SoftResetNeighborResponse{}}
close(grpcReq.ResponseCh)
break
}
@@ -2114,7 +2102,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
msgs = append(msgs, newSenderMsg(peer, withdrawnList, nil, false))
}
}
- grpcReq.ResponseCh <- &GrpcResponse{}
+ grpcReq.ResponseCh <- &GrpcResponse{Data: &api.SoftResetNeighborResponse{}}
close(grpcReq.ResponseCh)
case REQ_NEIGHBOR_ENABLE, REQ_NEIGHBOR_DISABLE:
@@ -2122,7 +2110,6 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
if err1 != nil {
break
}
- var err api.Error
result := &GrpcResponse{}
if grpcReq.RequestType == REQ_NEIGHBOR_ENABLE {
select {
@@ -2131,13 +2118,11 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
"Topic": "Peer",
"Key": peer.fsm.pConf.Config.NeighborAddress,
}).Debug("ADMIN_STATE_UP requested")
- err.Code = api.Error_SUCCESS
- err.Msg = "ADMIN_STATE_UP"
default:
log.Warning("previous request is still remaining. : ", peer.fsm.pConf.Config.NeighborAddress)
- err.Code = api.Error_FAIL
- err.Msg = "previous request is still remaining"
+ result.ResponseErr = fmt.Errorf("previous request is still remaining %v", peer.fsm.pConf.Config.NeighborAddress)
}
+ result.Data = &api.EnableNeighborResponse{}
} else {
select {
case peer.fsm.adminStateCh <- ADMIN_STATE_DOWN:
@@ -2145,20 +2130,25 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
"Topic": "Peer",
"Key": peer.fsm.pConf.Config.NeighborAddress,
}).Debug("ADMIN_STATE_DOWN requested")
- err.Code = api.Error_SUCCESS
- err.Msg = "ADMIN_STATE_DOWN"
default:
log.Warning("previous request is still remaining. : ", peer.fsm.pConf.Config.NeighborAddress)
- err.Code = api.Error_FAIL
- err.Msg = "previous request is still remaining"
+ result.ResponseErr = fmt.Errorf("previous request is still remaining %v", peer.fsm.pConf.Config.NeighborAddress)
}
+ result.Data = &api.DisableNeighborResponse{}
}
- result.Data = err
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
- case REQ_MOD_NEIGHBOR:
- m, err := server.handleGrpcModNeighbor(grpcReq)
+ case REQ_GRPC_ADD_NEIGHBOR:
+ _, err := server.handleAddNeighborRequest(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ Data: &api.AddNeighborResponse{},
+ ResponseErr: err,
+ }
+ close(grpcReq.ResponseCh)
+ case REQ_GRPC_DELETE_NEIGHBOR:
+ m, err := server.handleDeleteNeighborRequest(grpcReq)
grpcReq.ResponseCh <- &GrpcResponse{
+ Data: &api.DeleteNeighborResponse{},
ResponseErr: err,
}
if len(m) > 0 {
@@ -2190,56 +2180,116 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
msgs = append(msgs, m...)
}
close(grpcReq.ResponseCh)
- case REQ_DEFINED_SET:
- if err := server.handleGrpcGetDefinedSet(grpcReq); err != nil {
- grpcReq.ResponseCh <- &GrpcResponse{
- ResponseErr: err,
- }
+ case REQ_GET_DEFINED_SET:
+ rsp, err := server.handleGrpcGetDefinedSet(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: rsp,
}
close(grpcReq.ResponseCh)
- case REQ_MOD_DEFINED_SET:
- err := server.handleGrpcModDefinedSet(grpcReq)
+ case REQ_ADD_DEFINED_SET:
+ rsp, err := server.handleGrpcAddDefinedSet(grpcReq)
grpcReq.ResponseCh <- &GrpcResponse{
ResponseErr: err,
+ Data: rsp,
}
close(grpcReq.ResponseCh)
- case REQ_STATEMENT:
- if err := server.handleGrpcGetStatement(grpcReq); err != nil {
- grpcReq.ResponseCh <- &GrpcResponse{
- ResponseErr: err,
- }
+ case REQ_DELETE_DEFINED_SET:
+ rsp, err := server.handleGrpcDeleteDefinedSet(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: rsp,
}
close(grpcReq.ResponseCh)
- case REQ_MOD_STATEMENT:
- err := server.handleGrpcModStatement(grpcReq)
+ case REQ_REPLACE_DEFINED_SET:
+ rsp, err := server.handleGrpcReplaceDefinedSet(grpcReq)
grpcReq.ResponseCh <- &GrpcResponse{
ResponseErr: err,
+ Data: rsp,
}
close(grpcReq.ResponseCh)
- case REQ_POLICY:
- if err := server.handleGrpcGetPolicy(grpcReq); err != nil {
- grpcReq.ResponseCh <- &GrpcResponse{
- ResponseErr: err,
- }
+ case REQ_GET_STATEMENT:
+ rsp, err := server.handleGrpcGetStatement(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: rsp,
}
close(grpcReq.ResponseCh)
- case REQ_MOD_POLICY:
- err := server.handleGrpcModPolicy(grpcReq)
+ case REQ_ADD_STATEMENT:
+ data, err := server.handleGrpcAddStatement(grpcReq)
grpcReq.ResponseCh <- &GrpcResponse{
ResponseErr: err,
+ Data: data,
}
close(grpcReq.ResponseCh)
- case REQ_POLICY_ASSIGNMENT:
- if err := server.handleGrpcGetPolicyAssignment(grpcReq); err != nil {
- grpcReq.ResponseCh <- &GrpcResponse{
- ResponseErr: err,
- }
+ case REQ_DELETE_STATEMENT:
+ data, err := server.handleGrpcDeleteStatement(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: data,
+ }
+ close(grpcReq.ResponseCh)
+ case REQ_REPLACE_STATEMENT:
+ data, err := server.handleGrpcReplaceStatement(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: data,
}
close(grpcReq.ResponseCh)
- case REQ_MOD_POLICY_ASSIGNMENT:
- err := server.handleGrpcModPolicyAssignment(grpcReq)
+ case REQ_GET_POLICY:
+ rsp, err := server.handleGrpcGetPolicy(grpcReq)
grpcReq.ResponseCh <- &GrpcResponse{
ResponseErr: err,
+ Data: rsp,
+ }
+ close(grpcReq.ResponseCh)
+ case REQ_ADD_POLICY:
+ data, err := server.handleGrpcAddPolicy(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: data,
+ }
+ close(grpcReq.ResponseCh)
+ case REQ_DELETE_POLICY:
+ data, err := server.handleGrpcDeletePolicy(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: data,
+ }
+ close(grpcReq.ResponseCh)
+ case REQ_REPLACE_POLICY:
+ data, err := server.handleGrpcReplacePolicy(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: data,
+ }
+ close(grpcReq.ResponseCh)
+ case REQ_GET_POLICY_ASSIGNMENT:
+ data, err := server.handleGrpcGetPolicyAssignment(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: data,
+ }
+ close(grpcReq.ResponseCh)
+ case REQ_ADD_POLICY_ASSIGNMENT:
+ data, err := server.handleGrpcAddPolicyAssignment(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: data,
+ }
+ close(grpcReq.ResponseCh)
+ case REQ_DELETE_POLICY_ASSIGNMENT:
+ data, err := server.handleGrpcDeletePolicyAssignment(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: data,
+ }
+ close(grpcReq.ResponseCh)
+ case REQ_REPLACE_POLICY_ASSIGNMENT:
+ data, err := server.handleGrpcReplacePolicyAssignment(grpcReq)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: data,
}
close(grpcReq.ResponseCh)
case REQ_MONITOR_GLOBAL_BEST_CHANGED, REQ_MONITOR_NEIGHBOR_PEER_STATE:
@@ -2254,15 +2304,33 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) []*SenderMsg {
go w.(*grpcIncomingWatcher).addRequest(grpcReq)
case REQ_MRT_GLOBAL_RIB, REQ_MRT_LOCAL_RIB:
server.handleMrt(grpcReq)
- case REQ_MOD_MRT:
- server.handleModMrt(grpcReq)
- case REQ_MOD_BMP:
- server.handleModBmp(grpcReq)
- case REQ_MOD_RPKI:
+ case REQ_ENABLE_MRT:
+ server.handleEnableMrtRequest(grpcReq)
+ case REQ_DISABLE_MRT:
+ server.handleDisableMrtRequest(grpcReq)
+ case REQ_INJECT_MRT:
+ pathList := server.handleInjectMrtRequest(grpcReq)
+ if len(pathList) > 0 {
+ msgs, _ = server.propagateUpdate(nil, pathList)
+ grpcReq.ResponseCh <- &GrpcResponse{}
+ close(grpcReq.ResponseCh)
+ }
+ case REQ_ADD_BMP:
+ server.handleAddBmp(grpcReq)
+ case REQ_DELETE_BMP:
+ server.handleDeleteBmp(grpcReq)
+ case REQ_VALIDATE_RIB:
+ server.handleValidateRib(grpcReq)
+ case REQ_INITIALIZE_RPKI:
+ g := grpcReq.Data.(*config.Global)
+ grpcDone(grpcReq, server.roaManager.SetAS(g.Config.As))
+ case REQ_ADD_RPKI, REQ_DELETE_RPKI, REQ_ENABLE_RPKI, REQ_DISABLE_RPKI, REQ_RESET_RPKI, REQ_SOFT_RESET_RPKI:
server.handleModRpki(grpcReq)
- case REQ_ROA, REQ_RPKI:
- server.roaManager.handleGRPC(grpcReq)
- case REQ_VRF, REQ_VRFS, REQ_VRF_MOD:
+ case REQ_ROA, REQ_GET_RPKI:
+ rsp := server.roaManager.handleGRPC(grpcReq)
+ grpcReq.ResponseCh <- rsp
+ close(grpcReq.ResponseCh)
+ case REQ_VRF, REQ_GET_VRF, REQ_ADD_VRF, REQ_DELETE_VRF:
pathList := server.handleVrfRequest(grpcReq)
if len(pathList) > 0 {
msgs, _ = server.propagateUpdate(nil, pathList)
@@ -2286,31 +2354,18 @@ ERROR:
return msgs
}
-func (server *BgpServer) handleGrpcGetDefinedSet(grpcReq *GrpcRequest) error {
- arg := grpcReq.Data.(*api.DefinedSet)
+func (server *BgpServer) handleGrpcGetDefinedSet(grpcReq *GrpcRequest) (*api.GetDefinedSetResponse, error) {
+ arg := grpcReq.Data.(*api.GetDefinedSetRequest)
typ := table.DefinedType(arg.Type)
- name := arg.Name
set, ok := server.policy.DefinedSetMap[typ]
if !ok {
- return fmt.Errorf("invalid defined-set type: %d", typ)
+ return &api.GetDefinedSetResponse{}, fmt.Errorf("invalid defined-set type: %d", typ)
}
- found := false
+ sets := make([]*api.DefinedSet, 0)
for _, s := range set {
- if name != "" && name != s.Name() {
- continue
- }
- grpcReq.ResponseCh <- &GrpcResponse{
- Data: s.ToApiStruct(),
- }
- found = true
- if name != "" {
- break
- }
- }
- if !found {
- return fmt.Errorf("not found %s", name)
+ sets = append(sets, s.ToApiStruct())
}
- return nil
+ return &api.GetDefinedSetResponse{Sets: sets}, nil
}
func (server *BgpServer) handleAddNeighbor(c *config.Neighbor) ([]*SenderMsg, error) {
@@ -2439,10 +2494,11 @@ func (server *BgpServer) handleUpdateNeighbor(c *config.Neighbor) ([]*SenderMsg,
return msgs, policyUpdated, nil
}
-func (server *BgpServer) handleGrpcModNeighbor(grpcReq *GrpcRequest) ([]*SenderMsg, error) {
- arg := grpcReq.Data.(*api.ModNeighborArguments)
- switch arg.Operation {
- case api.Operation_ADD:
+func (server *BgpServer) handleAddNeighborRequest(grpcReq *GrpcRequest) ([]*SenderMsg, error) {
+ arg, ok := grpcReq.Data.(*api.AddNeighborRequest)
+ if !ok {
+ return []*SenderMsg{}, fmt.Errorf("AddNeighborRequest type assertion failed")
+ } else {
apitoConfig := func(a *api.Peer) (*config.Neighbor, error) {
pconf := &config.Neighbor{}
if a.Conf != nil {
@@ -2552,130 +2608,164 @@ func (server *BgpServer) handleGrpcModNeighbor(grpcReq *GrpcRequest) ([]*SenderM
return nil, err
}
return server.handleAddNeighbor(c)
- case api.Operation_DEL:
- return server.handleDelNeighbor(&config.Neighbor{
- Config: config.NeighborConfig{
- NeighborAddress: arg.Peer.Conf.NeighborAddress,
- },
- }, bgp.BGP_ERROR_CEASE, bgp.BGP_ERROR_SUB_PEER_DECONFIGURED)
- default:
- return nil, fmt.Errorf("unsupported operation %s", arg.Operation)
}
}
-func (server *BgpServer) handleGrpcModDefinedSet(grpcReq *GrpcRequest) error {
- arg := grpcReq.Data.(*api.ModDefinedSetArguments)
+func (server *BgpServer) handleDeleteNeighborRequest(grpcReq *GrpcRequest) ([]*SenderMsg, error) {
+ arg := grpcReq.Data.(*api.DeleteNeighborRequest)
+ return server.handleDelNeighbor(&config.Neighbor{
+ Config: config.NeighborConfig{
+ NeighborAddress: arg.Peer.Conf.NeighborAddress,
+ },
+ }, bgp.BGP_ERROR_CEASE, bgp.BGP_ERROR_SUB_PEER_DECONFIGURED)
+}
+
+func (server *BgpServer) handleGrpcAddDefinedSet(grpcReq *GrpcRequest) (*api.AddDefinedSetResponse, error) {
+ arg := grpcReq.Data.(*api.AddDefinedSetRequest)
+ set := arg.Set
+ typ := table.DefinedType(set.Type)
+ name := set.Name
+ var err error
+ m, ok := server.policy.DefinedSetMap[typ]
+ if !ok {
+ return nil, fmt.Errorf("invalid defined-set type: %d", typ)
+ }
+ d, ok := m[name]
+ s, err := table.NewDefinedSetFromApiStruct(set)
+ if err != nil {
+ return nil, err
+ }
+ if ok {
+ err = d.Append(s)
+ } else {
+ m[name] = s
+ }
+ return &api.AddDefinedSetResponse{}, err
+}
+
+func (server *BgpServer) handleGrpcDeleteDefinedSet(grpcReq *GrpcRequest) (*api.DeleteDefinedSetResponse, error) {
+ arg := grpcReq.Data.(*api.DeleteDefinedSetRequest)
set := arg.Set
typ := table.DefinedType(set.Type)
name := set.Name
var err error
m, ok := server.policy.DefinedSetMap[typ]
if !ok {
- return fmt.Errorf("invalid defined-set type: %d", typ)
+ return nil, fmt.Errorf("invalid defined-set type: %d", typ)
}
d, ok := m[name]
- if arg.Operation != api.Operation_ADD && !ok {
- return fmt.Errorf("not found defined-set: %s", name)
+ if !ok {
+ return nil, fmt.Errorf("not found defined-set: %s", name)
}
s, err := table.NewDefinedSetFromApiStruct(set)
if err != nil {
- return err
+ return nil, err
}
- switch arg.Operation {
- case api.Operation_ADD:
- if ok {
- err = d.Append(s)
- } else {
- m[name] = s
- }
- case api.Operation_DEL:
- err = d.Remove(s)
- case api.Operation_DEL_ALL:
+ if arg.All {
if server.policy.InUse(d) {
- return fmt.Errorf("can't delete. defined-set %s is in use", name)
+ return nil, fmt.Errorf("can't delete. defined-set %s is in use", name)
}
delete(m, name)
- case api.Operation_REPLACE:
- err = d.Replace(s)
+ } else {
+ err = d.Remove(s)
}
- return err
+ return &api.DeleteDefinedSetResponse{}, err
}
-func (server *BgpServer) handleGrpcGetStatement(grpcReq *GrpcRequest) error {
- arg := grpcReq.Data.(*api.Statement)
- name := arg.Name
- found := false
- for _, s := range server.policy.StatementMap {
- if name != "" && name != s.Name {
- continue
- }
- grpcReq.ResponseCh <- &GrpcResponse{
- Data: s.ToApiStruct(),
- }
- found = true
- if name != "" {
- break
- }
+func (server *BgpServer) handleGrpcReplaceDefinedSet(grpcReq *GrpcRequest) (*api.ReplaceDefinedSetResponse, error) {
+ arg := grpcReq.Data.(*api.ReplaceDefinedSetRequest)
+ set := arg.Set
+ typ := table.DefinedType(set.Type)
+ name := set.Name
+ var err error
+ m, ok := server.policy.DefinedSetMap[typ]
+ if !ok {
+ return nil, fmt.Errorf("invalid defined-set type: %d", typ)
}
- if !found {
- return fmt.Errorf("not found %s", name)
+ d, ok := m[name]
+ if !ok {
+ return nil, fmt.Errorf("not found defined-set: %s", name)
}
- return nil
+ s, err := table.NewDefinedSetFromApiStruct(set)
+ if err != nil {
+ return nil, err
+ }
+ return &api.ReplaceDefinedSetResponse{}, d.Replace(s)
+}
+
+func (server *BgpServer) handleGrpcGetStatement(grpcReq *GrpcRequest) (*api.GetStatementResponse, error) {
+ l := make([]*api.Statement, 0)
+ for _, s := range server.policy.StatementMap {
+ l = append(l, s.ToApiStruct())
+ }
+ return &api.GetStatementResponse{Statements: l}, nil
}
-func (server *BgpServer) handleGrpcModStatement(grpcReq *GrpcRequest) error {
- arg := grpcReq.Data.(*api.ModStatementArguments)
+func (server *BgpServer) handleGrpcAddStatement(grpcReq *GrpcRequest) (*api.AddStatementResponse, error) {
+ var err error
+ arg := grpcReq.Data.(*api.AddStatementRequest)
s, err := table.NewStatementFromApiStruct(arg.Statement, server.policy.DefinedSetMap)
if err != nil {
- return err
+ return nil, err
}
m := server.policy.StatementMap
name := s.Name
- d, ok := m[name]
- if arg.Operation != api.Operation_ADD && !ok {
- return fmt.Errorf("not found statement: %s", name)
+ if d, ok := m[name]; ok {
+ err = d.Add(s)
+ } else {
+ m[name] = s
+ }
+ return &api.AddStatementResponse{}, err
+}
+
+func (server *BgpServer) handleGrpcDeleteStatement(grpcReq *GrpcRequest) (*api.DeleteStatementResponse, error) {
+ var err error
+ arg := grpcReq.Data.(*api.DeleteStatementRequest)
+ s, err := table.NewStatementFromApiStruct(arg.Statement, server.policy.DefinedSetMap)
+ if err != nil {
+ return nil, err
}
- switch arg.Operation {
- case api.Operation_ADD:
- if ok {
- err = d.Add(s)
+ m := server.policy.StatementMap
+ name := s.Name
+ if d, ok := m[name]; ok {
+ if arg.All {
+ if server.policy.StatementInUse(d) {
+ err = fmt.Errorf("can't delete. statement %s is in use", name)
+ } else {
+ delete(m, name)
+ }
} else {
- m[name] = s
- }
- case api.Operation_DEL:
- err = d.Remove(s)
- case api.Operation_DEL_ALL:
- if server.policy.StatementInUse(d) {
- return fmt.Errorf("can't delete. statement %s is in use", name)
+ err = d.Remove(s)
}
- delete(m, name)
- case api.Operation_REPLACE:
- err = d.Replace(s)
+ } else {
+ err = fmt.Errorf("not found statement: %s", name)
}
- return err
+ return &api.DeleteStatementResponse{}, err
+}
+func (server *BgpServer) handleGrpcReplaceStatement(grpcReq *GrpcRequest) (*api.ReplaceStatementResponse, error) {
+ var err error
+ arg := grpcReq.Data.(*api.ReplaceStatementRequest)
+ s, err := table.NewStatementFromApiStruct(arg.Statement, server.policy.DefinedSetMap)
+ if err != nil {
+ return nil, err
+ }
+ m := server.policy.StatementMap
+ name := s.Name
+ if d, ok := m[name]; ok {
+ err = d.Replace(s)
+ } else {
+ err = fmt.Errorf("not found statement: %s", name)
+ }
+ return &api.ReplaceStatementResponse{}, err
}
-func (server *BgpServer) handleGrpcGetPolicy(grpcReq *GrpcRequest) error {
- arg := grpcReq.Data.(*api.Policy)
- name := arg.Name
- found := false
+func (server *BgpServer) handleGrpcGetPolicy(grpcReq *GrpcRequest) (*api.GetPolicyResponse, error) {
+ policies := make([]*api.Policy, 0, len(server.policy.PolicyMap))
for _, s := range server.policy.PolicyMap {
- if name != "" && name != s.Name() {
- continue
- }
- grpcReq.ResponseCh <- &GrpcResponse{
- Data: s.ToApiStruct(),
- }
- found = true
- if name != "" {
- break
- }
+ policies = append(policies, s.ToApiStruct())
}
- if !found {
- return fmt.Errorf("not found %s", name)
- }
- return nil
+ return &api.GetPolicyResponse{Policies: policies}, nil
}
func (server *BgpServer) policyInUse(x *table.Policy) bool {
@@ -2698,56 +2788,66 @@ func (server *BgpServer) policyInUse(x *table.Policy) bool {
return false
}
-func (server *BgpServer) handleGrpcModPolicy(grpcReq *GrpcRequest) error {
+func (server *BgpServer) handleGrpcAddPolicy(grpcReq *GrpcRequest) (*api.AddPolicyResponse, error) {
policyMutex.Lock()
defer policyMutex.Unlock()
- arg := grpcReq.Data.(*api.ModPolicyArguments)
+ rsp := &api.AddPolicyResponse{}
+ arg := grpcReq.Data.(*api.AddPolicyRequest)
x, err := table.NewPolicyFromApiStruct(arg.Policy, server.policy.DefinedSetMap)
if err != nil {
- return err
+ return rsp, err
}
pMap := server.policy.PolicyMap
sMap := server.policy.StatementMap
name := x.Name()
y, ok := pMap[name]
- if arg.Operation != api.Operation_ADD && !ok {
- return fmt.Errorf("not found policy: %s", name)
- }
- switch arg.Operation {
- case api.Operation_ADD, api.Operation_REPLACE:
- if arg.ReferExistingStatements {
- err = x.FillUp(sMap)
- if err != nil {
- return err
- }
- } else {
- for _, s := range x.Statements {
- if _, ok := sMap[s.Name]; ok {
- return fmt.Errorf("statement %s already defined", s.Name)
- }
- sMap[s.Name] = s
+ if arg.ReferExistingStatements {
+ err = x.FillUp(sMap)
+ } else {
+ for _, s := range x.Statements {
+ if _, ok := sMap[s.Name]; ok {
+ return rsp, fmt.Errorf("statement %s already defined", s.Name)
}
+ sMap[s.Name] = s
}
- if arg.Operation == api.Operation_REPLACE {
- err = y.Replace(x)
- } else if ok {
- err = y.Add(x)
- } else {
- pMap[name] = x
- }
- case api.Operation_DEL:
- err = y.Remove(x)
- case api.Operation_DEL_ALL:
+ }
+ if ok {
+ err = y.Add(x)
+ } else {
+ pMap[name] = x
+ }
+ return &api.AddPolicyResponse{}, err
+}
+
+func (server *BgpServer) handleGrpcDeletePolicy(grpcReq *GrpcRequest) (*api.DeletePolicyResponse, error) {
+ policyMutex.Lock()
+ defer policyMutex.Unlock()
+ rsp := &api.DeletePolicyResponse{}
+ arg := grpcReq.Data.(*api.DeletePolicyRequest)
+ x, err := table.NewPolicyFromApiStruct(arg.Policy, server.policy.DefinedSetMap)
+ if err != nil {
+ return rsp, err
+ }
+ pMap := server.policy.PolicyMap
+ sMap := server.policy.StatementMap
+ name := x.Name()
+ y, ok := pMap[name]
+ if !ok {
+ return rsp, fmt.Errorf("not found policy: %s", name)
+ }
+ if arg.All {
if server.policyInUse(y) {
- return fmt.Errorf("can't delete. policy %s is in use", name)
+ return rsp, fmt.Errorf("can't delete. policy %s is in use", name)
}
log.WithFields(log.Fields{
"Topic": "Policy",
"Key": name,
}).Debug("delete policy")
delete(pMap, name)
+ } else {
+ err = y.Remove(x)
}
- if err == nil && arg.Operation != api.Operation_ADD && !arg.PreserveStatements {
+ if err == nil && !arg.PreserveStatements {
for _, s := range y.Statements {
if !server.policy.StatementInUse(s) {
log.WithFields(log.Fields{
@@ -2758,7 +2858,51 @@ func (server *BgpServer) handleGrpcModPolicy(grpcReq *GrpcRequest) error {
}
}
}
- return err
+ return rsp, err
+}
+
+func (server *BgpServer) handleGrpcReplacePolicy(grpcReq *GrpcRequest) (*api.ReplacePolicyResponse, error) {
+ policyMutex.Lock()
+ defer policyMutex.Unlock()
+ rsp := &api.ReplacePolicyResponse{}
+ arg := grpcReq.Data.(*api.ReplacePolicyRequest)
+ x, err := table.NewPolicyFromApiStruct(arg.Policy, server.policy.DefinedSetMap)
+ if err != nil {
+ return rsp, err
+ }
+ pMap := server.policy.PolicyMap
+ sMap := server.policy.StatementMap
+ name := x.Name()
+ y, ok := pMap[name]
+ if !ok {
+ return rsp, fmt.Errorf("not found policy: %s", name)
+ }
+ if arg.ReferExistingStatements {
+ if err = x.FillUp(sMap); err != nil {
+ return rsp, err
+ }
+ } else {
+ for _, s := range x.Statements {
+ if _, ok := sMap[s.Name]; ok {
+ return rsp, fmt.Errorf("statement %s already defined", s.Name)
+ }
+ sMap[s.Name] = s
+ }
+ }
+
+ err = y.Replace(x)
+ if err == nil && !arg.PreserveStatements {
+ for _, s := range y.Statements {
+ if !server.policy.StatementInUse(s) {
+ log.WithFields(log.Fields{
+ "Topic": "Policy",
+ "Key": s.Name,
+ }).Debug("delete unused statement")
+ delete(sMap, s.Name)
+ }
+ }
+ }
+ return rsp, err
}
func (server *BgpServer) getPolicyInfo(a *api.PolicyAssignment) (string, table.PolicyDirection, error) {
@@ -2796,76 +2940,109 @@ func (server *BgpServer) getPolicyInfo(a *api.PolicyAssignment) (string, table.P
}
-func (server *BgpServer) handleGrpcGetPolicyAssignment(grpcReq *GrpcRequest) error {
- arg := grpcReq.Data.(*api.PolicyAssignment)
- id, dir, err := server.getPolicyInfo(arg)
+func (server *BgpServer) handleGrpcGetPolicyAssignment(grpcReq *GrpcRequest) (*api.GetPolicyAssignmentResponse, error) {
+ rsp := &api.GetPolicyAssignmentResponse{}
+ id, dir, err := server.getPolicyInfo(grpcReq.Data.(*api.GetPolicyAssignmentRequest).Assignment)
if err != nil {
- return err
+ return rsp, err
}
- arg.Default = server.policy.GetDefaultPolicy(id, dir).ToApiStruct()
+ rsp.Assignment.Default = server.policy.GetDefaultPolicy(id, dir).ToApiStruct()
ps := server.policy.GetPolicy(id, dir)
- arg.Policies = make([]*api.Policy, 0, len(ps))
+ rsp.Assignment.Policies = make([]*api.Policy, 0, len(ps))
for _, x := range ps {
- arg.Policies = append(arg.Policies, x.ToApiStruct())
- }
- grpcReq.ResponseCh <- &GrpcResponse{
- Data: arg,
+ rsp.Assignment.Policies = append(rsp.Assignment.Policies, x.ToApiStruct())
}
- return nil
+ return rsp, nil
}
-func (server *BgpServer) handleGrpcModPolicyAssignment(grpcReq *GrpcRequest) error {
+func (server *BgpServer) handleGrpcAddPolicyAssignment(grpcReq *GrpcRequest) (*api.AddPolicyAssignmentResponse, error) {
var err error
var dir table.PolicyDirection
var id string
+ rsp := &api.AddPolicyAssignmentResponse{}
policyMutex.Lock()
defer policyMutex.Unlock()
- arg := grpcReq.Data.(*api.ModPolicyAssignmentArguments)
+ arg := grpcReq.Data.(*api.AddPolicyAssignmentRequest)
assignment := arg.Assignment
id, dir, err = server.getPolicyInfo(assignment)
if err != nil {
- return err
+ return rsp, err
}
ps := make([]*table.Policy, 0, len(assignment.Policies))
seen := make(map[string]bool)
for _, x := range assignment.Policies {
p, ok := server.policy.PolicyMap[x.Name]
if !ok {
- return fmt.Errorf("not found policy %s", x.Name)
+ return rsp, fmt.Errorf("not found policy %s", x.Name)
}
if seen[x.Name] {
- return fmt.Errorf("duplicated policy %s", x.Name)
+ return rsp, fmt.Errorf("duplicated policy %s", x.Name)
}
seen[x.Name] = true
ps = append(ps, p)
}
cur := server.policy.GetPolicy(id, dir)
-
- switch arg.Operation {
- case api.Operation_ADD, api.Operation_REPLACE:
- if arg.Operation == api.Operation_REPLACE || cur == nil {
- err = server.policy.SetPolicy(id, dir, ps)
- } else {
- seen = make(map[string]bool)
- ps = append(cur, ps...)
- for _, x := range ps {
- if seen[x.Name()] {
- return fmt.Errorf("duplicated policy %s", x.Name())
- }
- seen[x.Name()] = true
+ if cur == nil {
+ err = server.policy.SetPolicy(id, dir, ps)
+ } else {
+ seen = make(map[string]bool)
+ ps = append(cur, ps...)
+ for _, x := range ps {
+ if seen[x.Name()] {
+ return rsp, fmt.Errorf("duplicated policy %s", x.Name())
}
- err = server.policy.SetPolicy(id, dir, ps)
+ seen[x.Name()] = true
}
- if err != nil {
- return err
+ err = server.policy.SetPolicy(id, dir, ps)
+ }
+ if err != nil {
+ return rsp, err
+ }
+
+ switch assignment.Default {
+ case api.RouteAction_ACCEPT:
+ err = server.policy.SetDefaultPolicy(id, dir, table.ROUTE_TYPE_ACCEPT)
+ case api.RouteAction_REJECT:
+ err = server.policy.SetDefaultPolicy(id, dir, table.ROUTE_TYPE_REJECT)
+ }
+ return rsp, err
+}
+
+func (server *BgpServer) handleGrpcDeletePolicyAssignment(grpcReq *GrpcRequest) (*api.DeletePolicyAssignmentResponse, error) {
+ var err error
+ var dir table.PolicyDirection
+ var id string
+ policyMutex.Lock()
+ defer policyMutex.Unlock()
+ rsp := &api.DeletePolicyAssignmentResponse{}
+ arg := grpcReq.Data.(*api.DeletePolicyAssignmentRequest)
+ assignment := arg.Assignment
+ id, dir, err = server.getPolicyInfo(assignment)
+ if err != nil {
+ return rsp, err
+ }
+ ps := make([]*table.Policy, 0, len(assignment.Policies))
+ seen := make(map[string]bool)
+ for _, x := range assignment.Policies {
+ p, ok := server.policy.PolicyMap[x.Name]
+ if !ok {
+ return rsp, fmt.Errorf("not found policy %s", x.Name)
}
- switch assignment.Default {
- case api.RouteAction_ACCEPT:
- err = server.policy.SetDefaultPolicy(id, dir, table.ROUTE_TYPE_ACCEPT)
- case api.RouteAction_REJECT:
- err = server.policy.SetDefaultPolicy(id, dir, table.ROUTE_TYPE_REJECT)
+ if seen[x.Name] {
+ return rsp, fmt.Errorf("duplicated policy %s", x.Name)
}
- case api.Operation_DEL:
+ seen[x.Name] = true
+ ps = append(ps, p)
+ }
+ cur := server.policy.GetPolicy(id, dir)
+
+ if arg.All {
+ err = server.policy.SetPolicy(id, dir, nil)
+ if err != nil {
+ return rsp, err
+ }
+ err = server.policy.SetDefaultPolicy(id, dir, table.ROUTE_TYPE_NONE)
+ } else {
n := make([]*table.Policy, 0, len(cur)-len(ps))
for _, y := range cur {
found := false
@@ -2880,14 +3057,48 @@ func (server *BgpServer) handleGrpcModPolicyAssignment(grpcReq *GrpcRequest) err
}
}
err = server.policy.SetPolicy(id, dir, n)
- case api.Operation_DEL_ALL:
- err = server.policy.SetPolicy(id, dir, nil)
- if err != nil {
- return err
+ }
+ return rsp, err
+}
+
+func (server *BgpServer) handleGrpcReplacePolicyAssignment(grpcReq *GrpcRequest) (*api.ReplacePolicyAssignmentResponse, error) {
+ var err error
+ var dir table.PolicyDirection
+ var id string
+ policyMutex.Lock()
+ defer policyMutex.Unlock()
+ rsp := &api.ReplacePolicyAssignmentResponse{}
+ arg := grpcReq.Data.(*api.ReplacePolicyAssignmentRequest)
+ assignment := arg.Assignment
+ id, dir, err = server.getPolicyInfo(assignment)
+ if err != nil {
+ return rsp, err
+ }
+ ps := make([]*table.Policy, 0, len(assignment.Policies))
+ seen := make(map[string]bool)
+ for _, x := range assignment.Policies {
+ p, ok := server.policy.PolicyMap[x.Name]
+ if !ok {
+ return rsp, fmt.Errorf("not found policy %s", x.Name)
}
- err = server.policy.SetDefaultPolicy(id, dir, table.ROUTE_TYPE_NONE)
+ if seen[x.Name] {
+ return rsp, fmt.Errorf("duplicated policy %s", x.Name)
+ }
+ seen[x.Name] = true
+ ps = append(ps, p)
+ }
+ server.policy.GetPolicy(id, dir)
+ err = server.policy.SetPolicy(id, dir, ps)
+ if err != nil {
+ return rsp, err
+ }
+ switch assignment.Default {
+ case api.RouteAction_ACCEPT:
+ err = server.policy.SetDefaultPolicy(id, dir, table.ROUTE_TYPE_ACCEPT)
+ case api.RouteAction_REJECT:
+ err = server.policy.SetDefaultPolicy(id, dir, table.ROUTE_TYPE_REJECT)
}
- return err
+ return rsp, err
}
func grpcDone(grpcReq *GrpcRequest, e error) {
@@ -2898,112 +3109,140 @@ func grpcDone(grpcReq *GrpcRequest, e error) {
close(grpcReq.ResponseCh)
}
-func (server *BgpServer) handleModMrt(grpcReq *GrpcRequest) {
- arg := grpcReq.Data.(*api.ModMrtArguments)
+func (server *BgpServer) handleEnableMrtRequest(grpcReq *GrpcRequest) {
+ arg := grpcReq.Data.(*api.EnableMrtRequest)
+ if _, y := server.watchers[WATCHER_MRT]; y {
+ grpcDone(grpcReq, fmt.Errorf("already enabled"))
+ return
+ }
+ if arg.Interval != 0 && arg.Interval < 30 {
+ log.Info("minimum mrt dump interval is 30 seconds")
+ arg.Interval = 30
+ }
+ w, err := newMrtWatcher(arg.DumpType, arg.Filename, arg.Interval)
+ if err == nil {
+ server.watchers[WATCHER_MRT] = w
+ }
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: &api.EnableMrtResponse{},
+ }
+ close(grpcReq.ResponseCh)
+}
+
+func (server *BgpServer) handleDisableMrtRequest(grpcReq *GrpcRequest) {
w, y := server.watchers[WATCHER_MRT]
- if arg.Operation == api.Operation_ADD {
- if y {
- grpcDone(grpcReq, fmt.Errorf("already enabled"))
- return
- }
- } else {
- if !y {
- grpcDone(grpcReq, fmt.Errorf("not enabled yet"))
- return
- }
+ if !y {
+ grpcDone(grpcReq, fmt.Errorf("not enabled yet"))
+ return
}
- switch arg.Operation {
- case api.Operation_ADD:
- if arg.Interval != 0 && arg.Interval < 30 {
- log.Info("minimum mrt dump interval is 30 seconds")
- arg.Interval = 30
- }
- w, err := newMrtWatcher(arg.DumpType, arg.Filename, arg.Interval)
- if err == nil {
- server.watchers[WATCHER_MRT] = w
- }
- grpcDone(grpcReq, err)
- case api.Operation_DEL:
- delete(server.watchers, WATCHER_MRT)
- w.stop()
- grpcDone(grpcReq, nil)
+
+ delete(server.watchers, WATCHER_MRT)
+ w.stop()
+ grpcReq.ResponseCh <- &GrpcResponse{
+ Data: &api.DisableMrtResponse{},
}
+ close(grpcReq.ResponseCh)
}
-func (server *BgpServer) handleModBmp(grpcReq *GrpcRequest) {
- var op api.Operation
+func (server *BgpServer) handleAddBmp(grpcReq *GrpcRequest) {
var c *config.BmpServerConfig
switch arg := grpcReq.Data.(type) {
- case *api.ModBmpArguments:
+ case *api.AddBmpRequest:
c = &config.BmpServerConfig{
Address: arg.Address,
Port: arg.Port,
RouteMonitoringPolicy: config.BmpRouteMonitoringPolicyType(arg.Type),
}
- op = arg.Operation
case *config.BmpServerConfig:
c = arg
- op = api.Operation_ADD
}
w, y := server.watchers[WATCHER_BMP]
if !y {
- if op == api.Operation_ADD {
- w, _ = newBmpWatcher(server.GrpcReqCh)
- server.watchers[WATCHER_BMP] = w
- } else if op == api.Operation_DEL {
- grpcDone(grpcReq, fmt.Errorf("not enabled yet"))
- return
+ w, _ = newBmpWatcher(server.GrpcReqCh)
+ server.watchers[WATCHER_BMP] = w
+ }
+
+ err := w.(*bmpWatcher).addServer(*c)
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: &api.AddBmpResponse{},
+ }
+ close(grpcReq.ResponseCh)
+}
+
+func (server *BgpServer) handleDeleteBmp(grpcReq *GrpcRequest) {
+ var c *config.BmpServerConfig
+ switch arg := grpcReq.Data.(type) {
+ case *api.DeleteBmpRequest:
+ c = &config.BmpServerConfig{
+ Address: arg.Address,
+ Port: arg.Port,
}
+ case *config.BmpServerConfig:
+ c = arg
}
- switch op {
- case api.Operation_ADD:
- err := w.(*bmpWatcher).addServer(*c)
- grpcDone(grpcReq, err)
- case api.Operation_DEL:
+ if w, y := server.watchers[WATCHER_BMP]; y {
err := w.(*bmpWatcher).deleteServer(*c)
- grpcDone(grpcReq, err)
- default:
- grpcDone(grpcReq, fmt.Errorf("unsupported operation: %s", op))
+ grpcReq.ResponseCh <- &GrpcResponse{
+ ResponseErr: err,
+ Data: &api.DeleteBmpResponse{},
+ }
+ close(grpcReq.ResponseCh)
+ } else {
+ grpcDone(grpcReq, fmt.Errorf("bmp not configured"))
}
}
-func (server *BgpServer) handleModRpki(grpcReq *GrpcRequest) {
- arg := grpcReq.Data.(*api.ModRpkiArguments)
-
- switch arg.Operation {
- case api.Operation_INITIALIZE:
- grpcDone(grpcReq, server.roaManager.SetAS(arg.Asn))
- return
- case api.Operation_ADD:
- grpcDone(grpcReq, server.roaManager.AddServer(net.JoinHostPort(arg.Address, strconv.Itoa(int(arg.Port))), arg.Lifetime))
- return
- case api.Operation_DEL:
- grpcDone(grpcReq, server.roaManager.DeleteServer(arg.Address))
- return
- case api.Operation_ENABLE, api.Operation_DISABLE, api.Operation_RESET, api.Operation_SOFTRESET:
- grpcDone(grpcReq, server.roaManager.operate(arg.Operation, arg.Address))
- return
- case api.Operation_REPLACE:
- for _, rf := range server.globalRib.GetRFlist() {
- if t, ok := server.globalRib.Tables[rf]; ok {
- dsts := t.GetDestinations()
- if arg.Prefix != "" {
- _, prefix, _ := net.ParseCIDR(arg.Prefix)
- if dst := t.GetDestination(prefix.String()); dst != nil {
- dsts = map[string]*table.Destination{prefix.String(): dst}
- }
- }
- for _, dst := range dsts {
- server.roaManager.validate(dst.GetAllKnownPathList())
+func (server *BgpServer) handleValidateRib(grpcReq *GrpcRequest) {
+ arg := grpcReq.Data.(*api.ValidateRibRequest)
+ for _, rf := range server.globalRib.GetRFlist() {
+ if t, ok := server.globalRib.Tables[rf]; ok {
+ dsts := t.GetDestinations()
+ if arg.Prefix != "" {
+ _, prefix, _ := net.ParseCIDR(arg.Prefix)
+ if dst := t.GetDestination(prefix.String()); dst != nil {
+ dsts = map[string]*table.Destination{prefix.String(): dst}
}
}
+ for _, dst := range dsts {
+ server.roaManager.validate(dst.GetAllKnownPathList())
+ }
}
- grpcDone(grpcReq, nil)
- return
}
- grpcDone(grpcReq, fmt.Errorf("not supported yet"))
+ result := &GrpcResponse{
+ Data: &api.ValidateRibResponse{},
+ }
+ grpcReq.ResponseCh <- result
+ close(grpcReq.ResponseCh)
+}
+
+func (server *BgpServer) handleModRpki(grpcReq *GrpcRequest) {
+ done := func(grpcReq *GrpcRequest, data interface{}, e error) {
+ result := &GrpcResponse{
+ ResponseErr: e,
+ Data: data,
+ }
+ grpcReq.ResponseCh <- result
+ close(grpcReq.ResponseCh)
+ }
+
+ switch arg := grpcReq.Data.(type) {
+ case *api.AddRpkiRequest:
+ done(grpcReq, &api.AddRpkiResponse{}, server.roaManager.AddServer(net.JoinHostPort(arg.Address, strconv.Itoa(int(arg.Port))), arg.Lifetime))
+ case *api.DeleteRpkiRequest:
+ done(grpcReq, &api.DeleteRpkiResponse{}, server.roaManager.DeleteServer(arg.Address))
+ case *api.EnableRpkiRequest:
+ done(grpcReq, &api.EnableRpkiResponse{}, server.roaManager.Enable(arg.Address))
+ case *api.DisableRpkiRequest:
+ done(grpcReq, &api.DisableRpkiResponse{}, server.roaManager.Disable(arg.Address))
+ case *api.ResetRpkiRequest:
+ done(grpcReq, &api.ResetRpkiResponse{}, server.roaManager.Reset(arg.Address))
+ case *api.SoftResetRpkiRequest:
+ done(grpcReq, &api.SoftResetRpkiResponse{}, server.roaManager.SoftReset(arg.Address))
+ }
}
func (server *BgpServer) handleMrt(grpcReq *GrpcRequest) {
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 17:46:11 +0000