rpc/notifications: add notification support to RPC client and SPDK host.

Two new RPC calls get_notification_types and get_notifications added.

Change-Id: Ia5288d83cc5e9f18ef1622d3f15b9fe3bbf640ed
Signed-off-by: Pawel Wodkowski <pawelx.wodkowski@intel.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/436530
Reviewed-by: Vitaliy Mysak <vitaliy.mysak@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>

doc/jsonrpc.md

@@ -5015,6 +5015,106 @@ Example response:
 }
 ~~~
 
+# Notifications
+
+## get_notification_types {#rpc_get_notification_types}
+
+Return list of all supported notification types.
+
+### Parameters
+
+None
+
+### Response
+
+The response is an array of strings - supported RPC notification types.
+
+### Example
+
+Example request:
+
+~~~
+{
+  "jsonrpc": "2.0",
+  "method": "get_notification_types",
+  "id": 1
+}
+~~~
+
+Example response:
+
+~~~
+{
+  "id": 1,
+  "result": [
+    "bdev_register",
+    "bdev_unregister"
+  ],
+  "jsonrpc": "2.0"
+}
+~~~
+
+## get_notifications {#get_notifications}
+
+Request notifications. Returns array of notifications that happend since the specified id (or first that is available).
+
+Notice: Notifications are kept in circular buffer with limited size. Older notifications might be inaccesible due to being overwritten by new ones.
+
+### Parameters
+
+Name                    | Optional | Type        | Description
+----------------------- | -------- | ----------- | -----------
+id                      | Optional | number      | First Event ID to fetch (default: first available).
+max                     | Optional | number      | Maximum number of event to return (default: no limit).
+
+### Response
+
+Response is an array of event objects.
+
+Name                    | Optional | Type        | Description
+----------------------- | -------- | ----------- | -----------
+id                      | Optional | number      | Event ID.
+type                    | Optional | number      | Type of the event.
+ctx                     | Optional | string      | Event context.
+
+### Example
+
+Example request:
+
+~~~
+{
+  "id": 1,
+  "jsonrpc": "2.0",
+  "method": "get_notifications",
+  "params": {
+    "id": 1,
+    "max": 10
+  }
+}
+
+~~~
+
+Example response:
+
+~~~
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": [
+    {
+      "ctx": "Malloc0",
+      "type": "bdev_register",
+      "id": 1
+    },
+    {
+      "ctx": "Malloc2",
+      "type": "bdev_register",
+      "id": 2
+    }
+  ]
+}
+~~~
+
 # Miscellaneous RPC commands
 
 ## send_nvme_cmd {#rpc_send_nvme_cmd}

lib/event/rpc/Makefile

@@ -34,7 +34,7 @@
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
 
-C_SRCS = app_rpc.c subsystem_rpc.c
+C_SRCS = app_rpc.c subsystem_rpc.c notify_rpc.c
 LIBNAME = app_rpc
 
 include $(SPDK_ROOT_DIR)/mk/spdk.lib.mk

lib/event/rpc/notify_rpc.c

