FS-9952: Intermediate commit for a fresh point to start retrofitting the jsonrpc code that is incomplete

libs/libblade/src/blade_protocol.c

@@ -33,22 +33,26 @@
 
 #include "blade.h"
 
-KS_DECLARE(ks_status_t) blade_request_create(blade_request_t **breqP, ks_pool_t *pool, const char *session_id, cJSON *json /*, response_callback*/)
+KS_DECLARE(ks_status_t) blade_request_create(blade_request_t **breqP, blade_handle_t *bh, const char *session_id, cJSON *json)
 {
 	blade_request_t *breq = NULL;
+	ks_pool_t *pool = NULL;
 
 	ks_assert(breqP);
-	ks_assert(pool);
+	ks_assert(bh);
 	ks_assert(session_id);
 	ks_assert(json);
 
+	pool = blade_handle_pool_get(bh);
+	ks_assert(pool);
+
 	breq = ks_pool_alloc(pool, sizeof(blade_request_t));
+	breq->handle = bh;
 	breq->pool = pool;
-	breq->refs = 1;
 	breq->session_id = ks_pstrdup(pool, session_id);
 	breq->message = json;
 	breq->message_id = cJSON_GetObjectCstr(json, "id");
-	//breq->response_callback = response_callback;
+
 	*breqP = breq;
 
 	return KS_STATUS_SUCCESS;
@@ -72,6 +76,51 @@ KS_DECLARE(ks_status_t) blade_request_destroy(blade_request_t **breqP)
 }
 
 
+KS_DECLARE(ks_status_t) blade_response_create(blade_response_t **bresP, blade_handle_t *bh, const char *session_id, blade_request_t *breq, cJSON *json)
+{
+	blade_response_t *bres = NULL;
+	ks_pool_t *pool = NULL;
+
+	ks_assert(bresP);
+	ks_assert(bh);
+	ks_assert(session_id);
+	ks_assert(breq);
+	ks_assert(json);
+
+	pool = blade_handle_pool_get(bh);
+	ks_assert(pool);
+
+	bres = ks_pool_alloc(pool, sizeof(blade_response_t));
+	bres->handle = bh;
+	bres->pool = pool;
+	bres->session_id = ks_pstrdup(pool, session_id);
+	bres->request = breq;
+	bres->message = json;
+
+	*bresP = bres;
+
+	return KS_STATUS_SUCCESS;
+}
+
+KS_DECLARE(ks_status_t) blade_response_destroy(blade_response_t **bresP)
+{
+	blade_response_t *bres = NULL;
+
+	ks_assert(bresP);
+	ks_assert(*bresP);
+
+	bres = *bresP;
+
+	ks_pool_free(bres->pool, (void **)&bres->session_id);
+	blade_request_destroy(&bres->request);
+	cJSON_Delete(bres->message);
+
+	ks_pool_free(bres->pool, bresP);
+
+	return KS_STATUS_SUCCESS;
+}
+
+
 /* For Emacs:
  * Local Variables:
  * mode:c

libs/libblade/src/blade_session.c

@@ -485,11 +485,20 @@ ks_status_t blade_session_state_on_ready(blade_session_t *bs)
 
 KS_DECLARE(ks_status_t) blade_session_send(blade_session_t *bs, cJSON *json)
 {
+	blade_request_t *request = NULL;
+	const char *method = NULL;
+
 	ks_assert(bs);
 	ks_assert(json);
 
-	// @todo check json for "method", if this is an outgoing request then build up the data for a response to lookup the message id and get back to the request
+	method = cJSON_GetObjectCstr(json, "method");
-	// this can reuse blade_request_t so that when the blade_response_t is passed up the blade_request_t within it is familiar from inbound requests
+	if (method) {
+		blade_request_create(&request, bs->handle, bs->id, json);
+		ks_assert(request);
+
+		// @todo set request TTL and figure out when requests are checked for expiration (separate thread in the handle?)
+		blade_handle_requests_add(request);
+	}
 
 	if (list_empty(&bs->connections)) {
 		// @todo cache the blade_request_t here if it exists to gaurentee it's cached before a response could be received
@@ -508,6 +517,11 @@ KS_DECLARE(ks_status_t) blade_session_send(blade_session_t *bs, cJSON *json)
 ks_status_t blade_session_process(blade_session_t *bs, cJSON *json)
 {
 	ks_status_t ret = KS_STATUS_SUCCESS;
+	blade_request_t *breq = NULL;
+	blade_response_t *bres = NULL;
+	const char *jsonrpc = NULL;
+	const char *id = NULL;
+	const char *method = NULL;
 
 	ks_assert(bs);
 	ks_assert(json);
@@ -515,6 +529,50 @@ ks_status_t blade_session_process(blade_session_t *bs, cJSON *json)
 	ks_log(KS_LOG_DEBUG, "Session (%s) processing\n", bs->id);
 
 	// @todo teardown the message, convert into a blade_request_t or blade_response_t
+	// @todo validate the jsonrpc fields
+
+	jsonrpc = cJSON_GetObjectCstr(json, "jsonrpc");
+	if (!jsonrpc || strcmp(jsonrpc, "2.0")) {
+        ks_log(KS_LOG_DEBUG, "Received message is not the expected protocol\n");
+		// @todo send error response, code = -32600 (invalid request)
+		// @todo hangup session entirely?
+		return KS_STATUS_FAIL;
+	}
+
+	id = cJSON_GetObjectCstr(json, "id");
+	if (!id) {
+        ks_log(KS_LOG_DEBUG, "Received message is missing 'id'\n");
+		// @todo send error response, code = -32600 (invalid request)
+		// @todo hangup session entirely?
+		return KS_STATUS_FAIL;
+	}
+
+	method = cJSON_GetObjectCstr(json, "method");
+	if (method) {
+		// @todo use method to find RPC callbacks
+
+		blade_request_create(&breq, bs->handle, bs->id, json);
+		ks_assert(breq);
+
+		// @todo call request callback handler
+	} else {
+		breq = blade_handle_requests_get(bs->handle, id);
+		if (!breq) {
+			// @todo hangup session entirely?
+			return KS_STATUS_FAIL;
+		}
+		blade_handle_requests_remove(breq);
+
+		method = cJSON_GetObjectCstr(breq->message, "method");
+		ks_assert(method);
+
+		// @todo use method to find RPC callbacks
+
+		blade_response_create(&bres, bs->handle, bs->id, breq, json);
+		ks_assert(bres);
+
+		// @todo call response callback handler
+	}
 
 	return ret;
 }

libs/libblade/src/blade_stack.c

@@ -482,6 +482,55 @@ KS_DECLARE(ks_status_t) blade_handle_sessions_remove(blade_session_t *bs)
 }
 
 
+KS_DECLARE(blade_request_t *) blade_handle_requests_get(blade_handle_t *bh, const char *mid)
+{
+	blade_request_t *br = NULL;
+
+	ks_assert(bh);
+	ks_assert(mid);
+
+	ks_hash_read_lock(bh->requests);
+	br = ks_hash_search(bh->requests, (void *)mid, KS_UNLOCKED);
+	ks_hash_read_unlock(bh->requests);
+
+	return br;
+}
+
+KS_DECLARE(ks_status_t) blade_handle_requests_add(blade_request_t *br)
+{
+	ks_status_t ret = KS_STATUS_SUCCESS;
+	blade_handle_t *bh = NULL;
+
+	ks_assert(br);
+
+	bh = br->handle;
+	ks_assert(bh);
+
+	ks_hash_write_lock(bh->requests);
+	ret = ks_hash_insert(bh->requests, (void *)br->message_id, br);
+	ks_hash_write_unlock(bh->requests);
+
+	return ret;
+}
+
+KS_DECLARE(ks_status_t) blade_handle_requests_remove(blade_request_t *br)
+{
+	ks_status_t ret = KS_STATUS_SUCCESS;
+	blade_handle_t *bh = NULL;
+
+	ks_assert(br);
+
+	bh = br->handle;
+	ks_assert(bh);
+
+	ks_hash_write_lock(bh->requests);
+	if (ks_hash_remove(bh->requests, (void *)br->message_id) == NULL) ret = KS_STATUS_FAIL;
+	ks_hash_write_unlock(bh->requests);
+
+	return ret;
+}
+
+
 
 KS_DECLARE(ks_bool_t) blade_handle_datastore_available(blade_handle_t *bh)
 {

libs/libblade/src/include/blade_protocol.h

@@ -36,8 +36,10 @@
 #include <blade.h>
 
 KS_BEGIN_EXTERN_C
-KS_DECLARE(ks_status_t) blade_request_create(blade_request_t **breqP, ks_pool_t *pool, const char *session_id, cJSON *json /*, response_callback*/);
+KS_DECLARE(ks_status_t) blade_request_create(blade_request_t **breqP, blade_handle_t *bh, const char *session_id, cJSON *json);
 KS_DECLARE(ks_status_t) blade_request_destroy(blade_request_t **breqP);
