summaryrefslogtreecommitdiffhomepage
path: root/server
diff options
context:
space:
mode:
Diffstat (limited to 'server')
-rw-r--r--server/peer.go243
-rw-r--r--server/peer_test.go101
-rw-r--r--server/server.go60
3 files changed, 202 insertions, 202 deletions
diff --git a/server/peer.go b/server/peer.go
index 8c62d105..194998fb 100644
--- a/server/peer.go
+++ b/server/peer.go
@@ -288,79 +288,93 @@ func (peer *Peer) sendMessages(msgs []*bgp.BGPMessage) {
}
}
-func (peer *Peer) handleREST(restReq *api.RestRequest) {
- result := &api.RestResponse{}
- switch restReq.RequestType {
+func (peer *Peer) handleGrpc(grpcReq *api.GrpcRequest) {
+ result := &api.GrpcResponse{}
+ switch grpcReq.RequestType {
case api.REQ_GLOBAL_ADD, api.REQ_GLOBAL_DELETE:
- rf := restReq.RouteFamily
- prefixes := restReq.Data["prefix"].([]string)
+ rf := grpcReq.RouteFamily
+ prefix := grpcReq.Data["prefix"].(string)
var isWithdraw bool
- if restReq.RequestType == api.REQ_GLOBAL_DELETE {
+ if grpcReq.RequestType == api.REQ_GLOBAL_DELETE {
isWithdraw = true
}
- pList := make([]table.Path, 0, len(prefixes))
- for _, prefix := range prefixes {
- var nlri bgp.AddrPrefixInterface
- pattr := make([]bgp.PathAttributeInterface, 0)
- pattr = append(pattr, bgp.NewPathAttributeOrigin(bgp.BGP_ORIGIN_ATTR_TYPE_IGP))
- asparam := bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, []uint32{peer.peerInfo.AS})
- pattr = append(pattr, bgp.NewPathAttributeAsPath([]bgp.AsPathParamInterface{asparam}))
-
- if rf == bgp.RF_IPv4_UC {
- ip, net, _ := net.ParseCIDR(prefix)
- if ip.To4() == nil {
- result.ResponseErr = fmt.Errorf("Invalid ipv4 prefix: %s", prefix)
- restReq.ResponseCh <- result
- close(restReq.ResponseCh)
- return
- }
- ones, _ := net.Mask.Size()
- nlri = &bgp.NLRInfo{
- IPAddrPrefix: *bgp.NewIPAddrPrefix(uint8(ones), ip.String()),
- }
+ var nlri bgp.AddrPrefixInterface
+ pattr := make([]bgp.PathAttributeInterface, 0)
+ pattr = append(pattr, bgp.NewPathAttributeOrigin(bgp.BGP_ORIGIN_ATTR_TYPE_IGP))
+ asparam := bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, []uint32{peer.peerInfo.AS})
+ pattr = append(pattr, bgp.NewPathAttributeAsPath([]bgp.AsPathParamInterface{asparam}))
- pattr = append(pattr, bgp.NewPathAttributeNextHop("0.0.0.0"))
-
- } else if rf == bgp.RF_IPv6_UC {
- ip, net, _ := net.ParseCIDR(prefix)
- if ip.To16() == nil {
- result.ResponseErr = fmt.Errorf("Invalid ipv6 prefix: %s", prefix)
- restReq.ResponseCh <- result
- close(restReq.ResponseCh)
- return
- }
- ones, _ := net.Mask.Size()
- nlri = bgp.NewIPv6AddrPrefix(uint8(ones), ip.String())
+ if rf == bgp.RF_IPv4_UC {
+ ip, net, _ := net.ParseCIDR(prefix)
+ if ip.To4() == nil {
+ result.ResponseErr = fmt.Errorf("Invalid ipv4 prefix: %s", prefix)
+ grpcReq.ResponseCh <- result
+ close(grpcReq.ResponseCh)
+ return
+ }
+ ones, _ := net.Mask.Size()
+ nlri = &bgp.NLRInfo{
+ IPAddrPrefix: *bgp.NewIPAddrPrefix(uint8(ones), ip.String()),
+ }
- pattr = append(pattr, bgp.NewPathAttributeMpReachNLRI("::", []bgp.AddrPrefixInterface{nlri}))
+ pattr = append(pattr, bgp.NewPathAttributeNextHop("0.0.0.0"))
- } else {
- result.ResponseErr = fmt.Errorf("Unsupported address family: %s", rf)
- restReq.ResponseCh <- result
- close(restReq.ResponseCh)
+ } else if rf == bgp.RF_IPv6_UC {
+ ip, net, _ := net.ParseCIDR(prefix)
+ if ip.To16() == nil {
+ result.ResponseErr = fmt.Errorf("Invalid ipv6 prefix: %s", prefix)
+ grpcReq.ResponseCh <- result
+ close(grpcReq.ResponseCh)
return
}
+ ones, _ := net.Mask.Size()
+ nlri = bgp.NewIPv6AddrPrefix(uint8(ones), ip.String())
- p := table.CreatePath(peer.peerInfo, nlri, pattr, isWithdraw, time.Now())
- pList = append(pList, p)
+ pattr = append(pattr, bgp.NewPathAttributeMpReachNLRI("::", []bgp.AddrPrefixInterface{nlri}))
+
+ } else {
+ result.ResponseErr = fmt.Errorf("Unsupported address family: %s", rf)
+ grpcReq.ResponseCh <- result
+ close(grpcReq.ResponseCh)
+ return
}
+ p := table.CreatePath(peer.peerInfo, nlri, pattr, isWithdraw, time.Now())
+
pm := &peerMsg{
msgType: PEER_MSG_PATH,
- msgData: pList,
+ msgData: []table.Path{p},
}
peer.peerMsgCh <- pm
case api.REQ_LOCAL_RIB, api.REQ_GLOBAL_RIB:
- // just empty so we use ipv4 for any route family
- j, _ := json.Marshal(table.NewIPv4Table(0))
- if peer.fsm.adminState != ADMIN_STATE_DOWN {
- if t, ok := peer.rib.Tables[restReq.RouteFamily]; ok {
- j, _ = json.Marshal(t)
+ 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
+ grpcReq.ResponseCh <- result
}
+ close(grpcReq.ResponseCh)
+ return
}
- result.Data = j
case api.REQ_NEIGHBOR_SHUTDOWN:
peer.outgoing <- bgp.NewBGPNotificationMessage(bgp.BGP_ERROR_CEASE, bgp.BGP_ERROR_SUB_ADMINISTRATIVE_SHUTDOWN, nil)
case api.REQ_NEIGHBOR_RESET:
@@ -368,40 +382,55 @@ func (peer *Peer) handleREST(restReq *api.RestRequest) {
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:
// soft-reconfiguration inbound
- peer.sendPathsToSiblings(peer.adjRib.GetInPathList(restReq.RouteFamily))
- if restReq.RequestType == api.REQ_NEIGHBOR_SOFT_RESET_IN {
+ peer.sendPathsToSiblings(peer.adjRib.GetInPathList(grpcReq.RouteFamily))
+ if grpcReq.RequestType == api.REQ_NEIGHBOR_SOFT_RESET_IN {
break
}
fallthrough
case api.REQ_NEIGHBOR_SOFT_RESET_OUT:
- pathList := peer.adjRib.GetOutPathList(restReq.RouteFamily)
+ pathList := peer.adjRib.GetOutPathList(grpcReq.RouteFamily)
peer.sendMessages(table.CreateUpdateMsgFromPaths(pathList))
case api.REQ_ADJ_RIB_IN, api.REQ_ADJ_RIB_OUT:
- rf := restReq.RouteFamily
- if restReq.RequestType == api.REQ_ADJ_RIB_IN {
- paths := peer.adjRib.GetInPathList(rf)
- j, _ := json.Marshal(paths)
- result.Data = j
+ rf := grpcReq.RouteFamily
+ var paths []table.Path
+
+ if grpcReq.RequestType == api.REQ_ADJ_RIB_IN {
+ paths = peer.adjRib.GetInPathList(rf)
log.Debugf("RouteFamily=%v adj-rib-in found : %d", rf.String(), len(paths))
} else {
- paths := peer.adjRib.GetOutPathList(rf)
- j, _ := json.Marshal(paths)
- result.Data = j
+ paths = peer.adjRib.GetOutPathList(rf)
log.Debugf("RouteFamily=%v adj-rib-out found : %d", rf.String(), len(paths))
}
+
+ for _, p := range paths {
+ result := &api.GrpcResponse{}
+ path := &api.Path{}
+ j, _ := json.Marshal(p)
+ err := json.Unmarshal(j, path)
+ if err != nil {
+ result.ResponseErr = err
+ } else {
+ result.Data = path
+ }
+ grpcReq.ResponseCh <- result
+ }
+ close(grpcReq.ResponseCh)
+ return
case api.REQ_NEIGHBOR_ENABLE, api.REQ_NEIGHBOR_DISABLE:
- r := make(map[string]string)
- if restReq.RequestType == api.REQ_NEIGHBOR_ENABLE {
+ var err api.Error
+ if grpcReq.RequestType == api.REQ_NEIGHBOR_ENABLE {
select {
case peer.fsm.adminStateCh <- ADMIN_STATE_UP:
log.WithFields(log.Fields{
"Topic": "Peer",
"Key": peer.peerConfig.NeighborAddress,
}).Debug("ADMIN_STATE_UP requested")
- r["result"] = "ADMIN_STATE_UP"
+ err.Code = api.Error_SUCCESS
+ err.Msg = "ADMIN_STATE_UP"
default:
log.Warning("previous request is still remaining. : ", peer.peerConfig.NeighborAddress)
- r["result"] = "previous request is still remaining"
+ err.Code = api.Error_FAIL
+ err.Msg = "previous request is still remaining"
}
} else {
select {
@@ -410,17 +439,18 @@ func (peer *Peer) handleREST(restReq *api.RestRequest) {
"Topic": "Peer",
"Key": peer.peerConfig.NeighborAddress,
}).Debug("ADMIN_STATE_DOWN requested")
- r["result"] = "ADMIN_STATE_DOWN"
+ err.Code = api.Error_SUCCESS
+ err.Msg = "ADMIN_STATE_DOWN"
default:
log.Warning("previous request is still remaining. : ", peer.peerConfig.NeighborAddress)
- r["result"] = "previous request is still remaining"
+ err.Code = api.Error_FAIL
+ err.Msg = "previous request is still remaining"
}
}
- j, _ := json.Marshal(r)
- result.Data = j
+ result.Data = err
}
- restReq.ResponseCh <- result
- close(restReq.ResponseCh)
+ grpcReq.ResponseCh <- result
+ close(grpcReq.ResponseCh)
}
func (peer *Peer) sendUpdateMsgFromPaths(pList []table.Path) {
@@ -626,7 +656,7 @@ func (peer *Peer) handleServerMsg(m *serverMsg) {
log.Warning("can not find peer: ", d.Address.String())
}
case SRV_MSG_API:
- peer.handleREST(m.msgData.(*api.RestRequest))
+ peer.handleGrpc(m.msgData.(*api.GrpcRequest))
case SRV_MSG_POLICY_UPDATED:
log.Debug("policy updated")
d := m.msgData.(map[string]*policy.Policy)
@@ -797,30 +827,29 @@ 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)
+}
+
+func (peer *Peer) ToGrpc() (*api.Peer, error) {
f := peer.fsm
c := f.peerConfig
- p := make(map[string]interface{})
- capList := make([]int, 0)
+ capList := make([]int32, 0, len(peer.capMap))
for k, _ := range peer.capMap {
- capList = append(capList, int(k))
+ capList = append(capList, int32(k))
}
- p["conf"] = struct {
- RemoteIP string `json:"remote_ip"`
- Id string `json:"id"`
- RemoteAS uint32 `json:"remote_as"`
- CapRefresh bool `json:"cap_refresh"`
- CapEnhancedRefresh bool `json:"cap_enhanced_refresh"`
- RemoteCap []int
- LocalCap []int
- }{
- RemoteIP: c.NeighborAddress.String(),
+ conf := &api.PeerConf{
+ RemoteIp: c.NeighborAddress.String(),
Id: peer.peerInfo.ID.To4().String(),
- RemoteAS: c.PeerAs,
+ RemoteAs: c.PeerAs,
RemoteCap: capList,
- LocalCap: []int{int(bgp.BGP_CAP_MULTIPROTOCOL), int(bgp.BGP_CAP_ROUTE_REFRESH), int(bgp.BGP_CAP_FOUR_OCTET_AS_NUMBER)},
+ LocalCap: []int32{int32(bgp.BGP_CAP_MULTIPROTOCOL), int32(bgp.BGP_CAP_ROUTE_REFRESH), int32(bgp.BGP_CAP_FOUR_OCTET_AS_NUMBER)},
}
s := c.BgpNeighborCommonState
@@ -845,34 +874,7 @@ func (peer *Peer) MarshalJSON() ([]byte, error) {
}
}
- p["info"] = struct {
- BgpState string `json:"bgp_state"`
- AdminState string
- FsmEstablishedTransitions uint32 `json:"fsm_established_transitions"`
- TotalMessageOut uint32 `json:"total_message_out"`
- TotalMessageIn uint32 `json:"total_message_in"`
- UpdateMessageOut uint32 `json:"update_message_out"`
- UpdateMessageIn uint32 `json:"update_message_in"`
- KeepAliveMessageOut uint32 `json:"keepalive_message_out"`
- KeepAliveMessageIn uint32 `json:"keepalive_message_in"`
- OpenMessageOut uint32 `json:"open_message_out"`
- OpenMessageIn uint32 `json:"open_message_in"`
- NotificationOut uint32 `json:"notification_out"`
- NotificationIn uint32 `json:"notification_in"`
- RefreshMessageOut uint32 `json:"refresh_message_out"`
- RefreshMessageIn uint32 `json:"refresh_message_in"`
- DiscardedOut uint32
- DiscardedIn uint32
- Uptime int64 `json:"uptime"`
- Downtime int64 `json:"downtime"`
- LastError string `json:"last_error"`
- Received uint32
- Accepted uint32
- Advertized uint32
- OutQ int
- Flops uint32
- }{
-
+ info := &api.PeerInfo{
BgpState: f.state.String(),
AdminState: f.adminState.String(),
FsmEstablishedTransitions: s.EstablishedCount,
@@ -895,9 +897,12 @@ func (peer *Peer) MarshalJSON() ([]byte, error) {
Received: received,
Accepted: accepted,
Advertized: advertized,
- OutQ: len(peer.outgoing),
+ OutQ: uint32(len(peer.outgoing)),
Flops: s.Flops,
}
- return json.Marshal(p)
+ return &api.Peer{
+ Conf: conf,
+ Info: info,
+ }, nil
}
diff --git a/server/peer_test.go b/server/peer_test.go
index 90c64960..cae3b0c7 100644
--- a/server/peer_test.go
+++ b/server/peer_test.go
@@ -17,8 +17,6 @@ package server
import (
"fmt"
- //"encoding/json"
- "encoding/json"
log "github.com/Sirupsen/logrus"
"github.com/osrg/gobgp/api"
"github.com/osrg/gobgp/config"
@@ -123,17 +121,16 @@ func TestPeerAdminShutdownWhileEstablished(t *testing.T) {
peer.connCh <- m
waitUntil(assert, bgp.BGP_FSM_ESTABLISHED, peer, 1000)
- restReq := api.NewRestRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
- msgData: restReq,
+ msgData: grpcReq,
}
peer.serverMsgCh <- msg
- result := <-restReq.ResponseCh
- res := make(map[string]string)
- json.Unmarshal(result.Data, &res)
- assert.Equal("ADMIN_STATE_DOWN", res["result"])
+ result := <-grpcReq.ResponseCh
+ err := result.Data.(api.Error)
+ assert.Equal(err.Code, api.Error_SUCCESS)
waitUntil(assert, bgp.BGP_FSM_IDLE, peer, 1000)
@@ -166,17 +163,16 @@ func TestPeerAdminShutdownWhileIdle(t *testing.T) {
waitUntil(assert, bgp.BGP_FSM_IDLE, peer, 1000)
- restReq := api.NewRestRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
- msgData: restReq,
+ msgData: grpcReq,
}
peer.serverMsgCh <- msg
- result := <-restReq.ResponseCh
- res := make(map[string]string)
- json.Unmarshal(result.Data, &res)
- assert.Equal("ADMIN_STATE_DOWN", res["result"])
+ result := <-grpcReq.ResponseCh
+ err := result.Data.(api.Error)
+ assert.Equal(err.Code, api.Error_SUCCESS)
waitUntil(assert, bgp.BGP_FSM_IDLE, peer, 100)
assert.Equal(bgp.BGP_FSM_IDLE, peer.fsm.state)
@@ -201,17 +197,16 @@ func TestPeerAdminShutdownWhileActive(t *testing.T) {
waitUntil(assert, bgp.BGP_FSM_ACTIVE, peer, 1000)
- restReq := api.NewRestRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
- msgData: restReq,
+ msgData: grpcReq,
}
peer.serverMsgCh <- msg
- result := <-restReq.ResponseCh
- res := make(map[string]string)
- json.Unmarshal(result.Data, &res)
- assert.Equal("ADMIN_STATE_DOWN", res["result"])
+ result := <-grpcReq.ResponseCh
+ err := result.Data.(api.Error)
+ assert.Equal(err.Code, api.Error_SUCCESS)
waitUntil(assert, bgp.BGP_FSM_IDLE, peer, 100)
assert.Equal(bgp.BGP_FSM_IDLE, peer.fsm.state)
@@ -238,17 +233,16 @@ func TestPeerAdminShutdownWhileOpensent(t *testing.T) {
peer.connCh <- m
waitUntil(assert, bgp.BGP_FSM_OPENSENT, peer, 1000)
- restReq := api.NewRestRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
- msgData: restReq,
+ msgData: grpcReq,
}
peer.serverMsgCh <- msg
- result := <-restReq.ResponseCh
- res := make(map[string]string)
- json.Unmarshal(result.Data, &res)
- assert.Equal("ADMIN_STATE_DOWN", res["result"])
+ result := <-grpcReq.ResponseCh
+ err := result.Data.(api.Error)
+ assert.Equal(err.Code, api.Error_SUCCESS)
waitUntil(assert, bgp.BGP_FSM_IDLE, peer, 100)
assert.Equal(bgp.BGP_FSM_IDLE, peer.fsm.state)
@@ -283,17 +277,16 @@ func TestPeerAdminShutdownWhileOpenconfirm(t *testing.T) {
peer.connCh <- m
waitUntil(assert, bgp.BGP_FSM_OPENCONFIRM, peer, 1000)
- restReq := api.NewRestRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
- msgData: restReq,
+ msgData: grpcReq,
}
peer.serverMsgCh <- msg
- result := <-restReq.ResponseCh
- res := make(map[string]string)
- json.Unmarshal(result.Data, &res)
- assert.Equal("ADMIN_STATE_DOWN", res["result"])
+ result := <-grpcReq.ResponseCh
+ err := result.Data.(api.Error)
+ assert.Equal(err.Code, api.Error_SUCCESS)
waitUntil(assert, bgp.BGP_FSM_IDLE, peer, 1000)
assert.Equal(bgp.BGP_FSM_IDLE, peer.fsm.state)
@@ -334,32 +327,30 @@ func TestPeerAdminEnable(t *testing.T) {
waitUntil(assert, bgp.BGP_FSM_ESTABLISHED, peer, 1000)
// shutdown peer at first
- restReq := api.NewRestRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
- msgData: restReq,
+ msgData: grpcReq,
}
peer.serverMsgCh <- msg
- result := <-restReq.ResponseCh
- res := make(map[string]string)
- json.Unmarshal(result.Data, &res)
- assert.Equal("ADMIN_STATE_DOWN", res["result"])
+ result := <-grpcReq.ResponseCh
+ err := result.Data.(api.Error)
+ assert.Equal(err.Code, api.Error_SUCCESS)
waitUntil(assert, bgp.BGP_FSM_IDLE, peer, 100)
assert.Equal(bgp.BGP_FSM_IDLE, peer.fsm.state)
assert.Equal(ADMIN_STATE_DOWN, peer.fsm.adminState)
// enable peer
- restReq = api.NewRestRequest(api.REQ_NEIGHBOR_ENABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq = api.NewGrpcRequest(api.REQ_NEIGHBOR_ENABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg = &serverMsg{
msgType: SRV_MSG_API,
- msgData: restReq,
+ msgData: grpcReq,
}
peer.serverMsgCh <- msg
- result = <-restReq.ResponseCh
- res = make(map[string]string)
- json.Unmarshal(result.Data, &res)
- assert.Equal("ADMIN_STATE_UP", res["result"])
+ result = <-grpcReq.ResponseCh
+ err = result.Data.(api.Error)
+ assert.Equal(err.Code, api.Error_SUCCESS)
waitUntil(assert, bgp.BGP_FSM_ACTIVE, peer, (HOLDTIME_IDLE+1)*1000)
assert.Equal(bgp.BGP_FSM_ACTIVE, peer.fsm.state)
@@ -397,31 +388,29 @@ func TestPeerAdminShutdownReject(t *testing.T) {
peer.connCh <- m
waitUntil(assert, bgp.BGP_FSM_OPENSENT, peer, 1000)
- restReq := api.NewRestRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq := api.NewGrpcRequest(api.REQ_NEIGHBOR_DISABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg := &serverMsg{
msgType: SRV_MSG_API,
- msgData: restReq,
+ msgData: grpcReq,
}
peer.fsm.adminStateCh <- ADMIN_STATE_DOWN
peer.serverMsgCh <- msg
- result := <-restReq.ResponseCh
- res := make(map[string]string)
- json.Unmarshal(result.Data, &res)
- assert.Equal("previous request is still remaining", res["result"])
+ result := <-grpcReq.ResponseCh
+ err := result.Data.(api.Error)
+ assert.Equal(err.Code, api.Error_FAIL)
- restReq = api.NewRestRequest(api.REQ_NEIGHBOR_ENABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
+ grpcReq = api.NewGrpcRequest(api.REQ_NEIGHBOR_ENABLE, "0.0.0.0", bgp.RF_IPv4_UC, nil)
msg = &serverMsg{
msgType: SRV_MSG_API,
- msgData: restReq,
+ msgData: grpcReq,
}
peer.serverMsgCh <- msg
- result = <-restReq.ResponseCh
- res = make(map[string]string)
- json.Unmarshal(result.Data, &res)
- assert.Equal("previous request is still remaining", res["result"])
+ result = <-grpcReq.ResponseCh
+ err = result.Data.(api.Error)
+ assert.Equal(err.Code, api.Error_FAIL)
waitUntil(assert, bgp.BGP_FSM_IDLE, peer, 1000)
assert.Equal(bgp.BGP_FSM_IDLE, peer.fsm.state)
diff --git a/server/server.go b/server/server.go
index a47f9177..8212a1a0 100644
--- a/server/server.go
+++ b/server/server.go
@@ -16,7 +16,6 @@
package server
import (
- "encoding/json"
"fmt"
log "github.com/Sirupsen/logrus"
"github.com/osrg/gobgp/api"
@@ -61,7 +60,7 @@ type BgpServer struct {
globalTypeCh chan config.Global
addedPeerCh chan config.Neighbor
deletedPeerCh chan config.Neighbor
- RestReqCh chan *api.RestRequest
+ GrpcReqCh chan *api.GrpcRequest
listenPort int
peerMap map[string]peerMapInfo
globalRib *Peer
@@ -74,7 +73,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.RestReqCh = make(chan *api.RestRequest, 1)
+ b.GrpcReqCh = make(chan *api.GrpcRequest, 1)
b.policyUpdateCh = make(chan config.RoutingPolicy)
b.listenPort = port
return &b
@@ -217,8 +216,8 @@ func (server *BgpServer) Serve() {
} else {
log.Info("Can't delete a peer configuration for ", addr)
}
- case restReq := <-server.RestReqCh:
- server.handleRest(restReq)
+ case grpcReq := <-server.GrpcReqCh:
+ server.handleGrpc(grpcReq)
case pl := <-server.policyUpdateCh:
server.SetPolicy(pl)
msg := &serverMsg{
@@ -294,37 +293,44 @@ func (p peers) Less(i, j int) bool {
return strings.Less(0, 1)
}
-func (server *BgpServer) handleRest(restReq *api.RestRequest) {
- switch restReq.RequestType {
+func (server *BgpServer) handleGrpc(grpcReq *api.GrpcRequest) {
+ switch grpcReq.RequestType {
case api.REQ_NEIGHBORS:
- result := &api.RestResponse{}
peerList := peers{}
for _, info := range server.peerMap {
peerList = append(peerList, info.peer)
}
sort.Sort(peerList)
- j, _ := json.Marshal(peerList)
- result.Data = j
- restReq.ResponseCh <- result
- close(restReq.ResponseCh)
-
+ for _, peer := range peerList {
+ data, err := peer.ToGrpc()
+ result := &api.GrpcResponse{
+ ResponseErr: err,
+ Data: data,
+ }
+ grpcReq.ResponseCh <- result
+ }
+ close(grpcReq.ResponseCh)
case api.REQ_NEIGHBOR:
-
- remoteAddr := restReq.RemoteAddr
- result := &api.RestResponse{}
+ remoteAddr := grpcReq.RemoteAddr
+ var result *api.GrpcResponse
info, found := server.peerMap[remoteAddr]
if found {
- j, _ := json.Marshal(info.peer)
- result.Data = j
+ data, err := info.peer.ToGrpc()
+ result = &api.GrpcResponse{
+ ResponseErr: err,
+ Data: data,
+ }
} else {
- result.ResponseErr = fmt.Errorf("Neighbor that has %v does not exist.", remoteAddr)
+ result = &api.GrpcResponse{
+ ResponseErr: fmt.Errorf("Neighbor that has %v does not exist.", remoteAddr),
+ }
}
- restReq.ResponseCh <- result
- close(restReq.ResponseCh)
+ grpcReq.ResponseCh <- result
+ close(grpcReq.ResponseCh)
case api.REQ_GLOBAL_RIB, api.REQ_GLOBAL_ADD, api.REQ_GLOBAL_DELETE:
msg := &serverMsg{
msgType: SRV_MSG_API,
- msgData: restReq,
+ msgData: grpcReq,
}
server.globalRib.serverMsgCh <- msg
case api.REQ_LOCAL_RIB, api.REQ_NEIGHBOR_SHUTDOWN, api.REQ_NEIGHBOR_RESET,
@@ -332,19 +338,19 @@ func (server *BgpServer) handleRest(restReq *api.RestRequest) {
api.REQ_ADJ_RIB_IN, api.REQ_ADJ_RIB_OUT,
api.REQ_NEIGHBOR_ENABLE, api.REQ_NEIGHBOR_DISABLE:
- remoteAddr := restReq.RemoteAddr
- result := &api.RestResponse{}
+ remoteAddr := grpcReq.RemoteAddr
+ result := &api.GrpcResponse{}
info, found := server.peerMap[remoteAddr]
if found {
msg := &serverMsg{
msgType: SRV_MSG_API,
- msgData: restReq,
+ msgData: grpcReq,
}
info.peer.serverMsgCh <- msg
} else {
result.ResponseErr = fmt.Errorf("Neighbor that has %v does not exist.", remoteAddr)
- restReq.ResponseCh <- result
- close(restReq.ResponseCh)
+ grpcReq.ResponseCh <- result
+ close(grpcReq.ResponseCh)
}
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-11 16:44:49 +0000