@@ -0,0 +1,131 @@
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright (c) Intel Corporation.
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include "spdk/rpc.h"
+#include "spdk/string.h"
+#include "spdk/notify.h"
+#include "spdk/env.h"
+#include "spdk/util.h"
+
+#include "spdk_internal/log.h"
+
+static int
+get_notification_types_cb(const struct spdk_notify_type *type, void *ctx)
+{
+	spdk_json_write_string((struct spdk_json_write_ctx *)ctx, spdk_notify_type_get_name(type));
+	return 0;
+}
+
+static void
+spdk_rpc_get_notification_types(struct spdk_jsonrpc_request *request,
+				const struct spdk_json_val *params)
+{
+	struct spdk_json_write_ctx *w;
+
+	if (params != NULL) {
+		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
+						 "No parameters required");
+		return;
+	}
+
+	w = spdk_jsonrpc_begin_result(request);
+	if (w == NULL) {
+		return;
+	}
+
+	spdk_json_write_array_begin(w);
+	spdk_notify_get_types(get_notification_types_cb, w);
+	spdk_json_write_array_end(w);
+
+	spdk_jsonrpc_end_result(request, w);
+}
+SPDK_RPC_REGISTER("get_notification_types", spdk_rpc_get_notification_types, SPDK_RPC_RUNTIME)
+
+struct rpc_get_notifications {
+	uint64_t id;
+	uint64_t max;
+
+	struct spdk_json_write_ctx *w;
+};
+
+static const struct spdk_json_object_decoder rpc_get_notifications_decoders[] = {
+	{"id", offsetof(struct rpc_get_notifications, id), spdk_json_decode_uint64, true},
+	{"max", offsetof(struct rpc_get_notifications, max), spdk_json_decode_uint64, true},
+};
+
+
+static int
+get_notifications_cb(uint64_t id, const struct spdk_notify_event *ev, void *ctx)
+{
+	struct rpc_get_notifications *req = ctx;
+
+	spdk_json_write_object_begin(req->w);
+	spdk_json_write_named_string(req->w, "type", ev->type);
+	spdk_json_write_named_string(req->w, "ctx", ev->ctx);
+	spdk_json_write_named_uint64(req->w, "id", id);
+	spdk_json_write_object_end(req->w);
+	return 0;
+}
+
+static void
+spdk_rpc_get_notifications(struct spdk_jsonrpc_request *request,
+			   const struct spdk_json_val *params)
+{
+	struct rpc_get_notifications req = {0, UINT64_MAX};
+
+	if (params &&
+	    spdk_json_decode_object(params, rpc_get_notifications_decoders,
+				    SPDK_COUNTOF(rpc_get_notifications_decoders), &req)) {
+		SPDK_DEBUGLOG(SPDK_NOTIFY_RPC, "spdk_json_decode_object failed\n");
+
+		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
+						 spdk_strerror(EINVAL));
+		return;
+	}
+
+
+	req.w = spdk_jsonrpc_begin_result(request);
+	if (req.w == NULL) {
+		return;
+	}
+
+	spdk_json_write_array_begin(req.w);
+	spdk_notify_get_events(req.id, req.max, get_notifications_cb, &req);
+	spdk_json_write_array_end(req.w);
+
+	spdk_jsonrpc_end_result(request, req.w);
+}
+SPDK_RPC_REGISTER("get_notifications", spdk_rpc_get_notifications, SPDK_RPC_RUNTIME)
+
+SPDK_LOG_REGISTER_COMPONENT("notify_rpc", SPDK_NOTIFY_RPC)

scripts/rpc.py

@@ -1770,6 +1770,24 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse
                    help="""Command execution timeout value, in milliseconds,  if 0, don't track timeout""", type=int, default=0)
     p.set_defaults(func=send_nvme_cmd)
 
+    # Notifications
+    def get_notification_types(args):
+        print_dict(rpc.notify.get_notification_types(args.client))
+
+    p = subparsers.add_parser('get_notification_types', help='List available notifications that user can subscribe to.')
+    p.set_defaults(func=get_notification_types)
+
+    def get_notifications(args):
+        ret = rpc.notify.get_notifications(args.client,
+                                           id=args.id,
+                                           max=args.max)
+        print_dict(ret)
+
+    p = subparsers.add_parser('get_notifications', help='Get notifications')
+    p.add_argument('-i', '--id', help="""First ID to start fetching from""", type=int)
+    p.add_argument('-n', '--max', help="""Maximum number of notifications to return in response""", type=int)
+    p.set_defaults(func=get_notifications)
+
     args = parser.parse_args()
 
     with rpc.client.JSONRPCClient(args.server_addr, args.port, args.timeout, log_level=getattr(logging, args.verbose.upper())) as client:

scripts/rpc/__init__.py

@@ -9,6 +9,7 @@ from . import log
 from . import lvol
 from . import nbd
 from . import net
+from . import notify
 from . import nvme
 from . import nvmf
 from . import pmem

scripts/rpc/notify.py

@@ -0,0 +1,25 @@
+def get_notification_types(client):
+    return client.call("get_notification_types")
+
+
+def get_notifications(client,
+                      id=None,
+                      max=None):
+    """
+
+    Args:
+        id First ID to start fetching from
+        max Maximum number of notifications to return in response
+
+    Return:
+        Notifications array
+    """
+
+    params = {}
+    if id:
+        params['id'] = id
+
+    if max:
+        params['max'] = max
+
+    return client.call("get_notifications", params)