+KS_DECLARE(ks_status_t) blade_response_create(blade_response_t **bresP, blade_handle_t *bh, const char *session_id, blade_request_t *breq, cJSON *json);
+KS_DECLARE(ks_status_t) blade_response_destroy(blade_response_t **bresP);
 KS_END_EXTERN_C
 
 #endif

libs/libblade/src/include/blade_stack.h

@@ -60,6 +60,10 @@ KS_DECLARE(blade_session_t *) blade_handle_sessions_get(blade_handle_t *bh, cons
 KS_DECLARE(ks_status_t) blade_handle_sessions_add(blade_session_t *bs);
 KS_DECLARE(ks_status_t) blade_handle_sessions_remove(blade_session_t *bs);
 
+KS_DECLARE(blade_request_t *) blade_handle_requests_get(blade_handle_t *bh, const char *mid);
+KS_DECLARE(ks_status_t) blade_handle_requests_add(blade_request_t *br);
+KS_DECLARE(ks_status_t) blade_handle_requests_remove(blade_request_t *br);
+
 KS_DECLARE(ks_bool_t) blade_handle_datastore_available(blade_handle_t *bh);
 KS_DECLARE(ks_status_t) blade_handle_datastore_store(blade_handle_t *bh, const void *key, int32_t key_length, const void *data, int64_t data_length);
 KS_DECLARE(ks_status_t) blade_handle_datastore_fetch(blade_handle_t *bh,

libs/libblade/src/include/blade_types.h

@@ -141,8 +141,8 @@ struct blade_transport_callbacks_s {
 
 
 struct blade_request_s {
+	blade_handle_t *handle;
 	ks_pool_t *pool;
-	uint32_t refs;
 	const char *session_id;
 
 	cJSON *message;
@@ -152,8 +152,8 @@ struct blade_request_s {
 };
 
 struct blade_response_s {
+	blade_handle_t *handle;
 	ks_pool_t *pool;
-	uint32_t refs;
 	const char *session_id;
 	blade_request_t *request;