List all routes and lbtargets using gRPC

cli/dpservice-cli/cmd/list_loadbalancer_targets.go

@@ -54,11 +54,6 @@ func (o *ListLoadBalancerTargetOptions) AddFlags(fs *pflag.FlagSet) {
 }
 
 func (o *ListLoadBalancerTargetOptions) MarkRequiredFlags(cmd *cobra.Command) error {
-	for _, name := range []string{"lb-id"} {
-		if err := cmd.MarkFlagRequired(name); err != nil {
-			return err
-		}
-	}
 	return nil
 }
 

cli/dpservice-cli/cmd/list_routes.go

@@ -50,16 +50,11 @@ type ListRoutesOptions struct {
 }
 
 func (o *ListRoutesOptions) AddFlags(fs *pflag.FlagSet) {
-	fs.Uint32Var(&o.VNI, "vni", o.VNI, "VNI to get the routes from.")
+	fs.Uint32Var(&o.VNI, "vni", 0, "VNI to get the routes from.")
 	fs.StringVar(&o.SortBy, "sort-by", "", "Column to sort by.")
 }
 
 func (o *ListRoutesOptions) MarkRequiredFlags(cmd *cobra.Command) error {
-	for _, name := range []string{"vni"} {
-		if err := cmd.MarkFlagRequired(name); err != nil {
-			return err
-		}
-	}
 	return nil
 }
 

go/dpservice-go/client/client_test.go

@@ -1603,13 +1603,6 @@ var _ = Describe("negative loadbalancer related tests", Label("negative"), func(
 			Expect(err.Error()).To(Equal("[error code 204] BAD_IPVER"))
 		})
 
