refactor: made jsonrpc an independent library

lib/jsonrpc/error.c

@@ -0,0 +1,27 @@
+#include "jsonrpc/error.h"
+
+json_t *
+jsonrpc_error(
+    int code,
+    char const * message)
+{
+    json_t * error = json_object();
+    json_object_set_new(error, "code", json_integer(code));
+    json_object_set_new(error, "message", json_string(message));
+
+    return error;
+}
+
+void
+jsonrpc_propate_error(
+    jsonrpc_proxy_finished_fn * finised,
+    void * user_data,
+    int code,
+    char const * message)
+{
+    json_t * error = jsonrpc_error(code, message);
+    finised(user_data, NULL, error);
+
+    json_decref(error);
+}
+

lib/jsonrpc/error.h

@@ -0,0 +1,29 @@
+#ifndef JSONRPC_ERROR_H
+#define JSONRPC_ERROR_H
+
+#include <jansson.h>
+#include "jsonrpc/proxy.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern json_t *
+jsonrpc_error(
+    int code,
+    char const * message);
+
+extern void
+jsonrpc_propate_error(
+    jsonrpc_proxy_finished_fn * finised,
+    void * user_data,
+    int code,
+    char const * message);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

lib/jsonrpc/method.c

@@ -0,0 +1,27 @@
+#include "jsonrpc/method.h"
+#include <stdlib.h>
+#include <string.h>
+
+struct jsonrpc_method * jsonrpc_method_create(
+    char const * method_name,
+    jsonrpc_method_invoke_fn * invoke,
+    void * user_data)
+{
+    struct jsonrpc_method * method = malloc(sizeof(struct jsonrpc_method));
+    if (NULL != method)
+    {
+        method->next = NULL;
+        method->name = strdup(method_name);
+        method->invoke = invoke;
+        method->user_data = user_data;
+    }
+
+    return method;
+}
+
+void jsonrpc_method_dispose(
+    struct jsonrpc_method * method)
+{
+    free(method->name);
+    free(method);
+}

lib/jsonrpc/proxy.c

@@ -0,0 +1,195 @@
+#include "jsonrpc/proxy.h"
+#include "jsonrpc/response.h"
+#include "jsonrpc/error.h"
+#include "jsonrpc/status.h"
+
+#include <string.h>
+
+static void jsonrpc_proxy_timeout(
+    struct wf_impl_timer * timer)
+{
+    struct jsonrpc_proxy * proxy = timer->user_data;
+
+    if (proxy->request.is_pending)
+    {
+        jsonrpc_proxy_finished_fn * finished = proxy->request.finished;
+        void * user_data = proxy->request.user_data;
+
+        proxy->request.is_pending = false;
+        proxy->request.id = 0;
+        proxy->request.user_data = NULL;
+        proxy->request.finished = NULL;
+        wf_impl_timer_cancel(&proxy->request.timer);
+
+        jsonrpc_propate_error(finished, user_data, JSONRPC_BAD_TIMEOUT, "Timeout");
+    }
+}
+
+static json_t * jsonrpc_request_create(
+	char const * method,
+	int id,
+	char const * param_info,
+	va_list args)
+{
+	json_t * request = json_object();
+	json_object_set_new(request, "method", json_string(method));
+	json_t * params = json_array();
+	
+	for (char const * param_type = param_info; '\0' != *param_type; param_type++)
+	{
+		switch(*param_type)
+		{
+			case 's':
+			{
+				char const * const value = va_arg(args, char const *);
+				json_array_append_new(params, json_string(value));
+			}
+			break;
+			case 'i':
+			{
+				int const value = va_arg(args, int);
+				json_array_append_new(params, json_integer(value));
+			}
+			break;
+			default:
+			fprintf(stderr, "fatal: unknown param_type '%c'\n", *param_type);
+            json_decref(params);
+            json_decref(request);
+            return NULL;
+		}
+	}
+	
+
+	json_object_set_new(request, "params", params);
+	if (0 != id)
+	{
+		json_object_set_new(request, "id", json_integer(id));
+	}
+	
+	return request;
+}
+
+void jsonrpc_proxy_init(
+    struct jsonrpc_proxy * proxy,
+    struct wf_impl_timeout_manager * timeout_manager,
+    int timeout,
+    jsonrpc_send_fn * send,
+    void * user_data)
+{
+    proxy->send = send;
+    proxy->timeout = timeout;
+    proxy->user_data = user_data;
+    proxy->request.is_pending = false;
+    
+    wf_impl_timer_init(&proxy->request.timer, timeout_manager);
+}
+
+void jsonrpc_proxy_cleanup(
+    struct jsonrpc_proxy * proxy)
+{
+    if (proxy->request.is_pending)
+    {
+        void * user_data = proxy->request.user_data;
+        jsonrpc_proxy_finished_fn * finished = proxy->request.finished;
+
+        proxy->request.is_pending = false;
+        proxy->request.finished = NULL;
+        proxy->request.user_data = NULL;
+        proxy->request.id = 0;
+        wf_impl_timer_cancel(&proxy->request.timer);
+
+        jsonrpc_propate_error(finished, user_data, JSONRPC_BAD, "Bad");
+    }
+
+    wf_impl_timer_cleanup(&proxy->request.timer);
+}
+
+void jsonrpc_proxy_invoke(
+	struct jsonrpc_proxy * proxy,
+	jsonrpc_proxy_finished_fn * finished,
+	void * user_data,
+	char const * method_name,
+	char const * param_info,
+	...
+)
+{
+    if (!proxy->request.is_pending)
+    {
+        proxy->request.is_pending = true;
+        proxy->request.finished = finished;
+        proxy->request.user_data = user_data;
+        proxy->request.id = 42;
+        wf_impl_timer_start(&proxy->request.timer, wf_impl_timepoint_in_msec(proxy->timeout), 
+                &jsonrpc_proxy_timeout, proxy);
+        
+        va_list args;
+        va_start(args, param_info);
+        json_t * request = jsonrpc_request_create(method_name, proxy->request.id, param_info, args);
+        va_end(args);
+
+        bool const is_send = ((NULL != request) && (proxy->send(request, proxy->user_data)));
+        if (!is_send)
+        {
+            proxy->request.is_pending = false;
+            proxy->request.finished = NULL;
+            proxy->request.user_data = NULL;
+            proxy->request.id = 0;
+            wf_impl_timer_cancel(&proxy->request.timer);
+
+            jsonrpc_propate_error(finished, user_data, JSONRPC_BAD, "Bad");
+        }
+
+        if (NULL != request)
+        {
+            json_decref(request);
+        }
+    }
+    else
+    {
+        jsonrpc_propate_error(finished, user_data, JSONRPC_BAD_BUSY, "Busy");
+    }
+}
+
+extern void jsonrpc_proxy_notify(
+	struct jsonrpc_proxy * proxy,
+	char const * method_name,
+	char const * param_info,
+	...
+)
+{            
+    va_list args;
+    va_start(args, param_info);
+    json_t * request = jsonrpc_request_create(method_name, 0, param_info, args);
+    va_end(args);
+    if (NULL != request)
+    {
+        proxy->send(request, proxy->user_data);
+        json_decref(request);
+    }
+}
+
+
+void jsonrpc_proxy_onresult(
+    struct jsonrpc_proxy * proxy,
+    json_t * message)
+{
+	struct jsonrpc_response response;
+	jsonrpc_response_init(&response, message);
+
+    if ((proxy->request.is_pending) && (response.id == proxy->request.id))
+    {
+        jsonrpc_proxy_finished_fn * finished = proxy->request.finished;
+        void * user_data = proxy->request.user_data;
+
+        proxy->request.is_pending = false;
+        proxy->request.id = 0;
+        proxy->request.user_data = NULL;
+        proxy->request.finished = NULL;
+        wf_impl_timer_cancel(&proxy->request.timer);
+
+        finished(user_data, response.result, response.error);
+    }
+
+    jsonrpc_response_cleanup(&response);
+}
+

