Archives/falk-werner_webfuse-provider
1
0
Fork 0
mirror of https://github.com/falk-werner/webfuse-provider synced 2024-10-27 20:44:10 +00:00
Code Issues Releases Wiki Activity

removed unused code

Browse Source
This commit is contained in:
Falk Werner 2020-06-21 17:31:42 +02:00
parent b5c87edcf9
commit 7568c15138
9 changed files with 0 additions and 567 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
lib/webfuse_provider/impl/jsonrpc/method.c
View File

@ -1,24 +0,0 @@
#include "webfuse_provider/impl/jsonrpc/method.h"
#include <stdlib.h>
#include <string.h>
struct wfp_jsonrpc_method * wfp_jsonrpc_method_create(
char const * method_name,
wfp_jsonrpc_method_invoke_fn * invoke,
void * user_data)
{
struct wfp_jsonrpc_method * method = malloc(sizeof(struct wfp_jsonrpc_method));
method->next = NULL;
method->name = strdup(method_name);
method->invoke = invoke;
method->user_data = user_data;
return method;
}
void wfp_jsonrpc_method_dispose(
struct wfp_jsonrpc_method * method)
{
free(method->name);
free(method);
}

34
lib/webfuse_provider/impl/jsonrpc/method.h
View File

@ -1,34 +0,0 @@
#ifndef WFP_JSONRPC_METHOD_H
#define WFP_JSONRPC_METHOD_H
#include "webfuse_provider/impl/jsonrpc/method_invoke_fn.h"
#ifdef __cplusplus
extern "C"
{
#endif
struct wfp_jsonrpc_method
{
struct wfp_jsonrpc_method * next;
char * name;
wfp_jsonrpc_method_invoke_fn * invoke;
void * user_data;
};
extern struct wfp_jsonrpc_method *
wfp_jsonrpc_method_create(
char const * method_name,
wfp_jsonrpc_method_invoke_fn * invoke,
void * user_data);
extern void
wfp_jsonrpc_method_dispose(
struct wfp_jsonrpc_method * method);
#ifdef __cplusplus
}
#endif
#endif

24
lib/webfuse_provider/impl/jsonrpc/method_invoke_fn.h
View File

@ -1,24 +0,0 @@
#ifndef WFP_JSONRPC_METHOD_INVOKE_FN_H
#define WFP_JSONRPC_METHOD_INVOKE_FN_H
#include <jansson.h>
#ifdef __cplusplus
extern "C"
{
#endif
struct wfp_jsonrpc_request;
typedef void wfp_jsonrpc_method_invoke_fn(
struct wfp_jsonrpc_request * request,
char const * method_name,
json_t * params,
void * user_data);
#ifdef __cplusplus
}
#endif
#endif

128
lib/webfuse_provider/impl/jsonrpc/server.c
View File

@ -1,128 +0,0 @@
#include "webfuse_provider/impl/jsonrpc/server.h"
#include "webfuse_provider/impl/jsonrpc/method.h"
#include "webfuse_provider/impl/jsonrpc/request.h"
#include "webfuse_provider/status.h"
#include "webfuse_provider/impl/util.h"
#include <stdlib.h>
#include <string.h>
struct wfp_jsonrpc_server
{
struct wfp_jsonrpc_method * methods;
};
static void
wfp_jsonrpc_server_init(
struct wfp_jsonrpc_server * server);
static void
wfp_jsonrpc_server_cleanup(
struct wfp_jsonrpc_server * server);
struct wfp_jsonrpc_server *
wfp_jsonrpc_server_create(void)
{
struct wfp_jsonrpc_server * server = malloc(sizeof(struct wfp_jsonrpc_server));
wfp_jsonrpc_server_init(server);
return server;
}
void
wfp_jsonrpc_server_dispose(
struct wfp_jsonrpc_server * server)
{
wfp_jsonrpc_server_cleanup(server);
free(server);
}
static void wfp_jsonrpc_server_init(
struct wfp_jsonrpc_server * server)
{
server->methods = NULL;
}
static void wfp_jsonrpc_server_cleanup(
struct wfp_jsonrpc_server * server)
{
struct wfp_jsonrpc_method * current = server->methods;
while (NULL != current)
{
struct wfp_jsonrpc_method * next = current->next;
wfp_jsonrpc_method_dispose(current);
current = next;
}
server->methods = NULL;
}
void wfp_jsonrpc_server_add(
struct wfp_jsonrpc_server * server,
char const * method_name,
wfp_jsonrpc_method_invoke_fn * invoke,
void * user_data)
{
struct wfp_jsonrpc_method * method = wfp_jsonrpc_method_create(method_name, invoke, user_data);
method->next = server->methods;
server->methods = method;
}
static void wfp_jsonrpc_server_invalid_method_invoke(
struct wfp_jsonrpc_request * request,
char const * WFP_UNUSED_PARAM(method_name),
json_t * WFP_UNUSED_PARAM(params),
void * WFP_UNUSED_PARAM(user_data))
{
wfp_jsonrpc_respond_error(request, WFP_BAD_NOTIMPLEMENTED, "not implemented");
}
static struct wfp_jsonrpc_method const wfp_jsonrpc_server_invalid_method =
{
.next = NULL,
.name = "<invalid>",
.invoke = &wfp_jsonrpc_server_invalid_method_invoke,
.user_data = NULL
};
static struct wfp_jsonrpc_method const *
wfp_jsonrpc_server_get_method(
struct wfp_jsonrpc_server * server,
char const * method_name)
{
struct wfp_jsonrpc_method const * current = server->methods;
while (NULL != current)
{
if (0 == strcmp(method_name, current->name))
{
return current;
}
current = current->next;
}
return &wfp_jsonrpc_server_invalid_method;
}
void wfp_jsonrpc_server_process(
struct wfp_jsonrpc_server * server,
json_t * request_data,
wfp_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 wfp_jsonrpc_request * request = wfp_jsonrpc_request_create(id, send, user_data);
struct wfp_jsonrpc_method const * method = wfp_jsonrpc_server_get_method(server, method_name);
method->invoke(request, method_name, params, method->user_data);
}
}

