rpki: support show the state of RPKI servers

Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
rastislavs · Aug 31, 2015 · 955409c · 955409c
1 parent 70a8399
commit 955409c
Show file tree

Hide file tree

Showing 9 changed files with 300 additions and 67 deletions.
diff --git a/api/gobgp.pb.go b/api/gobgp.pb.go
diff --git a/api/gobgp.proto b/api/gobgp.proto
@@ -39,7 +39,8 @@ service Grpc {
   rpc MonitorBestChanged(Arguments) returns (stream Destination) {}
   rpc MonitorPeerState(Arguments) returns (stream Peer) {}
   rpc GetMrt(MrtArguments) returns (stream MrtMessage) {}
-  rpc GetRPKI(Arguments) returns (stream ROA) {}
+  rpc GetRPKI(Arguments) returns (stream RPKI) {}
+  rpc GetROA(Arguments) returns (stream ROA) {}
   rpc GetVrfs(Arguments) returns (stream Vrf) {}
   rpc ModVrf(ModVrfArguments) returns (Error) {}
 }
@@ -295,6 +296,22 @@ message MrtMessage {
     bytes data = 1;
 }
 
+message RPKIConf {
+    string address = 1;
+}
+
+message RPKIState {
+    int64 uptime = 1;
+    int64 downtime = 2;
+    int32 received_ipv4 = 3;
+    int32 received_ipv6 = 4;
+}
+
+message RPKI {
+    RPKIConf conf = 1;
+    RPKIState state = 2;
+}
+
 message ROA {
     uint32 as = 1;
     uint32 prefixlen = 2;

diff --git a/docs/sources/rpki.md b/docs/sources/rpki.md
@@ -56,26 +56,28 @@ and get the ROA (Route Origin Authorization) information in the
 following way:
 
 ```bash
-$ gobgp rpki|head -n4
+$ gobgp rpki server
+Session            State  Uptime     #IPv4/IPv6 records
+210.173.170.254    Up     00:03:06   14823/2168
+```
+
+```bash
+$ gobgp rpki table 210.173.170.254|head -n4
 Network            Maxlen AS
 2.0.0.0/12         16     3215
 2.0.0.0/16         16     3215
 2.1.0.0/16         16     3215
-$ gobgp rpki |wc -l
-14576
 ```
 
 By default, IPv4's ROA information is shown. You can see IPv6's like:
 
 ```bash
-$ gobgp rpki -a ipv6|head -n4
+$ gobgp rpki -a ipv6 table 210.173.170.254|head -n4
 fujita@ubuntu:~$ gobgp rpki -a ipv6|head -n3
 Network                                    Maxlen AS
 2001:608::/32                              32     5539
 2001:610::/32                              48     1103
 2001:610:240::/42                          42     3333
-$ gobgp rpki -a ipv6|wc -l
-2150
 ```
 
 We configure the peer 10.0.255.1 to send three routes:

diff --git a/gobgp/common.go b/gobgp/common.go
@@ -60,6 +60,8 @@ const (
 	CMD_DUMP           = "dump"
 	CMD_INJECT         = "inject"
 	CMD_RPKI           = "rpki"
+	CMD_RPKI_TABLE     = "table"
+	CMD_RPKI_SERVER    = "server"
 	CMD_VRF            = "vrf"
 )
 

diff --git a/gobgp/mrt.go b/gobgp/mrt.go
@@ -296,8 +296,8 @@ func injectMrt(r string, filename string, count int) error {
 					ch <- &api.ModPathArguments{
 						Resource: resource,
 						Path:     path,
-						Asn: peers[e.PeerIndex].AS,
-						Id: peers[e.PeerIndex].BgpId.String(),
+						Asn:      peers[e.PeerIndex].AS,
+						Id:       peers[e.PeerIndex].BgpId.String(),
 					}
 				}
 

diff --git a/gobgp/rpki.go b/gobgp/rpki.go
@@ -24,18 +24,48 @@ import (
 	"io"
 	"net"
 	"os"
+	"time"
 )
 
+func showRPKIServer(args []string) error {
+	arg := &api.Arguments{}
+
+	stream, err := client.GetRPKI(context.Background(), arg)
+	if err != nil {
+		fmt.Println(err)
+		return err
+	}
+	format := "%-18s %-6s %-10s %s\n"
+	fmt.Printf(format, "Session", "State", "Uptime", "#IPv4/IPv6 records")
+	for {
+		r, err := stream.Recv()
+		if err == io.EOF {
+			break
+		} else if err != nil {
+			return err
+		}
+		s := "Up"
+		uptime := int64(time.Now().Sub(time.Unix(r.State.Uptime, 0)).Seconds())
+
+		fmt.Printf(format, fmt.Sprintf(r.Conf.Address), s, fmt.Sprint(formatTimedelta(uptime)), fmt.Sprintf("%d/%d", r.State.ReceivedIpv4, r.State.ReceivedIpv6))
+	}
+	return nil
+}
+
 func showRPKITable(args []string) error {
+	if len(args) == 0 {
+		return fmt.Errorf("Needs to specify RPKI server address")
+	}
 	rf, err := checkAddressFamily(net.IP{})
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 	arg := &api.Arguments{
-		Rf: uint32(rf),
+		Rf:   uint32(rf),
+		Name: args[0],
 	}
-	stream, err := client.GetRPKI(context.Background(), arg)
+	stream, err := client.GetROA(context.Background(), arg)
 	if err != nil {
 		fmt.Println(err)
 		return err
@@ -64,10 +94,25 @@ func showRPKITable(args []string) error {
 func NewRPKICmd() *cobra.Command {
 	rpkiCmd := &cobra.Command{
 		Use: CMD_RPKI,
+	}
+
+	serverCmd := &cobra.Command{
+		Use: CMD_RPKI_SERVER,
+		Run: func(cmd *cobra.Command, args []string) {
+			showRPKIServer(args)
+		},
+	}
+
+	rpkiCmd.AddCommand(serverCmd)
+
+	tableCmd := &cobra.Command{
+		Use: CMD_RPKI_TABLE,
 		Run: func(cmd *cobra.Command, args []string) {
 			showRPKITable(args)
 		},
 	}
-	rpkiCmd.PersistentFlags().StringVarP(&subOpts.AddressFamily, "address-family", "a", "", "address family")
+	tableCmd.PersistentFlags().StringVarP(&subOpts.AddressFamily, "address-family", "a", "", "address family")
+
+	rpkiCmd.AddCommand(tableCmd)
 	return rpkiCmd
 }
diff --git a/server/grpc_server.go b/server/grpc_server.go
@@ -83,6 +83,7 @@ const (
 	REQ_MRT_GLOBAL_RIB
 	REQ_MRT_LOCAL_RIB
 	REQ_RPKI
+	REQ_ROA
 	REQ_VRF
 	REQ_VRFS
 	REQ_VRF_MOD
@@ -512,6 +513,15 @@ func (s *Server) GetRPKI(arg *api.Arguments, stream api.Grpc_GetRPKIServer) erro
 	req := NewGrpcRequest(REQ_RPKI, "", bgp.RouteFamily(arg.Rf), nil)
 	s.bgpServerCh <- req
 
+	return handleMultipleResponses(req, func(res *GrpcResponse) error {
+		return stream.Send(res.Data.(*api.RPKI))
+	})
+}
+
+func (s *Server) GetROA(arg *api.Arguments, stream api.Grpc_GetROAServer) error {
+	req := NewGrpcRequest(REQ_ROA, arg.Name, bgp.RouteFamily(arg.Rf), nil)
+	s.bgpServerCh <- req
+
 	return handleMultipleResponses(req, func(res *GrpcResponse) error {
 		return stream.Send(res.Data.(*api.ROA))
 	})