draft implementing the core of the paginator

Signed-off-by: Vincenzo Palazzo <[email protected]>

Author: vincenzopalazzo

common/Makefile

@@ -109,6 +109,7 @@ COMMON_HEADERS_NOGEN := $(COMMON_SRC_NOGEN:.c=.h)	\
 	common/htlc.h					\
 	common/json_command.h				\
 	common/jsonrpc_errors.h				\
+       common/jsonrpc_paginator.h                      \
 	common/overflows.h
 
 COMMON_HEADERS_GEN := common/htlc_state_names_gen.h common/status_wiregen.h common/peer_status_wiregen.h common/scb_wiregen.h

common/json_param.c

@@ -1,4 +1,7 @@
+#include "ccan/tal/tal.h"
 #include "config.h"
+#include "jsmn.h"
+#include <assert.h>
 #include <bitcoin/address.h>
 #include <bitcoin/base58.h>
 #include <bitcoin/feerate.h>
@@ -14,6 +17,8 @@
 #include <common/json_command.h>
 #include <common/json_param.h>
 #include <common/route.h>
+#include <stdbool.h>
+#include <stddef.h>
 
 struct param {
 	const char *name;
@@ -352,6 +357,14 @@ bool param(struct command *cmd, const char *buffer,
 		if (streq(name, "")) {
 			allow_extra = true;
 			continue;
+		} else if (streq(name, "paginator")) {
+			struct command_result *result;
+			if ((result = cbx(cmd, name, buffer, NULL, arg)))
+				return result;
+			/* we allow extra but we already made a check that are
+			 * paginator keys, so this should be safe! */
+			allow_extra = true;
+			continue;
 		}
 		if (!param_add(&params, name, style, cbx, arg)) {
 			/* We really do ignore this return! */
@@ -439,6 +452,37 @@ struct command_result *param_string(struct command *cmd, const char *name,
 	return NULL;
 }
 
+struct command_result *param_arr_str(struct command *cmd, const char *name,
+				   const char *buffer, const jsmntok_t *tok,
+				   const char ***arr)
+{
+	const jsmntok_t *curr;
+	size_t i;
+
+	if (tok->type != JSMN_ARRAY)
+		return command_fail_badparam(cmd, name, buffer, tok,
+					     "schould be an array of string");
+
+	*arr = tal_arr(cmd, const char *, 0);
+	json_for_each_arr(i, curr, tok) {
+		struct json_escape *esc;
+		const char *str;
+
+		if (curr->type != JSMN_STRING)
+			return command_fail_badparam(cmd, name, buffer, tok,
+						     "the item of the array should be a string");
+
+		esc = json_escape_string_(cmd, buffer + curr->start,
+			   curr->end - curr->start);
+		str = json_escape_unescape(cmd, esc);
+		tal_arr_expand(arr, str);
+	}
+
+	return NULL;
+}
+
+
+
 struct command_result *param_ignore(struct command *cmd, const char *name,
 				    const char *buffer, const jsmntok_t *tok,
 				    const void *unused)
@@ -1066,3 +1110,24 @@ struct command_result *param_pubkey(struct command *cmd, const char *name,
 				     "should be a compressed pubkey");
 }
 
+struct command_result *param_paginator(struct command *cmd, const char *name,
+				       const char *buffer, const jsmntok_t *tok)
+{
+	/*
+	const jsmntok_t *tok_tmp;
+
+	tok_tmp = json_get_member(buffer, tok, "batch");
+	if (tok_tmp)
+		return NULL;
+	tok_tmp = json_get_member(buffer, tok, "offset");
+	if (tok_tmp)
+		return NULL;
+
+	tok_tmp = json_get_member(buffer, tok, "limit");
+	if (tok_tmp)
+		return NULL;
+
+	return command_fail_badparam(cmd, name, buffer, tok,
+	"paginator request format in the wrong way!");*/
+	return NULL;
+}

common/json_param.h

@@ -2,9 +2,11 @@
 #ifndef LIGHTNING_COMMON_JSON_PARAM_H
 #define LIGHTNING_COMMON_JSON_PARAM_H
 #include "config.h"
+#include <assert.h>
 #include <ccan/short_types/short_types.h>
 #include <common/bolt11.h>
 #include <common/json_parse.h>
+#include <common/jsonrpc_paginator.h>
 #include <common/lease_rates.h>
 #include <common/node_id.h>
 #include <common/sphinx.h>
@@ -49,6 +51,10 @@ struct command_result;
 bool param(struct command *cmd, const char *buffer,
 	   const jsmntok_t params[], ...) LAST_ARG_NULL;
 
+bool param_partial_par(struct command *cmd, const char *buffer,
+		       const jsmntok_t tokens[], ...) LAST_ARG_NULL;
+
+
 /*
  * The callback signature.
  *
@@ -80,6 +86,10 @@ enum param_style {
 	PARAM_OPTIONAL_WITH_DEFAULT,
 };
 
+/** Check if this is a valid paginator input */
+struct command_result *param_paginator(struct command *cmd, const char *name,
+				       const char *buffer, const jsmntok_t *tok);
+
 /*
  * Add a required parameter.
  */
@@ -139,6 +149,9 @@ enum param_style {
 /* Special flag for 'check' which allows any parameters. */
 #define p_opt_any() "", PARAM_OPTIONAL, NULL, NULL
 
+#define p_paginator() "paginator", PARAM_OPTIONAL, param_paginator, NULL
+
+
 /* All the helper routines. */
 struct amount_msat;
 struct amount_sat;
@@ -181,6 +194,11 @@ struct command_result *param_string(struct command *cmd, const char *name,
 				    const char * buffer, const jsmntok_t *tok,
 				    const char **str);
 
+/* Extract an array of strings */
+struct command_result *param_arr_str(struct command *cmd, const char *name,
+				   const char *buffer, const jsmntok_t *tok,
+				   const char ***arr);
+
 /* Extract a label. It is either an escaped string or a number. */
 struct command_result *param_label(struct command *cmd, const char *name,
 				   const char * buffer, const jsmntok_t *tok,
@@ -340,5 +358,4 @@ struct command_result *param_lease_hex(struct command *cmd,
 struct command_result *param_pubkey(struct command *cmd, const char *name,
 				    const char *buffer, const jsmntok_t *tok,
 				    struct pubkey **pubkey);
-
 #endif /* LIGHTNING_COMMON_JSON_PARAM_H */

common/jsonrpc_paginator.h

@@ -0,0 +1,81 @@
+/**
+ * Welcome in this wanderful experience of writing
+ * a paginator for the core lightning JSON RPC 2.0 in C!
+ *
+ *
+ * I will try to keep the code as simple as possible,
+ * so if you had any dout on what I'm trying to do, blame me
+ * that I was not able to do my job.
+ *
+ *
+ * In short, the goal of this paginator is offer a struct
+ * that it is used to grep the paginator information by
+ * pre processin the JSON RPC request.
+ *
+ * So let immagine a normal listnode RPC call, where
+ * cli | rest | grpc -> json_listnodes -> json response {....}
+ *
+ * if the paginator will be enbaled on the listnodes, the
+ * call will be
+ *
+ * cli | rest | grpc -> json_paginator_listnodes -> json_listnodes + struct jsonrpc_paginator -> sjon response { .... }
+ *
+ * Done, this should be all!
+ *
+ *
+ * Now let see how this is implemented.
+ * */
+#ifndef JSONRPC_PAGINATOR_H
+#define JSONRPC_PAGINATOR_H
+
+#include <ccan/tal/tal.h>
+#include <ccan/short_types/short_types.h>
+
+/**
+ * jsonrpc_paginator - core struct where all the paginator information
+ * are stored,
+ *
+ * A developer that want to extend the functionality of the
+ * paginator must not abuse of this struct to avoid to made the logic
+ * messy, thanks!
+ *
+ * @batch: array string to be able to query a list of things, useful also
+ * when you deal with reading stuff from file to avoid reaccess to the file
+ * to search another item.
+ *
+ * @offset: a position (u64) that determines the number of element (in SQL row)
+ * returned by request.
+ * @limit: a position (u64) that give the number of element in [0,..,offset - 1] to skip skip.
+ */
+struct jsonrpc_paginator {
+	/** reall usefult for access to gossip map */
+	const char **batch;
+	/** query the database */
+	const u64 *offset;
+	const u64 *limit;
+	/* FIXME: more smarter one? like sort_by = "json key"
+	 * but this required to have a mapping between json_keys and sql keys
+	 * maybe we had already somethings in the sql plugin? */
+};
+
+/** new_paginator - helper function to create a new paginator from a list of parameter.
+ * This is simple enought to be avoided, but write simple code inside the C macros
+ * is frustating, so let use this insteand.
+ *
+ * BTW: I love C Macros, really!
+ * */
+static inline struct jsonrpc_paginator *new_paginator(const tal_t *ctx, const char **batch,
+					      const u64 *limit, const u64 *offset)
+{
+	struct jsonrpc_paginator *paginator = NULL;
+	if (batch || limit || offset) {
+		paginator = tal(ctx, struct jsonrpc_paginator);
+		paginator->batch = batch;
+		paginator->limit = limit;
+		paginator->offset = offset;
+		return paginator;
+	}
+	return NULL;
+}
+
+#endif // JSONRPC_PAGINATOR_H

lightningd/jsonrpc.h

@@ -1,10 +1,10 @@
 #ifndef LIGHTNING_LIGHTNINGD_JSONRPC_H
 #define LIGHTNING_LIGHTNINGD_JSONRPC_H
-#include "ccan/compiler/compiler.h"
 #include "config.h"
 #include <ccan/list/list.h>
 #include <common/autodata.h>
 #include <common/json_stream.h>
+#include <common/jsonrpc_paginator.h>
 #include <common/status_levels.h>
 
 struct jsonrpc;
@@ -19,10 +19,6 @@ enum command_mode {
 	CMD_CHECK
 };
 
-// FIXME(vincenzopalazzo): The filtering architecture
-// desearve an own file.
-struct jsonrpc_paginator { };
-
 /* Context for a command (from JSON, but might outlive the connection!). */
 /* FIXME: move definition into jsonrpc.c */
 struct command {
@@ -49,7 +45,7 @@ struct command {
 	/* Optional output field filter. */
 	struct json_filter *filter;
 	/* Option filtering option */
-	struct jsonrpc_paginator *paginator;
+	const struct jsonrpc_paginator *paginator;
 };
 
 /**
@@ -279,15 +275,23 @@ struct jsonrpc_request *jsonrpc_request_start_(
 
 void jsonrpc_request_end(struct jsonrpc_request *request);
 
-#define PAGINATOR(callback)                                                             \
-	static struct command_result *callback##_paginator(struct command *cmd,       \
+AUTODATA_TYPE(json_command, struct json_command);
+
+#define PAGINATOR(callback)						\
+	static struct command_result* callback##_paginator(struct command *cmd,         \
 	                                     const char *buffer,                        \
 	                                     const jsmntok_t *obj UNNEEDED,             \
 	                                     const jsmntok_t *params)                   \
 	{                                                                               \
-	   return callback(cmd, buffer, obj, params);                                   \
+		const char **batch;						        \
+		u64 *limit, *offset;                                                    \
+                if (!param_partial_par(cmd, buffer, params,				\
+	             p_opt("batch", param_arr_str, &batch),                             \
+                     p_opt("limit", param_u64, &limit),                                 \
+		     p_opt("offset", param_u64, &offset),                               \
+		     NULL))                                                             \
+		     return command_param_failed();                                     \
+		cmd->paginator = new_paginator(cmd, batch, limit, offset);              \
+		return callback(cmd, buffer, obj, params);		                \
         }
-
-AUTODATA_TYPE(json_command, struct json_command);
-
 #endif /* LIGHTNING_LIGHTNINGD_JSONRPC_H */

plugins/libplugin.h

@@ -14,6 +14,7 @@
 #include <common/htlc.h>
 #include <common/json_command.h>
 #include <common/jsonrpc_errors.h>
+#include <common/jsonrpc_paginator.h>
 #include <common/node_id.h>
 #include <common/status_levels.h>
 #include <common/utils.h>
@@ -57,6 +58,8 @@ struct command {
 	struct plugin *plugin;
 	/* Optional output field filter. */
 	struct json_filter *filter;
+	/* Option filtering option */
+	struct jsonrpc_paginator *paginator;
 };
 
 /* Create an array of these, one for each command you support. */
@@ -485,4 +488,22 @@ const jsmntok_t *jsonrpc_request_sync(const tal_t *ctx, struct plugin *plugin,
 				      const struct json_out *params TAKES,
 				      const char **resp);
 
+#define PAGINATOR(callback)						                \
+	static struct command_result* callback##_paginator(struct command *cmd,         \
+	                                     const char *buffer,                        \
+	                                     const jsmntok_t *params)                   \
+	{                                                                               \
+		const char **batch;						        \
+		u64 *limit, *offset;                                                    \
+                if (!param(cmd, buffer, params,				                \
+	             p_opt("batch", param_arr_str, &batch),                             \
+                     p_opt("limit", param_u64, &limit),                                 \
+		     p_opt("offset", param_u64, &offset),                               \
+	             p_opt_any(),                                                       \
+		     NULL))                                                             \
+		     return command_param_failed();                                     \
+		cmd->paginator = new_paginator(cmd, batch, limit, offset);              \
+                return callback(cmd, buffer, params);				        \
+        }
+
 #endif /* LIGHTNING_PLUGINS_LIBPLUGIN_H */