lib/jsonrpc/request.c

@@ -0,0 +1,82 @@
+#include "jsonrpc/request.h"
+#include "webfuse/core/status_intern.h"
+#include <stdlib.h>
+
+struct jsonrpc_request
+{
+    int id;
+    jsonrpc_send_fn * send;
+    void * user_data;
+};
+
+bool jsonrpc_is_request(
+    json_t * message)
+{
+    json_t * id = json_object_get(message, "id");
+    json_t * method = json_object_get(message, "method");
+    json_t * params = json_object_get(message, "params");
+
+    return (json_is_integer(id) && json_is_string(method) &&
+            (json_is_array(params) || json_is_object(params)));
+}
+
+
+struct jsonrpc_request * jsonrpc_request_create(
+    int id,
+    jsonrpc_send_fn * send,
+    void * user_data)
+{
+    struct jsonrpc_request * request = malloc(sizeof(struct jsonrpc_request));
+    if (NULL != request)
+    {
+        request->id = id;
+        request->send = send;
+        request->user_data = user_data;
+    }
+
+    return request;
+}
+
+void jsonrpc_request_dispose(
+    struct jsonrpc_request * request)
+{
+    free(request);
+}
+
+void * jsonrpc_request_get_userdata(
+    struct jsonrpc_request * request)
+{
+    return request->user_data;
+}
+
+
+void jsonrpc_respond(
+    struct jsonrpc_request * request,
+    json_t * result)
+{
+    json_t * response = json_object();
+    json_object_set_new(response, "result", result);
+    json_object_set_new(response, "id", json_integer(request->id));
+
+    request->send(response, request->user_data);
+    json_decref(response);
+    jsonrpc_request_dispose(request);
+}
+
+void jsonrpc_respond_error(
+    struct jsonrpc_request * request,
+    wf_status status)
+{
+    json_t * err = json_object();
+    json_object_set_new(err, "code", json_integer(status));
+    json_object_set_new(err, "message", json_string(wf_status_tostring(status)));
+
+    json_t * response = json_object();
+    json_object_set_new(response, "error", err);
+    json_object_set_new(response, "id", json_integer(request->id));
+
+    request->send(response, request->user_data);
+    json_decref(response);
+    jsonrpc_request_dispose(request);
+}
+

