summaryrefslogtreecommitdiffhomepage
path: root/server
diff options
context:
space:
mode:
Diffstat (limited to 'server')
-rw-r--r--server/grpc_server.go296
-rw-r--r--server/peer.go77
-rw-r--r--server/peer_test.go18
-rw-r--r--server/server.go39
4 files changed, 355 insertions, 75 deletions
diff --git a/server/grpc_server.go b/server/grpc_server.go
new file mode 100644
index 00000000..76e79943
--- /dev/null
+++ b/server/grpc_server.go
@@ -0,0 +1,296 @@
+// Copyright (C) 2014,2015 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"
+ "github.com/osrg/gobgp/api"
+ "github.com/osrg/gobgp/packet"
+ "golang.org/x/net/context"
+ "google.golang.org/grpc"
+ "io"
+ "net"
+)
+
+const (
+ _ = iota
+ REQ_NEIGHBOR
+ REQ_NEIGHBORS
+ REQ_ADJ_RIB_IN
+ REQ_ADJ_RIB_OUT
+ REQ_LOCAL_RIB
+ REQ_NEIGHBOR_SHUTDOWN
+ REQ_NEIGHBOR_RESET
+ REQ_NEIGHBOR_SOFT_RESET
+ REQ_NEIGHBOR_SOFT_RESET_IN
+ REQ_NEIGHBOR_SOFT_RESET_OUT
+ REQ_NEIGHBOR_ENABLE
+ REQ_NEIGHBOR_DISABLE
+ REQ_GLOBAL_RIB
+ REQ_GLOBAL_ADD
+ REQ_GLOBAL_DELETE
+)
+
+const GRPC_PORT = 8080
+
+func convertAf2Rf(af *api.AddressFamily) (bgp.RouteFamily, error) {
+ if af.Equal(api.AF_IPV4_UC) {
+ return bgp.RF_IPv4_UC, nil
+ } else if af.Equal(api.AF_IPV6_UC) {
+ return bgp.RF_IPv6_UC, nil
+ } else if af.Equal(api.AF_EVPN) {
+ return bgp.RF_EVPN, nil
+ }
+
+ return bgp.RouteFamily(0), fmt.Errorf("unsupported address family: %v", af)
+}
+
+type Server struct {
+ grpcServer *grpc.Server
+ bgpServerCh chan *GrpcRequest
+}
+
+func (s *Server) Serve() error {
+ lis, err := net.Listen("tcp", fmt.Sprintf(":%d", GRPC_PORT))
+ if err != nil {
+ return fmt.Errorf("failed to listen: %v", err)
+ }
+ s.grpcServer.Serve(lis)
+ return nil
+}
+
+func (s *Server) GetNeighbor(ctx context.Context, arg *api.Arguments) (*api.Peer, error) {
+ var rf bgp.RouteFamily
+ req := NewGrpcRequest(REQ_NEIGHBOR, arg.RouterId, rf, nil)
+ s.bgpServerCh <- req
+
+ res := <-req.ResponseCh
+ if err := res.Err(); err != nil {
+ log.Debug(err.Error())
+ return nil, err
+ }
+
+ return res.Data.(*api.Peer), nil
+}
+
+func (s *Server) GetNeighbors(_ *api.Arguments, stream api.Grpc_GetNeighborsServer) error {
+ var rf bgp.RouteFamily
+ req := NewGrpcRequest(REQ_NEIGHBORS, "", rf, nil)
+ s.bgpServerCh <- req
+
+ for res := range req.ResponseCh {
+ if err := res.Err(); err != nil {
+ log.Debug(err.Error())
+ return err
+ }
+ if err := stream.Send(res.Data.(*api.Peer)); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+func (s *Server) GetAdjRib(arg *api.Arguments, stream api.Grpc_GetAdjRibServer) error {
+ var reqType int
+ switch arg.Resource {
+ case api.Resource_ADJ_IN:
+ reqType = REQ_ADJ_RIB_IN
+ case api.Resource_ADJ_OUT:
+ reqType = REQ_ADJ_RIB_OUT
+ default:
+ return fmt.Errorf("unsupported resource type: %v", arg.Resource)
+ }
+
+ rf, err := convertAf2Rf(arg.Af)
+ if err != nil {
+ return err
+ }
+
+ req := NewGrpcRequest(reqType, arg.RouterId, rf, nil)
+ s.bgpServerCh <- req
+
+ for res := range req.ResponseCh {
+ if err := res.Err(); err != nil {
+ log.Debug(err.Error())
+ return err
+ }
+ if err := stream.Send(res.Data.(*api.Path)); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+func (s *Server) GetRib(arg *api.Arguments, stream api.Grpc_GetRibServer) error {
+ var reqType int
+ switch arg.Resource {
+ case api.Resource_LOCAL:
+ reqType = REQ_LOCAL_RIB
+ case api.Resource_GLOBAL:
+ reqType = REQ_GLOBAL_RIB
+ default:
+ return fmt.Errorf("unsupported resource type: %v", arg.Resource)
+ }
+
+ rf, err := convertAf2Rf(arg.Af)
+ if err != nil {
+ return err
+ }
+
+ req := NewGrpcRequest(reqType, arg.RouterId, rf, nil)
+ s.bgpServerCh <- req
+
+ for res := range req.ResponseCh {
+ if err := res.Err(); err != nil {
+ log.Debug(err.Error())
+ return err
+ }
+ if err := stream.Send(res.Data.(*api.Destination)); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (s *Server) neighbor(reqType int, arg *api.Arguments) (*api.Error, error) {
+ rf, err := convertAf2Rf(arg.Af)
+ if err != nil {
+ return nil, err
+ }
+
+ none := &api.Error{}
+ req := NewGrpcRequest(reqType, arg.RouterId, rf, nil)
+ s.bgpServerCh <- req
+
+ res := <-req.ResponseCh
+ if err := res.Err(); err != nil {
+ log.Debug(err.Error())
+ return nil, err
+ }
+ return none, nil
+}
+
+func (s *Server) Reset(ctx context.Context, arg *api.Arguments) (*api.Error, error) {
+ return s.neighbor(REQ_NEIGHBOR_RESET, arg)
+}
+
+func (s *Server) SoftReset(ctx context.Context, arg *api.Arguments) (*api.Error, error) {
+ return s.neighbor(REQ_NEIGHBOR_SOFT_RESET, arg)
+}
+
+func (s *Server) SoftResetIn(ctx context.Context, arg *api.Arguments) (*api.Error, error) {
+ return s.neighbor(REQ_NEIGHBOR_SOFT_RESET_IN, arg)
+}
+
+func (s *Server) SoftResetOut(ctx context.Context, arg *api.Arguments) (*api.Error, error) {
+ return s.neighbor(REQ_NEIGHBOR_SOFT_RESET_OUT, arg)
+}
+
+func (s *Server) Shutdown(ctx context.Context, arg *api.Arguments) (*api.Error, error) {
+ return s.neighbor(REQ_NEIGHBOR_SHUTDOWN, arg)
+}
+
+func (s *Server) Enable(ctx context.Context, arg *api.Arguments) (*api.Error, error) {
+ return s.neighbor(REQ_NEIGHBOR_ENABLE, arg)
+}
+
+func (s *Server) Disable(ctx context.Context, arg *api.Arguments) (*api.Error, error) {
+ return s.neighbor(REQ_NEIGHBOR_DISABLE, arg)
+}
+
+func (s *Server) ModPath(stream api.Grpc_ModPathServer) error {
+ for {
+ arg, err := stream.Recv()
+
+ if err == io.EOF {
+ return nil
+ } else if err != nil {
+ return err
+ }
+
+ if arg.Resource != api.Resource_GLOBAL {
+ return fmt.Errorf("unsupported resource: %s", arg.Resource)
+ }
+
+ reqType := REQ_GLOBAL_ADD
+ if arg.Path.IsWithdraw {
+ reqType = REQ_GLOBAL_DELETE
+ }
+
+ rf, err := convertAf2Rf(arg.Path.Nlri.Af)
+ if err != nil {
+ return nil
+ }
+ req := NewGrpcRequest(reqType, "", rf, arg.Path)
+ s.bgpServerCh <- req
+
+ res := <-req.ResponseCh
+ if err := res.Err(); err != nil {
+ log.Debug(err.Error())
+ return err
+ }
+
+ err = stream.Send(&api.Error{
+ Code: api.Error_SUCCESS,
+ })
+
+ if err != nil {
+ return err
+ }
+ }
+}
+
+type GrpcRequest struct {
+ RequestType int
+ RemoteAddr string
+ RouteFamily bgp.RouteFamily
+ ResponseCh chan *GrpcResponse
+ Err error
+ Data interface{}
+}
+
+func NewGrpcRequest(reqType int, remoteAddr string, rf bgp.RouteFamily, d interface{}) *GrpcRequest {
+ r := &GrpcRequest{
+ RequestType: reqType,
+ RouteFamily: rf,
+ RemoteAddr: remoteAddr,
+ ResponseCh: make(chan *GrpcResponse),
+ Data: d,
+ }
+ return r
+}
+
+type GrpcResponse struct {
+ ResponseErr error
+ Data interface{}
+}
+
+func (r *GrpcResponse) Err() error {
+ return r.ResponseErr
+}
+
+func NewGrpcServer(port int, bgpServerCh chan *GrpcRequest) *Server {
+ grpcServer := grpc.NewServer()
+ server := &Server{
+ grpcServer: grpcServer,
+ bgpServerCh: bgpServerCh,
+ }
+ api.RegisterGrpcServer(grpcServer, server)
+ return server
+}
diff --git a/server/peer.go b/server/peer.go
index 194998fb..2570019f 100644
--- a/server/peer.go
+++ b/server/peer.go
@@ -288,14 +288,20 @@ func (peer *Peer) sendMessages(msgs []*bgp.BGPMessage) {
}
}
-func (peer *Peer) handleGrpc(grpcReq *api.GrpcRequest) {
- result := &api.GrpcResponse{}
+func (peer *Peer) handleGrpc(grpcReq *GrpcRequest) {
+ result := &GrpcResponse{}
switch grpcReq.RequestType {
- case api.REQ_GLOBAL_ADD, api.REQ_GLOBAL_DELETE:
+ case REQ_GLOBAL_ADD, REQ_GLOBAL_DELETE:
rf := grpcReq.RouteFamily
- prefix := grpcReq.Data["prefix"].(string)
+ path, ok := grpcReq.Data.(*api.Path)
+ if !ok {
+ result.ResponseErr = fmt.Errorf("type assertion failed")
+ grpcReq.ResponseCh <- result
+ close(grpcReq.ResponseCh)
+ return
+ }
var isWithdraw bool
- if grpcReq.RequestType == api.REQ_GLOBAL_DELETE {
+ if grpcReq.RequestType == REQ_GLOBAL_DELETE {
isWithdraw = true
}
@@ -306,9 +312,9 @@ func (peer *Peer) handleGrpc(grpcReq *api.GrpcRequest) {
pattr = append(pattr, bgp.NewPathAttributeAsPath([]bgp.AsPathParamInterface{asparam}))
if rf == bgp.RF_IPv4_UC {
- ip, net, _ := net.ParseCIDR(prefix)
+ ip, net, _ := net.ParseCIDR(path.Nlri.Prefix)
if ip.To4() == nil {
- result.ResponseErr = fmt.Errorf("Invalid ipv4 prefix: %s", prefix)
+ result.ResponseErr = fmt.Errorf("Invalid ipv4 prefix: %s", path.Nlri.Prefix)
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
return
@@ -321,9 +327,9 @@ func (peer *Peer) handleGrpc(grpcReq *api.GrpcRequest) {
pattr = append(pattr, bgp.NewPathAttributeNextHop("0.0.0.0"))
} else if rf == bgp.RF_IPv6_UC {
- ip, net, _ := net.ParseCIDR(prefix)
+ ip, net, _ := net.ParseCIDR(path.Nlri.Prefix)
if ip.To16() == nil {
- result.ResponseErr = fmt.Errorf("Invalid ipv6 prefix: %s", prefix)
+ result.ResponseErr = fmt.Errorf("Invalid ipv6 prefix: %s", path.Nlri.Prefix)
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
return
@@ -348,53 +354,40 @@ func (peer *Peer) handleGrpc(grpcReq *api.GrpcRequest) {
}
peer.peerMsgCh <- pm
- case api.REQ_LOCAL_RIB, api.REQ_GLOBAL_RIB:
+ case REQ_LOCAL_RIB, REQ_GLOBAL_RIB:
if peer.fsm.adminState == ADMIN_STATE_DOWN {
close(grpcReq.ResponseCh)
return
}
if t, ok := peer.rib.Tables[grpcReq.RouteFamily]; ok {
- type table struct {
- Destinations []*api.Destination
- }
- var tt table
- j, _ := json.Marshal(t)
- err := json.Unmarshal(j, &tt)
- if err != nil {
- result := &api.GrpcResponse{}
- result.ResponseErr = err
- grpcReq.ResponseCh <- result
- close(grpcReq.ResponseCh)
- return
- }
- for _, dst := range tt.Destinations {
- result := &api.GrpcResponse{}
- result.Data = dst
+ for _, dst := range t.GetDestinations() {
+ result := &GrpcResponse{}
+ result.Data = dst.ToApiStruct()
grpcReq.ResponseCh <- result
}
close(grpcReq.ResponseCh)
return
}
- case api.REQ_NEIGHBOR_SHUTDOWN:
+ case REQ_NEIGHBOR_SHUTDOWN:
peer.outgoing <- bgp.NewBGPNotificationMessage(bgp.BGP_ERROR_CEASE, bgp.BGP_ERROR_SUB_ADMINISTRATIVE_SHUTDOWN, nil)
- case api.REQ_NEIGHBOR_RESET:
+ case REQ_NEIGHBOR_RESET:
peer.fsm.idleHoldTime = peer.peerConfig.Timers.IdleHoldTimeAfterReset
peer.outgoing <- bgp.NewBGPNotificationMessage(bgp.BGP_ERROR_CEASE, bgp.BGP_ERROR_SUB_ADMINISTRATIVE_RESET, nil)
- case api.REQ_NEIGHBOR_SOFT_RESET, api.REQ_NEIGHBOR_SOFT_RESET_IN:
+ case REQ_NEIGHBOR_SOFT_RESET, REQ_NEIGHBOR_SOFT_RESET_IN:
// soft-reconfiguration inbound
peer.sendPathsToSiblings(peer.adjRib.GetInPathList(grpcReq.RouteFamily))
- if grpcReq.RequestType == api.REQ_NEIGHBOR_SOFT_RESET_IN {
+ if grpcReq.RequestType == REQ_NEIGHBOR_SOFT_RESET_IN {
break
}
fallthrough
- case api.REQ_NEIGHBOR_SOFT_RESET_OUT:
+ case REQ_NEIGHBOR_SOFT_RESET_OUT:
pathList := peer.adjRib.GetOutPathList(grpcReq.RouteFamily)
peer.sendMessages(table.CreateUpdateMsgFromPaths(pathList))
- case api.REQ_ADJ_RIB_IN, api.REQ_ADJ_RIB_OUT:
+ case REQ_ADJ_RIB_IN, REQ_ADJ_RIB_OUT:
rf := grpcReq.RouteFamily
var paths []table.Path
- if grpcReq.RequestType == api.REQ_ADJ_RIB_IN {
+ if grpcReq.RequestType == REQ_ADJ_RIB_IN {
paths = peer.adjRib.GetInPathList(rf)
log.Debugf("RouteFamily=%v adj-rib-in found : %d", rf.String(), len(paths))
} else {
@@ -403,7 +396,7 @@ func (peer *Peer) handleGrpc(grpcReq *api.GrpcRequest) {
}
for _, p := range paths {
- result := &api.GrpcResponse{}
+ result := &GrpcResponse{}
path := &api.Path{}
j, _ := json.Marshal(p)
err := json.Unmarshal(j, path)
@@ -416,9 +409,9 @@ func (peer *Peer) handleGrpc(grpcReq *api.GrpcRequest) {
}
close(grpcReq.ResponseCh)
return
- case api.REQ_NEIGHBOR_ENABLE, api.REQ_NEIGHBOR_DISABLE:
+ case REQ_NEIGHBOR_ENABLE, REQ_NEIGHBOR_DISABLE:
var err api.Error
- if grpcReq.RequestType == api.REQ_NEIGHBOR_ENABLE {
+ if grpcReq.RequestType == REQ_NEIGHBOR_ENABLE {
select {
case peer.fsm.adminStateCh <- ADMIN_STATE_UP:
log.WithFields(log.Fields{
@@ -656,7 +649,7 @@ func (peer *Peer) handleServerMsg(m *serverMsg) {
log.Warning("can not find peer: ", d.Address.String())
}
case SRV_MSG_API:
- peer.handleGrpc(m.msgData.(*api.GrpcRequest))
+ peer.handleGrpc(m.msgData.(*GrpcRequest))
case SRV_MSG_POLICY_UPDATED:
log.Debug("policy updated")
d := m.msgData.(map[string]*policy.Policy)
@@ -827,14 +820,10 @@ func (peer *Peer) PassConn(conn *net.TCPConn) {
}
func (peer *Peer) MarshalJSON() ([]byte, error) {
- p, err := peer.ToGrpc()
- if err != nil {
- return nil, err
- }
- return json.Marshal(p)
+ return json.Marshal(peer.ToApiStruct())
}
-func (peer *Peer) ToGrpc() (*api.Peer, error) {
+func (peer *Peer) ToApiStruct() *api.Peer {
f := peer.fsm
c := f.peerConfig
@@ -904,5 +893,5 @@ func (peer *Peer) ToGrpc() (*api.Peer, error) {
return &api.Peer{
Conf: conf,
Info: info,
- }, nil
+ }
}
diff --git a/server/peer_test.go b/server/peer_test.go
index cae3b0c7..ab3bfa54 100644
--- a/server/peer_test.go
+++ b/server/peer_test.go
@@ -121,7 +121,7 @@ func TestPeerAdminShutdownWhileEstablished(t *testing.T) {
peer.connCh <- m
waitUntil(assert, bgp.BGP_FSM_ESTABLISHED, peer, 1000)
- grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := NewGrpcRequest(REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
msgData: grpcReq,
@@ -163,7 +163,7 @@ func TestPeerAdminShutdownWhileIdle(t *testing.T) {
waitUntil(assert, bgp.BGP_FSM_IDLE, peer, 1000)
- grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := NewGrpcRequest(REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
msgData: grpcReq,
@@ -197,7 +197,7 @@ func TestPeerAdminShutdownWhileActive(t *testing.T) {
waitUntil(assert, bgp.BGP_FSM_ACTIVE, peer, 1000)
- grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := NewGrpcRequest(REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
msgData: grpcReq,
@@ -233,7 +233,7 @@ func TestPeerAdminShutdownWhileOpensent(t *testing.T) {
peer.connCh <- m
waitUntil(assert, bgp.BGP_FSM_OPENSENT, peer, 1000)
- grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := NewGrpcRequest(REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
msgData: grpcReq,
@@ -277,7 +277,7 @@ func TestPeerAdminShutdownWhileOpenconfirm(t *testing.T) {
peer.connCh <- m
waitUntil(assert, bgp.BGP_FSM_OPENCONFIRM, peer, 1000)
- grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := NewGrpcRequest(REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
msgData: grpcReq,
@@ -327,7 +327,7 @@ func TestPeerAdminEnable(t *testing.T) {
waitUntil(assert, bgp.BGP_FSM_ESTABLISHED, peer, 1000)
// shutdown peer at first
- grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := NewGrpcRequest(REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
msgData: grpcReq,
@@ -342,7 +342,7 @@ func TestPeerAdminEnable(t *testing.T) {
assert.Equal(ADMIN_STATE_DOWN, peer.fsm.adminState)
// enable peer
- grpcReq = api.NewGrpcRequest(api.REQ_NEIGHBOR_ENABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq = NewGrpcRequest(REQ_NEIGHBOR_ENABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg = &serverMsg{
msgType: SRV_MSG_API,
msgData: grpcReq,
@@ -388,7 +388,7 @@ func TestPeerAdminShutdownReject(t *testing.T) {
peer.connCh <- m
waitUntil(assert, bgp.BGP_FSM_OPENSENT, peer, 1000)
- grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := NewGrpcRequest(REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
msgData: grpcReq,
@@ -401,7 +401,7 @@ func TestPeerAdminShutdownReject(t *testing.T) {
err := result.Data.(api.Error)
assert.Equal(err.Code, api.Error_FAIL)
- grpcReq = api.NewGrpcRequest(api.REQ_NEIGHBOR_ENABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq = NewGrpcRequest(REQ_NEIGHBOR_ENABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg = &serverMsg{
msgType: SRV_MSG_API,
msgData: grpcReq,
diff --git a/server/server.go b/server/server.go
index 8212a1a0..c83c48df 100644
--- a/server/server.go
+++ b/server/server.go
@@ -18,7 +18,6 @@ package server
import (
"fmt"
log "github.com/Sirupsen/logrus"
- "github.com/osrg/gobgp/api"
"github.com/osrg/gobgp/config"
"github.com/osrg/gobgp/policy"
"net"
@@ -60,7 +59,7 @@ type BgpServer struct {
globalTypeCh chan config.Global
addedPeerCh chan config.Neighbor
deletedPeerCh chan config.Neighbor
- GrpcReqCh chan *api.GrpcRequest
+ GrpcReqCh chan *GrpcRequest
listenPort int
peerMap map[string]peerMapInfo
globalRib *Peer
@@ -73,7 +72,7 @@ func NewBgpServer(port int) *BgpServer {
b.globalTypeCh = make(chan config.Global)
b.addedPeerCh = make(chan config.Neighbor)
b.deletedPeerCh = make(chan config.Neighbor)
- b.GrpcReqCh = make(chan *api.GrpcRequest, 1)
+ b.GrpcReqCh = make(chan *GrpcRequest, 1)
b.policyUpdateCh = make(chan config.RoutingPolicy)
b.listenPort = port
return &b
@@ -293,53 +292,49 @@ func (p peers) Less(i, j int) bool {
return strings.Less(0, 1)
}
-func (server *BgpServer) handleGrpc(grpcReq *api.GrpcRequest) {
+func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) {
switch grpcReq.RequestType {
- case api.REQ_NEIGHBORS:
+ case REQ_NEIGHBORS:
peerList := peers{}
for _, info := range server.peerMap {
peerList = append(peerList, info.peer)
}
sort.Sort(peerList)
for _, peer := range peerList {
- data, err := peer.ToGrpc()
- result := &api.GrpcResponse{
- ResponseErr: err,
- Data: data,
+ result := &GrpcResponse{
+ Data: peer.ToApiStruct(),
}
grpcReq.ResponseCh <- result
}
close(grpcReq.ResponseCh)
- case api.REQ_NEIGHBOR:
+ case REQ_NEIGHBOR:
remoteAddr := grpcReq.RemoteAddr
- var result *api.GrpcResponse
+ var result *GrpcResponse
info, found := server.peerMap[remoteAddr]
if found {
- data, err := info.peer.ToGrpc()
- result = &api.GrpcResponse{
- ResponseErr: err,
- Data: data,
+ result = &GrpcResponse{
+ Data: info.peer.ToApiStruct(),
}
} else {
- result = &api.GrpcResponse{
+ result = &GrpcResponse{
ResponseErr: fmt.Errorf("Neighbor that has %v does not exist.", remoteAddr),
}
}
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
- case api.REQ_GLOBAL_RIB, api.REQ_GLOBAL_ADD, api.REQ_GLOBAL_DELETE:
+ case REQ_GLOBAL_RIB, REQ_GLOBAL_ADD, REQ_GLOBAL_DELETE:
msg := &serverMsg{
msgType: SRV_MSG_API,
msgData: grpcReq,
}
server.globalRib.serverMsgCh <- msg
- case api.REQ_LOCAL_RIB, api.REQ_NEIGHBOR_SHUTDOWN, api.REQ_NEIGHBOR_RESET,
- api.REQ_NEIGHBOR_SOFT_RESET, api.REQ_NEIGHBOR_SOFT_RESET_IN, api.REQ_NEIGHBOR_SOFT_RESET_OUT,
- api.REQ_ADJ_RIB_IN, api.REQ_ADJ_RIB_OUT,
- api.REQ_NEIGHBOR_ENABLE, api.REQ_NEIGHBOR_DISABLE:
+ case REQ_LOCAL_RIB, REQ_NEIGHBOR_SHUTDOWN, REQ_NEIGHBOR_RESET,
+ REQ_NEIGHBOR_SOFT_RESET, REQ_NEIGHBOR_SOFT_RESET_IN, REQ_NEIGHBOR_SOFT_RESET_OUT,
+ REQ_ADJ_RIB_IN, REQ_ADJ_RIB_OUT,
+ REQ_NEIGHBOR_ENABLE, REQ_NEIGHBOR_DISABLE:
remoteAddr := grpcReq.RemoteAddr
- result := &api.GrpcResponse{}
+ result := &GrpcResponse{}
info, found := server.peerMap[remoteAddr]
if found {
msg := &serverMsg{
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 19:25:25 +0000