45
lib/webfuse_provider/impl/jsonrpc/server.h
View File

@ -1,45 +0,0 @@
#ifndef WFP_JSONRPC_SERVER_H
#define WFP_JSONRPC_SERVER_H
#ifndef __cplusplus
#include <stdarg.h>
#include <stdbool.h>
#else
#include <cstdarg>
#endif
#include <jansson.h>
#include "webfuse_provider/impl/jsonrpc/method_invoke_fn.h"
#include "webfuse_provider/impl/jsonrpc/send_fn.h"
#ifdef __cplusplus
extern "C"
{
#endif
struct wfp_jsonrpc_server;
extern struct wfp_jsonrpc_server *
wfp_jsonrpc_server_create(void);
extern void
wfp_jsonrpc_server_dispose(
struct wfp_jsonrpc_server * server);
extern void wfp_jsonrpc_server_add(
struct wfp_jsonrpc_server * server,
char const * method_name,
wfp_jsonrpc_method_invoke_fn * invoke,
void * user_data);
extern void wfp_jsonrpc_server_process(
struct wfp_jsonrpc_server * server,
json_t * request,
wfp_jsonrpc_send_fn * send,
void * user_data);
#ifdef __cplusplus
}
#endif
#endif

3
meson.build
View File

@ -30,8 +30,6 @@ webfuse_provider_static = static_library('webfuse_provider',
'lib/webfuse_provider/impl/timer/timer.c',
'lib/webfuse_provider/impl/jsonrpc/proxy.c',
'lib/webfuse_provider/impl/jsonrpc/proxy_variadic.c',
'lib/webfuse_provider/impl/jsonrpc/server.c',
'lib/webfuse_provider/impl/jsonrpc/method.c',
'lib/webfuse_provider/impl/jsonrpc/request.c',
'lib/webfuse_provider/impl/jsonrpc/response.c',
'lib/webfuse_provider/impl/jsonrpc/error.c',
@ -108,7 +106,6 @@ alltests = executable('alltests',
'test/webfuse_provider/tests/core/jsonrpc/test_request.cc',
'test/webfuse_provider/tests/core/jsonrpc/test_is_response.cc',
'test/webfuse_provider/tests/core/jsonrpc/test_response.cc',
'test/webfuse_provider/tests/core/jsonrpc/test_server.cc',
'test/webfuse_provider/tests/core/jsonrpc/test_proxy.cc',
'test/webfuse_provider/tests/core/jsonrpc/test_response_parser.cc',
'test/webfuse_provider/tests/core/timer/test_timepoint.cc',

50
test/webfuse_provider/mocks/lookup_matcher.hpp
View File

@ -1,50 +0,0 @@
#ifndef WFP_LOOKUP_MATCHER_HPP
#define WFP_LOOKUP_MATCHER_HPP
#include <gmock/gmock.h>
#include <jansson.h>
#include <cstring>
namespace webfuse_test
{
MATCHER_P2(Lookup, parent, name, "")
{
if (!json_is_array(arg))
{
*result_listener << "json array expected";
return false;
}
json_t * parent_ = json_array_get(arg, 1);
if (!json_is_integer(parent_))
{
*result_listener << "parent is expected to be an integer";
return false;
}
if (parent != json_integer_value(parent_))
{
*result_listener << "parent mismatch: expected " << parent
<< " but was " << json_integer_value(parent_);
return false;
}
json_t * name_ = json_array_get(arg, 2);
if (!json_is_string(name_))
{
*result_listener << "name is expected to be a string";
return false;
}
if (0 != strcmp(name, json_string_value(name_)))
{
*result_listener << "name mismatch: expected \"" << name
<< "\" but was \"" << json_string_value(name_) << "\"";
return false;
}
return true;
}
}
#endif

18
test/webfuse_provider/mocks/mock_invokation_handler.hpp
View File

@ -1,18 +0,0 @@
#ifndef WFP_MOCK_INVOKATION_HANDLER_HPP
#define WFP_MOCK_INVOKATION_HANDLER_HPP
#include "webfuse/utils/ws_server2.hpp"
#include <gtest/gtest.h>
namespace webfuse_test
{
class MockInvokationHander: public IIvokationHandler
{
public:
MOCK_METHOD2(Invoke, std::string(char const * method, json_t * params));
};
}
#endif

241
test/webfuse_provider/tests/core/jsonrpc/test_server.cc
View File

@ -1,241 +0,0 @@
#include <gtest/gtest.h>
#include "webfuse_provider/impl/jsonrpc/server.h"
#include "webfuse_provider/impl/jsonrpc/request.h"
#include "webfuse_provider/status.h"
namespace
{
struct Context
{
json_t * response;
bool is_called;
};
bool jsonrpc_send(
json_t * request,
void * user_data)
{
Context * context = reinterpret_cast<Context*>(user_data);
context->is_called = true;
context->response = request;
json_incref(request);
return true;
}
void sayHello(
struct wfp_jsonrpc_request * request,
char const * method_name,
json_t * params,
void * user_data)
{
(void) method_name;
(void) params;
(void) user_data;
json_t * result = json_string("Hello");
wfp_jsonrpc_respond(request, result);
}
}
TEST(wfp_jsonrpc_server, process_request)
{
struct wfp_jsonrpc_server * server = wfp_jsonrpc_server_create();
wfp_jsonrpc_server_add(server, "sayHello", &sayHello, nullptr);
Context context{nullptr, false};
void * user_data = reinterpret_cast<void*>(&context);
json_t * request = json_object();
json_object_set_new(request, "method", json_string("sayHello"));
json_object_set_new(request, "params", json_array());
json_object_set_new(request, "id", json_integer(23));
wfp_jsonrpc_server_process(server, request, &jsonrpc_send, user_data);
ASSERT_TRUE(context.is_called);
ASSERT_NE(nullptr, context.response);
ASSERT_TRUE(json_is_object(context.response));
json_t * id = json_object_get(context.response, "id");
ASSERT_TRUE(json_is_integer(id));
ASSERT_EQ(23, json_integer_value(id));
json_t * result = json_object_get(context.response, "result");
ASSERT_TRUE(json_is_string(result));
ASSERT_STREQ("Hello", json_string_value(result));
json_decref(context.response);
json_decref(request);
wfp_jsonrpc_server_dispose(server);
}
TEST(wfp_jsonrpc_server, process_request_with_oject_params)
{
struct wfp_jsonrpc_server * server = wfp_jsonrpc_server_create();
wfp_jsonrpc_server_add(server, "sayHello", &sayHello, nullptr);
Context context{nullptr, false};
void * user_data = reinterpret_cast<void*>(&context);
json_t * request = json_object();
json_object_set_new(request, "method", json_string("sayHello"));
json_object_set_new(request, "params", json_object());
json_object_set_new(request, "id", json_integer(23));
wfp_jsonrpc_server_process(server, request, &jsonrpc_send, user_data);
ASSERT_TRUE(context.is_called);
ASSERT_NE(nullptr, context.response);
ASSERT_TRUE(json_is_object(context.response));
json_t * id = json_object_get(context.response, "id");
ASSERT_TRUE(json_is_integer(id));
ASSERT_EQ(23, json_integer_value(id));
json_t * result = json_object_get(context.response, "result");
ASSERT_TRUE(json_is_string(result));
ASSERT_STREQ("Hello", json_string_value(result));
json_decref(context.response);
json_decref(request);
wfp_jsonrpc_server_dispose(server);
}
TEST(wfp_jsonrpc_server, invoke_unknown_method)
{
struct wfp_jsonrpc_server * server = wfp_jsonrpc_server_create();
wfp_jsonrpc_server_add(server, "sayHello", &sayHello, nullptr);
Context context{nullptr, false};
void * user_data = reinterpret_cast<void*>(&context);
json_t * request = json_object();
json_object_set_new(request, "method", json_string("greet"));
json_object_set_new(request, "params", json_array());
json_object_set_new(request, "id", json_integer(42));
wfp_jsonrpc_server_process(server, request, &jsonrpc_send, user_data);
ASSERT_TRUE(context.is_called);
ASSERT_NE(nullptr, context.response);
ASSERT_TRUE(json_is_object(context.response));
json_t * id = json_object_get(context.response, "id");
ASSERT_TRUE(json_is_integer(id));
ASSERT_EQ(42, json_integer_value(id));
json_t * err = json_object_get(context.response, "error");
ASSERT_TRUE(json_is_object(err));
json_t * err_code = json_object_get(err, "code");
ASSERT_TRUE(json_is_integer(err_code));
ASSERT_EQ(WFP_BAD_NOTIMPLEMENTED, json_integer_value(err_code));
json_t * err_message = json_object_get(err, "message");
ASSERT_TRUE(json_is_string(err_message));
json_decref(context.response);
json_decref(request);
wfp_jsonrpc_server_dispose(server);
}
TEST(wfp_jsonrpc_server, skip_invalid_request_missing_id)
{
struct wfp_jsonrpc_server * server = wfp_jsonrpc_server_create();
Context context{nullptr, false};
void * user_data = reinterpret_cast<void*>(&context);
json_t * request = json_object();
json_object_set_new(request, "method", json_string("sayHello"));
json_object_set_new(request, "params", json_array());
wfp_jsonrpc_server_process(server, request, &jsonrpc_send, user_data);
ASSERT_FALSE(context.is_called);
json_decref(request);
wfp_jsonrpc_server_dispose(server);
}
TEST(wfp_jsonrpc_server, skip_invalid_request_wrong_id_type)
{
struct wfp_jsonrpc_server * server = wfp_jsonrpc_server_create();
Context context{nullptr, false};
void * user_data = reinterpret_cast<void*>(&context);
json_t * request = json_object();
json_object_set_new(request, "method", json_string("sayHello"));
json_object_set_new(request, "params", json_array());
json_object_set_new(request, "id", json_string("42"));
wfp_jsonrpc_server_process(server, request, &jsonrpc_send, user_data);
ASSERT_FALSE(context.is_called);
json_decref(request);
wfp_jsonrpc_server_dispose(server);
}
TEST(wfp_jsonrpc_server, skip_invalid_request_missing_params)
{
struct wfp_jsonrpc_server * server = wfp_jsonrpc_server_create();
Context context{nullptr, false};
void * user_data = reinterpret_cast<void*>(&context);
json_t * request = json_object();
json_object_set_new(request, "method", json_string("sayHello"));
json_object_set_new(request, "id", json_integer(42));
wfp_jsonrpc_server_process(server, request, &jsonrpc_send, user_data);
ASSERT_FALSE(context.is_called);
json_decref(request);
wfp_jsonrpc_server_dispose(server);
}
TEST(wfp_jsonrpc_server, skip_invalid_request_wrong_params_type)
{
struct wfp_jsonrpc_server * server = wfp_jsonrpc_server_create();
Context context{nullptr, false};
void * user_data = reinterpret_cast<void*>(&context);
json_t * request = json_object();
json_object_set_new(request, "method", json_string("sayHello"));
json_object_set_new(request, "params", json_string("invalid"));
json_object_set_new(request, "id", json_integer(42));
wfp_jsonrpc_server_process(server, request, &jsonrpc_send, user_data);
ASSERT_FALSE(context.is_called);
json_decref(request);
wfp_jsonrpc_server_dispose(server);
}
TEST(wfp_jsonrpc_server, skip_invalid_request_missing_method)
{
struct wfp_jsonrpc_server * server = wfp_jsonrpc_server_create();
Context context{nullptr, false};
void * user_data = reinterpret_cast<void*>(&context);
json_t * request = json_object();
json_object_set_new(request, "params", json_array());
json_object_set_new(request, "id", json_integer(42));
wfp_jsonrpc_server_process(server, request, &jsonrpc_send, user_data);
ASSERT_FALSE(context.is_called);
json_decref(request);
wfp_jsonrpc_server_dispose(server);
}
TEST(wfp_jsonrpc_server, skip_invalid_request_wront_method_type)
{
struct wfp_jsonrpc_server * server = wfp_jsonrpc_server_create();
Context context{nullptr, false};
void * user_data = reinterpret_cast<void*>(&context);
json_t * request = json_object();
json_object_set_new(request, "method", json_integer(42));
json_object_set_new(request, "params", json_array());
json_object_set_new(request, "id", json_integer(42));
wfp_jsonrpc_server_process(server, request, &jsonrpc_send, user_data);
ASSERT_FALSE(context.is_called);
json_decref(request);
wfp_jsonrpc_server_dispose(server);
}