lib/jsonrpc/response.c

@@ -0,0 +1,65 @@
+#include "jsonrpc/response.h"
+#include "jsonrpc/error.h"
+#include "jsonrpc/status.h"
+
+extern bool jsonrpc_is_response(
+    json_t * message)
+{
+	json_t * id = json_object_get(message, "id");
+	json_t * err = json_object_get(message, "error");
+	json_t * result = json_object_get(message, "result");
+
+	return (json_is_integer(id) && 
+		(json_is_object(err) ||  (NULL != result)));
+}
+
+
+void jsonrpc_response_init(
+	struct jsonrpc_response * result,
+	json_t * response)
+{
+	result->id = -1;
+	result->result = NULL;
+	result->error = NULL;
+
+	json_t * id_holder = json_object_get(response, "id");
+	if ((NULL == id_holder) || (!json_is_integer(id_holder)))
+	{
+		result->error = jsonrpc_error(JSONRPC_BAD_FORMAT, "invalid format: missing id");
+		return;
+	}
+	
+	result->id = json_integer_value(id_holder);
+	result->result = json_object_get(response, "result");
+	if (NULL != result->result)
+	{
+		json_incref(result->result);
+	}
+	else
+	{
+		json_t * error = json_object_get(response, "error");
+		if ((json_is_object(error)) && (json_is_integer(json_object_get(error, "code"))))
+		{
+			result->error = error;
+			json_incref(result->error);
+		}
+		else
+		{
+			result->error = jsonrpc_error(JSONRPC_BAD_FORMAT, "invalid format: invalid error object");
+		}
+	}
+}
+
+void jsonrpc_response_cleanup(
+	struct jsonrpc_response * response)
+{
+    if (NULL != response->result)
+    {
+        json_decref(response->result);
+    }
+
+    if (NULL != response->error)
+    {
+        json_decref(response->error);
+    }
+}

lib/jsonrpc/server.c

@@ -0,0 +1,95 @@
+#include "jsonrpc/server.h"
+#include "jsonrpc/method.h"
+#include "jsonrpc/request.h"
+#include "webfuse/core/util.h"
+
+#include <string.h>
+
+void jsonrpc_server_init(
+    struct jsonrpc_server * server)
+{
+    server->methods = NULL;
+}
+
+void jsonrpc_server_cleanup(
+    struct jsonrpc_server * server)
+{
+    struct jsonrpc_method * current = server->methods;
+    while (NULL != current)
+    {
+        struct jsonrpc_method * next = current->next;
+        jsonrpc_method_dispose(current);
+        current = next;
+    }
+    server->methods = NULL;
+}
+
+void jsonrpc_server_add(
+    struct jsonrpc_server * server,
+    char const * method_name,
+    jsonrpc_method_invoke_fn * invoke,
+    void * user_data)
+{
+    struct jsonrpc_method * method = jsonrpc_method_create(method_name, invoke, user_data);
+    method->next = server->methods;
+    server->methods = method;
+}
+
+static void jsonrpc_server_invalid_method_invoke(
+    struct jsonrpc_request * request,
+    char const * WF_UNUSED_PARAM(method_name),
+    json_t * WF_UNUSED_PARAM(params),
+    void * WF_UNUSED_PARAM(user_data))
+{
+    jsonrpc_respond_error(request, WF_BAD_NOTIMPLEMENTED);
+}
+
+static struct jsonrpc_method const jsonrpc_server_invalid_method = 
+{
+    .next = NULL,
+    .name = "<invalid>",
+    .invoke = &jsonrpc_server_invalid_method_invoke,
+    .user_data = NULL    
+};
+
+static struct jsonrpc_method const * jsonrpc_server_get_method(
+    struct jsonrpc_server * server,
+    char const * method_name)
+{
+    struct jsonrpc_method const * current = server->methods;
+    while (NULL != current) 
+    {
+        if (0 == strcmp(method_name, current->name))
+        {
+            return current;
+        }
+
+        current = current->next;
+    }
+
+    return &jsonrpc_server_invalid_method;
+}
+
+void jsonrpc_server_process(
+    struct jsonrpc_server * server,
+    json_t * request_data,
+    jsonrpc_send_fn * send,
+    void * user_data)
+{
+    json_t * method_holder = json_object_get(request_data, "method");
+    json_t * params = json_object_get(request_data, "params");
+    json_t * id_holder = json_object_get(request_data, "id");
+
+    if (json_is_string(method_holder) &&
+        (json_is_array(params) || (json_is_object(params))) &&
+        json_is_integer(id_holder))
+    {
+        char const * method_name = json_string_value(method_holder);
+        int id = json_integer_value(id_holder);
+        struct jsonrpc_request * request = jsonrpc_request_create(id, send, user_data);
+        struct jsonrpc_method const * method = jsonrpc_server_get_method(server, method_name);
+
+        method->invoke(request, method_name, params, method->user_data);
+    }
+}
+