-		It("should not list", func() {
-			By("not defining loadbalancer ID")
-			_, err = dpdkClient.ListLoadBalancerTargets(ctx, "")
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(Equal("rpc error: code = InvalidArgument desc = Invalid loadbalancer_id"))
-		})
-
 		It("should not delete", func() {
 			By("not defining loadbalancer ID")
 			targetIp := netip.MustParseAddr("ff80::5")

src/dp_lb.c

@@ -249,20 +249,10 @@ const union dp_ipv6 *dp_lb_get_backend_ip(struct flow_key *flow_key, uint32_t vn
 	return &lb_val->back_end_ips[pos];
 }
 
-int dp_get_lb_back_ips(const void *id_key, struct dp_grpc_responder *responder)
+static int dp_get_single_lb_back_ips(const struct lb_value *lb_val, struct dp_grpc_responder *responder)
 {
-	struct lb_key *lb_k;
-	struct lb_value *lb_val;
 	struct dpgrpc_lb_target *reply;
 
-	if (DP_FAILED(rte_hash_lookup_data(id_map_lb_tbl, id_key, (void **)&lb_k)))
-		return DP_GRPC_ERR_NO_LB;
-
-	if (DP_FAILED(rte_hash_lookup_data(lb_table, lb_k, (void **)&lb_val)))
-		return DP_GRPC_ERR_NO_BACKIP;
-
-	dp_grpc_set_multireply(responder, sizeof(*reply));
-
 	for (int i = 0; i < DP_LB_MAX_IPS_PER_VIP; ++i) {
 		if (!dp_is_ipv6_zero(&lb_val->back_end_ips[i])) {
 			reply = dp_grpc_add_reply(responder);
@@ -271,10 +261,47 @@ int dp_get_lb_back_ips(const void *id_key, struct dp_grpc_responder *responder)
 			dp_set_ipaddr6(&reply->addr, &lb_val->back_end_ips[i]);
 		}
 	}
+	return DP_GRPC_OK;
+}
+
+static int dp_get_all_lb_back_ips(struct dp_grpc_responder *responder)
+{
+	uint32_t iter = 0;
+	const struct lb_key *lb_key;
+	struct lb_value *lb_val;
+	int ret;
 
+	if (rte_hash_count(id_map_lb_tbl) == 0)
+		return DP_GRPC_OK;
+
+	while ((ret = rte_hash_iterate(lb_table, (const void **)&lb_key, (void **)&lb_val, &iter)) != -ENOENT) {
+		if (DP_FAILED(ret))
+			return DP_GRPC_ERR_ITERATOR;
+		dp_get_single_lb_back_ips(lb_val, responder);
+		// ignore errors, try to send as much as possible
+	}
 	return DP_GRPC_OK;
 }
 
+int dp_get_lb_back_ips(const void *id_key, struct dp_grpc_responder *responder)
+{
+	struct lb_key *lb_k;
+	struct lb_value *lb_val;
+
+	dp_grpc_set_multireply(responder, sizeof(struct dpgrpc_lb_target));
+
+	if (!id_key || *(const char *)id_key == '\0')
+		return dp_get_all_lb_back_ips(responder);
+
+	if (DP_FAILED(rte_hash_lookup_data(id_map_lb_tbl, id_key, (void **)&lb_k)))
+		return DP_GRPC_ERR_NO_LB;
+
+	if (DP_FAILED(rte_hash_lookup_data(lb_table, lb_k, (void **)&lb_val)))
+		return DP_GRPC_ERR_NO_BACKIP;
+
+	return dp_get_single_lb_back_ips(lb_val, responder);
+}
+
 int dp_add_lb_back_ip(const void *id_key, const union dp_ipv6 *back_ip)
 {
 	struct lb_value *lb_val = NULL;

src/dp_lpm.c

@@ -190,19 +190,12 @@ static int dp_list_route_entry(struct rte_rib_node *node,
 	return DP_GRPC_OK;
 }
 
-int dp_list_routes(const struct dp_port *port, uint32_t vni, bool ext_routes,
-				   struct dp_grpc_responder *responder)
+static int dp_list_route_table(const struct dp_port *port, struct rte_rib *root, bool ext_routes,
+							   struct dp_grpc_responder *responder)
 {
 	struct rte_rib_node *node;
-	struct rte_rib *root;
 	int ret;
 
-	root = dp_get_vni_route4_table(vni);
-	if (!root)
-		return DP_GRPC_ERR_NO_VNI;
-
-	dp_grpc_set_multireply(responder, sizeof(struct dpgrpc_route));
-
 	node = rte_rib_lookup_exact(root, RTE_IPV4(0, 0, 0, 0), 0);
 	if (node) {
 		ret = dp_list_route_entry(node, port, ext_routes, responder);
@@ -220,6 +213,51 @@ int dp_list_routes(const struct dp_port *port, uint32_t vni, bool ext_routes,
 	return DP_GRPC_OK;
 }
 
+static int dp_list_single_route_table(const struct dp_port *port, uint32_t vni, bool ext_routes,
+									  struct dp_grpc_responder *responder)
+{
+	struct rte_rib *root;
+
+	root = dp_get_vni_route4_table(vni);
+	if (!root)
+		return DP_GRPC_ERR_NO_VNI;
+
+	return dp_list_route_table(port, root, ext_routes, responder);
+}
+
+static int dp_list_all_route_tables(const struct dp_port *port, bool ext_routes,
+									struct dp_grpc_responder *responder)
+{
+	struct dp_vni_data *vni_data;
+	const struct dp_vni_key *vni_key;
+	uint32_t iter = 0;
+	int32_t ret;
+
+	if (rte_hash_count(vni_handle_tbl) == 0)
+		return DP_GRPC_OK;
+
+	while ((ret = rte_hash_iterate(vni_handle_tbl, (const void **)&vni_key, (void **)&vni_data, &iter)) != -ENOENT) {
+		if (DP_FAILED(ret)) {
+			DPS_LOG_ERR("Cannot iterate VNI table", DP_LOG_RET(ret));
+			return DP_GRPC_ERR_ITERATOR;
+		}
+		dp_list_single_route_table(port, vni_key->vni, ext_routes, responder);
+		// ignore errors, show as much as possible
+	}
+	return DP_GRPC_OK;
+}
+
+int dp_list_routes(const struct dp_port *port, uint32_t vni, bool ext_routes,
+				   struct dp_grpc_responder *responder)
+{
+	dp_grpc_set_multireply(responder, sizeof(struct dpgrpc_route));
+
+	if (vni == 0)
+		return dp_list_all_route_tables(port, ext_routes, responder);
+	else
+		return dp_list_single_route_table(port, vni, ext_routes, responder);
+}
+
 int dp_add_route6(const struct dp_port *port, uint32_t vni, uint32_t t_vni, const union dp_ipv6 *ipv6,
 				  const union dp_ipv6 *t_ip6, uint8_t depth)
 {

src/dp_vni.c

@@ -240,6 +240,10 @@ int dp_reset_all_vni_route_tables(void)
 		return DP_OK;
 
 	while ((ret = rte_hash_iterate(vni_handle_tbl, (const void **)&vni_key, (void **)&vni_data, &iter)) != -ENOENT) {
+		if (DP_FAILED(ret)) {
+			DPS_LOG_ERR("Cannot iterate VNI table", DP_LOG_RET(ret));
+			return DP_ERROR;
+		}
 		if (DP_FAILED(dp_reset_vni_data(vni_key->vni, vni_data)))
 			return DP_ERROR;
 	}

src/grpc/dp_async_grpc.cpp

@@ -851,8 +851,11 @@ const char* ListLoadBalancerTargetsCall::FillRequest(struct dpgrpc_request* requ
 {
 	DPGRPC_LOG_INFO("Listing loadbalancer targets",
 					DP_LOG_LBID(request_.loadbalancer_id().c_str()));
-	if (SNPRINTF_FAILED(request->list_lbtrgt.lb_id, request_.loadbalancer_id()))
-		return "Invalid loadbalancer_id";
+	if (request_.loadbalancer_id().empty())
+		request->list_lbtrgt.lb_id[0] = 0;
+	else
+		if (SNPRINTF_FAILED(request->list_lbtrgt.lb_id, request_.loadbalancer_id()))
+			return "Invalid loadbalancer_id";
 	return NULL;
 }
 void ListLoadBalancerTargetsCall::ParseReply(struct dpgrpc_reply* reply)